@bubblebrain-ai/bubble 0.0.19 → 0.0.21

package/dist/session.js

@@ -5,6 +5,7 @@ import { randomUUID } from "node:crypto";
 import { mkdirSync, appendFileSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { getBubbleHome } from "./bubble-home.js";
+import { CheckpointStore } from "./checkpoints.js";
 import { compactSessionEntries } from "./context/compact.js";
 import { SessionLog } from "./session-log.js";
 import { normalizeSingleLine, truncateVisual } from "./text-display.js";
@@ -14,6 +15,7 @@ const AUTO_COMPACT_KEEP_RECENT_TURNS = 3;
 export class SessionManager {
     sessionFile;
     log = new SessionLog();
+    checkpoints;
     constructor(sessionFile) {
         this.sessionFile = sessionFile;
         if (existsSync(sessionFile)) {
@@ -163,6 +165,73 @@ export class SessionManager {
     getMessages() {
         return this.log.toMessages();
     }
+    /**
+     * Pre-edit file snapshot store for this session, used by /rewind.
+     * Lives next to the session JSONL as `<session>.checkpoints/`.
+     */
+    getCheckpoints() {
+        if (!this.checkpoints) {
+            this.checkpoints = new CheckpointStore(this.sessionFile.replace(/\.jsonl$/, "") + ".checkpoints", () => this.lastUserEntryId());
+        }
+        return this.checkpoints;
+    }
+    /** Entry id of the most recent user message, or "0" before the first one. */
+    lastUserEntryId() {
+        const entries = this.log.list();
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const entry = entries[i];
+            if (entry.type === "user_message")
+                return entry.id;
+        }
+        return "0";
+    }
+    /** User messages after the latest /clear, oldest first — the valid rewind anchors. */
+    listUserTurns() {
+        const entries = this.log.list();
+        let start = 0;
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const entry = entries[i];
+            if (entry.type === "marker" && entry.kind === "conversation_clear") {
+                start = i + 1;
+                break;
+            }
+        }
+        const turns = [];
+        for (let i = start; i < entries.length; i++) {
+            const entry = entries[i];
+            if (entry.type !== "user_message")
+                continue;
+            const text = messageText(entry.message);
+            turns.push({
+                id: entry.id,
+                text,
+                preview: truncateVisual(normalizeSingleLine(text), 80) || "(empty message)",
+                timestamp: entry.timestamp,
+            });
+        }
+        return turns;
+    }
+    /**
+     * Truncate the session to just before the user message with the given
+     * entry id. Returns undefined when the id does not name a user message.
+     */
+    rewindToEntry(entryId) {
+        const entries = this.log.list();
+        const index = entries.findIndex((entry) => entry.id === entryId && entry.type === "user_message");
+        if (index < 0)
+            return undefined;
+        const target = entries[index];
+        const removed = entries.slice(index);
+        this.rewrite(entries.slice(0, index));
+        const metadata = this.log.getMetadata();
+        if (metadata.titleUserMessageId && removed.some((entry) => entry.id === metadata.titleUserMessageId)) {
+            this.clearTitleMetadata();
+        }
+        return {
+            removedEntries: removed.length,
+            targetText: target.type === "user_message" ? messageText(target.message) : "",
+        };
+    }
     getEntries() {
         return this.log.list();
     }

package/dist/slash-commands/commands.js

@@ -6,6 +6,7 @@ import { parseRule } from "../permissions/rule.js";
 import { encodeModel, decodeModel, displayModel, BUILTIN_PROVIDERS, isUserVisibleProvider } from "../provider-registry.js";
 import { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "../provider-transform.js";
 import { buildSystemPrompt } from "../system-prompt.js";
+import { HOOK_EVENT_NAMES, isHookEventName } from "../hooks/index.js";
 import { isThinkingLevel } from "../variant/thinking-level.js";
 import { collectUsageStatsBundle, formatStatsText } from "../stats/usage.js";
 import { buildMemoryPrompt, getMemoryStatus, isMemoryDisabled, resetMemory, searchMemory, } from "../memory/index.js";
@@ -49,6 +50,45 @@ function handlePermissionsMutation(sub, tokens, ctx) {
         return `Rule not found in ${scope} ${list}: ${rule}`;
     return `Removed from ${scope} ${list}: ${rule}`;
 }
+async function handleHooksCommand(args, ctx) {
+    const hooks = ctx.hookController;
+    if (!hooks)
+        return "Hooks controller is not attached to this session.";
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    const sub = tokens[0] ?? "status";
+    if (sub === "status" || sub === "list" || sub === "") {
+        return hooks.status();
+    }
+    if (sub === "reload") {
+        hooks.reload();
+        return `Reloaded hooks.\n\n${hooks.status()}`;
+    }
+    if (sub === "trust" && tokens[1] === "project") {
+        return hooks.trustProject();
+    }
+    if (sub === "untrust" && tokens[1] === "project") {
+        return hooks.untrustProject();
+    }
+    if (sub === "test") {
+        const event = tokens[1];
+        if (!isHookEventName(event)) {
+            return `Usage: /hooks test <event> [target]\nEvents: ${HOOK_EVENT_NAMES.join(", ")}`;
+        }
+        return hooks.test(event, tokens.slice(2).join(" ") || undefined);
+    }
+    if (sub === "explain") {
+        const event = tokens[1];
+        if (!isHookEventName(event)) {
+            return `Usage: /hooks explain <event>\nEvents: ${HOOK_EVENT_NAMES.join(", ")}`;
+        }
+        return hooks.explain(event);
+    }
+    if (sub === "logs") {
+        const limit = Number(tokens[1] ?? 20);
+        return hooks.logs(Number.isFinite(limit) ? limit : 20);
+    }
+    return "Usage: /hooks [status|reload|trust project|untrust project|test <event> [target]|explain <event>|logs [limit]]";
+}
 function persistSelectedModel(model, ctx) {
     const userConfig = new UserConfig();
     userConfig.setDefaultModel(model);
@@ -359,6 +399,86 @@ const builtinSlashCommandEntries = [
             ctx.clearMessages();
         },
     },
+    {
+        name: "rewind",
+        description: "Rewind conversation and/or file edits to before an earlier message. Usage: /rewind [n] [--code|--chat]",
+        async handler(args, ctx) {
+            const session = ctx.sessionManager;
+            if (!session) {
+                return "Rewind requires an active session.";
+            }
+            const turns = session.listUserTurns();
+            if (turns.length === 0) {
+                return "Nothing to rewind: no user messages in this session.";
+            }
+            const tokens = args.trim().split(/\s+/).filter(Boolean);
+            const flags = tokens.filter((token) => token.startsWith("--"));
+            const positional = tokens.filter((token) => !token.startsWith("--"));
+            const checkpoints = session.getCheckpoints();
+            if (positional.length === 0) {
+                if (ctx.openRewindPicker) {
+                    ctx.openRewindPicker();
+                    return;
+                }
+                const lines = ["Rewind points (oldest first):", ""];
+                turns.forEach((turn, index) => {
+                    const time = new Date(turn.timestamp).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+                    const files = checkpoints.filesTouchedAt(turn.id).length;
+                    const fileNote = files > 0 ? `  [${files} file${files === 1 ? "" : "s"} changed]` : "";
+                    lines.push(`  ${index + 1}. ${time}  ${turn.preview}${fileNote}`);
+                });
+                lines.push("", "Usage:", "  /rewind <n>         restore conversation AND files to just before message n", "  /rewind <n> --chat  conversation only", "  /rewind <n> --code  files only", "", "Note: only edits made by the edit/write tools are tracked; changes from", "bash commands are not. Checkpoints complement git, they don't replace it.");
+                return lines.join("\n");
+            }
+            const n = Number(positional[0]);
+            if (!Number.isInteger(n) || n < 1 || n > turns.length) {
+                return `Invalid rewind point "${positional[0]}". Run /rewind to list points (1-${turns.length}).`;
+            }
+            const target = turns[n - 1];
+            const codeOnly = flags.includes("--code");
+            const chatOnly = flags.includes("--chat") || flags.includes("--conversation");
+            if (codeOnly && chatOnly) {
+                return "Pick at most one of --code / --chat.";
+            }
+            // The "⏪" prefix is recognized by the TUIs: they rebuild the visible
+            // transcript from the rewound agent.messages before showing this text.
+            const lines = [
+                codeOnly
+                    ? `Files restored to just before: ${target.preview}`
+                    : `⏪ Rewound to before: ${target.preview}`,
+            ];
+            if (!chatOnly) {
+                const restore = await checkpoints.restoreTo(target.id);
+                const touched = restore.restored.length + restore.deleted.length;
+                if (touched === 0 && restore.failed.length === 0) {
+                    lines.push("Files: no tracked edits to undo.");
+                }
+                else {
+                    for (const file of restore.restored)
+                        lines.push(`Restored ${file}`);
+                    for (const file of restore.deleted)
+                        lines.push(`Deleted ${file} (created after this point)`);
+                    for (const file of restore.failed)
+                        lines.push(`FAILED to restore ${file}`);
+                }
+            }
+            if (!codeOnly) {
+                session.rewindToEntry(target.id);
+                const head = ctx.agent.messages.filter((m) => m.role === "system" || m.role === "meta");
+                ctx.agent.messages = [...head, ...session.getMessages()];
+                ctx.agent.setTodos(session.getTodos());
+                ctx.agent.resetContextUsageAnchor();
+                if (ctx.fillComposer) {
+                    // Put the rewound message back into the input box for re-editing.
+                    ctx.fillComposer(target.text);
+                }
+                else {
+                    lines.push("", "Rewound message (copy to re-edit):", target.text);
+                }
+            }
+            return lines.join("\n");
+        },
+    },
     {
         name: "session",
         description: "Show current session information",
@@ -667,6 +787,13 @@ const builtinSlashCommandEntries = [
             return lines.join("\n");
         },
     },
+    {
+        name: "hooks",
+        description: "Inspect and manage lifecycle hooks. Usage: /hooks [status|trust project|test <event>]",
+        async handler(args, ctx) {
+            return handleHooksCommand(args, ctx);
+        },
+    },
     {
         name: "lsp",
         description: "Inspect or restart language servers. Usage: /lsp [status|diagnostics|restart]",
@@ -788,8 +915,33 @@ const builtinSlashCommandEntries = [
             if (!ctx.sessionManager) {
                 return "Compaction requires session persistence. Start an interactive session first.";
             }
+            const preHook = await ctx.hookController?.runEvent({
+                eventName: "PreCompact",
+                cwd: ctx.cwd,
+                sessionId: ctx.sessionManager.getSessionFile(),
+                agentRole: "driver",
+                target: "manual",
+                payload: {
+                    kind: "manual",
+                    messageCount: ctx.agent.messages.length,
+                },
+            });
+            if (preHook?.decision === "deny") {
+                return preHook.reason ?? `Compaction blocked by hook ${preHook.sourceHookId ?? "<unknown>"}.`;
+            }
             const result = ctx.sessionManager.compact();
             if (!result.compacted) {
+                await ctx.hookController?.runEvent({
+                    eventName: "PostCompact",
+                    cwd: ctx.cwd,
+                    sessionId: ctx.sessionManager.getSessionFile(),
+                    agentRole: "driver",
+                    target: "manual",
+                    payload: {
+                        kind: "manual",
+                        compacted: false,
+                    },
+                });
                 return "Session is already compact enough.";
             }
             const systemMessage = ctx.agent.messages.find((message) => message.role === "system");
@@ -799,6 +951,18 @@ const builtinSlashCommandEntries = [
             ];
             ctx.agent.resetContextUsageAnchor();
             const dropped = result.droppedEntries ?? 0;
+            await ctx.hookController?.runEvent({
+                eventName: "PostCompact",
+                cwd: ctx.cwd,
+                sessionId: ctx.sessionManager.getSessionFile(),
+                agentRole: "driver",
+                target: "manual",
+                payload: {
+                    kind: "manual",
+                    compacted: true,
+                    droppedEntries: dropped,
+                },
+            });
             return `✓ Compaction complete · ${dropped} log entr${dropped === 1 ? "y" : "ies"} summarized`;
         },
     },

package/dist/slash-commands/types.d.ts

@@ -9,6 +9,7 @@ import type { McpManager } from "../mcp/manager.js";
 import type { LspService } from "../lsp/index.js";
 import type { MemoryScope } from "../memory/index.js";
 import type { ThemeMode } from "../config.js";
+import type { ExternalHookController } from "../hooks/controller.js";
 export type SidebarMode = "auto" | "expanded" | "collapsed";
 export interface SidebarCommandState {
     mode: SidebarMode;
@@ -28,6 +29,7 @@ export interface SlashCommandContext {
     skillRegistry: SkillRegistry;
     bashAllowlist?: BashAllowlist;
     settingsManager?: SettingsManager;
+    hookController?: ExternalHookController;
     mcpManager?: McpManager;
     lspService?: LspService;
     flushMemory?: () => Promise<void>;
@@ -46,6 +48,10 @@ export interface SlashCommandContext {
     setSidebarMode?: (mode: SidebarMode) => SidebarCommandState;
     /** Open the feedback dialog. `initialDescription` prefills the description field. */
     openFeedback?: (initialDescription: string) => void;
+    /** Open the interactive rewind picker. When absent, /rewind falls back to a text listing. */
+    openRewindPicker?: () => void;
+    /** Replace the composer/input box content (e.g. /rewind restores the rewound message for re-editing). */
+    fillComposer?: (text: string) => void;
     /** Open the interactive usage stats panel. */
     openStats?: () => void;
 }

package/dist/tools/bash.js

@@ -21,6 +21,10 @@ export function createBashTool(cwd, approval, _fileState) {
             type: "object",
             properties: {
                 command: { type: "string", description: "Bash command to execute" },
+                description: {
+                    type: "string",
+                    description: "One short sentence (5-10 words) describing what this command does, shown to the user in the UI. Write it in the same language the user is conversing in.",
+                },
                 timeout: { type: "number", description: "Timeout in seconds (optional)" },
             },
             required: ["command"],

package/dist/tools/edit-apply.js

@@ -1,3 +1,4 @@
+import { isSensitivePath } from "./sensitive-paths.js";
 export class EditApplyError extends Error {
     status;
     constructor(message, status = "no_match") {
@@ -6,6 +7,9 @@ export class EditApplyError extends Error {
         this.name = "EditApplyError";
     }
 }
+const CANDIDATE_EXCERPT_CONTEXT_LINES = 3;
+const CANDIDATE_EXCERPT_MAX_LINES = 8;
+const CANDIDATE_EXCERPT_MAX_CHARS = 1200;
 function detectLineEnding(content) {
     const crlf = content.indexOf("\r\n");
     const lf = content.indexOf("\n");
@@ -234,19 +238,75 @@ function findBestLineHint(content, oldText) {
         return undefined;
     const contentLines = nonBlankLines(splitLines(content));
     let best;
+    let tieCount = 0;
     for (let i = 0; i < contentLines.length; i++) {
         let score = 0;
         for (let j = 0; j < oldLines.length && i + j < contentLines.length; j++) {
             if (contentLines[i + j].normalized === oldLines[j])
                 score++;
         }
-        if (!best || score > best.score)
+        if (!best || score > best.score) {
             best = { index: i, score };
+            tieCount = 1;
+        }
+        else if (score === best.score) {
+            tieCount++;
+        }
     }
     if (!best || best.score === 0)
         return undefined;
     const startLine = contentLines[best.index].lineIndex + 1;
-    return `Closest line-based candidate starts near line ${startLine} and matched ${best.score}/${oldLines.length} non-blank lines.`;
+    return {
+        startLine,
+        score: best.score,
+        total: oldLines.length,
+        lineIndex: contentLines[best.index].lineIndex,
+        tieCount,
+    };
+}
+function isHighConfidenceLineHint(hint) {
+    return hint.score >= 2 && hint.score / hint.total >= 0.5 && hint.tieCount === 1;
+}
+function formatLineHint(hint) {
+    if (hint.tieCount > 1) {
+        return `Closest ambiguous line-based candidate starts near line ${hint.startLine} and matched ${hint.score}/${hint.total} non-blank lines, but ${hint.tieCount} candidates tied. Current bytes were not included because the candidate may be unrelated.`;
+    }
+    if (!isHighConfidenceLineHint(hint)) {
+        return `Closest low-confidence line-based candidate starts near line ${hint.startLine} and matched ${hint.score}/${hint.total} non-blank lines. Current bytes were not included because the candidate may be unrelated.`;
+    }
+    return `Closest line-based candidate starts near line ${hint.startLine} and matched ${hint.score}/${hint.total} non-blank lines.`;
+}
+function formatFence(content) {
+    let fence = "```";
+    while (content.includes(fence))
+        fence += "`";
+    return `${fence}\n${content}\n${fence}`;
+}
+function truncateExcerpt(excerpt) {
+    if (excerpt.length <= CANDIDATE_EXCERPT_MAX_CHARS)
+        return excerpt;
+    const marker = "\n...[truncated current candidate excerpt]";
+    return excerpt.slice(0, Math.max(0, CANDIDATE_EXCERPT_MAX_CHARS - marker.length)) + marker;
+}
+function formatCandidateExcerpt(content, hint) {
+    const lines = splitLines(content);
+    const startLineIndex = Math.max(0, hint.lineIndex - CANDIDATE_EXCERPT_CONTEXT_LINES);
+    const requestedEnd = Math.min(lines.length, hint.lineIndex + CANDIDATE_EXCERPT_CONTEXT_LINES + 1);
+    const endLineIndex = Math.min(requestedEnd, startLineIndex + CANDIDATE_EXCERPT_MAX_LINES);
+    const excerpt = truncateExcerpt(lines.slice(startLineIndex, endLineIndex).map((line) => line.text).join("\n"));
+    return [
+        `Current candidate excerpt (high confidence, current file lines ${startLineIndex + 1}-${endLineIndex}, not guaranteed target):`,
+        formatFence(excerpt),
+    ].join("\n");
+}
+function formatBestLineHint(content, hint, options) {
+    const lineHint = formatLineHint(hint);
+    if (!isHighConfidenceLineHint(hint))
+        return lineHint;
+    if (options?.path && isSensitivePath(options.path)) {
+        return `${lineHint}\nCurrent bytes were not included because this path is blocked by the sensitive-path read policy.`;
+    }
+    return `${lineHint}\n\n${formatCandidateExcerpt(content, hint)}`;
 }
 function matchEdit(content, edit, index, total, options) {
     if (edit.oldText.length === 0) {
@@ -350,7 +410,7 @@ function matchEdit(content, edit, index, total, options) {
         }
     }
     const hint = findBestLineHint(content, oldText);
-    const hintSuffix = hint ? `\n${hint}` : "";
+    const hintSuffix = hint ? `\n${formatBestLineHint(content, hint, options)}` : "";
     const recovery = [
         "",
         "How to recover:",

package/dist/tools/edit.d.ts

@@ -4,6 +4,7 @@
  * This is the safest way to edit files: old_string must exist exactly once.
  */
 import type { ApprovalController } from "../approval/types.js";
+import type { CheckpointStore } from "../checkpoints.js";
 import type { ToolRegistryEntry } from "../types.js";
 import { type LspService } from "../lsp/index.js";
 import { type FileStateTracker } from "./file-state.js";
@@ -14,4 +15,4 @@ export interface EditArgs {
         newText: string;
     }>;
 }
-export declare function createEditTool(cwd: string, approval?: ApprovalController, lsp?: LspService, fileState?: FileStateTracker): ToolRegistryEntry;
+export declare function createEditTool(cwd: string, approval?: ApprovalController, lsp?: LspService, fileState?: FileStateTracker, checkpoints?: () => CheckpointStore | undefined): ToolRegistryEntry;

package/dist/tools/edit.js

@@ -60,17 +60,17 @@ function firstString(...values) {
     }
     return undefined;
 }
-export function createEditTool(cwd, approval, lsp, fileState) {
+export function createEditTool(cwd, approval, lsp, fileState, checkpoints) {
     return {
         name: "edit",
         effect: "write_direct",
         requiresApproval: true,
-        description: "Edit a single file using targeted text replacements. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
+        description: "Edit a single file using targeted text replacements. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes overlap or one replacement is nested inside another, merge them into one edit. Do not include large unchanged regions just to connect distant changes.",
         promptSnippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
         promptGuidelines: [
-            "Use edit for precise changes; edits[].oldText should be copied from a recent read and must identify a unique target.",
-            "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls.",
-            "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
+            "Use edit for precise changes; each edits[].oldText must be copied verbatim from a fresh read of the current exact target block and must identify a unique target. Do not reconstruct oldText from memory, stale reads, or similar code elsewhere.",
+            "When changing multiple small, clearly disjoint locations copied from the same fresh read, you may use one edit call with multiple entries in edits[]. Use separate smaller edit calls after re-reading when anchors are uncertain, stale, or likely to drift.",
+            "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits; merge only truly overlapping targets.",
             "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.",
         ],
         parameters: {
@@ -178,6 +178,7 @@ export function createEditTool(cwd, approval, lsp, fileState) {
                         },
                     };
                 }
+                await checkpoints?.()?.captureBefore(filePath, original);
                 await writeFile(filePath, applied.content, "utf-8");
                 await fileState?.observe(filePath, "edit", applied.content).catch(() => undefined);
                 let output = `Edited ${filePath}${formatEditMatchNotes(applied.matches)}\n\nDiff:\n${diff}`;

package/dist/tools/index.d.ts

@@ -28,6 +28,7 @@ import { type LspService } from "../lsp/index.js";
 import { type TodoStore } from "./todo.js";
 import { type ToolSearchController } from "./tool-search.js";
 import type { QuestionController } from "../question/index.js";
+import type { CheckpointStore } from "../checkpoints.js";
 import { FileStateTracker } from "./file-state.js";
 export interface CreateAllToolsOptions {
     todoStore?: TodoStore;
@@ -37,5 +38,11 @@ export interface CreateAllToolsOptions {
     toolSearchController?: ToolSearchController;
     lspService?: LspService;
     fileStateTracker?: FileStateTracker;
+    /**
+     * Lazy accessor for the session's checkpoint store (the session manager may
+     * not exist yet when tools are created). Used by edit/write to snapshot
+     * files before mutating them so /rewind can restore.
+     */
+    checkpoints?: () => CheckpointStore | undefined;
 }
 export declare function createAllTools(cwd: string, skillRegistry?: SkillRegistry, options?: CreateAllToolsOptions): ToolRegistryEntry[];

package/dist/tools/index.js

@@ -48,8 +48,8 @@ export function createAllTools(cwd, skillRegistry, options = {}) {
         createReadTool(cwd, approval, lsp, fileState),
         createBashTool(cwd, approval, fileState),
         ...createManagedServerTools(cwd, approval),
-        createWriteTool(cwd, {}, approval, lsp, fileState),
-        createEditTool(cwd, approval, lsp, fileState),
+        createWriteTool(cwd, {}, approval, lsp, fileState, options.checkpoints),
+        createEditTool(cwd, approval, lsp, fileState, options.checkpoints),
         createGlobTool(cwd),
         createGrepTool(cwd),
         createLspTool(cwd, lsp, approval),

package/dist/tools/write.d.ts

@@ -2,8 +2,9 @@
  * Write tool - create files or replace full file contents.
  */
 import type { ApprovalController } from "../approval/types.js";
+import type { CheckpointStore } from "../checkpoints.js";
 import type { ToolRegistryEntry } from "../types.js";
 import { type LspService } from "../lsp/index.js";
 import { type FileStateTracker } from "./file-state.js";
 export type WriteToolOptions = Record<string, never>;
-export declare function createWriteTool(cwd: string, _options?: WriteToolOptions, approval?: ApprovalController, lsp?: LspService, fileState?: FileStateTracker): ToolRegistryEntry;
+export declare function createWriteTool(cwd: string, _options?: WriteToolOptions, approval?: ApprovalController, lsp?: LspService, fileState?: FileStateTracker, checkpoints?: () => CheckpointStore | undefined): ToolRegistryEntry;

package/dist/tools/write.js

@@ -18,7 +18,7 @@ function prepareWriteArguments(input) {
     }
     return args;
 }
-export function createWriteTool(cwd, _options = {}, approval, lsp, fileState) {
+export function createWriteTool(cwd, _options = {}, approval, lsp, fileState, checkpoints) {
     return {
         name: "write",
         effect: "write_direct",
@@ -76,6 +76,7 @@ export function createWriteTool(cwd, _options = {}, approval, lsp, fileState) {
                     return changedDuringApprovalResult(filePath, changed);
                 }
                 try {
+                    await checkpoints?.()?.captureBefore(filePath, existed ? oldContent : null);
                     await mkdir(dirname(filePath), { recursive: true });
                     await writeFile(filePath, args.content, "utf-8");
                     await fileState?.observe(filePath, "write", args.content).catch(() => undefined);

package/dist/tui/display-history.d.ts

@@ -2,7 +2,6 @@ import type { ToolResultMetadata, TokenUsage } from "../types.js";
 export interface CompactionMeta {
     turns: number;
     messages: number;
-    tokensSaved: number;
     summarySections: Array<{
         label: string;
         content: string;
@@ -10,11 +9,12 @@ export interface CompactionMeta {
     contextWindow?: number;
     compactedAt: number;
 }
+export type UserInputStatus = "queued" | "pending_steer";
 export interface DisplayMessage {
     role: "user" | "assistant" | "error";
     content: string;
     clientId?: string;
-    queued?: boolean;
+    inputStatus?: UserInputStatus;
     reasoning?: string;
     toolCalls?: DisplayToolCall[];
     parts?: DisplayMessagePart[];
@@ -53,11 +53,12 @@ export interface DisplayToolCall {
     startedAt?: number;
     completedAt?: number;
 }
+export declare function userInputStatusBadgeLabel(status?: UserInputStatus): string | undefined;
+export declare function setUserInputStatus(message: DisplayMessage, inputStatus?: UserInputStatus): DisplayMessage;
 export declare function appendTextPart(parts: DisplayMessagePart[], content: string): void;
 export declare function appendToolPart(parts: DisplayMessagePart[], toolCall: DisplayToolCall): void;
 export declare function snapshotDisplayParts(parts: DisplayMessagePart[]): DisplayMessagePart[];
 export declare function contentFromParts(parts: DisplayMessagePart[]): string;
 export declare function toolCallsFromParts(parts: DisplayMessagePart[]): DisplayToolCall[];
 export declare function compactDisplayMessages(messages: DisplayMessage[]): DisplayMessage[];
-export declare function truncateText(value: string, maxChars: number): string;
 export declare function formatCompactNumber(n: number): string;