@opencode/core 2.1.2 → 2.1.4

package/dist/chunks/{repository-cache-vsa820f9.js → location-4fspmagn.js}

@@ -1,84 +1,83 @@
 import {
   Service86,
   node90
-} from "./repository-cache-qy7ffa5a.js";
+} from "./location-5nankzt7.js";
 import {
   Service85,
   node89
-} from "./repository-cache-z1fx9rk1.js";
+} from "./location-wedh6qfb.js";
 import {
   create3
-} from "./repository-cache-rdw6cm16.js";
+} from "./location-vd3b3yk9.js";
 import {
   ID11,
-  Service76,
-  node80
-} from "./repository-cache-5xte2yyn.js";
+  Service75,
+  node79
+} from "./location-dqc1xg2h.js";
 import {
   llmClient2
-} from "./repository-cache-775gj3j1.js";
+} from "./location-p015t6z3.js";
 import {
-  Service68,
-  node72
-} from "./repository-cache-hnvjv21h.js";
+  Service70,
+  node74
+} from "./location-6b66j3w1.js";
 import {
   estimate2
-} from "./repository-cache-h6vf3j39.js";
+} from "./location-8wtp7s3z.js";
 import {
   SessionEvent2
-} from "./repository-cache-ec1grn59.js";
+} from "./location-ec1grn59.js";
 import {
   kept2,
   messageToText2,
-  truncateToolOutput2,
   serializeToolContent2
-} from "./repository-cache-8mywswrd.js";
+} from "./location-v2r1d0zg.js";
 import {
   isNativeCompaction2,
   load5
-} from "./repository-cache-gm3f9v0x.js";
+} from "./location-5qebhevh.js";
 import {
   toLLMMessages2
-} from "./repository-cache-vzjp43bk.js";
+} from "./location-0928y98p.js";
 import {
   outputLimit2,
   baseTranscript2,
   unsupportedParts2,
   boundImages2,
-  Service30,
-  node33
-} from "./repository-cache-n99h6tw9.js";
+  Service32,
+  node35
+} from "./location-k6wybhe4.js";
 import {
-  Service47,
-  node49
-} from "./repository-cache-vs7zhs8r.js";
+  Service49,
+  node51
+} from "./location-p184mqc5.js";
 import {
   isRetryable2,
   policy2
-} from "./repository-cache-tt8gc4fv.js";
+} from "./location-c8666r4c.js";
 import {
   toSessionError2,
   contentFilterError2
-} from "./repository-cache-be5vje8s.js";
+} from "./location-0hpjzkz5.js";
 import {
   calculateCost2,
   record2,
   add2
-} from "./repository-cache-tdstcens.js";
+} from "./location-tw8zr1ps.js";
 import {
   __export
-} from "./repository-cache-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/session/compaction.ts
 var exports_compaction2 = {};
 __export(exports_compaction2, {
-  Service: () => Service11,
+  Service: () => Service8,
   SessionCompaction: () => exports_compaction2,
   buildPrompt: () => buildPrompt2,
   estimateContext: () => estimateContext2,
   estimatePrompt: () => estimatePrompt2,
   layer: () => layer7,
-  node: () => node13,
+  node: () => node10,
   recentUserMessages: () => recentUserMessages2
 });
 import {
@@ -93,16 +92,28 @@ import {
   UnknownProviderError
 } from "@opencode/ai";
 import { makeLocationNode } from "@opencode/util/effect/app-node";
-import { Context, Effect, Layer, Result, Stream } from "effect";
-class Service11 extends Context.Service()("@opencode/SessionCompaction") {
+import { Context, Effect, Exit, Fiber, Layer, Result, Scope, Stream } from "effect";
+class Service8 extends Context.Service()("@opencode/SessionCompaction") {
 }
 var NOTHING_TO_COMPACT = { error: { type: "compaction.unavailable", message: "Nothing to compact yet" } };
-var SHRINK_STEPS = [0.7, 0.5, 0.35];
+var SHRINK_STEPS = [0.85, 0.7, 0.5, 0.35];
 var RESERVE_MIN = 16000;
 var RESERVE_SHARE = 0.15;
 var UNKNOWN_WINDOW = 200000;
+var SUMMARY_OUTPUT_FLOOR = 32000;
+var OUTPUTS_CLIPPED = 1;
+var OUTPUTS_REMOVED = 2;
+var USER_ONLY = 3;
+var OMITTED = 4;
+var TRANSCRIPT_LEVELS = [0, OUTPUTS_CLIPPED, OUTPUTS_REMOVED, USER_ONLY, OMITTED];
+var TRANSCRIPT_CLIP = 2000;
 var IMAGE_TOKEN_ESTIMATE = 1500;
 var PDF_TOKEN_ESTIMATE = 2000;
+var PRECOMPUTE_RATIO = 0.85;
+var PRECOMPUTE_MIN_TOKENS = 64000;
+var PRECOMPUTED_TAIL_MIN = 30000;
+var PRECOMPUTED_TAIL_SHARE = 0.25;
+var PRECOMPUTE_MAX_FAILURES = 2;
 var SUMMARY_TEMPLATE = `You MUST use this format for your response (you may omit sections that aren't applicable). Do not include the <template> tags in your response.
 <template>
 ## Objective
@@ -173,23 +184,34 @@ var buildPrompt2 = (update, legacy = false) => {
 };
 var NUDGE = "The previous response did not fill in the required summary template. Do not call tools. Return the summary as text using the exact section headings from the template.";
 var LEGACY_HEADING = "## Additional Context";
-var layer7 = Layer.effect(Service11, Effect.gen(function* () {
-  const agents = yield* Service76;
+var layer7 = Layer.effect(Service8, Effect.gen(function* () {
+  const agents = yield* Service75;
   const bus = yield* Service85;
   const llm = yield* LLMClient.Service;
-  const catalog = yield* Service68;
-  const models = yield* Service47;
+  const catalog = yield* Service70;
+  const models = yield* Service49;
   const db = (yield* Service86).db;
-  const requests = yield* Service30;
+  const requests = yield* Service32;
+  const scope = yield* Scope.Scope;
+  const precomputed = new Map;
   const state = create3({
     name: "session-compaction",
-    initial: () => ({ auto: true, keep: 15000 }),
+    initial: () => ({ auto: true, keep: 15000, precompute: false }),
     editor: (settings) => ({
       configure: (update) => {
         Object.assign(settings, update);
       }
     })
   });
+  const selectModel = Effect.fnUntraced(function* (context, buffer, native) {
+    const agent = native ? undefined : yield* agents.get(ID11.make("compaction"));
+    const model = (agent?.model && (yield* models.resolve({ ...context.session, model: agent.model }, catalog.available).pipe(Effect.orElseSucceed(() => {
+      return;
+    })))) ?? context.model;
+    const ceiling = calculateCeiling(model.limit, buffer);
+    const cap = Number.isFinite(ceiling) ? ceiling : calculateCeiling({ ...model.limit, context: UNKNOWN_WINDOW }, buffer);
+    return { context: model === context.model ? context : { ...context, model }, cap };
+  });
   const compact = Effect.fn("SessionCompaction.compact")(function* (trigger) {
     const settings = state.get();
     const context = trigger.context;
@@ -197,21 +219,86 @@ var layer7 = Layer.effect(Service11, Effect.gen(function* () {
       return { status: "skipped" };
     if (trigger.reason === "auto" && !due(context, calculateCeiling(context.model.limit, settings.buffer)))
       return { status: "skipped" };
+    const held = precomputed.get(context.session.id);
+    precomputed.delete(context.session.id);
     const native = context.model.compaction?.type === "native";
-    const agent = native ? undefined : yield* agents.get(ID11.make("compaction"));
-    const model = (agent?.model && (yield* models.resolve({ ...context.session, model: agent.model }, catalog.available).pipe(Effect.orElseSucceed(() => {
-      return;
-    })))) ?? context.model;
-    const ceiling = calculateCeiling(model.limit, settings.buffer);
-    const cap = Number.isFinite(ceiling) ? ceiling : calculateCeiling({ ...model.limit, context: UNKNOWN_WINDOW }, settings.buffer);
-    const budget = trigger.reason === "overflow" ? Math.min(cap, Math.floor(estimateContext2(context) * SHRINK_STEPS[0])) : cap;
-    const selected = model === context.model ? trigger : { ...trigger, context: { ...context, model } };
-    const compaction = native ? compactNatively(selected, budget, settings.keep) : summarize(selected, budget, settings.keep);
+    const model = yield* selectModel(context, settings.buffer, native);
+    const budget = trigger.reason === "overflow" ? Math.min(model.cap, Math.floor(estimateContext2(context) * SHRINK_STEPS[0])) : model.cap;
+    const selected = model.context === context ? trigger : { ...trigger, context: model.context };
+    if (trigger.reason !== "manual")
+      yield* bus.publish(SessionEvent2.Compaction.Started, { sessionID: context.session.id, reason: "auto" });
+    const swapped = held ? yield* usePrecomputed(selected, held, budget, settings) : undefined;
+    const compaction = swapped ? Effect.succeed(swapped) : native ? compactNatively(selected, budget, settings.keep) : summarize(selected, budget, settings.keep);
     return yield* compaction.pipe(Effect.matchEffect({
       onSuccess: (result) => publish(selected, result),
       onFailure: (failure) => publish(selected, failure)
     }));
   });
+  const precompute = Effect.fn("SessionCompaction.precompute")(function* (load) {
+    const settings = state.get();
+    if (!settings.precompute || !settings.auto)
+      return;
+    const context = yield* load;
+    if (context.model.compaction?.type === "native")
+      return;
+    const ceiling = calculateCeiling(context.model.limit, settings.buffer);
+    if (!Number.isFinite(ceiling) || due(context, ceiling))
+      return;
+    if (estimateContext2(context) < ceiling * PRECOMPUTE_RATIO)
+      return;
+    const anchorIndex = context.messages.findLastIndex((message) => hasMeasuredPrompt(message, context.model.ref));
+    const anchor = context.messages[anchorIndex];
+    if (anchorIndex <= 0 || anchor?.type !== "assistant" || !anchor.tokens)
+      return;
+    if (anchor.tokens.input + anchor.tokens.cache.read + anchor.tokens.cache.write < PRECOMPUTE_MIN_TOKENS)
+      return;
+    const sessionID = context.session.id;
+    const existing = precomputed.get(sessionID);
+    const exit = existing?.fiber.pollUnsafe();
+    const failed = exit !== undefined && Exit.isFailure(exit);
+    const failures = (existing?.failures ?? 0) + (failed ? 1 : 0);
+    if (existing) {
+      const index = heldIndex(existing, context);
+      if (index >= 0 && !failed && tailTokens(context, index) <= existing.tailLimit)
+        return;
+      if (index >= 0 && (existing.keepID === anchor.id || failures >= PRECOMPUTE_MAX_FAILURES))
+        return;
+      yield* Fiber.interrupt(existing.fiber);
+      precomputed.delete(sessionID);
+    }
+    if (anchor.model.id !== context.model.ref.id || anchor.model.variant !== context.model.ref.variant)
+      return;
+    const model = yield* selectModel(context, settings.buffer, false);
+    const usage = [];
+    const fiber = yield* summarize({ reason: "auto", context: model.context }, model.cap, settings.keep, {
+      messages: context.messages.slice(0, anchorIndex),
+      usage: (recorded) => usage.push(recorded)
+    }).pipe(Effect.forkIn(scope));
+    precomputed.set(sessionID, {
+      firstID: context.messages[0]?.id,
+      keepID: anchor.id,
+      model: context.model.ref,
+      initial: context.initial,
+      tailLimit: tailLimit(settings.keep, model.cap),
+      failures,
+      usage,
+      fiber
+    });
+  });
+  const usePrecomputed = Effect.fnUntraced(function* (trigger, held, budget, settings) {
+    const context = trigger.context;
+    const index = heldIndex(held, context);
+    const usable = settings.precompute && trigger.reason !== "overflow" && context.model.compaction?.type !== "native" && index >= 0 && tailTokens(context, index) <= tailLimit(settings.keep, budget);
+    if (!usable) {
+      yield* Fiber.interrupt(held.fiber);
+      return;
+    }
+    const exit = yield* Fiber.await(held.fiber).pipe(Effect.onInterrupt(() => Fiber.interrupt(held.fiber)));
+    if (Exit.isFailure(exit))
+      return;
+    held.usage.forEach((usage) => addSpent(context.session.id, usage));
+    return { ...exit.value, metadata: { keepID: held.keepID, ...exit.value.metadata } };
+  });
   const due = (context, ceiling) => {
     const messages = context.messages;
     const last = messages.at(-1);
@@ -222,25 +309,27 @@ var layer7 = Layer.effect(Service11, Effect.gen(function* () {
       return false;
     return estimateContext2(context) >= ceiling;
   };
-  const summarize = Effect.fnUntraced(function* (trigger, budget, keep) {
+  const summarize = Effect.fnUntraced(function* (trigger, budget, keep, background) {
     const context = trigger.context;
-    const split = splitConversation(context.messages, keep);
+    const messages = background?.messages ?? context.messages;
+    const split = splitConversation(messages, keep);
     if (split === undefined)
       return yield* Effect.fail(NOTHING_TO_COMPACT);
-    const previous = previousCompaction(context.messages);
+    const keepID = background ? undefined : split.keepID;
+    const previous = previousCompaction(messages);
     const prompt = buildPrompt2(previous !== undefined, previous?.summary.includes(LEGACY_HEADING) ?? false);
     const headings = SUMMARY_TEMPLATE.split(`
 `).filter((line) => line.startsWith("##"));
     const filled = (text) => text.split(`
 `).some((line) => headings.includes(line.trim()));
-    const prepared = yield* prepare(context, context.messages, budget);
+    const prepared = yield* prepare(context, messages, budget);
     const send = (request) => Effect.gen(function* () {
       const prompted = fitOutput(LLMRequest.update(request, { messages: [...request.messages, Message.user(prompt)] }), context.model.limit);
-      const reply = yield* stream(context, prompted, prepared.options);
+      const reply = yield* stream(context, prompted, prepared.options, background);
       if (filled(reply.text))
         return reply;
       const nudged = fitOutput(LLMRequest.update(prompted, { messages: [...prompted.messages, Message.user(NUDGE)] }), context.model.limit);
-      const retry = yield* stream(context, nudged, prepared.options);
+      const retry = yield* stream(context, nudged, prepared.options, background);
       if (filled(retry.text))
         return retry;
       return yield* Effect.fail({
@@ -252,13 +341,10 @@ var layer7 = Layer.effect(Service11, Effect.gen(function* () {
     });
     const overhead = estimate2(prompt) + estimate2(NUDGE);
     const fit = trigger.reason === "overflow" ? budget : Math.max(budget, summaryRoom(context.model.limit));
-    const result = yield* deliver(trigger, prepared, budget - overhead, send, {
-      fit: fit - overhead,
-      history: withoutTail(prepared.request, split.keepID)
-    });
-    if (!split.keepID)
+    const result = yield* deliver(trigger, prepared, budget - overhead, send, { fit: fit - overhead, history: withoutTail(prepared.request, keepID) }, background);
+    if (!keepID)
       return result;
-    return { ...result, metadata: { keepID: split.keepID, ...result.metadata } };
+    return { ...result, metadata: { keepID, ...result.metadata } };
   });
   const compactNatively = Effect.fnUntraced(function* (trigger, budget, keep) {
     const context = trigger.context;
@@ -286,13 +372,10 @@ var layer7 = Layer.effect(Service11, Effect.gen(function* () {
     };
     return yield* deliver(trigger, prepared, budget, send);
   });
-  const deliver = Effect.fnUntraced(function* (trigger, prepared, target, send, shrink = { fit: target, history: prepared.request }) {
+  const deliver = Effect.fnUntraced(function* (trigger, prepared, target, send, shrink = { fit: target, history: prepared.request }, background) {
     const context = trigger.context;
-    if (trigger.reason !== "manual") {
-      yield* bus.publish(SessionEvent2.Compaction.Started, { sessionID: context.session.id, reason: "auto" });
-    }
     if (prepared.event.result)
-      return yield* fromHook(context, prepared.event.result);
+      return yield* fromHook(context, prepared.event.result, background);
     const policy = yield* policy2(context.session.id);
     let rejections = 0;
     let rejected;
@@ -350,31 +433,44 @@ var layer7 = Layer.effect(Service11, Effect.gen(function* () {
     const summary = previous !== undefined && !isNativeCompaction2(previous) ? previous : undefined;
     const lead = summary ? toLLMMessages2([{ ...summary, metadata: { ...summary.metadata, recent: "" } }], context.model.ref) : request.messages.slice(0, end);
     const recent = summary ? kept2(summary) : "";
-    const exchanges = request.messages.slice(end).reduce((groups, message) => {
-      const text = flattenMessage(message);
-      if (!text)
+    const exchanges = [
+      ...recent ? [TRANSCRIPT_LEVELS.map((level) => level === OMITTED ? "" : recent)] : [],
+      ...request.messages.slice(end).reduce((groups, message) => {
+        if (message.role === "user" || groups.length === 0)
+          groups.push([message]);
+        else
+          groups[groups.length - 1].push(message);
         return groups;
-      if (message.role === "user" || groups.length === 0)
-        groups.push(text);
-      else
-        groups[groups.length - 1] += `
-${text}`;
-      return groups;
-    }, recent ? [recent] : []);
+      }, []).map((group) => TRANSCRIPT_LEVELS.map((level) => group.map((message) => flattenMessage(message, level)).filter(Boolean).join(`
+`))).filter((renders) => renders[0])
+    ];
+    if (exchanges.length === 0)
+      return;
     const note = (omitted) => omitted ? `[${omitted} older ${omitted === 1 ? "exchange" : "exchanges"} omitted]
 
 ` : "";
-    const room = target - estimateRequest({ system: request.system, tools: request.tools, messages: lead }) - estimate2(note(exchanges.length));
-    const kept = exchanges.slice(oldestToDrop(exchanges, (text) => estimate2(text) + 1, room));
-    if (kept.length === 0)
+    const size = (text) => text ? estimate2(text) + 1 : 0;
+    const room = target - estimateRequest({ system: request.system, tools: [], messages: lead }) - estimate2(note(exchanges.length));
+    const levels = exchanges.map(() => 0);
+    let total = exchanges.reduce((sum, renders) => sum + size(renders[0]), 0);
+    const newest = exchanges.length - 1;
+    for (const level of TRANSCRIPT_LEVELS.slice(1)) {
+      for (let index = 0;index < exchanges.length && total > room; index++) {
+        if (index === newest && !exchanges[index][level])
+          continue;
+        total += size(exchanges[index][level]) - size(exchanges[index][levels[index]]);
+        levels[index] = level;
+      }
+    }
+    if (total > room)
       return;
-    return LLMRequest.update(request, {
-      messages: [...lead, Message.user(note(exchanges.length - kept.length) + kept.join(`
+    const omitted = levels.filter((level, index) => !exchanges[index][level]).length;
+    const text = exchanges.map((renders, index) => renders[levels[index]]).filter(Boolean).join(`
 
-`))]
-    });
+`);
+    return LLMRequest.update(request, { tools: [], messages: [...lead, Message.user(note(omitted) + text)] });
   };
-  const stream = (context, request, options) => {
+  const stream = (context, request, options, background) => {
     const sessionID = context.session.id;
     const unusable = (error) => Effect.fail({ error });
     return llm.stream(request, options).pipe(Stream.runFoldEffect(() => ({ text: "" }), (streamed, event) => {
@@ -386,10 +482,13 @@ ${text}`;
         }));
       }
       if (LLMEvent.is.textDelta(event)) {
-        return bus.publish(SessionEvent2.Compaction.Delta, { sessionID, text: event.text }).pipe(Effect.as({ ...streamed, text: streamed.text + event.text }));
+        const next = { ...streamed, text: streamed.text + event.text };
+        if (background)
+          return Effect.succeed(next);
+        return bus.publish(SessionEvent2.Compaction.Delta, { sessionID, text: event.text }).pipe(Effect.as(next));
       }
       if (LLMEvent.is.stepFinish(event)) {
-        return spend(sessionID, record2(event.usage, context.model.cost)).pipe(Effect.as(streamed));
+        return spend(sessionID, record2(event.usage, context.model.cost), background?.usage).pipe(Effect.as(streamed));
       }
       if (!LLMEvent.is.finish(event))
         return Effect.succeed(streamed);
