@lasso-ai/cli 1.5.0 → 2.0.1

package/dist/runtime/__tests__/state-machine.test.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const agent_state_machine_1 = require("../agent-state-machine");
+function makeSession(overrides = {}) {
+    return {
+        id: "sess-1",
+        phase: "verify",
+        status: "running",
+        iteration: 1,
+        userPrompt: "Add a greeting",
+        conversation: [],
+        observations: [],
+        actions: [],
+        completedActions: [],
+        errors: [],
+        project: {
+            projectId: "proj-1",
+            hasTypeScript: true,
+            hasTailwind: false,
+            hasReact: false,
+            hasNext: false,
+            hasVite: true,
+            files: [],
+        },
+        model: { provider: "anthropic", id: "claude-3-5-sonnet-20241022" },
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides,
+    };
+}
+const action = {
+    id: "act-1",
+    type: "edit_file",
+    data: { filePath: "a.ts", oldString: "a", newString: "b" },
+};
+(0, node_test_1.describe)("AgentStateMachine (review / corrective flow)", () => {
+    (0, node_test_1.it)("cannot enter recover without verification errors", () => {
+        const session = makeSession();
+        const result = agent_state_machine_1.AgentStateMachine.transition(session, "recover");
+        strict_1.default.equal(result.success, false);
+        strict_1.default.match(result.error || "", /without errors/i);
+    });
+    (0, node_test_1.it)("can enter recover once verification errors exist", () => {
+        const session = makeSession({
+            errors: [
+                {
+                    id: "err-1",
+                    type: "verification",
+                    message: "Build failed",
+                    phase: "verify",
+                    timestamp: Date.now(),
+                    recoverable: true,
+                },
+            ],
+        });
+        const result = agent_state_machine_1.AgentStateMachine.transition(session, "recover");
+        strict_1.default.equal(result.success, true);
+    });
+    (0, node_test_1.it)("complete is terminal", () => {
+        const session = makeSession({ phase: "complete", actions: [action], completedActions: [action] });
+        strict_1.default.equal(agent_state_machine_1.AgentStateMachine.canTransition(session, "execute"), false);
+        strict_1.default.equal(agent_state_machine_1.AgentStateMachine.canTransition(session, "verify"), false);
+        strict_1.default.equal(agent_state_machine_1.AgentStateMachine.canTransition(session, "recover"), false);
+    });
+    (0, node_test_1.it)("cannot complete a session with no executed actions", () => {
+        const session = makeSession({ actions: [], completedActions: [] });
+        const result = agent_state_machine_1.AgentStateMachine.transition(session, "complete");
+        strict_1.default.equal(result.success, false);
+        strict_1.default.match(result.error || "", /without executing/i);
+    });
+    (0, node_test_1.it)("cannot complete a failed session", () => {
+        const session = makeSession({ status: "failed", actions: [action], completedActions: [action] });
+        const result = agent_state_machine_1.AgentStateMachine.transition(session, "complete");
+        strict_1.default.equal(result.success, false);
+        strict_1.default.match(result.error || "", /failed session/i);
+    });
+    (0, node_test_1.it)("backend switching allowed only while running and not complete", () => {
+        strict_1.default.equal(agent_state_machine_1.AgentStateMachine.canSwitchModel(makeSession({ status: "running", phase: "execute" })), true);
+        strict_1.default.equal(agent_state_machine_1.AgentStateMachine.canSwitchModel(makeSession({ status: "running", phase: "complete" })), false);
+        strict_1.default.equal(agent_state_machine_1.AgentStateMachine.canSwitchModel(makeSession({ status: "waiting", phase: "execute" })), false);
+        strict_1.default.equal(agent_state_machine_1.AgentStateMachine.canSwitchModel(makeSession({ status: "cancelled", phase: "execute" })), false);
+    });
+    (0, node_test_1.it)("next phase after a failed verification is recover, after success is complete", () => {
+        const failed = makeSession({
+            phase: "verify",
+            completedActions: [action],
+            errors: [
+                {
+                    id: "err-1",
+                    type: "verification",
+                    message: "Build failed",
+                    phase: "verify",
+                    timestamp: Date.now(),
+                    recoverable: true,
+                },
+            ],
+        });
+        strict_1.default.equal(agent_state_machine_1.AgentStateMachine.determineNextPhase(failed, { type: "decide", goal: "verify" }), "recover");
+        const passed = makeSession({ phase: "verify", completedActions: [action], actions: [action] });
+        strict_1.default.equal(agent_state_machine_1.AgentStateMachine.determineNextPhase(passed, { type: "decide", goal: "verify" }), "complete");
+    });
+});

