@bubblebrain-ai/bubble 0.0.52 → 0.0.53

package/dist/context/compact-llm.js

@@ -108,13 +108,16 @@ export async function compactMessagesWithLLM(messages, options) {
  * `oldMessages`. Shared by the non-streaming overflow path (`generateSummary`)
  * and the streaming manual `/compact` path (`Agent.summarizeForCompaction`).
  */
-export function buildCompactionPromptMessages(oldMessages) {
+export function buildCompactionPromptMessages(oldMessages, userContext) {
     const transcript = serializeTranscript(oldMessages);
+    const preservationNote = userContext?.trim()
+        ? `\n\nUser-provided context for this compaction:\n${userContext.trim()}\n\nIncorporate this context prominently in the relevant sections.`
+        : "";
     return [
         { role: "system", content: COMPACT_SYSTEM_PROMPT },
         {
             role: "user",
-            content: `Conversation to summarize:\n\n${transcript}\n\n---\n\n${COMPACT_INSTRUCTIONS}`,
+            content: `Conversation to summarize:\n\n${transcript}\n\n---\n\n${COMPACT_INSTRUCTIONS}${preservationNote}`,
         },
     ];
 }

package/dist/context/overflow.js

@@ -10,6 +10,8 @@ const OVERFLOW_PATTERNS = [
     /exceeds the context window/i,
     /exceeds the limit of\s+\d+/i,
     /prompt is too long/i,
+    /prompt exceeds max(?:imum)? length/i,
+    /maximum prompt length/i,
     /maximum context length/i,
     /too many tokens/i,
     // Gemini: "The input token count (N) exceeds the maximum number of tokens allowed (M)."

package/dist/context/projector.d.ts

@@ -5,8 +5,16 @@ export interface ProjectionOptions {
     modelId?: string;
     usageAnchorTokens?: number;
     anchorMessageCount?: number;
+    /** Request tokens not represented by messages, such as active tool schemas. */
+    additionalInputTokens?: number;
 }
 export declare function projectMessages(messages: Message[], options?: ProjectionOptions): ProviderMessage[];
+/**
+ * Re-bound restored tool messages and divide a hard aggregate budget fairly
+ * across sibling calls. A historical 6MB JSONL entry therefore becomes safe
+ * at projection time even if it predates live-result normalization.
+ */
+export declare function boundToolOutputBatches(messages: ProviderMessage[], providerId: string, modelId: string): ProviderMessage[];
 /**
  * Ensures every assistant `tool_calls` is followed (in order) by tool messages
  * responding to each tool_call_id, with no foreign messages interleaved.

package/dist/context/projector.js

@@ -2,6 +2,7 @@ import { getContextBudget } from "./budget.js";
 import { compactCurrentTurnToolGroups, compactMessages } from "./compact.js";
 import { pruneMessages } from "./prune.js";
 import { formatInternalContextBlock, formatInternalReminderBlock } from "../agent/internal-reminder-sanitizer.js";
+import { DEFAULT_TOOL_OUTPUT_BYTE_LIMIT, TOOL_OUTPUT_BATCH_BYTE_LIMIT, truncateToolOutputForModel, } from "./tool-output-truncate.js";
 // Prefix-cache invariant: only the leading static system prompt is promoted to
 // the first provider message. Runtime meta reminders stay in the conversational
 // body at their original relative position, so a new per-turn reminder does not
@@ -49,11 +50,14 @@ export function projectMessages(messages, options = {}) {
         ...projectedBody,
     ];
     const repaired = repairToolCallChains(projected);
+    const bounded = options.providerId && options.modelId
+        ? boundToolOutputBatches(repaired, options.providerId, options.modelId)
+        : repaired;
     if (mode === "pruned") {
-        return pruneMessages(repaired);
+        return pruneMessages(bounded);
     }
     if (mode === "budgeted") {
-        const pruned = pruneMessages(repaired);
+        const pruned = pruneMessages(bounded);
         if (!options.providerId || !options.modelId) {
             return pruned;
         }
@@ -61,8 +65,9 @@ export function projectMessages(messages, options = {}) {
             ? {
                 usageAnchorTokens: options.usageAnchorTokens,
                 tailMessages: pruned.slice(Math.min(options.anchorMessageCount, pruned.length)),
+                additionalInputTokens: options.additionalInputTokens,
             }
-            : undefined);
+            : { additionalInputTokens: options.additionalInputTokens });
         if (!budget.shouldCompact) {
             return pruned;
         }
@@ -81,7 +86,9 @@ export function projectMessages(messages, options = {}) {
             const next = pass();
             if (next)
                 working = next;
-            const after = getContextBudget(options.providerId, options.modelId, working);
+            const after = getContextBudget(options.providerId, options.modelId, working, {
+                additionalInputTokens: options.additionalInputTokens,
+            });
             if (!after.shouldCompact)
                 break;
         }
@@ -91,9 +98,51 @@ export function projectMessages(messages, options = {}) {
         const providerSafe = working.map((message) => message.role === "meta"
             ? { role: "user", content: formatMetaMessage(message) }
             : message);
-        return repairToolCallChains(providerSafe);
+        return boundToolOutputBatches(repairToolCallChains(providerSafe), options.providerId, options.modelId);
+    }
+    return bounded;
+}
+/**
+ * Re-bound restored tool messages and divide a hard aggregate budget fairly
+ * across sibling calls. A historical 6MB JSONL entry therefore becomes safe
+ * at projection time even if it predates live-result normalization.
+ */
+export function boundToolOutputBatches(messages, providerId, modelId) {
+    const bounded = [];
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        bounded.push(message);
+        if (message.role !== "assistant" || !message.toolCalls?.length)
+            continue;
+        const siblingCount = message.toolCalls.length;
+        const perResultByteLimit = Math.min(DEFAULT_TOOL_OUTPUT_BYTE_LIMIT, Math.floor(TOOL_OUTPUT_BATCH_BYTE_LIMIT / siblingCount));
+        for (let sibling = 0; sibling < siblingCount; sibling++) {
+            const toolMessage = messages[index + 1 + sibling];
+            if (!toolMessage || toolMessage.role !== "tool")
+                break;
+            const result = truncateToolOutputForModel(toolMessage.content, providerId, modelId, { hardByteLimit: perResultByteLimit });
+            bounded.push(result.truncated
+                ? {
+                    ...toolMessage,
+                    content: result.content,
+                    metadata: {
+                        ...toolMessage.metadata,
+                        truncated: true,
+                        toolOutputTruncation: {
+                            originalBytes: result.originalBytes,
+                            finalBytes: result.finalBytes,
+                            originalTokens: result.originalTokens,
+                            finalTokens: result.finalTokens,
+                            hardByteLimit: result.hardByteLimit,
+                            ...(result.limit ? { modelTokenLimit: result.limit } : {}),
+                        },
+                    },
+                }
+                : toolMessage);
+        }
+        index += siblingCount;
     }
-    return repaired;
+    return bounded;
 }
 /**
  * Ensures every assistant `tool_calls` is followed (in order) by tool messages

package/dist/context/tool-output-truncate.d.ts

@@ -1,8 +1,24 @@
+import type { ToolResult } from "../types.js";
+export declare const DEFAULT_TOOL_OUTPUT_BYTE_LIMIT: number;
+export declare const TOOL_OUTPUT_BATCH_BYTE_LIMIT: number;
+export interface ToolTruncationOptions {
+    /** Override used by a sibling tool batch to divide its aggregate budget. */
+    hardByteLimit?: number;
+}
 export interface ToolTruncationResult {
     content: string;
     truncated: boolean;
     originalTokens: number;
     finalTokens: number;
+    originalBytes: number;
+    finalBytes: number;
+    /** Provider/model-declared token cap, when one exists. */
     limit: number | undefined;
+    hardByteLimit: number;
 }
-export declare function truncateToolOutputForModel(content: string, providerId: string, modelId: string): ToolTruncationResult;
+export declare function truncateToolOutputForModel(content: string, providerId: string, modelId: string, options?: ToolTruncationOptions): ToolTruncationResult;
+export declare function normalizeToolResultForModel(result: ToolResult, providerId: string, modelId: string, options?: ToolTruncationOptions): ToolResult;
+/** Return the longest prefix that fits without splitting a Unicode code point. */
+export declare function utf8Prefix(content: string, maxBytes: number): string;
+/** Return the longest suffix that fits without splitting a Unicode code point. */
+export declare function utf8Suffix(content: string, maxBytes: number): string;

package/dist/context/tool-output-truncate.js

@@ -1,59 +1,181 @@
-// Tool-output truncation honoring the model's server-declared limit.
+// Tool-output bounding for both live results and restored session history.
 //
-// Codex backend's /models endpoint reports per-model `truncation_policy.limit`
-// (e.g. 10000 tokens for gpt-5.5). The expectation is that the CLIENT truncates
-// each tool result to that budget before adding it to history; sending raw
-// 50-100k tool dumps will blow through the input window after a handful of
-// calls. Codex CLI does this via TruncationPolicy::Tokens; mirror it here.
-//
-// Strategy: middle-truncate (preserve head + tail with an explicit marker in
-// between). Heads usually carry structure/headers; tails often carry totals,
-// errors, or conclusions — losing either is worse than losing the middle.
+// A provider-declared token cap is useful when present, but it cannot be the
+// only guard: several providers (including GLM coding-plan models) declare no
+// per-tool limit at all. Every model-visible tool result therefore has a hard
+// byte ceiling as well. The stricter of the two policies wins.
 import { getToolOutputTokenLimit } from "../model-catalog.js";
 import { estimateTextTokens } from "./budget.js";
-export function truncateToolOutputForModel(content, providerId, modelId) {
+export const DEFAULT_TOOL_OUTPUT_BYTE_LIMIT = 64 * 1024;
+export const TOOL_OUTPUT_BATCH_BYTE_LIMIT = 160 * 1024;
+export function truncateToolOutputForModel(content, providerId, modelId, options = {}) {
     const limit = getToolOutputTokenLimit(providerId, modelId);
+    const hardByteLimit = Math.max(0, Math.floor(options.hardByteLimit ?? DEFAULT_TOOL_OUTPUT_BYTE_LIMIT));
     const originalTokens = estimateTextTokens(content, providerId);
-    if (!limit || originalTokens <= limit) {
-        return { content, truncated: false, originalTokens, finalTokens: originalTokens, limit };
+    const originalBytes = Buffer.byteLength(content, "utf8");
+    if (originalBytes <= hardByteLimit && (!limit || originalTokens <= limit)) {
+        return {
+            content,
+            truncated: false,
+            originalTokens,
+            finalTokens: originalTokens,
+            originalBytes,
+            finalBytes: originalBytes,
+            limit,
+            hardByteLimit,
+        };
+    }
+    if (hardByteLimit === 0) {
+        return {
+            content: "",
+            truncated: content.length > 0,
+            originalTokens,
+            finalTokens: 0,
+            originalBytes,
+            finalBytes: 0,
+            limit,
+            hardByteLimit,
+        };
+    }
+    // Start with the byte ceiling. If a token policy is tighter, use the
+    // observed token/byte ratio to choose a smaller first candidate.
+    let candidateByteBudget = hardByteLimit;
+    if (limit && originalTokens > limit) {
+        candidateByteBudget = Math.min(candidateByteBudget, Math.max(1, Math.floor(originalBytes * (limit / originalTokens) * 0.9)));
+    }
+    let truncated = middleTruncateToByteBudget(content, candidateByteBudget, buildMarker(originalBytes, hardByteLimit, limit));
+    // Token estimation varies across providers and scripts. Tighten until both
+    // invariants hold; byte truncation itself is UTF-8 safe on every pass.
+    for (let pass = 0; pass < 8 && limit && estimateTextTokens(truncated, providerId) > limit; pass++) {
+        const tokens = estimateTextTokens(truncated, providerId);
+        candidateByteBudget = Math.max(1, Math.floor(candidateByteBudget * (limit / Math.max(1, tokens)) * 0.9));
+        truncated = middleTruncateToByteBudget(content, candidateByteBudget, buildMarker(originalBytes, hardByteLimit, limit));
+    }
+    // Extremely small model caps may not even fit the descriptive marker.
+    // Continue shrinking deterministically rather than violating the contract.
+    while (limit && estimateTextTokens(truncated, providerId) > limit && truncated.length > 0) {
+        candidateByteBudget = Math.max(0, Math.floor(candidateByteBudget * 0.75));
+        truncated = middleTruncateToByteBudget(content, candidateByteBudget, buildMarker(originalBytes, hardByteLimit, limit));
     }
-    const truncated = middleTruncateToTokenBudget(content, limit, providerId);
     const finalTokens = estimateTextTokens(truncated, providerId);
-    return { content: truncated, truncated: true, originalTokens, finalTokens, limit };
+    const finalBytes = Buffer.byteLength(truncated, "utf8");
+    return {
+        content: truncated,
+        truncated: true,
+        originalTokens,
+        finalTokens,
+        originalBytes,
+        finalBytes,
+        limit,
+        hardByteLimit,
+    };
+}
+export function normalizeToolResultForModel(result, providerId, modelId, options = {}) {
+    const bounded = truncateToolOutputForModel(result.content, providerId, modelId, options);
+    if (!bounded.truncated)
+        return result;
+    return {
+        ...result,
+        content: bounded.content,
+        metadata: {
+            ...result.metadata,
+            truncated: true,
+            toolOutputTruncation: {
+                originalBytes: bounded.originalBytes,
+                finalBytes: bounded.finalBytes,
+                originalTokens: bounded.originalTokens,
+                finalTokens: bounded.finalTokens,
+                hardByteLimit: bounded.hardByteLimit,
+                ...(bounded.limit ? { modelTokenLimit: bounded.limit } : {}),
+            },
+        },
+    };
+}
+function buildMarker(originalBytes, hardByteLimit, tokenLimit) {
+    const policy = tokenLimit
+        ? `${formatBytes(hardByteLimit)} hard cap; ${tokenLimit}-token model cap`
+        : `${formatBytes(hardByteLimit)} hard cap`;
+    return `\n\n[... middle of ${formatBytes(originalBytes)} output truncated by model policy (${policy}) ...]\n\n`;
+}
+function middleTruncateToByteBudget(content, byteBudget, marker) {
+    if (byteBudget <= 0)
+        return "";
+    if (Buffer.byteLength(content, "utf8") <= byteBudget)
+        return content;
+    let safeMarker = marker;
+    if (Buffer.byteLength(safeMarker, "utf8") > byteBudget) {
+        safeMarker = utf8Prefix(safeMarker, byteBudget);
+    }
+    const markerBytes = Buffer.byteLength(safeMarker, "utf8");
+    const payloadBytes = Math.max(0, byteBudget - markerBytes);
+    const headBudget = Math.floor(payloadBytes / 2);
+    const tailBudget = payloadBytes - headBudget;
+    const head = utf8Prefix(content, headBudget);
+    const tail = utf8Suffix(content, tailBudget);
+    return `${head}${safeMarker}${tail}`;
+}
+/** Return the longest prefix that fits without splitting a Unicode code point. */
+export function utf8Prefix(content, maxBytes) {
+    if (maxBytes <= 0 || content.length === 0)
+        return "";
+    if (Buffer.byteLength(content, "utf8") <= maxBytes)
+        return content;
+    let low = 0;
+    let high = content.length;
+    while (low < high) {
+        const mid = Math.ceil((low + high) / 2);
+        const safeMid = isLowSurrogateAt(content, mid) ? mid - 1 : mid;
+        if (Buffer.byteLength(content.slice(0, safeMid), "utf8") <= maxBytes)
+            low = mid;
+        else
+            high = mid - 1;
+    }
+    let end = Math.min(low, content.length);
+    if (isLowSurrogateAt(content, end))
+        end -= 1;
+    while (end > 0 && Buffer.byteLength(content.slice(0, end), "utf8") > maxBytes)
+        end -= 1;
+    if (isLowSurrogateAt(content, end))
+        end -= 1;
+    return content.slice(0, Math.max(0, end));
 }
-function middleTruncateToTokenBudget(content, tokenBudget, providerId) {
-    // Convert token budget to a char budget via the estimator's effective ratio.
-    // The estimator may under/overcount, so we iterate one round if needed.
-    const tokensAll = estimateTextTokens(content, providerId);
-    if (tokensAll <= tokenBudget)
+/** Return the longest suffix that fits without splitting a Unicode code point. */
+export function utf8Suffix(content, maxBytes) {
+    if (maxBytes <= 0 || content.length === 0)
+        return "";
+    if (Buffer.byteLength(content, "utf8") <= maxBytes)
         return content;
-    const charsPerToken = content.length / Math.max(1, tokensAll);
-    let charBudget = Math.floor(tokenBudget * charsPerToken);
-    const marker = (dropped) => `\n\n[... middle ${formatChars(dropped)} truncated by model policy (${tokenBudget}-token cap) ...]\n\n`;
-    // Reserve some room for the marker itself.
-    const reserveForMarker = 200;
-    charBudget = Math.max(200, charBudget - reserveForMarker);
-    const half = Math.floor(charBudget / 2);
-    const head = content.slice(0, half);
-    const tail = content.slice(content.length - (charBudget - half));
-    const droppedChars = content.length - head.length - tail.length;
-    let truncated = `${head}${marker(droppedChars)}${tail}`;
-    // Tighten if our estimate of charsPerToken undercounts and we're still over.
-    let safety = 3;
-    while (estimateTextTokens(truncated, providerId) > tokenBudget && safety-- > 0) {
-        const newHalf = Math.floor(head.length * 0.8);
-        const newTailLen = Math.floor(tail.length * 0.8);
-        const newHead = content.slice(0, newHalf);
-        const newTail = content.slice(content.length - newTailLen);
-        const newDropped = content.length - newHead.length - newTail.length;
-        truncated = `${newHead}${marker(newDropped)}${newTail}`;
-    }
-    return truncated;
-}
-function formatChars(count) {
-    if (count < 1000)
-        return `${count} chars`;
-    if (count < 1_000_000)
-        return `${(count / 1000).toFixed(1)}K chars`;
-    return `${(count / 1_000_000).toFixed(2)}M chars`;
+    let low = 0;
+    let high = content.length;
+    while (low < high) {
+        const length = Math.ceil((low + high) / 2);
+        let start = content.length - length;
+        if (isLowSurrogateAt(content, start))
+            start += 1;
+        if (Buffer.byteLength(content.slice(start), "utf8") <= maxBytes)
+            low = length;
+        else
+            high = length - 1;
+    }
+    let start = Math.max(0, content.length - low);
+    if (isLowSurrogateAt(content, start))
+        start += 1;
+    while (start < content.length && Buffer.byteLength(content.slice(start), "utf8") > maxBytes)
+        start += 1;
+    if (isLowSurrogateAt(content, start))
+        start += 1;
+    return content.slice(Math.min(start, content.length));
+}
+function isLowSurrogateAt(content, index) {
+    if (index <= 0 || index >= content.length)
+        return false;
+    const code = content.charCodeAt(index);
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+function formatBytes(count) {
+    if (count < 1024)
+        return `${count}B`;
+    if (count < 1024 * 1024)
+        return `${(count / 1024).toFixed(1)}KiB`;
+    return `${(count / (1024 * 1024)).toFixed(2)}MiB`;
 }

package/dist/feishu/agent-host/run-driver.js

@@ -31,6 +31,7 @@ import { applyCardBudget } from "../card/budget.js";
 import { renderCard } from "../card/renderer.js";
 import { createInitialRunState } from "../card/run-state-types.js";
 import { hasInFlightTool, markError, markInterrupted, markIdleTimeout, reduceRunState } from "../card/run-state.js";
+import { assertProviderModelAllowed } from "../../provider-model-policy.js";
 export class RunDriver {
     opts;
     constructor(opts) {
@@ -311,6 +312,8 @@ export class RunDriver {
             ? decodeModel(normalizedConfigured)
             : { providerId: undefined, modelId: "" };
         const activeProviderId = effectiveProviderId || fallbackProviderId;
+        if (effectiveModelId)
+            assertProviderModelAllowed(activeProviderId, effectiveModelId);
         if (registry.supportsOAuth(activeProviderId) && registry.getAuthStorage().has(activeProviderId)) {
             await registry.prepareProvider(activeProviderId);
         }

package/dist/feishu/serve.js

@@ -85,6 +85,8 @@ export async function serveFeishu(opts = {}) {
     const skillRegistry = new SkillRegistry({
         cwd: rootCwd,
         skillPaths: userConfig.getSkillPaths(),
+        disabledSkills: userConfig.getDisabledSkills(),
+        onDisabledSkillsChange: (disabledSkills) => userConfig.setDisabledSkills(disabledSkills),
     });
     const mcpLoaded = loadMcpConfig({ cwd: rootCwd });
     const mcpManager = new McpManager({ servers: mcpLoaded.servers });

package/dist/goal/command.d.ts

@@ -4,7 +4,7 @@
  * Forms:
  *   /goal                      -> show summary
  *   /goal <objective> [--budget N]  -> set a new goal
- *   /goal clear | pause | resume
+ *   /goal status | clear | pause | resume
  *   /goal edit <new objective>
  *
  * --budget accepts plain integers and k/m suffixes: 200000, 200k, 1.5m.

package/dist/goal/command.js

@@ -4,12 +4,12 @@
  * Forms:
  *   /goal                      -> show summary
  *   /goal <objective> [--budget N]  -> set a new goal
- *   /goal clear | pause | resume
+ *   /goal status | clear | pause | resume
  *   /goal edit <new objective>
  *
  * --budget accepts plain integers and k/m suffixes: 200000, 200k, 1.5m.
  */
-const SUBCOMMANDS = new Set(["clear", "pause", "resume", "edit"]);
+const SUBCOMMANDS = new Set(["status", "clear", "pause", "resume", "edit"]);
 export function parseGoalCommand(input) {
     const body = input.trim().replace(/^\/goal\b/, "").trim();
     if (!body)
@@ -17,6 +17,11 @@ export function parseGoalCommand(input) {
     const firstToken = body.split(/\s+/, 1)[0].toLowerCase();
     const rest = body.slice(firstToken.length).trim();
     if (SUBCOMMANDS.has(firstToken)) {
+        if (firstToken === "status") {
+            if (rest)
+                return { kind: "show", error: "/goal status takes no arguments" };
+            return { kind: "show" };
+        }
         if (firstToken === "edit") {
             if (!rest)
                 return { kind: "edit", error: "Usage: /goal edit <new objective>" };

package/dist/main.d.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 /**
  * Main entry point - assembles all layers and runs the agent.
  */

package/dist/main.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 /**
  * Main entry point - assembles all layers and runs the agent.
  */
@@ -38,6 +38,8 @@ import { normalizeSingleLine, truncateVisual } from "./text-display.js";
 import { BUBBLE_WORDMARK } from "./tui/wordmark.js";
 import { configureDebugTrace, summarizeAgentEventForTrace, summarizeTraceMessage, traceEvent, } from "./debug-trace.js";
 import { shouldRejectGrokSessionInPrintMode } from "./external-runtime/session-policy.js";
+import { rmSync } from "node:fs";
+import { splitLeadingContext } from "./context/compact.js";
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     if (process.argv.includes("-h") || process.argv.includes("--help")) {
@@ -72,6 +74,8 @@ async function main() {
     const skillRegistry = new SkillRegistry({
         cwd: args.cwd,
         skillPaths: userConfig.getSkillPaths(),
+        disabledSkills: userConfig.getDisabledSkills(),
+        onDisabledSkillsChange: (disabledSkills) => userConfig.setDisabledSkills(disabledSkills),
     });
     const printMode = args.print || !!args.prompt;
     // Resolve configured providers only; do not auto-inject OpenRouter as a startup default.
@@ -187,6 +191,7 @@ async function main() {
         processManager,
         allowBackgroundTasks,
         promotionChannel,
+        autoBackgroundAfterMs: userConfig.getTasksAutoBackgroundAfterMs(),
         // Lazy: sessionManager is resolved after tools are created.
         checkpoints: () => sessionManager?.getCheckpoints(),
     });
@@ -263,8 +268,8 @@ async function main() {
             }
             const pickerThemeMode = effectiveThemeModeForTerminal(themeConfig, preResolvedTheme);
             const pickerResolvedTheme = pickerThemeMode === "auto" ? preResolvedTheme : pickerThemeMode;
-            const { runSessionPicker } = await import("./tui-ink/run-session-picker.js");
-            const { canvasBackgroundFor } = await import("./tui-ink/theme.js");
+            const { runSessionPicker } = await import("./tui/run-session-picker.js");
+            const { canvasBackgroundFor } = await import("./tui/model/theme.js");
             // Same rule as the main TUI: a forced theme mismatching the terminal
             // paints its canvas so its foregrounds stay readable.
             const pickerCanvas = themeConfig.overrides?.background
@@ -367,7 +372,7 @@ async function main() {
         sessionFile: sessionManager?.getSessionFile(),
         provider: activeProviderId || "none",
         model: activeModel || "none",
-        renderer: printMode ? "print" : "ink",
+        renderer: printMode ? "print" : "pi-tui",
     });
     if (traceInfo.enabled) {
         traceEvent("run_start", {
@@ -451,6 +456,8 @@ async function main() {
             list: () => processManager.listTasks(agent.getSessionID()),
             version: () => processManager.getTaskStateVersion(),
             outputTail: (id) => processManager.taskOutputTail(id, 2000),
+            kill: (id) => processManager.killTask(id),
+            subscribe: (listener) => processManager.onChange(() => listener()),
         };
     }
     if (sessionManager) {
@@ -674,9 +681,8 @@ async function main() {
         // that persists to the session (onMessageAppend, markers, title updater)
         // by reassigning the outer `sessionManager`, then replace the agent's
         // history the same way startup resume does.
-        const switchSession = (sessionFile) => {
+        const activateSession = (next) => {
             try {
-                const next = new SessionManager(sessionFile);
                 const history = next.getMessages();
                 const nextPromptCacheKey = next.getOrCreatePromptCacheKey();
                 const nextTitleUpdater = createSessionTitleUpdater({
@@ -691,7 +697,7 @@ async function main() {
                 });
                 // Keep the live system/meta head (mode reminders survive the switch),
                 // mirroring the /rewind history-replacement pattern.
-                const head = agent.messages.filter((m) => m.role === "system" || m.role === "meta");
+                const head = splitLeadingContext(agent.messages).leading;
                 const nextMessages = [...head, ...history];
                 // Commit only after every file read/write and reconstruction step has
                 // succeeded. Callers can safely prepare candidate sessions without a
@@ -713,9 +719,33 @@ async function main() {
                 return { error: error instanceof Error ? error.message : String(error) };
             }
         };
+        const switchSession = (sessionFile) => {
+            try {
+                return activateSession(new SessionManager(sessionFile));
+            }
+            catch (error) {
+                return { error: error instanceof Error ? error.message : String(error) };
+            }
+        };
+        const createFreshSession = (cwd) => {
+            let fresh;
+            try {
+                fresh = SessionManager.createFresh(cwd);
+                const result = activateSession(fresh);
+                if ("error" in result)
+                    rmSync(fresh.getSessionFile(), { force: true });
+                return result;
+            }
+            catch (error) {
+                if (fresh)
+                    rmSync(fresh.getSessionFile(), { force: true });
+                return { error: error instanceof Error ? error.message : String(error) };
+            }
+        };
         const commonOptions = {
             sessionManager,
             switchSession,
+            createFreshSession,
             createProvider,
             registry,
             skillRegistry,
@@ -749,7 +779,7 @@ async function main() {
         const { startStartupUpdateCheck } = await import("./update/index.js");
         const updateCheck = await startStartupUpdateCheck();
         const updateNotice = updateCheck.notice;
-        const { runTui } = await import("./tui-ink/run.js");
+        const { runTui } = await import("./tui/run.js");
         const summary = await runTui(agent, args, {
             ...commonOptions,
             themeMode: effectiveThemeMode,

package/dist/memory/db.js

@@ -304,10 +304,6 @@ function unixNow() {
     return Math.floor(Date.now() / 1000);
 }
 function createDatabase(path) {
-    if (isBunRuntime()) {
-        const bunSqlite = require("bun:sqlite");
-        return new bunSqlite.Database(path);
-    }
     const Database = require("better-sqlite3");
     return new Database(path);
 }
@@ -318,6 +314,3 @@ function setWalMode(db) {
     }
     db.prepare("PRAGMA journal_mode = WAL").get();
 }
-function isBunRuntime() {
-    return typeof globalThis.Bun !== "undefined";
-}