clearclaw 0.4.0 → 0.6.0

package/dist/orchestrator.js

@@ -1,8 +1,14 @@
 import fs from "node:fs";
 import path from "node:path";
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
 import log from "./logger.js";
 import { saveFile } from "./files.js";
-import { formatToolStatusLine, formatToolCallSummary, formatPermissionPrompt, timeAgo } from "./format.js";
+import { formatToolStatusLine, formatToolCallSummary, formatPermissionPrompt, formatTodoList, timeAgo } from "./format.js";
+import { permissionHandlers, displayHandledTools } from "./tool-handlers.js";
+function isTask(ctx) {
+    return "prompt" in ctx;
+}
 const MODE_OPTIONS = [
     { label: "Default", value: "default" },
     { label: "Accept Edits", value: "acceptEdits" },
@@ -12,25 +18,21 @@ const MODE_OPTIONS = [
 export class Orchestrator {
     channel;
     engine;
-    workspaceStore;
-    permissionMode;
-    defaultPromptPath;
-    filesPath;
+    config;
     chats = new Map();
+    tasks = new Map();
     constructor(opts) {
         this.channel = opts.channel;
         this.engine = opts.engine;
-        this.workspaceStore = opts.workspaceStore;
-        this.permissionMode = opts.permissionMode;
-        this.defaultPromptPath = opts.defaultPromptPath;
-        this.filesPath = opts.filesPath;
+        this.config = opts.config;
     }
     chat(chatId) {
         let s = this.chats.get(chatId);
         if (!s) {
             s = {
                 busy: false, abort: null, permissionMode: null, stats: null, lastStatusText: null,
-                toolCallHandle: null,
+                toolCallHandle: null, todoHandle: null,
+                messageQueue: [], debounceTimer: null,
             };
             this.chats.set(chatId, s);
         }
@@ -38,7 +40,7 @@ export class Orchestrator {
     }
     async start() {
         this.channel.on("message", (msg) => {
-            this.handleMessage(msg).catch((err) => {
+            this.routeMessage(msg).catch((err) => {
                 log.error({ err }, "[orchestrator] unhandled message error");
             });
         });
@@ -54,13 +56,191 @@ export class Orchestrator {
     async stop() {
         await this.channel.disconnect();
     }
-    async handleMessage(msg) {
+    /** Effective behavior: tasks→assistant, workspace→explicit setting or home→assistant / project→relay. */
+    effectiveBehavior(ctx) {
+        if (isTask(ctx))
+            return "assistant";
+        if (ctx.behavior !== undefined)
+            return ctx.behavior;
+        return ctx.cwd === path.dirname(this.config.defaultPromptPath) ? "assistant" : "relay";
+    }
+    /** Enqueue a message and drain — immediately for relay, debounced for assistant/task. */
+    enqueueMessage(msg, ctx, state) {
+        state.messageQueue.push(msg);
+        if (state.busy)
+            return;
+        if (this.effectiveBehavior(ctx) === "assistant") {
+            if (state.debounceTimer)
+                clearTimeout(state.debounceTimer);
+            this.scheduleDebounce(msg.chatId);
+        }
+        else {
+            this.processQueuedMessages(msg.chatId).catch((err) => {
+                log.error({ err }, "[orchestrator] drain error");
+            });
+        }
+    }
+    scheduleDebounce(chatId) {
+        const state = this.chat(chatId);
+        state.debounceTimer = setTimeout(() => {
+            state.debounceTimer = null;
+            this.processQueuedMessages(chatId).catch((err) => {
+                log.error({ err }, "[orchestrator] drain error");
+            });
+        }, 1000);
+    }
+    async processQueuedMessages(chatId) {
+        const state = this.chat(chatId);
+        if (state.messageQueue.length === 0 || state.busy)
+            return;
+        const ctx = this.tasks.get(chatId) ?? this.config.workspaceByChat(chatId);
+        if (!ctx)
+            return;
+        const messages = [...state.messageQueue];
+        state.messageQueue = [];
+        try {
+            await this.executeTurn(chatId, messages, ctx, state);
+        }
+        catch (err) {
+            log.error({ err }, "[fatal]");
+            await this.channel.sendMessage(chatId, `Internal error: ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
+            return;
+        }
+        // Post-turn drain: new messages may have arrived while the turn was running
+        if (state.messageQueue.length > 0) {
+            if (this.effectiveBehavior(ctx) === "assistant") {
+                this.scheduleDebounce(chatId);
+            }
+            else {
+                this.processQueuedMessages(chatId).catch((err) => {
+                    log.error({ err }, "[orchestrator] drain error");
+                });
+            }
+        }
+    }
+    async executeTurn(chatId, messages, ctx, state) {
+        const task = isTask(ctx) ? ctx : undefined;
+        const ws = isTask(ctx) ? undefined : ctx;
+        state.busy = true;
+        const abort = new AbortController();
+        state.abort = abort;
+        const behavior = this.effectiveBehavior(ctx);
+        const turnState = { staySilent: false, replyToMessageId: null };
+        const sessionId = task ? task.sessionId : ws.current_session_id;
+        const cwd = task ? task.cwd : ws.cwd;
+        const logPrefix = task ? "[task-turn]" : "[turn]";
+        log.info("%s start session=%s msgs=%d cwd=%s", logPrefix, sessionId ?? "new", messages.length, cwd);
+        await this.channel.setTyping(chatId, true);
+        const isHomeWorkspace = ws && ws.cwd === path.dirname(this.config.defaultPromptPath);
+        const appendSystemPrompt = task
+            ? task.prompt
+            : (isHomeWorkspace ? undefined : this.readDefaultPrompt());
+        const prompt = buildPrompt(messages);
+        // Save attachments for workspace turns
+        const allAttachments = messages.flatMap((m) => m.attachments ?? []);
+        if (ws && allAttachments.length) {
+            const results = await Promise.allSettled(allAttachments.map((att) => saveFile(att, ws.name, this.config.filesPath)));
+            for (const r of results) {
+                if (r.status === "rejected")
+                    log.warn({ err: r.reason }, "[turn] failed to save attachment");
+            }
+            const saved = results.filter((r) => r.status === "fulfilled").length;
+            if (saved > 0)
+                log.info("[turn] saved %d/%d attachment(s) for workspace %s", saved, allAttachments.length, ws.name);
+        }
+        const mcpServer = createSdkMcpServer({
+            name: "clearclaw",
+            tools: this.buildMcpTools(chatId, behavior, turnState),
+        });
+        try {
+            for await (const event of this.engine.runTurn({
+                sessionId,
+                cwd,
+                prompt,
+                attachments: ws && allAttachments.length > 0 ? allAttachments : undefined,
+                permissionMode: state.permissionMode ?? (behavior === "assistant" ? "bypassPermissions" : this.config.permissionMode),
+                appendSystemPrompt,
+                mcpServers: { clearclaw: mcpServer },
+                signal: abort.signal,
+                onPermissionRequest: (req) => this.handlePermission(req, chatId),
+            })) {
+                // Handle done event inline — task vs workspace need different session storage
+                if (event.type === "done") {
+                    log.info("%s done session=%s", logPrefix, event.sessionId);
+                    if (task) {
+                        const currentTask = this.tasks.get(chatId);
+                        if (currentTask)
+                            currentTask.sessionId = event.sessionId;
+                    }
+                    else {
+                        this.config.setSession(ws.name, event.sessionId);
+                    }
+                    if (event.stats)
+                        state.stats = event.stats;
+                    if (behavior === "relay" && state.toolCallHandle && event.stats) {
+                        const summary = formatToolCallSummary(event.stats.toolCalls);
+                        if (summary) {
+                            try {
+                                await this.channel.editMessage(chatId, state.toolCallHandle, summary);
+                            }
+                            catch { /* */ }
+                        }
+                    }
+                    state.toolCallHandle = null;
+                    state.todoHandle = null;
+                    await this.updateStatusMessage(chatId, state);
+                    break;
+                }
+                await this.routeEngineEvent(chatId, event, ws?.name ?? "", behavior, turnState);
+            }
+        }
+        finally {
+            const cancelled = abort.signal.aborted;
+            state.busy = false;
+            state.abort = null;
+            if (!turnState.staySilent) {
+                await this.channel.setTyping(chatId, false);
+            }
+            // Task cancel already sent "Setup cancelled" from /cancel handler
+            if (cancelled && !task) {
+                await this.channel.sendMessage(chatId, "Turn cancelled.");
+            }
+        }
+    }
+    async routeMessage(msg) {
         try {
             log.info(`[msg] ${msg.user.name} (${msg.user.id}) ${msg.text.slice(0, 80)}`);
             const state = this.chat(msg.chatId);
+            // /cancel — abort running turn or clear active task (must come before task routing)
+            if (msg.text === "/cancel") {
+                const task = this.tasks.get(msg.chatId);
+                if (task) {
+                    this.tasks.delete(msg.chatId);
+                    if (state.abort)
+                        state.abort.abort();
+                    log.info("[cmd] task cancelled for chat %s", msg.chatId);
+                    await this.channel.sendMessage(msg.chatId, "Setup cancelled.");
+                    return;
+                }
+                if (state.abort) {
+                    state.abort.abort();
+                    log.info("[cmd] turn cancelled");
+                }
+                else {
+                    await this.channel.sendMessage(msg.chatId, "Nothing to cancel.");
+                }
+                return;
+            }
+            // Task routing — takes priority over workspace and all other commands
+            const existingTask = this.tasks.get(msg.chatId);
+            if (existingTask) {
+                this.enqueueMessage(msg, existingTask, state);
+                return;
+            }
+            const ws = this.config.workspaceByChat(msg.chatId);
             // /mode — switch permission mode (works even during active turns)
             if (msg.text === "/mode") {
-                const currentMode = state.permissionMode ?? this.permissionMode;
+                const currentMode = state.permissionMode ?? this.config.permissionMode;
                 const buttons = [
                     MODE_OPTIONS.slice(0, 2).map((opt) => ({
                         label: opt.value === currentMode ? `✓ ${opt.label}` : opt.label,
@@ -81,12 +261,11 @@ export class Orchestrator {
             }
             // /new — reset session
             if (msg.text === "/new") {
-                const ws = this.workspaceStore.byChat(msg.chatId);
                 if (!ws) {
                     await this.channel.sendMessage(msg.chatId, "No workspace linked to this group.");
                     return;
                 }
-                this.workspaceStore.clearSession(ws.name);
+                this.config.clearSession(ws.name);
                 state.permissionMode = null;
                 state.stats = null;
                 await this.updateStatusMessage(msg.chatId, state);
@@ -100,7 +279,6 @@ export class Orchestrator {
                     await this.channel.sendMessage(msg.chatId, "A turn is in progress. Wait for it to finish before switching sessions.");
                     return;
                 }
-                const ws = this.workspaceStore.byChat(msg.chatId);
                 if (!ws) {
                     await this.channel.sendMessage(msg.chatId, "No workspace linked to this group.");
                     return;
@@ -132,123 +310,100 @@ export class Orchestrator {
                 });
                 const resp = await this.channel.sendInteractive(msg.chatId, `Pick a session to resume:\n\n${listing}`, buttons);
                 if (resp.value) {
-                    this.workspaceStore.setSession(ws.name, resp.value);
+                    this.config.setSession(ws.name, resp.value);
                     const picked = stripped.find((s) => s.sessionId === resp.value);
                     await this.channel.sendMessage(msg.chatId, `Resumed session: ${picked?.summary ?? resp.value}`);
                     log.info("[cmd] resumed session %s for workspace %s", resp.value, ws.name);
                 }
                 return;
             }
-            // /cancel — abort the running turn
-            if (msg.text === "/cancel") {
-                if (state.abort) {
-                    state.abort.abort();
-                    log.info("[cmd] turn cancelled");
+            // /behavior — switch workspace behavior (assistant or relay)
+            if (msg.text === "/behavior") {
+                if (!ws) {
+                    await this.channel.sendMessage(msg.chatId, "No workspace linked to this chat.");
+                    return;
                 }
-                else {
-                    await this.channel.sendMessage(msg.chatId, "Nothing to cancel.");
+                const current = this.effectiveBehavior(ws);
+                const resp = await this.channel.sendInteractive(msg.chatId, `Current behavior: ${current}`, [
+                    [
+                        { label: current === "assistant" ? "✓ Assistant" : "Assistant", value: "assistant" },
+                        { label: current === "relay" ? "✓ Relay" : "Relay", value: "relay" },
+                    ],
+                ]);
+                if (resp.value === "assistant" || resp.value === "relay") {
+                    this.config.setBehavior(ws.name, resp.value);
+                    await this.updateStatusMessage(msg.chatId, this.chat(msg.chatId));
+                    log.info("[cmd] workspace %s behavior → %s", ws.name, resp.value);
                 }
                 return;
             }
-            // Workspace lookup — guard all turn logic below
-            const ws = this.workspaceStore.byChat(msg.chatId);
             if (!ws) {
-                log.info("[msg] no workspace for chat %s", msg.chatId);
-                await this.channel.sendMessage(msg.chatId, "No workspace linked to this group.");
-                return;
-            }
-            // Reject during active turn (per-chat)
-            if (state.busy) {
-                log.info("[msg] rejected (busy)");
-                await this.channel.sendMessage(msg.chatId, "Still working on the previous message...");
-                return;
-            }
-            state.busy = true;
-            const abort = new AbortController();
-            state.abort = abort;
-            log.info(`[turn] start session=${ws.current_session_id ?? "new"} cwd=${ws.cwd}`);
-            await this.channel.setTyping(msg.chatId, true);
-            // Append default workspace CLAUDE.md to non-default workspace sessions
-            const isDefaultWorkspace = ws.cwd === path.dirname(this.defaultPromptPath);
-            const appendSystemPrompt = isDefaultWorkspace ? undefined : this.readDefaultPrompt();
-            // In group workspaces, prepend sender identity so the engine knows who's talking
-            const sender = msg.user.handle ? `${msg.user.name} (@${msg.user.handle})` : msg.user.name;
-            const prompt = isDefaultWorkspace ? msg.text : `[${sender}]: ${msg.text}`;
-            // Save attachments to disk for the audit log (failures must not block the turn)
-            if (msg.attachments?.length) {
-                const results = await Promise.allSettled(msg.attachments.map((att) => saveFile(att, ws.name, this.filesPath)));
-                for (const r of results) {
-                    if (r.status === "rejected")
-                        log.warn({ err: r.reason }, "[turn] failed to save attachment");
+                if (this.config.isAuthorized(msg.user.id)) {
+                    const newTask = {
+                        sessionId: null,
+                        cwd: path.dirname(this.config.defaultPromptPath),
+                        prompt: [
+                            "THIS IS A TASK SESSION — not a regular conversation.",
+                            "Do NOT follow the 'Every Session' startup routine. Do NOT read MEMORY.md or daily notes. Do NOT greet the user.",
+                            "Your only job: help set up a workspace for this chat. Use the onboarding skill.",
+                        ].join("\n"),
+                    };
+                    this.tasks.set(msg.chatId, newTask);
+                    log.info("[task] onboarding started for chat %s", msg.chatId);
+                    this.enqueueMessage(msg, newTask, state);
                 }
-                const saved = results.filter((r) => r.status === "fulfilled").length;
-                if (saved > 0)
-                    log.info("[turn] saved %d/%d attachment(s) for workspace %s", saved, msg.attachments.length, ws.name);
-            }
-            try {
-                for await (const event of this.engine.runTurn({
-                    sessionId: ws.current_session_id,
-                    cwd: ws.cwd,
-                    prompt,
-                    attachments: msg.attachments,
-                    permissionMode: state.permissionMode ?? this.permissionMode,
-                    appendSystemPrompt,
-                    signal: abort.signal,
-                    onPermissionRequest: async (req) => {
-                        log.info(`[perm] ${req.toolName}`);
-                        try {
-                            const promptText = formatPermissionPrompt(req.toolName, req.input, req.description);
-                            const resp = await this.channel.sendInteractive(msg.chatId, promptText, [
-                                [
-                                    { label: "👍 Allow", value: "allow" },
-                                    { label: "👎 Deny", value: "deny" },
-                                ],
-                                [
-                                    { label: "📝 Deny + Note", value: "deny", requestText: true },
-                                ],
-                            ]);
-                            log.info(`[perm] ${req.toolName} → ${resp.value || "timeout"}${resp.text ? ` "${resp.text}"` : ""}`);
-                            return {
-                                decision: resp.value === "allow" ? "allow" : "deny",
-                                message: resp.text,
-                            };
-                        }
-                        catch (err) {
-                            log.warn({ err }, "[perm] failed to send prompt for %s, auto-denying", req.toolName);
-                            return {
-                                decision: "deny",
-                                message: "Permission prompt could not be delivered to chat — denied automatically.",
-                            };
-                        }
-                    },
-                })) {
-                    await this.routeEngineEvent(msg.chatId, event, ws.name);
-                }
-            }
-            finally {
-                const cancelled = abort.signal.aborted;
-                state.busy = false;
-                state.abort = null;
-                await this.channel.setTyping(msg.chatId, false);
-                if (cancelled) {
-                    await this.channel.sendMessage(msg.chatId, "Turn cancelled.");
+                else {
+                    log.info("[msg] no workspace for chat %s", msg.chatId);
+                    await this.channel.sendMessage(msg.chatId, "No workspace linked to this chat.");
                 }
+                return;
             }
+            this.enqueueMessage(msg, ws, state);
         }
         catch (err) {
             log.error({ err }, "[fatal]");
             await this.channel.sendMessage(msg.chatId, `Internal error: ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
         }
     }
-    async routeEngineEvent(chatId, event, workspaceName) {
+    async routeEngineEvent(chatId, event, workspaceName, behavior, turnState) {
         const state = this.chat(chatId);
         try {
             switch (event.type) {
                 case "text":
-                    await this.channel.sendMessage(chatId, event.text);
+                    if (turnState.staySilent)
+                        break;
+                    await this.channel.sendMessage(chatId, event.text, {
+                        replyToMessageId: turnState.replyToMessageId ?? undefined,
+                    });
                     break;
                 case "tool_use": {
-                    // Rolling message: each tool_use replaces the single message's content
+                    // In assistant behavior, all tool status is suppressed (no rolling status, no plan mode notifications)
+                    if (behavior === "assistant")
+                        break;
+                    // Relay behavior: existing display logic
+                    if (event.toolName === "TodoWrite") {
+                        const text = formatTodoList(event.input);
+                        if (state.todoHandle) {
+                            try {
+                                await this.channel.editMessage(chatId, state.todoHandle, text);
+                            }
+                            catch {
+                                const handles = await this.channel.sendMessage(chatId, text, { consumeTyping: false });
+                                state.todoHandle = handles[0];
+                            }
+                        }
+                        else {
+                            const handles = await this.channel.sendMessage(chatId, text, { consumeTyping: false });
+                            state.todoHandle = handles[0];
+                        }
+                        break;
+                    }
+                    if (event.toolName === "EnterPlanMode") {
+                        await this.channel.sendMessage(chatId, "📋 Planning");
+                        break;
+                    }
+                    if (displayHandledTools.has(event.toolName))
+                        break;
                     const line = formatToolStatusLine(event.toolName, event.input);
                     if (state.toolCallHandle) {
                         try {
@@ -266,7 +421,6 @@ export class Orchestrator {
                     break;
                 }
                 case "tool_result":
-                    // All tool results suppressed — Claude summarizes in its text response
                     break;
                 case "rate_limit": {
                     const resetMsg = event.resetsAt
@@ -276,26 +430,9 @@ export class Orchestrator {
                     await this.channel.sendMessage(chatId, `⚠️ Rate limited (${event.status}).${resetMsg}`);
                     break;
                 }
-                case "done": {
-                    // Persist state first — channel calls below are best-effort
-                    log.info(`[turn] done session=${event.sessionId}`);
-                    this.workspaceStore.setSession(workspaceName, event.sessionId);
-                    if (event.stats)
-                        state.stats = event.stats;
-                    // Best-effort: update tool summary and status message
-                    if (state.toolCallHandle && event.stats) {
-                        const summary = formatToolCallSummary(event.stats.toolCalls);
-                        if (summary) {
-                            try {
-                                await this.channel.editMessage(chatId, state.toolCallHandle, summary);
-                            }
-                            catch { /* edit failed, leave as-is */ }
-                        }
-                    }
-                    state.toolCallHandle = null;
-                    await this.updateStatusMessage(chatId, state);
+                case "done":
+                    // Handled inline in executeTurn (task vs workspace need different session storage)
                     break;
-                }
                 case "error":
                     log.error(`[turn] error: ${event.message}`);
                     await this.channel.sendMessage(chatId, `Error: ${event.message}`);
@@ -308,8 +445,114 @@ export class Orchestrator {
             log.warn({ err }, "[route] failed to relay %s event to channel", event.type);
         }
     }
+    buildMcpTools(chatId, behavior, turnState) {
+        const tools = [
+            tool("send_file", "Send a file or image to the current chat conversation", {
+                file_path: z.string().optional().describe("Absolute path to the file to send"),
+                data: z.string().optional().describe("Base64-encoded file data (alternative to file_path)"),
+                filename: z.string().optional().describe("Filename (required when using data, optional with file_path)"),
+                caption: z.string().optional().describe("Optional caption to accompany the file"),
+            }, async (args) => {
+                if (!args.file_path && !args.data)
+                    throw new Error("Either file_path or data must be provided");
+                const buffer = args.file_path
+                    ? await fs.promises.readFile(args.file_path)
+                    : Buffer.from(args.data, "base64");
+                const name = args.filename ?? path.basename(args.file_path ?? "file");
+                await this.channel.sendFile(chatId, buffer, name, { caption: args.caption });
+                return { content: [{ type: "text", text: `Sent ${name} to chat` }] };
+            }),
+        ];
+        // Task tools — only available during task turns
+        if (this.tasks.has(chatId)) {
+            tools.push(tool("workspace_create", "Create a new workspace and link it to the current chat", {
+                name: z.string().describe("Workspace name (unique, e.g. 'myproject')"),
+                cwd: z.string().describe("Absolute path to the workspace directory"),
+                behavior: z.enum(["assistant", "relay"]).optional()
+                    .describe("Workspace behavior mode"),
+            }, async (args) => {
+                if (this.config.workspaceByName(args.name)) {
+                    throw new Error(`Workspace "${args.name}" already exists. Choose a different name.`);
+                }
+                fs.mkdirSync(args.cwd, { recursive: true });
+                this.config.upsertWorkspace({
+                    name: args.name,
+                    cwd: args.cwd,
+                    chat_id: chatId,
+                    current_session_id: null,
+                    behavior: args.behavior,
+                });
+                log.info("[tool] workspace_create: %s → %s (chat %s)", args.name, args.cwd, chatId);
+                return { content: [{ type: "text", text: `Workspace "${args.name}" created at ${args.cwd}, linked to this chat.` }] };
+            }), tool("task_complete", "Signal that the current task is complete", {
+                message: z.string().optional().describe("Summary of what was accomplished"),
+            }, async (args) => {
+                this.tasks.delete(chatId);
+                log.info("[tool] task_complete: chat %s — %s", chatId, args.message ?? "done");
+                return { content: [{ type: "text", text: "Task completed." }] };
+            }));
+        }
+        if (behavior === "assistant") {
+            tools.push(tool("stay_silent", "Stay silent — do not send any text response for this turn", {}, async () => {
+                turnState.staySilent = true;
+                await this.channel.setTyping(chatId, false); // suppress typing indicator immediately
+                return { content: [{ type: "text", text: "Silent turn" }] };
+            }), tool("react", "React to a specific message with an emoji", {
+                message: z.string().describe("Platform message ID from [msg:N] tag"),
+                emoji: z.string().describe("Single emoji character"),
+            }, async (args) => {
+                await this.channel.reactToMessage(chatId, args.message, args.emoji);
+                return { content: [{ type: "text", text: `Reacted to ${args.message} with ${args.emoji}` }] };
+            }), tool("reply_to", "Thread the text response as a reply to a specific message", {
+                message: z.string().describe("Platform message ID from [msg:N] tag"),
+            }, async (args) => {
+                turnState.replyToMessageId = args.message;
+                return { content: [{ type: "text", text: `Will reply to message ${args.message}` }] };
+            }));
+        }
+        return tools;
+    }
+    async handlePermission(req, chatId) {
+        // Always auto-allow ClearClaw's own MCP tools
+        if (req.toolName.startsWith("mcp__clearclaw__")) {
+            log.info(`[perm] ${req.toolName} → auto-allow`);
+            return { decision: "allow" };
+        }
+        log.info(`[perm] ${req.toolName}`);
+        // Custom tool handler
+        const handler = permissionHandlers.get(req.toolName);
+        if (handler) {
+            const result = handler(req.input, req.description);
+            if (result === null) {
+                log.info(`[perm] ${req.toolName} → auto-allow (handler)`);
+                await this.channel.sendMessage(chatId, "📋 Entering plan mode");
+                return { decision: "allow" };
+            }
+            try {
+                const resp = await this.channel.sendInteractive(chatId, result.text, result.buttons);
+                log.info(`[perm] ${req.toolName} → ${resp.value || "timeout"}${resp.text ? ` "${resp.text}"` : ""}`);
+                return result.mapResponse(resp);
+            }
+            catch (err) {
+                log.warn({ err }, "[perm] failed to send prompt for %s, auto-denying", req.toolName);
+                return { decision: "deny", message: "Permission prompt could not be delivered to chat — denied automatically." };
+            }
+        }
+        try {
+            const resp = await this.channel.sendInteractive(chatId, formatPermissionPrompt(req.toolName, req.input, req.description), [
+                [{ label: "👍 Allow", value: "allow" }, { label: "👎 Deny", value: "deny" }],
+                [{ label: "📝 Deny + Note", value: "deny", requestText: true }],
+            ]);
+            log.info(`[perm] ${req.toolName} → ${resp.value || "timeout"}${resp.text ? ` "${resp.text}"` : ""}`);
+            return { decision: resp.value === "allow" ? "allow" : "deny", message: resp.text };
+        }
+        catch (err) {
+            log.warn({ err }, "[perm] failed to send prompt for %s, auto-denying", req.toolName);
+            return { decision: "deny", message: "Permission prompt could not be delivered to chat — denied automatically." };
+        }
+    }
     async updateStatusMessage(chatId, state) {
-        const mode = state.permissionMode ?? this.permissionMode;
+        const mode = state.permissionMode ?? this.config.permissionMode;
         const modeLabel = MODE_OPTIONS.find((o) => o.value === mode)?.label ?? mode;
         let text;
         if (state.stats) {
@@ -329,7 +572,7 @@ export class Orchestrator {
     /** Read default workspace CLAUDE.md to append to non-default workspace sessions. */
     readDefaultPrompt() {
         try {
-            const content = fs.readFileSync(this.defaultPromptPath, "utf-8").trim();
+            const content = fs.readFileSync(this.config.defaultPromptPath, "utf-8").trim();
             return content || undefined;
         }
         catch {
@@ -341,4 +584,33 @@ export class Orchestrator {
 function formatModelName(modelId) {
     return modelId.replace(/^claude-/, "").replace(/-\d{8}$/, "");
 }
+/** Format reply context as a bracketed prefix line for the LLM prompt. */
+function formatReplyLine(replyTo) {
+    if (!replyTo)
+        return "";
+    const parts = [];
+    if (replyTo.senderName)
+        parts.push(replyTo.senderName);
+    parts.push(`msg:${replyTo.messageId}`);
+    if (replyTo.mediaType)
+        parts.push(`[${replyTo.mediaType}]`);
+    if (replyTo.text)
+        parts.push(`"${replyTo.text}"`);
+    return `[Replying to ${parts.join(" ")}]\n`;
+}
+/**
+ * Build the turn prompt: `[msg:N] sender: text`, one line per message.
+ * Works for both single-message (relay) and batched (assistant) turns.
+ */
+function buildPrompt(messages) {
+    return messages.map((msg) => {
+        const sender = msg.user.handle ? `${msg.user.name} (@${msg.user.handle})` : msg.user.name;
+        const msgIdPrefix = msg.messageId ? `[msg:${msg.messageId}] ` : "";
+        const replyLine = formatReplyLine(msg.replyTo);
+        const attachmentNote = msg.attachments?.length
+            ? ` [${msg.attachments.length} attachment(s)]`
+            : "";
+        return `${replyLine}${msgIdPrefix}${sender}: ${msg.text}${attachmentNote}`;
+    }).join("\n");
+}
 //# sourceMappingURL=orchestrator.js.map