package/dist/runtime/__tests__/verification-engine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/__tests__/verification-engine.test.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const verification_engine_1 = require("../verification-engine");
+// Temp projects live under the server package so `npx tsc` resolves the
+// locally installed TypeScript instead of hitting the network.
+const TMP_ROOT = node_path_1.default.join(process.cwd(), ".tmp-tests");
+(0, node_test_1.describe)("VerificationEngine", () => {
+    let dir;
+    (0, node_test_1.beforeEach)(() => {
+        node_fs_1.default.mkdirSync(TMP_ROOT, { recursive: true });
+        dir = node_fs_1.default.mkdtempSync(node_path_1.default.join(TMP_ROOT, "verify-"));
+    });
+    (0, node_test_1.afterEach)(() => {
+        node_fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("skips typecheck when there is no tsconfig (inconclusive, not a failure)", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "index.js"), "console.log(1)");
+        const engine = new verification_engine_1.VerificationEngine(dir);
+        const result = await engine.verifyTypecheck("verify");
+        strict_1.default.equal(result.type, "typecheck");
+        strict_1.default.equal(result.success, true);
+        strict_1.default.equal(result.skipped, true);
+        strict_1.default.equal(result.errors.length, 0);
+        strict_1.default.match(result.observations[0].summary, /skipped/i);
+    });
+    (0, node_test_1.it)("passes typecheck for a valid project", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "tsconfig.json"), JSON.stringify({ compilerOptions: { noEmit: true, strict: true }, files: ["ok.ts"] }));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "ok.ts"), "export const x: number = 1;");
+        const engine = new verification_engine_1.VerificationEngine(dir);
+        const result = await engine.verifyTypecheck("verify");
+        strict_1.default.equal(result.type, "typecheck");
+        strict_1.default.equal(result.command, "npx tsc --noEmit");
+        strict_1.default.equal(result.skipped, undefined);
+        strict_1.default.equal(result.success, true, result.output || result.error || "");
+        strict_1.default.equal(result.errors.length, 0);
+    });
+    (0, node_test_1.it)("reports a real typecheck failure as a recoverable verification error", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "tsconfig.json"), JSON.stringify({ compilerOptions: { noEmit: true, strict: true }, files: ["bad.ts"] }));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "bad.ts"), "export const x: number = 'not a number';");
+        const engine = new verification_engine_1.VerificationEngine(dir);
+        const result = await engine.verifyTypecheck("verify");
+        strict_1.default.equal(result.success, false);
+        strict_1.default.equal(result.errors.length, 1);
+        strict_1.default.equal(result.errors[0].type, "verification");
+        strict_1.default.equal(result.errors[0].recoverable, true);
+        strict_1.default.equal(result.command, "npx tsc --noEmit");
+    });
+    (0, node_test_1.it)("skips build when package.json has no build script", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "package.json"), JSON.stringify({ name: "x", scripts: { test: "echo ok" } }));
+        const engine = new verification_engine_1.VerificationEngine(dir);
+        const result = await engine.verifyBuild("verify");
+        strict_1.default.equal(result.success, true);
+        strict_1.default.equal(result.skipped, true);
+        strict_1.default.equal(result.errors.length, 0);
+        strict_1.default.match(result.observations[0].summary, /skipped/i);
+    });
+    (0, node_test_1.it)("skips build when there is no package.json", async () => {
+        const engine = new verification_engine_1.VerificationEngine(dir);
+        const result = await engine.verifyBuild("verify");
+        strict_1.default.equal(result.success, true);
+        strict_1.default.equal(result.skipped, true);
+        strict_1.default.equal(result.errors.length, 0);
+    });
+    (0, node_test_1.it)("reports a real build failure as an error (corrective-run input)", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "package.json"), JSON.stringify({ name: "x", scripts: { build: "node -e \"console.error('boom'); process.exit(2)\"" } }));
+        const engine = new verification_engine_1.VerificationEngine(dir);
+        const result = await engine.verifyBuild("verify");
+        strict_1.default.equal(result.success, false);
+        strict_1.default.equal(result.skipped, undefined);
+        strict_1.default.equal(result.errors.length, 1);
+        strict_1.default.equal(result.errors[0].type, "verification");
+        strict_1.default.equal(result.errors[0].recoverable, true);
+        strict_1.default.equal(result.command, "npm run build");
+        strict_1.default.ok((result.output || "").includes("boom"));
+    });
+    (0, node_test_1.it)("allPassed/getErrors aggregate across results", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "package.json"), JSON.stringify({ name: "x" }));
+        const engine = new verification_engine_1.VerificationEngine(dir);
+        const results = await Promise.all([engine.verifyTypecheck("verify"), engine.verifyBuild("verify")]);
+        strict_1.default.equal(engine.allPassed(results), true);
+        strict_1.default.equal(engine.getErrors(results).length, 0);
+        strict_1.default.ok(engine.getObservations(results).length >= 2);
+    });
+});

