@lasso-ai/cli 2.1.3 → 2.1.5

package/dist/cli/backends.d.ts

@@ -33,6 +33,8 @@ export interface DetectedBackend {
     error?: string;
     fixInstructions?: string;
 }
+/** OpenCode-hosted free models are restricted to OpenCode's own product UI. */
+export declare function isOpenCodeHeadlessRestrictedModel(modelId: string): boolean;
 /**
  * Probe all supported local agents in parallel.
  * Fault-tolerant: a missing or broken CLI never rejects the whole list.

package/dist/cli/backends.js

@@ -16,6 +16,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LOCAL_MODEL_PREFIXES = void 0;
+exports.isOpenCodeHeadlessRestrictedModel = isOpenCodeHeadlessRestrictedModel;
 exports.detectBackends = detectBackends;
 exports.modelIdForBackend = modelIdForBackend;
 const node_child_process_1 = require("node:child_process");
@@ -43,6 +44,11 @@ async function probe(bin, args, timeout = 10000) {
 function stripAnsi(text) {
     return text.replace(/\u001b\[[0-9;]*m/g, "").replace(/\u001b\][^\u0007]*\u0007/g, "");
 }
+/** OpenCode-hosted free models are restricted to OpenCode's own product UI. */
+function isOpenCodeHeadlessRestrictedModel(modelId) {
+    const id = modelId.trim().toLowerCase();
+    return id === "opencode/big-pickle" || id.endsWith("-free") || id.includes("-free-");
+}
 function parseJson(stdout) {
     const start = stdout.indexOf("{");
     if (start < 0)
@@ -135,6 +141,7 @@ async function detectOpenCode() {
             .split("\n")
             .map((line) => line.trim())
             .filter((line) => /^[a-z0-9-]+\/[a-z0-9._-]+$/i.test(line))
+            .filter((line) => !isOpenCodeHeadlessRestrictedModel(line))
             .slice(0, 30);
         base.models = ids.map((full) => {
             const name = full.split("/")[1];
@@ -146,10 +153,7 @@ async function detectOpenCode() {
         });
     }
     if (base.models.length === 0) {
-        base.models = [
-            { id: "opencode:big-pickle", label: "Big Pickle", modelId: "opencode/big-pickle" },
-            { id: "opencode:deepseek-v4-flash", label: "DeepSeek V4 Flash", modelId: "opencode/deepseek-v4-flash" },
-        ];
+        base.models = [{ id: "opencode:claude-sonnet-4", label: "Claude Sonnet 4", modelId: "opencode/claude-sonnet-4" }];
     }
     return base;
 }

package/dist/cli/bridge.d.ts

@@ -145,7 +145,11 @@ export type BridgeMessage = {
         content: string;
     }>;
     taskId?: string;
+} | {
+    type: "page_context_response";
+    requestId: string;
     pageContext?: any;
+    error?: string;
 } | {
     type: "restore_snapshot";
     snapshotId: string;

package/dist/cli/bridge.js

@@ -22,6 +22,28 @@ const backends_1 = require("./backends");
 const local_runtime_1 = require("./local-runtime");
 exports.DEFAULT_BRIDGE_PORT = 3056;
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function cleanConversationReply(value) {
+    const text = typeof value === "string" ? value.trim() : "";
+    if (!text)
+        return "";
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed?.reply === "string")
+            return parsed.reply.trim();
+    }
+    catch {
+        const match = text.match(/"reply"\s*:\s*"((?:\\.|[^"\\])*)"/);
+        if (match) {
+            try {
+                return JSON.parse(`"${match[1]}"`).trim();
+            }
+            catch {
+                return match[1].replace(/\\n/g, "\n").replace(/\\"/g, '"').trim();
+            }
+        }
+    }
+    return text;
+}
 async function restartBridge(port = exports.DEFAULT_BRIDGE_PORT) {
     try {
         const response = await fetch(`http://127.0.0.1:${port}/__lasso/bridge/restart`, { method: "POST" });
@@ -143,6 +165,7 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
     // in this process), RuntimeClient for hosted models (via Lasso server).
     const taskFacades = new Map();
     const taskControllers = new Map();
+    const pendingBrowserContext = new Map();
     const correctiveAttempts = 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) => ({
@@ -167,6 +190,16 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
         }
         return undefined;
     }
+    function requestBrowserContext(action, taskId) {
+        return new Promise((resolve, reject) => {
+            if (!overlaySocket || overlaySocket.readyState !== overlaySocket.OPEN) {
+                reject(new Error("Live browser context is unavailable because the overlay is disconnected."));
+                return;
+            }
+            pendingBrowserContext.set(action.id, { resolve, reject });
+            overlaySocket.send(JSON.stringify({ type: "page_context_request", requestId: action.id, taskId, check: action.data || {} }));
+        });
+    }
     const cliCredentials = (0, auth_1.loadCredentials)();
     const resolvedLassoKey = cliCredentials?.apiKey ||
         (0, project_1.resolveLassoApiKey)(fileEnv) ||
@@ -271,55 +304,95 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             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...",
-                }));
+                // The command bar owns the neutral initial status; real runtime events
+                // replace it as soon as the agent has useful progress to report.
                 break;
