@lasso-ai/cli 2.0.1 → 2.1.0

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

@@ -1,9 +1,13 @@
 /**
  * Lasso Runtime Client
  *
- * Client for the new Lasso Agentic Runtime
- * Uses SSE for real-time progress events
+ * Client for the hosted-model agentic runtime. The server orchestrates the
+ * agent loop and calls the model, but never touches the local filesystem:
+ * workspace tools arrive as `tool_call` events and are executed HERE, in the
+ * CLI, against the real project directory. The CLI also owns the
+ * WorkspaceGuard (snapshot → diff → rollback → review → approval).
  */
+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;
@@ -178,6 +182,11 @@ export type RuntimeEvent = {
         success: boolean;
     };
     timestamp: number;
+} | {
+    type: "tool_call";
+    sessionId: string;
+    data: ToolCallRequest;
+    timestamp: number;
 } | {
     type: "observation";
     sessionId: string;
@@ -252,19 +261,38 @@ export type RuntimeEventHandler = (event: RuntimeEvent) => void | Promise<void>;
 export declare class RuntimeClient {
     private serverUrl;
     private apiKey?;
+    /**
+     * Review payloads computed locally from the WorkspaceGuard diff, keyed by
+     * sessionId. Merged into getSession() so the bridge's review flow sees the
+     * authoritative pendingChanges without the server ever touching the FS.
+     */
+    private localReviewCache;
     constructor(serverUrl: string, apiKey?: string);
     /**
      * Create a new runtime session
      */
     createSession(input: RuntimeSessionInput): Promise<RuntimeSession>;
     /**
-     * Get a session by ID
+     * Get a session by ID. Locally computed review changes (WorkspaceGuard
+     * diff from the last run) are merged into metadata.pendingChanges.
      */
     getSession(sessionId: string): Promise<RuntimeSession>;
     /**
-     * Run a session with SSE event streaming
+     * Run a session with SSE event streaming.
+     *
+     * Hosted-model flow (server orchestrates, CLI executes):
+     *   1. Capture the WorkspaceGuard BEFORE the run (CLI owns the snapshot).
+     *   2. Stream events from the server. `tool_call` events are executed
+     *      locally (ActionExecutor / VerificationEngine) and the result is
+     *      posted back to the server so the model loop can continue.
+     *   3. On agent_completed: diff the workspace, roll it back, and cache the
+     *      changes for the review panel. Only user approval re-applies them.
      */
     runSession(sessionId: string, projectPath: string, onEvent: RuntimeEventHandler, signal?: AbortSignal): Promise<void>;
+    /** Execute a tool_call request locally against the real project. */
+    private executeToolCallLocally;
+    /** Post a tool result back to the server (resolves its pending request). */
+    private postToolResult;
     /**
      * Cancel a running session
      */
@@ -280,8 +308,9 @@ export declare class RuntimeClient {
     /**
      * Verify the workspace for a session (after reviewed changes were applied).
      *
-     * Returns whether verification passed; on failure the session keeps the
-     * verification errors so a corrective re-run can fix them.
+     * Hosted sessions verify LOCALLY (the server cannot run typecheck/build
+     * against a filesystem it does not have). The results are also persisted
+     * on the server session so a corrective re-run has them in context.
      */
     verifySession(sessionId: string, projectPath: string): Promise<SessionVerificationResult>;
     /**

package/dist/cli/runtime-client.js

@@ -2,14 +2,28 @@
 /**
  * Lasso Runtime Client
  *
- * Client for the new Lasso Agentic Runtime
- * Uses SSE for real-time progress events
+ * Client for the hosted-model agentic runtime. The server orchestrates the
+ * agent loop and calls the model, but never touches the local filesystem:
+ * workspace tools arrive as `tool_call` events and are executed HERE, in the
+ * CLI, against the real project directory. The CLI also owns the
+ * WorkspaceGuard (snapshot → diff → rollback → review → approval).
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeClient = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const index_js_1 = require("../runtime/index.js");
 class RuntimeClient {
     serverUrl;
     apiKey;
+    /**
+     * Review payloads computed locally from the WorkspaceGuard diff, keyed by
+     * sessionId. Merged into getSession() so the bridge's review flow sees the
+     * authoritative pendingChanges without the server ever touching the FS.
+     */
+    localReviewCache = new Map();
     constructor(serverUrl, apiKey) {
         this.serverUrl = serverUrl;
         this.apiKey = apiKey;
@@ -33,7 +47,8 @@ class RuntimeClient {
         return data;
     }
     /**
-     * Get a session by ID
+     * Get a session by ID. Locally computed review changes (WorkspaceGuard
+     * diff from the last run) are merged into metadata.pendingChanges.
      */
     async getSession(sessionId) {
         const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}`, {
@@ -45,12 +60,67 @@ class RuntimeClient {
             throw new Error(`Failed to get session: ${response.statusText}`);
         }
         const data = await response.json();
+        const local = this.localReviewCache.get(sessionId);
+        if (local && local.length > 0) {
+            data.metadata = { ...(data.metadata || {}), pendingChanges: local };
+        }
         return data;
     }
     /**
-     * Run a session with SSE event streaming
+     * Run a session with SSE event streaming.
+     *
+     * Hosted-model flow (server orchestrates, CLI executes):
+     *   1. Capture the WorkspaceGuard BEFORE the run (CLI owns the snapshot).
+     *   2. Stream events from the server. `tool_call` events are executed
+     *      locally (ActionExecutor / VerificationEngine) and the result is
+     *      posted back to the server so the model loop can continue.
+     *   3. On agent_completed: diff the workspace, roll it back, and cache the
+     *      changes for the review panel. Only user approval re-applies them.
      */
     async runSession(sessionId, projectPath, onEvent, signal) {
+        // CLI-side snapshot: nothing the agent does is left on disk before review.
+        let guard = null;
+        try {
+            guard = await index_js_1.WorkspaceGuard.capture(projectPath);
+        }
+        catch (error) {
+            console.error("WorkspaceGuard capture failed:", error);
+        }
+        const executor = new index_js_1.ActionExecutor(projectPath);
+        const verifier = new index_js_1.VerificationEngine(projectPath);
+        const finalizeGuard = async () => {
+            if (!guard)
+                return;
+            try {
+                const changes = guard.diff();
+                const applyable = changes.filter((c) => !c.binary);
+                const pending = applyable.map((change) => ({
+                    filePath: change.filePath,
+                    oldString: change.operation === "created" ? "" : change.oldContent ?? "",
+                    newString: change.operation === "deleted" ? "" : change.newContent ?? "",
+                    operation: change.operation,
+                }));
+                this.localReviewCache.set(sessionId, pending);
+            }
+            catch (error) {
+                console.error("WorkspaceGuard diff failed:", error);
+            }
+            finally {
+                // Always restore BEFORE the review flow runs — it captures originals
+                // from disk for the undo snapshot, so the workspace must be back to
+                // its pre-run state by the time agent_completed is delivered.
+                try {
+                    await guard.restore();
+                }
+                catch (error) {
+                    console.error("WorkspaceGuard restore failed:", error);
+                }
+            }
+        };
+        const handleToolCall = async (request) => {
+            const result = await this.executeToolCallLocally(request, executor, verifier);
+            await this.postToolResult(sessionId, result);
+        };
         const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}/run`, {
             method: "POST",
             headers: {
@@ -83,6 +153,15 @@ class RuntimeClient {
                         continue;
                     try {
                         const event = JSON.parse(data);
+                        if (event.type === "tool_call") {
+                            // Execute locally and answer the server — never forwarded raw.
+                            await handleToolCall(event.data);
+                            continue;
+                        }
+                        if (event.type === "agent_completed") {
+                            // Diff + rollback BEFORE the review flow reads the session.
+                            await finalizeGuard();
+                        }
                         await onEvent(event);
                     }
                     catch (error) {
@@ -93,6 +172,71 @@ class RuntimeClient {
         }
         finally {
             reader.releaseLock();
+            // Safety net: if the stream died mid-run, still restore the workspace.
+            if (guard) {
+                guard.restore().catch(() => { });
+            }
+        }
+    }
+    /** Execute a tool_call request locally against the real project. */
+    async executeToolCallLocally(request, executor, verifier) {
+        try {
+            if (request.kind === "verify") {
+                const results = await verifier.verifyAll(request.verify?.phase || "verify");
+                return {
+                    callId: request.callId,
+                    success: verifier.allPassed(results),
+                    observations: verifier.getObservations(results),
+                    errors: verifier.getErrors(results),
+                };
+            }
+            if (!request.action) {
+                return { callId: request.callId, success: false, error: "tool_call missing action" };
+            }
+            const result = await executor.execute(request.action);
+            return {
+                callId: request.callId,
+                success: result.success,
+                output: result.output,
+                error: result.error,
+                observations: result.observation
+                    ? [{
+                            id: node_crypto_1.default.randomUUID(),
+                            type: result.observation.type,
+                            summary: result.observation.summary,
+                            data: result.observation.data,
+                            timestamp: Date.now(),
+                            phase: "execute",
+                            actionId: request.action.id,
+                        }]
+                    : undefined,
+            };
+        }
+        catch (error) {
+            return {
+                callId: request.callId,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /** Post a tool result back to the server (resolves its pending request). */
+    async postToolResult(sessionId, result) {
+        try {
+            const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}/tool-results`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
+                },
+                body: JSON.stringify(result),
+            });
+            if (!response.ok) {
+                console.error(`Failed to post tool result: ${response.statusText}`);
+            }
+        }
+        catch (error) {
+            console.error("Failed to post tool result:", error);
         }
     }
     /**
@@ -128,22 +272,36 @@ class RuntimeClient {
     /**
      * Verify the workspace for a session (after reviewed changes were applied).
      *
-     * Returns whether verification passed; on failure the session keeps the
-     * verification errors so a corrective re-run can fix them.
+     * Hosted sessions verify LOCALLY (the server cannot run typecheck/build
+     * against a filesystem it does not have). The results are also persisted
+     * on the server session so a corrective re-run has them in context.
      */
     async verifySession(sessionId, projectPath) {
-        const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}/verify`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
-            },
-            body: JSON.stringify({ projectPath }),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to verify session: ${response.statusText}`);
+        const engine = new index_js_1.VerificationEngine(projectPath);
+        const results = await engine.verifyAll("verify");
+        const passed = engine.allPassed(results);
+        const errors = engine.getErrors(results);
+        const observations = engine.getObservations(results);
+        // Persist on the server session (best-effort — corrective context).
+        try {
+            await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}/verify`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
+                },
+                body: JSON.stringify({ projectPath, localResults: { passed, errors, observations } }),
+            });
         }
-        return (await response.json());
+        catch {
+            // Non-fatal: the local result is still returned to the caller.
+        }
+        return {
+            passed,
+            errors,
+            observations,
+            requiresFix: !passed,
+        };
     }
     /**
      * List available backends from the server (hosted providers + local agents).

package/dist/runtime/action-executor.d.ts

@@ -0,0 +1,76 @@
+import type { AgentAction } from "./agent-runtime";
+/**
+ * Action Executor - Executes validated model actions on the LOCAL machine.
+ *
+ * Used by the CLI to fulfil `tool_call` requests from the hosted-model
+ * orchestrator. Every path is validated to stay inside the project directory
+ * (workspace boundary enforcement happens client-side, never on the server).
+ */
+export interface ActionExecutionResult {
+    success: boolean;
+    actionId: string;
+    output?: any;
+    error?: string;
+    observation?: {
+        type: string;
+        summary: string;
+        data?: any;
+    };
+}
+export declare class ActionExecutor {
+    private projectPath;
+    constructor(projectPath: string);
+    /**
+     * Execute a single action
+     */
+    execute(action: AgentAction): Promise<ActionExecutionResult>;
+    /**
+     * Execute multiple actions (stop on first failure)
+     */
+    executeBatch(actions: AgentAction[]): Promise<ActionExecutionResult[]>;
+    /**
+     * Read file action
+     */
+    private executeReadFile;
+    /**
+     * Edit file action
+     */
+    private executeEditFile;
+    /**
+     * Create file action
+     */
+    private executeCreateFile;
+    /**
+     * Delete file action
+     */
+    private executeDeleteFile;
+    /**
+     * Run command action
+     */
+    private executeRunCommand;
+    /**
+     * Search code action
+     */
+    private executeSearchCode;
+    /**
+     * Inspect project action
+     */
+    private executeInspectProject;
+    /**
+     * Browser check action (placeholder for now)
+     */
+    private executeBrowserCheck;
+    /**
+     * Resolve a path relative to the project and enforce the workspace
+     * boundary: every resolved path must stay inside projectPath.
+     */
+    private resolvePath;
+    /**
+     * List all project files recursively
+     */
+    private listProjectFiles;
+    /**
+     * Read package.json if it exists
+     */
+    private readPackageJson;
+}

package/dist/runtime/action-executor.js

@@ -0,0 +1,420 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionExecutor = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+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 exec = (0, node_util_1.promisify)(node_child_process_1.exec);
+class ActionExecutor {
+    projectPath;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+    }
+    /**
+     * Execute a single action
+     */
+    async execute(action) {
+        const { id, type } = action;
+        try {
+            switch (type) {
+                case "read_file":
+                    return await this.executeReadFile(action);
+                case "edit_file":
+                    return await this.executeEditFile(action);
+                case "create_file":
+                    return await this.executeCreateFile(action);
+                case "delete_file":
+                    return await this.executeDeleteFile(action);
+                case "run_command":
+                    return await this.executeRunCommand(action);
+                case "search_code":
+                    return await this.executeSearchCode(action);
+                case "inspect_project":
+                    return await this.executeInspectProject(action);
+                case "browser_check":
+                    return await this.executeBrowserCheck(action);
+                default:
+                    return {
+                        success: false,
+                        actionId: id,
+                        error: `Unknown action type: ${type}`,
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                actionId: id,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Execute multiple actions (stop on first failure)
+     */
+    async executeBatch(actions) {
+        const results = [];
+        for (const action of actions) {
+            const result = await this.execute(action);
+            results.push(result);
+            // Stop if an action fails
+            if (!result.success) {
+                break;
+            }
+        }
+        return results;
+    }
+    /**
+     * Read file action
+     */
+    async executeReadFile(action) {
+        const { id, data } = action;
+        const filePath = data.path;
+        const fullPath = this.resolvePath(filePath);
+        if (!node_fs_1.default.existsSync(fullPath)) {
+            return {
+                success: false,
+                actionId: id,
+                error: `File not found: ${filePath}`,
+            };
+        }
+        const content = node_fs_1.default.readFileSync(fullPath, "utf-8");
+        return {
+            success: true,
+            actionId: id,
+            output: { content, path: filePath },
+            observation: {
+                type: "file",
+                summary: `Read file: ${filePath}`,
+                data: { path: filePath, size: content.length },
+            },
+        };
+    }
+    /**
+     * Edit file action
+     */
+    async executeEditFile(action) {
+        const { id, data } = action;
+        const filePath = data.path;
+        const oldString = data.oldString;
+        const newString = data.newString;
+        const fullPath = this.resolvePath(filePath);
+        if (!node_fs_1.default.existsSync(fullPath)) {
+            return {
+                success: false,
+                actionId: id,
+                error: `File not found: ${filePath}`,
+            };
+        }
+        const content = node_fs_1.default.readFileSync(fullPath, "utf-8");
+        if (oldString && !content.includes(oldString)) {
+            return {
+                success: false,
+                actionId: id,
+                error: `oldString not found in file: ${filePath}`,
+            };
+        }
+        const newContent = oldString ? content.replace(oldString, newString) : newString;
+        // No local backup: the WorkspaceGuard snapshot taken before the run is
+        // the authoritative rollback mechanism (and .lasso-backup files would
+        // pollute the review diff).
+        node_fs_1.default.writeFileSync(fullPath, newContent);
+        return {
+            success: true,
+            actionId: id,
+            output: { path: filePath },
+            observation: {
+                type: "file",
+                summary: `Edited file: ${filePath}`,
+                data: { path: filePath },
+            },
+        };
+    }
+    /**
+     * Create file action
+     */
+    async executeCreateFile(action) {
+        const { id, data } = action;
+        const filePath = data.path;
+        const content = data.content;
+        const fullPath = this.resolvePath(filePath);
+        if (node_fs_1.default.existsSync(fullPath)) {
+            return {
+                success: false,
+                actionId: id,
+                error: `File already exists: ${filePath}`,
+            };
+        }
+        // Ensure directory exists
+        const dir = node_path_1.default.dirname(fullPath);
+        if (!node_fs_1.default.existsSync(dir)) {
+            node_fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        node_fs_1.default.writeFileSync(fullPath, content || "");
+        return {
+            success: true,
+            actionId: id,
+            output: { path: filePath },
+            observation: {
+                type: "file",
+                summary: `Created file: ${filePath}`,
+                data: { path: filePath },
+            },
+        };
+    }
+    /**
+     * Delete file action
+     */
+    async executeDeleteFile(action) {
+        const { id, data } = action;
+        const filePath = data.path;
+        const fullPath = this.resolvePath(filePath);
+        if (!node_fs_1.default.existsSync(fullPath)) {
+            return {
+                success: false,
+                actionId: id,
+                error: `File not found: ${filePath}`,
+            };
+        }
+        // No local backup: the WorkspaceGuard snapshot is the authoritative
+        // rollback mechanism.
+        node_fs_1.default.unlinkSync(fullPath);
+        return {
+            success: true,
+            actionId: id,
+            output: { path: filePath },
+            observation: {
+                type: "file",
+                summary: `Deleted file: ${filePath}`,
+                data: { path: filePath },
+            },
+        };
+    }
+    /**
+     * Run command action
+     */
+    async executeRunCommand(action) {
+        const { id, data } = action;
+        const command = data.command;
+        const cwd = data.cwd;
+        const workingDir = cwd ? this.resolvePath(cwd) : this.projectPath;
+        if (!node_fs_1.default.existsSync(workingDir)) {
+            return {
+                success: false,
+                actionId: id,
+                error: `Working directory not found: ${workingDir}`,
+            };
+        }
+        // Safety check: prevent dangerous commands
+        const dangerousPatterns = [
+            /\brm\s+-rf\b/,
+            /\bdd\s+if=/,
+            />\s*\/dev\/null/,
+            />\s*\/dev\/sd/,
+        ];
+        for (const pattern of dangerousPatterns) {
+            if (pattern.test(command)) {
+                return {
+                    success: false,
+                    actionId: id,
+                    error: `Command rejected for safety: ${command}`,
+                };
+            }
+        }
+        try {
+            const { stdout, stderr } = await exec(command, {
+                cwd: workingDir,
+                timeout: 120000, // 2 minute timeout
+            });
+            return {
+                success: true,
+                actionId: id,
+                output: { stdout, stderr },
+                observation: {
+                    type: "command",
+                    summary: `Ran command: ${command}`,
+                    data: { command, exitCode: 0 },
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                actionId: id,
+                error: error.message,
+                output: { stdout: error.stdout, stderr: error.stderr },
+                observation: {
+                    type: "command",
+                    summary: `Command failed: ${command}`,
+                    data: { command, exitCode: error.code || 1 },
+                },
+            };
+        }
+    }
+    /**
+     * Search code action
+     */
+    async executeSearchCode(action) {
+        const { id, data } = action;
+        const pattern = data.pattern;
+        const filePattern = data.filePattern;
+        const maxResults = data.maxResults || 50;
+        // Use grep to search
+        const grepPattern = filePattern ? `--include=${filePattern}` : "";
+        const command = `grep -r -n "${pattern}" ${grepPattern} . 2>/dev/null | head -n ${maxResults}`;
+        try {
+            const { stdout } = await exec(command, {
+                cwd: this.projectPath,
+                timeout: 30000, // 30 second timeout
+            });
+            const results = stdout
+                .trim()
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => {
+                const [filePath, lineNum, ...content] = line.split(":");
+                return {
+                    file: filePath,
+                    line: parseInt(lineNum, 10),
+                    content: content.join(":").trim(),
+                };
+            });
+            return {
+                success: true,
+                actionId: id,
+                output: { results },
+                observation: {
+                    type: "search",
+                    summary: `Found ${results.length} matches for: ${pattern}`,
+                    data: { pattern, count: results.length },
+                },
+            };
+        }
+        catch (error) {
+            // grep returns non-zero if no matches found
+            if (error.code === 1 && !error.stdout) {
+                return {
+                    success: true,
+                    actionId: id,
+                    output: { results: [] },
+                    observation: {
+                        type: "search",
+                        summary: `No matches found for: ${pattern}`,
+                        data: { pattern, count: 0 },
+                    },
+                };
+            }
+            return {
+                success: false,
+                actionId: id,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Inspect project action
+     */
+    async executeInspectProject(action) {
+        const { id } = action;
+        const files = this.listProjectFiles(this.projectPath);
+        const packageJson = this.readPackageJson();
+        return {
+            success: true,
+            actionId: id,
+            output: { files, packageJson },
+            observation: {
+                type: "file",
+                summary: `Inspected project: ${files.length} files`,
+                data: { fileCount: files.length },
+            },
+        };
+    }
+    /**
+     * Browser check action (placeholder for now)
+     */
+    async executeBrowserCheck(action) {
+        const { id, data } = action;
+        const url = data.url;
+        const check = data.check;
+        // TODO: Implement actual browser checking via Puppeteer or similar
+        return {
+            success: true,
+            actionId: id,
+            output: { url, check, result: "pending" },
+            observation: {
+                type: "browser",
+                summary: `Browser check pending: ${url}`,
+                data: { url, check },
+            },
+        };
+    }
+    /**
+     * Resolve a path relative to the project and enforce the workspace
+     * boundary: every resolved path must stay inside projectPath.
+     */
+    resolvePath(filePath) {
+        const resolved = node_path_1.default.isAbsolute(filePath)
+            ? node_path_1.default.resolve(filePath)
+            : node_path_1.default.resolve(this.projectPath, filePath);
+        const root = node_path_1.default.resolve(this.projectPath);
+        if (resolved !== root && !resolved.startsWith(root + node_path_1.default.sep)) {
+            throw new Error(`Path escapes workspace: ${filePath}`);
+        }
+        return resolved;
+    }
+    /**
+     * List all project files recursively
+     */
+    listProjectFiles(dir, maxDepth = 10) {
+        const files = [];
+        let depth = 0;
+        const traverse = (currentDir) => {
+            if (depth > maxDepth)
+                return;
+            const entries = node_fs_1.default.readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = node_path_1.default.join(currentDir, entry.name);
+                // Skip common ignored directories
+                if (entry.name === "node_modules" ||
+                    entry.name === ".git" ||
+                    entry.name === "dist" ||
+                    entry.name === "build" ||
+                    entry.name === ".next" ||
+                    entry.name === ".lasso") {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    depth++;
+                    traverse(fullPath);
+                    depth--;
+                }
+                else {
+                    files.push(node_path_1.default.relative(this.projectPath, fullPath));
+                }
+            }
+        };
+        traverse(dir);
+        return files;
+    }
+    /**
+     * Read package.json if it exists
+     */
+    readPackageJson() {
+        const packageJsonPath = node_path_1.default.join(this.projectPath, "package.json");
+        if (!node_fs_1.default.existsSync(packageJsonPath)) {
+            return null;
+        }
+        try {
+            const content = node_fs_1.default.readFileSync(packageJsonPath, "utf-8");
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.ActionExecutor = ActionExecutor;

package/dist/runtime/agent-runtime.d.ts

@@ -199,7 +199,7 @@ export interface LassoModelResponse {
     actions: AgentAction[];
     expectedOutcome?: string;
 }
-export type AgentEventType = "agent_started" | "agent_reasoning" | "agent_completed" | "agent_failed" | "agent_cancelled" | "phase_changed" | "tool_started" | "tool_completed" | "observation" | "plan_created" | "file_changed" | "verification_started" | "verification_completed" | "error" | "model_changed" | "waiting_for_user";
+export type AgentEventType = "agent_started" | "agent_reasoning" | "agent_completed" | "agent_failed" | "agent_cancelled" | "phase_changed" | "tool_started" | "tool_completed" | "tool_call" | "observation" | "plan_created" | "file_changed" | "verification_started" | "verification_completed" | "error" | "model_changed" | "waiting_for_user";
 export interface AgentEvent {
     type: AgentEventType;
     sessionId: string;
@@ -237,6 +237,22 @@ export interface ToolCompletedEvent extends AgentEvent {
         duration?: number;
     };
 }
+/**
+ * Emitted by the server when the hosted model requests a workspace tool.
+ * The local CLI executes the tool and posts the result back to
+ * `POST /sessions/:sessionId/tool-results` (see tool-protocol.ts).
+ */
+export interface ToolCallEvent extends AgentEvent {
+    type: "tool_call";
+    data: {
+        callId: string;
+        kind: "action" | "verify";
+        action?: AgentAction;
+        verify?: {
+            phase?: string;
+        };
+    };
+}
 export interface ObservationEvent extends AgentEvent {
     type: "observation";
     data: {

package/dist/runtime/index.d.ts

@@ -11,6 +11,8 @@ export * from "./agent-state-machine";
 export * from "./event-mapper";
 export * from "./review";
 export * from "./local-session-runner";
+export * from "./tool-protocol";
+export { ActionExecutor, ActionExecutionResult } from "./action-executor";
 export * from "./adapters/factory";
 export { LocalAgentAdapter, EventSink, newRunState } from "./adapters/local-agent-adapter";
 export type { LocalAgentConfig, CommandSpec, AgentRunState } from "./adapters/local-agent-adapter";

package/dist/runtime/index.js

@@ -19,7 +19,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CursorAdapter = exports.CodexCLIAdapter = exports.OpenCodeAdapter = exports.ClaudeCodeAdapter = exports.newRunState = exports.EventSink = exports.LocalAgentAdapter = void 0;
+exports.CursorAdapter = exports.CodexCLIAdapter = exports.OpenCodeAdapter = exports.ClaudeCodeAdapter = exports.newRunState = exports.EventSink = exports.LocalAgentAdapter = exports.ActionExecutor = void 0;
 __exportStar(require("./agent-runtime"), exports);
 __exportStar(require("./backend-interface"), exports);
 __exportStar(require("./workspace-guard"), exports);
@@ -28,6 +28,9 @@ __exportStar(require("./agent-state-machine"), exports);
 __exportStar(require("./event-mapper"), exports);
 __exportStar(require("./review"), exports);
 __exportStar(require("./local-session-runner"), exports);
+__exportStar(require("./tool-protocol"), exports);
+var action_executor_1 = require("./action-executor");
+Object.defineProperty(exports, "ActionExecutor", { enumerable: true, get: function () { return action_executor_1.ActionExecutor; } });
 __exportStar(require("./adapters/factory"), exports);
 var local_agent_adapter_1 = require("./adapters/local-agent-adapter");
 Object.defineProperty(exports, "LocalAgentAdapter", { enumerable: true, get: function () { return local_agent_adapter_1.LocalAgentAdapter; } });

package/dist/runtime/tool-protocol.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Tool-call protocol for hosted-model agent runs.
+ *
+ * The server orchestrates the agent loop and calls the hosted model, but it
+ * never touches the user's filesystem. When the model requests a workspace
+ * action (read/edit/run/verify/...), the server emits a `tool_call` event over
+ * the runtime event channel (SSE). The local CLI executes the tool against
+ * the real project directory and posts the result back to
+ * `POST /sessions/:sessionId/tool-results`, where the orchestrator feeds it
+ * back into the model loop.
+ */
+import type { AgentAction, AgentError, Observation } from "./agent-runtime";
+/** A tool execution request from the server to the local CLI. */
+export interface ToolCallRequest {
+    /** Unique id correlating the request with its result. */
+    callId: string;
+    sessionId: string;
+    /** `action` = workspace tool; `verify` = run the verification engine. */
+    kind: "action" | "verify";
+    /** Present when kind === "action". */
+    action?: AgentAction;
+    /** Present when kind === "verify". */
+    verify?: {
+        phase?: string;
+    };
+}
+/** The CLI's response to a tool_call, posted back to the server. */
+export interface ToolCallResultPayload {
+    callId: string;
+    success: boolean;
+    output?: unknown;
+    error?: string;
+    /** Observations to feed back into the model's context. */
+    observations?: Observation[];
+    /** Errors to record on the session (e.g. verification failures). */
+    errors?: AgentError[];
+}
+/** Default per-tool timeouts (ms). run_command is long-running by nature. */
+export declare const TOOL_CALL_TIMEOUT_MS: Record<string, number>;
+export declare function toolCallTimeoutMs(tool: string): number;

package/dist/runtime/tool-protocol.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_CALL_TIMEOUT_MS = void 0;
+exports.toolCallTimeoutMs = toolCallTimeoutMs;
+/** Default per-tool timeouts (ms). run_command is long-running by nature. */
+exports.TOOL_CALL_TIMEOUT_MS = {
+    run_command: 180_000,
+    verify: 300_000,
+    default: 120_000,
+};
+function toolCallTimeoutMs(tool) {
+    return exports.TOOL_CALL_TIMEOUT_MS[tool] ?? exports.TOOL_CALL_TIMEOUT_MS.default;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lasso-ai/cli",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "Select any part of your running app, describe a change, and let AI edit the real source code.",
   "type": "commonjs",
   "main": "dist/cli/index.js",