@lasso-ai/cli 1.0.29 → 1.1.1

package/ARCHITECTURE.md

@@ -67,9 +67,11 @@ Three parties, all coordinating around one shared filesystem:
                                    └──────────────────────┘
 ```
 
-Everything except the coding agent call runs locally. Nothing is ever written to disk
-without an explicit accept from the user. The agent is the only party that ever leaves the
-machine, and only with the exact context the CLI assembled for it.
+Everything except the coding agent call runs locally. Edit proposals are never written to
+disk without an explicit accept from the user. The New Page workflow is a separate explicit
+write path: it creates only the file at the folder the user selected in the project
+explorer. The agent is the only party that ever leaves the machine, and only with the
+exact context the CLI assembled for it.
 
 ## 4. Browser layer (capture only)
 
@@ -85,6 +87,17 @@ Responsibilities, and _only_ these:
   edit quality even when the AI has the source.
 - Show the inline prompt box anchored to the selection (never a blocking `prompt()`).
 - Render the diff/accept/undo UI once the CLI streams a proposed change back.
+- Render concurrent Agent Tasks with In progress/Completed tabs and task-level review
+  actions; acceptance is the transition that completes an edit task.
+- Keep a stable component conversation identity so repeated prompts reuse conversation
+  and change history across DOM replacement during HMR.
+- Render the secondary toolbar, custom tooltips, and the New Page dialog with a lazy
+  project-folder tree. The tree is populated per-directory on expand; the CLI never
+  sends the whole project at once. Selecting a folder sets the write target, and a
+  new nested folder is created inline through its own bridge message.
+- Render task-scoped permission/input prompts and send explicit responses back over
+  the bridge. The prompt must re-enable pointer events on its panel, because the
+  overlay host disables them to keep the toolbar click-through.
 - **Never mutate the DOM.** All visual changes the user sees post-edit come from the
   framework's own HMR reload, not from this layer.
 
@@ -111,6 +124,17 @@ A Node process that wraps the user's existing dev server. Entry: `src/cli/index.
    on receipt.
 6. On accept: snapshot the file's prior content (for undo), then apply the diff.
 7. On undo: restore the snapshot, full stop — no re-generation needed, so retries are free.
+8. For New Page: answer `list_page_folders` one directory at a time so the overlay can
+   build its tree lazily, skipping dot-entries and build/vendor directories. Every
+   request resolves against the project root, so `..` and absolute paths are refused.
+   Create a file only after the user confirms, and refuse to overwrite. Nested folder
+   creation arrives separately as `create_page_folder` and never accepts a slash or a
+   dotted name.
+9. For local agents: keep child-process stdin attached to its task and forward explicit
+   overlay responses when the agent requests permission or input. Classify stderr
+   before prompting: a filesystem or transport failure is reported as an error with a
+   suggested fix, because Allow/Deny cannot resolve it. Only a genuine approval or
+   sign-in request becomes a prompt, and the text is cleaned of log prefixes first.
 
 ### 5.2 Source resolution strategies
 

package/CHANGELOG.md

@@ -9,6 +9,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Agent task workflow**: concurrent prompts now appear in In progress and
+  Completed tabs. Review-ready tasks expose a Review action, and accepted changes
+  move the task to Completed.
+- **Component conversation continuity**: prompts reuse the latest conversation and
+  change history for a stable component identity across repeated prompts and DOM
+  replacement during HMR.
+- **Interactive local-agent prompts**: Claude Code, Codex, and OpenCode run with
+  piped stdin. Permission or input requests can be answered from a task-scoped
+  overlay prompt with Allow, Deny, or custom text.
+- **Secondary overlay toolbar**: added a New Page workflow with a project-folder
+  explorer, filename/content form, path validation, and explicit file creation.
+- **Redesigned New Page dialog**: replaced the flat folder dropdown with a
+  VS Code-style lazy tree of the project. You type only a page name and pick a
+  folder; nested folders are created inline with a `+` button, folders load on
+  demand, a filter box narrows deep trees, and clicking a file reuses its name.
+  Selecting a folder no longer collapses it, and the starter file is generated
+  from the extension (`.tsx`, `.ts`, `.css`, `.json`, `.md`).
+- **Readable agent permission prompts**: the prompt no longer dumps raw local-agent
+  log lines. Filesystem failures such as `EACCES: permission denied` and
+  `Cause([Die([…])])` now surface as errors with a suggested fix, because
+  Allow/Deny can never resolve them. Only genuine approval and sign-in requests
+  open the Allow/Deny prompt.
+- **Clickable agent prompt**: the prompt panel opts back into pointer events, so
+  Allow, Deny, and custom options respond to clicks again; Enter submits typed
+  input and Escape sends Deny, matching the close button.
+- **Custom toolbar tooltips**: toolbar labels now use an accessible Lasso-styled
+  tooltip on hover and keyboard focus instead of browser-native title popovers.
+- **Filtered agent progress**: useful tool/progress events remain visible while
+  process IDs, startup messages, and heartbeat logs are hidden.
 - Open-source documentation: `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md`,
   `SECURITY.md`, `SUPPORT.md`, `LICENSE` (ISC), and this changelog.
 - **Lasso Host** (`src/cli/host/`) — a user-level local domain server + runtime