-            case "tool_started":
-                socket.send(JSON.stringify({
-                    type: "agent_status",
-                    taskId,
-                    status: "working",
-                    message: `Running ${event.data.tool || event.data.actionType || "tool"}...`,
-                }));
+            case "agent_reasoning": {
+                // The model's actual reasoning summary — dynamic content only.
+                // Raw thoughts (when the provider exposes them) ride along as the
+                // step's detail line.
+                const summary = event.data?.summary;
+                if (summary) {
+                    const raw = event.data?.raw;
+                    const detail = typeof raw === "string" && raw.trim()
+                        ? raw.length > 800
+                            ? `${raw.slice(0, 800)}…`
+                            : raw
+                        : undefined;
+                    socket.send(JSON.stringify({
+                        type: "agent_status",
+                        taskId,
+                        status: "thinking",
+                        message: summary,
+                        detail,
+                    }));
+                }
                 break;
-            case "tool_completed":
-                socket.send(JSON.stringify({
-                    type: "agent_status",
-                    taskId,
-                    status: "working",
-                    message: "Completed tool",
-                }));
+            }
+            case "tool_started": {
+                const data = event.data || {};
+                // Model invocations are internal — the reasoning summaries bracket
+                // them; never surface "Running model" style steps.
+                if (data.actionType === "model")
+                    break;
+                const message = data.label || data.tool;
+                if (message) {
+                    socket.send(JSON.stringify({
+                        type: "agent_status",
+                        taskId,
+                        status: "working",
+                        message,
+                        detail: data.detail,
+                    }));
+                }
                 break;
-            case "phase_changed": {
-                const phase = event.data.phase;
-                socket.send(JSON.stringify({
-                    type: "agent_status",
-                    taskId,
-                    status: "working",
-                    message: `Phase: ${phase}`,
-                }));
+            }
+            case "tool_completed": {
+                const data = event.data || {};
+                if (data.actionType === "model")
+                    break;
+                // Success: the step auto-completes when the next event arrives.
+                // Only failures surface, with the real error.
+                if (data.success === false) {
+                    const message = data.label || data.tool;
+                    socket.send(JSON.stringify({
+                        type: "agent_status",
+                        taskId,
+                        status: "working",
+                        message: message ? `${message} didn't finish` : "A step didn't finish",
+                        detail: data.error || data.detail,
+                    }));
+                }
                 break;
             }
+            case "phase_changed":
+                // Internal phase names ("execute", "verify") are jargon — the
+                // reasoning and action labels already tell the real story.
+                break;
             case "verification_started":
-                socket.send(JSON.stringify({
-                    type: "agent_status",
-                    taskId,
-                    status: "review",
-                    message: "Verifying changes...",
-                }));
+                // No canned status line — the check names/results arrive with
+                // verification_completed and become the real progress copy.
                 break;
             case "verification_completed": {
-                const passed = event.data.success ?? event.data.passed;
+                const data = event.data || {};
+                const passed = data.success ?? data.passed;
+                const summaries = (data.observations || [])
+                    .map((o) => o?.summary)
+                    .filter(Boolean);
+                const errList = (data.errors || [])
+                    .map((e) => e?.message)
+                    .filter(Boolean);
+                const message = summaries.length
+                    ? summaries.join(" · ")
+                    : passed
+                        ? "Checks passed"
+                        : "Checks failed";
                 socket.send(JSON.stringify({
                     type: "agent_status",
                     taskId,
                     status: passed ? "working" : "error",
-                    message: passed ? "Verification passed" : "Verification failed",
+                    message,
+                    ...(errList.length ? { detail: errList.join("\n") } : {}),
                 }));
                 break;
             }
@@ -348,6 +421,28 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                 break;
         }
     }
