clearclaw 0.5.0 → 0.6.1

package/dist/config.js

@@ -1,53 +1,224 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-export function loadConfig() {
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+// --- Pairing constants ---
+const CODE_LENGTH = 8;
+const CODE_ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ"; // no ambiguous 0/O/1/I/l
+const EXPIRY_MS = 60 * 60 * 1000; // 1 hour
+const MAX_PENDING = 3;
+// --- Resolve data directory ---
+export function resolveDataDir() {
     const dataDir = process.env.CLEARCLAW_HOME ?? path.join(os.homedir(), ".clearclaw");
     fs.mkdirSync(dataDir, { recursive: true });
     fs.mkdirSync(path.join(dataDir, "files"), { recursive: true });
-    // Channel config: Slack takes priority if both SLACK_BOT_TOKEN and SLACK_APP_TOKEN are set
-    const slackBotToken = process.env.SLACK_BOT_TOKEN;
-    const slackAppToken = process.env.SLACK_APP_TOKEN;
-    const telegramBotToken = process.env.TELEGRAM_BOT_TOKEN;
-    let channel;
-    if (slackBotToken && slackAppToken) {
-        channel = { type: "slack", botToken: slackBotToken, appToken: slackAppToken };
-    }
-    else if (telegramBotToken) {
-        channel = { type: "telegram", botToken: telegramBotToken };
-    }
-    else {
-        throw new Error("Missing channel config: set TELEGRAM_BOT_TOKEN or both SLACK_BOT_TOKEN + SLACK_APP_TOKEN");
-    }
-    const rawIds = process.env.ALLOWED_USER_IDS ?? process.env.ALLOWED_USER_ID;
-    if (!rawIds)
-        throw new Error("Missing required env var: ALLOWED_USER_IDS");
-    const allowedUserIds = new Set(rawIds.split(",").map((s) => s.trim()).filter(Boolean));
-    const permissionMode = (process.env.PERMISSION_MODE ?? "default");
-    const valid = [
-        "default",
-        "acceptEdits",
-        "bypassPermissions",
-        "plan",
-        "dontAsk",
-    ];
-    if (!valid.includes(permissionMode)) {
-        throw new Error(`PERMISSION_MODE must be one of: ${valid.join(", ")}`);
-    }
-    return {
-        channel,
-        allowedUserIds,
-        permissionMode,
-        defaultPromptPath: path.join(dataDir, "workspace", "CLAUDE.md"),
-        workspaceStorePath: path.join(dataDir, "workspaces.json"),
-        filesPath: path.join(dataDir, "files"),
-        logPath: path.join(dataDir, "clearclaw.log"),
-    };
+    return dataDir;
 }
-function requireEnv(name) {
-    const val = process.env[name];
-    if (!val)
-        throw new Error(`Missing required env var: ${name}`);
-    return val;
+// --- Config class ---
+/**
+ * Unified config: env var resolution + persistent store backed by config.json.
+ *
+ * - `new Config(dataDir)` gives store access (read/write methods)
+ * - `config.resolve()` adds env var settings (channel, envUserIds, permissionMode)
+ *
+ * File is re-read on every store call (hot-reload without file watching).
+ * Writes use 0o600 permissions (file contains bot token).
+ */
+export class Config {
+    // Resolved settings — populated by resolve()
+    channel;
+    permissionMode = "default";
+    envUserIds = new Set();
+    // Derived paths
+    defaultPromptPath;
+    filesPath;
+    logPath;
+    dataDir = resolveDataDir();
+    filePath;
+    constructor() {
+        this.filePath = path.join(this.dataDir, "config.json");
+        this.defaultPromptPath = path.join(this.dataDir, "workspace", "CLAUDE.md");
+        this.filesPath = path.join(this.dataDir, "files");
+        this.logPath = path.join(this.dataDir, "clearclaw.log");
+    }
+    /** Resolve channel + env vars. Throws if no channel config found. */
+    resolve() {
+        const slackBotToken = process.env.SLACK_BOT_TOKEN;
+        const slackAppToken = process.env.SLACK_APP_TOKEN;
+        const telegramBotToken = process.env.TELEGRAM_BOT_TOKEN;
+        if (slackBotToken && slackAppToken) {
+            this.channel = { type: "slack", botToken: slackBotToken, appToken: slackAppToken };
+        }
+        else if (telegramBotToken) {
+            this.channel = { type: "telegram", botToken: telegramBotToken };
+        }
+        else {
+            const saved = this.getChannel();
+            if (!saved) {
+                throw new Error("Missing channel config: set TELEGRAM_BOT_TOKEN or SLACK_BOT_TOKEN + SLACK_APP_TOKEN, or run `clearclaw setup`");
+            }
+            this.channel = saved;
+        }
+        const rawIds = process.env.ALLOWED_USER_IDS ?? process.env.ALLOWED_USER_ID;
+        this.envUserIds = new Set(rawIds ? rawIds.split(",").map((s) => s.trim()).filter(Boolean) : []);
+        const pm = (process.env.PERMISSION_MODE ?? "default");
+        const valid = [
+            "default", "acceptEdits", "bypassPermissions", "plan", "dontAsk",
+        ];
+        if (!valid.includes(pm)) {
+            throw new Error(`PERMISSION_MODE must be one of: ${valid.join(", ")}`);
+        }
+        this.permissionMode = pm;
+        return this;
+    }
+    // --- File I/O (internal) ---
+    read() {
+        if (!fs.existsSync(this.filePath)) {
+            return { authorizedUsers: [], pendingPairings: [], workspaces: [] };
+        }
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
+            return {
+                channel: raw.channel,
+                authorizedUsers: raw.authorizedUsers ?? [],
+                pendingPairings: raw.pendingPairings ?? [],
+                workspaces: raw.workspaces ?? [],
+            };
+        }
+        catch {
+            return { authorizedUsers: [], pendingPairings: [], workspaces: [] };
+        }
+    }
+    write(data) {
+        fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
+    }
+    // --- Channel ---
+    getChannel() {
+        return this.read().channel;
+    }
+    setChannel(config) {
+        const data = this.read();
+        data.channel = config;
+        this.write(data);
+    }
+    // --- Authorized users ---
+    hasUser(userId) {
+        return this.read().authorizedUsers.some((u) => u.id === userId);
+    }
+    addUser(user) {
+        const data = this.read();
+        if (data.authorizedUsers.some((u) => u.id === user.id))
+            return;
+        data.authorizedUsers.push(user);
+        this.write(data);
+    }
+    listUsers() {
+        return this.read().authorizedUsers;
+    }
+    /** env var IDs (in-memory) + pairing-approved users (hot-reload from disk) */
+    isAuthorized(userId) {
+        return this.envUserIds.has(userId) || this.hasUser(userId);
+    }
+    // --- Pairing codes ---
+    createPairing(userId, userName, chatId) {
+        const data = this.read();
+        const now = Date.now();
+        // Filter expired
+        data.pendingPairings = data.pendingPairings.filter((p) => p.expiresAt > now);
+        // Idempotent: return existing code for same user
+        const existing = data.pendingPairings.find((p) => p.userId === userId);
+        if (existing) {
+            this.write(data);
+            return existing.code;
+        }
+        // Evict oldest if at capacity
+        if (data.pendingPairings.length >= MAX_PENDING) {
+            data.pendingPairings.sort((a, b) => a.expiresAt - b.expiresAt);
+            data.pendingPairings = data.pendingPairings.slice(data.pendingPairings.length - MAX_PENDING + 1);
+        }
+        const code = this.generateCode();
+        data.pendingPairings.push({ code, userId, userName, chatId, expiresAt: now + EXPIRY_MS });
+        this.write(data);
+        return code;
+    }
+    consumePairing(code) {
+        const data = this.read();
+        const now = Date.now();
+        const idx = data.pendingPairings.findIndex((p) => p.code.toLowerCase() === code.toLowerCase() && p.expiresAt > now);
+        if (idx < 0)
+            return null;
+        const [pairing] = data.pendingPairings.splice(idx, 1);
+        this.write(data);
+        return pairing;
+    }
+    generateCode() {
+        const bytes = crypto.randomBytes(CODE_LENGTH);
+        return Array.from(bytes)
+            .map((b) => CODE_ALPHABET[b % CODE_ALPHABET.length])
+            .join("");
+    }
+    // --- Workspaces ---
+    workspaceByChat(chatId) {
+        return this.read().workspaces.find((ws) => ws.chat_id === chatId);
+    }
+    workspaceByName(name) {
+        return this.read().workspaces.find((ws) => ws.name === name);
+    }
+    upsertWorkspace(ws) {
+        const data = this.read();
+        const idx = data.workspaces.findIndex((w) => w.name === ws.name);
+        if (idx >= 0)
+            data.workspaces[idx] = ws;
+        else
+            data.workspaces.push(ws);
+        this.write(data);
+    }
+    setSession(name, sessionId) {
+        const data = this.read();
+        const ws = data.workspaces.find((w) => w.name === name);
+        if (ws) {
+            ws.current_session_id = sessionId;
+            this.write(data);
+        }
+    }
+    clearSession(name) {
+        const data = this.read();
+        const ws = data.workspaces.find((w) => w.name === name);
+        if (ws) {
+            ws.current_session_id = null;
+            this.write(data);
+        }
+    }
+    setBehavior(name, behavior) {
+        const data = this.read();
+        const ws = data.workspaces.find((w) => w.name === name);
+        if (ws) {
+            ws.behavior = behavior;
+            this.write(data);
+        }
+    }
+    // --- 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) {
+        this.addUser({ id: userId, name: userName, approvedAt: Date.now() });
+        this.ensureDefaultWorkspace(chatId);
+    }
 }
 //# sourceMappingURL=config.js.map