@@ -99,4 +128,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Notes
 
 - Version 0.1.0 was developed as an internal prototype. This changelog records
-  behavior from that point forward. The project uses the product name **Lasso**.
+  behavior from that point forward. The project uses the product name **Lasso**.

package/README.md

@@ -87,6 +87,17 @@ Turn on Lasso Mode and interact with your application normally.
 - Hover to see what will be selected
 - Select empty space to insert new UI
 
+### Overlay toolbars
+
+The overlay includes a primary editing toolbar and a compact secondary toolbar.
+The secondary toolbar's **New Page** action opens a project explorer. You type a page
+name and pick the folder it should live in — the tree loads lazily as you expand
+it, a filter box narrows deep trees, and the `+` button next to **Folder** creates
+a new nested folder inline. Clicking a file in the tree reuses its name so you only
+type the part that is missing. Starter content is generated from the extension, and
+Lasso never chooses a source folder for you or overwrites an existing file without
+confirmation.
+
 ### Source-aware editing
 
 Lasso doesn't stop at the DOM.
@@ -133,6 +144,20 @@ Accept ────────→ Write to source
 
 Accepted changes are written to the filesystem and your framework's normal development workflow takes over.
 
+### Agent tasks and review
+
+Multiple prompts can run concurrently from the **Agent Tasks** panel. Tasks are
+separated into **In progress** and **Completed** tabs. Edit tasks expose a Review
+action when a proposal is ready; accepting the diff applies the changes and moves
+the task to Completed. Conversation and change history are retained for the same
+component during the overlay session, including when the framework replaces its DOM
+node during HMR.
+
+Local CLI agents stream useful tool/progress events while they work. Infrastructure
+noise such as process IDs and heartbeat messages is hidden. If a local agent needs
+permission or input, Lasso presents a task-scoped prompt with Allow, Deny, or a
+custom response field.
+
 ### Bring your own agent
 
 Lasso's editing pipeline is agent-agnostic.
@@ -145,8 +170,8 @@ Use:
 
 Your selection and project context stay inside the Lasso pipeline while the actual coding agent can be swapped independently.
 
-When installed, Lasso automatically detects the `claude` and `codex` commands
-on your PATH and adds **Claude Code · Local** and **Codex · Local** to the
+When installed, Lasso automatically detects the `claude`, `codex`, and
+`opencode` commands on your PATH and adds the available local agents to the
 prompt model menu. Local agents run in read-only/planning mode and return a
 reviewable proposal; Lasso remains the only process that writes accepted
 changes to your source files.
@@ -336,6 +361,14 @@ Undo   → restore the previous snapshot
 
 That's it.
 
+### Create a page manually
+
+Use **New Page** in the secondary toolbar to open the project explorer. Type a page
+name, expand the tree to pick the target folder, and select **Create page**. Use the
+`+` button beside **Folder** to create a nested folder without leaving the dialog,
+or the filter box to narrow a large tree. The bridge validates that the folder stays
+inside the project and refuses to overwrite an existing file.
+
 ---
 
 ## Agent configuration
