clearclaw 0.2.0 → 0.4.0

package/dist/format.d.ts

@@ -1,19 +1,28 @@
 /**
- * Diff formatting utilities for tool_use display in Telegram.
+ * Formatting utilities for Telegram display.
  *
- * Uses the `diff` library for proper unified diffs with context lines.
+ * Uses the `diff` library for unified diffs in Edit permission prompts.
  */
 /**
- * Format a tool_use event for display. Returns a MarkdownV2 string.
- * Edit/Write get rich formatting; all others get a one-line status.
+ * Summary line for the rolling tool message after a turn completes.
+ * e.g. "🔧 3× Read, 2× Grep, 1× Bash"
  */
-export declare function formatToolUse(toolName: string, input: Record<string, unknown>): string;
+export declare function formatToolCallSummary(toolCalls: Record<string, number>): string | null;
 /**
- * Format a tool_result event for display. Returns a MarkdownV2 code block
- * with input + output, or null if suppressed/empty.
+ * Short one-liner for the rolling tool message. Includes key detail
+ * but truncated to stay compact.
  */
-export declare function formatToolResult(toolName: string, output: string): string | null;
+export declare function formatToolStatusLine(toolName: string, input: Record<string, unknown>): string;
 /**
- * Human-readable one-liner for a tool invocation (used in permission prompts).
+ * Format a permission prompt for display. Returns a MarkdownV2 string.
+ * Edit/Write include the diff/preview; other tools get a one-line description.
+ */
+export declare function formatPermissionPrompt(toolName: string, input: Record<string, unknown>, description: string): string;
+/**
+ * Relative time string: "just now", "5m ago", "2h ago", "3d ago".
+ */
+export declare function timeAgo(epochMs: number): 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;

package/dist/format.js

@@ -1,22 +1,59 @@
 /**
- * Diff formatting utilities for tool_use display in Telegram.
+ * Formatting utilities for Telegram display.
  *
- * Uses the `diff` library for proper unified diffs with context lines.
+ * Uses the `diff` library for unified diffs in Edit permission prompts.
  */
 import { createTwoFilesPatch } from "diff";
 const MAX_LINES = 200;
+const MAX_STATUS_LEN = 60;
 /**
- * Format a tool_use event for display. Returns a MarkdownV2 string.
- * Edit/Write get rich formatting; all others get a one-line status.
+ * Summary line for the rolling tool message after a turn completes.
+ * e.g. "🔧 3× Read, 2× Grep, 1× Bash"
  */