@@ -428,23 +527,26 @@ ${text}`;
       inputTokens: { measured: budget, estimated: 0 }
     });
   };
-  const fromHook = (context, supplied) => {
+  const fromHook = (context, supplied, background) => {
     const usage = supplied.tokens && {
       tokens: supplied.tokens,
       cost: calculateCost2(context.model.cost, supplied.tokens)
     };
-    return spend(context.session.id, usage).pipe(Effect.as({
+    return spend(context.session.id, usage, background?.usage).pipe(Effect.as({
       text: supplied.summary,
       native: supplied.native,
       metadata: supplied.metadata
     }));
   };
   const spent = new Map;
-  const spend = (sessionID, usage) => Effect.gen(function* () {
-    if (!usage)
-      return;
+  const addSpent = (sessionID, usage) => {
     const total = spent.get(sessionID);
     spent.set(sessionID, total ? add2(total, usage) : usage);
+  };
+  const spend = (sessionID, usage, record = (recorded) => addSpent(sessionID, recorded)) => Effect.gen(function* () {
+    if (!usage)
+      return;
+    record(usage);
     yield* bus.publish(SessionEvent2.UsageRecorded, { sessionID, source: "compaction", ...usage });
   });
   const publish = Effect.fnUntraced(function* (trigger, outcome) {
@@ -472,17 +574,31 @@ ${text}`;
     }, { metadata: outcome.metadata });
     return { status: "completed" };
   });