package/dist/runtime/__tests__/workspace-guard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/__tests__/workspace-guard.test.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const workspace_guard_1 = require("../workspace-guard");
+(0, node_test_1.describe)("WorkspaceGuard", () => {
+    let dir;
+    (0, node_test_1.beforeEach)(() => {
+        dir = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), "lasso-guard-"));
+    });
+    (0, node_test_1.afterEach)(() => {
+        node_fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+    (0, node_test_1.it)("reports no changes right after capture", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "a.txt"), "hello");
+        const guard = await workspace_guard_1.WorkspaceGuard.capture(dir);
+        strict_1.default.equal(guard.fileCount, 1);
+        strict_1.default.deepEqual(guard.diff(), []);
+        await guard.dispose();
+    });
+    (0, node_test_1.it)("rejects a capture of a missing directory", async () => {
+        await strict_1.default.rejects(() => workspace_guard_1.WorkspaceGuard.capture(node_path_1.default.join(dir, "does-not-exist")));
+    });
+    (0, node_test_1.it)("diffs modified, created, and deleted files", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "a.txt"), "hello");
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "gone.txt"), "bye");
+        const guard = await workspace_guard_1.WorkspaceGuard.capture(dir);
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "a.txt"), "hello world");
+        node_fs_1.default.mkdirSync(node_path_1.default.join(dir, "sub"));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "sub", "new.txt"), "fresh");
+        node_fs_1.default.unlinkSync(node_path_1.default.join(dir, "gone.txt"));
+        const changes = guard.diff();
+        const byPath = new Map(changes.map((c) => [c.filePath, c]));
+        strict_1.default.equal(changes.length, 3);
+        const modified = byPath.get("a.txt");
+        strict_1.default.equal(modified.operation, "modified");
+        strict_1.default.equal(modified.oldContent, "hello");
+        strict_1.default.equal(modified.newContent, "hello world");
+        const created = byPath.get(node_path_1.default.join("sub", "new.txt"));
+        strict_1.default.equal(created.operation, "created");
+        strict_1.default.equal(created.newContent, "fresh");
+        const deleted = byPath.get("gone.txt");
+        strict_1.default.equal(deleted.operation, "deleted");
+        strict_1.default.equal(deleted.oldContent, "bye");
+        await guard.dispose();
+    });
+    (0, node_test_1.it)("restore() rolls the workspace back (review rejection)", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "a.txt"), "original");
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "keep.txt"), "keep me");
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "gone.txt"), "will be deleted");
+        const guard = await workspace_guard_1.WorkspaceGuard.capture(dir);
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "a.txt"), "agent edit");
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "created.txt"), "agent file");
+        node_fs_1.default.unlinkSync(node_path_1.default.join(dir, "gone.txt"));
+        strict_1.default.equal(guard.diff().length, 3);
+        await guard.restore();
+        strict_1.default.equal(node_fs_1.default.readFileSync(node_path_1.default.join(dir, "a.txt"), "utf8"), "original");
+        strict_1.default.equal(node_fs_1.default.readFileSync(node_path_1.default.join(dir, "keep.txt"), "utf8"), "keep me");
+        strict_1.default.equal(node_fs_1.default.readFileSync(node_path_1.default.join(dir, "gone.txt"), "utf8"), "will be deleted");
+        strict_1.default.ok(!node_fs_1.default.existsSync(node_path_1.default.join(dir, "created.txt")));
+        // Post-rollback the workspace matches capture again: nothing pending.
+        strict_1.default.deepEqual(guard.diff(), []);
+    });
+    (0, node_test_1.it)("ignores default ignore dirs such as node_modules and .git", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "app.ts"), "code");
+        node_fs_1.default.mkdirSync(node_path_1.default.join(dir, "node_modules"));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "node_modules", "dep.js"), "dep");
+        node_fs_1.default.mkdirSync(node_path_1.default.join(dir, ".git"));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, ".git", "HEAD"), "ref");
+        const guard = await workspace_guard_1.WorkspaceGuard.capture(dir);
+        strict_1.default.equal(guard.fileCount, 1);
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "node_modules", "dep.js"), "changed");
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, ".git", "HEAD"), "changed");
+        strict_1.default.deepEqual(guard.diff(), []);
+        await guard.dispose();
+    });
+    (0, node_test_1.it)("keeps binary files restorable but excludes them from text diffs", async () => {
+        const original = Buffer.from([0x00, 0x01, 0x02, 0x00, 0xff, 0x7f]);
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "logo.bin"), original);
+        const guard = await workspace_guard_1.WorkspaceGuard.capture(dir);
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "logo.bin"), Buffer.from([0x00, 0x99, 0x00]));
+        const changes = guard.diff();
+        strict_1.default.equal(changes.length, 1);
+        strict_1.default.equal(changes[0].operation, "modified");
+        strict_1.default.equal(changes[0].binary, true);
+        strict_1.default.equal(changes[0].oldContent, undefined);
+        await guard.restore();
+        strict_1.default.deepEqual(node_fs_1.default.readFileSync(node_path_1.default.join(dir, "logo.bin")), original);
+    });
+    (0, node_test_1.it)("restore() is single-use and dispose stays safe", async () => {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "a.txt"), "one");
+        const guard = await workspace_guard_1.WorkspaceGuard.capture(dir);
+        node_fs_1.default.writeFileSync(node_path_1.default.join(dir, "a.txt"), "two");
+        await guard.restore();
+        await guard.dispose();
+        strict_1.default.equal(node_fs_1.default.readFileSync(node_path_1.default.join(dir, "a.txt"), "utf8"), "one");
+    });
+});

