@selesai/code 0.9.10 → 0.9.12

package/dist/cli/args.js

@@ -16,7 +16,18 @@ export function parseArgs(args) {
     };
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
-        if (arg === "--help" || arg === "-h") {
+        if (arg === "--") {
+            for (const positionalArg of args.slice(i + 1)) {
+                if (positionalArg.startsWith("@")) {
+                    result.fileArgs.push(positionalArg.slice(1));
+                }
+                else {
+                    result.messages.push(positionalArg);
+                }
+            }
+            break;
+        }
+        else if (arg === "--help" || arg === "-h") {
             result.help = true;
         }
         else if (arg === "--version" || arg === "-v") {
@@ -269,7 +280,7 @@ ${chalk.bold("Options:")}
   --models <patterns>            Comma-separated model patterns for Ctrl+P cycling
                                  Supports globs (anthropic/*, *sonnet*) and fuzzy matching
   --no-tools, -nt                Disable all tools by default (built-in and extension)
-  --no-builtin-tools, -nbt       Disable built-in tools by default but keep extension/custom tools enabled
+  --no-builtin-tools, -nbt       Disable built-in tools and enable extension/custom tools
   --tools, -t <tools>            Comma-separated allowlist of tool names to enable
                                  Applies to built-in, extension, and custom tools
   --exclude-tools, -xt <tools>   Comma-separated denylist of tool names to disable

package/dist/cli/args.test.js

@@ -1,5 +1,13 @@
 import { describe, expect, test } from "vitest";
 import { parseArgs } from "./args.js";
+describe("parseArgs end-of-options delimiter", () => {
+    test("treats remaining arguments as messages and @files", () => {
+        const result = parseArgs(["--no-session", "--", "--provider", "openai", "-c", "@prompt.md"]);
+        expect(result.noSession).toBe(true);
+        expect(result.messages).toEqual(["--provider", "openai", "-c"]);
+        expect(result.fileArgs).toEqual(["prompt.md"]);
+    });
+});
 describe("parseArgs --use-theme", () => {
     test("parses --use-theme with a theme name", () => {
         const result = parseArgs(["--use-theme", "nord-border", "hello"]);

package/dist/cli/credential-print.js

@@ -7,10 +7,10 @@ export function isCredentialPrintHelp(args) {
     return (args[0] === "auth" && (args[1] === undefined || args[1] === "help" || args[1] === "--help" || args[1] === "-h"));
 }
 export function printCredentialPrintHelp() {
-    console.log(`Usage:
-  ${APP_NAME} auth print-api-key --model <model> [--provider <provider>]
-  ${APP_NAME} auth print-bearer-token --model <model> [--provider <provider>] [--min-expiry <duration>]
-
+    console.log(`Usage:
+  ${APP_NAME} auth print-api-key --model <model> [--provider <provider>]
+  ${APP_NAME} auth print-bearer-token --model <model> [--provider <provider>] [--min-expiry <duration>]
+
 Prints the configured credential alone on stdout. Provider inference uses configured credentials; specify --provider to select explicitly. Bearer tokens have a 30-minute minimum expiry by default. --min-expiry accepts ms, s, m, or h (for example, 30m).`);
 }
 /** Parse the auth command surface before normal startup. */

package/dist/config.d.ts

@@ -156,12 +156,10 @@ export declare function seedMissingSubagentSettings(destPath: string, bundledDef
 export declare function seedDefaultExtensions(agentDir: string, bundledExtensionsDir?: string): string[];
 /**
  * Seed bundled built-in skills into the user's agent dir/skills.
- * Ownership rule: bundled files are installed only when missing, so a new
- * release can supply new bundled skills, but existing user files are never
- * overwritten — user-authored edits survive. User-only skills stay. The
- * authoritative bundled copy still loads directly from the package at boot
- * (additionalSkillPaths), so a stale user copy never loses functionality.
- * Returns the list of destination paths that were written.
+ * The bundled copy is authoritative: existing user copies are overwritten so a
+ * stale installed copy never shadows the shipped skill. User-only skills (not
+ * present in the bundled tree) are left untouched. Returns the list of
+ * destination paths that were written.
  */
 export declare function seedDefaultSkills(agentDir: string, bundledSkillsDir?: string): string[];
 /**

package/dist/config.js

@@ -676,10 +676,11 @@ export function seedMissingSubagentSettings(destPath, bundledDefaultsDir = getBu
     }
 }
 /**
- * Recursively copy a bundled directory tree into the user's agent dir, skipping
- * any file that already exists (user edits survive). Never overwrites. Used to
- * seed bundled skills/themes so the user can inspect and edit them.
- * Returns the list of destination paths that were written.
+ * Recursively copy a bundled directory tree into the user's agent dir,
+ * overwriting any existing file so the bundled copy stays authoritative.
+ * Used to seed/sync bundled skills and themes. User-only files (not present in
+ * the bundled tree) are left untouched. Returns the list of destination paths
+ * that were written.
  */
 function seedBundledDir(destDir, bundledDir) {
     if (!existsSync(bundledDir))
@@ -696,13 +697,10 @@ function seedBundledDir(destDir, bundledDir) {
             const srcPath = join(src, entry.name);
             const dstPath = join(dst, entry.name);
             if (entry.isDirectory()) {
-                if (!existsSync(dstPath))
-                    mkdirSync(dstPath, { recursive: true, mode: 0o700 });
+                mkdirSync(dstPath, { recursive: true, mode: 0o700 });
                 stack.push({ src: srcPath, dst: dstPath });
             }
             else if (entry.isFile() || entry.isSymbolicLink()) {
-                if (existsSync(dstPath))
-                    continue;
                 copyFileSync(srcPath, dstPath);
                 try {
                     chmodSync(dstPath, 0o600);
@@ -754,12 +752,10 @@ export function seedDefaultExtensions(agentDir, bundledExtensionsDir = getBundle
 }
 /**
  * Seed bundled built-in skills into the user's agent dir/skills.
- * Ownership rule: bundled files are installed only when missing, so a new
- * release can supply new bundled skills, but existing user files are never
- * overwritten — user-authored edits survive. User-only skills stay. The
- * authoritative bundled copy still loads directly from the package at boot
- * (additionalSkillPaths), so a stale user copy never loses functionality.
- * Returns the list of destination paths that were written.
+ * The bundled copy is authoritative: existing user copies are overwritten so a
+ * stale installed copy never shadows the shipped skill. User-only skills (not
+ * present in the bundled tree) are left untouched. Returns the list of
+ * destination paths that were written.
  */
 export function seedDefaultSkills(agentDir, bundledSkillsDir = getBundledSkillsDir()) {
     return seedBundledDir(join(agentDir, "skills"), bundledSkillsDir);

package/dist/core/agent-session-auto-handoff.test.js

@@ -1,7 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
+import { Type } from "typebox";
 import { AgentSession } from "./agent-session.js";
 import { SettingsManager } from "./settings-manager.js";
-function createMockSession({ enabled, threshold = 128_000, tokens, mode = "tui", command, }) {
+function createMockSession({ enabled, threshold = 128_000, tokens, mode = "tui", command, customTools, allowedToolNames, }) {
     const settings = SettingsManager.inMemory({
         autoHandoff: { enabled, thresholdTokens: threshold },
     });
@@ -45,13 +46,35 @@ function createMockSession({ enabled, threshold = 128_000, tokens, mode = "tui",
         settingsManager: settings,
         cwd: "/tmp",
         resourceLoader: resourceLoader,
+        customTools,
         modelRuntime: modelRegistry,
+        allowedToolNames,
     });
     session._extensionRunner = extensionRunner;
     session._extensionMode = mode;
     session.getContextUsage = () => tokens === null ? null : { tokens, contextWindow: 200_000, percent: tokens / 200_000 };
     return { session, getCommand, createCommandContext, handler, emitError, settings };
 }
+describe("AgentSession tools", () => {
+    const customTool = {
+        name: "custom",
+        label: "Custom",
+        description: "A custom tool",
+        parameters: Type.Object({}),
+        execute: async () => ({ content: [{ type: "text", text: "ok" }], details: undefined }),
+    };
+    it("keeps custom tools inactive by default but activates explicitly allowed ones", () => {
+        const defaults = createMockSession({ enabled: false, tokens: null, customTools: [customTool] });
+        expect(defaults.session.getActiveToolNames()).not.toContain("custom");
+        const allowed = createMockSession({
+            enabled: false,
+            tokens: null,
+            customTools: [customTool],
+            allowedToolNames: ["custom"],
+        });
+        expect(allowed.session.getActiveToolNames()).toEqual(["custom"]);
+    });
+});
 describe("AgentSession auto handoff", () => {
     it("invokes handoff-new once when enabled and threshold reached in tui mode", async () => {
         const command = { handler: vi.fn() };

package/dist/core/agent-session.d.ts

@@ -172,6 +172,11 @@ export interface PromptOptions {
     preflightResult?: (success: boolean) => void;
 }
 /** Result from cycleModel() */
+/** Options for model and thinking mutations. */
+export interface ModelMutationOptions {
+    /** Persist the value to global defaults. Defaults to session-only. */
+    persist?: boolean;
+}
 export interface ModelCycleResult {
     model: Model<any>;
     thinkingLevel: ThinkingLevel;
@@ -265,6 +270,7 @@ export declare class AgentSession {
     /** Emit an event to all listeners */
     private _emit;
     private _emitQueueUpdate;
+    private _emitSessionCompactFailed;
     private _getIdleWaitPromise;
     private _resolveIdleWaitIfIdle;
     private _emitAgentSettled;
@@ -478,14 +484,14 @@ export declare class AgentSession {
      * Validates that auth is configured, saves to session and settings.
      * @throws Error if no auth is configured for the model
      */
-    setModel(model: Model<any>): Promise<void>;
+    setModel(model: Model<any>, options?: ModelMutationOptions): Promise<void>;
     /**
      * Cycle to next/previous model.
      * Uses scoped models (from --models flag) if available, otherwise all available models.
      * @param direction - "forward" (default) or "backward"
      * @returns The new model info, or undefined if only one model available
      */
-    cycleModel(direction?: "forward" | "backward"): Promise<ModelCycleResult | undefined>;
+    cycleModel(direction?: "forward" | "backward", options?: ModelMutationOptions): Promise<ModelCycleResult | undefined>;
     private _cycleScopedModel;
     private _cycleAvailableModel;
     /**
@@ -493,12 +499,12 @@ export declare class AgentSession {
      * Clamps to model capabilities based on available thinking levels.
      * Saves to session and settings only if the level actually changes.
      */
-    setThinkingLevel(level: ThinkingLevel): void;
+    setThinkingLevel(level: ThinkingLevel, options?: ModelMutationOptions): void;
     /**
      * Cycle to next thinking level.
      * @returns New level, or undefined if model doesn't support thinking
      */
-    cycleThinkingLevel(): ThinkingLevel | undefined;
+    cycleThinkingLevel(options?: ModelMutationOptions): ThinkingLevel | undefined;
     /**
      * Get available thinking levels for current model.
      * The provider will clamp to what the specific model supports internally.

package/dist/core/agent-session.js

@@ -24,7 +24,7 @@ import { normalizeAssistantThinkingTags } from "../utils/thinking-tags.js";
 import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateTokens, generateBranchSummary, prepareCompaction, shouldCompact, } from "./compaction/index.js";
-import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
+import { DEFAULT_THINKING_LEVEL, THINKING_LEVEL_OPTIONS } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
@@ -35,7 +35,7 @@ import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-man
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { createLocalBashOperations } from "./tools/bash.js";
-import { createAllToolDefinitions, stripToolParameterDescriptions } from "./tools/index.js";
+import { createAllToolDefinitions } from "./tools/index.js";
 import { createToolDefinitionFromAgentTool } from "./tools/tool-definition-wrapper.js";
 import { addUsageToTotals, createUsageTotals } from "./usage-totals.js";
 import { captionImageWithModel } from "./vision-caption.js";
@@ -82,8 +82,6 @@ function estimateMessagesTokens(messages) {
 // ============================================================================
 // Constants
 // ============================================================================
-/** Standard thinking levels */
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -307,6 +305,11 @@ export class AgentSession {
             followUp: [...this._followUpMessages],
         });
     }
+    async _emitSessionCompactFailed(event) {
+        if (this._extensionRunner.hasHandlers("session_compact_failed")) {
+            await this._extensionRunner.emit({ type: "session_compact_failed", ...event });
+        }
+    }
     _getIdleWaitPromise() {
         if (!this._idleWaitPromise) {
             this._idleWaitPromise = new Promise((resolve) => {
@@ -1435,16 +1438,17 @@ export class AgentSession {
      * Validates that auth is configured, saves to session and settings.
      * @throws Error if no auth is configured for the model
      */
-    async setModel(model) {
+    async setModel(model, options = {}) {
         if (!(await this._modelRuntime.checkAuth(model.provider))) {
             throw new Error(`No API key for ${model.provider}/${model.id}`);
         }
         const previousModel = this.model;
-        const thinkingLevel = this._getThinkingLevelForModelSwitch();
+        const thinkingLevel = this._getThinkingLevelForModelSwitch(model);
         this.agent.state.model = model;
         this.sessionManager.appendModelChange(model.provider, model.id);
-        this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
-        // Re-clamp thinking level for new model's capabilities
+        if (options.persist) {
+            this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+        }
         this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(model, previousModel, "set");
     }
@@ -1454,13 +1458,13 @@ export class AgentSession {
      * @param direction - "forward" (default) or "backward"
      * @returns The new model info, or undefined if only one model available
      */
-    async cycleModel(direction = "forward") {
+    async cycleModel(direction = "forward", options = {}) {
         if (this._scopedModels.length > 0) {
-            return this._cycleScopedModel(direction);
+            return this._cycleScopedModel(direction, options);
         }
-        return this._cycleAvailableModel(direction);
+        return this._cycleAvailableModel(direction, options);
     }
-    async _cycleScopedModel(direction) {
+    async _cycleScopedModel(direction, options) {
         const checks = await Promise.all(this._scopedModels.map(async (scoped) => ({
             scoped,
             auth: await this._modelRuntime.checkAuth(scoped.model.provider),
@@ -1475,11 +1479,13 @@ export class AgentSession {
         const len = scopedModels.length;
         const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
         const next = scopedModels[nextIndex];
-        const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
+        const thinkingLevel = this._getThinkingLevelForModelSwitch(next.model, next.thinkingLevel);
         // Apply model
         this.agent.state.model = next.model;
         this.sessionManager.appendModelChange(next.model.provider, next.model.id);
-        this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+        if (options.persist) {
+            this.settingsManager.setDefaultModelAndProvider(next.model.provider, next.model.id);
+        }
         // Apply thinking level.
         // - Explicit scoped model thinking level overrides current session level
         // - Undefined scoped model thinking level inherits the current session preference
@@ -1488,7 +1494,7 @@ export class AgentSession {
         await this._emitModelSelect(next.model, currentModel, "cycle");
         return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
     }
-    async _cycleAvailableModel(direction) {
+    async _cycleAvailableModel(direction, options) {
         const availableModels = await this._modelRuntime.getAvailable();
         if (availableModels.length <= 1)
             return undefined;
@@ -1499,10 +1505,12 @@ export class AgentSession {
         const len = availableModels.length;
         const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
         const nextModel = availableModels[nextIndex];
-        const thinkingLevel = this._getThinkingLevelForModelSwitch();
+        const thinkingLevel = this._getThinkingLevelForModelSwitch(nextModel);
         this.agent.state.model = nextModel;
         this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
-        this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
+        if (options.persist) {
+            this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
+        }
         // Re-clamp thinking level for new model's capabilities
         this.setThinkingLevel(thinkingLevel);
         await this._emitModelSelect(nextModel, currentModel, "cycle");
@@ -1516,18 +1524,18 @@ export class AgentSession {
      * Clamps to model capabilities based on available thinking levels.
      * Saves to session and settings only if the level actually changes.
      */
-    setThinkingLevel(level) {
+    setThinkingLevel(level, options = {}) {
         const availableLevels = this.getAvailableThinkingLevels();
         const effectiveLevel = availableLevels.includes(level) ? level : this._clampThinkingLevel(level, availableLevels);
         // Only persist if actually changing
         const previousLevel = this.agent.state.thinkingLevel;
         const isChanging = effectiveLevel !== previousLevel;
         this.agent.state.thinkingLevel = effectiveLevel;
+        if (options.persist) {
+            this.settingsManager.setDefaultThinkingLevel(level);
+        }
         if (isChanging) {
             this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-            if (this.supportsThinking() || effectiveLevel !== "off") {
-                this.settingsManager.setDefaultThinkingLevel(effectiveLevel);
-            }
             this._emit({ type: "thinking_level_changed", level: effectiveLevel });
             void this._extensionRunner.emit({
                 type: "thinking_level_select",
@@ -1540,14 +1548,14 @@ export class AgentSession {
      * Cycle to next thinking level.
      * @returns New level, or undefined if model doesn't support thinking
      */
-    cycleThinkingLevel() {
+    cycleThinkingLevel(options = {}) {
         if (!this.supportsThinking())
             return undefined;
         const levels = this.getAvailableThinkingLevels();
         const currentIndex = levels.indexOf(this.thinkingLevel);
         const nextIndex = (currentIndex + 1) % levels.length;
         const nextLevel = levels[nextIndex];
-        this.setThinkingLevel(nextLevel);
+        this.setThinkingLevel(nextLevel, options);
         return nextLevel;
     }
     /**
@@ -1556,7 +1564,7 @@ export class AgentSession {
      */
     getAvailableThinkingLevels() {
         if (!this.model)
-            return THINKING_LEVELS;
+            return [...THINKING_LEVEL_OPTIONS];
         return getSupportedThinkingLevels(this.model);
     }
     /**
@@ -1565,14 +1573,16 @@ export class AgentSession {
     supportsThinking() {
         return !!this.model?.reasoning;
     }
-    _getThinkingLevelForModelSwitch(explicitLevel) {
+    _getThinkingLevelForModelSwitch(targetModel, explicitLevel) {
         if (explicitLevel !== undefined) {
             return explicitLevel;
         }
-        if (!this.supportsThinking()) {
-            return this.settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+        if (targetModel) {
+            const perModel = this.settingsManager.getModelThinkingLevel(targetModel.provider, targetModel.id);
+            if (perModel !== undefined)
+                return perModel;
         }
-        return this.thinkingLevel;
+        return this.settingsManager.getDefaultThinkingLevel() ?? this.thinkingLevel ?? DEFAULT_THINKING_LEVEL;
     }
     _clampThinkingLevel(level, _availableLevels) {
         return this.model ? clampThinkingLevel(this.model, level) : "off";
@@ -1710,13 +1720,21 @@ export class AgentSession {
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             const aborted = message === "Compaction cancelled" || (error instanceof Error && error.name === "AbortError");
+            const errorMessage = aborted ? undefined : `Compaction failed: ${message}`;
             this._emit({
                 type: "compaction_end",
                 reason: "manual",
                 result: undefined,
                 aborted,
                 willRetry: false,
-                errorMessage: aborted ? undefined : `Compaction failed: ${message}`,
+                errorMessage,
+            });
+            await this._emitSessionCompactFailed({
+                reason: "manual",
+                errorMessage,
+                aborted,
+                willRetry: false,
+                fromExtension: false,
             });
             throw error;
         }
@@ -1835,6 +1853,7 @@ export class AgentSession {
     async _runAutoCompaction(reason, willRetry) {
         const settings = this.settingsManager.getCompactionSettings();
         let started = false;
+        let fromExtension = false;
         try {
             if (!this.model) {
                 return false;
@@ -1857,7 +1876,6 @@ export class AgentSession {
             this._autoCompactionAbortController = new AbortController();
             started = true;
             let extensionCompaction;
-            let fromExtension = false;
             if (this._extensionRunner.hasHandlers("session_before_compact")) {
                 const extensionResult = (await this._extensionRunner.emit({
                     type: "session_before_compact",
@@ -1876,6 +1894,7 @@ export class AgentSession {
                         aborted: true,
                         willRetry: false,
                     });
+                    await this._emitSessionCompactFailed({ reason, aborted: true, willRetry: false, fromExtension: false });
                     return false;
                 }
                 if (extensionResult?.compaction) {
@@ -1913,6 +1932,7 @@ export class AgentSession {
                     aborted: true,
                     willRetry: false,
                 });
+                await this._emitSessionCompactFailed({ reason, aborted: true, willRetry: false, fromExtension });
                 return false;
             }
             this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension, usage);
@@ -1955,15 +1975,23 @@ export class AgentSession {
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
             if (started) {
+                const formattedErrorMessage = reason === "overflow"
+                    ? `Context overflow recovery failed: ${errorMessage}`
+                    : `Auto-compaction failed: ${errorMessage}`;
                 this._emit({
                     type: "compaction_end",
                     reason,
                     result: undefined,
                     aborted: false,
                     willRetry: false,
-                    errorMessage: reason === "overflow"
-                        ? `Context overflow recovery failed: ${errorMessage}`
-                        : `Auto-compaction failed: ${errorMessage}`,
+                    errorMessage: formattedErrorMessage,
+                });
+                await this._emitSessionCompactFailed({
+                    reason,
+                    errorMessage: formattedErrorMessage,
+                    aborted: false,
+                    willRetry: false,
+                    fromExtension,
                 });
             }
             return false;
@@ -2242,18 +2270,6 @@ export class AgentSession {
             toolRegistry.set(tool.name, tool);
         }
         this._toolRegistry = toolRegistry;
-        if (this.settingsManager.getPruneToolDescriptions()) {
-            const keepDescriptions = new Set();
-            for (const [name, entry] of definitionRegistry) {
-                if (entry.definition.keepParameterDescriptions)
-                    keepDescriptions.add(name);
-            }
-            for (const [name, tool] of toolRegistry) {
-                if (!keepDescriptions.has(name)) {
-                    toolRegistry.set(name, stripToolParameterDescriptions(tool));
-                }
-            }
-        }
         const nextActiveToolNames = (options?.activeToolNames ? [...options.activeToolNames] : [...previousActiveToolNames]).filter((name) => isAllowedTool(name));
         if (allowedToolNames) {
             for (const toolName of this._toolRegistry.keys()) {
@@ -2322,7 +2338,6 @@ export class AgentSession {
         this._buildRuntime({
             activeToolNames: this.getActiveToolNames(),
             flagValues: previousFlagValues,
-            includeAllExtensionTools: true,
         });
         const hasBindings = this._extensionUIContext ||
             this._extensionCommandContextActions ||

package/dist/core/compaction/branch-summarization.js

@@ -146,37 +146,37 @@ export function prepareBranchEntries(entries, tokenBudget = 0) {
 // ============================================================================
 // Summary Generation
 // ============================================================================
-const BRANCH_SUMMARY_PREAMBLE = `The user explored a different conversation branch before returning here.
-Summary of that exploration:
-
+const BRANCH_SUMMARY_PREAMBLE = `The user explored a different conversation branch before returning here.
+Summary of that exploration:
+
 `;
-const BRANCH_SUMMARY_PROMPT = `Create a structured summary of this conversation branch for context when returning later.
-
-Use this EXACT format:
-
-## Goal
-[What was the user trying to accomplish in this branch?]
-
-## Constraints & Preferences
-- [Any constraints, preferences, or requirements mentioned]
-- [Or "(none)" if none were mentioned]
-
-## Progress
-### Done
-- [x] [Completed tasks/changes]
-
-### In Progress
-- [ ] [Work that was started but not finished]
-
-### Blocked
-- [Issues preventing progress, if any]
-
-## Key Decisions
-- **[Decision]**: [Brief rationale]
-
-## Next Steps
-1. [What should happen next to continue this work]
-
+const BRANCH_SUMMARY_PROMPT = `Create a structured summary of this conversation branch for context when returning later.
+
+Use this EXACT format:
+
+## Goal
+[What was the user trying to accomplish in this branch?]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Work that was started but not finished]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [What should happen next to continue this work]
+
 Keep each section concise. Preserve exact file paths, function names, and error messages.`;
 /**
  * Generate a summary of abandoned branch entries.