+    async function sendLocalConversationReply(facade, session, taskId, socket) {
+        const finalSession = await facade.getSession(session.id);
+        const messages = finalSession.conversation || [];
+        const reply = [...messages]
+            .reverse()
+            .find((message) => message?.role === "assistant" && typeof message.content === "string")?.content?.trim();
+        if (reply) {
+            socket.send(JSON.stringify({
+                type: "assistant_message",
+                taskId,
+                message: reply,
+            }));
+        }
+        else {
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                taskId,
+                status: "stopped",
+                message: "Complete",
+            }));
+        }
+    }
     // The server rolled the workspace back before review, so the current files
     // are the originals: capture them for undo, then open the review panel.
     async function handleReviewReady(session, socket, taskId, instruction) {
@@ -368,37 +463,124 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                     return { filePath: change.filePath, content };
                 }));
                 (0, snapshot_1.createSnapshot)(cwd, taskId, instruction, changes.map((change) => change.filePath), undefined, session.id);
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "review",
+                    message: "Review changes",
+                    changes,
+                }));
             }
+            else {
+                await sendLocalConversationReply(facade, session, taskId, socket);
+            }
+        }
+        catch (error) {
             socket.send(JSON.stringify({
                 type: "agent_status",
                 taskId,
-                status: "review",
-                message: changes.length > 0 ? "Review changes" : "No file changes were produced",
-                changes,
+                status: "error",
+                message: error instanceof Error ? error.message : "Failed to load review changes",
             }));
         }
+    }
+    // Handler for edit/ask - uses runtime
+    async function handleHostedConversation(taskId, prompt, model, provider, messages, socket, signal) {
+        const requestController = new AbortController();
+        const abortRequest = () => requestController.abort();
+        signal.addEventListener("abort", abortRequest, { once: true });
+        const timeout = setTimeout(() => {
+            if (!signal.aborted)
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "error",
+                    message: "The conversation timed out. Please try again.",
+                }));
+            requestController.abort();
+        }, 30_000);
+        try {
+            const response = await fetch(`${serverUrl}/api/v1/agent/session`, {
+                method: "POST",
+                headers: {
+                    Accept: "text/event-stream",
+                    "Content-Type": "application/json",
+                    ...(resolvedLassoKey ? { Authorization: `Bearer ${resolvedLassoKey}` } : {}),
+                },
+                body: JSON.stringify({
+                    prompt,
+                    model: { id: model, provider },
+                    messages: Array.isArray(messages) ? messages : undefined,
+                }),
+                signal: requestController.signal,
+            });
+            if (!response.ok || !response.body) {
+                throw new Error(`Conversation request failed (${response.status})`);
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (!line.startsWith("data: "))
+                        continue;
+                    const payload = line.slice(6).trim();
+                    if (!payload || payload === "[DONE]")
+                        continue;
+                    const event = JSON.parse(payload);
+                    if (event.type === "error")
+                        throw new Error(event.error || "Conversation failed");
+                    if (event.type === "done") {
+                        socket.send(JSON.stringify({
+                            type: "assistant_message",
+                            taskId,
+                            message: cleanConversationReply(event.reply || event.summary),
+                        }));
+                    }
+                }
+            }
+        }
         catch (error) {
+            if (signal.aborted)
+                return;
             socket.send(JSON.stringify({
                 type: "agent_status",
                 taskId,
                 status: "error",
-                message: error instanceof Error ? error.message : "Failed to load review changes",
+                message: error instanceof Error ? error.message : "Conversation failed",
             }));
         }
+        finally {
+            clearTimeout(timeout);
+            signal.removeEventListener("abort", abortRequest);
+            taskControllers.delete(taskId);
+        }
     }
