@aparte/core 0.24.0 → 0.26.0

package/dist/{dialog-triggers-BqXRdHWZ.js → defer-hydration-8vI8xNNx.js}

@@ -1,5 +1,5 @@
 import { toolRefusal as toolRefusal$1, unansweredTail, runStreamAgent } from "@aparte/engine";
-import { A as APARTE_ICON_GLYPHS } from "./glyphs-C8z2oJUg.js";
+import { A as APARTE_ICON_GLYPHS } from "./glyphs-2bym5jl5.js";
 function contentToText(content) {
   if (typeof content === "string") return content;
   return content.filter((p) => p.type === "text").map((p) => p.text).join("");
@@ -58,9 +58,14 @@ class AparteError extends Error {
     if (error instanceof AparteError) return error;
     const message = error instanceof Error ? error.message : String(error);
     const status = error?.status || error?.statusCode || defaultStatus;
-    const code = defaultCode !== "UNKNOWN_ERROR" ? defaultCode : AparteError.codeForStatus(status) ?? AparteError.codeForFailure(error) ?? defaultCode;
+    const carried = error?.code;
+    const code = defaultCode !== "UNKNOWN_ERROR" ? defaultCode : AparteError.carriedCode(carried) ?? AparteError.codeForStatus(status) ?? AparteError.codeForFailure(error) ?? defaultCode;
     return new AparteError(message, code, void 0, error, status);
   }
+  /** The value as an {@link AparteErrorCode}, when it is one — a Node `ECONNRESET` or a vendor's own string is not. */
+  static carriedCode(value) {
+    return typeof value === "string" && Object.values(AparteErrorCode).includes(value) ? value : void 0;
+  }
   /**
    * What a thrown, statusless error says about itself. `fetch` rejects a network
    * failure with a TypeError whose message names the fetch ("Failed to fetch",
@@ -104,7 +109,26 @@ const APARTE_DEFAULT_LOCALE = {
   scrollToBottom: "Scroll to bottom",
   suggestionsLabel: "Suggested prompts",
   contextLabel: "Context window",
+  contextSystem: "System prompt",
+  contextTools: "Tools",
+  contextSummary: "Summary",
+  contextMessages: "Messages",
+  contextOther: "Other",
+  contextFree: "Free",
+  contextTotal: "Total",
+  contextReclaim: "Compacting now would free ~{n} tokens",
+  contextCompactNow: "Compact now",
   compactionSummaryTitle: "Conversation summary",
+  checkpointCount: "{n} messages summarised for the model",
+  checkpointCountOne: "1 message summarised for the model",
+  checkpointLegacy: "Earlier messages were summarised",
+  checkpointGroup: "Context summary",
+  checkpointShow: "Show summary",
+  checkpointHide: "Hide summary",
+  checkpointRestore: "Restore",
+  checkpointRestoreConfirm: "Send the original messages to the model again?",
+  checkpointPending: "Summarising the context…",
+  checkpointFailed: "Couldn't summarise the context",
   toolRunning: "Running",
   toolCompleted: "Done",
   toolRejected: "Rejected",
@@ -143,6 +167,7 @@ const APARTE_DEFAULT_LOCALE = {
   generating: "Generating…",
   rebuildingPreview: "Rebuilding preview…",
   typing: "Typing",
+  responseCutOff: "Cut off at the model's length limit.",
   error: "Error",
   running: "Running...",
   run: "Run",
@@ -199,15 +224,19 @@ function readAuth(auth) {
   if (auth && typeof auth === "object") return { key: auth["apiKey"], endpoint: auth["endpoint"] };
   return {};
 }
-async function vendorErrorMessage(response, label = "HTTP") {
-  const body = await response.json().catch(() => ({}));
+function messageOf(body, status, label) {
   const raw = body?.error;
   const msg = typeof raw === "object" ? raw?.message : raw;
-  return typeof msg === "string" && msg ? msg : `${label} ${response.status}`;
+  return typeof msg === "string" && msg ? msg : `${label} ${status}`;
+}
+function isAparteErrorCode(value) {
+  return typeof value === "string" && Object.values(AparteErrorCode).includes(value);
 }
-async function vendorError(response, label = "HTTP") {
-  const message = await vendorErrorMessage(response, label);
-  const code = AparteError.codeForStatus(response.status) ?? AparteErrorCode.UNKNOWN_ERROR;
+async function vendorError(response, label = "HTTP", adapter) {
+  const body = await response.json().catch(() => void 0);
+  const message = messageOf(body, response.status, label);
+  const forwarded = body?.error?.code;
+  const code = adapter?.classifyError?.(response.status, body) ?? (isAparteErrorCode(forwarded) ? forwarded : void 0) ?? AparteError.codeForStatus(response.status) ?? AparteErrorCode.UNKNOWN_ERROR;
   return new AparteError(message, code, void 0, void 0, response.status);
 }
 async function parseNonStreamText(provider, response, providerId) {
@@ -250,7 +279,7 @@ class AparteDirectTransport {
       signal: ctx.signal
     });
     if (!response.ok) {
-      throw await vendorError(response);
+      throw await vendorError(response, "HTTP", provider);
     }
     if (request.stream === false) {
       return parseNonStreamText(provider, response, ctx.providerId);
@@ -878,12 +907,18 @@ function createAparteChatHandler(options) {
       const raw = await vendor.text().catch(() => "");
       let code;
       let type;
+      let body;
       try {
-        const parsed = JSON.parse(raw);
+        body = JSON.parse(raw);
+        const parsed = body;
         code = parsed?.error?.code;
         type = parsed?.error?.type;
       } catch {
       }
+      try {
+        code = adapter.classifyError?.(vendor.status, body) ?? code;
+      } catch {
+      }
       return new Response(
         JSON.stringify({
           error: {
@@ -897,7 +932,12 @@ function createAparteChatHandler(options) {
     }
     if (request.stream === false) {
       const json = await vendor.json().catch(() => ({}));
-      const text = typeof adapter.parseText === "function" ? adapter.parseText(json) : "";
+      let text;
+      try {
+        text = typeof adapter.parseText === "function" ? adapter.parseText(json) : "";
+      } catch {
+        return jsonError$1(502, "The vendor answered with an error.");
+      }
       return new Response(JSON.stringify({ text }), {
         headers: { "Content-Type": "application/json" }
       });
@@ -915,7 +955,7 @@ function createAparteChatHandler(options) {
             controller.close();
             return;
           }
-          controller.enqueue(encoder2.encode(JSON.stringify(value) + "\n"));
+          controller.enqueue(encoder2.encode(JSON.stringify(relayable(value)) + "\n"));
         } catch (err) {
           controller.error(err);
         }
@@ -927,6 +967,13 @@ function createAparteChatHandler(options) {
     return new Response(ndjson, { headers: { "Content-Type": "application/x-ndjson" } });
   };
 }
+function relayable(event) {
+  const e = event;
+  if (e?.type !== "error") return event;
+  console.error("[aparte] the vendor streamed an error", event);
+  const code = typeof e.code === "string" && Object.values(AparteErrorCode).includes(e.code) ? e.code : void 0;
+  return { type: "error", message: "The vendor reported an error.", ...code ? { code } : {} };
+}
 function jsonError$1(status, message) {
   return new Response(JSON.stringify({ error: { message } }), {
     status,
@@ -950,13 +997,13 @@ function stampSegmentOnInsert(segments, segment, messageId, defaults) {
     ...timingPatch(base, { startedAt: segmentTiming(segment)?.startedAt ?? Date.now() })
   };
 }
-function adoptSegment(segments, segment, messageId, live = false) {
+function adoptSegment(segments, segment, messageId, live2 = false) {
   return {
     ...segment,
     messageId,
     index: segments.length,
     isStreaming: false,
-    ...segment.type === "tool_call" && (segment.status === "awaiting-approval" || segment.status === "pending" && !live) && !segment.deferred?.ticket ? { status: "aborted" } : {}
+    ...segment.type === "tool_call" && (segment.status === "awaiting-approval" || segment.status === "pending" && !live2) && !segment.deferred?.ticket ? { status: "aborted" } : {}
   };
 }
 const RESERVED = /* @__PURE__ */ new Set(["id", "type", "messageId", "index"]);
@@ -1030,11 +1077,11 @@ function openSegmentIds(segments) {
 }
 function adoptMessageSegments(message) {
   if (!message.segments?.length) return { ...message };
-  const live = message.status === "streaming" || message.status === "pending";
+  const live2 = message.status === "streaming" || message.status === "pending";
   return {
     ...message,
     segments: message.segments.reduce((acc, segment) => {
-      acc.push(adoptSegment(acc, segment, message.id, live));
+      acc.push(adoptSegment(acc, segment, message.id, live2));
       return acc;
     }, [])
   };
@@ -1070,8 +1117,8 @@ function detachConfig(el2) {
   if (previous) notifyConfigChanged(el2, resolveConfig(el2.parentElement), previous);
 }
 function resolveConfig(el2) {
-  const host = el2?.closest?.(`[${APARTE_HOST_ATTR}]`);
-  return host?.[CONFIG_SLOT] ?? aparteGlobalConfig;
+  const host2 = el2?.closest?.(`[${APARTE_HOST_ATTR}]`);
+  return host2?.[CONFIG_SLOT] ?? aparteGlobalConfig;
 }
 let _renderConfig = null;
 function runWithConfig(config, fn) {
@@ -1248,7 +1295,10 @@ function createStreamAdapter(opts) {
         break;
       }
       case "run-done":
-        target.updateMessage?.(messageId, { status: "completed" });
+        target.updateMessage?.(messageId, {
+          status: "completed",
+          ...e.finishReason ? { finishReason: e.finishReason } : {}
+        });
         if (e.usage) {
           try {
             target.setUsage?.(messageId, e.usage);
@@ -1519,10 +1569,11 @@ function createAparteAgentHandler(options) {
           console.error("[aparte] agent run failed", error);
           await pendingWrite?.catch(() => {
           });
+          const named = AparteError.from(error).code;
           write({
             type: "run-error",
             message: "The agent run failed.",
-            code: error instanceof AparteError ? error.code : "AGENT_RUN_FAILED"
+            code: named === AparteErrorCode.UNKNOWN_ERROR ? "AGENT_RUN_FAILED" : named
           });
           close();
         });
@@ -1928,6 +1979,33 @@ function renderingVersionOf(cfg) {
 function bumpRenderingVersion(cfg) {
   renderingVersions.set(cfg, renderingVersionOf(cfg) + 1);
 }
+const rendererListeners = /* @__PURE__ */ new Set();
+const pendingRendererChanges = /* @__PURE__ */ new Set();
+function onRenderersChange(listener) {
+  rendererListeners.add(listener);
+  return () => {
+    rendererListeners.delete(listener);
+  };
+}
+function notifyRenderersChanged(cfg) {
+  if (pendingRendererChanges.size === 0) {
+    queueMicrotask(() => {
+      const changed = [...pendingRendererChanges];
+      pendingRendererChanges.clear();
+      for (const config of changed) {
+        for (const listener of [...rendererListeners]) {
+          try {
+            listener(config);
+          } catch (err) {
+            console.error("[aparte] a renderer-change listener threw", err);
+          }
+        }
+      }
+    });
+  }
+  pendingRendererChanges.add(cfg);
+}
+const matcherKey = (match) => match instanceof RegExp ? `re:${String(match)}` : `name:${match}`;
 const ELEMENT_SHAPING = ["hidden", "open", "details", "quiet"];
 function drawingOf(provider, name) {
   if (!provider || !(name in provider) || name in Object.prototype) return void 0;
@@ -1996,6 +2074,8 @@ class AparteConfig {
   _modelPreferenceProvider;
   // Per-call approval policy (a mode: plan / ask / auto). `null` = the tools' own flags.
   _approvalPolicy = null;
+  // What makes the context smaller — `@aparte/plugin-compaction` registers itself here. `null` = nothing does.
+  _compactor = null;
   // Conversation persistence (optional, agnostic)
   _conversationManager;
   /*
@@ -2039,6 +2119,11 @@ class AparteConfig {
   _tools = /* @__PURE__ */ new Map();
   // By exact name, pattern or '*' — see `tool-table.ts` for the one resolution rule.
   _toolRenderers = new ToolTable();
+  /** {@link overrideToolRenderer}'s stacks: what each matcher held below every override. */
+  /** Per matcher: what it held below every override, then one entry per override — an object of its own, so two overrides of the same renderer are told apart. */
+  _toolRendererOverrides = /* @__PURE__ */ new Map();
+  /** Bumped by `reset()`: a restore function from before it must not undo what came after. */
+  _overrideGeneration = 0;
   _toolDisplays = new ToolTable();
   /** Tagged blocks the stream parser recognises in the prose — see {@link registerStreamBlock}. */
   _streamBlocks = /* @__PURE__ */ new Map();
@@ -2481,7 +2566,11 @@ class AparteConfig {
     try {
       const auth = await this.getKey(providerId);
       const models = await provider.fetchModels(auth);
+      const held = this._fetchedModels.get(providerId);
+      if (models.length === 0 && held?.length) return held;
+      const windowBefore = this.getCurrentModel()?.contextWindow;
       this._fetchedModels.set(providerId, models);
+      if (this.getCurrentModel()?.contextWindow !== windowBefore) this._notify();
       return models;
     } catch (error) {
       console.warn(`[AparteConfig] Failed to refresh models for ${providerId}`, error);
@@ -2605,6 +2694,26 @@ class AparteConfig {
   getApprovalPolicy() {
     return this._approvalPolicy;
   }
+  /**
+   * Register what makes the context smaller: the gauge's Compact now, a separator's
+   * Retry and the client's pre-flight and overflow retry call it. `null` removes it.
+   *
+   * `@aparte/plugin-compaction`'s `setupCompaction()` registers itself here; core never
+   * compacts on its own, so a page without a compactor has a gauge that measures and a
+   * separator whose Retry falls back to the `aparte-compact` event. A chat reads the one
+   * on ITS config first (`resolveConfig(chat).getCompactor()`), then the client's.
+   *
+   * Notifies like every other registration: a mounted gauge has to hear that "Compact
+   * now" became possible after it was drawn, or went away.
+   */
+  setCompactor(compactor) {
+    this._compactor = compactor;
+    this._notify();
+  }
+  /** The registered compactor, or `null`. */
+  getCompactor() {
+    return this._compactor;
+  }
   /**
    * What the policy says about one call, with the tool's own `needsApproval` as the
    * answer when it has no opinion. The one place the two are combined, so the client's
@@ -2880,12 +2989,64 @@ class AparteConfig {
    * // Custom pill for a web-search tool
    * aparteGlobalConfig.registerToolRenderer('web_search', { render: (seg) => `<div class="aparte-tool-label">Searching...</div>` });
    *
+   * Calls already on screen follow: those this registration now draws are drawn again
+   * by it (the renderer that drew them before gets its `cleanup`), and nothing else on
+   * the page is touched.
+   *
    * @example
    * // One look for every tool an MCP server brings
    * aparteGlobalConfig.registerToolRenderer(/^mcp__/, { render: (seg) => myMcpCard(seg) });
    */
   registerToolRenderer(match, renderer) {
+    if (this._toolRenderers.get(match) === renderer) return;
     this._toolRenderers.set(match, renderer);
+    notifyRenderersChanged(this);
+  }
+  /**
+   * Put `renderer` over whatever this matcher holds, and get back the function that takes
+   * it off again — the registration a component makes for as long as it is mounted.
+   *
+   * Overrides stack per matcher. The function restores what was there before THIS
+   * override, and taking off an override that is no longer on top changes nothing on
+   * screen: two components declaring the same tool, the newer wins, and unmounting the
+   * older does not take the newer's away. When the last one goes, the matcher holds what
+   * it held before the first — another registration, or nothing. Calls on screen follow
+   * each change, as with {@link registerToolRenderer}. The returned function is safe to
+   * call twice.
+   *
+   * @example
+   * const restore = aparteGlobalConfig.overrideToolRenderer('get_weather', weatherCard);
+   * // …later, when the component that declared it unmounts:
+   * restore();
+   */
+  overrideToolRenderer(match, renderer) {
+    const key = matcherKey(match);
+    const current = this._toolRenderers.get(match);
+    let stack = this._toolRendererOverrides.get(key);
+    if (!stack) {
+      stack = [{ renderer: current }];
+      this._toolRendererOverrides.set(key, stack);
+    } else if (stack[stack.length - 1].renderer !== current) {
+      stack.splice(0, stack.length, { renderer: current });
+    }
+    const entry = { renderer };
+    stack.push(entry);
+    this.registerToolRenderer(match, renderer);
+    const generation = this._overrideGeneration;
+    let restored = false;
+    return () => {
+      if (restored || generation !== this._overrideGeneration) return;
+      restored = true;
+      const i = stack.indexOf(entry);
+      if (i <= 0) return;
+      const wasTop = i === stack.length - 1;
+      stack.splice(i, 1);
+      if (stack.length === 1 && this._toolRendererOverrides.get(key) === stack) this._toolRendererOverrides.delete(key);
+      if (!wasTop || this._toolRenderers.get(match) !== renderer) return;
+      const top = stack[stack.length - 1].renderer;
+      if (top) this.registerToolRenderer(match, top);
+      else this.unregisterToolRenderer(match);
+    };
   }
   /**
    * Field defaults for a segment TYPE, filled in when a segment enters a message.
@@ -2925,9 +3086,11 @@ class AparteConfig {
   clearSegmentDefaults(type) {
     this._segmentDefaults.delete(type);
   }
-  /** Unregister the renderer registered under this matcher. */
+  /** Unregister the renderer registered under this matcher. Calls on screen it drew go back to core's row. */
   unregisterToolRenderer(match) {
+    if (this._toolRenderers.get(match) === void 0) return;
     this._toolRenderers.delete(match);
+    notifyRenderersChanged(this);
   }
   /** The renderer that draws a tool named `toolName` — exact, pattern or `'*'` — or undefined. */
   getToolRenderer(toolName) {
@@ -3278,6 +3441,9 @@ class AparteConfig {
     this._fetchedModels.clear();
     this._tools.clear();
     this._toolRenderers.clear();
+    this._toolRendererOverrides.clear();
+    this._overrideGeneration++;
+    notifyRenderersChanged(this);
     this._toolDisplays.clear();
     this._streamBlocks.clear();
     this._modelConfig = {};
@@ -3288,6 +3454,7 @@ class AparteConfig {
     this._elicitationFieldRenderer = void 0;
     this._modelPreferenceProvider = void 0;
     this._approvalPolicy = null;
+    this._compactor = null;
     this._bubbleActionsConfig = { ...APARTE_DEFAULT_BUBBLE_ACTIONS };
     this._hostHandlers = { ...APARTE_DEFAULT_HOST_HANDLERS };
     this._notify();
@@ -3329,19 +3496,19 @@ const ONE_SHOT_PROBE = "<i>a</i>";
 function hasOneShotMarkdownProvider() {
   return contextConfig().renderMarkdown(ONE_SHOT_PROBE) !== escapeHtml(ONE_SHOT_PROBE);
 }
-function writeStreamedMarkdown(host, contentEl, content, streaming) {
+function writeStreamedMarkdown(host2, contentEl, content, streaming) {
   if (streaming) {
-    if (host._aparteSmd === void 0) {
+    if (host2._aparteSmd === void 0) {
       settledFromParser.delete(contentEl);
       const renderer = contextConfig().createStreamingMarkdownRenderer(contentEl);
       if (renderer) {
         contentEl.textContent = "";
-        host._aparteSmd = { renderer, written: 0 };
+        host2._aparteSmd = { renderer, written: 0 };
       } else {
-        host._aparteSmd = null;
+        host2._aparteSmd = null;
       }
     }
-    const smd = host._aparteSmd;
+    const smd = host2._aparteSmd;
     if (smd) {
       const delta = content.slice(smd.written);
       if (delta) {
@@ -3350,15 +3517,15 @@ function writeStreamedMarkdown(host, contentEl, content, streaming) {
       }
       return;
     }
-  } else if (host._aparteSmd) {
-    const smd = host._aparteSmd;
+  } else if (host2._aparteSmd) {
+    const smd = host2._aparteSmd;
     const tail = content.slice(smd.written);
     if (tail) {
       smd.renderer.write(tail);
       smd.written = content.length;
     }
     smd.renderer.end();
-    host._aparteSmd = void 0;
+    host2._aparteSmd = void 0;
     if (!hasOneShotMarkdownProvider()) {
       contentEl.innerHTML = contextConfig().sanitizeHtml(contentEl.innerHTML);
       settledFromParser.set(contentEl, content);
@@ -3587,16 +3754,16 @@ function streamHighlight(element, paneSelector, content, lang, segId) {
   if (now - (_lastHighlightAt.get(segId) ?? 0) < HIGHLIGHT_DEBOUNCE_MS) return;
   markThrottle(_lastHighlightAt, segId, now);
   void contextConfig(element).highlightCode(content.slice(0, cut), lang).then((html) => {
-    const live = element.querySelector(paneSelector);
-    if (!live) return;
-    if (cut <= highlightedLen(live)) return;
-    live.innerHTML = html;
-    const codeEl = live.querySelector("code") ?? live;
+    const live2 = element.querySelector(paneSelector);
+    if (!live2) return;
+    if (cut <= highlightedLen(live2)) return;
+    live2.innerHTML = html;
+    const codeEl = live2.querySelector("code") ?? live2;
     const span = document.createElement("span");
     span.dataset.aparteTail = "";
     span.textContent = content.slice(cut);
     codeEl.appendChild(span);
-    live.dataset.aparteHlLen = String(cut);
+    live2.dataset.aparteHlLen = String(cut);
   }).catch(() => {
   });
 }
@@ -3820,9 +3987,9 @@ function sameShape(a, b) {
   }
   return true;
 }
-function patchChanges(live, prev, next) {
-  for (let i = 0; i < live.childNodes.length; i++) {
-    const l = live.childNodes[i];
+function patchChanges(live2, prev, next) {
+  for (let i = 0; i < live2.childNodes.length; i++) {
+    const l = live2.childNodes[i];
     const p = prev.childNodes[i];
     const n = next.childNodes[i];
     if (l instanceof Element && p instanceof Element && n instanceof Element) {
@@ -3989,16 +4156,26 @@ function placeholderMarkup(segment) {
   return `<div class="aparte-segment aparte-segment-tool-call" data-segment-id="${escapeHtml(segment.id)}" data-status="${escapeAttr(segment.status ?? "pending")}" data-tool-call-id="${escapeAttr(segment.toolCall?.id ?? "")}" data-tool-name="${escapeAttr(segment.toolCall?.name ?? "tool")}" hidden></div>`;
 }
 const isPlaceholder = (element) => element.hidden && element.classList.contains("aparte-segment-tool-call") && element.childElementCount === 0;
-function drawDefault(segment, behind) {
+const drawnBy = /* @__PURE__ */ new WeakMap();
+const behind = /* @__PURE__ */ new WeakMap();
+function toolRendererThatDrew(element) {
+  return behind.get(element) ?? null;
+}
+function drawerOf(element, current) {
+  const recorded = drawnBy.get(element);
+  if (recorded) return recorded;
+  return element.classList.contains("aparte-segment-tool-call") ? null : current;
+}
+function drawDefault(segment, behind2) {
   const name = segment.toolCall?.name ?? "tool";
   const status = segment.status ?? "pending";
   const toolCallId = segment.toolCall?.id ?? "";
   const pill = pillMarkup(segment);
   const quiet = isQuiet(segment) ? " data-quiet" : "";
   const toggle = contextConfig().getIcon("expand");
-  const input = behind.kind === "parts" ? describeInput(segment) : "";
-  const outcome = behind.kind === "parts" ? outcomeOf(segment) : null;
-  if (behind.kind === "none" || behind.kind === "parts" && !input && !outcome) {
+  const input = behind2.kind === "parts" ? describeInput(segment) : "";
+  const outcome = behind2.kind === "parts" ? outcomeOf(segment) : null;
+  if (behind2.kind === "none" || behind2.kind === "parts" && !input && !outcome) {
     return `
         <div class="aparte-segment aparte-segment-tool-call" data-segment-id="${escapeHtml(segment.id)}" data-status="${escapeAttr(status)}" data-tool-call-id="${escapeAttr(toolCallId)}" data-tool-name="${escapeAttr(name)}"${quiet}><div class="aparte-tool-line">${pill}</div>
         </div>
@@ -4007,7 +4184,7 @@ function drawDefault(segment, behind) {
   const cfg = contextConfig();
   const copy = copyButtonMarkup("aparte-tool-copy");
   const open = segment.collapsed !== void 0 ? !segment.collapsed : cfg.getToolDisplay(name)?.open === true;
-  if (behind.kind === "body") {
+  if (behind2.kind === "body") {
     const tpl = document.createElement("template");
     tpl.innerHTML = `
         <details class="aparte-segment aparte-segment-tool-call" data-segment-id="${escapeHtml(segment.id)}" data-status="${escapeAttr(status)}" data-tool-call-id="${escapeAttr(toolCallId)}" data-tool-name="${escapeAttr(name)}"${quiet}${open ? " open" : ""}>
@@ -4015,7 +4192,7 @@ function drawDefault(segment, behind) {
             <div class="aparte-tool-detail" data-details="app"></div>
         </details>`.trim();
     const row = tpl.content.firstElementChild;
-    setBody(row, behind.body);
+    setBody(row, behind2.body);
     return row;
   }
   return `
@@ -4044,7 +4221,12 @@ const toolCallRenderer = {
     const customRenderer = contextConfig().getToolRenderer(name);
     if (customRenderer) {
       injectToolRendererStyles(name, customRenderer);
-      return customRenderer.render(segment) || placeholderMarkup(segment);
+      const out = customRenderer.render(segment);
+      if (out instanceof HTMLElement) {
+        drawnBy.set(out, customRenderer);
+        behind.set(out, customRenderer);
+      }
+      return out || placeholderMarkup(segment);
     }
     return drawDefault(segment, behindOf(segment));
   },
@@ -4061,7 +4243,7 @@ const toolCallRenderer = {
   relabel: (element, segment) => {
     if (isPlaceholder(element)) return;
     const cfg = contextConfig();
-    const custom = cfg.getToolRenderer(segment.toolCall?.name);
+    const custom = drawerOf(element, cfg.getToolRenderer(segment.toolCall?.name) ?? null);
     if (custom) {
       custom.relabel?.(element, segment);
       return;
@@ -4081,8 +4263,8 @@ const toolCallRenderer = {
     for (const button of element.querySelectorAll(".aparte-tool-copy")) relabelCopyButton(button);
     const appDetail = appDetailOf(element);
     if (appDetail) {
-      const behind = behindOf(segment);
-      if (behind.kind === "body") relabelBody(appDetail, behind.body);
+      const behind2 = behindOf(segment);
+      if (behind2.kind === "body") relabelBody(appDetail, behind2.body);
     }
     const statusEl = element.querySelector(".aparte-tool-state");
     if (statusEl) statusEl.innerHTML = stateBadge(segment);
@@ -4108,9 +4290,10 @@ const toolCallRenderer = {
       element.setAttribute("data-status", status);
       return;
     }
-    const custom = contextConfig().getToolRenderer(segment.toolCall?.name);
-    if (custom?.update && !hidden && !isPlaceholder(element)) {
-      custom.update(element, segment);
+    const custom = hidden ? null : contextConfig().getToolRenderer(segment.toolCall?.name) ?? null;
+    const drawn = isPlaceholder(element) ? null : drawerOf(element, custom);
+    if (drawn && drawn === custom && drawn.update && !isPlaceholder(element)) {
+      drawn.update(element, segment);
       return;
     }
     const rebuild = (out) => {
@@ -4119,21 +4302,22 @@ const toolCallRenderer = {
       const rebuilt = typeof out === "string" ? tpl.content.firstElementChild : out;
       if (rebuilt) {
         if (!rebuilt.hasAttribute("data-segment-id")) rebuilt.setAttribute("data-segment-id", segment.id);
+        toolCallRenderer.cleanup?.(element, segment);
         element.replaceWith(rebuilt);
         toolCallRenderer.setup?.(rebuilt, segment);
       }
     };
-    if (custom || hidden || isPlaceholder(element)) {
+    if (custom || drawn || hidden || isPlaceholder(element)) {
       rebuild(toolCallRenderer.render(segment));
       return;
     }
-    const behind = behindOf(segment);
-    const input = behind.kind === "parts" ? describeInput(segment) : "";
-    const outcome = behind.kind === "parts" ? outcomeOf(segment) : null;
-    const wantsDetail = behind.kind === "body" || !!input || !!outcome;
+    const behind2 = behindOf(segment);
+    const input = behind2.kind === "parts" ? describeInput(segment) : "";
+    const outcome = behind2.kind === "parts" ? outcomeOf(segment) : null;
+    const wantsDetail = behind2.kind === "body" || !!input || !!outcome;
     const holdsAppDetail = !!appDetailOf(element);
-    if (wantsDetail !== (element.tagName === "DETAILS") || wantsDetail && behind.kind === "body" !== holdsAppDetail) {
-      rebuild(drawDefault(segment, behind));
+    if (wantsDetail !== (element.tagName === "DETAILS") || wantsDetail && behind2.kind === "body" !== holdsAppDetail) {
+      rebuild(drawDefault(segment, behind2));
       return;
     }
     element.setAttribute("data-status", status);
@@ -4143,8 +4327,8 @@ const toolCallRenderer = {
     setName(element, segment);
     setTarget(element, segment);
     setNote(element, segment);
-    if (behind.kind === "body") {
-      setBody(element, behind.body);
+    if (behind2.kind === "body") {
+      setBody(element, behind2.body);
       return;
     }
     setPart(element, "input", input, "toolInput");
@@ -4152,12 +4336,31 @@ const toolCallRenderer = {
     highlightParts(element);
   },
   setup: (element, segment) => {
+    const hidden = contextConfig().isToolHidden(segment.toolCall?.name ?? "tool");
+    const customRenderer = hidden ? void 0 : contextConfig().getToolRenderer(segment.toolCall?.name);
+    if (customRenderer) behind.set(element, customRenderer);
     if (isPlaceholder(element)) return;
     wireParts(element);
     highlightParts(element);
-    const customRenderer = contextConfig().getToolRenderer(segment.toolCall?.name);
+    if (customRenderer) drawnBy.set(element, customRenderer);
     customRenderer?.setup?.(element, segment);
   },
+  /**
+   * The row leaves for good: the registered renderer that drew it, if any, cleans up. A
+   * cleanup that throws is reported and goes no further: the row is replaced or removed
+   * all the same, and the stream that caused it is not interrupted.
+   */
+  cleanup: (element, segment) => {
+    behind.delete(element);
+    const custom = drawnBy.get(element);
+    if (!custom) return;
+    drawnBy.delete(element);
+    try {
+      custom.cleanup?.(element, segment);
+    } catch (err) {
+      console.error("[aparte] a tool renderer's cleanup threw", err);
+    }
+  },
   // CSS lives in styles/segment/ — see that folder for why a
   // built-in's rules belong there. `getStyles` stays for a CONSUMER's renderer, which
   // has no other way onto the page.
@@ -4181,8 +4384,51 @@ function effectiveRenderers(config) {
 }
 let styleElement = null;
 function registerSegmentRenderer(renderer, config = contextConfig()) {
-  registryFor(config).renderers.set(renderer.type, renderer);
+  const reg = registryFor(config);
+  if (reg.renderers.get(renderer.type) === renderer) return;
+  reg.renderers.set(renderer.type, renderer);
   injectRendererStyles(config);
+  notifyRenderersChanged(config);
+}
+const overrideStacks = /* @__PURE__ */ new WeakMap();
+function overrideSegmentRenderer(renderer, config = contextConfig()) {
+  const type = renderer.type;
+  const reg = registryFor(config);
+  let byType = overrideStacks.get(config);
+  if (!byType) {
+    byType = /* @__PURE__ */ new Map();
+    overrideStacks.set(config, byType);
+  }
+  const current = reg.renderers.get(type);
+  let stack = byType.get(type);
+  if (!stack) {
+    stack = [{ renderer: current }];
+    byType.set(type, stack);
+  } else if (stack[stack.length - 1].renderer !== current) stack.splice(0, stack.length, { renderer: current });
+  const entry = { renderer };
+  stack.push(entry);
+  registerSegmentRenderer(renderer, config);
+  let restored = false;
+  return () => {
+    if (restored) return;
+    restored = true;
+    const i = stack.indexOf(entry);
+    if (i <= 0) return;
+    const wasTop = i === stack.length - 1;
+    stack.splice(i, 1);
+    if (stack.length === 1 && byType.get(type) === stack) byType.delete(type);
+    if (!wasTop || reg.renderers.get(type) !== renderer) return;
+    const top = stack[stack.length - 1].renderer;
+    if (top) {
+      registerSegmentRenderer(top, config);
+      return;
+    }
+    unregisterSegmentRenderer(type, config);
+    if (!effectiveRenderers(config).has(type) && reg.defaultsInstalled && !reg.defaultsDeclined) {
+      const builtIn = DEFAULT_RENDERERS.find((r) => r.type === type);
+      if (builtIn) registerSegmentRenderer(builtIn, config);
+    }
+  };
 }
 function declineDefaultRenderers(config = contextConfig()) {
   registryFor(config).defaultsDeclined = true;
@@ -4197,7 +4443,10 @@ function installDefaultRenderersOnce(config = contextConfig()) {
   injectRendererStyles(config);
 }
 function unregisterSegmentRenderer(type, config = contextConfig()) {
-  registryFor(config).renderers.delete(type);
+  const reg = registryFor(config);
+  if (!reg.renderers.has(type)) return;
+  reg.renderers.delete(type);
+  notifyRenderersChanged(config);
 }
 function getSegmentRenderer(type, config = contextConfig()) {
   return effectiveRenderers(config).get(type);
@@ -4257,6 +4506,71 @@ const DEFAULT_RENDERERS = [
   errorRenderer,
   toolCallRenderer
 ];
+const mountedRenderers = /* @__PURE__ */ new WeakSet();
+function isMountedRenderer(renderer) {
+  return !!renderer && mountedRenderers.has(renderer);
+}
+function toToolCallView(segment) {
+  return {
+    id: segment.toolCall?.id ?? segment.id,
+    name: segment.toolCall?.name ?? "tool",
+    input: segment.toolCall?.input,
+    status: segment.status ?? "pending",
+    result: segment.result,
+    structuredResult: segment.structuredResult,
+    deferred: segment.deferred,
+    refusal: segment.refusal,
+    abortCause: segment.abortCause,
+    segment
+  };
+}
+function host(className, segmentId) {
+  const el2 = document.createElement("div");
+  el2.className = className;
+  el2.setAttribute("data-segment-id", segmentId);
+  return el2;
+}
+function defineMountedToolRenderer(mount) {
+  const mounted = /* @__PURE__ */ new WeakMap();
+  const renderer = {
+    render: (segment) => host("aparte-tool-ui", segment.id),
+    setup: (el2, segment) => {
+      if (!mounted.has(el2)) mounted.set(el2, mount(el2, toToolCallView(segment)));
+    },
+    update: (el2, segment) => {
+      mounted.get(el2)?.update(toToolCallView(segment));
+    },
+    cleanup: (el2) => {
+      const view = mounted.get(el2);
+      if (!view) return;
+      mounted.delete(el2);
+      view.destroy();
+    }
+  };
+  mountedRenderers.add(renderer);
+  return renderer;
+}
+function defineMountedSegmentRenderer(type, mount) {
+  const mounted = /* @__PURE__ */ new WeakMap();
+  const renderer = {
+    type,
+    render: (segment) => host("aparte-segment-ui", segment.id),
+    setup: (el2, segment) => {
+      if (!mounted.has(el2)) mounted.set(el2, mount(el2, segment));
+    },
+    update: (el2, segment) => {
+      mounted.get(el2)?.update(segment);
+    },
+    cleanup: (el2) => {
+      const view = mounted.get(el2);
+      if (!view) return;
+      mounted.delete(el2);
+      view.destroy();
+    }
+  };
+  mountedRenderers.add(renderer);
+  return renderer;
+}
 function populateBubbleFromMessage(bubble, message, siblingInfo) {
   if (message.segments && message.segments.length > 0) {
     const existing = bubble.getSegments?.() ?? [];
@@ -4284,13 +4598,25 @@ function populateBubbleFromMessage(bubble, message, siblingInfo) {
   if (message.usage !== void 0) {
     bubble.setUsage?.(message.usage);
   }
+  bubble.setFinishReason?.(message.finishReason);
+  bubble.setContextSummary?.(message.contextSummary, { legacy: message.compaction === true });
 }
 const APARTE_CONVERSATION_SCHEMA_VERSION = 2;
 const APARTE_DERIVED_SEGMENTS = Symbol.for("aparte.derivedSegments");
 function applyRetention(messages, tree, maxMessages) {
   if (maxMessages <= 0 || messages.length <= maxMessages) return { messages, tree };
-  const trimmedFlat = messages.slice(messages.length - maxMessages);
-  const cutoffId = trimmedFlat[0]?.id;
+  const cutIndex = messages.length - maxMessages;
+  const trimmedFlat = messages.slice(cutIndex);
+  const first = trimmedFlat[0];
+  const cutoffId = first?.id;
+  let inherited;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const own = messages[i].contextSummary;
+    if (!own) continue;
+    if (i < cutIndex) inherited = { ...own, count: own.count + (cutIndex - i) };
+    break;
+  }
+  if (first && inherited) trimmedFlat[0] = { ...first, contextSummary: inherited };
   if (!cutoffId || !tree) return { messages: trimmedFlat, tree };
   const treeIds = new Set(tree.messages.map((m) => m.message.id));
   if (!treeIds.has(cutoffId)) return { messages: trimmedFlat, tree };
@@ -4312,7 +4638,7 @@ function applyRetention(messages, tree, maxMessages) {
   }
   const trimmedTree = {
     headId: tree.headId,
-    messages: tree.messages.filter((m) => keep.has(m.message.id)).map((m) => m.message.id === cutoffId ? { message: m.message, parentId: null } : m)
+    messages: tree.messages.filter((m) => keep.has(m.message.id)).map((m) => m.message.id === cutoffId ? { message: inherited ? { ...m.message, contextSummary: inherited } : m.message, parentId: null } : m)
   };
   return { messages: trimmedFlat, tree: trimmedTree };
 }
@@ -4343,6 +4669,7 @@ function treeContentOf(tree) {
   const byId = [...tree.messages].sort((a, b) => a.message.id < b.message.id ? -1 : a.message.id > b.message.id ? 1 : 0);
   return stableStringify(byId.map((entry) => ({ parentId: entry.parentId, message: asContent(entry.message) })));
 }
+const isTitleSource = (m) => m.role === "user" && !m.compaction;
 class AparteConversationManager {
   _adapter;
   _conversations = [];
@@ -4551,7 +4878,7 @@ class AparteConversationManager {
   async _append(convId, msg) {
     const conv = await this._full(convId);
     if (!conv) return;
-    const isFirstUserMsg = msg.role === "user" && conv.messages.every((m) => m.role !== "user");
+    const isFirstUserMsg = msg.role === "user" && !msg.compaction && conv.messages.every((m) => m.role !== "user" || m.compaction);
     const title = isFirstUserMsg ? await this._title(msg) : null;
     const fresh = this._find(convId);
     if (!fresh) return;
@@ -4579,7 +4906,7 @@ class AparteConversationManager {
       console.warn(`[AparteConversationManager] updateMessages('${convId}') before its messages were loaded: ignored.`);
       return;
     }
-    const firstUser = messages.find((m) => m.role === "user");
+    const firstUser = messages.find(isTitleSource);
     if (this._retention) {
       ({ messages, tree } = applyRetention(messages, tree, this._retention.maxMessages));
     }
@@ -4600,7 +4927,7 @@ class AparteConversationManager {
     }
     let title;
     if (conv.autoTitle) {
-      const before = conv.messages.find((m) => m.role === "user");
+      const before = conv.messages.find(isTitleSource);
       if (firstUser && (firstUser.content ?? "") !== (before?.content ?? "")) {
         title = await this._title(firstUser);
       }
@@ -4902,7 +5229,7 @@ class AparteConversationController {
    * Attach event listeners to the binding host. Returns an unbind function.
    */
   bind() {
-    const host = this._binding.host;
+    const host2 = this._binding.host;
     this._onSendCapture = (e) => {
       const evt = e;
       const targetId = evt.detail?.targetId;
@@ -4921,13 +5248,13 @@ class AparteConversationController {
       evt.detail.echoed = true;
       void this._ensureConversationAndPersist(userMsg);
     };
-    host.addEventListener("aparte-send", this._onSendCapture, { capture: true });
+    host2.addEventListener("aparte-send", this._onSendCapture, { capture: true });
     this._onPathChanged = () => {
       if (!this._isLoadingConversation) {
         this._persistActive();
       }
     };
-    host.addEventListener("aparte-path-changed", this._onPathChanged);
+    host2.addEventListener("aparte-path-changed", this._onPathChanged);
     this._onMessageStart = (e) => {
       this._isStreaming = true;
       this._turnMessage = e.detail?.messageId ?? null;
@@ -4958,12 +5285,12 @@ class AparteConversationController {
     this._onMessageResumed = (e) => {
       if (this._ofThisTurn(e)) this._setTurn("running");
     };
-    host.addEventListener("aparte-message-start", this._onMessageStart);
-    host.addEventListener("aparte-message-done", this._onMessageDone);
-    host.addEventListener("aparte-message-error", this._onMessageError);
-    host.addEventListener("aparte-message-aborted", this._onMessageAborted);
-    host.addEventListener("aparte-message-paused", this._onMessagePaused);
-    host.addEventListener("aparte-message-resumed", this._onMessageResumed);
+    host2.addEventListener("aparte-message-start", this._onMessageStart);
+    host2.addEventListener("aparte-message-done", this._onMessageDone);
+    host2.addEventListener("aparte-message-error", this._onMessageError);
+    host2.addEventListener("aparte-message-aborted", this._onMessageAborted);
+    host2.addEventListener("aparte-message-paused", this._onMessagePaused);
+    host2.addEventListener("aparte-message-resumed", this._onMessageResumed);
     this._onSelectConversation = (e) => {
       const evt = e;
       const targetId = evt.detail?.targetId;
@@ -4973,7 +5300,7 @@ class AparteConversationController {
     this._onCompactDone = (e) => {
       const detail = e.detail;
       if (detail?.targetId && detail.targetId !== this._binding.hostId) return;
-      queueMicrotask(() => this._persistOnceSummarised(detail?.summary, 0));
+      queueMicrotask(() => this._persistOnceSummarised(detail ?? {}, 0));
     };
     if (typeof window !== "undefined") {
       window.addEventListener("aparte-conversation-select", this._onSelectConversation);
@@ -4995,37 +5322,37 @@ class AparteConversationController {
     this._turnMessage = null;
     this._stopHydrationRetry?.();
     this._stopHydrationRetry = null;
-    const host = this._binding.host;
+    const host2 = this._binding.host;
     if (this._onSendCapture) {
-      host.removeEventListener("aparte-send", this._onSendCapture, { capture: true });
+      host2.removeEventListener("aparte-send", this._onSendCapture, { capture: true });
       this._onSendCapture = null;
     }
     if (this._onPathChanged) {
-      host.removeEventListener("aparte-path-changed", this._onPathChanged);
+      host2.removeEventListener("aparte-path-changed", this._onPathChanged);
       this._onPathChanged = null;
     }
     if (this._onMessageStart) {
-      host.removeEventListener("aparte-message-start", this._onMessageStart);
+      host2.removeEventListener("aparte-message-start", this._onMessageStart);
       this._onMessageStart = null;
     }
     if (this._onMessageDone) {
-      host.removeEventListener("aparte-message-done", this._onMessageDone);
+      host2.removeEventListener("aparte-message-done", this._onMessageDone);
       this._onMessageDone = null;
     }
     if (this._onMessageError) {
-      host.removeEventListener("aparte-message-error", this._onMessageError);
+      host2.removeEventListener("aparte-message-error", this._onMessageError);
       this._onMessageError = null;
     }
     if (this._onMessageAborted) {
-      host.removeEventListener("aparte-message-aborted", this._onMessageAborted);
+      host2.removeEventListener("aparte-message-aborted", this._onMessageAborted);
       this._onMessageAborted = null;
     }
     if (this._onMessagePaused) {
-      host.removeEventListener("aparte-message-paused", this._onMessagePaused);
+      host2.removeEventListener("aparte-message-paused", this._onMessagePaused);
       this._onMessagePaused = null;
     }
     if (this._onMessageResumed) {
-      host.removeEventListener("aparte-message-resumed", this._onMessageResumed);
+      host2.removeEventListener("aparte-message-resumed", this._onMessageResumed);
       this._onMessageResumed = null;
     }
     if (this._onCompactDone && typeof window !== "undefined") {
@@ -5178,20 +5505,40 @@ class AparteConversationController {
    * that was partially written before a switch or component destruction.
    */
   /**
-   * Save once the binding holds the summary a compaction announced. A transcript kept in
-   * a framework store reaches the binding only when that framework renders, so a save on
-   * the microtask wrote the conversation as it stood before the compaction. Bounded: a
-   * run with no summary (skipped), or a binding that never shows it, is saved as it is.
-   */
-  _persistOnceSummarised(summary, waits) {
-    const holds = !summary || this._binding.getMessages().some(
-      (m) => m.compaction === true && typeof m.content === "string" && m.content.endsWith(summary)
-    );
+   * Save once the binding holds what a compaction (or a Restore) announced. A transcript
+   * kept in a framework store reaches the binding only when that framework renders, so a
+   * save on the microtask wrote the conversation as it stood before the change. Bounded:
+   * a run that changed nothing (skipped), or a binding that never shows the change, is
+   * saved as it is.
+   *
+   * What "holds" means follows what the run said it did:
+   * - a checkpoint — `messageId` names the message carrying it, and it holds once that
+   *   message carries a `contextSummary` with its `createdAt` (a summary without the
+   *   stamp is a half-written one);
+   * - a Restore — it holds once no message of the path carries a checkpoint any more;
+   * - an older host's summary MESSAGE (`compaction: true`, ending with the summary).
+   * A run that names none of these has nothing to wait for.
+   */
+  _persistOnceSummarised(detail, waits) {
+    const messages = this._binding.getMessages();
+    let holds = true;
+    if (detail.restored) {
+      holds = !messages.some((m) => m.contextSummary !== void 0);
+    } else if (detail.messageId || detail.summary) {
+      const { messageId, summary } = detail;
+      const checkpointed = !!messageId && messages.some(
+        (m) => m.id === messageId && typeof m.contextSummary?.createdAt === "number"
+      );
+      const summaryMessage = !!summary && messages.some(
+        (m) => m.compaction === true && typeof m.content === "string" && m.content.endsWith(summary)
+      );
+      holds = checkpointed || summaryMessage;
+    }
     if (holds || !this._binding.afterRender || waits >= MAX_COMPACTION_SAVE_WAITS) {
       this._persistActive();
       return;
     }
-    this._binding.afterRender(() => this._persistOnceSummarised(summary, waits + 1));
+    this._binding.afterRender(() => this._persistOnceSummarised(detail, waits + 1));
   }
   _persistActive() {
     if (!this._activeId) return;
@@ -5269,16 +5616,126 @@ function gateGlide(el2) {
   el2.addEventListener("aparte-send", lift);
   return off;
 }
+function chatIdOf(el2) {
+  let node = el2.parentElement;
+  while (node) {
+    const isHost = node.tagName.toLowerCase() === "aparte-chat" || node.hasAttribute("data-aparte-chat");
+    if (isHost && node.id) return node.id;
+    node = node.parentElement;
+  }
+  return void 0;
+}
+class CheckpointStateWatcher {
+  constructor(_options) {
+    this._options = _options;
+  }
+  _messageId = null;
+  _state = null;
+  _reason = "";
+  /** The bubble the attributes were last written to, so they can be taken off it even after it left the lookup. */
+  _marked = null;
+  /** Listen on `window` for the three events; returns the function that stops. */
+  start() {
+    const mine = (targetId) => {
+      if (this._options.active && !this._options.active()) return false;
+      return !targetId || targetId === this._options.ownId();
+    };
+    const mineMessage = (messageId) => !!messageId && this._options.owns(messageId);
+    const onStart = (e) => {
+      const detail = e.detail;
+      if (!mine(detail?.targetId) || !mineMessage(detail?.messageId)) return;
+      this.clear();
+      this._set(detail.messageId, "pending", "");
+    };
+    const onDone = (e) => {
+      const detail = e.detail;
+      if (!mine(detail?.targetId) || detail?.skipped) return;
+      if (detail?.messageId && detail.messageId === this._messageId) this.clear();
+    };
+    const onError = (e) => {
+      const detail = e.detail;
+      if (!mine(detail?.targetId) || !mineMessage(detail?.messageId)) return;
+      if (detail.aborted) {
+        if (detail.messageId === this._messageId) this.clear();
+        return;
+      }
+      if (detail.messageId !== this._messageId) this.clear();
+      this._set(detail.messageId, "failed", detail.error ?? "");
+    };
+    window.addEventListener("aparte-compact-start", onStart);
+    window.addEventListener("aparte-compact-done", onDone);
+    window.addEventListener("aparte-compact-error", onError);
+    return () => {
+      window.removeEventListener("aparte-compact-start", onStart);
+      window.removeEventListener("aparte-compact-done", onDone);
+      window.removeEventListener("aparte-compact-error", onError);
+    };
+  }
+  /** Take the state off the bubble and forget it. */
+  clear() {
+    const bubble = this._marked ?? (this._messageId ? this._options.bubbleOf(this._messageId) : null);
+    this._messageId = null;
+    this._state = null;
+    this._reason = "";
+    this._marked = null;
+    bubble?.removeAttribute("data-checkpoint");
+    bubble?.removeAttribute("data-checkpoint-reason");
+  }
+  /** Write the remembered state onto the bubble, which may have been created since. */
+  reapply() {
+    if (!this._messageId || !this._state) return;
+    this._write(this._messageId, this._state, this._reason);
+  }
+  _set(messageId, state, reason) {
+    this._messageId = messageId;
+    this._state = state;
+    this._reason = reason;
+    this._write(messageId, state, reason);
+  }
+  _write(messageId, state, reason) {
+    const bubble = this._options.bubbleOf(messageId);
+    if (!bubble) return;
+    if (this._marked && this._marked !== bubble) {
+      this._marked.removeAttribute("data-checkpoint");
+      this._marked.removeAttribute("data-checkpoint-reason");
+    }
+    this._marked = bubble;
+    if (reason) bubble.setAttribute("data-checkpoint-reason", reason);
+    else bubble.removeAttribute("data-checkpoint-reason");
+    if (bubble.getAttribute("data-checkpoint") !== state) bubble.setAttribute("data-checkpoint", state);
+  }
+}
 const MAX_SIBLING_RETRIES = 6;
 const TREE_OWNED_FIELDS = /* @__PURE__ */ new Set(["id", "branches", "activeBranchIndex", "isStreaming"]);
 const ALWAYS_PRESENT_FIELDS = /* @__PURE__ */ new Set(["content", "segments", "status"]);
+const RENDERED_FIELDS = ["content", "segments", "attachments", "usage", "finishReason", "contextSummary", "compaction"];
 class AparteChatHost {
   binding;
   options;
   /** Id of the assistant message currently streaming (null when idle). */
   _streamingId = null;
-  /** Message ids already reconciled onto a bubble (skip-rerender cache). */
-  _renderedIds = /* @__PURE__ */ new Set();
+  /**
+   * The message object each bubble was last drawn from, by id (skip-rerender cache).
+   *
+   * An id alone could not say whether the list had changed under a bubble: a framework
+   * that owns the transcript (a controlled `messages` prop, a v-model, a store behind a
+   * compaction target) never goes through {@link updateMessage}, it hands over a list
+   * with a NEW object for the message it changed, and a checkpoint written that way to a
+   * message that was not the last never reached its bubble. Immutable updates always
+   * produce a new object, so the reference is the signal; the same object again means
+   * nothing changed and the bubble is left alone.
+   */
+  _renderedIds = /* @__PURE__ */ new Map();
+  /**
+   * Says on the bubble what a compaction is doing to the message it will sit on. The
+   * viewport answers for this in a chat with no framework; here the framework owns the
+   * list and the host is the one that knows which bubble is whose.
+   */
+  _checkpointState = new CheckpointStateWatcher({
+    ownId: () => this.binding.hostId,
+    bubbleOf: (id) => this._bubbleById(id),
+    owns: (id) => this.binding.getMessages().some((m) => m.id === id)
+  });
   /** Sibling info from the last path-change, applied after the next render. */
   _pendingSiblings;
   /** How many render passes the sibling write has waited for — see `_applyPendingSiblings`. */
@@ -5302,6 +5759,12 @@ class AparteChatHost {
   _tokenBuffer = null;
   /** Handle of the scheduled coalesced sync, or null when none is pending. */
   _flushHandle = null;
+  /**
+   * Lists reported through `onMessagesChange` that the parent has not handed back yet, oldest
+   * first — what {@link takeEcho} recognises. Bounded: a parent that never hands a list back
+   * (an uncontrolled chat) must not make it grow for the life of the page.
+   */
+  _pendingEchoes = [];
   _conversationId = null;
   _controller;
   _teardown = [];
@@ -5311,6 +5774,34 @@ class AparteChatHost {
     this.options = options;
     this._conversationId = options.conversationId ?? null;
   }
+  /** Every report goes through here, so {@link takeEcho} knows what the parent may hand back. */
+  _report(next) {
+    this._pendingEchoes.push(next);
+    if (this._pendingEchoes.length > 64) this._pendingEchoes.shift();
+    this.binding.onMessagesChange?.(next);
+  }
+  /**
+   * Whether a list the parent hands back is this host's own report coming back — the echo of
+   * `onMessagesChange` through a two-way binding (`bind:messages`, `v-model:messages`,
+   * `[(messages)]`, a controlled React prop). A wrapper asks before applying the list it is
+   * given, because applying an echo rolls back what the host did since without reporting (an
+   * optimistic append).
+   *
+   * True for a list reported and not handed back yet, however late it lands — a parent whose
+   * render comes after the host's next write hands back an EARLIER report — and that list and
+   * every older one are taken. False for any other list, the parent's own word, which clears
+   * them: a list the parent restores later (a reopened conversation, an undo) is applied,
+   * where remembering every list ever reported swallowed it.
+   */
+  takeEcho(list) {
+    const i = this._pendingEchoes.indexOf(list);
+    if (i < 0) {
+      this._pendingEchoes.length = 0;
+      return false;
+    }
+    this._pendingEchoes.splice(0, i + 1);
+    return true;
+  }
   // ── lifecycle ──────────────────────────────────────────────────────────
   /**
    * Install the host-method surface + event listeners and create the
@@ -5320,19 +5811,20 @@ class AparteChatHost {
   bind() {
     if (this._bound) return () => this.unbind();
     this._bound = true;
-    const host = this.binding.host;
-    if (!host.id) host.id = this.binding.hostId;
+    const host2 = this.binding.host;
+    if (!host2.id) host2.id = this.binding.hostId;
     if (this.options.config) attachConfig(this.binding.host, this.options.config);
     const vp = this._vp();
     vp?.setFrameworkManagedDOM?.(true);
     if (this.options.layoutTransitionMs && this.options.layoutTransitionMs > 0) {
       vp?.configure?.({ layoutTransitionMs: this.options.layoutTransitionMs });
     }
-    this._installHostMethods(host);
-    this._installLifecycleListeners(host);
-    this._teardown.push(gateGlide(host));
+    this._installHostMethods(host2);
+    this._installLifecycleListeners(host2);
+    this._teardown.push(this._checkpointState.start());
+    this._teardown.push(gateGlide(host2));
     this._installViewportListeners();
-    this._createController(host);
+    this._createController(host2);
     return () => this.unbind();
   }
   unbind() {
@@ -5378,10 +5870,10 @@ class AparteChatHost {
     return this._controller?.setConversationId(id) ?? Promise.resolve();
   }
   _unbindController;
-  _createController(host) {
+  _createController(host2) {
     const convBinding = {
       hostId: this.binding.hostId,
-      host,
+      host: host2,
       // Controller-driven flushes mirror AparteConversationManager state, not
       // user intent — deliberately NOT emitted as `messagesChange` to
       // avoid a feedback loop with hosts using a two-way `messages` input.
@@ -5443,6 +5935,7 @@ class AparteChatHost {
     this._setStreamingId(null);
     this.binding.onTypingChange?.(false);
     this._renderedIds.clear();
+    this._checkpointState.clear();
     this.binding.resetComposer?.();
   }
   // ── host method surface (also installed on the host element) ───────────
@@ -5488,10 +5981,17 @@ class AparteChatHost {
     const merged = { ...next[index], ...updates };
     next[index] = merged;
     this.binding.setMessages(next);
-    this.binding.onMessagesChange?.(next);
+    this._report(next);
     if (updates.status) {
       this._bubbleById(messageId)?.updateMessage?.({ status: updates.status });
     }
+    if (index !== msgs.length - 1 && RENDERED_FIELDS.some((key) => key in updates)) {
+      this._renderedIds.delete(messageId);
+      const bubble = this._bubbleById(messageId);
+      if (bubble && ("contextSummary" in updates || "compaction" in updates)) {
+        bubble.setContextSummary?.(merged.contextSummary, { legacy: merged.compaction === true });
+      }
+    }
     if (isTerminalStatus(merged.status) && merged.segments) {
       for (const id of openSegmentIds(merged.segments)) {
         this.updateSegment(id, { isStreaming: false });
@@ -5508,7 +6008,7 @@ class AparteChatHost {
     const newContent = options?.append ? (last.content || "") + content : content;
     const next = [...msgs.slice(0, -1), { ...last, content: newContent }];
     this.binding.setMessages(next);
-    this.binding.onMessagesChange?.(next);
+    this._report(next);
   }
   /** Add a segment to the last message (immediate bubble + state sync). */
   addSegment(segment) {
@@ -5533,7 +6033,7 @@ class AparteChatHost {
     const segments = [...last.segments || [], stamped];
     const next = [...msgs.slice(0, -1), { ...last, segments }];
     this.binding.setMessages(next);
-    this.binding.onMessagesChange?.(next);
+    this._report(next);
   }
   /** Update a segment in the last message in place. */
   updateSegment(segmentId, updates) {
@@ -5550,7 +6050,7 @@ class AparteChatHost {
     );
     const next = [...msgs.slice(0, -1), { ...last, segments }];
     this.binding.setMessages(next);
-    this.binding.onMessagesChange?.(next);
+    this._report(next);
   }
   /** Remove a transient segment (a status row the host added itself). */
   removeSegment(segmentId) {
@@ -5564,7 +6064,7 @@ class AparteChatHost {
     renumberSegments(segments);
     const next = [...msgs.slice(0, -1), { ...last, segments }];
     this.binding.setMessages(next);
-    this.binding.onMessagesChange?.(next);
+    this._report(next);
   }
   /**
    * Append text to a segment's content in the last message — the streaming path
@@ -5620,8 +6120,8 @@ class AparteChatHost {
       this._flushHandle = null;
     }
     const tokens = this._tokenBuffer;
-    const pending = this._segmentBuffer.size > 0 ? new Map(this._segmentBuffer) : null;
-    if (!tokens && !pending) return;
+    const pending2 = this._segmentBuffer.size > 0 ? new Map(this._segmentBuffer) : null;
+    if (!tokens && !pending2) return;
     this._tokenBuffer = null;
     this._segmentBuffer.clear();
     let msgs = this.binding.getMessages();
@@ -5635,11 +6135,11 @@ class AparteChatHost {
         changed = true;
       }
     }
-    if (pending) {
+    if (pending2) {
       const last = msgs[msgs.length - 1];
       if (last?.segments) {
         const segments = last.segments.map((s) => {
-          const buffered = pending.get(s.id);
+          const buffered = pending2.get(s.id);
           if (buffered === void 0 || !("content" in s)) return s;
           return {
             ...s,
@@ -5653,7 +6153,7 @@ class AparteChatHost {
     }
     if (!changed) return;
     this.binding.setMessages(msgs);
-    this.binding.onMessagesChange?.(msgs);
+    this._report(msgs);
   }
   /** Read the current message list. */
   getMessages() {
@@ -5686,7 +6186,7 @@ class AparteChatHost {
     const idx = msgs.findIndex((m) => m.id === messageId);
     const next = idx >= 0 ? msgs.slice(0, idx) : msgs;
     this.binding.setMessages(next);
-    this.binding.onMessagesChange?.(next);
+    this._report(next);
   }
   /** Keep up to and including a user message, drop later responses (retry). */
   truncateResponsesAfter(userMessageId) {
@@ -5695,7 +6195,7 @@ class AparteChatHost {
     const idx = msgs.findIndex((m) => m.id === userMessageId);
     const next = idx >= 0 ? msgs.slice(0, idx + 1) : msgs;
     this.binding.setMessages(next);
-    this.binding.onMessagesChange?.(next);
+    this._report(next);
   }
   // ── manual token streaming (agnostic core of injectTokenStream) ─────────
   /**
@@ -5723,14 +6223,14 @@ class AparteChatHost {
       }
       ac.signal.addEventListener("abort", () => resolve("aborted"), { once: true });
     });
-    const { host, hostId } = this.binding;
+    const { host: host2, hostId } = this.binding;
     const onAbort = (e) => {
       const target = e.detail?.targetId;
       if ((!target || target === hostId) && this._streamAbort === ac) this.stopTokenStream();
     };
     window.addEventListener("aparte-abort", onAbort);
     const replaced = () => this._streamAbort !== void 0 && this._streamAbort !== ac;
-    dispatchLifecycleEvent(host, "aparte-message-start", { messageId, role: "assistant" }, hostId);
+    dispatchLifecycleEvent(host2, "aparte-message-start", { messageId, role: "assistant" }, hostId);
     try {
       for (; ; ) {
         const res = await Promise.race([iterator.next(), aborted]);
@@ -5743,7 +6243,7 @@ class AparteChatHost {
       if (!replaced()) {
         this._setStreamingId(null);
         dispatchLifecycleEvent(
-          host,
+          host2,
           ac.signal.aborted ? "aparte-message-aborted" : "aparte-message-done",
           ac.signal.aborted ? { messageId } : { messageId, role: "assistant" },
           hostId
@@ -5753,7 +6253,7 @@ class AparteChatHost {
       this._flushStreamState();
       if (!replaced()) {
         this._setStreamingId(null);
-        dispatchLifecycleEvent(host, "aparte-message-error", { messageId, error: err }, hostId);
+        dispatchLifecycleEvent(host2, "aparte-message-error", { messageId, error: err }, hostId);
       }
       throw err;
     } finally {
@@ -5790,18 +6290,20 @@ class AparteChatHost {
   /**
    * Reconcile rendered bubbles with the current message list. The framework
    * calls this from its reactive message-change hook after rendering; the
-   * last message is always re-synced (streaming), others only once.
+   * last message is always re-synced (streaming), the others whenever the list
+   * holds a different object for them than the one they were drawn from.
    */
   syncBubbles() {
     const msgs = this.binding.getMessages();
     msgs.forEach((message, index) => {
       const isLast = index === msgs.length - 1;
-      if (this._renderedIds.has(message.id) && !isLast) return;
+      if (this._renderedIds.get(message.id) === message && !isLast) return;
       const bubble = this._bubbleById(message.id);
       if (!bubble) return;
       populateBubbleFromMessage(bubble, message);
-      this._renderedIds.add(message.id);
+      this._renderedIds.set(message.id, message);
     });
+    this._checkpointState.reapply();
   }
   /**
    * Rebuild the viewport's internal repo from the message list before branch
@@ -5911,22 +6413,23 @@ class AparteChatHost {
     const all = vp.querySelectorAll("aparte-chat-bubble");
     return all.length ? all[all.length - 1] : null;
   }
-  _installHostMethods(host) {
-    host["appendMessage"] = (m) => this.appendMessage(m);
-    host["updateMessage"] = (id, u) => this.updateMessage(id, u);
-    host["updateLastMessage"] = (c, o) => this.updateLastMessage(c, o);
-    host["addSegment"] = (s) => this.addSegment(s);
-    host["updateSegment"] = (id, u) => this.updateSegment(id, u);
-    host["removeSegment"] = (id) => this.removeSegment(id);
-    host["appendToSegment"] = (id, c) => this.appendToSegment(id, c);
-    host["getMessages"] = () => this.getMessages();
-    host["addBranch"] = (id) => this.addBranch(id);
-    host["addSiblingOf"] = (id, m) => this.addSiblingOf(id, m);
-    host["truncateFrom"] = (id) => this.truncateFrom(id);
-    host["truncateResponsesAfter"] = (id) => this.truncateResponsesAfter(id);
-    host["clearAll"] = (options) => this.clearMessages(options);
-  }
-  _installLifecycleListeners(host) {
+  _installHostMethods(host2) {
+    host2["appendMessage"] = (m) => this.appendMessage(m);
+    host2["updateMessage"] = (id, u) => this.updateMessage(id, u);
+    host2["updateLastMessage"] = (c, o) => this.updateLastMessage(c, o);
+    host2["addSegment"] = (s) => this.addSegment(s);
+    host2["updateSegment"] = (id, u) => this.updateSegment(id, u);
+    host2["removeSegment"] = (id) => this.removeSegment(id);
+    host2["appendToSegment"] = (id, c) => this.appendToSegment(id, c);
+    host2["getMessages"] = () => this.getMessages();
+    host2["getMessage"] = (id) => this.binding.getMessages().find((m) => m.id === id);
+    host2["addBranch"] = (id) => this.addBranch(id);
+    host2["addSiblingOf"] = (id, m) => this.addSiblingOf(id, m);
+    host2["truncateFrom"] = (id) => this.truncateFrom(id);
+    host2["truncateResponsesAfter"] = (id) => this.truncateResponsesAfter(id);
+    host2["clearAll"] = (options) => this.clearMessages(options);
+  }
+  _installLifecycleListeners(host2) {
     const onStart = (e) => {
       const d = e?.detail;
       if (d?.messageId) this._setStreamingId(d.messageId);
@@ -5946,7 +6449,7 @@ class AparteChatHost {
         (m) => m.id === d.messageId ? { ...m, usage: d.usage } : m
       );
       this.binding.setMessages(next);
-      this.binding.onMessagesChange?.(next);
+      this._report(next);
       this._bubbleById(d.messageId)?.setUsage?.(d.usage);
     };
     const onEnd = (e) => {
@@ -5954,15 +6457,15 @@ class AparteChatHost {
       this.binding.onTypingChange?.(false);
       this._setStreamingId(null);
     };
-    host.addEventListener("aparte-message-start", onStart);
-    host.addEventListener("aparte-message-done", onDone);
-    host.addEventListener("aparte-message-error", onEnd);
-    host.addEventListener("aparte-message-aborted", onEnd);
+    host2.addEventListener("aparte-message-start", onStart);
+    host2.addEventListener("aparte-message-done", onDone);
+    host2.addEventListener("aparte-message-error", onEnd);
+    host2.addEventListener("aparte-message-aborted", onEnd);
     this._teardown.push(() => {
-      host.removeEventListener("aparte-message-start", onStart);
-      host.removeEventListener("aparte-message-done", onDone);
-      host.removeEventListener("aparte-message-error", onEnd);
-      host.removeEventListener("aparte-message-aborted", onEnd);
+      host2.removeEventListener("aparte-message-start", onStart);
+      host2.removeEventListener("aparte-message-done", onDone);
+      host2.removeEventListener("aparte-message-error", onEnd);
+      host2.removeEventListener("aparte-message-aborted", onEnd);
     });
   }
   _installViewportListeners() {
@@ -5979,7 +6482,7 @@ class AparteChatHost {
         return old?.usage !== void 0 ? { ...m, usage: old.usage } : m;
       });
       this.binding.setMessages(merged);
-      this.binding.onMessagesChange?.(merged);
+      this._report(merged);
       if (evt.detail.siblings.some((s) => s.count > 1)) {
         this._pendingSiblings = evt.detail.siblings;
         this.binding.afterRender(() => this._applyPendingSiblings());
@@ -5994,6 +6497,37 @@ class AparteChatHost {
     });
   }
 }
+function historyFromCheckpoint(path) {
+  for (let i = path.length - 1; i >= 0; i--) {
+    const summary = path[i].contextSummary?.summary;
+    if (summary !== void 0) return { summary, messages: path.slice(i) };
+  }
+  return { messages: path };
+}
+const COMPACTION_PREAMBLE = "The earlier part of this conversation was compacted. This is a summary of what came before; continue from it.";
+const underPreamble = (text) => `${COMPACTION_PREAMBLE}
+
+${text}`;
+function mergeAdjacentUserMessages(messages) {
+  const asParts = (c) => typeof c === "string" ? [{ type: "text", text: c }] : c;
+  const out = [];
+  for (const m of messages) {
+    const prev = out[out.length - 1];
+    if (m.role !== "user" || prev?.role !== "user") {
+      out.push(m);
+    } else if (typeof prev.content === "string" && typeof m.content === "string") {
+      out[out.length - 1] = { ...prev, content: `${prev.content}
+
+${m.content}` };
+    } else {
+      out[out.length - 1] = {
+        ...prev,
+        content: [...asParts(prev.content), { type: "text", text: "\n\n" }, ...asParts(m.content)]
+      };
+    }
+  }
+  return out;
+}
 const STOPPED_TOOL_TEXT = "The tool call was stopped before it ran.";
 const EMPTY_TOOL_TEXT = "The tool returned no output.";
 function answerOf(segment) {
@@ -6044,6 +6578,139 @@ function wireTurns(message, textOf, options = {}) {
   flush();
   return out;
 }
+const isInFlight = (m) => m.status === "streaming" || m.status === "pending";
+function segmentsToWireText(segments) {
+  if (!segments?.length) return "";
+  const fence = "```";
+  const parts = [];
+  for (const segment of segments) {
+    const content = segment.content;
+    if (segment.type === "text") {
+      if (content) parts.push(content);
+    } else if (segment.type === "code") {
+      const lang = segment.language ?? "";
+      parts.push(`${fence}${lang}
+${content ?? ""}
+${fence}`);
+    } else if (segment.type === "thinking" || segment.type === "tool_call" || segment.type === "error") {
+      continue;
+    } else if (typeof content === "string" && content) {
+      parts.push(content);
+    } else {
+      const fallback = segment.fallback;
+      if (fallback) parts.push(fallback);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function extractWireText(message) {
+  const rendered = segmentsToWireText(message.segments);
+  if (rendered) return rendered;
+  if (typeof message.content === "string" && message.content) return message.content;
+  return "";
+}
+function messageWireText(message) {
+  const text = extractWireText(message);
+  return message.compaction ? underPreamble(text) : text;
+}
+function wireMessages(messages) {
+  return messages.filter((m) => {
+    if (m.role !== "user" && m.role !== "assistant") return false;
+    return m.status !== "error" && !isInFlight(m);
+  }).flatMap((m) => {
+    if (m.role === "assistant" && m.segments?.some((s) => s.type === "tool_call")) {
+      return wireTurns(m, segmentsToWireText);
+    }
+    const content = messageWireText(m);
+    return content ? [{ role: m.role, content }] : [];
+  });
+}
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 3.8);
+}
+const estimateJson = (value) => {
+  if (!value) return 0;
+  try {
+    return estimateTokens(JSON.stringify(value));
+  } catch {
+    return 0;
+  }
+};
+function estimateChatTokens(messages) {
+  let total = 0;
+  for (const message of messages) {
+    total += estimateTokens(contentToText(message.content));
+    if (message.toolCalls?.length) total += estimateJson(message.toolCalls);
+  }
+  return total;
+}
+function carriesNonTextParts(messages) {
+  return messages.some((m) => typeof m.content !== "string" && m.content.some((p) => p.type !== "text"));
+}
+function estimateRequestTokens(request) {
+  const declared = (request.tools ?? []).map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }));
+  return estimateChatTokens(request.messages) + (declared.length ? estimateJson(declared) : 0);
+}
+function estimateWireTokens(messages) {
+  return estimateChatTokens(wireMessages(messages));
+}
+const usageTokens = (usage) => usage.totalTokens ?? usage.inputTokens + usage.outputTokens;
+function toolsForCurrentModel(config) {
+  const capabilities = config.getCurrentModel()?.capabilities;
+  const declinesTools = capabilities ? !capabilities.includes("function_calling") : false;
+  return declinesTools ? [] : config.getTools();
+}
+function windowOf(config, windowOverride) {
+  if (typeof windowOverride === "number" && Number.isFinite(windowOverride) && windowOverride > 0) return windowOverride;
+  const declared = config.getCurrentModel()?.contextWindow;
+  return declared && declared > 0 ? declared : void 0;
+}
+const hasSegment = (message, type) => message.segments?.some((s) => s.type === type) === true;
+function calibration(reply) {
+  const sent = reply.usage?.inputTokens;
+  const recorded = reply.contextEstimate;
+  if (hasSegment(reply, "tool_call")) return 1;
+  return sent && recorded && sent > 0 && recorded > 0 ? Math.min(3, Math.max(0.5, sent / recorded)) : 1;
+}
+function nextRequestTokens(reply, k) {
+  const usage = reply.usage;
+  if (!hasSegment(reply, "thinking") || !(usage.inputTokens > 0)) return usageTokens(usage);
+  const segments = reply.segments ?? [];
+  const lastCall = segments.map((s) => s.type).lastIndexOf("tool_call");
+  const said = Math.round(k * estimateTokens(segmentsToWireText(segments.slice(lastCall + 1))));
+  return usage.inputTokens + (usage.outputTokens > 0 ? Math.min(said, usage.outputTokens) : said);
+}
+function measureContext(input) {
+  const { messages, config } = input;
+  const view = historyFromCheckpoint(messages);
+  const system = estimateTokens(config.resolveSystemPrompt()) + estimateTokens(config.resolveToolSystemPrompts());
+  const declared = toolsForCurrentModel(config).map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }));
+  const tools = declared.length ? estimateJson(declared) : 0;
+  const summary = view.summary === void 0 ? 0 : estimateTokens(underPreamble(view.summary));
+  const parts = { system, tools, summary, messages: estimateWireTokens(view.messages) };
+  const total = system + tools + summary + parts.messages;
+  let replyIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant" && messages[i].usage) {
+      replyIndex = i;
+      break;
+    }
+  }
+  const reply = replyIndex >= 0 ? messages[replyIndex] : void 0;
+  const window2 = windowOf(config, input.windowOverride);
+  const result = (used, estimated) => ({
+    ...window2 !== void 0 ? { window: window2 } : {},
+    used,
+    estimated,
+    parts,
+    other: Math.max(0, used - total)
+  });
+  const unchanged = reply !== void 0 && !input.viewChanged && replyIndex === messages.length - 1 && !messages.some((m) => m.contextSummary !== void 0 && m.contextSummary.createdAt > reply.timestamp);
+  const k = reply ? calibration(reply) : 1;
+  if (reply && unchanged) return result(nextRequestTokens(reply, k), false);
+  return result(Math.round(k * total), true);
+}
 function eventOrigin(e) {
   return e.composedPath?.()[0] ?? e.target;
 }
@@ -6580,7 +7247,6 @@ function buildApprovalPanel(message, options, onChange, details) {
 function requestUserInput(request) {
   return resolveConfig(request.target ?? null).requestUserInput(request);
 }
-const COMPACTION_PREAMBLE = "The earlier part of this conversation was compacted. This is a summary of what came before; continue from it.";
 const NOT_RUN_AFTER_A_REFUSAL = "Not run: an earlier call of the same step was refused.";
 const approvalKey = (call) => JSON.stringify([call.id, call.name, call.input]);
 const warnedUninlinedFiles = /* @__PURE__ */ new Set();
@@ -6600,12 +7266,37 @@ function remoteProvider(id) {
 }
 class AparteClient {
   _boundHandler = null;
+  /** Between `start()` and `stop()`: the listeners are on `window`. The send handler alone is
+   *  not the sign — the constructor prepares it without listening. */
+  _listening = false;
   _boundAbortHandler = null;
   _boundLoadedHandler = null;
   _boundRetryHandler = null;
   _boundEditHandler = null;
   _releaseKeyResolver = null;
   _isAborted = false;
+  /** Provider and model pairs whose window was already read again after a turn (see `_readWindowAfterTurn`). */
+  _windowReadFor = /* @__PURE__ */ new Set();
+  /**
+   * The current model's window, read again once after a turn when it had none.
+   *
+   * A local server that loads a model on its first request — LM Studio's just-in-time
+   * loading, Ollama — has no loaded window to report when the model list is fetched at
+   * start-up, so the model comes without one, and the gauge and the compaction have
+   * nothing to measure against. After a reply the model is loaded, and the provider's
+   * own probe finds it. Once per provider and model: a server that never says costs one
+   * request, not one per turn. The config announces the window when it appears.
+   */
+  async _readWindowAfterTurn() {
+    const config = this._config;
+    const model = config.getCurrentModel();
+    const providerId = config.getModelConfig().defaultProvider;
+    if (!model || model.contextWindow || !providerId) return;
+    const key = `${providerId}\0${model.id}`;
+    if (this._windowReadFor.has(key)) return;
+    this._windowReadFor.add(key);
+    await config.refreshProviderModels(providerId);
+  }
   /**
    * Does this window event belong to this client?
    *
@@ -6734,11 +7425,12 @@ class AparteClient {
     if (!this._boundLoadedHandler) {
       this._boundLoadedHandler = (e) => {
         if (!this._isForThisInstance(e)) return;
-        const host = e.target instanceof HTMLElement ? e.target : void 0;
-        void this.resumeDeferred(host ?? e.detail?.targetId);
+        const host2 = e.target instanceof HTMLElement ? e.target : void 0;
+        void this.resumeDeferred(host2 ?? e.detail?.targetId);
       };
     }
     window.addEventListener("aparte-conversation-loaded", this._boundLoadedHandler);
+    this._listening = true;
   }
   /**
    * Stop answering: abort the reply in flight, take this client's `keyResolver` off the
@@ -6748,7 +7440,8 @@ class AparteClient {
     this.abort();
     this._releaseKeyResolver?.();
     this._releaseKeyResolver = null;
-    if (!this._boundHandler) return;
+    if (!this._listening || !this._boundHandler) return;
+    this._listening = false;
     window.removeEventListener("aparte-send", this._boundHandler);
     this._boundHandler = null;
     if (this._boundAbortHandler) {
@@ -6885,19 +7578,23 @@ class AparteClient {
   async _streamTurn(targetElement, messageId, provider, messages, modelId, authConfig, opts) {
     const chatId = this._targetIdOf(targetElement);
     const registeredTools = this._toolsForCurrentModel();
-    let baseRequest = {
-      messages,
-      modelId,
-      stream: true,
-      tools: registeredTools.length ? registeredTools : void 0,
-      ...opts?.temperature !== void 0 ? { temperature: opts.temperature } : {}
+    const buildRequest = async (requestMessages2) => {
+      let built = {
+        messages: requestMessages2,
+        modelId,
+        stream: true,
+        tools: registeredTools.length ? registeredTools : void 0,
+        ...opts?.temperature !== void 0 ? { temperature: opts.temperature } : {}
+      };
+      if (this.options.requestInterceptor) {
+        built = await this.options.requestInterceptor(built);
+      }
+      if (built.toolChoice === "none") {
+        built = { ...built, tools: void 0 };
+      }
+      return built;
     };
-    if (this.options.requestInterceptor) {
-      baseRequest = await this.options.requestInterceptor(baseRequest);
-    }
-    if (baseRequest.toolChoice === "none") {
-      baseRequest = { ...baseRequest, tools: void 0 };
-    }
+    let baseRequest = await buildRequest(messages);
     if (this._isAborted) {
       dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
       this._updateMessage(targetElement, messageId, { status: "completed" });
@@ -6918,7 +7615,23 @@ class AparteClient {
     if (this._streamController !== streamController) this._streamController?.abort();
     this._streamController = streamController;
     this._turnsInFlight.add(messageId);
-    try {
+    const compactor = opts?.rebuild ? resolveConfig(targetElement).getCompactor() ?? this._config.getCompactor() : null;
+    const turnIds = () => {
+      const path = targetElement.getMessages?.() ?? [];
+      const at = path.findIndex((m) => m.id === messageId);
+      const asked = at > 0 ? path[at - 1] : void 0;
+      return asked?.role === "user" ? [asked.id, messageId] : [messageId];
+    };
+    const requestMessages = () => opts?.resume ? this._resumeMessages(targetElement, messageId, baseRequest.messages) : baseRequest.messages;
+    const requestEstimate = () => estimateRequestTokens({ messages: requestMessages(), tools: baseRequest.tools });
+    const recordedEstimate = () => carriesNonTextParts(requestMessages()) ? void 0 : requestEstimate();
+    const endStopped = () => {
+      this._closeOpenCalls(targetElement, messageId);
+      dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
+      this._updateMessage(targetElement, messageId, { status: "completed" });
+    };
+    const isStopped = () => this._isAborted || streamController.signal.aborted;
+    const runOnce = async () => {
       let result = opts?.resume ? { usage: void 0, suspended: opts.resume } : await this._streamLoop(targetElement, messageId, provider, baseRequest, authConfig, streamController);
       const maxResumes = this.options.maxTurns ?? 10;
       let resumes = 0;
@@ -6961,21 +7674,80 @@ class AparteClient {
         );
       }
       const usage = result.usage;
+      const finishReason = result.finishReason;
       if (this._isAborted || streamController.signal.aborted) {
         this._closeOpenCalls(targetElement, messageId);
         this._updateMessage(targetElement, messageId, { status: "completed" });
       } else {
-        dispatchLifecycleEvent(targetElement, "aparte-message-done", { messageId, role: "assistant", usage }, chatId);
+        dispatchLifecycleEvent(targetElement, "aparte-message-done", { messageId, role: "assistant", usage, ...finishReason ? { finishReason } : {} }, chatId);
+        void this._readWindowAfterTurn();
       }
-    } catch (error) {
-      this._closeOpenCalls(targetElement, messageId);
-      if (this._isAborted || streamController.signal.aborted) {
-        dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
-        this._updateMessage(targetElement, messageId, { status: "completed" });
-        return;
+    };
+    const resendAfterOverflow = async (error) => {
+      if (error.code !== AparteErrorCode.USAGE_CONTEXT_EXCEEDED || !compactor || !opts?.rebuild) return "stands";
+      const segments = targetElement.getMessage?.(messageId)?.segments ?? targetElement.getMessages?.()?.find((m) => m.id === messageId)?.segments ?? [];
+      if (segments.some((s) => s.type === "text" || s.type === "tool_call")) return "stands";
+      try {
+        const outcome = await compactor.compact({
+          target: targetElement,
+          ...chatId ? { targetId: chatId } : {},
+          force: true,
+          reason: "overflow",
+          exclude: turnIds(),
+          signal: streamController.signal
+        });
+        if (isStopped()) return "stopped";
+        if (!outcome.ok || outcome.skipped) return "stands";
+        baseRequest = await buildRequest(await opts.rebuild());
+      } catch {
+        return "stands";
+      }
+      this._updateMessage(targetElement, messageId, { status: "pending" });
+      return "resend";
+    };
+    try {
+      for (let attempt = 0; ; attempt++) {
+        try {
+          if (attempt === 0 && compactor?.beforeSend && opts?.rebuild) {
+            let compacted = false;
+            try {
+              compacted = await compactor.beforeSend({
+                target: targetElement,
+                ...chatId ? { targetId: chatId } : {},
+                exclude: turnIds(),
+                requestTokens: requestEstimate(),
+                signal: streamController.signal
+              });
+            } catch (failure) {
+              console.warn("[AparteClient] The compactor threw before a send; sending the request as built.", failure);
+            }
+            if (isStopped()) {
+              endStopped();
+              return;
+            }
+            if (compacted) baseRequest = await buildRequest(await opts.rebuild());
+          }
+          this._updateMessage(targetElement, messageId, { contextEstimate: recordedEstimate() });
+          await runOnce();
+          return;
+        } catch (error) {
+          this._closeOpenCalls(targetElement, messageId);
+          if (isStopped()) {
+            dispatchLifecycleEvent(targetElement, "aparte-message-aborted", { messageId }, chatId);
+            this._updateMessage(targetElement, messageId, { status: "completed" });
+            return;
+          }
+          const aparteError = AparteError.from(error, AparteErrorCode.UNKNOWN_ERROR);
+          const next = attempt === 0 ? await resendAfterOverflow(aparteError) : "stands";
+          if (next === "resend") continue;
+          if (next === "stopped") {
+            endStopped();
+            return;
+          }
+          this._handleLifecycleError(targetElement, messageId, aparteError);
+          return;
+        }
       }
-      const aparteError = AparteError.from(error, AparteErrorCode.UNKNOWN_ERROR);
-      this._handleLifecycleError(targetElement, messageId, aparteError);
     } finally {
       this._turnsInFlight.delete(messageId);
     }
@@ -6990,29 +7762,12 @@ class AparteClient {
    * using the same conversation history minus the retried reply.
    */
   /**
-   * The registered tools, unless the current model says it cannot call one.
-   *
-   * Single source for the gate, so send / retry / edit cannot drift.
-   *
-   * The question is "did this model say it cannot", not "did it say it can": the
-   * app sets a model id by hand (`setModelConfig`) or a selector sets it from a
-   * fetched list, and in both cases the model's declared capabilities are commonly
-   * unknown. `undefined` capabilities read as "can", or `tools: []` would go on
-   * the wire while `getTools()` held the tool the app had explicitly registered,
-   * and the model would answer that it had no such tool. Registering a tool is an explicit act by the app; silently dropping it
-   * because a `/models` listing is terse is the library second-guessing the
-   * developer. A model that declares its capabilities and omits function calling
-   * is still honoured — that is a statement, and it is respected.
-   *
-   * Failure modes, both ways round: over-sending means a model that cannot use
-   * tools does not call one, or its own endpoint rejects the array with an error
-   * the developer can read. Under-sending would be silent, total, and look like a
-   * lying model.
+   * The registered tools, unless the current model says it cannot call one — the gate
+   * lives in `toolsForCurrentModel` (with its reasoning), where the context measure reads
+   * the same rule, so send / retry / edit and the gauge cannot drift.
    */
   _toolsForCurrentModel() {
-    const capabilities = this._config.getCurrentModel()?.capabilities;
-    const declinesTools = capabilities ? !capabilities.includes("function_calling") : false;
-    return declinesTools ? [] : this._config.getTools();
+    return toolsForCurrentModel(this._config);
   }
   async _handleRetry(event) {
     const { messageId, targetId } = event.detail ?? {};
@@ -7047,10 +7802,16 @@ class AparteClient {
       targetElement,
       newMessageId,
       provider,
-      [...systemMessages, ...chatMessages],
+      [...systemMessages, ...mergeAdjacentUserMessages(chatMessages)],
       config.defaultModel || "",
       authConfig,
-      { temperature: 0.4 }
+      {
+        temperature: 0.4,
+        rebuild: async () => [
+          ...this._systemMessages(),
+          ...mergeAdjacentUserMessages(this._messagesToChatMessages(this._current(targetElement, historyMessages)))
+        ]
+      }
     );
   }
   /**
@@ -7113,11 +7874,27 @@ class AparteClient {
       targetElement,
       newMessageId,
       provider,
-      [...systemMessages, ...chatMessages],
+      [...systemMessages, ...mergeAdjacentUserMessages(chatMessages)],
       config.defaultModel || "",
-      authConfig
+      authConfig,
+      {
+        rebuild: async () => [
+          ...this._systemMessages(),
+          ...mergeAdjacentUserMessages(this._messagesToChatMessages(this._current(targetElement, historyMessages)))
+        ]
+      }
     );
   }
+  /**
+   * These messages as the transcript holds them NOW. A retry or an edit slices the path
+   * before it streams; a compaction that runs during the turn writes its checkpoint onto
+   * one of those messages in the transcript, and the slice still holds the objects as they
+   * were. Looked up by id, tree-wide, because a retry has moved the path since.
+   */
+  _current(target, messages) {
+    const live2 = new Map((target.getMessages?.() ?? []).map((m) => [m.id, m]));
+    return messages.map((m) => target.getMessage?.(m.id) ?? live2.get(m.id) ?? m);
+  }
   /**
    * The chain the gesture really came up, nearest node first.
    *
@@ -7251,29 +8028,17 @@ class AparteClient {
    * imitating.
    */
   _messagesToChatMessages(messages) {
-    return this._wireHistory(messages);
+    const { summary, messages: kept } = historyFromCheckpoint(messages);
+    return [...this._summaryMessage(summary), ...wireMessages(kept)];
   }
   /**
-   * The one rule for what a message contributes to the wire.
-   *
-   * Not the slice — the contribution: a role the wire has (`user`/`assistant`), a
-   * turn that neither failed nor is still in flight, and text that is not empty.
-   *
-   * `_wireText` (not `m.content`): assistant replies stream their text into
-   * `segments`, leaving `content` as '', so without flattening every reply would be
-   * empty here and the drop below would swallow the whole transcript.
-   */
-  _wireHistory(messages) {
-    return messages.filter((m) => {
-      if (m.role !== "user" && m.role !== "assistant") return false;
-      return m.status !== "error" && !AparteClient._inFlight(m);
-    }).flatMap((m) => {
-      if (m.role === "assistant" && m.segments?.some((s) => s.type === "tool_call")) {
-        return wireTurns(m, (segments) => this._segmentsToText(segments));
-      }
-      const content = this._wireText(m);
-      return content ? [{ role: m.role, content }] : [];
-    });
+   * What the model reads in place of everything before a checkpoint: the summary, as a
+   * `user` message under the same preamble a legacy compaction message gets, so it is
+   * context and not something the person said. It may sit right before a user turn;
+   * `mergeAdjacentUserMessages` joins the two where the history is assembled.
+   */
+  _summaryMessage(summary) {
+    return summary === void 0 ? [] : [{ role: "user", content: underPreamble(summary) }];
   }
   /** The "no model selected" warning is said once per client, not once per dropped send. */
   _warnedNoModel = false;
@@ -7363,12 +8128,14 @@ class AparteClient {
     });
     let authConfig;
     let messages;
+    let fileParts;
     try {
       authConfig = providerId ? await this._resolveAuth(providerId) : void 0;
       const rawFiles = Array.isArray(event.detail?.files) ? event.detail.files : [];
       const filesToInject = this._selectFilesToInject(rawFiles);
       const contentParts = filesToInject.length > 0 ? await this._filesToContentParts(filesToInject) : [];
-      messages = this._buildMessages(content, targetElement, contentParts.length > 0 ? contentParts : void 0);
+      fileParts = contentParts.length > 0 ? contentParts : void 0;
+      messages = this._buildMessages(content, targetElement, fileParts);
     } catch (error) {
       this._handleLifecycleError(targetElement, messageId, AparteError.from(error, AparteErrorCode.UNKNOWN_ERROR));
       return;
@@ -7379,7 +8146,8 @@ class AparteClient {
       provider,
       messages,
       modelId || config.defaultModel || "",
-      authConfig
+      authConfig,
+      { rebuild: async () => this._buildMessages(content, targetElement, fileParts) }
     );
   }
   /**
@@ -7396,101 +8164,18 @@ class AparteClient {
     }
     const userMsg = parts && parts.length > 0 ? [{ type: "text", text: userContent }, ...parts] : userContent;
     messages.push({ role: "user", content: userMsg });
-    return messages;
-  }
-  /**
-   * A turn that has not finished yet. `status` is OPTIONAL on `AparteMessage`, so
-   * the question the history gates can ask is "is this still in flight?", never
-   * "is this completed?".
-   *
-   * The gates below ask the first, because a host that SEEDS a transcript
-   * — restoring a saved conversation, hydrating a server-rendered one — has no
-   * reason to invent a status for turns that are already over. Asking "is this
-   * completed?" would leave the cutoff at 0 and slice away the whole transcript: the
-   * model would get the new question with no context, and nothing in the UI would say
-   * so, because the viewport still shows every message.
-   */
-  static _inFlight(m) {
-    return m.status === "streaming" || m.status === "pending";
+    return mergeAdjacentUserMessages(messages);
   }
-  _toHistoryMessages(messages) {
+  _toHistoryMessages(path) {
+    const { summary, messages } = historyFromCheckpoint(path);
     let cutoff = 0;
     for (let i = 0; i < messages.length; i++) {
       const m = messages[i];
-      if (m.role === "assistant" && m.status !== "error" && !AparteClient._inFlight(m)) {
+      if (m.role === "assistant" && m.status !== "error" && !isInFlight(m)) {
         cutoff = i + 1;
       }
     }
-    return this._wireHistory(messages.slice(0, cutoff));
-  }
-  /**
-   * A message's text as the MODEL should read it — the one mapper both history
-   * paths use, so the compaction preamble cannot be applied on retry and edit and
-   * forgotten on the ordinary send, which is what the first review of this feature
-   * caught: the summary went out on every normal turn as something the user said.
-   */
-  _wireText(message) {
-    const text = this._extractText(message);
-    return message.compaction ? `${COMPACTION_PREAMBLE}
-
-${text}` : text;
-  }
-  /**
-   * What the model is told it said last turn — reconstructed from what was
-   * RENDERED, not from the raw-text field.
-   *
-   * The segments are what the reader saw, so they come first. `content` is the
-   * fallback, and that is not vestigial: a non-streaming transport writes the whole
-   * reply there and creates no segments at all.
-   */
-  _extractText(message) {
-    const rendered = this._segmentsToText(message.segments);
-    if (rendered) return rendered;
-    if (typeof message.content === "string" && message.content) return message.content;
-    return "";
-  }
-  /**
-   * Segments → the text a model can read back.
-   *
-   * Fences and the language tag are kept. Without them the model re-reads its own
-   * code as prose — which is how it starts explaining a snippet it believes it
-   * wrote in English.
-   *
-   * A type core does not know — a registered block grammar's (an artifact, a
-   * citation, a file), a consumer's custom segment — follows one rule: its
-   * `content` if it has one, else its `fallback`, else nothing. Dropping such a
-   * segment would make a document the model had just produced invisible on the very
-   * next turn, so it could not be asked to change the thing it had built. An artifact
-   * is a plugin's type like any other and follows this rule.
-   *
-   * `thinking` and `tool_call` stay out on purpose — the first is the model's own
-   * scratchpad, and most APIs neither want it back nor bill for it kindly; the
-   * second is not text: `_wireHistory` sends a reply's calls as the assistant's
-   * `toolCalls` and the `tool` messages answering them (`wire-history.ts`).
-   */
-  _segmentsToText(segments) {
-    if (!segments?.length) return "";
-    const fence = "```";
-    const parts = [];
-    for (const segment of segments) {
-      const content = segment.content;
-      if (segment.type === "text") {
-        if (content) parts.push(content);
-      } else if (segment.type === "code") {
-        const lang = segment.language ?? "";
-        parts.push(`${fence}${lang}
-${content ?? ""}
-${fence}`);
-      } else if (segment.type === "thinking" || segment.type === "tool_call" || segment.type === "error") {
-        continue;
-      } else if (typeof content === "string" && content) {
-        parts.push(content);
-      } else {
-        const fallback = segment.fallback;
-        if (fallback) parts.push(fallback);
-      }
-    }
-    return parts.join("\n").trim();
+    return [...this._summaryMessage(summary), ...wireMessages(messages.slice(0, cutoff))];
   }
   /**
    * Which of the send's pending files get inlined into the request: the
@@ -7597,8 +8282,10 @@ ${content}
     });
     const prefixSegments = baseRequest._meta?.["prefixSegments"];
     let suspended;
+    let finishReason;
     const emitter = (event) => {
       adapter(event);
+      if (event.type === "run-done") finishReason = event.finishReason;
       if (event.type === "run-suspended") {
         const ticket = event.ticket;
         suspended = { pending: event.pending, ...typeof ticket === "string" ? { ticket } : {} };
@@ -7651,7 +8338,11 @@ ${content}
       // BARE uuid for the synthetic tool (the adapter renders `tool-<id>`).
       idGen: (prefix) => prefix === "synthetic-tool" ? uuid() : `${prefix}-${uuid()}`
     });
-    return { usage: usage ?? void 0, ...suspended ? { suspended } : {} };
+    return {
+      usage: usage ?? void 0,
+      ...finishReason ? { finishReason } : {},
+      ...suspended ? { suspended } : {}
+    };
   }
   /**
    * The approval channel a run asks through — and the one a paused server run's calls
@@ -7681,15 +8372,15 @@ ${content}
    * nobody answered — the turn was stopped, or the channel gave up — and there is no
    * resume. A channel that CRASHES fails the turn, as it does for a run in the page.
    */
-  async _answerDeferred(targetElement, pending, signal, rowEvents, approvedBefore = /* @__PURE__ */ new Set(), approvedNow = /* @__PURE__ */ new Set()) {
+  async _answerDeferred(targetElement, pending2, signal, rowEvents, approvedBefore = /* @__PURE__ */ new Set(), approvedNow = /* @__PURE__ */ new Set()) {
     const outcomes = {};
     const resolver = this._approvalResolverFor(targetElement, true);
     const refuseTheRest = (after) => {
-      for (const rest of pending.slice(after + 1)) {
+      for (const rest of pending2.slice(after + 1)) {
         outcomes[rest.toolCallId] = { kind: "decision", approved: false, reason: NOT_RUN_AFTER_A_REFUSAL, by: "earlier-refusal" };
       }
     };
-    for (const [index, p] of pending.entries()) {
+    for (const [index, p] of pending2.entries()) {
       if (signal.aborted) break;
       const call = { id: p.toolCallId, name: p.name, input: p.input ?? {} };
       if (p.reason === "approval") {
@@ -7802,7 +8493,7 @@ ${content}
    */
   _resumeMessages(targetElement, messageId, sent) {
     const reply = targetElement.getMessages?.().find((m) => m.id === messageId);
-    return [...sent, ...reply ? wireTurns(reply, (segments) => this._segmentsToText(segments), { openDeferred: true }) : []];
+    return [...sent, ...reply ? wireTurns(reply, segmentsToWireText, { openDeferred: true }) : []];
   }
   /**
    * What the send of a reloaded turn put before its reply, rebuilt the way
@@ -7817,7 +8508,11 @@ ${content}
     const askedAt = before.map((m) => m.role).lastIndexOf("user");
     const historyOption = this.options.history ?? "viewport";
     const history = historyOption === "viewport" ? this._toHistoryMessages(before) : typeof historyOption === "function" ? historyOption(before) : [];
-    return [...this._systemMessages(), ...history, ...askedAt >= 0 ? this._wireHistory([before[askedAt]]) : []];
+    return mergeAdjacentUserMessages([
+      ...this._systemMessages(),
+      ...history,
+      ...askedAt >= 0 ? wireMessages([before[askedAt]]) : []
+    ]);
   }
   /**
    * A new message closes a wait nobody answered. The paused calls of the last reply are
@@ -7849,8 +8544,8 @@ ${content}
    * @param target The chat — an element, or its id. Defaults to the one `targetResolver` names, else the first on the page.
    */
   async resumeDeferred(target) {
-    const host = typeof target === "string" ? this._byId(target) : target ?? this.options.targetResolver?.() ?? null;
-    const targetElement = host ? this._asRenderTarget(host) : this._scanForTarget();
+    const host2 = typeof target === "string" ? this._byId(target) : target ?? this.options.targetResolver?.() ?? null;
+    const targetElement = host2 ? this._asRenderTarget(host2) : this._scanForTarget();
     if (!targetElement) return false;
     const messages = targetElement.getMessages?.() ?? [];
     const last = [...messages].reverse().find((m) => m.role === "assistant");
@@ -7869,7 +8564,7 @@ ${content}
     this._resuming.add(last.id);
     try {
       const authConfig = provider.id ? await this._resolveAuth(provider.id) : void 0;
-      const pending = open.map((s) => ({
+      const pending2 = open.map((s) => ({
         toolCallId: s.toolCall.id,
         name: s.toolCall.name,
         input: s.toolCall.input,
@@ -7877,7 +8572,12 @@ ${content}
       }));
       const base = this._resumeBase(messages, messages.indexOf(last));
       await this._streamTurn(targetElement, last.id, provider, base, recorded?.modelId ?? config.defaultModel ?? "", authConfig, {
-        resume: { pending, ticket },
+        resume: { pending: pending2, ticket },
+        rebuild: async () => {
+          const now = targetElement.getMessages?.() ?? [];
+          const at = now.findIndex((m) => m.id === last.id);
+          return at >= 0 ? this._resumeBase(now, at) : base;
+        },
         ...recorded?.temperature !== void 0 ? { temperature: recorded.temperature } : {}
       });
     } finally {
@@ -7957,7 +8657,8 @@ function createAgentStreamRunner(options) {
     let ended = false;
     for await (const line of readNdjson(response.body, opts.signal)) {
       if (line.type === "run-error") {
-        throw new AparteError(line.message || "The agent run failed.", AparteErrorCode.PROVIDER_ERROR, line.code ? { code: line.code } : void 0);
+        const known2 = Object.values(AparteErrorCode).includes(line.code ?? "") ? line.code : void 0;
+        throw new AparteError(line.message || "The agent run failed.", known2 ?? AparteErrorCode.PROVIDER_ERROR, line.code ? { code: line.code } : void 0);
       }
       if (line.type === "run-done" || line.type === "run-suspended") {
         usage = line.usage;
@@ -8364,8 +9065,95 @@ function installDialogTriggersOnce(doc = document) {
   doc.addEventListener("pointerup", onPointerUp, true);
   doc.addEventListener("click", onClick);
 }
+const ATTR = "defer-hydration";
+const waiting = /* @__PURE__ */ new WeakMap();
+const holderOf = /* @__PURE__ */ new WeakMap();
+const pending = /* @__PURE__ */ new WeakSet();
+const live = /* @__PURE__ */ new WeakSet();
+const observers = /* @__PURE__ */ new WeakMap();
+const patched = /* @__PURE__ */ new WeakSet();
+function isHeld(el2) {
+  if (live.has(el2)) return false;
+  if (holderOf.has(el2)) return true;
+  const holder = el2.closest(`[${ATTR}]`);
+  if (!holder) return false;
+  holderOf.set(el2, holder);
+  let list = waiting.get(holder);
+  if (!list) {
+    list = [];
+    waiting.set(holder, list);
+    const observer = new MutationObserver(() => {
+      if (!holder.hasAttribute(ATTR)) release(holder);
+    });
+    observer.observe(holder, { attributes: true, attributeFilter: [ATTR] });
+    observers.set(holder, observer);
+  }
+  list.push(el2);
+  return true;
+}
+function release(holder) {
+  observers.get(holder)?.disconnect();
+  observers.delete(holder);
+  const list = waiting.get(holder) ?? [];
+  waiting.delete(holder);
+  for (const el2 of list) {
+    holderOf.delete(el2);
+    if (el2.isConnected && !live.has(el2)) el2.connectedCallback?.();
+  }
+}
+function releaseDeferredHydration(root) {
+  if (!root) return;
+  if (root.hasAttribute(ATTR)) root.removeAttribute(ATTR);
+  else if (!waiting.has(root)) return;
+  release(root);
+}
+function deferHydrationOf(ctor) {
+  if (patched.has(ctor)) return;
+  patched.add(ctor);
+  const proto = ctor.prototype;
+  const connected = proto.connectedCallback;
+  const changed = proto.attributeChangedCallback;
+  const disconnected = proto.disconnectedCallback;
+  const observed = ctor.observedAttributes ?? [];
+  proto.connectedCallback = function() {
+    if (isHeld(this)) {
+      pending.add(this);
+      return;
+    }
+    if (pending.has(this)) {
+      pending.delete(this);
+      for (const name of observed) {
+        const value = this.getAttribute(name);
+        if (value !== null) changed?.call(this, name, null, value);
+      }
+    }
+    live.add(this);
+    connected?.call(this);
+  };
+  if (changed) {
+    proto.attributeChangedCallback = function(name, oldValue, newValue) {
+      if (isHeld(this)) {
+        pending.add(this);
+        return;
+      }
+      changed.call(this, name, oldValue, newValue);
+    };
+  }
+  proto.disconnectedCallback = function() {
+    const holder = holderOf.get(this);
+    if (holder) {
+      holderOf.delete(this);
+      const list = waiting.get(holder);
+      if (list) list.splice(list.indexOf(this), 1);
+      return;
+    }
+    if (pending.has(this)) return;
+    live.delete(this);
+    disconnected?.call(this);
+  };
+}
 export {
-  registerSegmentRenderer as $,
+  isSegmentSettled as $,
   APARTE_CONFIG_CHANGE as A,
   contextConfig as B,
   copyText as C,
@@ -8376,53 +9164,70 @@ export {
   cssEscape as H,
   declineDefaultRenderers as I,
   defaultSanitizer as J,
-  detachConfig as K,
-  escapeAttr as L,
-  escapeHtml as M,
-  filesToAttachments as N,
-  getAllRenderers as O,
-  getSegmentRenderer as P,
-  installDefaultRenderersOnce as Q,
-  installDialogTriggersOnce as R,
-  isAwaitingReply as S,
-  isFormatAdapter as T,
-  isSafeUrl as U,
-  isSegmentSettled as V,
-  parseAparteEventStream as W,
-  parseMarkdownToSegments as X,
-  populateBubbleFromMessage as Y,
-  readableToAsyncIterable as Z,
-  registerDefaultRenderers as _,
+  deferHydrationOf as K,
+  defineMountedSegmentRenderer as L,
+  defineMountedToolRenderer as M,
+  detachConfig as N,
+  escapeAttr as O,
+  escapeHtml as P,
+  estimateTokens as Q,
+  estimateWireTokens as R,
+  filesToAttachments as S,
+  getAllRenderers as T,
+  getSegmentRenderer as U,
+  historyFromCheckpoint as V,
+  installDefaultRenderersOnce as W,
+  installDialogTriggersOnce as X,
+  isAwaitingReply as Y,
+  isFormatAdapter as Z,
+  isSafeUrl as _,
   APARTE_CONVERSATION_SCHEMA_VERSION as a,
-  requestUserInput as a0,
-  resolveConfig as a1,
-  revokeAttachmentUrls as a2,
-  runWithConfig as a3,
-  segmentDuration as a4,
-  segmentTiming as a5,
-  subscribeConfigChange as a6,
-  toolRefusal as a7,
-  unregisterSegmentRenderer as a8,
-  uuid as a9,
-  eventOrigin as aa,
-  activeElementIn as ab,
-  gateGlide as ac,
-  renderingVersionOf as ad,
-  mergeSegmentUpdate as ae,
-  writeStreamedMarkdown as af,
-  stampSegmentActivity as ag,
-  stampSegmentOnInsert as ah,
-  stampSegmentOnUpdate as ai,
-  renumberSegments as aj,
-  openSegmentIds as ak,
-  isTerminalStatus as al,
-  adoptMessageSegments as am,
-  APARTE_DERIVED_SEGMENTS as an,
-  rememberConversationStatus as ao,
-  tellConversationStatus as ap,
-  conversationStatusOf as aq,
-  chatBoundaryOf as ar,
-  rootOf as as,
+  measureContext as a0,
+  overrideSegmentRenderer as a1,
+  parseAparteEventStream as a2,
+  parseMarkdownToSegments as a3,
+  populateBubbleFromMessage as a4,
+  readableToAsyncIterable as a5,
+  registerDefaultRenderers as a6,
+  registerSegmentRenderer as a7,
+  releaseDeferredHydration as a8,
+  requestUserInput as a9,
+  renumberSegments as aA,
+  openSegmentIds as aB,
+  isTerminalStatus as aC,
+  adoptMessageSegments as aD,
+  APARTE_DERIVED_SEGMENTS as aE,
+  rememberConversationStatus as aF,
+  tellConversationStatus as aG,
+  conversationStatusOf as aH,
+  usageTokens as aI,
+  rootOf as aJ,
+  resolveConfig as aa,
+  revokeAttachmentUrls as ab,
+  runWithConfig as ac,
+  segmentDuration as ad,
+  segmentTiming as ae,
+  subscribeConfigChange as af,
+  toToolCallView as ag,
+  toolRefusal as ah,
+  unregisterSegmentRenderer as ai,
+  uuid as aj,
+  eventOrigin as ak,
+  activeElementIn as al,
+  gateGlide as am,
+  chatBoundaryOf as an,
+  toolCallRenderer as ao,
+  toolRendererThatDrew as ap,
+  isMountedRenderer as aq,
+  renderingVersionOf as ar,
+  onRenderersChange as as,
+  mergeSegmentUpdate as at,
+  writeStreamedMarkdown as au,
+  CheckpointStateWatcher as av,
+  chatIdOf as aw,
+  stampSegmentActivity as ax,
+  stampSegmentOnInsert as ay,
+  stampSegmentOnUpdate as az,
   APARTE_DEFAULT_BUBBLE_ACTIONS as b,
   APARTE_DEFAULT_HOST_HANDLERS as c,
   APARTE_DEFAULT_ICON_FALLBACKS as d,
@@ -8449,4 +9254,4 @@ export {
   collectRendererStyles as y,
   contentToText as z
 };
-//# sourceMappingURL=dialog-triggers-BqXRdHWZ.js.map
+//# sourceMappingURL=defer-hydration-8vI8xNNx.js.map