package/dist/runtime/adapters/claude-code-adapter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Claude Code Adapter
+ *
+ * Adapter for the Claude Code CLI (`claude`), the Anthropic coding agent.
+ *
+ * Claude Code has its own agentic loop, so Lasso delegates the task wholesale:
+ *   claude -p <prompt> --output-format stream-json --verbose --permission-mode acceptEdits
+ *
+ * The JSONL stream (system/init, assistant, result) is 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, so nothing is applied without approval.
+ *
+ * Reference: https://docs.claude.com/en/docs/claude-code/headless
+ */
+import { LocalAgentAdapter, LocalAgentConfig, CommandSpec, EventSink } from "./local-agent-adapter";
+import { BackendCapabilities, TaskContext } from "../backend-interface";
+interface ClaudeCodeConfig extends LocalAgentConfig {
+    provider: "claude_code";
+    maxTurns?: number;
+    maxBudgetUsd?: number;
+}
+export declare class ClaudeCodeAdapter extends LocalAgentAdapter {
+    readonly provider: "claude_code";
+    constructor(config: ClaudeCodeConfig);
+    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 handleAssistant;
+    private describeToolInput;
+    private reportFileOperation;
+    protected inspectFailureText(text: string): {
+        message: string;
+        authFailure?: boolean;
+    } | null;
+}
+export {};

