clearclaw 0.6.0 → 0.7.0

package/dist/channel/slack.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import type { Channel, Button, ButtonResponse, SendFileOpts, SendMessageOpts, UserInfo } from "../types.js";
+import type { Channel, Button, ButtonResponse, SendFileOpts, MessageOpts, UserInfo } from "../types.js";
 export declare class SlackChannel extends EventEmitter implements Channel {
     name: string;
     private static readonly EMOJI_TO_SLACK;
@@ -16,9 +16,9 @@ export declare class SlackChannel extends EventEmitter implements Channel {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     ownsId(chatId: string): boolean;
-    sendMessage(chatId: string, text: string, opts?: SendMessageOpts): Promise<string[]>;
+    sendMessage(chatId: string, text: string, opts?: MessageOpts): Promise<string[]>;
     sendInteractive(chatId: string, text: string, buttons: Button[][]): Promise<ButtonResponse>;
-    editMessage(chatId: string, handle: string, text: string): Promise<void>;
+    editMessage(chatId: string, handle: string, text: string, opts?: MessageOpts): Promise<void>;
     deleteMessage(chatId: string, handle: string): Promise<void>;
     pinMessage(chatId: string, handle: string): Promise<void>;
     unpinAllMessages(chatId: string): Promise<void>;

package/dist/channel/slack.js

@@ -168,36 +168,60 @@ export class SlackChannel extends EventEmitter {
         const chunks = splitMessage(text);
         const handles = [];
         const threadTs = opts?.replyToMessageId;
+        const plain = opts?.format === "plain";
+        /** Post a chunk, with mrkdwn blocks unless plain format requested. */
+        const postChunk = async (chunk, extra = {}) => {
+            if (plain) {
+                const r = await this.app.client.chat.postMessage({ channel, text: chunk, ...extra });
+                return r.ts;
+            }
+            const blocks = mrkdwnBlocks(chunk);
+            try {
+                const r = await this.app.client.chat.postMessage({ channel, text: chunk, blocks, ...extra });
+                return r.ts;
+            }
+            catch {
+                log.warn("[channel] postMessage failed with mrkdwn, retrying as plain text");
+                const r = await this.app.client.chat.postMessage({ channel, text: chunk, ...extra });
+                return r.ts;
+            }
+        };
         // Consume typing placeholder only when not posting as a thread reply
         const consumeTyping = !threadTs && opts?.consumeTyping !== false;
         const typingTs = consumeTyping ? this.typingMessageTs.get(chatId) : undefined;
         if (typingTs && chunks.length > 0) {
             this.typingMessageTs.delete(chatId);
             const firstChunk = chunks.shift();
-            const blocks = mrkdwnBlocks(firstChunk);
-            try {
-                await this.app.client.chat.update({
-                    channel, ts: typingTs, text: firstChunk, blocks,
-                });
-                handles.push(typingTs);
+            if (plain) {
+                try {
+                    await this.app.client.chat.update({ channel, ts: typingTs, text: firstChunk });
+                    handles.push(typingTs);
+                }
+                catch {
+                    const ts = await postChunk(firstChunk);
+                    if (ts)
+                        handles.push(ts);
+                }
             }
-            catch {
-                // Placeholder was deleted externally — fall back to posting
-                const result = await this.app.client.chat.postMessage({
-                    channel, text: firstChunk, blocks,
-                });
-                if (result.ts)
-                    handles.push(result.ts);
+            else {
+                const blocks = mrkdwnBlocks(firstChunk);
+                try {
+                    await this.app.client.chat.update({
+                        channel, ts: typingTs, text: firstChunk, blocks,
+                    });
+                    handles.push(typingTs);
+                }
+                catch {
+                    const ts = await postChunk(firstChunk);
+                    if (ts)
+                        handles.push(ts);
+                }
             }
         }
         for (const chunk of chunks) {
-            const blocks = mrkdwnBlocks(chunk);
-            const result = await this.app.client.chat.postMessage({
-                channel, text: chunk, blocks,
-                ...(threadTs && { thread_ts: threadTs }),
-            });
-            if (result.ts)
-                handles.push(result.ts);
+            const ts = await postChunk(chunk, threadTs ? { thread_ts: threadTs } : {});
+            if (ts)
+                handles.push(ts);
         }
         return handles;
     }
@@ -304,14 +328,23 @@ export class SlackChannel extends EventEmitter {
         }
         return { value: pressed.value };
     }
-    async editMessage(chatId, handle, text) {
+    async editMessage(chatId, handle, text, opts) {
         const chunk = splitMessage(text)[0];
-        await this.app.client.chat.update({
-            channel: this.slackId(chatId),
-            ts: handle,
-            text: chunk,
-            blocks: mrkdwnBlocks(chunk),
-        });
+        if (opts?.format === "plain") {
+            await this.app.client.chat.update({
+                channel: this.slackId(chatId),
+                ts: handle,
+                text: chunk,
+            });
+        }
+        else {
+            await this.app.client.chat.update({
+                channel: this.slackId(chatId),
+                ts: handle,
+                text: chunk,
+                blocks: mrkdwnBlocks(chunk),
+            });
+        }
     }
     async deleteMessage(chatId, handle) {
         await this.app.client.chat.delete({

package/dist/channel/telegram.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import type { Channel, Button, ButtonResponse, SendFileOpts, SendMessageOpts, UserInfo } from "../types.js";
+import type { Channel, Button, ButtonResponse, SendFileOpts, MessageOpts, UserInfo } from "../types.js";
 export declare class TelegramChannel extends EventEmitter implements Channel {
     name: string;
     private bot;
@@ -14,9 +14,9 @@ export declare class TelegramChannel extends EventEmitter implements Channel {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     ownsId(chatId: string): boolean;
-    sendMessage(chatId: string, text: string, opts?: SendMessageOpts): Promise<string[]>;
+    sendMessage(chatId: string, text: string, opts?: MessageOpts): Promise<string[]>;
     sendInteractive(chatId: string, text: string, buttons: Button[][]): Promise<ButtonResponse>;
-    editMessage(chatId: string, handle: string, text: string): Promise<void>;
+    editMessage(chatId: string, handle: string, text: string, opts?: MessageOpts): Promise<void>;
     deleteMessage(chatId: string, handle: string): Promise<void>;
     pinMessage(chatId: string, handle: string): Promise<void>;
     unpinAllMessages(chatId: string): Promise<void>;

package/dist/channel/telegram.js

@@ -110,24 +110,31 @@ export class TelegramChannel extends EventEmitter {
         const numId = this.numericId(chatId);
         const chunks = splitMessage(text);
         const handles = [];
+        const plain = opts?.format === "plain";
         let firstChunk = true;
         for (const chunk of chunks) {
             const replyParams = firstChunk && opts?.replyToMessageId
                 ? { reply_parameters: { message_id: Number(opts.replyToMessageId) } }
                 : {};
-            const rendered = telegramifyMarkdown(chunk, "escape");
-            try {
-                const sent = await this.bot.api.sendMessage(numId, rendered, {
-                    parse_mode: "MarkdownV2",
-                    ...replyParams,
-                });
-                handles.push(String(sent.message_id));
-            }
-            catch (err) {
-                log.warn("[channel] sendMessage failed with MarkdownV2, retrying as plain text");
+            if (plain) {
                 const sent = await this.bot.api.sendMessage(numId, chunk, replyParams);
                 handles.push(String(sent.message_id));
             }
+            else {
+                const rendered = telegramifyMarkdown(chunk, "escape");
+                try {
+                    const sent = await this.bot.api.sendMessage(numId, rendered, {
+                        parse_mode: "MarkdownV2",
+                        ...replyParams,
+                    });
+                    handles.push(String(sent.message_id));
+                }
+                catch (err) {
+                    log.warn("[channel] sendMessage failed with MarkdownV2, retrying as plain text");
+                    const sent = await this.bot.api.sendMessage(numId, chunk, replyParams);
+                    handles.push(String(sent.message_id));
+                }
+            }
             firstChunk = false;
         }
         return handles;
@@ -212,9 +219,20 @@ export class TelegramChannel extends EventEmitter {
         }
         return { value: pressed.value };
     }
-    async editMessage(chatId, handle, text) {
+    async editMessage(chatId, handle, text, opts) {
         const numId = this.numericId(chatId);
-        await this.bot.api.editMessageText(numId, Number(handle), text);
+        if (opts?.format === "plain") {
+            await this.bot.api.editMessageText(numId, Number(handle), text);
+        }
+        else {
+            const rendered = telegramifyMarkdown(text, "escape");
+            try {
+                await this.bot.api.editMessageText(numId, Number(handle), rendered, { parse_mode: "MarkdownV2" });
+            }
+            catch {
+                await this.bot.api.editMessageText(numId, Number(handle), text);
+            }
+        }
     }
     async deleteMessage(chatId, handle) {
         const numId = this.numericId(chatId);

package/dist/config.d.ts

@@ -21,6 +21,11 @@ export interface PendingPairing {
     chatId: string;
     expiresAt: number;
 }
+export interface EngineEntry {
+    name: string;
+    default?: boolean;
+    path: string;
+}
 export declare function resolveDataDir(): string;
 /**
  * Unified config: env var resolution + persistent store backed by config.json.
@@ -33,20 +38,26 @@ export declare function resolveDataDir(): string;
  */
 export declare class Config {
     channel?: ChannelConfig;
+    engines: Record<string, EngineEntry>;
+    defaultEngine: string;
     permissionMode: PermissionMode;
     private envUserIds;
-    readonly defaultPromptPath: string;
+    readonly homeWorkspacePath: string;
     readonly filesPath: string;
     readonly logPath: string;
+    readonly instructionsDir: string;
+    readonly frameworkPromptDir: string;
     private readonly dataDir;
     private readonly filePath;
     constructor();
     /** Resolve channel + env vars. Throws if no channel config found. */
     resolve(): this;
+    private readRaw;
     private read;
     private write;
     getChannel(): ChannelConfig | undefined;
     setChannel(config: ChannelConfig): void;
+    setEngines(engines: EngineEntry[]): void;
     hasUser(userId: string): boolean;
     addUser(user: AuthorizedUser): void;
     listUsers(): AuthorizedUser[];
@@ -61,8 +72,5 @@ export declare class Config {
     setSession(name: string, sessionId: string): void;
     clearSession(name: string): void;
     setBehavior(name: string, behavior: "assistant" | "relay"): void;
-    ensureDefaultWorkspace(chatId: string): void;
-    /** Copy bundled skills from the repo's skills/ directory to the home workspace's .claude/skills/. */
-    syncSkills(): void;
-    approveUser(userId: string, userName: string, chatId: string): void;
+    approveUser(userId: string, userName: string): void;
 }

package/dist/config.js

@@ -28,19 +28,25 @@ export function resolveDataDir() {
 export class Config {
     // Resolved settings — populated by resolve()
     channel;
+    engines;
+    defaultEngine; // derived: name of the engine with default: true
     permissionMode = "default";
     envUserIds = new Set();
     // Derived paths
-    defaultPromptPath;
+    homeWorkspacePath;
     filesPath;
     logPath;
+    instructionsDir;
+    frameworkPromptDir;
     dataDir = resolveDataDir();
     filePath;
     constructor() {
         this.filePath = path.join(this.dataDir, "config.json");
-        this.defaultPromptPath = path.join(this.dataDir, "workspace", "CLAUDE.md");
+        this.homeWorkspacePath = path.join(this.dataDir, "workspace");
         this.filesPath = path.join(this.dataDir, "files");
         this.logPath = path.join(this.dataDir, "clearclaw.log");
+        this.instructionsDir = path.join(this.dataDir, "workspace", "instructions");
+        this.frameworkPromptDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "prompts");
     }
     /** Resolve channel + env vars. Throws if no channel config found. */
     resolve() {
@@ -70,26 +76,40 @@ export class Config {
             throw new Error(`PERMISSION_MODE must be one of: ${valid.join(", ")}`);
         }
         this.permissionMode = pm;
+        const data = this.read();
+        if (!data.engines?.length) {
+            throw new Error("No engines configured. Run `clearclaw setup`.");
+        }
+        this.engines = Object.fromEntries(data.engines.map((e) => [e.name, e]));
+        const defaultEntry = data.engines.find((e) => e.default);
+        if (!defaultEntry) {
+            throw new Error("No default engine configured. Run `clearclaw setup`.");
+        }
+        this.defaultEngine = defaultEntry.name;
         return this;
     }
     // --- File I/O (internal) ---
-    read() {
-        if (!fs.existsSync(this.filePath)) {
-            return { authorizedUsers: [], pendingPairings: [], workspaces: [] };
-        }
+    readRaw() {
+        if (!fs.existsSync(this.filePath))
+            return {};
         try {
-            const raw = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
-            return {
-                channel: raw.channel,
-                authorizedUsers: raw.authorizedUsers ?? [],
-                pendingPairings: raw.pendingPairings ?? [],
-                workspaces: raw.workspaces ?? [],
-            };
+            return JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
         }
         catch {
-            return { authorizedUsers: [], pendingPairings: [], workspaces: [] };
+            return {};
         }
     }
+    read() {
+        const raw = this.readRaw();
+        return {
+            ...raw,
+            channel: raw.channel,
+            engines: raw.engines,
+            authorizedUsers: (raw.authorizedUsers ?? []),
+            pendingPairings: (raw.pendingPairings ?? []),
+            workspaces: (raw.workspaces ?? []),
+        };
+    }
     write(data) {
         fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
     }
@@ -102,6 +122,12 @@ export class Config {
         data.channel = config;
         this.write(data);
     }
+    // --- Engines ---
+    setEngines(engines) {
+        const data = this.read();
+        data.engines = engines;
+        this.write(data);
+    }
     // --- Authorized users ---
     hasUser(userId) {
         return this.read().authorizedUsers.some((u) => u.id === userId);
@@ -199,26 +225,8 @@ export class Config {
         }
     }
     // --- Approval ---
-    ensureDefaultWorkspace(chatId) {
-        if (this.workspaceByChat(chatId) || this.workspaceByName("default"))
-            return;
-        const defaultCwd = path.join(this.dataDir, "workspace");
-        fs.mkdirSync(defaultCwd, { recursive: true });
-        this.upsertWorkspace({ name: "default", cwd: defaultCwd, chat_id: chatId, current_session_id: null });
-        this.syncSkills();
-    }
-    /** Copy bundled skills from the repo's skills/ directory to the home workspace's .claude/skills/. */
-    syncSkills() {
-        const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-        const srcSkills = path.join(pkgRoot, "skills");
-        if (!fs.existsSync(srcSkills))
-            return;
-        const destSkills = path.join(this.dataDir, "workspace", ".claude", "skills");
-        fs.cpSync(srcSkills, destSkills, { recursive: true, force: true });
-    }
-    approveUser(userId, userName, chatId) {
+    approveUser(userId, userName) {
         this.addUser({ id: userId, name: userName, approvedAt: Date.now() });
-        this.ensureDefaultWorkspace(chatId);
     }
 }
 //# sourceMappingURL=config.js.map

package/dist/engine/acp.d.ts

@@ -0,0 +1,9 @@
+import type { SpawnConfig } from "./registry.js";
+import type { Engine, EngineEvent, RunTurnOpts, SessionInfo } from "../types.js";
+export declare class AcpEngine implements Engine {
+    readonly name: string;
+    private readonly spawnConfig;
+    constructor(name: string, spawnConfig: SpawnConfig);
+    runTurn(opts: RunTurnOpts): AsyncIterable<EngineEvent>;
+    listSessions(_cwd: string): Promise<SessionInfo[]>;
+}

package/dist/engine/acp.js

@@ -0,0 +1,247 @@
+import { spawn } from "node:child_process";
+import { Readable, Writable } from "node:stream";
+import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
+import log from "../logger.js";
+import { AsyncQueue } from "./async-queue.js";
+export class AcpEngine {
+    name;
+    spawnConfig;
+    constructor(name, spawnConfig) {
+        this.name = name;
+        this.spawnConfig = spawnConfig;
+    }
+    async *runTurn(opts) {
+        const { sessionId, cwd, prompt: textPrompt, attachments, permissionMode, onPermissionRequest, signal, } = opts;
+        let proc;
+        const queue = new AsyncQueue();
+        const toolCalls = {};
+        // tool_call events carry content that requestPermission lacks — cache by ID
+        const pendingTools = new Map();
+        try {
+            proc = spawnAgent(this.spawnConfig);
+            // Log stderr for debugging
+            proc.stderr?.on("data", (chunk) => {
+                log.debug("[acp:%s] %s", this.name, chunk.toString().trim());
+            });
+            // If the process dies unexpectedly, close the queue
+            proc.on("exit", (code) => {
+                log.info("[acp:%s] process exited with code %d", this.name, code ?? -1);
+                queue.close();
+            });
+            // Build Client — sessionUpdate pushes to queue after session setup
+            let live = false;
+            const client = {
+                requestPermission: async (params) => {
+                    return handlePermission(params, permissionMode, onPermissionRequest, pendingTools);
+                },
+                sessionUpdate: async (notification) => {
+                    if (!live)
+                        return; // Suppress replay events from loadSession
+                    const event = mapSessionUpdate(notification, toolCalls, pendingTools);
+                    if (event)
+                        queue.push(event);
+                },
+            };
+            // Create ACP connection over ndjson stdio
+            const stream = ndJsonStream(Writable.toWeb(proc.stdin), Readable.toWeb(proc.stdout));
+            const conn = new ClientSideConnection((_agent) => client, stream);
+            // Initialize and read agent capabilities
+            const initResponse = await conn.initialize({
+                protocolVersion: PROTOCOL_VERSION,
+                clientInfo: { name: "clearclaw", version: "0.4.0" },
+                clientCapabilities: {},
+            });
+            const supportsImages = initResponse.agentCapabilities?.promptCapabilities?.image ?? false;
+            // Create or resume session
+            let acpSessionId;
+            if (sessionId) {
+                await conn.loadSession({ sessionId, cwd, mcpServers: [] });
+                acpSessionId = sessionId;
+            }
+            else {
+                const newSession = await conn.newSession({ cwd, mcpServers: [] });
+                acpSessionId = newSession.sessionId;
+            }
+            // Now start accepting live events
+            live = true;
+            // Wire cancellation
+            const onAbort = () => {
+                conn.cancel({ sessionId: acpSessionId }).catch(() => { });
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            // Build prompt content blocks: text + any image attachments
+            const promptBlocks = [
+                { type: "text", text: textPrompt },
+            ];
+            const imageAttachments = attachments?.filter((a) => a.mimeType.startsWith("image/")) ?? [];
+            if (imageAttachments.length > 0) {
+                if (supportsImages) {
+                    for (const att of imageAttachments) {
+                        promptBlocks.push({ type: "image", data: att.buffer.toString("base64"), mimeType: att.mimeType });
+                    }
+                }
+                else {
+                    log.warn("[acp:%s] dropping %d image attachment(s) — agent does not support images", this.name, imageAttachments.length);
+                }
+            }
+            // Send prompt — resolves when turn completes
+            const promptResponse = conn.prompt({
+                sessionId: acpSessionId,
+                prompt: promptBlocks,
+            });
+            // When prompt completes, push done event and close queue
+            promptResponse
+                .then(() => {
+                queue.push({
+                    type: "done",
+                    sessionId: acpSessionId,
+                    stats: { model: null, contextUsed: 0, contextWindow: 0, toolCalls },
+                });
+                queue.close();
+            })
+                .catch((err) => {
+                queue.push({
+                    type: "error",
+                    message: err instanceof Error ? err.message : String(err),
+                });
+                queue.close();
+            });
+            // Yield events as they arrive
+            yield* queue;
+            // Cleanup
+            signal?.removeEventListener("abort", onAbort);
+        }
+        catch (err) {
+            if (!(err instanceof Error && err.name === "AbortError")) {
+                yield {
+                    type: "error",
+                    message: err instanceof Error ? err.message : String(err),
+                };
+            }
+            queue.close();
+        }
+        finally {
+            if (proc && !proc.killed) {
+                proc.kill();
+            }
+        }
+    }
+    async listSessions(_cwd) {
+        // Fast follow: spawn agent process and call conn.listSessions()
+        return [];
+    }
+}
+// --- Helpers ---
+function spawnAgent(config) {
+    const proc = spawn(config.command, config.args, {
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    proc.on("error", (err) => {
+        log.error({ err }, "[acp] failed to spawn %s", config.command);
+    });
+    if (!proc.stdin || !proc.stdout) {
+        throw new Error(`Failed to spawn ${config.command} — stdin/stdout not available`);
+    }
+    return proc;
+}
+function mapSessionUpdate(notification, toolCalls, pendingTools) {
+    const update = notification.update;
+    switch (update.sessionUpdate) {
+        case "agent_message_chunk": {
+            const content = update.content;
+            if (content.type === "text") {
+                return { type: "text_chunk", text: content.text };
+            }
+            return null;
+        }
+        case "tool_call": {
+            const kind = update.kind ?? "tool";
+            toolCalls[kind] = (toolCalls[kind] ?? 0) + 1;
+            const tool = acpToolCall(update.title, update.toolCallId, kind, update.locations, update.content);
+            pendingTools.set(update.toolCallId, tool);
+            return { type: "tool_use", tool };
+        }
+        case "tool_call_update":
+            return null;
+        default:
+            return null;
+    }
+}
+/** Map ACP tool call fields to ToolCall. */
+function acpToolCall(title, toolCallId, kind, locations, content) {
+    const toolName = title;
+    const toolUseId = toolCallId;
+    const paths = locations?.map((l) => l.line ? `${l.path}:${l.line}` : l.path);
+    switch (kind) {
+        case "edit": {
+            const diff = findDiff(content);
+            return {
+                action: "edit", toolName, toolUseId,
+                path: diff?.path ?? paths?.[0] ?? "",
+                before: diff?.oldText ?? "",
+                after: diff?.newText ?? "",
+            };
+        }
+        case "write": {
+            const diff = findDiff(content);
+            return {
+                action: "write", toolName, toolUseId,
+                path: diff?.path ?? paths?.[0] ?? "",
+                content: diff?.newText ?? "",
+            };
+        }
+        case "read":
+            return { action: "read", toolName, toolUseId, paths: paths ?? [] };
+        case "execute":
+            return { action: "execute", toolName, toolUseId, command: title };
+        case "search":
+            return { action: "search", toolName, toolUseId, pattern: title, paths };
+        case "fetch":
+            return { action: "fetch", toolName, toolUseId, url: title };
+        default: {
+            const detail = findTextContent(content);
+            return { action: kind, toolName, toolUseId, paths, detail };
+        }
+    }
+}
+/** Find the first diff content block from ACP tool call content. */
+function findDiff(content) {
+    const entry = content?.find((c) => c.type === "diff");
+    return entry?.type === "diff" ? entry : undefined;
+}
+/** Extract text from the first content block. */
+function findTextContent(content) {
+    const entry = content?.find((c) => c.type === "content");
+    if (entry?.type === "content" && entry.content.type === "text")
+        return entry.content.text;
+    return undefined;
+}
+async function handlePermission(params, permissionMode, onPermissionRequest, pendingTools) {
+    const allowOption = params.options.find((o) => o.kind === "allow_once");
+    const rejectOption = params.options.find((o) => o.kind === "reject_once");
+    // Auto-approve in bypass mode
+    if (permissionMode === "bypassPermissions" || permissionMode === "dontAsk") {
+        return {
+            outcome: allowOption
+                ? { outcome: "selected", optionId: allowOption.optionId }
+                : { outcome: "cancelled" },
+        };
+    }
+    // Use cached tool_call data (has content/locations) over the sparse permission request
+    const toolCall = params.toolCall;
+    const tool = pendingTools.get(toolCall.toolCallId)
+        ?? acpToolCall(toolCall.title ?? "Unknown tool", toolCall.toolCallId, toolCall.kind ?? "other", toolCall.locations, toolCall.content);
+    const resp = await onPermissionRequest(tool);
+    if (resp.decision === "allow" && allowOption) {
+        return {
+            outcome: { outcome: "selected", optionId: allowOption.optionId },
+        };
+    }
+    if (rejectOption) {
+        return {
+            outcome: { outcome: "selected", optionId: rejectOption.optionId },
+        };
+    }
+    return { outcome: { outcome: "cancelled" } };
+}
+//# sourceMappingURL=acp.js.map

package/dist/engine/async-queue.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Bridges callback-driven event producers to AsyncIterable consumers.
+ *
+ * Used by AcpEngine to convert ACP's sessionUpdate callbacks into
+ * the AsyncIterable<EngineEvent> that ClearClaw's Engine interface requires.
+ */
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private buffer;
+    private waiting;
+    private closed;
+    push(value: T): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}