bashkit 0.5.0 → 0.5.2

package/dist/index.js

@@ -613,14 +613,15 @@ var DEFAULT_CONFIG = {
 };
 
 // src/utils/budget-tracking.ts
-var openRouterCache = null;
+var openRouterPricingCache = null;
+var openRouterModelsCache = null;
 var openRouterCacheTimestamp = 0;
 var openRouterFetchPromise = null;
 var OPENROUTER_FETCH_TIMEOUT_MS = 1e4;
 var OPENROUTER_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-async function fetchOpenRouterPricing(apiKey) {
-  if (openRouterCache && Date.now() - openRouterCacheTimestamp < OPENROUTER_CACHE_TTL_MS) {
-    return openRouterCache;
+async function fetchOpenRouterData(apiKey) {
+  if (openRouterModelsCache && Date.now() - openRouterCacheTimestamp < OPENROUTER_CACHE_TTL_MS) {
+    return openRouterModelsCache;
   }
   if (openRouterFetchPromise)
     return openRouterFetchPromise;
@@ -653,7 +654,9 @@ async function fetchOpenRouterPricing(apiKey) {
         throw new Error(`[bashkit] OpenRouter pricing response missing data array. ` + `The API may have changed. Please provide modelPricing overrides in your config.`);
       }
       const MAX_MODELS = 1e4;
-      const map = new Map;
+      const MAX_CONTEXT_LENGTH = 1e7;
+      const modelsMap = new Map;
+      const pricingMap = new Map;
       for (const model of models.slice(0, MAX_MODELS)) {
         if (!model.id || !model.pricing)
           continue;
@@ -673,11 +676,19 @@ async function fetchOpenRouterPricing(apiKey) {
         const cacheWrite = parseFloat(model.pricing.input_cache_write ?? "");
         if (Number.isFinite(cacheWrite) && cacheWrite >= 0)
           pricing.cacheWritePerToken = cacheWrite;
-        map.set(model.id.toLowerCase(), pricing);
+        const key = model.id.toLowerCase();
+        pricingMap.set(key, pricing);
+        const contextLength = model.context_length;
+        if (typeof contextLength === "number" && Number.isFinite(contextLength) && contextLength > 0 && contextLength <= MAX_CONTEXT_LENGTH) {
+          modelsMap.set(key, { pricing, contextLength });
+        } else {
+          modelsMap.set(key, { pricing, contextLength: 0 });
+        }
       }
-      openRouterCache = map;
+      openRouterModelsCache = modelsMap;
+      openRouterPricingCache = pricingMap;
       openRouterCacheTimestamp = Date.now();
-      return openRouterCache;
+      return openRouterModelsCache;
     } finally {
       clearTimeout(timeoutId);
       openRouterFetchPromise = null;
@@ -685,6 +696,9 @@ async function fetchOpenRouterPricing(apiKey) {
   })();
   return openRouterFetchPromise;
 }
+async function fetchOpenRouterModels(apiKey) {
+  return fetchOpenRouterData(apiKey);
+}
 function getModelMatchVariants(model) {
   const lower = model.toLowerCase();
   const kebab = lower.replace(/[^a-z0-9]+/g, "-");
@@ -700,54 +714,65 @@ function getModelMatchVariants(model) {
   }
   return variants;
 }
-function searchModelInCosts(model, costsMap) {
-  if (costsMap.size === 0)
+function searchModelInMap(model, map, filter) {
+  if (map.size === 0)
     return;
   const modelVariants = getModelMatchVariants(model);
-  const costVariantsCache = new Map;
-  function getCostVariants(key) {
-    let variants = costVariantsCache.get(key);
+  const entryVariantsCache = new Map;
+  function getEntryVariants(key) {
+    let variants = entryVariantsCache.get(key);
     if (!variants) {
       variants = getModelMatchVariants(key);
-      costVariantsCache.set(key, variants);
+      entryVariantsCache.set(key, variants);
     }
     return variants;
   }
   for (const variant of modelVariants) {
-    const pricing = costsMap.get(variant);
-    if (pricing)
-      return pricing;
+    const value = map.get(variant);
+    if (value !== undefined && (!filter || filter(value)))
+      return value;
   }
   let bestMatch;
   let bestMatchLength = 0;
-  for (const [costKey, pricing] of costsMap) {
-    const costVariants = getCostVariants(costKey);
+  for (const [entryKey, value] of map) {
+    if (filter && !filter(value))
+      continue;
+    const entryVariants = getEntryVariants(entryKey);
     for (const modelVariant of modelVariants) {
-      for (const costVariant of costVariants) {
-        if (modelVariant.includes(costVariant) && costVariant.length > bestMatchLength) {
-          bestMatch = pricing;
-          bestMatchLength = costVariant.length;
+      for (const entryVariant of entryVariants) {
+        if (modelVariant.includes(entryVariant) && entryVariant.length > bestMatchLength) {
+          bestMatch = value;
+          bestMatchLength = entryVariant.length;
         }
       }
     }
   }
-  if (bestMatch)
+  if (bestMatch !== undefined)
     return bestMatch;
   let reverseMatch;
   let reverseMatchLength = Infinity;
-  for (const [costKey, pricing] of costsMap) {
-    const costVariants = getCostVariants(costKey);
+  for (const [entryKey, value] of map) {
+    if (filter && !filter(value))
+      continue;
+    const entryVariants = getEntryVariants(entryKey);
     for (const modelVariant of modelVariants) {
-      for (const costVariant of costVariants) {
-        if (costVariant.includes(modelVariant) && costVariant.length < reverseMatchLength) {
-          reverseMatch = pricing;
-          reverseMatchLength = costVariant.length;
+      for (const entryVariant of entryVariants) {
+        if (entryVariant.includes(modelVariant) && entryVariant.length < reverseMatchLength) {
+          reverseMatch = value;
+          reverseMatchLength = entryVariant.length;
         }
       }
     }
   }
   return reverseMatch;
 }
+function searchModelInCosts(model, costsMap) {
+  return searchModelInMap(model, costsMap);
+}
+function getModelContextLength(model, modelsMap) {
+  const info = searchModelInMap(model, modelsMap, (v) => v.contextLength > 0);
+  return info?.contextLength;
+}
 function findPricingForModel(model, options) {
   if (options?.overrides) {
     const overrideMap = options.overrides instanceof Map ? options.overrides : new Map(Object.entries(options.overrides).map(([k, v]) => [
@@ -853,13 +878,14 @@ import { tool, zodSchema } from "ai";
 import { z } from "zod";
 
 // src/utils/debug.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { appendFileSync } from "node:fs";
 var state = {
   mode: "off",
   logs: [],
-  counters: new Map,
-  parentStack: []
+  counters: new Map
 };
+var debugContext = new AsyncLocalStorage;
 var MAX_STRING_LENGTH = 1000;
 var MAX_ARRAY_ITEMS = 10;
 function initDebugMode() {
@@ -947,7 +973,8 @@ function emitEvent(event) {
   }
 }
 function formatHumanReadable(event) {
-  const indent = "  ".repeat(state.parentStack.length);
+  const ctx = debugContext.getStore();
+  const indent = "  ".repeat(ctx?.depth ?? 0);
   if (event.event === "start") {
     const inputSummary = event.input ? Object.entries(event.input).map(([k, v]) => `${k}=${JSON.stringify(v)}`).slice(0, 3).join(" ") : "";
     process.stderr.write(`${indent}[bashkit:${event.tool}] → ${inputSummary}
@@ -965,7 +992,8 @@ function debugStart(tool, input) {
   if (state.mode === "off")
     return "";
   const id = generateId(tool);
-  const parent = state.parentStack.length > 0 ? state.parentStack[state.parentStack.length - 1] : undefined;
+  const ctx = debugContext.getStore();
+  const parent = ctx?.parentId;
   const event = {
     id,
     ts: Date.now(),
@@ -1003,15 +1031,12 @@ function debugError(id, tool, error) {
   };
   emitEvent(event);
 }
-function pushParent(id) {
-  if (state.mode === "off" || !id)
-    return;
-  state.parentStack.push(id);
-}
-function popParent() {
-  if (state.mode === "off")
-    return;
-  state.parentStack.pop();
+function runWithDebugParent(parentId, fn) {
+  if (state.mode === "off" || !parentId)
+    return fn();
+  const current = debugContext.getStore();
+  const depth = current ? current.depth + 1 : 1;
+  return debugContext.run({ parentId, depth }, fn);
 }
 function getDebugLogs() {
   return [...state.logs];
@@ -1019,12 +1044,10 @@ function getDebugLogs() {
 function clearDebugLogs() {
   state.logs = [];
   state.counters.clear();
-  state.parentStack = [];
 }
 function reinitDebugMode() {
   state.logs = [];
   state.counters.clear();
-  state.parentStack = [];
   initDebugMode();
 }
 
@@ -1164,6 +1187,37 @@ function createAskUserTool(config) {
 // src/tools/bash.ts
 import { tool as tool2, zodSchema as zodSchema2 } from "ai";
 import { z as z2 } from "zod";
+
+// src/utils/helpers.ts
+function isToolCallPart(part) {
+  return typeof part === "object" && part !== null && part.type === "tool-call" && "toolName" in part && "input" in part;
+}
+function isToolResultPart(part) {
+  return typeof part === "object" && part !== null && part.type === "tool-result" && "toolName" in part && "output" in part;
+}
+function middleTruncate(text, maxLength) {
+  if (!Number.isFinite(maxLength) || maxLength < 0)
+    return text;
+  if (text.length <= maxLength)
+    return text;
+  const headLength = Math.floor(maxLength / 2);
+  const tailLength = maxLength - headLength;
+  const omitted = text.length - headLength - tailLength;
+  let totalLines = 1;
+  for (let i = 0;i < text.length; i++) {
+    if (text.charCodeAt(i) === 10)
+      totalLines++;
+  }
+  return `[Total output lines: ${totalLines}]
+
+` + text.slice(0, headLength) + `
+
+…${omitted} chars truncated…
+
+` + text.slice(text.length - tailLength);
+}
+
+// src/tools/bash.ts
 var bashInputSchema = z2.object({
   command: z2.string().describe("The command to execute"),
   timeout: z2.number().nullable().default(null).describe("Optional timeout in milliseconds (max 600000)"),
@@ -1239,16 +1293,8 @@ function createBashTool(sandbox, config) {
         const result = await sandbox.exec(command, {
           timeout: effectiveTimeout
         });
-        let stdout = result.stdout;
-        let stderr = result.stderr;
-        if (stdout.length > maxOutputLength) {
-          stdout = stdout.slice(0, maxOutputLength) + `
-[output truncated, ${stdout.length - maxOutputLength} chars omitted]`;
-        }
-        if (stderr.length > maxOutputLength) {
-          stderr = stderr.slice(0, maxOutputLength) + `
-[output truncated, ${stderr.length - maxOutputLength} chars omitted]`;
-        }
+        const stdout = middleTruncate(result.stdout, maxOutputLength);
+        const stderr = middleTruncate(result.stderr, maxOutputLength);
         const durationMs = Math.round(performance.now() - startTime);
         if (debugId) {
           debugEnd(debugId, "bash", {
@@ -2598,53 +2644,98 @@ function createTaskTool(config) {
           ...Object.keys(typeConfig.additionalTools ?? {})
         ]
       }) : "";
-      if (debugId)
-        pushParent(debugId);
-      try {
-        const model = typeConfig.model || defaultModel;
-        const tools = filterTools(allTools, customTools ?? typeConfig.tools, typeConfig.additionalTools);
-        const systemPrompt = system_prompt ?? typeConfig.systemPrompt;
-        const baseStopWhen = typeConfig.stopWhen ?? defaultStopWhen ?? stepCountIs(15);
-        const effectiveStopWhen = budget ? [baseStopWhen, budget.stopWhen].flat() : baseStopWhen;
-        const commonOptions = {
-          model,
-          tools,
-          system: systemPrompt,
-          prompt,
-          stopWhen: effectiveStopWhen,
-          prepareStep: typeConfig.prepareStep
-        };
-        if (streamWriter) {
-          const startId = generateEventId();
-          streamWriter.write({
-            type: "data-subagent",
-            id: startId,
-            data: {
-              event: "start",
+      const executeTask = async () => {
+        try {
+          const model = typeConfig.model || defaultModel;
+          const tools = filterTools(allTools, customTools ?? typeConfig.tools, typeConfig.additionalTools);
+          const systemPrompt = system_prompt ?? typeConfig.systemPrompt;
+          const baseStopWhen = typeConfig.stopWhen ?? defaultStopWhen ?? stepCountIs(15);
+          const effectiveStopWhen = budget ? [baseStopWhen, budget.stopWhen].flat() : baseStopWhen;
+          const commonOptions = {
+            model,
+            tools,
+            system: systemPrompt,
+            prompt,
+            stopWhen: effectiveStopWhen,
+            prepareStep: typeConfig.prepareStep
+          };
+          if (streamWriter) {
+            const startId = generateEventId();
+            streamWriter.write({
+              type: "data-subagent",
+              id: startId,
+              data: {
+                event: "start",
+                subagent: subagent_type,
+                description
+              }
+            });
+            const result3 = streamText({
+              ...commonOptions,
+              onStepFinish: async (step) => {
+                budget?.onStepFinish(step);
+                if (step.toolCalls?.length) {
+                  for (const tc of step.toolCalls) {
+                    const eventId = generateEventId();
+                    streamWriter.write({
+                      type: "data-subagent",
+                      id: eventId,
+                      data: {
+                        event: "tool-call",
+                        subagent: subagent_type,
+                        description,
+                        toolName: tc.toolName,
+                        args: tc.input
+                      }
+                    });
+                  }
+                }
+                await typeConfig.onStepFinish?.(step);
+                await defaultOnStepFinish?.({
+                  subagentType: subagent_type,
+                  description,
+                  step
+                });
+              }
+            });
+            const text = await result3.text;
+            const usage2 = await result3.usage;
+            const response = await result3.response;
+            streamWriter.write({
+              type: "data-subagent",
+              id: generateEventId(),
+              data: {
+                event: "done",
+                subagent: subagent_type,
+                description
+              }
+            });
+            streamWriter.write({
+              type: "data-subagent",
+              id: generateEventId(),
+              data: {
+                event: "complete",
+                subagent: subagent_type,
+                description,
+                messages: response.messages
+              }
+            });
+            const durationMs2 = Math.round(performance.now() - startTime);
+            return {
+              result: text,
+              usage: usage2.inputTokens !== undefined && usage2.outputTokens !== undefined ? {
+                input_tokens: usage2.inputTokens,
+                output_tokens: usage2.outputTokens
+              } : undefined,
+              duration_ms: durationMs2,
               subagent: subagent_type,
               description
-            }
-          });
-          const result2 = streamText({
+            };
+          }
+          const result2 = await generateText2({
             ...commonOptions,
             onStepFinish: async (step) => {
               budget?.onStepFinish(step);
-              if (step.toolCalls?.length) {
-                for (const tc of step.toolCalls) {
-                  const eventId = generateEventId();
-                  streamWriter.write({
-                    type: "data-subagent",
-                    id: eventId,
-                    data: {
-                      event: "tool-call",
-                      subagent: subagent_type,
-                      description,
-                      toolName: tc.toolName,
-                      args: tc.input
-                    }
-                  });
-                }
-              }
               await typeConfig.onStepFinish?.(step);
               await defaultOnStepFinish?.({
                 subagentType: subagent_type,
@@ -2653,98 +2744,46 @@ function createTaskTool(config) {
               });
             }
           });
-          const text = await result2.text;
-          const usage2 = await result2.usage;
-          const response = await result2.response;
-          streamWriter.write({
-            type: "data-subagent",
-            id: generateEventId(),
-            data: {
-              event: "done",
-              subagent: subagent_type,
-              description
-            }
-          });
-          streamWriter.write({
-            type: "data-subagent",
-            id: generateEventId(),
-            data: {
-              event: "complete",
-              subagent: subagent_type,
-              description,
-              messages: response.messages
-            }
-          });
-          const durationMs2 = Math.round(performance.now() - startTime);
-          if (debugId) {
-            popParent();
-            debugEnd(debugId, "task", {
-              summary: {
-                tokens: {
-                  input: usage2.inputTokens,
-                  output: usage2.outputTokens
-                },
-                steps: response.messages?.length
-              },
-              duration_ms: durationMs2
-            });
-          }
+          const durationMs = Math.round(performance.now() - startTime);
+          const usage = result2.usage.inputTokens !== undefined && result2.usage.outputTokens !== undefined ? {
+            input_tokens: result2.usage.inputTokens,
+            output_tokens: result2.usage.outputTokens
+          } : undefined;
           return {
-            result: text,
-            usage: usage2.inputTokens !== undefined && usage2.outputTokens !== undefined ? {
-              input_tokens: usage2.inputTokens,
-              output_tokens: usage2.outputTokens
-            } : undefined,
-            duration_ms: durationMs2,
+            result: result2.text,
+            usage,
+            duration_ms: durationMs,
             subagent: subagent_type,
             description
           };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          const durationMs = Math.round(performance.now() - startTime);
+          return {
+            error: errorMessage,
+            subagent: subagent_type,
+            description,
+            duration_ms: durationMs
+          };
         }
-        const result = await generateText2({
-          ...commonOptions,
-          onStepFinish: async (step) => {
-            budget?.onStepFinish(step);
-            await typeConfig.onStepFinish?.(step);
-            await defaultOnStepFinish?.({
-              subagentType: subagent_type,
-              description,
-              step
-            });
-          }
-        });
-        const durationMs = Math.round(performance.now() - startTime);
-        const usage = result.usage.inputTokens !== undefined && result.usage.outputTokens !== undefined ? {
-          input_tokens: result.usage.inputTokens,
-          output_tokens: result.usage.outputTokens
-        } : undefined;
-        if (debugId) {
-          popParent();
+      };
+      const result = await runWithDebugParent(debugId, executeTask);
+      if (debugId) {
+        if ("error" in result) {
+          debugError(debugId, "task", result.error);
+        } else {
           debugEnd(debugId, "task", {
             summary: {
-              tokens: {
-                input: result.usage.inputTokens,
-                output: result.usage.outputTokens
-              },
-              steps: result.steps?.length
+              tokens: result.usage ? {
+                input: result.usage.input_tokens,
+                output: result.usage.output_tokens
+              } : undefined
             },
-            duration_ms: durationMs
+            duration_ms: result.duration_ms ?? Math.round(performance.now() - startTime)
           });
         }
-        return {
-          result: result.text,
-          usage,
-          duration_ms: durationMs,
-          subagent: subagent_type,
-          description
-        };
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        if (debugId) {
-          popParent();
-          debugError(debugId, "task", errorMessage);
-        }
-        return { error: errorMessage };
       }
+      return result;
     }
   });
 }
@@ -2939,31 +2978,39 @@ async function createAgentTools(sandbox, config) {
       }
     }
   }
+  let openRouterModels;
+  const shouldFetchOpenRouter = config?.modelRegistry?.provider === "openRouter" || config?.budget?.pricingProvider === "openRouter";
+  if (shouldFetchOpenRouter) {
+    const apiKey = config?.modelRegistry?.apiKey ?? config?.budget?.apiKey;
+    try {
+      openRouterModels = await fetchOpenRouterModels(apiKey);
+    } catch (err) {
+      if (config?.budget && !config.budget.modelPricing) {
+        throw new Error(`[bashkit] Failed to fetch OpenRouter pricing and no modelPricing overrides provided. ` + `Either provide modelPricing in your budget config or ensure network access to OpenRouter. ` + `Original error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  let openRouterPricing;
+  if (openRouterModels) {
+    openRouterPricing = new Map([...openRouterModels].map(([k, v]) => [k, v.pricing]));
+  }
   let budget;
   if (config?.budget) {
-    const { pricingProvider, apiKey, modelPricing, maxUsd } = config.budget;
-    if (!pricingProvider && !modelPricing) {
-      throw new Error("[bashkit] Budget requires either pricingProvider or modelPricing (or both).");
-    }
-    let openRouterPricing;
-    if (pricingProvider === "openRouter") {
-      try {
-        openRouterPricing = await fetchOpenRouterPricing(apiKey);
-      } catch (err) {
-        if (!modelPricing) {
-          throw new Error(`[bashkit] Failed to fetch OpenRouter pricing and no modelPricing overrides provided. ` + `Either provide modelPricing in your budget config or ensure network access to OpenRouter. ` + `Original error: ${err instanceof Error ? err.message : String(err)}`);
-        }
-      }
+    const { modelPricing, maxUsd } = config.budget;
+    if (!openRouterPricing && !modelPricing) {
+      throw new Error("[bashkit] Budget requires either modelRegistry, pricingProvider, or modelPricing.");
     }
     budget = createBudgetTracker(maxUsd, {
       modelPricing,
       openRouterPricing
     });
   }
-  return { tools, planModeState, budget };
+  return { tools, planModeState, budget, openRouterModels };
 }
 // src/utils/compact-conversation.ts
-import { generateText as generateText3 } from "ai";
+import {
+  generateText as generateText3
+} from "ai";
 
 // src/utils/prune-messages.ts
 var DEFAULT_CONFIG2 = {
@@ -2984,10 +3031,10 @@ function estimateMessageTokens(message) {
         tokens += estimateTokens(part);
       } else if ("text" in part && typeof part.text === "string") {
         tokens += estimateTokens(part.text);
-      } else if ("result" in part) {
-        tokens += estimateTokens(JSON.stringify(part.result));
-      } else if ("args" in part) {
-        tokens += estimateTokens(JSON.stringify(part.args));
+      } else if (isToolResultPart(part)) {
+        tokens += estimateTokens(JSON.stringify(part.output));
+      } else if (isToolCallPart(part)) {
+        tokens += estimateTokens(JSON.stringify(part.input));
       } else {
         tokens += estimateTokens(JSON.stringify(part));
       }
@@ -3029,10 +3076,10 @@ function pruneMessageContent(message) {
     return message;
   }
   const prunedContent = message.content.map((part) => {
-    if (typeof part === "object" && "toolName" in part && "args" in part) {
+    if (isToolCallPart(part)) {
       return {
         ...part,
-        args: { _pruned: true, toolName: part.toolName }
+        input: { _pruned: true, toolName: part.toolName }
       };
     }
     return part;
@@ -3047,10 +3094,10 @@ function pruneToolMessage(message) {
     return message;
   }
   const prunedContent = message.content.map((part) => {
-    if (typeof part === "object" && "result" in part) {
+    if (isToolResultPart(part)) {
       return {
         ...part,
-        result: { _pruned: true }
+        output: { type: "text", value: "pruned" }
       };
     }
     return part;
@@ -3099,7 +3146,53 @@ function pruneMessagesByTokens(messages, config) {
   return prunedMessages;
 }
 
+// src/utils/context-status.ts
+var DEFAULT_CONFIG3 = {
+  elevatedThreshold: 0.5,
+  highThreshold: 0.7,
+  criticalThreshold: 0.85
+};
+function defaultHighGuidance(metrics) {
+  const used = Math.round(metrics.usagePercent * 100);
+  const remaining = Math.round((1 - metrics.usagePercent) * 100);
+  return `Context usage: ${used}%. You still have ${remaining}% remaining—no need to rush. Continue working thoroughly.`;
+}
+function defaultCriticalGuidance(metrics) {
+  const used = Math.round(metrics.usagePercent * 100);
+  return `Context usage: ${used}%. Consider wrapping up the current task or summarizing progress before continuing.`;
+}
+function getContextStatus(messages, maxTokens, config) {
+  const { elevatedThreshold, highThreshold, criticalThreshold } = {
+    ...DEFAULT_CONFIG3,
+    ...config
+  };
+  const usedTokens = config?.knownTokenCount ?? estimateMessagesTokens(messages);
+  const usagePercent = usedTokens / maxTokens;
+  const baseStatus = { usedTokens, maxTokens, usagePercent };
+  if (usagePercent < elevatedThreshold) {
+    return { ...baseStatus, status: "comfortable" };
+  }
+  if (usagePercent < highThreshold) {
+    return { ...baseStatus, status: "elevated" };
+  }
+  if (usagePercent < criticalThreshold) {
+    const guidance2 = typeof config?.highGuidance === "function" ? config.highGuidance(baseStatus) : config?.highGuidance ?? defaultHighGuidance(baseStatus);
+    return { ...baseStatus, status: "high", guidance: guidance2 };
+  }
+  const guidance = typeof config?.criticalGuidance === "function" ? config.criticalGuidance(baseStatus) : config?.criticalGuidance ?? defaultCriticalGuidance(baseStatus);
+  return { ...baseStatus, status: "critical", guidance };
+}
+function contextNeedsAttention(status) {
+  return status.status === "high" || status.status === "critical";
+}
+function contextNeedsCompaction(status) {
+  return status.status === "critical";
+}
+
 // src/utils/compact-conversation.ts
+class CompactionError extends Error {
+  name = "CompactionError";
+}
 async function compactConversation(messages, config, state2 = { conversationSummary: "" }) {
   const currentTokens = estimateMessagesTokens(messages);
   const threshold = config.compactionThreshold ?? 0.85;
@@ -3108,12 +3201,14 @@ async function compactConversation(messages, config, state2 = { conversationSumm
     return { messages, state: state2, didCompact: false };
   }
   const protectCount = config.protectRecentMessages ?? 10;
-  const recentMessages = messages.slice(-protectCount);
-  const oldMessages = messages.slice(0, -protectCount);
+  const splitAt = findSafeSplitIndex(messages, protectCount);
+  const oldMessages = messages.slice(0, splitAt);
+  const recentMessages = messages.slice(splitAt);
   if (oldMessages.length === 0) {
     return { messages, state: state2, didCompact: false };
   }
-  const newSummary = await summarizeMessages(oldMessages, config.summarizerModel, config.taskContext, state2.conversationSummary);
+  const fileOps = extractFileOps(oldMessages);
+  const newSummary = await summarizeMessages(oldMessages, config.summarizerModel, config.taskContext, state2.conversationSummary, fileOps, config.summaryInstructions);
   const compactedMessages = [
     {
       role: "user",
@@ -3151,6 +3246,8 @@ Create a structured summary of the conversation below. This summary will replace
 {{PREVIOUS_SUMMARY}}
 </previous-summary>
 
+{{FILE_OPERATIONS}}
+
 <conversation-to-summarize>
 {{CONVERSATION}}
 </conversation-to-summarize>
@@ -3197,9 +3294,44 @@ Brief description of what the user asked for and the current goal.
 - Maintain the user's original terminology and naming.
 - Do not editorialize or add suggestions - just capture what happened.
 - Omit sections that have no relevant information.
-</instructions>`;
-async function summarizeMessages(messages, model, taskContext, previousSummary) {
-  const prompt = SUMMARIZATION_PROMPT.replace("{{TASK_CONTEXT}}", taskContext || "Not specified").replace("{{PREVIOUS_SUMMARY}}", previousSummary || "None - this is the first compaction").replace("{{CONVERSATION}}", formatMessagesForSummary(messages));
+{{SUMMARY_INSTRUCTIONS}}</instructions>`;
+async function summarizeMessages(messages, model, taskContext, previousSummary, fileOps, summaryInstructions) {
+  let fileOpsBlock = "";
+  if (fileOps) {
+    const MAX_FILES = 50;
+    const sanitize = (p) => p.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    const readFiles = [...fileOps.read].sort().map(sanitize);
+    const modifiedFiles = [...fileOps.modified].sort().map(sanitize);
+    const sections = [];
+    if (readFiles.length > 0) {
+      const listed = readFiles.slice(0, MAX_FILES);
+      sections.push(`Read: ${listed.join(", ")}`);
+      if (readFiles.length > MAX_FILES) {
+        sections.push(`... and ${readFiles.length - MAX_FILES} more read files`);
+      }
+    }
+    if (modifiedFiles.length > 0) {
+      const listed = modifiedFiles.slice(0, MAX_FILES);
+      sections.push(`Modified: ${listed.join(", ")}`);
+      if (modifiedFiles.length > MAX_FILES) {
+        sections.push(`... and ${modifiedFiles.length - MAX_FILES} more modified files`);
+      }
+    }
+    if (sections.length > 0) {
+      fileOpsBlock = `<file-operations>
+${sections.join(`
+`)}
+</file-operations>`;
+    }
+  }
+  const templateVars = {
+    TASK_CONTEXT: taskContext || "Not specified",
+    PREVIOUS_SUMMARY: previousSummary || "None - this is the first compaction",
+    CONVERSATION: formatMessagesForSummary(messages),
+    FILE_OPERATIONS: fileOpsBlock,
+    SUMMARY_INSTRUCTIONS: summaryInstructions ? `- ${summaryInstructions}` : ""
+  };
+  const prompt = SUMMARIZATION_PROMPT.replace(/\{\{(\w+)\}\}/g, (_, key) => templateVars[key] ?? "");
   const result = await generateText3({
     model,
     messages: [
@@ -3211,6 +3343,12 @@ async function summarizeMessages(messages, model, taskContext, previousSummary)
   });
   return result.text;
 }
+var MAX_PART_LENGTH = 500;
+function truncate(str) {
+  if (str.length <= MAX_PART_LENGTH)
+    return str;
+  return `${str.slice(0, MAX_PART_LENGTH)}... [truncated]`;
+}
 function formatMessagesForSummary(messages) {
   return messages.map((msg, index) => {
     const role = msg.role.toUpperCase();
@@ -3227,16 +3365,17 @@ ${msg.content}
         if ("text" in part && typeof part.text === "string") {
           return part.text;
         }
-        if ("toolName" in part && "args" in part) {
+        if (isToolCallPart(part)) {
+          const inputStr = truncate(JSON.stringify(part.input));
           return `[Tool Call: ${part.toolName}]
-Args: ${JSON.stringify(part.args, null, 2)}`;
+Input: ${inputStr}`;
         }
-        if ("result" in part) {
-          const resultStr = typeof part.result === "string" ? part.result : JSON.stringify(part.result, null, 2);
+        if (isToolResultPart(part)) {
+          const outputStr = typeof part.output === "string" ? part.output : JSON.stringify(part.output);
           return `[Tool Result]
-${resultStr}`;
+${truncate(outputStr)}`;
         }
-        return JSON.stringify(part, null, 2);
+        return truncate(JSON.stringify(part));
       }).join(`
 
 `);
@@ -3245,12 +3384,117 @@ ${parts}
 </message>`;
     }
     return `<message index="${index}" role="${role}">
-${JSON.stringify(msg.content, null, 2)}
+${truncate(JSON.stringify(msg.content))}
 </message>`;
   }).join(`
 
 `);
 }
+function hasToolCalls(message) {
+  if (message.role !== "assistant" || !Array.isArray(message.content)) {
+    return false;
+  }
+  return message.content.some(isToolCallPart);
+}
+function findSafeSplitIndex(messages, protectCount) {
+  const naiveSplit = Math.max(0, messages.length - protectCount);
+  let splitAt = naiveSplit;
+  while (splitAt > 0) {
+    const msg = messages[splitAt];
+    if (msg.role === "tool") {
+      splitAt--;
+      continue;
+    }
+    const prev = messages[splitAt - 1];
+    if (prev?.role === "assistant" && hasToolCalls(prev)) {
+      splitAt--;
+      continue;
+    }
+    break;
+  }
+  if (splitAt === 0 && naiveSplit > 0) {
+    splitAt = naiveSplit;
+    while (splitAt < messages.length) {
+      const msg = messages[splitAt];
+      if (msg.role !== "tool") {
+        const prev = messages[splitAt - 1];
+        if (!prev || prev.role !== "assistant" || !hasToolCalls(prev)) {
+          break;
+        }
+      }
+      splitAt++;
+    }
+    if (splitAt >= messages.length) {
+      splitAt = naiveSplit;
+    }
+  }
+  return splitAt;
+}
+function extractFileOps(messages) {
+  const ops = {
+    read: new Set,
+    modified: new Set
+  };
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || !Array.isArray(msg.content))
+      continue;
+    for (const part of msg.content) {
+      if (!isToolCallPart(part))
+        continue;
+      const toolName = String(part.toolName).toLowerCase();
+      const rawInput = part.input;
+      if (typeof rawInput !== "object" || rawInput === null)
+        continue;
+      const input = rawInput;
+      switch (toolName) {
+        case "read": {
+          const filePath = input.file_path;
+          if (typeof filePath === "string")
+            ops.read.add(filePath);
+          break;
+        }
+        case "write":
+        case "edit": {
+          const filePath = input.file_path;
+          if (typeof filePath === "string")
+            ops.modified.add(filePath);
+          break;
+        }
+      }
+    }
+  }
+  return ops;
+}
+function createAutoCompaction(config) {
+  const state2 = { conversationSummary: "" };
+  const threshold = config.compactionThreshold ?? 0.85;
+  const prepareStep = async (args) => {
+    const status = getContextStatus(args.messages, config.maxTokens, {
+      criticalThreshold: threshold
+    });
+    if (status.status !== "critical") {
+      return {};
+    }
+    let lastError;
+    for (let attempt = 0;attempt < 2; attempt++) {
+      try {
+        const result = await compactConversation(args.messages, config, state2);
+        if (result.didCompact) {
+          state2.conversationSummary = result.state.conversationSummary;
+          return { messages: result.messages };
+        }
+        return {};
+      } catch (err) {
+        lastError = err;
+        if (attempt < 1) {
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+      }
+    }
+    throw new CompactionError("Conversation compaction failed after 2 attempts", { cause: lastError });
+  };
+  return { prepareStep, getState: () => ({ ...state2 }) };
+}
 var MODEL_CONTEXT_LIMITS = {
   "claude-opus-4-5": 200000,
   "claude-sonnet-4-5": 200000,
@@ -3270,47 +3514,16 @@ function createCompactConfig(modelId, summarizerModel, overrides) {
     ...overrides
   };
 }
-// src/utils/context-status.ts
-var DEFAULT_CONFIG3 = {
-  elevatedThreshold: 0.5,
-  highThreshold: 0.7,
-  criticalThreshold: 0.85
-};
-function defaultHighGuidance(metrics) {
-  const used = Math.round(metrics.usagePercent * 100);
-  const remaining = Math.round((1 - metrics.usagePercent) * 100);
-  return `Context usage: ${used}%. You still have ${remaining}% remaining—no need to rush. Continue working thoroughly.`;
-}
-function defaultCriticalGuidance(metrics) {
-  const used = Math.round(metrics.usagePercent * 100);
-  return `Context usage: ${used}%. Consider wrapping up the current task or summarizing progress before continuing.`;
-}
-function getContextStatus(messages, maxTokens, config) {
-  const { elevatedThreshold, highThreshold, criticalThreshold } = {
-    ...DEFAULT_CONFIG3,
-    ...config
-  };
-  const usedTokens = estimateMessagesTokens(messages);
-  const usagePercent = usedTokens / maxTokens;
-  const baseStatus = { usedTokens, maxTokens, usagePercent };
-  if (usagePercent < elevatedThreshold) {
-    return { ...baseStatus, status: "comfortable" };
-  }
-  if (usagePercent < highThreshold) {
-    return { ...baseStatus, status: "elevated" };
+function createCompactConfigFromModels(modelId, summarizerModel, modelsMap, overrides) {
+  const contextLength = getModelContextLength(modelId, modelsMap);
+  if (contextLength === undefined) {
+    throw new Error(`[bashkit] No context length found for model "${modelId}" in OpenRouter data. ` + `Provide maxTokens manually via overrides or use createCompactConfig() with a known model.`);
   }
-  if (usagePercent < criticalThreshold) {
-    const guidance2 = typeof config?.highGuidance === "function" ? config.highGuidance(baseStatus) : config?.highGuidance ?? defaultHighGuidance(baseStatus);
-    return { ...baseStatus, status: "high", guidance: guidance2 };
-  }
-  const guidance = typeof config?.criticalGuidance === "function" ? config.criticalGuidance(baseStatus) : config?.criticalGuidance ?? defaultCriticalGuidance(baseStatus);
-  return { ...baseStatus, status: "critical", guidance };
-}
-function contextNeedsAttention(status) {
-  return status.status === "high" || status.status === "critical";
-}
-function contextNeedsCompaction(status) {
-  return status.status === "critical";
+  return {
+    maxTokens: contextLength,
+    summarizerModel,
+    ...overrides
+  };
 }
 // src/skills/discovery.ts
 import { readdir as readdir2, readFile as readFile2, stat } from "node:fs/promises";
@@ -3654,10 +3867,12 @@ export {
   loadSkillBundles,
   loadSkillBundle,
   isDebugEnabled,
+  getModelContextLength,
   getDebugLogs,
   getContextStatus,
   fetchSkills,
   fetchSkill,
+  fetchOpenRouterModels,
   estimateTokens,
   estimateMessagesTokens,
   estimateMessageTokens,
@@ -3679,9 +3894,11 @@ export {
   createEnterPlanModeTool,
   createEditTool,
   createE2BSandbox,
+  createCompactConfigFromModels,
   createCompactConfig,
   createBudgetTracker,
   createBashTool,
+  createAutoCompaction,
   createAskUserTool,
   createAgentTools,
   contextNeedsCompaction,
@@ -3693,5 +3910,6 @@ export {
   anthropicPromptCacheMiddleware,
   MODEL_CONTEXT_LIMITS,
   LRUCacheStore,
-  DEFAULT_CONFIG
+  DEFAULT_CONFIG,
+  CompactionError
 };