-    // 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);
+        const isLocalAgent = ["claude_code", "opencode", "codex_cli", "cursor"].includes(provider || "");
+        if (message.type === "ask" && !isLocalAgent) {
+            await handleHostedConversation(taskId, instruction, model, provider, messages, socket, controller.signal);
+            return;
+        }
+        // Do not echo the user's prompt into the thinking feed. The prompt is
+        // already visible in the conversation; use a neutral status while the
+        // runtime produces its first useful event.
         socket.send(JSON.stringify({
             type: "agent_status",
             taskId,
             status: "thinking",
-            message: "Starting...",
+            message: "Thinking…",
         }));
         try {
-            const isLocalAgent = ["claude_code", "opencode", "codex_cli", "cursor"].includes(provider || "");
             // Overlay model option ids are prefixed ("claude_code:sonnet") — the
             // agent CLIs need the unprefixed/normalized form.
             const backendModelId = (0, backends_1.modelIdForBackend)(model || "", provider || "");
@@ -441,7 +623,10 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             // already rolled back at that point).
             await facade.runSession(session.id, cwd, (event) => {
                 handleRuntimeEvent(event, socket, taskId, session, `Runtime session: ${instruction}`, true);
-            }, controller.signal, { providerApiKey: providerApiKeyFor(provider) });
+            }, controller.signal, {
+                providerApiKey: providerApiKeyFor(provider),
+                browserContextProvider: ((action) => requestBrowserContext(action, taskId)),
+            });
         }
         catch (error) {
             socket.send(JSON.stringify({
@@ -706,12 +891,9 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
         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...",
-        }));
+        // Greetings and conversational messages still go through the selected
+        // agent/model. The overlay only skips expensive page capture for them;
+        // there are no canned assistant responses in the bridge.
         try {
             const isLocalAgent = ["claude_code", "opencode", "codex_cli", "cursor"].includes(provider || "");
             const backendModelId = (0, backends_1.modelIdForBackend)(model || "", provider || "");
@@ -743,13 +925,6 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                 // Oneshot results are reviewed exactly like edit/ask: the workspace is
                 // rolled back and only approval re-applies the changes.
                 handleRuntimeEvent(event, socket, taskId, session, `Oneshot: ${instruction}`, true);
-                if (event.type === "agent_completed") {
-                    socket.send(JSON.stringify({
-                        type: "assistant_message",
-                        taskId,
-                        message: "Oneshot completed",
-                    }));
-                }
             }, controller.signal, { providerApiKey: providerApiKeyFor(provider) });
         }
         catch (error) {
@@ -990,6 +1165,11 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                             }));
                         }
                         break;
+                    case "runtime_error":
+                        // Overlay-side crash (e.g. ReferenceError) — surface it in the
+                        // daemon log so it's diagnosable.
+                        console.error("[overlay error]", msg.selectionId || "", msg.details || msg.message || msg);
+                        break;
                     default:
                         console.warn("Unknown bridge message type:", msg.type);
                 }

package/dist/cli/local-runtime.d.ts