-export function formatToolUse(toolName, input) {
+export function formatToolCallSummary(toolCalls) {
+    const entries = Object.entries(toolCalls);
+    if (entries.length === 0)
+        return null;
+    const breakdown = entries
+        .sort(([, a], [, b]) => b - a)
+        .map(([name, count]) => `${count}× ${name}`)
+        .join(", ");
+    return `🔧 ${breakdown}`;
+}
+/**
+ * Short one-liner for the rolling tool message. Includes key detail
+ * but truncated to stay compact.
+ */
+export function formatToolStatusLine(toolName, input) {
+    const full = `🔧 ${formatToolStatus(toolName, input)}`;
+    if (full.length <= MAX_STATUS_LEN)
+        return full;
+    return `${full.slice(0, MAX_STATUS_LEN - 1)}…`;
+}
+/**
+ * Format a permission prompt for display. Returns a MarkdownV2 string.
+ * Edit/Write include the diff/preview; other tools get a one-line description.
+ */
+export function formatPermissionPrompt(toolName, input, description) {
     if (toolName === "Edit") {
-        return formatEditDiff(input);
+        const edit = input;
+        const patch = createTwoFilesPatch(`a/${edit.file_path}`, `b/${edit.file_path}`, edit.old_string, edit.new_string, "", "", { context: 3 });
+        const lines = patch.split("\n");
+        const start = lines.findIndex((l) => l.startsWith("---"));
+        const diffLines = start >= 0 ? lines.slice(start) : lines;
+        const body = truncateLines(diffLines, MAX_LINES);
+        return `🔐 Allow Edit? ${edit.file_path}\n\`\`\`diff\n${body}\n\`\`\``;
     }
     if (toolName === "Write") {
-        return formatWritePreview(input);
+        const write = input;
+        const lines = write.content.split("\n");
+        const body = truncateLines(lines, MAX_LINES);
+        return `🔐 Allow Write? ${write.file_path} (${lines.length} lines)\n\`\`\`\n${body}\n\`\`\``;
     }
-    return escapeMarkdownV2(`🔧 ${formatToolStatus(toolName, input)}`);
+    // Non-Edit/Write tools: emoji header + detail in code block
+    const detail = formatToolDetail(toolName, input);
+    const body = truncateLines(detail.split("\n"), MAX_LINES);
+    return `🔐 Allow ${toolName}?\n\`\`\`\n${body}\n\`\`\``;
 }
 function formatToolStatus(toolName, input) {
     switch (toolName) {
@@ -24,6 +61,10 @@ function formatToolStatus(toolName, input) {
             return `Bash: ${input.command ?? "(unknown)"}`;
         case "Read":
             return `Read: ${input.file_path ?? "(unknown)"}`;
+        case "Edit":
+            return `Edit: ${input.file_path ?? "(unknown)"}`;
+        case "Write":
+            return `Write: ${input.file_path ?? "(unknown)"}`;
         case "Glob":
             return `Glob: ${input.pattern ?? "(unknown)"}`;
         case "Grep":
@@ -38,22 +79,43 @@ function formatToolStatus(toolName, input) {
             return toolName;
     }
 }
-function formatEditDiff(input) {
-    const patch = createTwoFilesPatch(`a/${input.file_path}`, `b/${input.file_path}`, input.old_string, input.new_string, "", "", { context: 3 });
-    // Strip the "Index:" / "===" preamble, keep --- / +++ / @@ lines onward.
-    const lines = patch.split("\n");
-    const start = lines.findIndex((l) => l.startsWith("---"));
-    const diffLines = start >= 0 ? lines.slice(start) : lines;
-    const body = truncateLines(diffLines, MAX_LINES);
-    const header = escapeMarkdownV2(`\u270f\ufe0f Edit: ${input.file_path}`);
-    return `${header}\n\`\`\`diff\n${body}\n\`\`\``;
+/** Extract the key detail for a tool's permission prompt (command, query, URL, etc.). */
+function formatToolDetail(toolName, input) {
+    switch (toolName) {
+        case "Bash":
+            return String(input.command ?? "");
+        case "Read":
+        case "Edit":
+        case "Write":
+            return String(input.file_path ?? "");
+        case "Glob":
+        case "Grep":
+            return String(input.pattern ?? "");
+        case "WebSearch":
+            return String(input.query ?? "");
+        case "WebFetch":
+            return String(input.url ?? "");
+        case "Agent":
+            return String(input.description ?? "");
+        default:
+            return JSON.stringify(input, null, 2);
+    }
 }
-function formatWritePreview(input) {
-    const lines = input.content.split("\n");
-    const totalLines = lines.length;
-    const body = truncateLines(lines, MAX_LINES);
-    const header = escapeMarkdownV2(`\ud83d\udcc4 Write: ${input.file_path} (${totalLines} lines)`);
-    return `${header}\n\`\`\`\n${body}\n\`\`\``;
+/**
+ * Relative time string: "just now", "5m ago", "2h ago", "3d ago".
+ */
+export function timeAgo(epochMs) {
+    const seconds = Math.floor((Date.now() - epochMs) / 1000);
+    if (seconds < 60)
+        return "just now";
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
 }
 function truncateLines(lines, max) {
     if (lines.length <= max) {
@@ -63,33 +125,8 @@ function truncateLines(lines, max) {
     const remaining = lines.length - max;
     return `${shown}\n... (${remaining} more lines)`;
 }
-// Tools whose output is noisy or redundant (tool_use already shows input).
-// New/unknown tools show by default.
-const SUPPRESSED_RESULTS = new Set([
-    "Read", "Edit", "Write", "Glob", "Agent",
-    "TodoWrite", "NotebookEdit", "EnterPlanMode", "ExitPlanMode",
-]);
-/**
- * Format a tool_result event for display. Returns a MarkdownV2 code block
- * with input + output, or null if suppressed/empty.
- */
-export function formatToolResult(toolName, output) {
-    if (SUPPRESSED_RESULTS.has(toolName))
-        return null;
-    if (!output.trim())
-        return null;
-    const body = truncateLines(output.split("\n"), MAX_LINES);
-    return `\`\`\`\n${body}\n\`\`\``;
-}
-/**
- * Escape special characters for MarkdownV2 (outside code blocks).
- * Inside ``` blocks, no escaping is needed.
- */
-function escapeMarkdownV2(text) {
-    return text.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
-}
 /**
- * Human-readable one-liner for a tool invocation (used in permission prompts).
+ * Human-readable one-liner for a tool invocation (used in engine's canUseTool).
  */
 export function formatToolDescription(toolName, input) {
     switch (toolName) {

package/dist/index.js

@@ -4,6 +4,7 @@ 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
@@ -23,8 +24,14 @@ process.on("unhandledRejection", (reason) => {
 async function main() {
     const config = loadConfig();
     initLogger(config.logPath);
-    const workspaceStore = new WorkspaceStore(config.workspacesPath);
-    const channel = new TelegramChannel(config.botToken, config.allowedUserIds);
+    const workspaceStore = new WorkspaceStore(config.workspaceStorePath);
+    let channel;
+    if (config.channel.type === "slack") {
+        channel = new SlackChannel(config.channel.botToken, config.channel.appToken, config.allowedUserIds);
+    }
+    else {
+        channel = new TelegramChannel(config.channel.botToken, config.allowedUserIds);
+    }
     const engine = new ClaudeCodeEngine();
     const orchestrator = new Orchestrator({
         channel,
@@ -32,6 +39,7 @@ async function main() {
         workspaceStore,
         permissionMode: config.permissionMode,
         defaultPromptPath: config.defaultPromptPath,
+        filesPath: config.filesPath,
     });
     await orchestrator.start();
 }

package/dist/orchestrator.d.ts

@@ -6,6 +6,7 @@ export interface OrchestratorOpts {
     workspaceStore: WorkspaceStore;
     permissionMode: PermissionMode;
     defaultPromptPath: string;
+    filesPath: string;
 }
 export declare class Orchestrator {
     private channel;
@@ -13,6 +14,7 @@ export declare class Orchestrator {
     private workspaceStore;
     private permissionMode;
     private defaultPromptPath;
+    private filesPath;
     private chats;
     constructor(opts: OrchestratorOpts);
     private chat;
@@ -20,6 +22,7 @@ export declare class Orchestrator {
     stop(): Promise<void>;
     private handleMessage;
     private routeEngineEvent;
+    private updateStatusMessage;
     /** Read default workspace CLAUDE.md to append to non-default workspace sessions. */
     private readDefaultPrompt;
 }

package/dist/orchestrator.js

@@ -1,13 +1,21 @@
 import fs from "node:fs";
 import path from "node:path";
 import log from "./logger.js";
-import { formatToolUse, formatToolResult } from "./format.js";
+import { saveFile } from "./files.js";
+import { formatToolStatusLine, formatToolCallSummary, formatPermissionPrompt, timeAgo } from "./format.js";
+const MODE_OPTIONS = [
+    { label: "Default", value: "default" },
+    { label: "Accept Edits", value: "acceptEdits" },
+    { label: "Plan", value: "plan" },
+    { label: "Bypass", value: "bypassPermissions" },
+];
 export class Orchestrator {
     channel;
     engine;
     workspaceStore;
     permissionMode;
     defaultPromptPath;
+    filesPath;
     chats = new Map();
     constructor(opts) {
         this.channel = opts.channel;
@@ -15,11 +23,15 @@ export class Orchestrator {
         this.workspaceStore = opts.workspaceStore;
         this.permissionMode = opts.permissionMode;
         this.defaultPromptPath = opts.defaultPromptPath;
+        this.filesPath = opts.filesPath;
     }
     chat(chatId) {
         let s = this.chats.get(chatId);
         if (!s) {
-            s = { busy: false, abort: null };
+            s = {
+                busy: false, abort: null, permissionMode: null, stats: null, lastStatusText: null,
+                toolCallHandle: null,
+            };
             this.chats.set(chatId, s);
         }
         return s;
@@ -46,6 +58,27 @@ export class Orchestrator {
         try {
             log.info(`[msg] ${msg.user.name} (${msg.user.id}) ${msg.text.slice(0, 80)}`);
             const state = this.chat(msg.chatId);
+            // /mode — switch permission mode (works even during active turns)
+            if (msg.text === "/mode") {
+                const currentMode = state.permissionMode ?? this.permissionMode;
+                const buttons = [
+                    MODE_OPTIONS.slice(0, 2).map((opt) => ({
+                        label: opt.value === currentMode ? `✓ ${opt.label}` : opt.label,
+                        value: opt.value,
+                    })),
+                    MODE_OPTIONS.slice(2).map((opt) => ({
+                        label: opt.value === currentMode ? `✓ ${opt.label}` : opt.label,
+                        value: opt.value,
+                    })),
+                ];
+                const resp = await this.channel.sendInteractive(msg.chatId, `Current mode: ${MODE_OPTIONS.find((o) => o.value === currentMode)?.label ?? currentMode}`, buttons);
+                if (resp.value) {
+                    state.permissionMode = resp.value;
+                    await this.updateStatusMessage(msg.chatId, state);
+                    log.info("[cmd] mode → %s", resp.value);
+                }
+                return;
+            }
             // /new — reset session
             if (msg.text === "/new") {
                 const ws = this.workspaceStore.byChat(msg.chatId);
@@ -54,10 +87,58 @@ export class Orchestrator {
                     return;
                 }
                 this.workspaceStore.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.");
                 return;
             }
+            // /resume — switch to a previous session
+            if (msg.text === "/resume") {
+                if (state.busy) {
+                    await this.channel.sendMessage(msg.chatId, "A turn is in progress. Wait for it to finish before switching sessions.");
+                    return;
+                }
+                const ws = this.workspaceStore.byChat(msg.chatId);
+                if (!ws) {
+                    await this.channel.sendMessage(msg.chatId, "No workspace linked to this group.");
+                    return;
+                }
+                const sessions = await this.engine.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
+                const stripped = sessions.map((s) => ({
+                    ...s,
+                    summary: s.summary.replace(/^\[.*?\]:\s*/, ""),
+                }));
+                // 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(" · ");
+                    return `${i + 1}. ${s.summary}${current}\n   ${meta}`;
+                }).join("\n");
+                // Concise button labels (single line)
+                const buttons = stripped.map((s, i) => {
+                    const label = `${i + 1}. ${s.summary}`;
+                    const truncated = label.length > MAX_BTN
+                        ? label.slice(0, MAX_BTN - 1) + "…"
+                        : label;
+                    return [{ label: truncated, value: s.sessionId }];
+                });
+                const resp = await this.channel.sendInteractive(msg.chatId, `Pick a session to resume:\n\n${listing}`, buttons);
+                if (resp.value) {
+                    this.workspaceStore.setSession(ws.name, resp.value);
+                    const picked = stripped.find((s) => s.sessionId === resp.value);
+                    await this.channel.sendMessage(msg.chatId, `Resumed session: ${picked?.summary ?? resp.value}`);
+                    log.info("[cmd] resumed session %s for workspace %s", resp.value, ws.name);
+                }
+                return;
+            }
             // /cancel — abort the running turn
             if (msg.text === "/cancel") {
                 if (state.abort) {
@@ -93,26 +174,52 @@ export class Orchestrator {
             // In group workspaces, prepend sender identity so the engine knows who's talking
             const sender = msg.user.handle ? `${msg.user.name} (@${msg.user.handle})` : msg.user.name;
             const prompt = isDefaultWorkspace ? msg.text : `[${sender}]: ${msg.text}`;
+            // Save attachments to disk for the audit log (failures must not block the turn)
+            if (msg.attachments?.length) {
+                const results = await Promise.allSettled(msg.attachments.map((att) => saveFile(att, ws.name, this.filesPath)));
+                for (const r of results) {
+                    if (r.status === "rejected")
+                        log.warn({ err: r.reason }, "[turn] failed to save attachment");
+                }
+                const saved = results.filter((r) => r.status === "fulfilled").length;
+                if (saved > 0)
+                    log.info("[turn] saved %d/%d attachment(s) for workspace %s", saved, msg.attachments.length, ws.name);
+            }
             try {
                 for await (const event of this.engine.runTurn({
                     sessionId: ws.current_session_id,
                     cwd: ws.cwd,
                     prompt,
-                    permissionMode: this.permissionMode,
+                    attachments: msg.attachments,
+                    permissionMode: state.permissionMode ?? this.permissionMode,
                     appendSystemPrompt,
                     signal: abort.signal,
                     onPermissionRequest: async (req) => {
                         log.info(`[perm] ${req.toolName}`);
-                        const resp = await this.channel.sendInteractive(msg.chatId, `Allow ${req.toolName}?\n${req.description}`, [
-                            { label: "Allow", value: "allow" },
-                            { label: "Deny", value: "deny" },
-                            { label: "Deny+Note", value: "deny", requestText: true },
-                        ]);
-                        log.info(`[perm] ${req.toolName} → ${resp.value || "timeout"}${resp.text ? ` "${resp.text}"` : ""}`);
-                        return {
-                            decision: resp.value === "allow" ? "allow" : "deny",
-                            message: resp.text,
-                        };
+                        try {
+                            const promptText = formatPermissionPrompt(req.toolName, req.input, req.description);
+                            const resp = await this.channel.sendInteractive(msg.chatId, promptText, [
+                                [
+                                    { label: "👍 Allow", value: "allow" },
+                                    { label: "👎 Deny", value: "deny" },
+                                ],
+                                [
+                                    { label: "📝 Deny + Note", value: "deny", requestText: true },
+                                ],
+                            ]);
+                            log.info(`[perm] ${req.toolName} → ${resp.value || "timeout"}${resp.text ? ` "${resp.text}"` : ""}`);
+                            return {
+                                decision: resp.value === "allow" ? "allow" : "deny",
+                                message: resp.text,
+                            };
+                        }
+                        catch (err) {
+                            log.warn({ err }, "[perm] failed to send prompt for %s, auto-denying", req.toolName);
+                            return {
+                                decision: "deny",
+                                message: "Permission prompt could not be delivered to chat — denied automatically.",
+                            };
+                        }
                     },
                 })) {
                     await this.routeEngineEvent(msg.chatId, event, ws.name);
@@ -134,44 +241,91 @@ export class Orchestrator {
         }
     }
     async routeEngineEvent(chatId, event, workspaceName) {
-        switch (event.type) {
-            case "text":
-                await this.channel.sendMessage(chatId, event.text);
-                break;
-            case "tool_use": {
-                const formatted = formatToolUse(event.toolName, event.input);
-                await this.channel.sendMessage(chatId, formatted, {
-                    parseMode: "MarkdownV2",
-                });
-                break;
-            }
-            case "tool_result": {
-                const formatted = formatToolResult(event.toolName, event.output);
-                if (formatted) {
-                    await this.channel.sendMessage(chatId, formatted, {
-                        parseMode: "MarkdownV2",
-                    });
+        const state = this.chat(chatId);
+        try {
+            switch (event.type) {
+                case "text":
+                    await this.channel.sendMessage(chatId, event.text);
+                    break;
+                case "tool_use": {
+                    // Rolling message: each tool_use replaces the single message's content
+                    const line = formatToolStatusLine(event.toolName, event.input);
+                    if (state.toolCallHandle) {
+                        try {
+                            await this.channel.editMessage(chatId, state.toolCallHandle, line);
+                        }
+                        catch {
+                            const handles = await this.channel.sendMessage(chatId, line, { consumeTyping: false });
+                            state.toolCallHandle = handles[0];
+                        }
+                    }
+                    else {
+                        const handles = await this.channel.sendMessage(chatId, line, { consumeTyping: false });
+                        state.toolCallHandle = handles[0];
+                    }
+                    break;
                 }
-                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 "tool_result":
+                    // All tool results suppressed — Claude summarizes in its text response
+                    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 "done": {
+                    // Persist state first — channel calls below are best-effort
+                    log.info(`[turn] done session=${event.sessionId}`);
+                    this.workspaceStore.setSession(workspaceName, event.sessionId);
+                    if (event.stats)
+                        state.stats = event.stats;
+                    // Best-effort: update tool summary and status message
+                    if (state.toolCallHandle && event.stats) {
+                        const summary = formatToolCallSummary(event.stats.toolCalls);
+                        if (summary) {
+                            try {
+                                await this.channel.editMessage(chatId, state.toolCallHandle, summary);
+                            }
+                            catch { /* edit failed, leave as-is */ }
+                        }
+                    }
+                    state.toolCallHandle = null;
+                    await this.updateStatusMessage(chatId, state);
+                    break;
+                }
+                case "error":
+                    log.error(`[turn] error: ${event.message}`);
+                    await this.channel.sendMessage(chatId, `Error: ${event.message}`);
+                    break;
             }
-            case "done":
-                log.info(`[turn] done session=${event.sessionId}`);
-                this.workspaceStore.setSession(workspaceName, event.sessionId);
-                break;
-            case "error":
-                log.error(`[turn] error: ${event.message}`);
-                await this.channel.sendMessage(chatId, `Error: ${event.message}`);
-                break;
+        }
+        catch (err) {
+            // Channel errors must never propagate — they'd crash the engine turn loop,
+            // killing the SDK session and losing the session ID.
+            log.warn({ err }, "[route] failed to relay %s event to channel", event.type);
         }
     }
+    async updateStatusMessage(chatId, state) {
+        const mode = state.permissionMode ?? this.permissionMode;
+        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}`;
+        }
+        else {
+            text = `🔒 ${modeLabel}`;
+        }
+        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 {
@@ -183,4 +337,8 @@ export class Orchestrator {
         }
     }
 }
+/** 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}$/, "");
+}
 //# sourceMappingURL=orchestrator.js.map