clearclaw 0.6.1 → 0.8.0

package/dist/engine/claude-code.js

@@ -1,10 +1,84 @@
-import { query, listSessions, } from "@anthropic-ai/claude-agent-sdk";
+import { query, listSessions, getSessionMessages, } from "@anthropic-ai/claude-agent-sdk";
 import log from "../logger.js";
-import { formatToolDescription } from "../format.js";
+/** Map Claude Code SDK tool call to ToolCall. */
+function toToolCall(toolName, input, toolUseId) {
+    switch (toolName) {
+        case "Edit":
+            return {
+                action: "edit", toolName, toolUseId,
+                path: String(input.file_path ?? ""),
+                before: String(input.old_string ?? ""),
+                after: String(input.new_string ?? ""),
+            };
+        case "Write":
+            return {
+                action: "write", toolName, toolUseId,
+                path: String(input.file_path ?? ""),
+                content: String(input.content ?? ""),
+            };
+        case "Bash":
+            return {
+                action: "execute", toolName, toolUseId,
+                command: String(input.command ?? ""),
+            };
+        case "Read":
+        case "Glob":
+            return {
+                action: "read", toolName, toolUseId,
+                paths: [String(input.file_path ?? input.pattern ?? "")],
+            };
+        case "Grep":
+            return {
+                action: "search", toolName, toolUseId,
+                pattern: String(input.pattern ?? ""),
+                paths: input.path ? [String(input.path)] : undefined,
+            };
+        case "WebSearch":
+            return {
+                action: "search", toolName, toolUseId,
+                pattern: String(input.query ?? ""),
+            };
+        case "WebFetch":
+            return {
+                action: "fetch", toolName, toolUseId,
+                url: String(input.url ?? ""),
+            };
+        default:
+            return { action: "other", toolName, toolUseId, ...input };
+    }
+}
 export class ClaudeCodeEngine {
+    executablePath;
+    configPath;
     name = "claude-code";
+    planUsageWindows = CLAUDE_PLAN_WINDOWS;
+    constructor(executablePath, configPath) {
+        this.executablePath = executablePath;
+        this.configPath = configPath;
+    }
+    async getSessionMessages({ sessionId, cwd, signal }) {
+        signal?.throwIfAborted();
+        const messages = await getSessionMessages(sessionId, { dir: cwd });
+        signal?.throwIfAborted();
+        // The SDK returns [] for missing sessions as well as sessions with no records.
+        if (!messages.length)
+            throw new Error("No conversation history available for this session");
+        return messages.flatMap(({ type, message }) => {
+            if ((type !== "user" && type !== "assistant") || !isRecord(message))
+                return [];
+            const content = message.content;
+            const text = typeof content === "string" ? content : Array.isArray(content)
+                ? content.filter((block) => isRecord(block) && block.type === "text" && typeof block.text === "string")
+                    .map((block) => block.text).join("\n")
+                : "";
+            return text.trim() ? [{ role: type, text }] : [];
+        });
+    }
     async listSessions(cwd) {
-        const sessions = await listSessions({ dir: cwd, limit: 10 });
+        // includeWorktrees:false — SDK defaults to true, which merges sessions
+        // from all git worktrees of the same repo into one pool. We want only
+        // this cwd's own sessions.
+        const sessions = await listSessions({ dir: cwd, limit: 10, includeWorktrees: false });
         return sessions
             .sort((a, b) => b.lastModified - a.lastModified)
             .map((s) => ({
@@ -15,7 +89,7 @@ export class ClaudeCodeEngine {
         }));
     }
     async *runTurn(opts) {
-        const { sessionId, cwd, prompt: textPrompt, attachments, permissionMode, onPermissionRequest, appendSystemPrompt, mcpServers, signal, } = opts;
+        const { sessionId, cwd, prompt: textPrompt, attachments, permissionMode, onPermissionRequest, appendSystemPrompt, mcpServers, signal, model, } = opts;
         const abortController = new AbortController();
         // Wire external signal to our abort controller
         if (signal) {
@@ -27,14 +101,7 @@ export class ClaudeCodeEngine {
             ? { resume: sessionId }
             : {};
         const canUseTool = async (toolName, input, options) => {
-            const description = formatToolDescription(toolName, input);
-            const resp = await onPermissionRequest({
-                toolName,
-                input,
-                description,
-                reason: options.decisionReason,
-                toolUseId: options.toolUseID,
-            });
+            const resp = await onPermissionRequest(toToolCall(toolName, input, options.toolUseID));
             if (resp.decision === "allow") {
                 return { behavior: "allow", updatedInput: resp.updatedInput ?? input };
             }
@@ -63,10 +130,13 @@ export class ClaudeCodeEngine {
                 ...sessionOpts,
                 cwd,
                 permissionMode,
+                ...(model ? { model } : {}),
+                ...(this.executablePath ? { pathToClaudeCodeExecutable: this.executablePath } : {}),
                 allowDangerouslySkipPermissions: permissionMode === "bypassPermissions" ? true : undefined,
                 canUseTool: permissionMode === "bypassPermissions" ? undefined : canUseTool,
                 abortController,
                 settingSources: ["user", "project", "local"],
+                ...(this.configPath ? { settings: this.configPath } : {}),
                 ...(mcpServers ? { mcpServers } : {}),
                 ...(appendSystemPrompt
                     ? {
@@ -82,6 +152,7 @@ export class ClaudeCodeEngine {
         let resultSessionId;
         let turnStats;
         let lastInputTokens = 0;
+        let lastModel;
         const toolUseIdToName = new Map();
         try {
             for await (const msg of q) {
@@ -89,12 +160,22 @@ export class ClaudeCodeEngine {
                     const sub = msg.type === "result" ? ` (${msg.subtype})` : "";
                     log.info(`[sdk] ${msg.type}${sub}`);
                 }
+                // Report session metadata immediately so a cancelled turn keeps its ID.
+                // The observed model is metadata, not a user-selected override.
+                if (msg.type === "system" && msg.subtype === "init") {
+                    const init = msg;
+                    yield { type: "session", sessionId: init.session_id, model: init.model };
+                }
                 // Extract text and tool_use from assistant messages
                 if (msg.type === "assistant") {
                     // BetaMessage type isn't directly importable (@anthropic-ai/sdk not installed);
                     // .message is typed as `any` so property access works without casting.
                     const betaMsg = msg.message;
-                    if (betaMsg.usage) {
+                    // Only the main thread describes the session; subagent turns carry a parent.
+                    const mainThread = msg.parent_tool_use_id === null;
+                    if (mainThread && betaMsg.model)
+                        lastModel = betaMsg.model;
+                    if (mainThread && betaMsg.usage) {
                         const u = betaMsg.usage;
                         lastInputTokens = (u.input_tokens ?? 0)
                             + (u.cache_read_input_tokens ?? 0)
@@ -110,9 +191,7 @@ export class ClaudeCodeEngine {
                             toolUseIdToName.set(toolUseId, block.name);
                             yield {
                                 type: "tool_use",
-                                toolName: block.name,
-                                input: block.input,
-                                toolUseId,
+                                tool: toToolCall(block.name, block.input, toolUseId),
                             };
                         }
                     }
@@ -135,13 +214,7 @@ export class ClaudeCodeEngine {
                 // Relay rate limit events
                 if (msg.type === "rate_limit_event") {
                     const { rate_limit_info } = msg;
-                    if (rate_limit_info.status !== "allowed") {
-                        yield {
-                            type: "rate_limit",
-                            status: rate_limit_info.status,
-                            resetsAt: rate_limit_info.resetsAt,
-                        };
-                    }
+                    yield claudePlanUsage(rate_limit_info);
                 }
                 // Relay local command output (e.g. /compact, /cost, /model)
                 if (msg.type === "system" && msg.subtype === "local_command_output") {
@@ -154,9 +227,10 @@ export class ClaudeCodeEngine {
                 if (msg.type === "result") {
                     const result = msg;
                     resultSessionId = result.session_id;
-                    const models = Object.keys(result.modelUsage);
-                    if (models.length > 0) {
-                        const model = models[0];
+                    // modelUsage also counts background calls (e.g. Haiku), so its first key
+                    // is not necessarily the model that answered.
+                    const model = lastModel ?? Object.keys(result.modelUsage)[0];
+                    if (model) {
                         const mu = result.modelUsage[model];
                         // Build per-tool call counts from accumulated map
                         const toolCalls = {};
@@ -165,8 +239,9 @@ export class ClaudeCodeEngine {
                         }
                         turnStats = {
                             model,
+                            modelLabel: model.replace(/^claude-/, "").replace(/-\d{8}$/, ""),
                             contextUsed: lastInputTokens,
-                            contextWindow: mu.contextWindow,
+                            contextWindow: mu?.contextWindow ?? 0,
                             toolCalls,
                         };
                     }
@@ -192,12 +267,15 @@ export class ClaudeCodeEngine {
         }
     }
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 /**
  * Build an AsyncIterable<SDKUserMessage> that yields a single user message
  * with content blocks for attachments + text.
  */
 function buildAttachmentPrompt(text, attachments) {
-    const contentBlocks = attachments.map(encodeAttachment);
+    const contentBlocks = attachments.flatMap(encodeAttachment);
     // Text prompt always comes last
     if (text) {
         contentBlocks.push({ type: "text", text });
@@ -220,34 +298,42 @@ function buildAttachmentPrompt(text, attachments) {
 const SUPPORTED_IMAGE_TYPES = new Set([
     "image/jpeg", "image/png", "image/gif", "image/webp",
 ]);
-/** Encode an attachment as an SDK content block using its in-memory buffer. */
+/** Build a metadata label for an attachment. */
+function attachmentLabel(att) {
+    const name = att.filename ?? att.mimeType;
+    if (att.savedAs) {
+        return { type: "text", text: `[Attachment: ${name} — saved to ${att.savedAs}. Content already included; do not re-read from disk.]` };
+    }
+    return { type: "text", text: `[Attachment: ${name}]` };
+}
+/** Encode an attachment as SDK content blocks using its in-memory buffer. */
 function encodeAttachment(att) {
     const data = att.buffer.toString("base64");
+    const label = attachmentLabel(att);
     if (SUPPORTED_IMAGE_TYPES.has(att.mimeType)) {
-        return {
-            type: "image",
-            source: {
-                type: "base64",
-                media_type: att.mimeType,
-                data,
-            },
-        };
+        return [{
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: att.mimeType,
+                    data,
+                },
+            }, label];
     }
     if (att.mimeType === "application/pdf") {
-        return {
-            type: "document",
-            source: { type: "base64", media_type: "application/pdf", data },
-        };
+        return [{
+                type: "document",
+                source: { type: "base64", media_type: "application/pdf", data },
+            }, label];
     }
     if (att.mimeType.startsWith("text/")) {
         const content = att.buffer.toString("utf-8");
-        const header = att.filename ? `--- ${att.filename} ---\n` : "";
-        return { type: "text", text: `${header}${content}` };
+        return [{ type: "text", text: content }, label];
     }
     // Unsupported (includes non-standard image types like svg, bmp, tiff)
     const name = att.filename ?? att.mimeType;
     log.warn("[engine] unsupported attachment type: %s", att.mimeType);
-    return { type: "text", text: `[Unsupported file: ${name}]` };
+    return [{ type: "text", text: `[Unsupported file type: ${name}]` }, label];
 }
 /** Pull plain text out of a tool_result content block. */
 function extractToolResultText(content) {
@@ -261,4 +347,48 @@ function extractToolResultText(content) {
     }
     return "";
 }
+const CLAUDE_LABELS = {
+    five_hour: "5h", seven_day: "7d", seven_day_opus: "Opus 7d",
+    seven_day_sonnet: "Sonnet 7d", overage: "extra",
+    seven_day_overage_included: "Fable 7d",
+};
+function claudeWindowLabel(id) {
+    return CLAUDE_LABELS[id] ?? id.replace(/[_\r\n|]/g, " ").slice(0, 32);
+}
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value : undefined;
+}
+function finite(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+export const CLAUDE_PLAN_WINDOWS = [
+    { id: "five_hour", label: "5h" },
+    { id: "seven_day", label: "7d" },
+    { id: "seven_day_overage_included", label: "Fable 7d" },
+];
+export function claudePlanUsage(info) {
+    const windows = [];
+    const utilization = finite(info.utilization);
+    if (info.rateLimitType)
+        windows.push({
+            id: info.rateLimitType, label: claudeWindowLabel(info.rateLimitType),
+            limited: info.status === "rejected",
+            usedPercent: utilization !== undefined && utilization >= 0
+                ? utilization * 100 : undefined,
+            resetsAt: info.resetsAt,
+        });
+    // Claude Code 2.1.251 supplies all observed windows, even while allowed.
+    // Prefer these percentages over the selected top-level warning window.
+    for (const [id, raw] of Object.entries(object(info.unifiedWindows) ?? {})) {
+        const window = object(raw);
+        const utilization = finite(window?.utilization);
+        const resetsAt = finite(window?.resetsAt);
+        if (utilization === undefined || utilization < 0 || resetsAt === undefined || resetsAt <= 0)
+            continue;
+        windows.push({ id, label: claudeWindowLabel(id), usedPercent: utilization * 100,
+            resetsAt, limited: id === info.rateLimitType && info.status === "rejected" });
+    }
+    return { type: "plan_usage", windows, isUsingOverage: info.isUsingOverage };
+}
 //# sourceMappingURL=claude-code.js.map

package/dist/engine/mcp-http.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from "@agentclientprotocol/sdk";
+import type { McpSdkServerConfigWithInstance } from "@anthropic-ai/claude-agent-sdk";
+/** A turn-scoped HTTP endpoint in front of one in-process MCP server. */
+export interface McpBridge {
+    config: McpServer;
+    close(): Promise<void>;
+}
+/** Expose the turn's existing handlers to a subprocess, without another tool process. */
+export declare function serveMcpOverHttp(name: string, server: McpSdkServerConfigWithInstance): Promise<McpBridge>;

package/dist/engine/mcp-http.js

@@ -0,0 +1,59 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import log from "../logger.js";
+/** Expose the turn's existing handlers to a subprocess, without another tool process. */
+export async function serveMcpOverHttp(name, server) {
+    const authorization = `Bearer ${randomBytes(32).toString("hex")}`;
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: randomUUID });
+    const http = createServer((req, res) => {
+        if (req.headers.authorization !== authorization) {
+            res.writeHead(401).end();
+            return;
+        }
+        if (req.url !== "/mcp") {
+            res.writeHead(404).end();
+            return;
+        }
+        transport.handleRequest(req, res).catch((err) => {
+            log.error({ err }, "[mcp] HTTP transport failed");
+            if (!res.headersSent)
+                res.writeHead(500);
+            res.end();
+        });
+    });
+    const close = async () => {
+        // Stop accepting requests before closing MCP streams and keep-alive sockets.
+        const closed = new Promise((resolve) => http.close(() => resolve()));
+        http.closeAllConnections();
+        await server.instance.close();
+        await closed;
+    };
+    try {
+        await server.instance.connect(transport);
+        await new Promise((resolve, reject) => {
+            http.once("error", reject);
+            http.listen(0, "127.0.0.1", () => {
+                http.off("error", reject);
+                resolve();
+            });
+        });
+        const address = http.address();
+        if (!address || typeof address === "string")
+            throw new Error("MCP HTTP listener has no address");
+        return {
+            config: {
+                type: "http",
+                name,
+                url: `http://127.0.0.1:${address.port}/mcp`,
+                headers: [{ name: "Authorization", value: authorization }],
+            },
+            close,
+        };
+    }
+    catch (err) {
+        await close();
+        throw err;
+    }
+}
+//# sourceMappingURL=mcp-http.js.map

package/dist/engine/registry.d.ts

@@ -0,0 +1,19 @@
+import type { EngineEntry } from "../config.js";
+import type { Engine, RunTurnOpts } from "../types.js";
+export interface AcpEngineDefinition {
+    command: [string, ...string[]];
+    env?: Record<string, string> | ((opts: RunTurnOpts) => Record<string, string> | undefined);
+}
+/** All known engine names (for validation / setup prompts). */
+export declare const ENGINE_NAMES: readonly ["claude-code", ...string[]];
+/** Return the CLI command an engine needs on PATH. */
+export declare function engineCommand(name: string): string | undefined;
+/** Prefer an installed CLI; bundled engines can omit the override. */
+export declare function resolveEnginePath(name: string): string | undefined;
+/**
+ * Build the engine map: claude-code (Agent SDK) + known ACP engines.
+ * Engines are lightweight — they store config, not running processes.
+ *
+ * @param engineConfigs - executable and settings-file overrides from config
+ */
+export declare function createEngineMap(engineConfigs?: Record<string, Pick<EngineEntry, "path" | "configPath">>): Map<string, Engine>;

package/dist/engine/registry.js

@@ -0,0 +1,115 @@
+import { readFileSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { ClaudeCodeEngine } from "./claude-code.js";
+import { AcpEngine } from "./acp.js";
+/** Known ACP engines: CLI for setup, optional adapter for launch. */
+const require = createRequire(import.meta.url);
+const KNOWN_ACP_ENGINES = {
+    kiro: { cliCommand: "kiro-cli", command: (cliPath) => [cliPath, "acp"] },
+    codex: {
+        cliCommand: "codex",
+        bundled: true,
+        supportsConfigPath: true,
+        // Resolve only when starting Codex, and always use our pinned, patched dependency.
+        get command() { return [process.execPath, require.resolve("@agentclientprotocol/codex-acp")]; },
+        env: codexEnv,
+    },
+};
+/**
+ * ACP has no system-prompt channel, so ClearClaw's assembled framework prompt
+ * reaches Codex through its config: codex-acp parses CODEX_CONFIG as a JSON
+ * config object and forwards it to codex core, which honors
+ * `developer_instructions`. An explicit JSON file supplies personal settings;
+ * without one, inherited CODEX_CONFIG remains the source.
+ * CODEX_PATH selects the underlying CLI while the pinned adapter stays fixed.
+ */
+function codexEnv(opts, executablePath, configPath) {
+    const developerInstructions = opts.appendSystemPrompt?.trim();
+    if (!developerInstructions && !executablePath && !configPath)
+        return undefined;
+    return {
+        ...(executablePath ? { CODEX_PATH: executablePath } : {}),
+        ...(developerInstructions || configPath ? {
+            CODEX_CONFIG: JSON.stringify({
+                ...readCodexConfig(configPath),
+                ...(developerInstructions ? { developer_instructions: developerInstructions } : {}),
+            }),
+        } : {}),
+    };
+}
+/**
+ * Installation state the Codex CLI owns. codex-acp applies our config when it
+ * starts a thread, long after the CLI would have fetched a marketplace and
+ * installed a plugin, so declaring these here installs nothing: an enabled
+ * plugin stays missing, and a marketplace with no local snapshot fails every
+ * thread with an opaque config-load error. Reject them at load with the fix.
+ */
+const CLI_OWNED_CONFIG_KEYS = ["marketplaces", "plugins"];
+function readCodexConfig(configPath) {
+    const raw = configPath ? readFileSync(configPath, "utf8") : process.env.CODEX_CONFIG?.trim() || "{}";
+    const source = configPath ?? "CODEX_CONFIG";
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${source} must be a JSON object`);
+    }
+    const config = parsed;
+    const cliOwned = CLI_OWNED_CONFIG_KEYS.filter((key) => key in config);
+    if (cliOwned.length > 0) {
+        throw new Error(`${source} sets ${cliOwned.join(" and ")}, which ClearClaw cannot apply: plugin installation is Codex CLI state, ` +
+            `not thread settings. Install with "codex plugin marketplace add <source>" and "codex plugin add <plugin>@<marketplace>", ` +
+            `then remove ${cliOwned.length > 1 ? "these keys" : "the key"}.`);
+    }
+    return config;
+}
+/** All known engine names (for validation / setup prompts). */
+export const ENGINE_NAMES = ["claude-code", ...Object.keys(KNOWN_ACP_ENGINES)];
+/** Return the CLI command an engine needs on PATH. */
+export function engineCommand(name) {
+    return name === "claude-code" ? "claude" : KNOWN_ACP_ENGINES[name]?.cliCommand;
+}
+/** Prefer an installed CLI; bundled engines can omit the override. */
+export function resolveEnginePath(name) {
+    const command = engineCommand(name);
+    if (!command)
+        throw new Error(`Unknown engine: ${name}`);
+    try {
+        return execFileSync("which", [command], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        if (KNOWN_ACP_ENGINES[name]?.bundled)
+            return undefined;
+        throw new Error(`"${command}" not found on PATH. Install it first or choose another engine.`);
+    }
+}
+/**
+ * Build the engine map: claude-code (Agent SDK) + known ACP engines.
+ * Engines are lightweight — they store config, not running processes.
+ *
+ * @param engineConfigs - executable and settings-file overrides from config
+ */
+export function createEngineMap(engineConfigs = {}) {
+    for (const [name, { configPath }] of Object.entries(engineConfigs)) {
+        if (configPath && !isAbsolute(configPath))
+            throw new Error(`${name} configPath must be absolute`);
+        if (configPath && name !== "claude-code" && !KNOWN_ACP_ENGINES[name]?.supportsConfigPath) {
+            throw new Error(`${name} does not support configPath`);
+        }
+    }
+    const engines = new Map();
+    const claude = engineConfigs["claude-code"];
+    engines.set("claude-code", new ClaudeCodeEngine(claude?.path, claude?.configPath));
+    for (const [name, config] of Object.entries(KNOWN_ACP_ENGINES)) {
+        const { path, configPath } = engineConfigs[name] ?? {};
+        engines.set(name, new AcpEngine(name, {
+            get command() {
+                const command = config.command;
+                return typeof command === "function" ? command(path ?? config.cliCommand) : command;
+            },
+            env: (opts) => config.env?.(opts, path, configPath),
+        }));
+    }
+    return engines;
+}
+//# sourceMappingURL=registry.js.map

package/dist/engine/session-transcript.d.ts

@@ -0,0 +1,14 @@
+import type { SessionMessage } from "../types.js";
+/**
+ * Inverse of the orchestrator's prompt framing, for showing a stored prompt back
+ * to a human (session summaries, catch-up blocks): drop the leading bracketed
+ * tags and the sender label.
+ * "[2026-09-10 …] [msg:10107] [user] Paddy (@handle): hi" → "hi".
+ * Text with no bracketed tag is left alone, so a summary that merely contains a
+ * colon keeps its first clause.
+ */
+export declare function stripPromptPrefix(text: string): string;
+/** Format all engine-normalized conversation text for a handoff prompt. */
+export declare function formatSessionTranscript(messages: SessionMessage[]): string;
+/** Replay the last three user prompts and their replies, including a pending reply. */
+export declare function formatSessionRecap(messages: SessionMessage[]): string;

package/dist/engine/session-transcript.js

@@ -0,0 +1,38 @@
+/**
+ * Inverse of the orchestrator's prompt framing, for showing a stored prompt back
+ * to a human (session summaries, catch-up blocks): drop the leading bracketed
+ * tags and the sender label.
+ * "[2026-09-10 …] [msg:10107] [user] Paddy (@handle): hi" → "hi".
+ * Text with no bracketed tag is left alone, so a summary that merely contains a
+ * colon keeps its first clause.
+ */
+export function stripPromptPrefix(text) {
+    return text.replace(/^(?:\[[^\]]*\]\s*)+(?:[^:\n]{0,60}:\s*)?/, "");
+}
+/** Format all engine-normalized conversation text for a handoff prompt. */
+export function formatSessionTranscript(messages) {
+    let text = "";
+    for (const message of messages) {
+        if (!message.text.trim())
+            continue;
+        text += `${text ? "\n\n" : ""}${message.role === "user" ? "User" : "Assistant"}:\n${message.text}`;
+    }
+    return text || "[No conversation text was returned for the previous session.]";
+}
+/** Replay the last three user prompts and their replies, including a pending reply. */
+export function formatSessionRecap(messages) {
+    const visible = messages.flatMap((message) => {
+        const text = (message.role === "user" ? stripPromptPrefix(message.text) : message.text).trim();
+        return text ? [{ ...message, text }] : [];
+    });
+    let start = 0;
+    let prompts = 0;
+    for (let i = visible.length - 1; i >= 0; i--) {
+        if (visible[i].role === "user" && ++prompts === 3) {
+            start = i;
+            break;
+        }
+    }
+    return visible.slice(start).map((message) => `**${message.role === "user" ? "Prompt" : "Assistant"}**\n${message.text}`).join("\n\n") || "No conversation text to recap yet.";
+}
+//# sourceMappingURL=session-transcript.js.map

package/dist/format.d.ts

@@ -1,8 +1,9 @@
 /**
  * Formatting utilities for Telegram display.
  *
- * Uses the `diff` library for unified diffs in Edit permission prompts.
+ * Uses the `diff` library for interleaved diffs in Edit permission prompts.
  */
+import { type ToolCall } from "./types.js";
 /**
  * Summary line for the rolling tool message after a turn completes.
  * e.g. "🔧 3× Read, 2× Grep, 1× Bash"
@@ -12,12 +13,13 @@ export declare function formatToolCallSummary(toolCalls: Record<string, number>)
  * Short one-liner for the rolling tool message. Includes key detail
  * but truncated to stay compact.
  */
-export declare function formatToolStatusLine(toolName: string, input: Record<string, unknown>): string;
+export declare function formatToolStatusLine(tool: ToolCall): string;
 /**
- * Format a permission prompt for display. Returns a MarkdownV2 string.
- * Edit/Write include the diff/preview; other tools get a one-line description.
+ * Format a permission prompt for display.
+ * Switches on action type: edit shows diff, write shows preview,
+ * execute shows command, others show available detail.
  */
-export declare function formatPermissionPrompt(toolName: string, input: Record<string, unknown>, description: string): string;
+export declare function formatPermissionPrompt(tool: ToolCall): string;
 /**
  * Relative time string: "just now", "5m ago", "2h ago", "3d ago".
  */
@@ -42,13 +44,9 @@ export declare function truncateButtonLabel(index: number, label: string): strin
  * Format an ExitPlanMode permission prompt.
  * Renders plan text from the description or input fields.
  */
-export declare function formatExitPlanMode(input: Record<string, unknown>, description: string): string;
+export declare function formatExitPlanMode(input: Record<string, unknown>): string;
 /**
  * Format a TodoWrite task list for display.
  */
 export declare function formatTodoList(input: Record<string, unknown>): string;
-/**
- * Human-readable one-liner for a tool invocation (used in engine's canUseTool).
- */
-export declare function formatToolDescription(toolName: string, input: Record<string, unknown>): string;
 export {};