package/dist/runtime/adapters/claude-code-adapter.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * Claude Code Adapter
+ *
+ * Adapter for the Claude Code CLI (`claude`), the Anthropic coding agent.
+ *
+ * Claude Code has its own agentic loop, so Lasso delegates the task wholesale:
+ *   claude -p <prompt> --output-format stream-json --verbose --permission-mode acceptEdits
+ *
+ * The JSONL stream (system/init, assistant, result) is 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, so nothing is applied without approval.
+ *
+ * Reference: https://docs.claude.com/en/docs/claude-code/headless
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeCodeAdapter = void 0;
+const node_util_1 = require("node:util");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const local_agent_adapter_1 = require("./local-agent-adapter");
+const execFileAsync = (0, node_util_1.promisify)(require("node:child_process").execFile);
+const TOOL_FILE_KEYS = ["file_path", "filePath", "path", "notebook_path"];
+class ClaudeCodeAdapter extends local_agent_adapter_1.LocalAgentAdapter {
+    provider = "claude_code";
+    constructor(config) {
+        super({ ...config, type: "local_agent", provider: "claude_code" });
+    }
+    getCapabilities() {
+        return {
+            canStreamEvents: true,
+            // Operates directly on the project; WorkspaceGuard guarantees rollback before review.
+            canIsolateWorkspace: false,
+            providesStructuredDiffs: false,
+            supportsSessionContinuation: true,
+            supportsCancellation: true,
+            hasInternalLoop: true,
+            supportedFileOperations: "both",
+            canRunCommands: true,
+            authMethod: "cli_session",
+            forbiddenCommands: ["rm -rf /", "mkfs"],
+        };
+    }
+    get binary() {
+        return "claude";
+    }
+    get installInstructions() {
+        return "Install Claude Code: npm install -g @anthropic-ai/claude-code (or https://docs.claude.com/en/docs/claude-code/setup)";
+    }
+    get versionArgs() {
+        return ["--version"];
+    }
+    get supportsResume() {
+        return true;
+    }
+    async checkAuthentication() {
+        try {
+            const { stdout } = (await execFileAsync("claude", ["auth", "status"], {
+                timeout: 10000,
+                windowsHide: true,
+            }));
+            const jsonStart = stdout.indexOf("{");
+            if (jsonStart >= 0) {
+                try {
+                    const parsed = JSON.parse(stdout.slice(jsonStart));
+                    if (parsed && typeof parsed.loggedIn === "boolean") {
+                        return parsed.loggedIn
+                            ? { authenticated: true }
+                            : { authenticated: false, error: "Claude Code is not logged in.", fixInstructions: "Run 'claude' once and log in, or run 'claude auth login'." };
+                    }
+                }
+                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 Claude Code authentication: ${message}`,
+                fixInstructions: "Run 'claude' once and complete the login flow, then retry.",
+            };
+        }
+    }
+    buildCommand(context) {
+        const cfg = this.config;
+        const resumeId = this.resumeSessionId(context);
+        const sessionId = node_crypto_1.default.randomUUID();
+        const args = [
+            "-p",
+            this.buildTaskPrompt(context),
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--permission-mode",
+            cfg.permissionMode || "acceptEdits",
+        ];
+        if (this.modelId)
+            args.push("--model", this.modelId);
+        if (resumeId)
+            args.push("--resume", resumeId);
+        else
+            args.push("--session-id", sessionId);
+        if (cfg.maxTurns)
+            args.push("--max-turns", String(cfg.maxTurns));
+        if (cfg.maxBudgetUsd)
+            args.push("--max-budget-usd", String(cfg.maxBudgetUsd));
+        return { bin: "claude", args, cwd: cfg.projectPath };
+    }
+    handleLine(line, context, sink) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            return false;
+        }
+        if (typeof event.session_id === "string" && 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(`Claude Code session started${event.model ? ` (model: ${event.model})` : ""}`);
+                }
+                return true;
+            }
+            case "assistant": {
+                this.handleAssistant(event, sink);
+                return true;
+            }
+            case "result": {
+                if (event.is_error) {
+                    sink.state.failureMessage = event.result || "Claude Code reported an error";
+                    if (/credit balance|billing|quota|rate.?limit/i.test(sink.state.failureMessage)) {
+                        sink.state.authFailure = true;
+                    }
+                }
+                else if (event.subtype === "success" || !event.is_error) {
+                    sink.state.receivedTerminalSuccess = true;
+                    if (event.result)
+                        sink.state.summary = event.result;
+                }
+                return true;
+            }
+            case "stream_event": {
+                // Incremental progress; ignore bulk content, keep assistant-level info only.
+                return true;
+            }
+            default:
+                return true;
+        }
+    }
+    handleAssistant(event, sink) {
+        const content = event.message?.content || [];
+        if (event.error) {
+            const text = content.map((c) => c.text || "").filter(Boolean).join(" ");
+            sink.state.failureMessage = text || `Claude Code error: ${event.error}`;
+            if (/billing|auth|unauthorized|credit/i.test(event.error) || /credit balance|not logged in|unauthorized/i.test(sink.state.failureMessage)) {
+                sink.state.authFailure = true;
+            }
+            sink.error(sink.state.failureMessage, { recoverable: false, authFailure: sink.state.authFailure });
+            return;
+        }
+        for (const block of content) {
+            if (block.type === "text" && block.text) {
+                sink.progress(block.text);
+            }
+            else if (block.type === "tool_use" && block.name) {
+                const input = block.input || {};
+                sink.toolStarted(block.name, this.describeToolInput(block.name, input));
+                this.reportFileOperation(block.name, input, sink);
+            }
+            else if (block.type === "tool_result" && block.is_error) {
+                const msg = typeof block.content === "string" ? block.content : JSON.stringify(block.content).slice(0, 500);
+                sink.error(`Tool returned an error: ${msg}`, { recoverable: true, asEvent: true });
+            }
+        }
+    }
+    describeToolInput(name, input) {
+        switch (name) {
+            case "Bash":
+                return typeof input.command === "string" ? input.command.slice(0, 200) : undefined;
+            case "Read":
+            case "Write":
+            case "Edit":
+            case "MultiEdit":
+            case "NotebookEdit": {
+                const key = TOOL_FILE_KEYS.find((k) => typeof input[k] === "string");
+                return key ? String(input[key]) : undefined;
+            }
+            default:
+                return typeof input.description === "string" ? input.description : undefined;
+        }
+    }
+    reportFileOperation(toolName, input, sink) {
+        const key = TOOL_FILE_KEYS.find((k) => typeof input[k] === "string");
+        if (!key)
+            return;
+        const rel = this.relPath(String(input[key]));
+        // Claude's Write creates-or-overwrites; the guard diff decides the real operation.
+        if (toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit" || toolName === "NotebookEdit") {
+            sink.fileChange("modified", rel);
+        }
+    }
+    inspectFailureText(text) {
+        if (!text)
+            return null;
+        if (/authentication required|not logged in|please run ['"]?claude auth|invalid api key/i.test(text)) {
+            return {
+                message: "Claude Code authentication failed.",
+                authFailure: true,
+            };
+        }
+        if (/credit balance is too low|billing_error/i.test(text)) {
+            return { message: "Claude Code account has insufficient credit balance.", authFailure: true };
+        }
+        if (/usage limit reached|rate limit/i.test(text)) {
+            return { message: "Claude Code usage limit reached — try again later.", authFailure: true };
+        }
+        return null;
+    }
+}
+exports.ClaudeCodeAdapter = ClaudeCodeAdapter;

package/dist/runtime/adapters/codex-cli-adapter.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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
+ */
+import { LocalAgentAdapter, LocalAgentConfig, CommandSpec, EventSink } from "./local-agent-adapter";
+import { BackendCapabilities, TaskContext } from "../backend-interface";
+interface CodexConfig extends LocalAgentConfig {
+    provider: "codex_cli";
+}
+export declare class CodexCLIAdapter extends LocalAgentAdapter {
+    readonly provider: "codex_cli";
+    constructor(config: CodexConfig);
+    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 handleItemCompleted;
+    private recordFailure;
+    protected inspectFailureText(text: string): {
+        message: string;
+        authFailure?: boolean;
+    } | null;
+}
+export {};