package/dist/engine/claude-code.js

@@ -36,7 +36,7 @@ export class ClaudeCodeEngine {
                 toolUseId: options.toolUseID,
             });
             if (resp.decision === "allow") {
-                return { behavior: "allow", updatedInput: input };
+                return { behavior: "allow", updatedInput: resp.updatedInput ?? input };
             }
             const denyMessage = resp.message
                 ? `User denied this action with feedback: ${resp.message}`
@@ -56,6 +56,7 @@ export class ClaudeCodeEngine {
         const prompt = attachments?.length
             ? buildAttachmentPrompt(textPrompt, attachments)
             : textPrompt;
+        log.info("[turn] permissionMode=%s session=%s", permissionMode, sessionId ?? "new");
         const q = query({
             prompt,
             options: {
@@ -63,7 +64,7 @@ export class ClaudeCodeEngine {
                 cwd,
                 permissionMode,
                 allowDangerouslySkipPermissions: permissionMode === "bypassPermissions" ? true : undefined,
-                canUseTool,
+                canUseTool: permissionMode === "bypassPermissions" ? undefined : canUseTool,
                 abortController,
                 settingSources: ["user", "project", "local"],
                 ...(mcpServers ? { mcpServers } : {}),

package/dist/format.d.ts

@@ -22,7 +22,33 @@ export declare function formatPermissionPrompt(toolName: string, input: Record<s
  * Relative time string: "just now", "5m ago", "2h ago", "3d ago".
  */
 export declare function timeAgo(epochMs: number): string;
+interface AskUserQuestionOption {
+    label: string;
+    description: string;
+}
+/**
+ * Format the first question from an AskUserQuestion tool call.
+ * Returns { text, options } where options are the parsed option objects.
+ */
+export declare function formatAskUserQuestion(input: Record<string, unknown>): {
+    text: string;
+    options: AskUserQuestionOption[];
+};
+/**
+ * Truncate a button label to MAX_BTN chars with number prefix.
+ */
+export declare function truncateButtonLabel(index: number, label: string): string;
+/**
+ * Format an ExitPlanMode permission prompt.
+ * Renders plan text from the description or input fields.
+ */
+export declare function formatExitPlanMode(input: Record<string, unknown>, description: string): string;
+/**
+ * Format a TodoWrite task list for display.
+ */
+export declare function formatTodoList(input: Record<string, unknown>): string;
 /**
  * Human-readable one-liner for a tool invocation (used in engine's canUseTool).
  */
 export declare function formatToolDescription(toolName: string, input: Record<string, unknown>): string;
+export {};

package/dist/format.js

@@ -117,6 +117,57 @@ export function timeAgo(epochMs) {
     const days = Math.floor(hours / 24);
     return `${days}d ago`;
 }
+const MAX_BTN = 45;
+/**
+ * Format the first question from an AskUserQuestion tool call.
+ * Returns { text, options } where options are the parsed option objects.
+ */
+export function formatAskUserQuestion(input) {
+    const { questions } = input;
+    const q = questions[0];
+    const lines = [`❓ ${q.header}`, q.question, ""];
+    for (let i = 0; i < q.options.length; i++) {
+        const opt = q.options[i];
+        lines.push(`${i + 1}. ${opt.label} — ${opt.description}`);
+    }
+    return { text: lines.join("\n"), options: q.options };
+}
+/**
+ * Truncate a button label to MAX_BTN chars with number prefix.
+ */
+export function truncateButtonLabel(index, label) {
+    const full = `${index + 1}. ${label}`;
+    if (full.length <= MAX_BTN)
+        return full;
+    return `${full.slice(0, MAX_BTN - 1)}…`;
+}
+/**
+ * Format an ExitPlanMode permission prompt.
+ * Renders plan text from the description or input fields.
+ */
+export function formatExitPlanMode(input, description) {
+    const plan = (typeof input.plan === "string" ? input.plan : null)
+        || JSON.stringify(input, null, 2);
+    const lines = plan.split("\n");
+    const body = truncateLines(lines, MAX_LINES);
+    return `📋 Plan Review\n\n${body}`;
+}
+/**
+ * Format a TodoWrite task list for display.
+ */
+export function formatTodoList(input) {
+    const todos = (input.todos ?? []);
+    if (todos.length === 0)
+        return "📋 Tasks\n(empty)";
+    const lines = todos.map((t) => {
+        switch (t.status) {
+            case "completed": return `✅ ${t.content}`;
+            case "in_progress": return `⏳ ${t.activeForm}`;
+            default: return `⬚ ${t.content}`;
+        }
+    });
+    return `📋 Tasks\n${lines.join("\n")}`;
+}
 function truncateLines(lines, max) {
     if (lines.length <= max) {
         return lines.join("\n");

package/dist/index.js

@@ -1,50 +1,152 @@
 #!/usr/bin/env node
-import { loadConfig } from "./config.js";
+import readline from "node:readline";
+import { Config } from "./config.js";
 import log, { initLogger } from "./logger.js";
-import { WorkspaceStore } from "./workspace-store.js";
 import { ClaudeCodeEngine } from "./engine/claude-code.js";
 import { TelegramChannel } from "./channel/telegram.js";
 import { SlackChannel } from "./channel/slack.js";
 import { Orchestrator } from "./orchestrator.js";
-// The Claude Agent SDK has a bug: handleControlRequest() writes to the
-// subprocess stdin without a .catch(), so aborting during a permission
-// callback causes an unhandled rejection (write to dead process).
-// Suppress that specific error so we can use abort for deny + /cancel.
-process.on("unhandledRejection", (reason) => {
-    const msg = reason instanceof Error ? reason.message : String(reason);
-    if (msg.includes("Operation aborted") ||
-        msg.includes("Failed to write to process stdin") ||
-        msg.includes("Cannot write to terminated process")) {
-        log.warn("[sdk] suppressed write error (known SDK bug): %s", msg);
-        return;
-    }
-    log.fatal({ err: reason }, "Unhandled rejection");
-    process.exit(1);
-});
-async function main() {
-    const config = loadConfig();
+async function runDaemon() {
+    const config = new Config().resolve();
+    config.syncSkills();
     initLogger(config.logPath);
-    const workspaceStore = new WorkspaceStore(config.workspaceStorePath);
-    let channel;
-    if (config.channel.type === "slack") {
-        channel = new SlackChannel(config.channel.botToken, config.channel.appToken, config.allowedUserIds);
+    // The Claude Agent SDK has a bug: handleControlRequest() writes to the
+    // subprocess stdin without a .catch(), so aborting during a permission
+    // callback causes an unhandled rejection (write to dead process).
+    // Suppress that specific error so we can use abort for deny + /cancel.
+    process.on("unhandledRejection", (reason) => {
+        const msg = reason instanceof Error ? reason.message : String(reason);
+        if (msg.includes("Operation aborted") ||
+            msg.includes("Failed to write to process stdin") ||
+            msg.includes("Cannot write to terminated process")) {
+            log.warn("[sdk] suppressed write error (known SDK bug): %s", msg);
+            return;
+        }
+        log.fatal({ err: reason }, "Unhandled rejection");
+        process.exit(1);
+    });
+    // Daemon always uses pairing code flow (no console/readline)
+    const onUnauthorizedDM = (chatId, user) => {
+        const code = config.createPairing(user.id, user.name, chatId);
+        const text = [
+            `Your user ID: ${user.id}`,
+            `Pairing code: ${code}`,
+            "",
+            "Ask the server owner to run:",
+            `  clearclaw approve ${code}`,
+            "",
+            "Code expires in 1 hour.",
+        ].join("\n");
+        channel.sendMessage(chatId, text).catch((err) => {
+            log.warn({ err }, "[pairing] failed to send pairing message");
+        });
+    };
+    const channel = createChannel(config.channel, (userId) => config.isAuthorized(userId), onUnauthorizedDM);
+    await new Orchestrator({ channel, engine: new ClaudeCodeEngine(), config }).start();
+}
+async function runApprove(args) {
+    const code = args[0];
+    if (!code) {
+        console.error("Usage: clearclaw approve <code>");
+        process.exit(1);
     }
-    else {
-        channel = new TelegramChannel(config.channel.botToken, config.allowedUserIds);
+    const config = new Config();
+    const pairing = config.consumePairing(code);
+    if (!pairing) {
+        console.error("Invalid or expired pairing code.");
+        process.exit(1);
     }
-    const engine = new ClaudeCodeEngine();
-    const orchestrator = new Orchestrator({
-        channel,
-        engine,
-        workspaceStore,
-        permissionMode: config.permissionMode,
-        defaultPromptPath: config.defaultPromptPath,
-        filesPath: config.filesPath,
-    });
-    await orchestrator.start();
+    config.approveUser(pairing.userId, pairing.userName, pairing.chatId);
+    console.log(`Approved ${pairing.userName} (${pairing.userId})`);
+}
+const SETUP_TIMEOUT_MS = 5 * 60 * 1000;
+async function runSetup() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    let channel = null;
+    try {
+        console.log("ClearClaw setup\n");
+        let channelType;
+        while (true) {
+            channelType = (await ask("Channel [telegram/slack]: ")).trim().toLowerCase();
+            if (channelType === "telegram" || channelType === "slack")
+                break;
+            console.log('  Please enter "telegram" or "slack".');
+        }
+        let channelConfig;
+        if (channelType === "slack") {
+            const botToken = (await ask("Slack bot token (xoxb-...): ")).trim();
+            const appToken = (await ask("Slack app token (xapp-...): ")).trim();
+            if (!botToken || !appToken)
+                throw new Error("Both tokens required for Slack.");
+            channelConfig = { type: "slack", botToken, appToken };
+        }
+        else {
+            const botToken = (await ask("Telegram bot token: ")).trim();
+            if (!botToken)
+                throw new Error("Bot token required.");
+            channelConfig = { type: "telegram", botToken };
+        }
+        const config = new Config();
+        config.setChannel(channelConfig);
+        console.log("Saved to ~/.clearclaw/config.json\n");
+        config.resolve();
+        let resolveFirstDM;
+        const firstDM = new Promise((r) => {
+            resolveFirstDM = r;
+        });
+        channel = createChannel(config.channel, (userId) => config.isAuthorized(userId), (chatId, user) => resolveFirstDM({ chatId, user }));
+        console.log("Connecting...");
+        await channel.connect();
+        console.log("Connected! Waiting for a DM — message the bot from your chat app.\n");
+        const { chatId, user } = await Promise.race([
+            firstDM,
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Timed out. Run `clearclaw setup` again.")), SETUP_TIMEOUT_MS)),
+        ]);
+        console.log(`→ Message from ${user.name} (${user.id})`);
+        const pairingCode = config.createPairing(user.id, user.name, chatId);
+        await channel.sendMessage(chatId, [
+            `Pairing code: ${pairingCode}`,
+            "",
+            "The server owner is approving you now.",
+            "Code expires in 1 hour.",
+        ].join("\n"));
+        const entered = (await ask("  Enter pairing code to approve: ")).trim();
+        const pairing = config.consumePairing(entered);
+        if (!pairing) {
+            console.log("  Invalid code. Exiting.");
+            await channel.sendMessage(chatId, "Pairing code was invalid. Please try again.");
+            return;
+        }
+        config.approveUser(pairing.userId, pairing.userName, pairing.chatId);
+        console.log(`  Approved ${pairing.userName} (${pairing.userId})`);
+        await channel.sendMessage(chatId, "You're approved! The bot is being set up — you'll be able to chat soon.");
+        console.log("\nSetup complete! Start the daemon:\n  clearclaw daemon\n");
+    }
+    finally {
+        if (channel)
+            await channel.disconnect().catch(() => { });
+        rl.close();
+    }
+}
+function createChannel(ch, isAuthorized, onUnauthorizedDM) {
+    if (ch.type === "slack") {
+        return new SlackChannel(ch.botToken, ch.appToken, isAuthorized, onUnauthorizedDM);
+    }
+    return new TelegramChannel(ch.botToken, isAuthorized, onUnauthorizedDM);
+}
+switch (process.argv[2]) {
+    case "setup":
+        await runSetup();
+        break;
+    case "approve":
+        await runApprove(process.argv.slice(3));
+        break;
+    case "daemon":
+        await runDaemon();
+        break;
+    default:
+        console.log(`Usage: clearclaw <command>\n\nCommands:\n  setup     Interactive first-run setup\n  daemon    Start the relay daemon\n  approve   Approve a pairing code\n\nRun 'clearclaw setup' to get started.`);
+        process.exit(process.argv[2] ? 1 : 0);
 }
-main().catch((err) => {
-    log.fatal({ err }, "Fatal");
-    process.exit(1);
-});
 //# sourceMappingURL=index.js.map

package/dist/orchestrator.d.ts

@@ -1,27 +1,31 @@
-import type { WorkspaceStore } from "./workspace-store.js";
-import type { Channel, Engine, PermissionMode } from "./types.js";
+import type { Config } from "./config.js";
+import type { Channel, Engine } from "./types.js";
 export interface OrchestratorOpts {
     channel: Channel;
     engine: Engine;
-    workspaceStore: WorkspaceStore;
-    permissionMode: PermissionMode;
-    defaultPromptPath: string;
-    filesPath: string;
+    config: Config;
 }
 export declare class Orchestrator {
     private channel;
     private engine;
-    private workspaceStore;
-    private permissionMode;
-    private defaultPromptPath;
-    private filesPath;
+    private config;
     private chats;
+    private tasks;
     constructor(opts: OrchestratorOpts);
     private chat;
     start(): Promise<void>;
     stop(): Promise<void>;
-    private handleMessage;
+    /** Effective behavior: tasks→assistant, workspace→explicit setting or home→assistant / project→relay. */
+    private effectiveBehavior;
+    /** Enqueue a message and drain — immediately for relay, debounced for assistant/task. */
+    private enqueueMessage;
+    private scheduleDebounce;
+    private processQueuedMessages;
+    private executeTurn;
+    private routeMessage;
     private routeEngineEvent;
+    private buildMcpTools;
+    private handlePermission;
     private updateStatusMessage;
     /** Read default workspace CLAUDE.md to append to non-default workspace sessions. */
     private readDefaultPrompt;