-  return Service11.of({
+  return Service8.of({
     transform: state.transform,
     reload: state.reload,
-    compact: (trigger) => compact(trigger).pipe(Effect.onInterrupt(() => trigger.reason === "manual" ? Effect.void : publish(trigger, { error: { type: "compaction.interrupted", message: "Compaction was interrupted" } })), Effect.ensuring(Effect.sync(() => spent.delete(trigger.context.session.id))))
+    compact: (trigger) => compact(trigger).pipe(Effect.onInterrupt(() => trigger.reason === "manual" ? Effect.void : publish(trigger, { error: { type: "compaction.interrupted", message: "Compaction was interrupted" } })), Effect.ensuring(Effect.sync(() => spent.delete(trigger.context.session.id)))),
+    precompute
   });
 }));
-var node13 = makeLocationNode({
-  service: Service11,
+var node10 = makeLocationNode({
+  service: Service8,
   layer: layer7,
-  deps: [node80, node89, node90, llmClient2, node72, node33, node49]
+  deps: [node79, node89, node90, llmClient2, node74, node35, node51]
 });
+var heldIndex = (held, context) => {
+  if (held.firstID !== context.messages[0]?.id || held.initial !== context.initial)
+    return -1;
+  if (held.model.providerID !== context.model.ref.providerID || held.model.id !== context.model.ref.id)
+    return -1;
+  if (held.model.variant !== context.model.ref.variant)
+    return -1;
+  return context.messages.findIndex((message) => message.id === held.keepID);
+};
+var tailTokens = (context, index) => estimate2(context.messages.slice(index).map(messageToText2).filter(Boolean).join(`
+
+`));
+var tailLimit = (keep, budget) => Math.min(Math.max(keep * 2, PRECOMPUTED_TAIL_MIN), Math.floor(budget * PRECOMPUTED_TAIL_SHARE));
 var previousCompaction = (messages) => {
   const [first] = messages;
   return first?.type === "compaction" && first.status === "completed" ? first : undefined;
@@ -534,25 +650,49 @@ var oldestToDrop = (items, size, budget) => {
   }
   return start;
 };
-var flattenMessage = (message) => {
-  if (message.role === "system")
+var flattenMessage = (message, level) => {
+  if (message.role === "system" || level === OMITTED)
+    return "";
+  if (level >= USER_ONLY && message.role !== "user")
     return "";
   return message.content.flatMap((part) => {
-    if (part.type === "text")
-      return part.text ? [`[${message.role === "user" ? "User" : "Assistant"}]: ${part.text}`] : [];
+    if (part.type === "text") {
+      if (!part.text)
+        return [];
+      const text = level >= USER_ONLY ? clip(part.text) : part.text;
+      return [`[${message.role === "user" ? "User" : "Assistant"}]: ${text}`];
+    }
+    if (level >= USER_ONLY)
+      return [];
     if (part.type === "media")
       return [`[${part.media.mediaType} omitted]`];
-    if (part.type === "tool-call")
-      return [`[Assistant tool call]: ${part.name}(${JSON.stringify(part.input) ?? ""})`];
+    if (part.type === "tool-call") {
+      const input = JSON.stringify(part.input) ?? "";
+      return [`[Assistant tool call]: ${part.name}(${level >= OUTPUTS_REMOVED ? clip(input) : input})`];
+    }
     if (part.type !== "tool-result")
       return [];
     const result = part.result;
-    const output = result.type === "content" ? serializeToolContent2(result.value) : typeof result.value === "string" ? result.value : JSON.stringify(result.value) ?? "";
     const label = result.type === "error" ? "Tool error" : "Tool result";
-    return [`[${label}]: ${truncateToolOutput2(output)}`];
+    if (level >= OUTPUTS_REMOVED)
+      return [`[${label} omitted]`];
+    const output = result.type === "content" ? serializeToolContent2(result.value) : typeof result.value === "string" ? result.value : JSON.stringify(result.value) ?? "";
+    return [`[${label}]: ${level >= OUTPUTS_CLIPPED ? clip(output) : output}`];
   }).join(`
 `);
 };
+var clip = (value) => {
+  if (value.length <= TRANSCRIPT_CLIP)
+    return value;
+  const chars = Array.from(value);
+  if (chars.length <= TRANSCRIPT_CLIP)
+    return value;
+  const half = TRANSCRIPT_CLIP / 2;
+  const omitted = chars.length - TRANSCRIPT_CLIP;
+  return `${chars.slice(0, half).join("")}
+[… ${omitted} characters omitted …]
+${chars.slice(-half).join("")}`;
+};
 var recentUserMessages2 = (messages, model, keep) => {
   const users = messages.filter((message) => message.type === "user").map((message) => ({ ...message, skills: undefined }));
   const sendable = boundImages2(unsupportedParts2(toLLMMessages2(users, model.ref), model.capabilities));
@@ -583,7 +723,7 @@ var calculateCeiling = (limit, buffer) => {
   const window = limit.input || limit.context;
   if (window <= 0)
     return Number.POSITIVE_INFINITY;
-  if (buffer !== undefined)
+  if (buffer !== undefined && buffer < window)
     return window - buffer;
   return window - Math.max(Math.floor(window * RESERVE_SHARE), window >= 2 * RESERVE_MIN ? RESERVE_MIN : 0);
 };
@@ -593,7 +733,8 @@ var fitOutput = (request, limit) => {
   const current = request.generation?.maxTokens;
   if (current === undefined)
     return request;
-  const maxTokens = Math.min(current, outputLimit2(limit, "compaction", { measured: estimateRequest(request), estimated: 0 }));
+  const estimated = estimateRequest(request);
+  const maxTokens = Math.min(current, Math.max(outputLimit2(limit, { measured: 0, estimated }), Math.min(SUMMARY_OUTPUT_FLOOR, outputLimit2(limit, { measured: estimated, estimated: 0 }))));
   if (maxTokens === current)
     return request;
   return LLMRequest.update(request, { generation: { ...request.generation, maxTokens } });
@@ -630,4 +771,4 @@ var estimateMedia = (mime) => {
   return 0;
 };
 
-export { Service11, buildPrompt2, layer7, node13, recentUserMessages2, estimateContext2, estimatePrompt2, exports_compaction2 };
+export { Service8, buildPrompt2, layer7, node10, recentUserMessages2, estimateContext2, estimatePrompt2, exports_compaction2 };

package/dist/chunks/{repository-cache-twwrpnjg.js → location-4jbtvrw1.js}

@@ -1,36 +1,36 @@
 import {
-  Service57
-} from "./repository-cache-ey9nrxd1.js";
+  Service59
+} from "./location-s56jz2hb.js";
 import {
-  Service56
-} from "./repository-cache-z0mn1t4q.js";
+  Service58
+} from "./location-4v3515yy.js";
 import {
   parse2
-} from "./repository-cache-8wmb0r1y.js";
+} from "./location-mjey6v08.js";
 import {
   ignore2,
   scan2
-} from "./repository-cache-bzeyqsqd.js";
+} from "./location-nah043kf.js";
 import {
   __export
-} from "./repository-cache-9rqn6x4v.js";
+} from "./location-9rqn6x4v.js";
 
 // src/config/plugin/compatibility.ts
 var exports_compatibility = {};
 __export(exports_compatibility, {
   ConfigCompatibilityPlugin: () => exports_compatibility,
-  Plugin: () => Plugin4
+  Plugin: () => Plugin34
 });
 import { define } from "@opencode/plugin/effect/plugin";
 import { FSUtil } from "@opencode/util/fs-util";
 import path from "path";
 import { Effect, FiberMap, PubSub, Semaphore, Stream } from "effect";
-var Plugin4 = define({
+var Plugin34 = define({
   id: "opencode.config.compatibility",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* Service56;
+    const config = yield* Service58;
     const fs = yield* FSUtil.Service;
-    const watcher = yield* Service57;
+    const watcher = yield* Service59;
     const watches = yield* FiberMap.make();
     const changes = yield* PubSub.sliding(1);
     const lock = Semaphore.makeUnsafe(1);
@@ -76,4 +76,4 @@ var Plugin4 = define({
   })
 });
 
-export { Plugin4, exports_compatibility };
+export { Plugin34, exports_compatibility };