@@ -16,6 +16,11 @@ export declare class LocalRuntime implements RuntimeFacade {
     getSession(sessionId: string): Promise<RuntimeSession>;
     runSession(sessionId: string, projectPath: string, onEvent: RuntimeEventHandler, signal?: AbortSignal, _opts?: {
         providerApiKey?: string;
+        browserContextProvider?: (action: {
+            id: string;
+            type: "browser_check";
+            data?: Record<string, unknown>;
+        }) => Promise<unknown>;
     }): Promise<void>;
     verifySession(sessionId: string, projectPath: string): Promise<SessionVerificationResult>;
     switchModel(sessionId: string, model: {

package/dist/cli/local-runtime.js

@@ -36,6 +36,7 @@ class LocalRuntime {
             status: "running",
             iteration: 0,
             userPrompt: input.userPrompt,
+            mode: input.mode || "task",
             conversation: [
                 { id: node_crypto_1.default.randomUUID(), role: "user", content: input.userPrompt, timestamp: now.getTime() },
             ],
@@ -99,6 +100,7 @@ class LocalRuntime {
             const outcome = await runner.run({
                 taskId: record.id,
                 userPrompt: record.userPrompt,
+                mode: record.mode,
                 project: {
                     projectId: record.project.projectId || "local",
                     framework: record.project.framework,

package/dist/cli/oneshot.js

@@ -116,31 +116,52 @@ async function runOneShotAgent(cwd, prompt, scope, config, signal, onProgress, o
                 return;
             switch (event.type) {
                 case "agent_started":
-                    onProgress("thinking", "Agent started", "Initializing runtime");
                     break;
-                case "agent_reasoning":
-                    const summary = event.data.summary || "Thinking...";
-                    thinkingSteps.push({ title: summary, durationMs: 0 });
-                    onProgress("thinking", summary);
+                case "agent_reasoning": {
+                    const summary = event.data?.summary;
+                    if (summary) {
+                        thinkingSteps.push({ title: summary, durationMs: 0 });
+                        onProgress("thinking", summary);
+                    }
                     break;
-                case "tool_started":
-                    const tool = event.data.tool || "tool";
-                    onProgress("working", `Running ${tool}...`);
+                }
+                case "tool_started": {
+                    const data = event.data || {};
+                    if (data.actionType === "model")
+                        break;
+                    const message = data.label || data.tool;
+                    if (message)
+                        onProgress("working", message);
                     break;
-                case "tool_completed":
-                    onProgress("working", "Tool completed");
+                }
+                case "tool_completed": {
+                    const data = event.data || {};
+                    if (data.actionType === "model")
+                        break;
+                    if (data.success === false) {
+                        const message = data.label || data.tool;
+                        onProgress("working", message ? `${message} didn't finish` : "A step didn't finish");
+                    }
                     break;
+                }
                 case "phase_changed":
-                    const phase = event.data.phase;
-                    onProgress("working", `Phase: ${phase}`);
                     break;
                 case "verification_started":
-                    onProgress("review", "Verifying changes...");
+                    // Real check names/results arrive with verification_completed.
                     break;
-                case "verification_completed":
-                    const passed = event.data.success ?? event.data.passed;
-                    onProgress(passed ? "working" : "error", passed ? "Verification passed" : "Verification failed");
+                case "verification_completed": {
+                    const data = event.data || {};
+                    const passed = data.success ?? data.passed;
+                    const summaries = (data.observations || [])
+                        .map((o) => o?.summary)
+                        .filter(Boolean);
+                    onProgress(passed ? "working" : "error", summaries.length
+                        ? summaries.join(" · ")
+                        : passed
+                            ? "Checks passed"
+                            : "Checks failed");
                     break;
+                }
                 case "waiting_for_user":
                     const question = event.data?.question || "Input required";
                     onPrompt({ question });

package/dist/cli/runtime-client.d.ts

@@ -11,6 +11,8 @@ import { type ToolCallRequest } from "../runtime/index.js";
 export type RuntimeProvider = "anthropic" | "openai" | "google" | "nvidia" | "ollama" | "claude_code" | "opencode" | "codex_cli" | "cursor";
 export interface RuntimeSessionInput {
     userPrompt: string;
+    /** Conversation-only requests must not enter the coding/tool workflow. */
+    mode?: "conversation" | "task";
     project: {
         projectId: string;
         framework?: string;
@@ -50,6 +52,11 @@ export interface RuntimeSessionInput {
         projectPath?: string;
     };
 }
+export type BrowserContextProvider = (action: {
+    id: string;
+    type: "browser_check";
+    data?: Record<string, unknown>;
+}) => Promise<unknown>;
 export interface RuntimeSession {
     id: string;
     phase: "understand" | "inspect" | "plan" | "execute" | "verify" | "recover" | "complete";
@@ -139,6 +146,7 @@ export interface RuntimeFacade {
     createSession(input: RuntimeSessionInput): Promise<RuntimeSession>;
     runSession(sessionId: string, projectPath: string, onEvent: RuntimeEventHandler, signal?: AbortSignal, opts?: {
         providerApiKey?: string;
+        browserContextProvider?: BrowserContextProvider;
     }): Promise<void>;
     getSession(sessionId: string): Promise<RuntimeSession>;
     verifySession(sessionId: string, projectPath: string): Promise<SessionVerificationResult>;
@@ -159,6 +167,7 @@ export type RuntimeEvent = {
     sessionId: string;
     data: {
         summary: string;
+        raw?: string;
     };
     timestamp: number;
 } | {
@@ -174,6 +183,7 @@ export type RuntimeEvent = {
     sessionId: string;
     data: {
         actionType: string;
+        label?: string;
     };
     timestamp: number;
 } | {
@@ -181,7 +191,9 @@ export type RuntimeEvent = {
     sessionId: string;
     data: {
         actionType: string;
+        label?: string;
         success: boolean;
+        error?: string;
     };
     timestamp: number;
 } | {
@@ -292,6 +304,7 @@ export declare class RuntimeClient {
      */
     runSession(sessionId: string, projectPath: string, onEvent: RuntimeEventHandler, signal?: AbortSignal, opts?: {
         providerApiKey?: string;
+        browserContextProvider?: BrowserContextProvider;
     }): Promise<void>;
     /** Execute a tool_call request locally against the real project. */
     private executeToolCallLocally;

package/dist/cli/runtime-client.js

@@ -86,7 +86,7 @@ class RuntimeClient {
         catch (error) {
             console.error("WorkspaceGuard capture failed:", error);
         }
-        const executor = new index_js_1.ActionExecutor(projectPath);
+        const executor = new index_js_1.ActionExecutor(projectPath, opts?.browserContextProvider);
         const verifier = new index_js_1.VerificationEngine(projectPath);
         const finalizeGuard = async () => {
             if (!guard)