@@ -462,6 +495,9 @@ The CLI:
 8. Shows you the diff
 9. Writes only after you accept
 
+The separate New Page workflow is also explicit: it writes only after you pick
+a folder in the project explorer, type a name, and choose **Create page**.
+
 The goal is simple:
 
 **Your development environment stays yours.**
@@ -504,6 +540,11 @@ The core visual editing pipeline is being built around:
 - Explicit accept/reject
 - Undo
 - Pluggable coding agents
+- Concurrent agent tasks with review/completed states
+- Component-scoped conversation and change history
+- Manual page creation with project-folder selection
+- Interactive permission/input prompts for local agents
+- Custom toolbar tooltips and filtered agent progress
 
 Expect breaking changes before `1.0`.
 

package/dist/cli/agent.d.ts

@@ -4,6 +4,7 @@ export type SourceChange = {
     newString: string;
 };
 type AgentInput = {
+    taskId?: string;
     instruction: string;
     model: string;
     messages?: Array<{
@@ -45,17 +46,25 @@ export type AgentConfig = {
 };
 export type LocalAgent = "claude-code" | "codex" | "opencode";
 export type AgentProgress = (message: string, detail?: string) => void;
+export type AgentPrompt = {
+    message: string;
+    kind: "permission" | "input";
+    options?: string[];
+};
+export type AgentPromptHandler = (prompt: AgentPrompt) => void;
 export type AgentAnswer = {
+    taskId?: string;
     question: string;
     context?: AgentInput["context"];
     element: AgentInput["element"];
     messages?: AgentInput["messages"];
 };
+export declare function respondToAgentPrompt(taskId: string, value: string): boolean;
 export declare function detectLocalAgents(): Promise<Set<LocalAgent>>;
-export declare function proposeChanges(cwd: string, input: AgentInput, config: AgentConfig, signal?: AbortSignal, onProgress?: AgentProgress): Promise<{
+export declare function proposeChanges(cwd: string, input: AgentInput, config: AgentConfig, signal?: AbortSignal, onProgress?: AgentProgress, onPrompt?: AgentPromptHandler): Promise<{
     summary: string;
     changes: SourceChange[];
 }>;
-export declare function answerQuestion(cwd: string, input: AgentAnswer, config: AgentConfig, signal?: AbortSignal, onProgress?: AgentProgress): Promise<string>;
+export declare function answerQuestion(cwd: string, input: AgentAnswer, config: AgentConfig, signal?: AbortSignal, onProgress?: AgentProgress, onPrompt?: AgentPromptHandler): Promise<string>;
 export declare function generateCommitMessage(cwd: string, status: string[], config: AgentConfig, signal?: AbortSignal, onProgress?: AgentProgress): Promise<string>;
 export {};

package/dist/cli/agent.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.respondToAgentPrompt = respondToAgentPrompt;
 exports.detectLocalAgents = detectLocalAgents;
 exports.proposeChanges = proposeChanges;
 exports.answerQuestion = answerQuestion;
@@ -12,6 +13,14 @@ 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 execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const activeAgentInputs = new Map();
+function respondToAgentPrompt(taskId, value) {
+    const respond = activeAgentInputs.get(taskId);
+    if (!respond)
+        return false;
+    respond(value);
+    return true;
+}
 async function detectLocalAgents() {
     const found = new Set();
     for (const [name, command] of [["claude-code", "claude"], ["codex", "codex"], ["opencode", "opencode"]]) {
@@ -202,7 +211,7 @@ function extractLocalAgentText(raw, provider) {
     }
     return texts.at(-1) || raw;
 }
-function collectTextFields(value, fields = new Set(["text", "output_text", "result", "content", "message"]), depth = 0) {
+function collectTextFields(value, fields = new Set(["text", "output_text", "result", "content", "message", "output", "value"]), depth = 0) {
     if (depth > 8 || value == null)
         return [];
     if (typeof value === "string")
@@ -220,6 +229,17 @@ function collectTextFields(value, fields = new Set(["text", "output_text", "resu
     }
     return output;
 }
+function findStructuredProposals(value, depth = 0) {
+    if (depth > 8 || value == null || typeof value !== "object")
+        return [];
+    if (!Array.isArray(value)) {
+        const record = value;
+        if (Array.isArray(record.changes))
+            return [JSON.stringify(record)];
+        return Object.values(record).flatMap((entry) => findStructuredProposals(entry, depth + 1));
+    }
+    return value.flatMap((entry) => findStructuredProposals(entry, depth + 1));
+}
 function extractLocalAgentProposal(raw, provider) {
     const outputs = [];
     const lines = raw.split(/\r?\n/).filter((line) => line.trim());
@@ -259,6 +279,14 @@ function extractLocalAgentProposal(raw, provider) {
         if (part?.type === "text" && typeof part.text === "string")
             outputs.push(part.text);
     }
+    for (const proposal of streamObjects.flatMap((event) => findStructuredProposals(event)).reverse()) {
+        try {
+            return jsonFrom(proposal);
+        }
+        catch {
+            // Continue through text candidates below.
+        }
+    }
     // Tool events are interleaved with the final answer. Try text events in
     // reverse order, then the complete stream as a final fallback.
     for (const output of [...outputs.reverse(), raw]) {
@@ -269,12 +297,76 @@ function extractLocalAgentProposal(raw, provider) {
             // Keep looking; this output may only be a progress or tool event.
         }
     }
-    throw new Error("The agent returned no valid reviewable changes. Progress output may have been mixed with the final JSON.");
+    throw new Error(`${provider === "opencode" ? "OpenCode" : "The agent"} did not return a reviewable proposal. It produced progress/tool events but no final JSON containing file changes.`);
 }
 function snippet(value, max = 80) {
     const s = String(value ?? "").trim().replace(/\s+/g, " ");
     return s.length > max ? `${s.slice(0, max)}…` : s;
 }
+const ANSI_PATTERN = /\u001B\[[0-9;?]*[ -/]*[@-~]/g;
+const LOG_FIELD_PATTERN = /([A-Za-z_][\w.-]*)=("(?:[^"\\]|\\.)*"|[^\s]*)/g;
+function cleanAgentText(value) {
+    return value.replace(ANSI_PATTERN, "").replace(/\s+/g, " ").trim();
+}
+/**
+ * Local agents (notably OpenCode) print structured logs such as
+ * `timestamp=… level=ERROR run=… message="Failed to fetch models.dev" cause="…"`.
+ * Those lines are machine diagnostics, never user-facing copy, so they are parsed
+ * into their fields instead of being shown verbatim.
+ */
+function parseAgentLogFields(line) {
+    if (!/^\s*(?:timestamp|time|ts)=\S/.test(line))
+        return null;
+    const fields = {};
+    for (const match of line.matchAll(LOG_FIELD_PATTERN)) {
+        const key = match[1];
+        const raw = match[2] ?? "";
+        fields[key] = raw.startsWith('"')
+            ? raw.slice(1, -1).replace(/\\(["\\])/g, "$1")
+            : raw;
+    }
+    return fields;
+}
+// Filesystem failures that a permission request can never resolve.
+const AGENT_FAILURE_MARKERS = /\b(?:EACCES|EPERM|ENOENT|EEXIST|EISDIR|ENOTDIR|ENOSPC|EMFILE|ENOTEMPTY)\b|\bCause\(\[Die\(/i;
+const AGENT_FAILURE_HINTS = [
+    {
+        pattern: /EACCES: permission denied[\s\S]*(?:locks?|state|storage|\.config|config\/)/i,
+        message: "The local agent cannot write to its own state folder. Fix that folder's ownership (for example `sudo chown -R $(whoami) ~/.local/state/opencode`) and retry.",
+    },
+    {
+        pattern: /EACCES: permission denied/i,
+        message: "The local agent was denied access to a file or folder it needs. Check the permissions on its state directory, then retry.",
+    },
+    {
+        pattern: /failed to fetch models\.dev/i,
+        message: "The local agent could not reach models.dev to refresh its model list. Check the network or proxy it uses, then retry.",
+    },
+];
+function agentFailureHint(line) {
+    return AGENT_FAILURE_HINTS.find((hint) => hint.pattern.test(line))?.message;
+}
+const PERMISSION_PROMPT_PATTERN = /permission\s+(?:is\s+)?(?:required|requested|needed|denied)|needs?\s+(?:your\s+)?permission|permission\s+to\s+(?:run|edit|write|read|execute|create|delete|modify|access|apply)|approve\s+(?:this|the|tool|action|command)|authori[sz]e\s+(?:this|the|tool|action|command)|authentication\s+(?:is\s+)?required|(?:please\s+)?log\s?in|sign\s?in\s+(?:required|to\s+continue)|press\s+.{1,24}?to\s+(?:continue|approve|confirm)|waiting for (?:your )?(?:permission|approval|input|response)/i;
+/**
+ * Returns human-readable copy for a real approval/authentication request, or
+ * `null` when the line is anything else. A structured error log never becomes a
+ * permission prompt: Allow/Deny cannot fix a filesystem failure, and hiding the
+ * error behind those buttons is what made the prompt unreadable.
+ */
+function permissionPromptMessage(raw) {
+    const line = cleanAgentText(raw);
+    if (!line)
+        return null;
+    if (parseAgentLogFields(line) || AGENT_FAILURE_MARKERS.test(line))
+        return null;
+    if (!PERMISSION_PROMPT_PATTERN.test(line))
+        return null;
+    const detail = line
+        .replace(/^[A-Za-z0-9_.-]+:\s*/, "")
+        .replace(/^["'\s]+|["'\s]+$/g, "")
+        .trim();
+    return snippet(detail || line, 240);
+}
 function progressEvent(message, detail) {
     const value = detail == null ? "" : String(detail).trim();
     return value ? { message, detail: value } : { message };
@@ -382,6 +474,12 @@ function progressEventsFromRaw(raw, provider) {
 }
 function localAgentError(command, stderr, exitCode) {
     const output = stderr.trim();
+    const hint = agentFailureHint(output);
+    if (hint)
+        return `${command === "opencode" ? "OpenCode" : command} could not finish: ${hint}`;
+    if (command === "opencode" && /waiting for permission or authentication/i.test(output)) {
+        return "OpenCode needs permission or authentication. Run OpenCode once in a terminal, approve the requested access or sign in, then retry in Lasso.";
+    }
     if (command === "codex" && output.includes("missing field `base_instructions`")) {
         return "Codex could not read its models cache because it uses an older cache format. Update Codex, then retry. Lasso already bypasses the repository trust check.";
     }
@@ -406,9 +504,9 @@ function localCommand(provider, model, prompt) {
     }
     return { command: "codex", args: ["exec", "--json", "--sandbox", "read-only", "--skip-git-repo-check", ...(selectedModel ? ["--model", selectedModel] : []), prompt || ""] };
 }
-function runLocalCommand(cwd, command, args, provider, signal, onProgress) {
+function runLocalCommand(cwd, command, args, provider, signal, onProgress, taskId, onPrompt) {
     return new Promise((resolve, reject) => {
-        const child = (0, node_child_process_1.spawn)(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        const child = (0, node_child_process_1.spawn)(command, args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
         const label = provider === "opencode" ? "OpenCode" : provider === "codex" ? "Codex" : "Claude Code";
         let stdout = "";
         let stderr = "";
@@ -416,6 +514,18 @@ function runLocalCommand(cwd, command, args, provider, signal, onProgress) {
         let pendingStderr = "";
         let settled = false;
         let timedOut = false;
+        let promptShown = false;
+        const sendPrompt = (message, kind = "permission") => {
+            if (!taskId || promptShown)
+                return;
+            promptShown = true;
+            activeAgentInputs.set(taskId, (value) => {
+                promptShown = false;
+                activeAgentInputs.delete(taskId);
+                child.stdin.write(`${value}\n`);
+            });
+            onPrompt?.({ message, kind, options: kind === "permission" ? ["Allow", "Deny"] : undefined });
+        };
         const timeout = setTimeout(() => {
             timedOut = true;
             child.kill("SIGTERM");
@@ -443,7 +553,14 @@ function runLocalCommand(cwd, command, args, provider, signal, onProgress) {
                 for (const progress of progressEventsFromRaw(line, provider)) {
                     onProgress?.(progress.message, progress.detail);
                 }
-                if (stream === "stderr" && line.trim()) {
+                const promptMessage = permissionPromptMessage(line);
+                if (promptMessage) {
+                    sendPrompt(promptMessage);
+                }
+                else if (stream === "stderr" && line.trim()) {
+                    const hint = agentFailureHint(line);
+                    if (hint)
+                        onProgress?.(`${label} · ${hint}`);
                     if (provider === "opencode" && /quota exceeded|authentication failed|invalid api key|unauthorized|forbidden/i.test(line)) {
                         onProgress?.("OpenCode · provider rejected the request; stopping this task…");
                         child.kill("SIGTERM");
@@ -463,6 +580,8 @@ function runLocalCommand(cwd, command, args, provider, signal, onProgress) {
                 return;
             settled = true;
             clearTimeout(timeout);
+            if (taskId)
+                activeAgentInputs.delete(taskId);
             signal?.removeEventListener("abort", abort);
             reject(error);
         });
@@ -471,6 +590,8 @@ function runLocalCommand(cwd, command, args, provider, signal, onProgress) {
                 return;
             settled = true;
             clearTimeout(timeout);
+            if (taskId)
+                activeAgentInputs.delete(taskId);
             signal?.removeEventListener("abort", abort);
             if (timedOut) {
                 reject(new Error(`${label} did not finish within 5 minutes. Check its login or approval prompt, then retry.`));
@@ -488,6 +609,9 @@ function runLocalCommand(cwd, command, args, provider, signal, onProgress) {
                 for (const progress of progressEventsFromRaw(stderrTail, provider)) {
                     onProgress?.(progress.message, progress.detail);
                 }
+                const hint = agentFailureHint(stderrTail);
+                if (hint)
+                    onProgress?.(`${label} · ${hint}`);
                 if (provider === "opencode" && /quota exceeded|authentication failed|invalid api key|unauthorized|forbidden/i.test(stderrTail)) {
                     onProgress?.("OpenCode · provider rejected the request; stopping this task…");
                 }
@@ -496,18 +620,18 @@ function runLocalCommand(cwd, command, args, provider, signal, onProgress) {
         });
     });
 }
-async function proposeWithLocalAgent(cwd, instruction, context, config, signal, onProgress) {
+async function proposeWithLocalAgent(cwd, instruction, context, config, signal, onProgress, taskId, onPrompt) {
     const outputContract = `Return ONLY valid JSON in this exact shape: {"summary":"short explanation","changes":[{"filePath":"relative/path","oldString":"exact existing text","newString":"replacement text"}]}. Treat the supplied source context as read-only. Before returning, verify every oldString against that context. Use project-relative paths only. Do not edit files, run write commands, commit, or produce markdown fences.`;
     const prompt = `${instruction}\n\n${outputContract}\n\nLasso has already assembled this source context:\n${context || "No matching source context was found."}`;
     const local = localCommand(config.provider, config.model, prompt);
     const command = local.command;
     const args = local.args;
-    const result = await runLocalCommand(cwd, command, args, config.provider, signal, onProgress);
+    const result = await runLocalCommand(cwd, command, args, config.provider, signal, onProgress, taskId, onPrompt);
     if (result.exitCode !== 0)
         throw new Error(localAgentError(command, result.stderr, result.exitCode));
     return extractLocalAgentProposal(result.stdout, config.provider);
 }
-async function proposeChanges(cwd, input, config, signal, onProgress) {
+async function proposeChanges(cwd, input, config, signal, onProgress, onPrompt) {
     const context = await contextFor(cwd, input.element);
     const visualContext = input.context ? { ...input.context, screenshots: undefined } : undefined;
     const history = input.messages?.map((message) => `${message.role}: ${message.content}`).join("\n") || input.instruction;
@@ -517,7 +641,7 @@ async function proposeChanges(cwd, input, config, signal, onProgress) {
         : "";
     const instruction = `Selection context:\n${JSON.stringify(input.element, null, 2)}\n${JSON.stringify(visualContext, null, 2)}\n\nConversation history:\n${history}\n\nPrevious change history for this selection:\n${priorChanges}\n\nRelevant source context:\n${context || "No matching source context was found. Ask for a more specific selection rather than inventing a file."}${dragHint}\n\nReturn ONLY JSON: {"summary":"short explanation","changes":[{"filePath":"relative/path","oldString":"exact text","newString":"replacement text"}]}`;
     if (config.provider === "claude-code" || config.provider === "codex" || config.provider === "opencode") {
-        return proposeWithLocalAgent(cwd, instruction, context, config, signal, onProgress);
+        return proposeWithLocalAgent(cwd, instruction, context, config, signal, onProgress, input.taskId, onPrompt);
     }
     const system = "You are Lasso, a careful source-code editing agent. Return only valid JSON. Each oldString must occur exactly once in its file. Never rewrite whole files. Keep changes focused on the request.";
     const model = config.model || (config.provider === "google" ? "gemini-2.5-flash" : config.provider === "openai" ? "gpt-4.1-mini" : config.provider === "ollama" ? "llama3.2" : "claude-sonnet-4-20250514");
@@ -568,13 +692,13 @@ async function proposeChanges(cwd, input, config, signal, onProgress) {
         throw new Error("The agent returned an empty response.");
     return jsonFrom(text);
 }
-async function answerQuestion(cwd, input, config, signal, onProgress) {
+async function answerQuestion(cwd, input, config, signal, onProgress, onPrompt) {
     const context = await contextFor(cwd, input.element);
     const history = input.messages?.map((message) => `${message.role}: ${message.content}`).join("\n") || "None";
     const prompt = `Answer the user's question conversationally and directly. Do not propose file changes and do not return JSON. If the question is about the selected UI, use the selection and source context below.\n\nUser question:\n${input.question}\n\nSelected element:\n${JSON.stringify(input.element, null, 2)}\n\nVisual context:\n${JSON.stringify({ ...input.context, screenshots: undefined }, null, 2)}\n\nConversation:\n${history}\n\nRelevant source context:\n${context || "No matching source context was found."}`;
     if (config.provider === "claude-code" || config.provider === "codex" || config.provider === "opencode") {
         const local = localCommand(config.provider, config.model, prompt);
-        const result = await runLocalCommand(cwd, local.command, local.args, config.provider, signal, onProgress);
+        const result = await runLocalCommand(cwd, local.command, local.args, config.provider, signal, onProgress, input.taskId, onPrompt);
         if (result.exitCode !== 0)
             throw new Error(localAgentError(local.command, result.stderr, result.exitCode));
         return extractLocalAgentText(result.stdout, config.provider).trim();

package/dist/cli/bridge.d.ts

@@ -1,4 +1,4 @@
-import { type SourceChange } from "./agent";
+import { type SourceChange, type AgentPrompt } from "./agent";
 import type { CollabConfig } from "./project";
 export declare const DEFAULT_BRIDGE_PORT = 3056;
 type GitState = {
@@ -91,6 +91,22 @@ export type BridgeMessage = {
 } | {
     type: "stop";
     taskId?: string;
+} | {
+    type: "agent_prompt_response";
+    taskId: string;
+    response: string;
+} | {
+    type: "list_page_folders";
+    path?: string;
+} | {
+    type: "create_page";
+    folder: string;
+    fileName: string;
+    content: string;
+} | {
+    type: "create_page_folder";
+    parent: string;
+    name: string;
 } | {
     type: "git_status";
 } | {
@@ -121,6 +137,11 @@ type ModelOption = {
     label: string;
     provider: "anthropic" | "openai" | "google" | "ollama" | "cli";
 };
+type PageEntry = {
+    name: string;
+    path: string;
+    type: "directory" | "file";
+};
 export type ServerBridgeMessage = {
     type: "config";
     apiKeyConfigured: boolean;
@@ -148,6 +169,24 @@ export type ServerBridgeMessage = {
     message: string;
     detail?: string;
     changes?: SourceChange[];
+} | {
+    type: "agent_prompt";
+    taskId: string;
+    prompt: AgentPrompt;
+} | {
+    type: "page_folders";
+    path: string;
+    entries: PageEntry[];
+    project?: string;
+    error?: string;
+} | {
+    type: "page_created";
+    path: string;
+    error?: string;
+} | {
+    type: "page_folder_created";
+    path: string;
+    error?: string;
 } | {
     type: "assistant_message";
     taskId?: string;