clearclaw 0.6.1 → 0.8.0

package/dist/orchestrator.js

@@ -1,29 +1,36 @@
+import crypto from "node:crypto";
 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 { assemblePrompt } from "./prompt.js";
+import { formatPlanUsage, recordPlanUsage } from "./plan-usage.js";
 import { formatToolStatusLine, formatToolCallSummary, formatPermissionPrompt, formatTodoList, timeAgo } from "./format.js";
 import { permissionHandlers, displayHandledTools } from "./tool-handlers.js";
-function isTask(ctx) {
-    return "prompt" in ctx;
-}
+import { formatSessionRecap, formatSessionTranscript, stripPromptPrefix } from "./engine/session-transcript.js";
+import { Scheduler } from "./scheduler.js";
 const MODE_OPTIONS = [
     { label: "Default", value: "default" },
     { label: "Accept Edits", value: "acceptEdits" },
     { label: "Plan", value: "plan" },
     { label: "Bypass", value: "bypassPermissions" },
 ];
+const STREAM_EDIT_LIMIT = 3000;
+const STREAM_INITIAL_EDIT_MIN = 96;
+const STREAM_EDIT_DELTA = 160;
 export class Orchestrator {
     channel;
-    engine;
+    engines;
     config;
     chats = new Map();
-    tasks = new Map();
+    creatingWorkspaces = new Set();
+    scheduler = null;
+    planUsage = new Map();
     constructor(opts) {
         this.channel = opts.channel;
-        this.engine = opts.engine;
+        this.engines = opts.engines;
         this.config = opts.config;
     }
     chat(chatId) {
@@ -31,21 +38,37 @@ export class Orchestrator {
         if (!s) {
             s = {
                 busy: false, abort: null, permissionMode: null, stats: null, lastStatusText: null,
-                toolCallHandle: null, todoHandle: null,
+                toolCallHandle: null, todoHandle: null, textHandle: null, textBuffer: "",
+                textPublishedLength: 0,
+                textReplySent: false,
+                engineName: null,
                 messageQueue: [], debounceTimer: null,
             };
             this.chats.set(chatId, s);
         }
         return s;
     }
+    engineFor(ws) {
+        const name = ws.engine ?? this.config.defaultEngine;
+        const engine = this.engines.get(name);
+        if (!engine) {
+            throw new Error(`Unknown engine "${name}" configured for workspace "${ws.name}". Available: ${[...this.engines.keys()].join(", ")}`);
+        }
+        return engine;
+    }
     async start() {
+        this.config.ensureHomeWorkspace();
         this.channel.on("message", (msg) => {
             this.routeMessage(msg).catch((err) => {
                 log.error({ err }, "[orchestrator] unhandled message error");
             });
         });
         await this.channel.connect();
+        for (const ws of this.config.listWorkspaces())
+            this.deliverInitialBrief(ws.name);
         log.info("ClearClaw ready.");
+        this.scheduler = new Scheduler(this.config, (msg) => this.deliverToWorkspace("default", msg.origin, msg.text));
+        this.scheduler.start();
         const shutdown = async () => {
             await this.stop();
             process.exit(0);
@@ -54,18 +77,192 @@ export class Orchestrator {
         process.on("SIGTERM", shutdown);
     }
     async stop() {
+        this.scheduler?.stop();
         await this.channel.disconnect();
     }
-    /** Effective behavior: tasks→assistant, workspace→explicit setting or home→assistant / project→relay. */
+    /** Deliver a synthetic message to a named workspace and trigger its turn. */
+    deliverToWorkspace(workspaceName, origin, text) {
+        const ws = this.config.workspaceByName(workspaceName);
+        if (!ws?.chat_id || !this.channel.ownsId(ws.chat_id)) {
+            log.warn("[deliver] workspace '%s' not found", workspaceName);
+            return false;
+        }
+        const msg = {
+            chatId: ws.chat_id,
+            chatType: ws.name === "default" ? "dm" : "group",
+            text,
+            origin,
+        };
+        this.enqueueMessage(msg, ws, this.chat(ws.chat_id));
+        return true;
+    }
+    /**
+     * Everything creation can reject without touching the platform. Runs before the
+     * confirmation, so the user is never asked to approve a doomed spawn, and again
+     * inside creation, where it is the authoritative check.
+     */
+    validateNewWorkspace(args, newProjectName) {
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(args.name)) {
+            return "Use a short workspace name containing letters, numbers, hyphens, or underscores.";
+        }
+        if (this.config.workspaceByName(args.name) || this.creatingWorkspaces.has(args.name)) {
+            return `Workspace "${args.name}" already exists or is being created. Pick another name.`;
+        }
+        if (newProjectName && this.config.projectByName(newProjectName)) {
+            return `Project "${newProjectName}" already exists. Name it as project to put this peer in it.`;
+        }
+        if (!path.isAbsolute(args.cwd) || !fs.existsSync(args.cwd) || !fs.statSync(args.cwd).isDirectory()) {
+            return `cwd "${args.cwd}" must be an existing directory with an absolute path. Prepare it with your own tooling, then retry.`;
+        }
+        return null;
+    }
+    /** Shared creation path for standalone projects and peers, with optional manual binding. */
+    async createWorkspace(chatId, fromName, project, newProjectName, mainWs, args, runtime) {
+        const result = (text) => ({ content: [{ type: "text", text }] });
+        const invalid = this.validateNewWorkspace(args, newProjectName);
+        if (invalid)
+            return result(invalid);
+        const description = args.description ?? args.brief.split("\n")[0].slice(0, 160);
+        const destination = project ?? { name: newProjectName, main_workspace: args.name, description };
+        const anchor = mainWs.chat_id ?? chatId;
+        if (!args.manual && (!this.channel.ownsId(anchor) || !this.channel.createProjectChat || !this.channel.closeProjectChat)) {
+            return result("Automatic chat creation is unavailable for this destination. Retry with a manual chat, then use /connect <workspace> in that chat.");
+        }
+        this.creatingWorkspaces.add(args.name);
+        const cwd = args.cwd;
+        let createdChatId = null;
+        let registered = false;
+        let createdProject = false;
+        try {
+            if (!args.manual)
+                createdChatId = await this.channel.createProjectChat(destination.name, anchor, args.name);
+            // Chat creation awaits the platform. Recheck config before committing our records.
+            if (this.config.workspaceByName(args.name) || (newProjectName && this.config.projectByName(newProjectName))) {
+                throw new Error("The workspace or project name was taken during chat creation. Retry with another name.");
+            }
+            if (createdChatId && this.config.workspaceByChat(createdChatId))
+                throw new Error("The created chat is already connected to another workspace.");
+            if (project && !this.config.projectByName(project.name))
+                throw new Error("The target project was archived during chat creation.");
+            this.config.upsertWorkspace({
+                name: args.name, cwd, chat_id: createdChatId, current_session_id: null,
+                behavior: args.behavior ?? mainWs.behavior, engine: runtime.engine, model: runtime.model,
+                project: destination.name, description, spawnedFrom: fromName,
+                pending_brief: { fromWorkspace: fromName, text: args.brief },
+            });
+            registered = true;
+            if (!project) {
+                this.config.addProject(destination);
+                createdProject = true;
+            }
+        }
+        catch (err) {
+            if (createdProject)
+                this.config.removeProject(destination.name);
+            if (registered)
+                this.config.removeWorkspace(args.name);
+            if (createdChatId && !this.config.workspaceByChat(createdChatId)) {
+                await this.channel.closeProjectChat(createdChatId, destination.name).catch(() => { });
+            }
+            return result(`Spawn failed: ${err instanceof Error ? err.message : String(err)}. Retry with a manual chat if automatic chat creation is unavailable.`);
+        }
+        finally {
+            this.creatingWorkspaces.delete(args.name);
+        }
+        // Once registered, notification failures must not roll back a workspace or a delivered brief.
+        const grouping = createdChatId ? await this.groupChat(destination.name, createdChatId) : undefined;
+        const delivered = this.deliverInitialBrief(args.name);
+        const note = createdChatId
+            ? (delivered ? "; brief delivered." : ".")
+            : `. In the intended chat, send /connect ${args.name}.`;
+        log.info("[workspace] created %s in %s", args.name, destination.name);
+        return result(`Spawned workspace "${args.name}" at ${cwd}${note}${grouping ? `\n\n${grouping}` : ""}`);
+    }
+    /** Grouping is best-effort: it never fails a lifecycle operation, but it is never silent either. */
+    async groupChat(projectName, chatId) {
+        try {
+            return await this.channel.groupProjectChat?.(projectName, chatId);
+        }
+        catch (err) {
+            log.warn({ err }, "[project] grouping failed for %s", projectName);
+            return `Could not group this chat under "${projectName}": ${err instanceof Error ? err.message : String(err)}.`;
+        }
+    }
+    deliverInitialBrief(name) {
+        const ws = this.config.workspaceByName(name);
+        if (!ws?.chat_id || !ws.pending_brief)
+            return false;
+        // An existing or queued ordinary turn already includes the saved brief.
+        const state = this.chats.get(ws.chat_id);
+        if (state?.busy || state?.messageQueue.length)
+            return false;
+        const brief = ws.pending_brief;
+        return this.deliverToWorkspace(name, { kind: "peer", workspaceName: brief.fromWorkspace }, brief.text);
+    }
+    /** An unbound chat can connect without starting a temporary agent or sharing home's session. */
+    async connectWorkspace(msg, name) {
+        const reply = (text) => this.channel.sendMessage(msg.chatId, text);
+        if (!name) {
+            await reply("Usage: /connect <workspace>. Create a workspace with a manual chat from home first.");
+            return;
+        }
+        const existing = this.config.workspaceByChat(msg.chatId);
+        if (existing) {
+            await reply(`This chat is already connected to "${existing.name}".`);
+            return;
+        }
+        const ws = this.config.workspaceByName(name);
+        if (!ws) {
+            await reply(`No workspace named "${name}". Create it from home with a manual chat first.`);
+            return;
+        }
+        if (name === "default") {
+            await reply("Home connects automatically through an authorized private DM.");
+            return;
+        }
+        if (ws.chat_id) {
+            await reply(`Workspace "${name}" already has a chat. Existing bindings cannot be replaced by /connect.`);
+            return;
+        }
+        if (this.chat(msg.chatId).busy) {
+            await reply("A turn is running. Wait for it to finish before connecting.");
+            return;
+        }
+        this.config.upsertWorkspace({ ...ws, chat_id: msg.chatId });
+        const grouping = ws.project ? await this.groupChat(ws.project, msg.chatId) : undefined;
+        this.deliverInitialBrief(name);
+        await reply(`Connected this chat to workspace "${name}".${grouping ? `\n\n${grouping}` : ""}`);
+    }
+    peerRuntime(baseWorkspace, requested) {
+        const baseEngine = baseWorkspace?.engine ?? this.config.defaultEngine;
+        const engine = requested.engine ?? baseWorkspace?.engine;
+        const effectiveEngine = engine ?? this.config.defaultEngine;
+        if (!this.engines.has(effectiveEngine)) {
+            return { error: `Unknown engine "${effectiveEngine}". Available: ${[...this.engines.keys()].join(", ")}` };
+        }
+        return {
+            runtime: {
+                engine,
+                model: requested.model
+                    ?? (effectiveEngine === baseEngine
+                        ? baseWorkspace?.model
+                        : undefined),
+            },
+        };
+    }
+    /** Effective behavior: 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";
+        return ctx.cwd === this.config.homeWorkspacePath ? "assistant" : "relay";
+    }
+    /** Permission mode a chat runs in until /mode picks one. */
+    baseMode(behavior) {
+        return behavior === "assistant" ? "bypassPermissions" : this.config.permissionMode;
     }
-    /** Enqueue a message and drain — immediately for relay, debounced for assistant/task. */
+    /** Enqueue a message and drain — immediately for relay, debounced for assistant. */
     enqueueMessage(msg, ctx, state) {
+        log.info("[msg] %s: %s", senderLabel(msg.origin), msg.text.slice(0, 80));
         state.messageQueue.push(msg);
         if (state.busy)
             return;
@@ -93,7 +290,7 @@ export class Orchestrator {
         const state = this.chat(chatId);
         if (state.messageQueue.length === 0 || state.busy)
             return;
-        const ctx = this.tasks.get(chatId) ?? this.config.workspaceByChat(chatId);
+        const ctx = this.config.workspaceByChat(chatId);
         if (!ctx)
             return;
         const messages = [...state.messageQueue];
@@ -103,6 +300,11 @@ export class Orchestrator {
         }
         catch (err) {
             log.error({ err }, "[fatal]");
+            // executeTurn marks the chat busy before its own finally is in scope; without this,
+            // an early throw leaves the chat wedged until restart.
+            state.busy = false;
+            state.abort = null;
+            await this.channel.setTyping(chatId, false).catch(() => { });
             await this.channel.sendMessage(chatId, `Internal error: ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
             return;
         }
@@ -119,30 +321,76 @@ export class Orchestrator {
         }
     }
     async executeTurn(chatId, messages, ctx, state) {
-        const task = isTask(ctx) ? ctx : undefined;
-        const ws = isTask(ctx) ? undefined : ctx;
+        const ws = ctx;
+        const initialBrief = slashCommandPrompt(messages) ? undefined : ws.pending_brief;
+        if (initialBrief && !messages.some((m) => m.origin.kind === "peer"
+            && m.origin.workspaceName === initialBrief.fromWorkspace && m.text === initialBrief.text)) {
+            messages = [{ chatId, chatType: "group", origin: { kind: "peer", workspaceName: initialBrief.fromWorkspace }, text: initialBrief.text }, ...messages];
+        }
+        const turnCwd = ws.cwd;
+        if (!fs.existsSync(turnCwd)) {
+            log.warn("[turn] aborting: cwd does not exist: %s", turnCwd);
+            await this.channel.sendMessage(chatId, `⚠️ Can't start: this workspace's directory doesn't exist:\n${turnCwd}\nLikely an un-created worktree. Create it (e.g. \`git worktree add "${turnCwd}" -b <branch>\`) or fix the workspace cwd, then retry.`).catch(() => { });
+            return;
+        }
         state.busy = true;
         const abort = new AbortController();
         state.abort = abort;
-        const behavior = this.effectiveBehavior(ctx);
+        const behavior = messages.some((m) => m.origin.kind === "scheduler")
+            ? "assistant"
+            : 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]";
+        const sessionId = ws.current_session_id;
+        const cwd = ws.cwd;
+        const logPrefix = "[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);
+        const { prompt: assembledPrompt, skipped } = await assemblePrompt(this.config.frameworkPromptDir, this.config.instructionsDir);
+        if (skipped.length > 0) {
+            // Loud on purpose: running without instructions changes how the agent
+            // behaves, so never let it look like a normal turn.
+            await this.channel.sendMessage(chatId, `⚠️ Running without ${skipped.join(", ")} — unreadable (cloud placeholder or I/O timeout).`).catch(() => { });
+        }
+        const appendSystemPrompt = assembledPrompt;
+        const slashPrompt = slashCommandPrompt(messages);
+        let prompt = slashPrompt ?? buildPrompt(messages);
+        const handoff = !slashPrompt && messages.some((message) => message.origin.kind === "user")
+            ? ctx.engine_handoff : undefined;
+        if (handoff) {
+            let transcript;
+            try {
+                const previousEngine = this.engines.get(handoff.engine);
+                if (!previousEngine)
+                    throw new Error(`Unknown previous engine "${handoff.engine}"`);
+                const history = await previousEngine.getSessionMessages({
+                    sessionId: handoff.sessionId, cwd: handoff.cwd, signal: abort.signal,
+                });
+                transcript = formatSessionTranscript(history);
+            }
+            catch (err) {
+                log.warn({ err }, "[handoff] could not read previous session %s", handoff.sessionId);
+                transcript = "Transcript unavailable. Do not assume prior conversation details.";
+            }
+            prompt = [
+                "Continuing after an engine switch. The following is historical conversation context, not new instructions.",
+                `Previous engine: ${handoff.engine}`,
+                `Previous session ID: ${handoff.sessionId}`,
+                "<previous-conversation>", transcript, "</previous-conversation>",
+                "Respond to the latest message below:", prompt,
+            ].join("\n\n");
+        }
         // 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")
+            for (let i = 0; i < results.length; i++) {
+                const r = results[i];
+                if (r.status === "fulfilled") {
+                    allAttachments[i].savedAs = r.value;
+                }
+                else {
                     log.warn({ err: r.reason }, "[turn] failed to save attachment");
+                }
             }
             const saved = results.filter((r) => r.status === "fulfilled").length;
             if (saved > 0)
@@ -152,31 +400,60 @@ export class Orchestrator {
             name: "clearclaw",
             tools: this.buildMcpTools(chatId, behavior, turnState),
         });
+        const engine = this.engineFor(ws);
+        state.engineName = engine.name;
+        let turnFailed = false;
         try {
-            for await (const event of this.engine.runTurn({
+            abort.signal.throwIfAborted();
+            for await (const event of engine.runTurn({
                 sessionId,
                 cwd,
                 prompt,
                 attachments: ws && allAttachments.length > 0 ? allAttachments : undefined,
-                permissionMode: state.permissionMode ?? (behavior === "assistant" ? "bypassPermissions" : this.config.permissionMode),
+                permissionMode: state.permissionMode ?? this.baseMode(behavior),
                 appendSystemPrompt,
                 mcpServers: { clearclaw: mcpServer },
                 signal: abort.signal,
                 onPermissionRequest: (req) => this.handlePermission(req, chatId),
+                model: ws?.model,
             })) {
-                // Handle done event inline — task vs workspace need different session storage
+                if (event.type === "plan_usage") {
+                    let usage = this.planUsage.get(engine.name);
+                    if (!usage) {
+                        usage = { windows: new Map(engine.planUsageWindows?.map((window) => [window.id, window])) };
+                        this.planUsage.set(engine.name, usage);
+                    }
+                    recordPlanUsage(usage, event);
+                    continue;
+                }
+                if (event.type === "error")
+                    turnFailed = true;
+                // Persist the session as soon as the engine reports it —
+                // so cancelling mid-turn doesn't lose it.
+                if (event.type === "session") {
+                    this.persistSessionId(ws, event.sessionId);
+                    continue;
+                }
+                // Persist completion only while the workspace still belongs to this turn.
                 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;
+                    // Observed model/usage belongs in stats, never in the model override.
+                    const persistedSessionId = this.persistSessionId(ws, event.sessionId);
+                    if (persistedSessionId !== undefined && event.stats)
+                        state.stats = event.stats;
+                    if (initialBrief && persistedSessionId !== undefined && !turnFailed && !abort.signal.aborted) {
+                        const current = this.config.workspaceByName(ws.name);
+                        if (current?.pending_brief?.text === initialBrief.text
+                            && current.pending_brief.fromWorkspace === initialBrief.fromWorkspace) {
+                            this.config.upsertWorkspace({ ...current, pending_brief: undefined });
+                        }
                     }
-                    else {
-                        this.config.setSession(ws.name, event.sessionId);
+                    if (handoff && persistedSessionId !== undefined && !turnFailed && !abort.signal.aborted) {
+                        const current = this.config.workspaceByName(ws.name);
+                        if (current && sameHandoff(current.engine_handoff, handoff)) {
+                            this.config.upsertWorkspace({ ...current, engine_handoff: undefined });
+                        }
                     }
-                    if (event.stats)
-                        state.stats = event.stats;
                     if (behavior === "relay" && state.toolCallHandle && event.stats) {
                         const summary = formatToolCallSummary(event.stats.toolCalls);
                         if (summary) {
@@ -188,6 +465,11 @@ export class Orchestrator {
                     }
                     state.toolCallHandle = null;
                     state.todoHandle = null;
+                    await this.flushTextSegment(chatId, state, turnState);
+                    state.textHandle = null;
+                    state.textBuffer = "";
+                    state.textPublishedLength = 0;
+                    state.textReplySent = false;
                     await this.updateStatusMessage(chatId, state);
                     break;
                 }
@@ -201,27 +483,81 @@ export class Orchestrator {
             if (!turnState.staySilent) {
                 await this.channel.setTyping(chatId, false);
             }
-            // Task cancel already sent "Setup cancelled" from /cancel handler
-            if (cancelled && !task) {
+            if (cancelled) {
                 await this.channel.sendMessage(chatId, "Turn cancelled.");
             }
         }
     }
+    persistSessionId(ws, sessionId) {
+        const current = this.config.workspaceByName(ws.name);
+        // Ignore late events after an archive, rebind, or engine switch.
+        if (!current || current.chat_id !== ws.chat_id
+            || (current.engine ?? this.config.defaultEngine) !== (ws.engine ?? this.config.defaultEngine))
+            return undefined;
+        this.config.setSession(ws.name, sessionId);
+        return sessionId;
+    }
+    /** Native selection works even when the workspace's engine cannot run. */
+    async selectEngine(msg, requested) {
+        const state = this.chat(msg.chatId);
+        const ws = this.config.workspaceByChat(msg.chatId);
+        if (!ws) {
+            await this.channel.sendMessage(msg.chatId, "No workspace linked to this chat. Use /connect <workspace> first.");
+            return;
+        }
+        if (state.busy) {
+            await this.channel.sendMessage(msg.chatId, "A turn is running. Use /cancel first, then /engine once it stops.");
+            return;
+        }
+        const current = ws.engine ?? this.config.defaultEngine;
+        const selected = requested ?? (await this.channel.sendInteractive(msg.chatId, `Current engine: ${current}`, [[...this.engines.keys()].map((name) => ({ label: name === current ? `✓ ${name}` : name, value: name }))])).value;
+        if (!selected)
+            return;
+        if (!this.engines.has(selected)) {
+            await this.channel.sendMessage(msg.chatId, `Unknown engine "${selected}". Available: ${[...this.engines.keys()].join(", ")}`);
+            return;
+        }
+        if (state.busy) {
+            await this.channel.sendMessage(msg.chatId, "A turn is running. Use /cancel first, then /engine once it stops.");
+            return;
+        }
+        const latest = this.config.workspaceByChat(msg.chatId);
+        if (!latest || latest.name !== ws.name || (latest.engine ?? this.config.defaultEngine) !== current) {
+            await this.channel.sendMessage(msg.chatId, "Workspace or engine changed while choosing. Run /engine again.");
+            return;
+        }
+        const changed = selected !== current;
+        if (changed) {
+            this.config.upsertWorkspace({ ...latest, engine: selected, current_session_id: null, model: undefined,
+                engine_handoff: captureHandoff(latest, current) });
+            state.stats = null;
+        }
+        state.engineName = selected;
+        const handoffNote = this.config.workspaceByChat(msg.chatId)?.engine_handoff
+            ? " Previous session context will be included with your next message." : "";
+        log.info("[cmd] chat %s engine → %s", msg.chatId, selected);
+        await this.channel.sendMessage(msg.chatId, `Engine set to ${selected}.${changed ? " Session cleared." : ""}${handoffNote}`);
+        await this.updateStatusMessage(msg.chatId, state);
+    }
     async routeMessage(msg) {
         try {
-            log.info(`[msg] ${msg.user.name} (${msg.user.id}) ${msg.text.slice(0, 80)}`);
+            // routeMessage only handles channel-emitted messages, which are always user-originated.
+            if (msg.origin.kind !== "user")
+                return; // unreachable; documents + type-narrows the invariant
+            const { user } = msg.origin;
+            if (!this.config.isAuthorized(user.id))
+                return;
+            if (this.channel.isRootDM(msg.chatId, user.id) && !this.config.workspaceByChat(msg.chatId)) {
+                this.config.connectHomeWorkspace(msg.chatId);
+            }
+            const connect = msg.text.match(/^\/connect(?:\s+(\S+))?$/);
+            if (connect) {
+                await this.connectWorkspace(msg, connect[1]);
+                return;
+            }
             const state = this.chat(msg.chatId);
-            // /cancel — abort running turn or clear active task (must come before task routing)
+            // Native controls run without a model call.
             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");
@@ -231,16 +567,10 @@ export class Orchestrator {
                 }
                 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.config.permissionMode;
+                const currentMode = state.permissionMode ?? this.baseMode(ws ? this.effectiveBehavior(ws) : "relay");
                 const buttons = [
                     MODE_OPTIONS.slice(0, 2).map((opt) => ({
                         label: opt.value === currentMode ? `✓ ${opt.label}` : opt.label,
@@ -268,9 +598,38 @@ export class Orchestrator {
                 this.config.clearSession(ws.name);
                 state.permissionMode = null;
                 state.stats = null;
-                await this.updateStatusMessage(msg.chatId, state);
                 log.info("[cmd] session cleared for workspace %s", ws.name);
                 await this.channel.sendMessage(msg.chatId, "Session cleared.");
+                await this.updateStatusMessage(msg.chatId, state);
+                return;
+            }
+            // /recap — replay current session history without running a model turn.
+            if (msg.text === "/recap") {
+                if (!ws) {
+                    await this.channel.sendMessage(msg.chatId, "No workspace linked to this chat.", { consumeTyping: false });
+                    return;
+                }
+                const sessionId = ws.current_session_id;
+                if (!sessionId) {
+                    await this.channel.sendMessage(msg.chatId, "No current session to recap yet.", { consumeTyping: false });
+                    return;
+                }
+                try {
+                    const history = await this.engineFor(ws).getSessionMessages({
+                        sessionId, cwd: ws.cwd, signal: AbortSignal.timeout(30_000),
+                    });
+                    const current = this.config.workspaceByChat(msg.chatId);
+                    if (!current || current.name !== ws.name || current.current_session_id !== sessionId
+                        || current.engine !== ws.engine) {
+                        await this.channel.sendMessage(msg.chatId, "Session changed while loading history. Run /recap again.", { consumeTyping: false });
+                        return;
+                    }
+                    await this.channel.sendMessage(msg.chatId, formatSessionRecap(history), { consumeTyping: false });
+                }
+                catch (err) {
+                    log.warn({ err }, "[recap] failed to load history for workspace %s", ws.name);
+                    await this.channel.sendMessage(msg.chatId, "Couldn’t load this session’s history. Try /recap again.", { consumeTyping: false });
+                }
                 return;
             }
             // /resume — switch to a previous session
@@ -283,21 +642,22 @@ export class Orchestrator {
                     await this.channel.sendMessage(msg.chatId, "No workspace linked to this group.");
                     return;
                 }
-                const sessions = await this.engine.listSessions(ws.cwd);
+                const sessions = await this.engineFor(ws).listSessions(ws.cwd);
                 if (sessions.length === 0) {
                     await this.channel.sendMessage(msg.chatId, "No sessions found for this workspace.");
                     return;
                 }
                 const MAX_BTN = 45;
-                // Strip ClearClaw's "[User (@handle)]: " prefix from SDK summaries
+                // SDK summaries can contain the session's latest prompt, including
+                // ClearClaw's bracketed framing. Drop that framing for display.
                 const stripped = sessions.map((s) => ({
                     ...s,
-                    summary: s.summary.replace(/^\[.*?\]:\s*/, ""),
+                    summary: stripPromptPrefix(s.summary),
                 }));
                 // Build detailed list for message body
                 const listing = stripped.map((s, i) => {
                     const current = s.sessionId === ws.current_session_id ? " ✅" : "";
-                    const meta = [timeAgo(s.lastModified), s.gitBranch].filter(Boolean).join(" · ");
+                    const meta = [s.lastModified ? timeAgo(s.lastModified) : "Unknown activity", s.gitBranch].filter(Boolean).join(" · ");
                     return `${i + 1}. ${s.summary}${current}\n   ${meta}`;
                 }).join("\n");
                 // Concise button labels (single line)
@@ -310,7 +670,9 @@ export class Orchestrator {
                 });
                 const resp = await this.channel.sendInteractive(msg.chatId, `Pick a session to resume:\n\n${listing}`, buttons);
                 if (resp.value) {
-                    this.config.setSession(ws.name, resp.value);
+                    const current = this.config.workspaceByName(ws.name);
+                    if (current)
+                        this.config.upsertWorkspace({ ...current, current_session_id: resp.value, engine_handoff: undefined });
                     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);
@@ -337,25 +699,41 @@ export class Orchestrator {
                 }
                 return;
             }
-            if (!ws) {
-                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);
+            // /engine [name] — select the workspace engine.
+            const engineMatch = msg.text.match(/^\/engine(?:\s+(\S+))?$/);
+            if (engineMatch) {
+                if (!this.config.isAuthorized(user.id)) {
+                    await this.channel.sendMessage(msg.chatId, "Not authorized to select an engine.");
+                    return;
                 }
-                else {
-                    log.info("[msg] no workspace for chat %s", msg.chatId);
+                await this.selectEngine(msg, engineMatch[1]);
+                return;
+            }
+            // /model [name] — show or set the per-workspace model override
+            const modelMatch = msg.text.match(/^\/model(?:\s+(\S+))?$/);
+            if (modelMatch) {
+                if (!ws) {
                     await this.channel.sendMessage(msg.chatId, "No workspace linked to this chat.");
+                    return;
                 }
+                const requested = modelMatch[1];
+                if (!requested) {
+                    await this.channel.sendMessage(msg.chatId, ws.model ? `Saved model: ${ws.model}` : "No model override set. New sessions use the engine's default.");
+                    return;
+                }
+                if (requested === "default") {
+                    this.config.setModel(ws.name, undefined);
+                    await this.channel.sendMessage(msg.chatId, "Model override cleared. Your current session is kept; use /new to start with the engine's default.");
+                    log.info("[cmd] workspace %s model override cleared", ws.name);
+                    return;
+                }
+                this.config.setModel(ws.name, requested);
+                await this.channel.sendMessage(msg.chatId, `Model set to ${requested} for the next turn.`);
+                log.info("[cmd] workspace %s model → %s", ws.name, requested);
+                return;
+            }
+            if (!ws) {
+                await this.channel.sendMessage(msg.chatId, "No workspace linked to this chat. Create a workspace with a manual chat from home or another workspace, then send /connect <workspace> here.");
                 return;
             }
             this.enqueueMessage(msg, ws, state);
@@ -376,13 +754,25 @@ export class Orchestrator {
                         replyToMessageId: turnState.replyToMessageId ?? undefined,
                     });
                     break;
+                case "text_chunk": {
+                    if (turnState.staySilent)
+                        break;
+                    await this.routeTextChunk(chatId, event.text, state, turnState);
+                    break;
+                }
                 case "tool_use": {
+                    // Flush streaming text — final edit with markdown formatting
+                    await this.flushTextSegment(chatId, state, turnState);
+                    state.textHandle = null;
+                    state.textBuffer = "";
+                    state.textPublishedLength = 0;
                     // 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);
+                    const { tool } = event;
+                    if (tool.toolName === "TodoWrite") {
+                        const text = formatTodoList(tool);
                         if (state.todoHandle) {
                             try {
                                 await this.channel.editMessage(chatId, state.todoHandle, text);
@@ -398,13 +788,13 @@ export class Orchestrator {
                         }
                         break;
                     }
-                    if (event.toolName === "EnterPlanMode") {
+                    if (tool.toolName === "EnterPlanMode") {
                         await this.channel.sendMessage(chatId, "📋 Planning");
                         break;
                     }
-                    if (displayHandledTools.has(event.toolName))
+                    if (displayHandledTools.has(tool.toolName))
                         break;
-                    const line = formatToolStatusLine(event.toolName, event.input);
+                    const line = formatToolStatusLine(tool);
                     if (state.toolCallHandle) {
                         try {
                             await this.channel.editMessage(chatId, state.toolCallHandle, line);
@@ -422,16 +812,10 @@ export class Orchestrator {
                 }
                 case "tool_result":
                     break;
-                case "rate_limit": {
-                    const resetMsg = event.resetsAt
-                        ? ` Resets at ${new Date(event.resetsAt).toLocaleTimeString()}.`
-                        : "";
-                    log.warn(`[turn] rate limit: ${event.status}${resetMsg}`);
-                    await this.channel.sendMessage(chatId, `⚠️ Rate limited (${event.status}).${resetMsg}`);
-                    break;
-                }
+                case "plan_usage":
+                    break; // Captured account-wide in executeTurn.
                 case "done":
-                    // Handled inline in executeTurn (task vs workspace need different session storage)
+                    // Handled inline in executeTurn for session persistence.
                     break;
                 case "error":
                     log.error(`[turn] error: ${event.message}`);
@@ -445,6 +829,66 @@ export class Orchestrator {
             log.warn({ err }, "[route] failed to relay %s event to channel", event.type);
         }
     }
+    async routeTextChunk(chatId, text, state, turnState) {
+        state.textBuffer += text;
+        while (state.textBuffer.length > STREAM_EDIT_LIMIT) {
+            const splitAt = streamSplitPoint(state.textBuffer, STREAM_EDIT_LIMIT);
+            const segment = state.textBuffer.slice(0, splitAt);
+            state.textBuffer = state.textBuffer.slice(state.textBuffer.charAt(splitAt) === "\n" ? splitAt + 1 : splitAt);
+            await this.publishTextSegment(chatId, segment, state, turnState, true);
+            state.textHandle = null;
+            state.textPublishedLength = 0;
+        }
+        if (state.textBuffer.length > 0
+            && (state.textHandle
+                ? state.textBuffer.length - state.textPublishedLength >= STREAM_EDIT_DELTA
+                : state.textBuffer.length >= STREAM_INITIAL_EDIT_MIN)) {
+            await this.publishTextSegment(chatId, state.textBuffer, state, turnState, false);
+        }
+    }
+    async publishTextSegment(chatId, text, state, turnState, final) {
+        const plainOpts = { format: "plain" };
+        if (state.textHandle) {
+            try {
+                await this.channel.editMessage(chatId, state.textHandle, text, final ? undefined : plainOpts);
+                state.textPublishedLength = text.length;
+                return;
+            }
+            catch (err) {
+                if (isUnchangedMessageError(err)) {
+                    state.textPublishedLength = text.length;
+                    return;
+                }
+                if (isTransientChannelError(err))
+                    return;
+                state.textHandle = null;
+                state.textPublishedLength = 0;
+            }
+        }
+        const handles = await this.channel.sendMessage(chatId, text, {
+            ...(final ? {} : plainOpts),
+            replyToMessageId: !state.textReplySent ? (turnState.replyToMessageId ?? undefined) : undefined,
+        });
+        state.textHandle = handles[0] ?? null;
+        state.textPublishedLength = text.length;
+        state.textReplySent = true;
+    }
+    async flushTextSegment(chatId, state, turnState) {
+        if (!state.textBuffer)
+            return;
+        if (!state.textHandle) {
+            try {
+                await this.publishTextSegment(chatId, state.textBuffer, state, turnState, true);
+            }
+            catch { /* best effort */ }
+            return;
+        }
+        try {
+            await this.channel.editMessage(chatId, state.textHandle, state.textBuffer);
+            state.textPublishedLength = state.textBuffer.length;
+        }
+        catch { /* best effort */ }
+    }
     buildMcpTools(chatId, behavior, turnState) {
         const tools = [
             tool("send_file", "Send a file or image to the current chat conversation", {
@@ -463,33 +907,234 @@ export class Orchestrator {
                 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"),
+        // Scheduled prompts run in normal workspace sessions.
+        if (this.scheduler) {
+            const sched = this.scheduler;
+            tools.push(tool("schedule_create", "Create a scheduled prompt. Accepts a cron expression for recurring, or an ISO timestamp for one-off (auto-deleted after firing). For timestamps, check current time first to ensure correctness.", {
+                cron: z.string().describe("Cron expression (e.g. '0 9 * * *') or ISO timestamp (e.g. '2026-05-03T15:00:00') for one-off. Check current time before setting timestamps."),
+                prompt: z.string().describe("The prompt text to run on schedule"),
+                timezone: z.string().optional().describe("IANA timezone (e.g. 'America/Los_Angeles'). Defaults to system timezone"),
             }, async (args) => {
-                if (this.config.workspaceByName(args.name)) {
-                    throw new Error(`Workspace "${args.name}" already exists. Choose a different name.`);
+                const entry = {
+                    id: crypto.randomUUID().slice(0, 8),
+                    cron: args.cron,
+                    prompt: args.prompt,
+                    enabled: true,
+                    timezone: args.timezone,
+                    createdAt: Date.now(),
+                };
+                sched.add(entry);
+                const isDate = !isNaN(new Date(args.cron).getTime());
+                return { content: [{ type: "text", text: `Schedule "${entry.id}" created: ${args.cron}${args.timezone ? ` (${args.timezone})` : ""}${isDate ? " [one-off]" : ""}` }] };
+            }), tool("schedule_list", "List all scheduled prompts", {}, async () => {
+                const entries = sched.list();
+                if (entries.length === 0) {
+                    return { content: [{ type: "text", text: "No schedules configured." }] };
                 }
-                fs.mkdirSync(args.cwd, { recursive: true });
-                this.config.upsertWorkspace({
+                const lines = entries.map((e) => `• ${e.id} — ${e.enabled ? "✓" : "✗"} ${e.cron}${e.timezone ? ` (${e.timezone})` : ""}\n  ${e.prompt.slice(0, 80)}`);
+                return { content: [{ type: "text", text: lines.join("\n") }] };
+            }), tool("schedule_delete", "Delete a scheduled prompt", {
+                id: z.string().describe("Schedule ID to delete"),
+            }, async (args) => {
+                sched.remove(args.id);
+                return { content: [{ type: "text", text: `Schedule "${args.id}" deleted.` }] };
+            }), tool("schedule_toggle", "Enable or disable a scheduled prompt", {
+                id: z.string().describe("Schedule ID to toggle"),
+                enabled: z.boolean().describe("Whether to enable or disable the schedule"),
+            }, async (args) => {
+                sched.toggle(args.id, args.enabled);
+                return { content: [{ type: "text", text: `Schedule "${args.id}" ${args.enabled ? "enabled" : "disabled"}.` }] };
+            }));
+        }
+        // Workspace tools are available in every workspace conversation.
+        if (this.config.workspaceByChat(chatId)) {
+            const self = this.config.workspaceByChat(chatId);
+            const peers = this.config.listWorkspaces().filter((w) => w.name !== self?.name);
+            const projectNames = this.config.listProjects().map((p) => `"${p.name}"`).join(", ") || "(none)";
+            tools.push(tool("list_workspaces", "List workspaces with their project, focus, and whether a chat is connected. Covers every project by default; pass project to scope it. Use this to find a name for message_workspace.", {
+                project: z.string().optional().describe("Only list workspaces in this project; omit for all projects"),
+            }, async (args) => {
+                const all = this.config.listWorkspaces();
+                const listed = args.project ? all.filter((w) => w.project === args.project) : all;
+                if (listed.length === 0) {
+                    const known = this.config.listProjects().map((p) => p.name).join(", ") || "(none)";
+                    return { content: [{ type: "text", text: args.project
+                                    ? `No workspaces in project "${args.project}". Known projects: ${known}.`
+                                    : "No workspaces." }] };
+                }
+                const lines = listed
+                    .map((w) => [
+                    w.name === self?.name ? `${w.name} (you)` : w.name,
+                    `project: ${w.project ?? "(none)"}`,
+                    w.chat_id ? "connected" : "awaiting /connect",
+                    w.description ? `— ${w.description}` : "",
+                ].filter(Boolean).join(" | "))
+                    .sort();
+                return { content: [{ type: "text", text: lines.join("\n") }] };
+            }), tool("message_workspace", "Send a message to another workspace, in any project. It is delivered as a turn there and rendered in that chat; it can reply by calling message_workspace back. Use list_workspaces to find a name.", {
+                workspace: z.string().describe("Target workspace name; see list_workspaces"),
+                message: z.string().describe("The message to send"),
+                summary: z.string().describe("One-line gist shown in both chats in place of the full message"),
+            }, async (args) => {
+                const target = this.config.workspaceByName(args.workspace);
+                if (!target) {
+                    return { content: [{ type: "text", text: `No workspace named "${args.workspace}". Call list_workspaces to see the ${peers.length} reachable.` }] };
+                }
+                if (self && target.name === self.name) {
+                    return { content: [{ type: "text", text: "Cannot message yourself." }] };
+                }
+                const fromName = self ? self.name : "unknown";
+                const ok = this.deliverToWorkspace(target.name, { kind: "peer", workspaceName: fromName }, args.message);
+                if (!ok) {
+                    return { content: [{ type: "text", text: `Failed to deliver to "${target.name}".` }] };
+                }
+                await this.channel.sendMessage(chatId, `→ sent to ${target.name}: ${args.summary}`);
+                await this.channel.sendMessage(target.chat_id, `← from ${fromName}: ${args.summary}`).catch(() => { });
+                log.info("[tool] message_workspace: %s → %s", fromName, target.name);
+                return { content: [{ type: "text", text: `Delivered to ${target.name}.` }] };
+            }), tool("project_create", `Create a Project around an existing workspace so it can host peers. A workspace that is a peer of another Project is adopted out of it; one that is its Project's main cannot be (reassign that main first). Defaults to the current workspace. Existing Projects: ${projectNames}.`, {
+                name: z.string().describe("New Project name"),
+                description: z.string().describe("What the Project is about"),
+                main_workspace: z.string().optional().describe("Existing workspace to make the Project main; must not be another Project's main. Defaults to the current workspace"),
+            }, async (args) => {
+                if (this.config.projectByName(args.name)) {
+                    return { content: [{ type: "text", text: `Project "${args.name}" already exists.` }] };
+                }
+                const mainName = args.main_workspace ?? self?.name;
+                if (!mainName) {
+                    return { content: [{ type: "text", text: "No current workspace to use as the Project main." }] };
+                }
+                const main = this.config.workspaceByName(mainName);
+                if (!main) {
+                    return { content: [{ type: "text", text: `No workspace named "${mainName}".` }] };
+                }
+                // A peer can be adopted out of its project; its main cannot — that would orphan the project.
+                const currentProject = this.config.listProjects().find((p) => p.main_workspace === main.name);
+                if (currentProject) {
+                    return { content: [{ type: "text", text: `Workspace "${main.name}" already belongs to project "${currentProject.name}" as its main. Reassign that project's main via project_update first, or archive it.` }] };
+                }
+                this.config.upsertWorkspace({ ...main, project: args.name });
+                this.config.addProject({
                     name: args.name,
-                    cwd: args.cwd,
-                    chat_id: chatId,
-                    current_session_id: null,
-                    behavior: args.behavior,
+                    description: args.description,
+                    main_workspace: main.name,
                 });
-                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"),
+                const grouping = main.chat_id ? await this.groupChat(args.name, main.chat_id) : undefined;
+                log.info("[tool] project_create: %s (main %s)", args.name, main.name);
+                return { content: [{ type: "text", text: `Project "${args.name}" created with "${main.name}" as its main workspace.${grouping ? `\n\n${grouping}` : ""}` }] };
+            }), tool("workspace_create", `Hand a strand of work to a NEW peer agent with its own chat, directory, and conversation. The peer joins your own project by default. Pass project to put it somewhere else: name an existing project to join it, or any new name to start that project with this peer as its main. Known projects: ${projectNames}. Prepare cwd yourself first — create a git worktree, clone, or plain directory the way this host and repository expect, and keep owning it; ClearClaw only reads the path and never creates or deletes it. The brief is the peer's first message: goal, decisions already made, and scope, leaving unstated implementation choices open. For an existing workspace use message_workspace instead.`, {
+                name: z.string().min(1).describe("Unique short workspace name"),
+                cwd: z.string().min(1).describe("Absolute path to a directory you have already prepared"),
+                brief: z.string().min(1).describe("Goal, agreed decisions, and scope; delivered as the peer's first message"),
+                description: z.string().optional().describe("One-line focus; defaults to the first 160 characters of the brief's first line"),
+                project: z.string().optional().describe("Existing project to join, or a new project name to create with this peer as its main; defaults to your own project"),
+                behavior: z.enum(["assistant", "relay"]).optional(),
+                engine: z.string().optional(),
+                model: z.string().optional(),
             }, 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." }] };
+                const currentSelf = this.config.workspaceByChat(chatId);
+                if (!currentSelf)
+                    return { content: [{ type: "text", text: "The source workspace is no longer connected." }] };
+                // An unknown name creates that project; a legacy caller with none falls back to the workspace name.
+                const requested = args.project ?? currentSelf.project;
+                const project = requested ? this.config.projectByName(requested) : undefined;
+                const newProjectName = project ? undefined : requested ?? args.name;
+                const base = project ? this.config.workspaceByName(project.main_workspace) : currentSelf;
+                if (!base)
+                    return { content: [{ type: "text", text: `Project "${project.name}" has no main workspace.` }] };
+                const resolved = this.peerRuntime(base, args);
+                if (resolved.error)
+                    return { content: [{ type: "text", text: resolved.error }] };
+                const invalid = this.validateNewWorkspace(args, newProjectName);
+                if (invalid)
+                    return { content: [{ type: "text", text: invalid }] };
+                const runtime = resolved.runtime;
+                const automatic = !!(this.channel.createProjectChat && this.channel.closeProjectChat
+                    && (!base.chat_id || this.channel.ownsId(base.chat_id)));
+                const destination = project ? `project "${project.name}"` : `new project "${newProjectName}"`;
+                const response = await this.channel.sendInteractive(chatId, `Create workspace "${args.name}" at ${args.cwd} in ${destination} using ${runtime.engine ?? this.config.defaultEngine}${runtime.model ? ` / ${runtime.model}` : ""}?\n\n${args.brief.slice(0, 300)}${automatic ? "" : "\nAutomatic chat creation is unavailable for this destination."}`, [[...(automatic ? [{ label: "Create chat", value: "spawn" }] : []),
+                        { label: "Manual chat", value: "manual" }, { label: "Cancel", value: "cancel" }]]);
+                if (response.value !== "spawn" && response.value !== "manual")
+                    return { content: [{ type: "text", text: "Workspace creation cancelled." }] };
+                return this.createWorkspace(chatId, currentSelf.name, project, newProjectName, base, { ...args, manual: response.value === "manual" }, runtime);
+            }), tool("workspace_archive", "Archive a workspace: try to close its bound chat, then unbind it even if chat closure fails. Reports any closure error. Always leaves the workspace directory on disk; clean that up with your own tooling. Cannot archive 'default'.", {
+                name: z.string().describe("Workspace to archive"),
+            }, async (args) => {
+                if (args.name === "default") {
+                    return { content: [{ type: "text", text: "Cannot archive the home workspace." }] };
+                }
+                const target = this.config.workspaceByName(args.name);
+                if (!target) {
+                    return { content: [{ type: "text", text: `No workspace named "${args.name}".` }] };
+                }
+                const project = target.project ? this.config.projectByName(target.project) : undefined;
+                if (project?.main_workspace === args.name) {
+                    const peers = this.config.listWorkspaces().filter((w) => w.project === project.name && w.name !== args.name);
+                    if (peers.length > 0) {
+                        return { content: [{ type: "text", text: `Cannot archive "${args.name}": it's the main of project "${project.name}", which still has peers (${peers.map((p) => `"${p.name}"`).join(", ")}). Archive those first, or reassign the main via project_update.` }] };
+                    }
+                }
+                const resp = await this.channel.sendInteractive(chatId, `Archive workspace "${args.name}" (${target.cwd})? Its registration will be removed even if closing its chat fails. Its directory is left in place.`, [[{ label: "Archive", value: "yes" }, { label: "Cancel", value: "no" }]]);
+                if (resp.value !== "yes") {
+                    return { content: [{ type: "text", text: "Archive cancelled by the user." }] };
+                }
+                if (target.chat_id && (!this.channel.ownsId(target.chat_id) || !this.channel.closeProjectChat)) {
+                    return { content: [{ type: "text", text: "Cannot archive: this channel cannot close the workspace's chat." }] };
+                }
+                // Whole Telegram chats and deleted topics can be impossible to close.
+                let archiveNote = "";
+                try {
+                    if (target.chat_id)
+                        await this.channel.closeProjectChat(target.chat_id, target.project);
+                }
+                catch (err) {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    log.warn("[tool] workspace_archive: chat closure failed, unbinding anyway: %s", reason);
+                    archiveNote = ` Chat closure failed (${reason}).`;
+                }
+                this.config.removeWorkspace(args.name);
+                const removedProject = project?.main_workspace === args.name ? project : undefined;
+                if (removedProject)
+                    this.config.removeProject(removedProject.name);
+                archiveNote += " Its directory is left in place; clean up with your own tooling.";
+                log.info("[tool] workspace_archive: %s", args.name);
+                return { content: [{ type: "text", text: `Workspace "${args.name}" archived.${archiveNote}` }] };
+            }), tool("project_update", "Update a project's shared context: its description, or reassign its main workspace.", {
+                name: z.string().describe("Project name to update"),
+                description: z.string().optional().describe("New description (what the project is about)"),
+                main_workspace: z.string().optional().describe("Reassign the project's main workspace"),
+            }, async (args) => {
+                const proj = this.config.projectByName(args.name);
+                if (!proj) {
+                    return { content: [{ type: "text", text: `No project named "${args.name}".` }] };
+                }
+                if (args.main_workspace && !this.config.workspaceByName(args.main_workspace)) {
+                    return { content: [{ type: "text", text: `No workspace named "${args.main_workspace}".` }] };
+                }
+                if (args.main_workspace && this.config.workspaceByName(args.main_workspace)?.project !== proj.name) {
+                    return { content: [{ type: "text", text: `Choose a main workspace that already belongs to project "${proj.name}".` }] };
+                }
+                this.config.addProject({
+                    name: proj.name,
+                    description: args.description ?? proj.description,
+                    main_workspace: args.main_workspace ?? proj.main_workspace,
+                });
+                log.info("[tool] project_update: %s", args.name);
+                return { content: [{ type: "text", text: `Project "${args.name}" updated.` }] };
+            }), tool("workspace_update", "Update what a workspace is working on (its description). Use /engine and /behavior in that workspace's chat to change runtime settings.", {
+                name: z.string().describe("Workspace to update"),
+                description: z.string().optional().describe("What this workspace is currently working on"),
+            }, async (args) => {
+                const ws = this.config.workspaceByName(args.name);
+                if (!ws) {
+                    return { content: [{ type: "text", text: `No workspace named "${args.name}".` }] };
+                }
+                this.config.upsertWorkspace({
+                    ...ws,
+                    description: args.description ?? ws.description,
+                });
+                log.info("[tool] workspace_update: %s", args.name);
+                return { content: [{ type: "text", text: `Workspace "${args.name}" updated.` }] };
             }));
         }
         if (behavior === "assistant") {
@@ -512,78 +1157,85 @@ export class Orchestrator {
         }
         return tools;
     }
-    async handlePermission(req, chatId) {
+    async handlePermission(tool, chatId) {
         // Always auto-allow ClearClaw's own MCP tools
-        if (req.toolName.startsWith("mcp__clearclaw__")) {
-            log.info(`[perm] ${req.toolName} → auto-allow`);
+        if (tool.toolName.startsWith("mcp__clearclaw__")) {
+            log.info(`[perm] ${tool.toolName} → auto-allow`);
             return { decision: "allow" };
         }
-        log.info(`[perm] ${req.toolName}`);
-        // Custom tool handler
-        const handler = permissionHandlers.get(req.toolName);
+        log.info(`[perm] ${tool.toolName}`);
+        // Custom tool handler (Claude Code specific tools like EnterPlanMode)
+        const handler = permissionHandlers.get(tool.toolName);
         if (handler) {
-            const result = handler(req.input, req.description);
+            const result = handler(tool);
             if (result === null) {
-                log.info(`[perm] ${req.toolName} → auto-allow (handler)`);
+                log.info(`[perm] ${tool.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}"` : ""}`);
+                log.info(`[perm] ${tool.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);
+                log.warn({ err }, "[perm] failed to send prompt for %s, auto-denying", tool.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), [
+            const resp = await this.channel.sendInteractive(chatId, formatPermissionPrompt(tool), [
                 [{ 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}"` : ""}`);
+            log.info(`[perm] ${tool.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);
+            log.warn({ err }, "[perm] failed to send prompt for %s, auto-denying", tool.toolName);
             return { decision: "deny", message: "Permission prompt could not be delivered to chat — denied automatically." };
         }
     }
     async updateStatusMessage(chatId, state) {
-        const mode = state.permissionMode ?? this.config.permissionMode;
+        const ws = this.config.workspaceByChat(chatId);
+        const baseMode = this.baseMode(ws ? this.effectiveBehavior(ws) : "relay");
+        const mode = state.permissionMode ?? baseMode;
         const modeLabel = MODE_OPTIONS.find((o) => o.value === mode)?.label ?? mode;
         let text;
         if (state.stats) {
-            const pct = state.stats.contextWindow > 0
-                ? Math.round((state.stats.contextUsed / state.stats.contextWindow) * 100)
-                : 0;
-            text = `🤖 ${formatModelName(state.stats.model)} ${pct}% | 🔒 ${modeLabel}`;
+            const usage = state.stats.contextWindow > 0
+                ? `${Math.round((state.stats.contextUsed / state.stats.contextWindow) * 100)}%`
+                : "usage n/a";
+            const displayName = state.stats.modelLabel ?? state.stats.model;
+            text = `🤖 ${displayName ? `${displayName} ` : ""}${usage}`;
         }
         else {
-            text = `🔒 ${modeLabel}`;
+            text = "";
         }
+        if (mode !== baseMode)
+            text += `${text ? " | " : ""}🔒 ${modeLabel}`;
+        const engine = ws?.engine ?? state.engineName ?? this.config.defaultEngine;
+        text += `${text ? " | " : ""}${engine}`;
+        const maxLength = this.channel.statusMaxLength ?? 4096;
+        if (text.length > maxLength - 80)
+            text = `${text.slice(0, maxLength - 81)}…`;
+        const usage = this.planUsage.get(engine) ?? {
+            windows: new Map(this.engines.get(engine)?.planUsageWindows?.map((window) => [window.id, window])),
+        };
+        const quota = formatPlanUsage(usage, maxLength - text.length - 3);
+        if (quota)
+            text += `${text ? " | " : ""}${quota}`;
         if (text === state.lastStatusText)
             return;
-        await this.channel.updateStatus(chatId, text);
-        state.lastStatusText = text;
-    }
-    /** Read default workspace CLAUDE.md to append to non-default workspace sessions. */
-    readDefaultPrompt() {
         try {
-            const content = fs.readFileSync(this.config.defaultPromptPath, "utf-8").trim();
-            return content || undefined;
+            await this.channel.updateStatus(chatId, text);
+            state.lastStatusText = text;
         }
-        catch {
-            return undefined;
+        catch (err) {
+            log.warn({ err }, "[status] failed to update status for chat %s", chatId);
         }
     }
 }
-/** Strip "claude-" prefix and date suffix from model ID. e.g. "claude-opus-4-6-20250514" → "opus-4-6" */
-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)
@@ -602,15 +1254,76 @@ function formatReplyLine(replyTo) {
  * 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) {
+function formatTimestamp() {
+    const now = new Date();
+    const day = now.toLocaleDateString("en-US", { weekday: "short" });
+    const date = now.toLocaleDateString("en-CA"); // YYYY-MM-DD
+    const time = now.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false, timeZoneName: "short" });
+    return `${date} ${day} ${time}`;
+}
+function senderLabel(origin) {
+    switch (origin.kind) {
+        // Keep the ID inside the brackets, because stripPromptPrefix stops at the first colon outside them.
+        case "user": return `[user ${origin.user.id}] ${origin.user.handle ? `${origin.user.name} (@${origin.user.handle})` : origin.user.name}`;
+        case "scheduler": return `[scheduler] ${origin.scheduleId}`;
+        case "peer": return `[peer] ${origin.workspaceName}`;
+        default: {
+            const _exhaustive = origin;
+            return _exhaustive;
+        }
+    }
+}
+/**
+ * A lone slash-command message (built-in like `/compact`, `/context`, or a
+ * custom `.claude/commands/<name>`) must reach the engine verbatim: the CLI
+ * only intercepts a slash command when it sits at position 0 of the prompt.
+ * buildPrompt's `[ts] sender:` framing would push it off position 0, so the
+ * command would be sent to the model as plain text instead of executed.
+ *
+ * ClearClaw's own commands (/new, /resume, /behavior, …) are handled and
+ * returned before the turn starts, so any leading-slash message that reaches
+ * here is a pass-through command. Restricted to single, user-typed messages —
+ * a slash buried in a batch, or in a scheduler/peer prompt, is not a command.
+ * Returns the bare command text, or null to fall back to buildPrompt.
+ */
+function slashCommandPrompt(messages) {
+    if (messages.length !== 1)
+        return null;
+    const msg = messages[0];
+    if (msg.origin.kind !== "user")
+        return null;
+    const text = msg.text.trim();
+    return text.startsWith("/") ? text : null;
+}
+function streamSplitPoint(text, limit) {
+    if (text.length <= limit)
+        return text.length;
+    const newlineAt = text.lastIndexOf("\n", limit);
+    return newlineAt > 0 ? newlineAt : limit;
+}
+function isTransientChannelError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.includes("Too Many Requests") || message.includes("429:");
+}
+function isUnchangedMessageError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.includes("message is not modified");
+}
+export function buildPrompt(messages) {
+    const ts = formatTimestamp();
     return messages.map((msg) => {
-        const sender = msg.user.handle ? `${msg.user.name} (@${msg.user.handle})` : msg.user.name;
+        const sender = senderLabel(msg.origin);
         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}`;
+        return `${replyLine}[${ts}] ${msgIdPrefix}${sender}: ${msg.text}`;
     }).join("\n");
 }
+/** Preserve the original source across multiple switches before a handoff succeeds. */
+function captureHandoff(ctx, engine) {
+    const sessionId = ctx.current_session_id;
+    return ctx.engine_handoff ?? (sessionId ? { engine, sessionId, cwd: ctx.cwd } : undefined);
+}
+function sameHandoff(left, right) {
+    return left?.engine === right.engine && left.sessionId === right.sessionId && left.cwd === right.cwd;
+}
 //# sourceMappingURL=orchestrator.js.map