@aparte/plugin-compaction 0.25.0 → 0.26.0

package/dist/index.js

@@ -1,4 +1,5 @@
-import { aparteGlobalConfig, uuid, revokeAttachmentUrls, resolveConfig, contentToText } from "@aparte/core";
+import { estimateTokens, aparteGlobalConfig, estimateWireTokens, measureContext, resolveConfig, contentToText, historyFromCheckpoint } from "@aparte/core";
+import { estimateTokens as estimateTokens2 } from "@aparte/core";
 const DEFAULT_COMPACTION_CONFIG = {
   // Conservative model-agnostic defaults — the consuming app overrides
   // `contextWindow` / `reservedThinking` with its model's real values.
@@ -12,10 +13,6 @@ const DEFAULT_COMPACTION_CONFIG = {
   summaryRatio: 0.1,
   summaryMaxTokens: 400
 };
-function estimateTokens(text) {
-  if (!text) return 0;
-  return Math.ceil(text.length / 3.8);
-}
 function estimateTokensJson(obj) {
   if (!obj) return 0;
   try {
@@ -50,6 +47,31 @@ function splitHistoryBudget(historyBudget, cfg = DEFAULT_COMPACTION_CONFIG) {
   const summary = Math.min(cfg.summaryMaxTokens, Math.floor(historyBudget * cfg.summaryRatio));
   return { summary, window: historyBudget - summary };
 }
+function cutAtUser(messages, boundary) {
+  const last = messages.length - 1;
+  if (last < 1) return null;
+  const start = Math.min(boundary, last);
+  for (let i = start; i > 0; i--) if (messages[i].role === "user") return i;
+  for (let i = start + 1; i <= last; i++) if (messages[i].role === "user") return i;
+  return null;
+}
+const FIRST_REQUEST_LINE = "The conversation's first request, verbatim:";
+const FIRST_REQUEST_MAX = 1500;
+function firstRequestBlock(text) {
+  const trimmed = text.trim();
+  const clipped = trimmed.length > FIRST_REQUEST_MAX ? `${trimmed.slice(0, FIRST_REQUEST_MAX)}…` : trimmed;
+  return `
+
+${FIRST_REQUEST_LINE}
+${clipped}`;
+}
+function splitFirstRequest(summary) {
+  const at = summary.indexOf(`
+
+${FIRST_REQUEST_LINE}
+`);
+  return at < 0 ? { base: summary, block: "" } : { base: summary.slice(0, at), block: summary.slice(at) };
+}
 const read = (value) => typeof value === "function" ? value() : value;
 const textOf = (message) => {
   if (typeof message.content === "string" && message.content.length > 0) return message.content;
@@ -65,7 +87,8 @@ ${typeof result === "string" ? result : ""}`;
 };
 function createCompactionSelector(options) {
   const minKeep = Math.max(0, options.minKeep ?? 2);
-  return (messages) => {
+  const costOf = options.estimate ?? ((message) => estimateTokens(textOf(message)));
+  return (messages, limits) => {
     const contextWindow = read(options.contextWindow);
     if (!contextWindow || contextWindow <= 0) return { keep: messages, drop: [] };
     const budget = computeHistoryBudget({
@@ -73,11 +96,23 @@ function createCompactionSelector(options) {
       toolsArray: read(options.tools),
       config: { ...options.config, contextWindow }
     });
-    const windowBudget = splitHistoryBudget(budget.historyBudget, budget.config).window;
+    const split = splitHistoryBudget(budget.historyBudget, budget.config);
+    const scale = limits?.scale !== void 0 && limits.scale > 0 ? limits.scale : 1;
+    const fixed = budget.breakdown.systemPrompt + budget.breakdown.tools;
+    let windowBudget = split.window - (scale - 1) * fixed;
+    if (limits?.landAt !== void 0) {
+      const { reservedThinking, reservedGeneration, minHistoryBudget } = budget.config;
+      windowBudget = Math.min(windowBudget, Math.max(
+        minHistoryBudget,
+        limits.landAt * contextWindow - scale * fixed - reservedThinking - reservedGeneration - split.summary
+      ));
+    }
+    if (limits?.ceiling !== void 0) windowBudget = Math.min(windowBudget, limits.ceiling);
+    windowBudget -= limits?.reserve ?? 0;
     let used = 0;
     let cut = messages.length;
     for (let i = messages.length - 1; i >= 0; i--) {
-      const cost = estimateTokens(textOf(messages[i]));
+      const cost = scale * costOf(messages[i]);
       const kept = messages.length - 1 - i;
       if (used + cost > windowBudget && kept >= minKeep) break;
       used += cost;
@@ -87,7 +122,7 @@ function createCompactionSelector(options) {
     return { keep: messages.slice(cut), drop: messages.slice(0, cut) };
   };
 }
-const DEFAULT_COMPACTION_PROMPT = "You are compacting a conversation between a user and an assistant so that it can continue with less context. Write a summary the assistant can pick the work up from: what the user wants and why, the decisions taken and their reasons, the tasks still open, the facts and tool results that still matter (file names, values, errors, outcomes), and anything the assistant would otherwise have to ask again. Lines marked [tool …] are tool calls with their result. Write in the third person, factually, as compact as completeness allows. No preamble. Do not continue the conversation, do not answer a question it contains and do not call a tool: reply with the summary and nothing else.";
+const DEFAULT_COMPACTION_PROMPT = "You are compacting a conversation between a user and an assistant so that it can continue with less context. Write a summary the assistant can pick the work up from, in these sections, each one short and factual: 1. The user's goal and constraints. 2. Decisions taken, and why. 3. Tasks still open. 4. Facts and tool results still needed: names, values, errors, outcomes. 5. The next step. Lines marked [tool …] are tool calls with their result. Write in the language of the conversation, in the third person, as compact as completeness allows. No preamble. Do not continue the conversation, do not answer a question it contains and do not call a tool: reply with the summary and nothing else.";
 const clip = (text, max) => text.length > max ? `${text.slice(0, max)}…` : text;
 const safeJson = (value) => {
   try {
@@ -137,7 +172,12 @@ function transcriptForSummary(message) {
   }
   return lines.join("\n");
 }
+const DEFAULT_THRESHOLD = 0.8;
+const MAX_FAILURES = 2;
+const LANDING_MARGIN = 0.2;
+const OVERFLOW_SHRINK = 0.75;
 const ABORTED = "Compaction aborted";
+const CHANGED = "The conversation changed while the summary was being written";
 const withAbort = (work, signal) => new Promise((resolve, reject) => {
   const onAbort = () => reject(new Error(ABORTED));
   if (signal.aborted) {
@@ -163,9 +203,8 @@ const ownResolvers = /* @__PURE__ */ new Map();
 const asTarget = (candidate, depth = 0) => {
   if (!candidate || typeof candidate !== "object" || depth > 1) return null;
   const el = candidate;
-  if (typeof el.getMessages === "function" && typeof el.clearAll === "function" && typeof el.appendMessage === "function") {
-    return el;
-  }
+  const writes = typeof el.updateMessage === "function" || typeof el.clearAll === "function" && typeof el.appendMessage === "function";
+  if (typeof el.getMessages === "function" && writes) return el;
   return asTarget(el.viewport, depth + 1);
 };
 const resolveDomTarget = (targetId) => {
@@ -179,23 +218,58 @@ const resolveDomTarget = (targetId) => {
 };
 const hasWindow = typeof window !== "undefined";
 const inFlight = (message) => message.status === "streaming" || message.status === "pending";
-function defaultSelector(config, keepWithoutWindow) {
+function defaultSelector(config, keepWithoutWindow, windowOf) {
   const budgeted = createCompactionSelector({
-    contextWindow: () => config.getCurrentModel()?.contextWindow,
+    contextWindow: windowOf,
     systemPrompt: () => config.resolveSystemPrompt(),
-    tools: () => config.getTools()
+    tools: () => config.getTools(),
+    estimate: (message) => estimateWireTokens([message])
   });
-  return (messages) => {
-    if (config.getCurrentModel()?.contextWindow) return budgeted(messages);
+  return (messages, limits) => {
+    if (windowOf()) return budgeted(messages, limits);
     const cut = Math.max(0, messages.length - keepWithoutWindow);
     return { keep: messages.slice(cut), drop: messages.slice(0, cut) };
   };
 }
-function buildRequest(drop, prompt, modelId) {
-  const history = drop.filter((m) => !inFlight(m)).map((m) => ({ role: m.role, content: transcriptForSummary(m) })).filter((m) => contentToText(m.content).length > 0);
+const summarisable = (drop) => drop.filter((m) => !inFlight(m)).map((m) => ({ role: m.role, content: transcriptForSummary(m) })).filter((m) => contentToText(m.content).length > 0);
+const alternating = (turns) => {
+  const merged = [];
+  for (const turn of turns) {
+    const last = merged[merged.length - 1];
+    if (last && last.role === turn.role) {
+      merged[merged.length - 1] = { role: last.role, content: `${contentToText(last.content)}
+
+${contentToText(turn.content)}` };
+    } else {
+      merged.push(turn);
+    }
+  }
+  return merged;
+};
+const withoutThinking = (text) => text.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/<think>[\s\S]*$/i, "").replace(/^[\s\S]*<\/think>/i, "").trim();
+const askFor = (prompt, updating) => `${prompt}
+
+${updating ? "Please write the updated summary: the summary so far, with the conversation above folded in." : "Please summarize the conversation above."}`;
+const withSummarySoFar = (turns, summary) => {
+  const note = `Summary so far:
+${summary}
+
+The conversation since then:`;
+  const [first, ...rest] = turns;
+  if (first?.role === "user") return [{ role: "user", content: `${note}
+
+${contentToText(first.content)}` }, ...rest];
+  return [{ role: "user", content: note }, ...turns];
+};
+function buildRequest(turns, summarySoFar, prompt, modelId, maxTokens) {
+  const body = summarySoFar === void 0 ? turns : withSummarySoFar(turns, summarySoFar);
+  const last = body[body.length - 1];
+  const ask = askFor(prompt, summarySoFar !== void 0);
   return {
     messages: [
-      ...history,
+      // The ask joins a trailing user turn rather than following it: two user turns in a
+      // row are what `alternating` took out of the transcript.
+      ...last?.role === "user" ? body.slice(0, -1) : body,
       // The instruction rides the USER turn, not a `system` message.
       //
       // A system message is a persona, and a provider is entitled to own that: one
@@ -212,12 +286,17 @@ function buildRequest(drop, prompt, modelId) {
       // The instruction is not a persona: it is the task of this one request, and the
       // task belongs where every provider must look. Reported as #45 by a consumer who
       // only found it by reading the output closely.
-      { role: "user", content: `${prompt}
+      { role: "user", content: last?.role === "user" ? `${contentToText(last.content)}
 
-Please summarize the conversation above.` }
+${ask}` : ask }
     ],
     modelId,
-    stream: false,
+    // Streamed, so an `error` event and a `done` that says the model ran out of room
+    // reach the drain below; a non-streamed answer cut at the limit is just a string.
+    stream: true,
+    // A ceiling on the answer, so a server cannot let it run until the context is
+    // full (see `summaryAnswerCap`).
+    maxTokens,
     // Named as what it is, so a backend can route it to a cheaper model.
     _meta: { compaction: true }
   };
@@ -235,19 +314,62 @@ async function summarizeThroughTransport(config, provider, request, signal, keyR
       const { done, value } = await reader.read();
       if (done) break;
       if (value.type === "text") chunks.push(value.delta);
+      else if (value.type === "error") throw new Error(value.message);
+      else if (value.type === "done" && value.finishReason === "length") {
+        throw new Error("The summary was cut off at the model's length limit");
+      }
     }
+  } catch (err) {
+    void reader.cancel().catch(() => void 0);
+    throw err;
   } finally {
     reader.releaseLock();
   }
   return chunks.join("");
 }
+function summaryAnswerCap(config, contextWindow) {
+  const { reservedGeneration } = DEFAULT_COMPACTION_CONFIG;
+  if (!contextWindow || contextWindow <= 0) return reservedGeneration;
+  const budget = computeHistoryBudget({
+    systemPrompt: config.resolveSystemPrompt() ?? "",
+    toolsArray: config.getTools(),
+    config: { contextWindow }
+  });
+  const reservation = splitHistoryBudget(budget.historyBudget, budget.config).summary;
+  return Math.max(1, reservation, Math.min(reservedGeneration, Math.floor(contextWindow / 4)));
+}
+function fitOldest(drop, prompt, contextWindow, maxTokens, baseTokens, scale) {
+  const room = contextWindow - maxTokens - DEFAULT_COMPACTION_CONFIG.reservedThinking - DEFAULT_COMPACTION_CONFIG.safetyMargin;
+  let used = scale * (estimateTokens(askFor(prompt, baseTokens > 0)) + baseTokens);
+  for (let i = 0; i < drop.length; i++) {
+    used += scale * summarisable([drop[i]]).reduce((sum, m) => sum + estimateTokens(contentToText(m.content)), 0);
+    if (used > room) return i;
+  }
+  return drop.length;
+}
 function setupCompaction(options = {}, config = aparteGlobalConfig) {
   controllers.get(config)?.dispose();
   const keepWithoutWindow = Math.max(0, options.keepWithoutWindow ?? 4);
-  const select = options.selector ?? defaultSelector(config, keepWithoutWindow);
-  const resolveTarget = options.resolveTarget ?? resolveDomTarget;
   const scope = options.scopeToTargetId;
-  let running = null;
+  const threshold = options.threshold !== void 0 && options.threshold > 0 ? Math.min(options.threshold, 1) : DEFAULT_THRESHOLD;
+  let windowHint;
+  const windowFor = () => {
+    const declared = config.getCurrentModel()?.contextWindow;
+    if (declared && declared > 0) return declared;
+    const own = typeof options.contextWindow === "function" ? options.contextWindow() : options.contextWindow;
+    return own && own > 0 ? own : windowHint;
+  };
+  const selectDefault = defaultSelector(config, keepWithoutWindow, windowFor);
+  const resolveFor = (element, targetId) => {
+    if (options.resolveTarget) {
+      const own = options.resolveTarget(targetId);
+      if (own) return own;
+    }
+    const named = element ? asTarget(element) : null;
+    if (named) return named;
+    return options.resolveTarget ? null : resolveDomTarget(targetId);
+  };
+  const running = /* @__PURE__ */ new Map();
   let disposed = false;
   const addressed = (e) => {
     const targetId = e.detail?.targetId;
@@ -256,7 +378,7 @@ function setupCompaction(options = {}, config = aparteGlobalConfig) {
     if (typeof document === "undefined") return true;
     const el = targetId ? document.getElementById(targetId) : document.querySelector("aparte-chat, aparte-chat-viewport, [data-aparte-chat]");
     if (!el && targetId) {
-      if (options.resolveTarget && resolveTarget(targetId)) return true;
+      if (options.resolveTarget && options.resolveTarget(targetId)) return true;
       for (const other of ownResolvers.keys()) if (other(targetId)) return false;
     }
     const owner = el ? resolveConfig(el) : aparteGlobalConfig;
@@ -267,29 +389,250 @@ function setupCompaction(options = {}, config = aparteGlobalConfig) {
   };
   const onCompact = (e) => {
     if (!addressed(e)) return;
-    void controller.compact(e.detail?.targetId);
+    const detail = e.detail;
+    if (typeof detail?.window === "number" && detail.window > 0) windowHint = detail.window;
+    void run({
+      target: null,
+      reason: detail?.auto ? "auto" : "manual",
+      ...detail?.targetId !== void 0 ? { targetId: detail.targetId } : {}
+    });
   };
   const onAbort = (e) => {
-    if (!running) return;
     const targetId = e.detail?.targetId;
-    if (targetId && (running.targetId ? targetId !== running.targetId : !addressed(e))) return;
-    controller.abort();
+    for (const [key, entry] of running) {
+      if (targetId && (key ? targetId !== key : !addressed(e))) continue;
+      entry.abort.abort();
+    }
   };
   const listening = options.listen !== false && typeof window !== "undefined";
+  const autoOn = options.auto !== false && listening;
+  const policies = /* @__PURE__ */ new Map();
+  const policyOf = (key) => {
+    let policy = policies.get(key);
+    if (!policy) {
+      policy = { failures: 0, suspended: false, cooling: false };
+      policies.set(key, policy);
+    }
+    return policy;
+  };
+  const canSummarise = () => {
+    if (options.summarize) return true;
+    const providerId = config.getModelConfig().defaultProvider;
+    return Boolean(providerId && config.getAIProvider(providerId));
+  };
+  const scaleOf = (messages, size) => {
+    const measure = measureContext({
+      messages,
+      config,
+      viewChanged: true,
+      ...size !== void 0 ? { windowOverride: size } : {}
+    });
+    const estimate = measure.parts.system + measure.parts.tools + measure.parts.summary + measure.parts.messages;
+    return estimate > 0 && measure.used > 0 ? measure.used / estimate : 1;
+  };
+  const mayAct = (policy, beforeSend = false) => autoOn && canSummarise() && policy.failures < MAX_FAILURES && !policy.suspended && (beforeSend || !policy.cooling);
+  const onTurnDone = (e) => {
+    if (!addressed(e) || !autoOn) return;
+    const targetId = e.detail?.targetId;
+    const policy = policyOf(targetId ?? "");
+    const element = e.target instanceof Element ? e.target : null;
+    const target = resolveFor(element, targetId);
+    const size = windowFor();
+    if (!target || !size) return;
+    if (measureContext({ messages: target.getMessages(), config, windowOverride: size }).used < threshold * size) {
+      policy.cooling = false;
+      return;
+    }
+    if (!mayAct(policy)) return;
+    void run({ target: element, reason: "auto", ...targetId !== void 0 ? { targetId } : {} });
+  };
+  const onRestored = (e) => {
+    if (!e.detail?.restored || !addressed(e)) return;
+    const key = e.detail.targetId ?? "";
+    const policy = policyOf(key);
+    policy.suspended = true;
+    policy.cooling = false;
+    delete policy.lastRange;
+    running.get(key)?.abort.abort();
+  };
+  const onSwitch = () => policies.clear();
   if (listening) {
     window.addEventListener("aparte-compact", onCompact);
     window.addEventListener("aparte-abort", onAbort);
+    window.addEventListener("aparte-message-done", onTurnDone);
+    window.addEventListener("aparte-compact-done", onRestored);
+    window.addEventListener("aparte-reset-done", onSwitch);
   }
   if (listening && !scope) answering.add(config);
   if (listening && scope) scopedChats.set(scope, (scopedChats.get(scope) ?? 0) + 1);
   const ownResolver = listening && !scope ? options.resolveTarget : void 0;
   if (ownResolver) ownResolvers.set(ownResolver, (ownResolvers.get(ownResolver) ?? 0) + 1);
+  const plan = (element, targetId, exclude, reason) => {
+    const target = resolveFor(element, targetId);
+    if (!target) return { kind: "fail", error: targetId ? `No chat with id "${targetId}" to compact` : "No chat found to compact" };
+    const path = target.getMessages();
+    if (path.length === 0) return { kind: "skip", reason: "empty" };
+    if (path.some((m) => !exclude.has(m.id) && inFlight(m))) return { kind: "skip", reason: "streaming" };
+    const contextWindow = windowFor();
+    const hostSizes = options.selector || options.summarize || options.keepWithoutWindow !== void 0;
+    if (!contextWindow && !hostSizes) return { kind: "skip", reason: "no-window" };
+    const checkpointed = historyFromCheckpoint(path);
+    const holderOfPrevious = checkpointed.summary !== void 0 ? checkpointed.messages[0] : void 0;
+    const previous = holderOfPrevious?.contextSummary ? { summary: holderOfPrevious.contextSummary.summary, count: holderOfPrevious.contextSummary.count } : void 0;
+    const view = checkpointed.messages.filter((m) => !exclude.has(m.id));
+    const scale = contextWindow ? scaleOf(path, contextWindow) : 1;
+    let selected;
+    if (options.selector) {
+      selected = options.selector(view);
+    } else {
+      const reserve = Math.round(scale * estimateWireTokens(path.filter((m) => exclude.has(m.id))));
+      const limits = { scale, reserve, landAt: Math.max(0, threshold - LANDING_MARGIN) };
+      if (reason === "overflow") limits.ceiling = Math.floor(OVERFLOW_SHRINK * (scale * estimateWireTokens(view) + reserve));
+      selected = selectDefault(view, limits);
+    }
+    if (selected.drop.length === 0) return { kind: "skip", reason: "nothing-to-drop" };
+    const droppedIds = new Set(selected.drop.map((m) => m.id));
+    let boundary = 0;
+    while (boundary < view.length && droppedIds.has(view[boundary].id)) boundary++;
+    if (boundary === 0) return { kind: "skip", reason: "nothing-to-drop" };
+    const prompt = options.prompt ?? DEFAULT_COMPACTION_PROMPT;
+    const maxTokens = summaryAnswerCap(config, contextWindow);
+    const base = previous ? splitFirstRequest(previous.summary) : void 0;
+    const baseTokens = base ? estimateTokens(base.base) : 0;
+    const fit = (n) => contextWindow && !options.summarize ? fitOldest(view.slice(0, n), prompt, contextWindow, maxTokens, baseTokens, scale) : n;
+    const fits = fit(boundary);
+    if (fits === 0) return { kind: "fail", error: "The oldest turn to summarise does not fit the model's context window" };
+    const cut = cutAtUser(view, fits);
+    if (cut === null) return { kind: "skip", reason: "nothing-to-drop" };
+    if (cut > fits && fit(cut) < cut) return { kind: "skip", reason: "nothing-to-drop" };
+    const drop = view.slice(0, cut);
+    const holder = view[cut];
+    let firstRequest = base?.block ?? "";
+    if (!previous) {
+      const first = path.find((m) => m.role === "user" && !m.compaction);
+      const text = first && drop.some((m) => m.id === first.id) ? messageText(first).trim() : "";
+      if (text) firstRequest = firstRequestBlock(text);
+    }
+    return {
+      kind: "plan",
+      plan: {
+        target,
+        drop,
+        holder,
+        ...previous ? { previous } : {},
+        ...holderOfPrevious ? { previousHolderId: holderOfPrevious.id } : {},
+        firstRequest,
+        maxTokens,
+        prompt
+      }
+    };
+  };
+  const run = async (request) => {
+    const targetId = request.targetId ?? scope ?? (request.target?.id || void 0);
+    const reason = request.reason ?? "manual";
+    const key = targetId ?? "";
+    const policy = policyOf(key);
+    let messageId;
+    const fail = (error) => {
+      if (error !== ABORTED) policy.failures++;
+      console.warn(`[aparte/plugin-compaction] compaction failed: ${error}`);
+      if (hasWindow) {
+        window.dispatchEvent(new CustomEvent("aparte-compact-error", {
+          detail: { error, targetId, ...messageId ? { messageId } : {}, ...error === ABORTED ? { aborted: true } : {} }
+        }));
+      }
+      return { ok: false, error, targetId, ...messageId ? { messageId } : {} };
+    };
+    const skip = (reason2) => {
+      if (hasWindow) window.dispatchEvent(new CustomEvent("aparte-compact-done", { detail: { skipped: true, reason: reason2, targetId } }));
+      return { ok: true, skipped: true, reason: reason2, targetId };
+    };
+    if (disposed) return fail("This compaction setup was disposed");
+    if (scope && request.targetId !== void 0 && request.targetId !== scope) {
+      return { ok: false, error: `This compaction setup only compacts the chat "${scope}"`, targetId: request.targetId };
+    }
+    if ((reason === "auto" || reason === "overflow") && !autoOn) return skip("nothing-to-drop");
+    if (reason === "manual" || reason === "retry") {
+      policy.failures = 0;
+      policy.suspended = false;
+    }
+    if (reason === "overflow") for (let busy = running.get(key); busy; busy = running.get(key)) await busy.done;
+    if (request.signal?.aborted) return fail(ABORTED);
+    if (running.has(key)) return skip("running");
+    if (reason === "auto" && !request.force && (policy.failures >= MAX_FAILURES || policy.suspended || policy.cooling && !request.beforeSend)) {
+      return skip("nothing-to-drop");
+    }
+    const planned = plan(request.target, targetId, new Set(request.exclude ?? []), reason);
+    if (planned.kind === "skip") return skip(planned.reason);
+    if (planned.kind === "fail") {
+      if (planned.messageId) messageId = planned.messageId;
+      return fail(planned.error);
+    }
+    const { target, drop, holder, previous, previousHolderId, firstRequest, maxTokens, prompt } = planned.plan;
+    messageId = holder.id;
+    const range = `${drop[0].id}..${drop[drop.length - 1].id}`;
+    if (reason === "auto" && !request.force && policy.lastRange === range) return skip("nothing-to-drop");
+    if (!target.updateMessage) return fail("This chat cannot hold a checkpoint: its transcript has no updateMessage");
+    const modelConfig = config.getModelConfig();
+    const providerId = modelConfig.defaultProvider;
+    let provider;
+    if (!options.summarize) {
+      if (!providerId) return fail("No provider configured");
+      provider = config.getAIProvider(providerId);
+      if (!provider) return fail(`Provider '${providerId}' not found`);
+    }
+    const summarySoFar = previous ? splitFirstRequest(previous.summary).base : void 0;
+    const turns = alternating(summarisable(drop));
+    if (turns.length === 0) return fail("Nothing summarisable in the dropped turns");
+    const summariseRequest = buildRequest(turns, summarySoFar, prompt, modelConfig.defaultModel || "", maxTokens);
+    const abort = new AbortController();
+    const onSignal = () => abort.abort();
+    request.signal?.addEventListener("abort", onSignal, { once: true });
+    let finished;
+    running.set(key, { abort, done: new Promise((resolve) => {
+      finished = resolve;
+    }) });
+    if (hasWindow) window.dispatchEvent(new CustomEvent("aparte-compact-start", { detail: { targetId, messageId } }));
+    try {
+      const raw = await withAbort(
+        options.summarize ? options.summarize(summariseRequest, abort.signal) : summarizeThroughTransport(config, provider, summariseRequest, abort.signal, options.keyResolver),
+        abort.signal
+      );
+      const modelSummary = withoutThinking(raw);
+      if (!modelSummary) throw new Error("Empty summary returned by model");
+      const replaced = estimateTokens(summarySoFar) + turns.reduce((sum, m) => sum + estimateTokens(contentToText(m.content)), 0);
+      if (estimateTokens(modelSummary) >= replaced) throw new Error("The summary is no shorter than the turns it replaces");
+      const live = target.getMessages();
+      const at = live.findIndex((m) => m.id === holder.id);
+      if (at < 0) throw new Error(CHANGED);
+      if (previousHolderId && !live.find((m) => m.id === previousHolderId)?.contextSummary) throw new Error(CHANGED);
+      const summary = `${modelSummary}${firstRequest}`;
+      const count = drop.length + (previous?.count ?? 0);
+      target.updateMessage(holder.id, { contextSummary: { summary, count, createdAt: Date.now() } });
+      policy.failures = 0;
+      policy.lastRange = range;
+      const size = windowFor();
+      const after = measureContext({ messages: target.getMessages(), config, ...size !== void 0 ? { windowOverride: size } : {} });
+      policy.cooling = after.window !== void 0 && after.used >= threshold * after.window;
+      const kept = live.length - at;
+      const outcome = { ok: true, skipped: false, summary, kept, dropped: drop.length, messageId: holder.id, count, targetId };
+      if (hasWindow) window.dispatchEvent(new CustomEvent("aparte-compact-done", { detail: { summary, kept, dropped: drop.length, targetId, messageId: holder.id, count } }));
+      return outcome;
+    } catch (err) {
+      const aborted = abort.signal.aborted || err instanceof Error && err.name === "AbortError";
+      return fail(aborted ? ABORTED : err instanceof Error ? err.message : String(err));
+    } finally {
+      request.signal?.removeEventListener("abort", onSignal);
+      running.delete(key);
+      finished();
+    }
+  };
   const controller = {
     get running() {
-      return running !== null;
+      return running.size > 0;
     },
     abort() {
-      running?.abort.abort();
+      for (const entry of running.values()) entry.abort.abort();
     },
     dispose() {
       if (disposed) return;
@@ -298,6 +641,9 @@ function setupCompaction(options = {}, config = aparteGlobalConfig) {
       if (listening) {
         window.removeEventListener("aparte-compact", onCompact);
         window.removeEventListener("aparte-abort", onAbort);
+        window.removeEventListener("aparte-message-done", onTurnDone);
+        window.removeEventListener("aparte-compact-done", onRestored);
+        window.removeEventListener("aparte-reset-done", onSwitch);
         if (scope) {
           const left = (scopedChats.get(scope) ?? 1) - 1;
           if (left > 0) scopedChats.set(scope, left);
@@ -309,84 +655,49 @@ function setupCompaction(options = {}, config = aparteGlobalConfig) {
         if (left > 0) ownResolvers.set(ownResolver, left);
         else ownResolvers.delete(ownResolver);
       }
+      if (config.getCompactor() === controller) config.setCompactor(null);
       if (controllers.get(config) === controller) {
         controllers.delete(config);
         answering.delete(config);
       }
     },
-    async compact(requested) {
-      const targetId = requested ?? scope;
-      const fail = (error) => {
-        console.warn(`[aparte/plugin-compaction] compaction failed: ${error}`);
-        if (hasWindow) window.dispatchEvent(new CustomEvent("aparte-compact-error", { detail: { error, targetId } }));
-        return { ok: false, error, targetId };
-      };
-      const skip = (reason) => {
-        if (hasWindow) window.dispatchEvent(new CustomEvent("aparte-compact-done", { detail: { skipped: true, reason, targetId } }));
-        return { ok: true, skipped: true, reason, targetId };
-      };
-      if (disposed) return fail("This compaction setup was disposed");
-      if (running) return skip("running");
-      const target = resolveTarget(targetId);
-      if (!target) return fail(targetId ? `No chat with id "${targetId}" to compact` : "No chat found to compact");
-      const messages = target.getMessages();
-      if (messages.length === 0) return skip("empty");
-      if (messages.some(inFlight)) return skip("streaming");
-      const { keep, drop } = select(messages);
-      if (drop.length === 0) return skip("nothing-to-drop");
-      const modelConfig = config.getModelConfig();
-      const providerId = modelConfig.defaultProvider;
-      let provider;
-      if (!options.summarize) {
-        if (!providerId) return fail("No provider configured");
-        provider = config.getAIProvider(providerId);
-        if (!provider) return fail(`Provider '${providerId}' not found`);
-      }
-      const request = buildRequest(drop, options.prompt ?? DEFAULT_COMPACTION_PROMPT, modelConfig.defaultModel || "");
-      if (request.messages.length <= 1) return fail("Nothing summarisable in the dropped turns");
-      const abort = new AbortController();
-      running = { targetId, abort };
-      if (hasWindow) window.dispatchEvent(new CustomEvent("aparte-compact-start", { detail: { targetId } }));
-      try {
-        const raw = await withAbort(
-          options.summarize ? options.summarize(request, abort.signal) : summarizeThroughTransport(config, provider, request, abort.signal, options.keyResolver),
-          abort.signal
-        );
-        const summary = raw.trim();
-        if (!summary) throw new Error("Empty summary returned by model");
-        const selectedIds = new Set(messages.map((m) => m.id));
-        const keptIds = new Set(keep.map((m) => m.id));
-        const live = target.getMessages();
-        if (!live.some((m) => selectedIds.has(m.id))) return fail("The transcript changed while the summary was being written");
-        const kept = live.filter((m) => keptIds.has(m.id));
-        const arrived = live.filter((m) => !selectedIds.has(m.id));
-        target.clearAll({ revokeAttachments: false });
-        target.appendMessage({
-          id: uuid(),
-          role: "user",
-          compaction: true,
-          content: `**${config.t("compactionSummaryTitle")}**
-
-${summary}`,
-          timestamp: Date.now(),
-          status: "completed"
-        });
-        for (const message of kept) target.appendMessage(message);
-        for (const message of arrived) target.appendMessage(message);
-        const survivors = new Set([...kept, ...arrived].map((m) => m.id));
-        for (const message of drop) if (!survivors.has(message.id)) revokeAttachmentUrls(message.attachments);
-        const outcome = { ok: true, skipped: false, summary, kept: kept.length, dropped: drop.length, targetId };
-        if (hasWindow) window.dispatchEvent(new CustomEvent("aparte-compact-done", { detail: { summary, kept: kept.length, dropped: drop.length, targetId } }));
-        return outcome;
-      } catch (err) {
-        const aborted = abort.signal.aborted || err instanceof Error && err.name === "AbortError";
-        return fail(aborted ? ABORTED : err instanceof Error ? err.message : String(err));
-      } finally {
-        running = null;
-      }
+    compact(request) {
+      return run(typeof request === "object" ? request : { target: null, ...request !== void 0 ? { targetId: request } : {} });
+    },
+    async settled(targetId) {
+      const pending = () => [...running].filter(([key]) => targetId === void 0 || key === "" || key === targetId).map(([, entry]) => entry.done);
+      for (let waiting = pending(); waiting.length > 0; waiting = pending()) await Promise.all(waiting);
+    },
+    async beforeSend({ target, targetId, exclude, requestTokens, signal }) {
+      await controller.settled(targetId);
+      const id = targetId ?? scope ?? (target?.id || void 0);
+      const policy = policyOf(id ?? "");
+      const size = windowFor();
+      if (!size || !mayAct(policy, true)) return false;
+      const chat = resolveFor(target, id);
+      const scale = chat ? scaleOf(chat.getMessages(), size) : 1;
+      if (scale * requestTokens + DEFAULT_COMPACTION_CONFIG.reservedGeneration <= size) return false;
+      const outcome = await run({
+        target,
+        reason: "auto",
+        beforeSend: true,
+        exclude,
+        ...id !== void 0 ? { targetId: id } : {},
+        ...signal ? { signal } : {}
+      });
+      return outcome.ok && !outcome.skipped;
+    },
+    preview(request) {
+      if (scope && request.targetId !== void 0 && request.targetId !== scope) return null;
+      const id = request.targetId ?? scope ?? (request.target?.id || void 0);
+      if (disposed || running.has(id ?? "") || !canSummarise()) return null;
+      const planned = plan(request.target, id, /* @__PURE__ */ new Set(), "manual");
+      if (planned.kind !== "plan") return null;
+      return { messages: planned.plan.drop.length, tokens: estimateWireTokens(planned.plan.drop) };
     }
   };
   controllers.set(config, controller);
+  config.setCompactor(controller);
   return controller;
 }
 export {
@@ -394,7 +705,7 @@ export {
   DEFAULT_COMPACTION_PROMPT,
   computeHistoryBudget,
   createCompactionSelector,
-  estimateTokens,
+  estimateTokens2 as estimateTokens,
   estimateTokensJson,
   messageText,
   setupCompaction,