@bubblebrain-ai/bubble 0.0.20 → 0.0.22

package/dist/provider.js

@@ -10,6 +10,7 @@ import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-open
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
+import { RateLimitError } from "./network/errors.js";
 // Diagnostic logger for tool-args byte-loss investigation. Activate with
 //   BUBBLE_DEBUG_TOOL_ARGS=/path/to/log.jsonl   (any writable path)
 // Each line is a JSON record describing a transition. When debugging is off,
@@ -128,9 +129,28 @@ export function createProviderInstance(options) {
         if (requestConfig.reasoningEffort && requestConfig.reasoningEffort !== "off") {
             body.reasoning = { enabled: true };
         }
-        const stream = (await client.chat.completions.create(body, {
-            signal: chatOptions.abortSignal,
-        }));
+        // Rate-limit contract (design §4.5): "defer" disables the SDK's own
+        // retries so the caller is the single 429 backoff layer; either policy
+        // surfaces a final 429 as a typed RateLimitError instead of a string.
+        let stream;
+        try {
+            stream = (await client.chat.completions.create(body, {
+                signal: chatOptions.abortSignal,
+                ...(chatOptions.rateLimitPolicy === "defer" ? { maxRetries: 0 } : {}),
+            }));
+        }
+        catch (error) {
+            if (error?.status === 429) {
+                const retryAfterHeader = error?.headers?.["retry-after"];
+                const retryAfterSeconds = Number(retryAfterHeader);
+                throw new RateLimitError(error?.message || "Rate limited (429)", {
+                    status: 429,
+                    retryAfterMs: Number.isFinite(retryAfterSeconds) ? Math.round(retryAfterSeconds * 1000) : undefined,
+                    cause: error,
+                });
+            }
+            throw error;
+        }
         yield* translateOpenAIStream(stream, {
             toolArgsMergeMode: resolveToolArgsMergeMode(options.providerId || "", options.baseURL),
             reasoningMergeMode: resolveReasoningMergeMode(options.providerId || "", options.baseURL),

package/dist/session.d.ts

@@ -1,6 +1,7 @@
 /**
  * Session Manager - Append-only JSONL persistence over a structured session log.
  */
+import { CheckpointStore } from "./checkpoints.js";
 import { type CompactOptions, type CompactResult } from "./context/compact.js";
 import type { Message, Todo } from "./types.js";
 import type { SessionLogEntry, SessionMarkerKind, SessionMetadata } from "./session-types.js";
@@ -16,9 +17,25 @@ export interface SessionSummary {
     mtime: number;
 }
 export type { SessionLogEntry, SessionMarkerKind, SessionMetadata } from "./session-types.js";
+export interface UserTurn {
+    /** Session log entry id of the user message that starts the turn. */
+    id: string;
+    /** Single-line preview of the user message. */
+    preview: string;
+    /** Full text of the user message. */
+    text: string;
+    timestamp: number;
+}
+export interface RewindResult {
+    /** Number of log entries removed. */
+    removedEntries: number;
+    /** Full text of the user message the session was rewound to (for re-editing). */
+    targetText: string;
+}
 export declare class SessionManager {
     private sessionFile;
     private log;
+    private checkpoints?;
     constructor(sessionFile: string);
     static create(cwd: string, sessionName?: string): SessionManager;
     static resume(cwd: string, sessionName?: string): SessionManager | undefined;
@@ -41,6 +58,20 @@ export declare class SessionManager {
     getTodos(): Todo[];
     compact(options?: CompactOptions): CompactResult;
     getMessages(): Message[];
+    /**
+     * Pre-edit file snapshot store for this session, used by /rewind.
+     * Lives next to the session JSONL as `<session>.checkpoints/`.
+     */
+    getCheckpoints(): CheckpointStore;
+    /** Entry id of the most recent user message, or "0" before the first one. */
+    lastUserEntryId(): string;
+    /** User messages after the latest /clear, oldest first — the valid rewind anchors. */
+    listUserTurns(): UserTurn[];
+    /**
+     * 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: string): RewindResult | undefined;
     getEntries(): SessionLogEntry[];
     getSessionFile(): string;
     private maybeAutoCompact;

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

@@ -5,7 +5,10 @@ import { normalizeNameForMCP } from "../mcp/name.js";
 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 { SessionManager } from "../session.js";
 import { buildSystemPrompt } from "../system-prompt.js";
+import { normalizeSingleLine } from "../text-display.js";
+import { formatRelativeTime } from "../tui/recent-activity.js";
 import { HOOK_EVENT_NAMES, isHookEventName } from "../hooks/index.js";
 import { isThinkingLevel } from "../variant/thinking-level.js";
 import { collectUsageStatsBundle, formatStatsText } from "../stats/usage.js";
@@ -399,11 +402,115 @@ 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",
+        description: "Browse recent sessions and resume one. /session to pick, /session --list to print",
         async handler(args, ctx) {
-            return `Session info not implemented yet.`;
+            const flag = args.trim();
+            if (flag && flag !== "--list") {
+                return "Usage: /session (open the session picker) or /session --list";
+            }
+            if (!flag && ctx.openSessionPicker) {
+                ctx.openSessionPicker();
+                return;
+            }
+            const summaries = SessionManager.summarizeSessionsForCwd(ctx.cwd);
+            if (summaries.length === 0) {
+                return "No sessions recorded for this project yet.";
+            }
+            const activeFile = ctx.sessionManager?.getSessionFile();
+            const lines = ["Recent sessions:"];
+            for (const summary of summaries.slice(0, 15)) {
+                const current = summary.file === activeFile ? " (current)" : "";
+                const title = normalizeSingleLine(summary.title || summary.preview || summary.name);
+                const count = `${summary.messageCount} message${summary.messageCount === 1 ? "" : "s"}`;
+                lines.push(`- ${title} — ${count}, ${formatRelativeTime(summary.mtime)} (${summary.name})${current}`);
+            }
+            if (summaries.length > 15) {
+                lines.push(`- … and ${summaries.length - 15} more`);
+            }
+            lines.push("", "Resume one with: bubble --resume --session <name>");
+            return lines.join("\n");
         },
     },
     {

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

@@ -48,6 +48,12 @@ 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;
+    /** Open the interactive session picker. When absent, /session falls back to a text listing. */
+    openSessionPicker?: () => 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/agent-lifecycle.d.ts

@@ -1,6 +1,32 @@
-import type { ToolRegistryEntry } from "../types.js";
-export declare function createSpawnAgentTool(): ToolRegistryEntry;
+import type { AgentProfile } from "../agent/profiles.js";
+import type { ApprovalController } from "../approval/types.js";
+import type { ToolRegistryEntry, ToolResult } from "../types.js";
+export interface AgentLifecycleToolOptions {
+    /** Working directory used for profile discovery in tool descriptions. */
+    cwd?: string;
+    /** Trust gate for project-local .bubble/agents profiles (design §10.2). */
+    approval?: ApprovalController;
+}
+/**
+ * Session-scoped trust decisions for project profiles, keyed by file path +
+ * content hash so an edited file re-prompts (design §10.2). Shared across the
+ * lifecycle tools created by one factory call.
+ */
+declare class ProjectProfileTrust {
+    private readonly approval?;
+    private readonly approved;
+    constructor(approval?: ApprovalController | undefined);
+    /** Returns undefined when trusted, else a blocked ToolResult. */
+    ensureTrusted(profile: AgentProfile): Promise<ToolResult | undefined>;
+}
+export declare function createSpawnAgentTool(options?: AgentLifecycleToolOptions, sharedTrust?: ProjectProfileTrust): ToolRegistryEntry;
 export declare function createWaitAgentTool(): ToolRegistryEntry;
 export declare function createSendInputTool(): ToolRegistryEntry;
 export declare function createCloseAgentTool(): ToolRegistryEntry;
-export declare function createAgentLifecycleTools(): ToolRegistryEntry[];
+export declare function createListAgentsTool(): ToolRegistryEntry;
+/** Items bound for one agent_team call (design §1.2). */
+export declare const AGENT_TEAM_MIN_ITEMS = 2;
+export declare const AGENT_TEAM_MAX_ITEMS = 32;
+export declare function createAgentTeamTool(options?: AgentLifecycleToolOptions, sharedTrust?: ProjectProfileTrust): ToolRegistryEntry;
+export declare function createAgentLifecycleTools(options?: AgentLifecycleToolOptions): ToolRegistryEntry[];
+export {};