@lasso-ai/cli 1.5.0 → 2.0.1

package/dist/runtime/adapters/codex-cli-adapter.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * Codex CLI Adapter
+ *
+ * Adapter for OpenAI's Codex CLI (`codex exec`), a local coding agent with its
+ * own agentic loop.
+ *
+ * Invocation: codex exec --json --skip-git-repo-check -s workspace-write [-m model] <prompt>
+ * (resume: codex exec resume <thread_id> --json --skip-git-repo-check <prompt>)
+ * with stdin ignored and cwd set to the project path. Output is JSONL
+ * (thread.started / item.* / turn.*) normalized into BackendEvents.
+ *
+ * File changes are not trusted from the agent's report — the orchestrator's
+ * WorkspaceGuard diffs the project after the run and restores it before review.
+ *
+ * Reference: https://github.com/openai/codex
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexCLIAdapter = void 0;
+const node_util_1 = require("node:util");
+const local_agent_adapter_1 = require("./local-agent-adapter");
+const execFileAsync = (0, node_util_1.promisify)(require("node:child_process").execFile);
+class CodexCLIAdapter extends local_agent_adapter_1.LocalAgentAdapter {
+    provider = "codex_cli";
+    constructor(config) {
+        super({ ...config, type: "local_agent", provider: "codex_cli" });
+    }
+    getCapabilities() {
+        return {
+            canStreamEvents: true,
+            canIsolateWorkspace: false,
+            providesStructuredDiffs: false,
+            supportsSessionContinuation: true,
+            supportsCancellation: true,
+            hasInternalLoop: true,
+            supportedFileOperations: "both",
+            canRunCommands: true,
+            authMethod: "cli_session",
+            forbiddenCommands: ["rm -rf /", "mkfs"],
+        };
+    }
+    get binary() {
+        return "codex";
+    }
+    get installInstructions() {
+        return "Install Codex CLI: npm install -g @openai/codex (or https://github.com/openai/codex). Then run 'codex login'.";
+    }
+    get versionArgs() {
+        return ["--version"];
+    }
+    get supportsResume() {
+        return true;
+    }
+    async checkAuthentication() {
+        try {
+            await execFileAsync("codex", ["login", "status"], { timeout: 10000, windowsHide: true });
+            return { authenticated: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                authenticated: false,
+                error: `Codex CLI is not logged in (${message.split("\n")[0]}).`,
+                fixInstructions: "Run 'codex login' and sign in with ChatGPT or an API key.",
+            };
+        }
+    }
+    buildCommand(context) {
+        const cfg = this.config;
+        const resumeId = this.resumeSessionId(context);
+        const prompt = this.buildTaskPrompt(context);
+        const args = ["exec"];
+        if (resumeId) {
+            // `resume` does not accept -s; sandbox policy goes through a config override.
+            args.push("resume", resumeId, "--json", "--skip-git-repo-check", "-c", 'sandbox_mode="workspace-write"');
+            if (this.modelId)
+                args.push("-m", this.modelId);
+        }
+        else {
+            args.push("--json", "--skip-git-repo-check", "-s", "workspace-write");
+            if (this.modelId)
+                args.push("-m", this.modelId);
+        }
+        args.push(prompt);
+        return { bin: "codex", args, cwd: cfg.projectPath };
+    }
+    handleLine(line, context, sink) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            return false;
+        }
+        switch (event.type) {
+            case "thread.started": {
+                if (event.thread_id)
+                    sink.state.sessionId = event.thread_id;
+                sink.progress(`Codex thread started${event.thread_id ? ` (${event.thread_id})` : ""}`);
+                return true;
+            }
+            case "turn.started": {
+                sink.progress("Codex turn started");
+                return true;
+            }
+            case "item.started":
+            case "item.updated": {
+                const item = event.item || {};
+                if (item.item_type === "command_execution" && item.command) {
+                    sink.toolStarted("shell", item.command.slice(0, 200));
+                }
+                else if (item.item_type === "file_change") {
+                    sink.toolStarted("file_change", undefined);
+                }
+                return true;
+            }
+            case "item.completed": {
+                this.handleItemCompleted(event.item || {}, sink);
+                return true;
+            }
+            case "error": {
+                const message = event.message || event.error?.message || "Codex reported an error";
+                this.recordFailure(sink, message);
+                return true;
+            }
+            case "turn.failed": {
+                const message = event.error?.message || "Codex turn failed";
+                this.recordFailure(sink, message);
+                return true;
+            }
+            case "turn.completed": {
+                sink.state.receivedTerminalSuccess = true;
+                return true;
+            }
+            default:
+                return true;
+        }
+    }
+    handleItemCompleted(item, sink) {
+        switch (item.item_type) {
+            case "command_execution": {
+                const success = typeof item.exit_code === "number" ? item.exit_code === 0 : item.status === "completed";
+                sink.toolCompleted("shell", success, (item.command || "").slice(0, 200));
+                if (!success && item.aggregated_output) {
+                    sink.error(`Command failed (exit ${item.exit_code ?? "?"}): ${item.aggregated_output.slice(-300)}`, { recoverable: true });
+                }
+                break;
+            }
+            case "file_change": {
+                sink.toolCompleted("file_change", true);
+                for (const change of item.changes || []) {
+                    if (!change.path)
+                        continue;
+                    const rel = this.relPath(change.path);
+                    const kind = (change.kind || "").toLowerCase();
+                    if (kind.includes("delete"))
+                        sink.fileChange("deleted", rel);
+                    else
+                        sink.fileChange("modified", rel);
+                }
+                break;
+            }
+            case "assistant_message": {
+                if (item.text) {
+                    sink.progress(item.text);
+                    sink.state.summary = item.text;
+                }
+                break;
+            }
+            case "error": {
+                const message = item.error?.message || item.message || "Codex item error";
+                this.recordFailure(sink, message);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    recordFailure(sink, message) {
+        if (!sink.state.failureMessage)
+            sink.state.failureMessage = message;
+        if (/usage limit|rate limit|quota|billing|upgrade to plus/i.test(message)) {
+            sink.state.authFailure = true;
+        }
+        // "error" and "turn.failed" often carry the same message — record once.
+        if (!sink.state.errors.some((e) => e.message === message)) {
+            sink.error(message, { recoverable: false, authFailure: sink.state.authFailure });
+        }
+    }
+    inspectFailureText(text) {
+        if (!text)
+            return null;
+        if (/not logged in|please run ['"]?codex login|authentication/i.test(text)) {
+            return { message: "Codex CLI is not authenticated.", authFailure: true };
+        }
+        if (/usage limit|upgrade to plus|quota exceeded/i.test(text)) {
+            return { message: "Codex usage limit reached — try again later or upgrade the account.", authFailure: true };
+        }
+        return null;
+    }
+}
+exports.CodexCLIAdapter = CodexCLIAdapter;

package/dist/runtime/adapters/cursor-adapter.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Cursor Adapter
+ *
+ * Adapter for the Cursor Agent CLI (binary: `cursor-agent`), a local coding
+ * agent with its own agentic loop.
+ *
+ * Invocation: cursor-agent -p --output-format stream-json --trust [--model m]
+ * [--resume <chatId>] <prompt>, cwd set to the project path.
+ *
+ * Stream-JSON events (system/init, assistant, tool_call, result) are normalized
+ * into BackendEvents. Success requires Cursor's terminal result event with
+ * is_error=false AND a zero exit code; on failure Cursor exits non-zero, often
+ * without a terminal event (stderr carries the error).
+ *
+ * File changes are not trusted from the agent's report — the orchestrator's
+ * WorkspaceGuard diffs the project after the run and restores it before review.
+ *
+ * Reference: https://cursor.com/docs/cli/reference/output-format
+ */
+import { LocalAgentAdapter, LocalAgentConfig, CommandSpec, EventSink } from "./local-agent-adapter";
+import { BackendCapabilities, TaskContext } from "../backend-interface";
+interface CursorConfig extends LocalAgentConfig {
+    provider: "cursor";
+}
+export declare class CursorAdapter extends LocalAgentAdapter {
+    readonly provider: "cursor";
+    constructor(config: CursorConfig);
+    getCapabilities(): BackendCapabilities;
+    protected get binary(): string;
+    protected get installInstructions(): string;
+    protected get versionArgs(): string[];
+    protected get supportsResume(): boolean;
+    protected checkAuthentication(): Promise<{
+        authenticated: boolean;
+        error?: string;
+        fixInstructions?: string;
+    }>;
+    protected buildCommand(context: TaskContext): CommandSpec;
+    protected handleLine(line: string, context: TaskContext, sink: EventSink): boolean;
+    private handleToolCall;
+    private describeArgs;
+    protected inspectFailureText(text: string): {
+        message: string;
+        authFailure?: boolean;
+    } | null;
+}
+export {};

package/dist/runtime/adapters/cursor-adapter.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * Cursor Adapter
+ *
+ * Adapter for the Cursor Agent CLI (binary: `cursor-agent`), a local coding
+ * agent with its own agentic loop.
+ *
+ * Invocation: cursor-agent -p --output-format stream-json --trust [--model m]
+ * [--resume <chatId>] <prompt>, cwd set to the project path.
+ *
+ * Stream-JSON events (system/init, assistant, tool_call, result) are normalized
+ * into BackendEvents. Success requires Cursor's terminal result event with
+ * is_error=false AND a zero exit code; on failure Cursor exits non-zero, often
+ * without a terminal event (stderr carries the error).
+ *
+ * File changes are not trusted from the agent's report — the orchestrator's
+ * WorkspaceGuard diffs the project after the run and restores it before review.
+ *
+ * Reference: https://cursor.com/docs/cli/reference/output-format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorAdapter = void 0;
+const node_util_1 = require("node:util");
+const local_agent_adapter_1 = require("./local-agent-adapter");
+const execFileAsync = (0, node_util_1.promisify)(require("node:child_process").execFile);
+const TOOL_KIND_MAP = {
+    readToolCall: "read",
+    editToolCall: "edit",
+    writeToolCall: "write",
+    deleteToolCall: "delete",
+    shellToolCall: "shell",
+    grepToolCall: "grep",
+    globToolCall: "glob",
+    lsToolCall: "ls",
+    todoToolCall: "todo",
+};
+const FILE_TOOLS = new Set(["edit", "write", "delete"]);
+class CursorAdapter extends local_agent_adapter_1.LocalAgentAdapter {
+    provider = "cursor";
+    constructor(config) {
+        super({ ...config, type: "local_agent", provider: "cursor" });
+    }
+    getCapabilities() {
+        return {
+            canStreamEvents: true,
+            canIsolateWorkspace: false,
+            providesStructuredDiffs: false,
+            supportsSessionContinuation: true,
+            supportsCancellation: true,
+            hasInternalLoop: true,
+            supportedFileOperations: "both",
+            canRunCommands: true,
+            authMethod: "cli_session",
+            forbiddenCommands: ["rm -rf /", "mkfs"],
+        };
+    }
+    get binary() {
+        return "cursor-agent";
+    }
+    get installInstructions() {
+        return "Install the Cursor Agent CLI: curl https://cursor.com/install -fsS | bash, then run 'cursor-agent login'.";
+    }
+    get versionArgs() {
+        return ["-v"];
+    }
+    get supportsResume() {
+        return true;
+    }
+    async checkAuthentication() {
+        try {
+            const { stdout } = (await execFileAsync("cursor-agent", ["status", "--format", "json"], {
+                timeout: 10000,
+                windowsHide: true,
+            }));
+            const jsonStart = stdout.indexOf("{");
+            if (jsonStart >= 0) {
+                try {
+                    const parsed = JSON.parse(stdout.slice(jsonStart));
+                    if (parsed && typeof parsed.isAuthenticated === "boolean") {
+                        return parsed.isAuthenticated
+                            ? { authenticated: true }
+                            : {
+                                authenticated: false,
+                                error: "Cursor Agent is not authenticated.",
+                                fixInstructions: "Run 'cursor-agent login' to authenticate with Cursor.",
+                            };
+                    }
+                }
+                catch {
+                    // Fall through to exit-code based result.
+                }
+            }
+            return { authenticated: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                authenticated: false,
+                error: `Could not verify Cursor Agent authentication: ${message.split("\n")[0]}`,
+                fixInstructions: "Run 'cursor-agent login' to authenticate with Cursor.",
+            };
+        }
+    }
+    buildCommand(context) {
+        const resumeId = this.resumeSessionId(context);
+        const args = ["-p", "--output-format", "stream-json", "--trust"];
+        if (this.modelId)
+            args.push("--model", this.modelId);
+        if (resumeId)
+            args.push("--resume", resumeId);
+        args.push(this.buildTaskPrompt(context));
+        return { bin: "cursor-agent", args, cwd: this.config.projectPath };
+    }
+    handleLine(line, context, sink) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            return false;
+        }
+        if (event.session_id)
+            sink.state.sessionId = event.session_id;
+        switch (event.type) {
+            case "system": {
+                if (event.subtype === "init") {
+                    sink.state.sessionId = event.session_id || sink.state.sessionId;
+                    sink.progress(`Cursor session started${event.model ? ` (model: ${event.model})` : ""}`);
+                }
+                return true;
+            }
+            case "assistant": {
+                const text = (event.message?.content || [])
+                    .filter((c) => c.type === "text" && c.text)
+                    .map((c) => c.text)
+                    .join("\n");
+                if (text)
+                    sink.progress(text);
+                return true;
+            }
+            case "tool_call": {
+                this.handleToolCall(event, sink);
+                return true;
+            }
+            case "result": {
+                if (event.is_error || event.subtype !== "success") {
+                    sink.state.failureMessage = event.result || `Cursor result subtype: ${event.subtype || "unknown"}`;
+                    sink.error(sink.state.failureMessage, { recoverable: false });
+                }
+                else {
+                    sink.state.receivedTerminalSuccess = true;
+                    if (event.result)
+                        sink.state.summary = event.result;
+                }
+                return true;
+            }
+            default:
+                return true;
+        }
+    }
+    handleToolCall(event, sink) {
+        const toolCall = event.tool_call || {};
+        const kindKey = Object.keys(toolCall)[0];
+        if (!kindKey)
+            return;
+        const toolName = TOOL_KIND_MAP[kindKey] || kindKey;
+        const call = toolCall[kindKey] || {};
+        const args = call.args || {};
+        if (event.subtype === "started") {
+            sink.toolStarted(toolName, this.describeArgs(toolName, args));
+            return;
+        }
+        if (event.subtype === "completed") {
+            const hasError = Boolean(call.result && call.result.error);
+            sink.toolCompleted(toolName, !hasError, this.describeArgs(toolName, args));
+            if (hasError && call.result?.error) {
+                const err = call.result.error;
+                sink.error(`${toolName} failed: ${err.errorMessage || JSON.stringify(call.result.error).slice(0, 300)}`, { recoverable: true });
+            }
+            if (FILE_TOOLS.has(toolName) && typeof args.path === "string") {
+                const rel = this.relPath(args.path);
+                // Guard diff decides create vs modify; only delete is unambiguous here.
+                if (toolName === "delete")
+                    sink.fileChange("deleted", rel);
+                else
+                    sink.fileChange("modified", rel);
+            }
+        }
+    }
+    describeArgs(toolName, args) {
+        if (typeof args.command === "string")
+            return args.command.slice(0, 200);
+        if (typeof args.path === "string")
+            return String(args.path);
+        if (typeof args.pattern === "string")
+            return String(args.pattern);
+        if (typeof args.query === "string")
+            return String(args.query);
+        void toolName;
+        return undefined;
+    }
+    inspectFailureText(text) {
+        if (!text)
+            return null;
+        if (/authentication required|please run ['"]?(cursor-agent |agent )?login|not logged in|unauthorized/i.test(text)) {
+            return { message: "Cursor Agent authentication failed.", authFailure: true };
+        }
+        if (/rate limit|usage limit|quota exceeded/i.test(text)) {
+            return { message: "Cursor usage limit or quota exceeded.", authFailure: true };
+        }
+        return null;
+    }
+}
+exports.CursorAdapter = CursorAdapter;

package/dist/runtime/adapters/factory.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Local coding agent factory.
+ *
+ * Creates the adapter for a local_agent backend config. Adapters are loaded
+ * lazily so consumers that never run local agents (e.g. hosted-only server
+ * paths) don't pay for parsing the adapter modules.
+ */
+import { BackendConfig, IBackend, BackendCapabilities } from "../backend-interface";
+export declare const LOCAL_AGENT_PROVIDERS: readonly ["claude_code", "opencode", "codex_cli", "cursor"];
+export type LocalAgentProvider = (typeof LOCAL_AGENT_PROVIDERS)[number];
+export declare function isLocalAgentProvider(provider: string): provider is LocalAgentProvider;
+export declare function isLocalAgentConfig(config: BackendConfig | undefined | null): config is BackendConfig & {
+    type: "local_agent";
+};
+export declare function createLocalAgentBackend(config: BackendConfig & {
+    type: "local_agent";
+}): Promise<IBackend>;
+/** Capabilities for a local agent provider (all share the local-agent profile). */
+export declare function localAgentCapabilities(_provider: string): BackendCapabilities;

package/dist/runtime/adapters/factory.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Local coding agent factory.
+ *
+ * Creates the adapter for a local_agent backend config. Adapters are loaded
+ * lazily so consumers that never run local agents (e.g. hosted-only server
+ * paths) don't pay for parsing the adapter modules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCAL_AGENT_PROVIDERS = void 0;
+exports.isLocalAgentProvider = isLocalAgentProvider;
+exports.isLocalAgentConfig = isLocalAgentConfig;
+exports.createLocalAgentBackend = createLocalAgentBackend;
+exports.localAgentCapabilities = localAgentCapabilities;
+const backend_interface_1 = require("../backend-interface");
+exports.LOCAL_AGENT_PROVIDERS = ["claude_code", "opencode", "codex_cli", "cursor"];
+function isLocalAgentProvider(provider) {
+    return exports.LOCAL_AGENT_PROVIDERS.includes(provider);
+}
+function isLocalAgentConfig(config) {
+    return Boolean(config && config.type === "local_agent" && isLocalAgentProvider(config.provider));
+}
+async function createLocalAgentBackend(config) {
+    switch (config.provider) {
+        case "claude_code": {
+            const { ClaudeCodeAdapter } = await import("./claude-code-adapter.js");
+            return new ClaudeCodeAdapter(config);
+        }
+        case "opencode": {
+            const { OpenCodeAdapter } = await import("./opencode-adapter.js");
+            return new OpenCodeAdapter(config);
+        }
+        case "codex_cli": {
+            const { CodexCLIAdapter } = await import("./codex-cli-adapter.js");
+            return new CodexCLIAdapter(config);
+        }
+        case "cursor": {
+            const { CursorAdapter } = await import("./cursor-adapter.js");
+            return new CursorAdapter(config);
+        }
+        default:
+            throw new Error(`Unsupported local agent: ${config.provider}`);
+    }
+}
+/** Capabilities for a local agent provider (all share the local-agent profile). */
+function localAgentCapabilities(_provider) {
+    return { ...backend_interface_1.DEFAULT_LOCAL_CAPABILITIES };
+}

package/dist/runtime/adapters/local-agent-adapter.d.ts

@@ -0,0 +1,143 @@
+/**
+ * LocalAgentAdapter - Shared base for external coding agent backends.
+ *
+ * Claude Code, OpenCode, Codex CLI, and Cursor are full coding agents with
+ * their own internal loops. Lasso does NOT wrap them in a competing model
+ * loop: it delegates a task, streams their native structured output,
+ * normalizes it into BackendEvents, and lets the orchestrator own
+ * diff review, verification, and session state.
+ *
+ * Every adapter in this package:
+ *   - invokes the agent's official non-interactive CLI with structured output
+ *     (JSON/JSONL), never human-readable terminal scraping,
+ *   - checks installation and authentication separately from execution,
+ *   - relies on WorkspaceGuard (owned by the orchestrator) for rollback, so
+ *     no agent's changes ever persist before user approval.
+ */
+import { ChildProcess } from "node:child_process";
+import { IBackend, BackendType, BackendProvider, BackendCapabilities, TaskContext, BackendEvent, BackendEvent as Event, BackendResult } from "../backend-interface";
+import { AgentError } from "../agent-runtime";
+export interface LocalAgentConfig {
+    type: "local_agent";
+    provider: BackendProvider;
+    modelId?: string;
+    projectPath: string;
+    /** Permission/approval mode passed to the agent CLI, if supported */
+    permissionMode?: string;
+    /** Provider-specific knobs */
+    providerConfig?: Record<string, unknown>;
+}
+export interface CommandSpec {
+    bin: string;
+    args: string[];
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+}
+export type AgentRunState = {
+    /** External agent session/thread id (for continuation) */
+    sessionId?: string;
+    /** Final assistant summary, when the agent provides one */
+    summary?: string;
+    /** Errors reported by the agent while running */
+    errors: AgentError[];
+    /** Normalized conversation (user prompt + assistant summary) */
+    conversation: Array<{
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp: number;
+    }>;
+    /** Tools executed during the run (for progress + observations) */
+    tools: Array<{
+        name: string;
+        success?: boolean;
+        detail?: string;
+    }>;
+    /** True only when the agent's OWN terminal success signal was observed */
+    receivedTerminalSuccess: boolean;
+    /** Failure message when the run failed */
+    failureMessage?: string;
+    /** Set when the failure is an authentication/authorization problem */
+    authFailure?: boolean;
+    /** Set when the run was cancelled by Lasso */
+    cancelled: boolean;
+};
+export declare function newRunState(): AgentRunState;
+/** Sink used by adapters while parsing native events → normalized BackendEvents */
+export declare class EventSink {
+    private readonly taskId;
+    private readonly emitRaw;
+    readonly state: AgentRunState;
+    constructor(taskId: string, emitRaw: (event: Event) => void, state: AgentRunState);
+    emit(type: Event["type"], data?: Record<string, unknown>): void;
+    progress(message: string): void;
+    toolStarted(name: string, detail?: string): void;
+    toolCompleted(name: string, success?: boolean, detail?: string): void;
+    fileChange(operation: "created" | "modified" | "deleted", filePath: string): void;
+    error(message: string, options?: {
+        recoverable?: boolean;
+        authFailure?: boolean;
+        asEvent?: boolean;
+    }): void;
+}
+export declare abstract class LocalAgentAdapter implements IBackend {
+    readonly id: string;
+    readonly type: BackendType;
+    abstract readonly provider: BackendProvider;
+    readonly modelId: string;
+    protected readonly config: LocalAgentConfig;
+    protected process?: ChildProcess;
+    private currentTaskId?;
+    private killTimer?;
+    constructor(config: LocalAgentConfig);
+    abstract getCapabilities(): BackendCapabilities;
+    /** Executable name resolved via PATH (e.g. "claude", "codex", "cursor-agent") */
+    protected abstract get binary(): string;
+    /** Human-readable install documentation URL or command */
+    protected abstract get installInstructions(): string;
+    /** Command used to probe installation + version */
+    protected abstract get versionArgs(): string[];
+    /** Check authentication using the agent's own session/credentials */
+    protected abstract checkAuthentication(): Promise<{
+        authenticated: boolean;
+        error?: string;
+        fixInstructions?: string;
+    }>;
+    /** Build the CLI invocation for this task */
+    protected abstract buildCommand(context: TaskContext): CommandSpec;
+    /**
+     * Parse one line of the agent's structured output.
+     * Return false when the line could not be parsed (used for diagnostics).
+     */
+    protected abstract handleLine(line: string, context: TaskContext, sink: EventSink): boolean;
+    /**
+     * Optional: extra stderr/stdout text inspection for failures
+     * (e.g. "Authentication required" messages).
+     */
+    protected inspectFailureText(text: string): {
+        message: string;
+        authFailure?: boolean;
+    } | null;
+    /** Whether this adapter can resume its own external session */
+    protected get supportsResume(): boolean;
+    checkAvailability(): Promise<{
+        available: boolean;
+        installed: boolean;
+        authenticated: boolean;
+        version?: string;
+        error?: string;
+        fixInstructions?: string;
+    }>;
+    executeTask(context: TaskContext, onEvent: (event: BackendEvent) => void, signal?: AbortSignal): Promise<BackendResult>;
+    cancelTask(taskId: string): Promise<void>;
+    switchBackend(newBackend: IBackend, context: TaskContext): Promise<{
+        transferableContext: Record<string, unknown>;
+        lostContext: string[];
+    }>;
+    /** Build the shared task prompt (project context + continuation context). */
+    protected buildTaskPrompt(context: TaskContext): string;
+    /** Resume reference from Lasso's canonical session state (if any). */
+    protected resumeSessionId(context: TaskContext): string | undefined;
+    /** Convert an absolute path reported by the agent to a project-relative one. */
+    protected relPath(absoluteOrRelative: string): string;
+    private buildResult;
+}