@allenyolk/pi-compaction 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AllenYolk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,202 @@
-# Temporary Holding Version
+# @allenyolk/pi-compaction
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Pi's compaction summarises with the **conversation model** at the **session's thinking level**, and
+there is no way to change either. A long session therefore pays for its summary with the most
+expensive model it has, at whatever thinking level interactive work needed.
+
+This package lets you choose both.
+
+- The **summarizer** — the request that produces the compaction summary — gets its own model and its
+  own thinking level, chosen independently of the conversation model and the session's thinking level.
+- The **kept window** — the most recent entries a compaction retains verbatim — is the package's own
+  token target rather than the host's recent-token setting, so the cut point is a number you control.
+- The summary is **never shortened, never truncated and never replaced**. This package sends no
+  output ceiling and does not touch tool results. A summary it cannot vouch for is refused rather
+  than persisted.
+
+The package ships **inert**. Installing it changes nothing until you enable it.
+
+## What it does not do
+
+It does **not** bound the summary. The host sends no `max_output_tokens` on its summarization request
+and neither does this package, so the summary is as long as the host's prompt and the model make it —
+the same as stock Pi. On the profile this package was built against that meant 26,019 tokens by the
+sixteenth compaction and a base context of 93,152.
+
+That is deliberate, and [ADR 0005](docs/adr/0005-bound-by-not-bounding.md) records why. Every
+mechanism that could shorten a summary produces one that ends before the model finished, and the
+host's prompt puts `## Next Steps` and `## Critical Context` — the two sections a continuing model
+most needs — at the very end, so a cut removes them first. A shorter summary is not worth a wrong one.
+
+It also does not prune. Replacing old tool results with placeholders would change what the summarizer
+reads, which makes the summary this package's responsibility rather than the host's.
+
+**What it improves is speed**: the same summary request, on a model and a thinking level chosen for
+the job rather than inherited from the conversation.
+
+## Configuration
+
+One JSON file in the Pi agent directory, at `extensions/pi-compaction/config.json`. There are no
+project-level overrides, and `/reload` picks up a change without restarting.
+
+```json
+{
+  "enabled": true,
+  "summarizerModel": "minimax-cn/MiniMax-M3.1-Flash",
+  "thinking": "off",
+  "keptWindowTokens": 16000
+}
+```
+
+| Field | Meaning |
+| --- | --- |
+| `enabled` | Whether the package acts at all. Defaults to `false`. |
+| `summarizerModel` | `provider/model`, or `null` — the default — for the conversation model. `"conversation"` is accepted as a spelling of `null`. |
+| `thinking` | `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Defaults to `medium`, and is clamped to what the chosen model supports. |
+| `keptWindowTokens` | Token target for the kept window. Defaults to `16000`. |
+
+An invalid value is rejected whole: the package reports the file and the field, and compaction stays
+stock Pi rather than half-applying a configuration.
+
+### Choosing a summarizer
+
+`summarizerModel` defaults to `null` — the conversation model — so installing the package never
+silently lowers your summary quality. Choosing a cheaper or faster summarizer is explicit:
+
+```sh
+/compaction model minimax-cn/MiniMax-M3.1-Flash
+/compaction thinking off
+```
+
+The chosen model must be one this host offers with configured credentials; if it is not, the package
+says so and hands compaction back to Pi rather than failing the compaction.
+
+**Check `Thinking:` in `/compaction` before assuming `off` took effect.** A model whose
+`thinkingLevelMap` marks `off` unsupported is clamped to its lowest level instead, and it then
+reasons anyway — the status view reports the level that was actually used, not the one you asked for.
+
+## The one thing that is refused
+
+A **partial summary** is never persisted.
+
+The host rejects a summarization response that stopped with `error` or `length`, and one that tried to
+call a tool. For any **other** stop reason it returns the partially written summary unchanged —
+`aborted` being the case the specification names.
+
+This matters more than it looks. A summary the model did not finish is a silent change to the
+session's history: the next compaction is told to preserve everything in the previous summary, so an
+incomplete one propagates, and nothing in the transcript says the checkpoint is short. **Reading the
+stop reason requires owning the stream function**, which is why this package wraps it rather than
+handing `compact()` a model and walking away — a wrapper that only swaps the model never sees a
+response at all.
+
+The package reads every response the request produced, not only the last one:
+
+- A split turn makes **two** summarization requests through the same stream function and the host
+  concatenates both into one summary, so a clean second response says nothing about a partial first
+  one. Both are checked.
+- An attempt whose responses were never observed at all is refused — it proves nothing.
+
+A length stop is refused too. Since this package sends no ceiling, a length stop means the summarizer
+hit the model's own output limit — a genuinely incomplete summary, not a budget working as intended.
+
+A cancellation stops everything and answers `{cancel: true}`: no fallback compaction begins behind
+your back.
+
+## Degradation
+
+Degradation is handing compaction back to stock Pi after the package's own attempt fails. It is never
+silent, and it is the same announcement whatever caused it: a host seam mismatch, an unavailable
+summarizer model, missing credentials, a model error, a partial response, or a cut point that leaves
+no history to summarise.
+
+```text
+pi-compaction: degraded — compaction handed back to stock Pi
+Summarizer: mafia-o/gpt-6.1-sol (openai-responses)
+Why: the summarizer reported an error (Summarization failed: 503 model_unavailable)
+Now: stock Pi compacts with the conversation model and the session's own thinking level, not the
+  summarizer configured here. The summary length is unaffected — neither path sends an output
+  ceiling — but the model and the thinking level are the whole of what this package controls, so a
+  handback gives both of them up.
+Next: /compaction model provider/model to summarise with a different model, /compaction thinking
+  off|minimal|low|medium|high to change how hard it thinks, or /compaction disable to make stock Pi
+  the default.
+```
+
+### How it reaches you
+
+A notification raised from inside a compaction does not paint: the host clears and rebuilds the
+transcript when the compaction ends, and anything raised before that is lost. A single stderr line
+scrolls away. So the announcement is delivered three ways, and only one of them is the terminal:
+
+| Surface | Survives the repaint | Survives a restart |
+| --- | --- | --- |
+| `console.error` and `ctx.ui.notify`, immediately | no — the repaint takes it | no |
+| A **widget pinned above the editor**, set once the compaction has settled | **yes** — it is chrome the repaint does not touch, and it cannot scroll away | no |
+| A **custom session entry**, `pi-compaction-degradation`, read back by `/compaction` | yes | **yes** |
+
+The pinned widget is cleared by the next compaction that completes, and at session start and
+shutdown. The session entry is the durable record: custom entries carry no LLM context, so it never
+enters the summary or the model's context.
+
+## `/compaction`
+
+`/compaction` on its own shows the effective configuration, what the summarizer will actually run at,
+the kept-window target, whether the package is enabled, and the result of the host-seam check. It does
+not shadow the host's `/compact`.
+
+```text
+Config: /home/you/.pi/agent/extensions/pi-compaction/config.json
+Enabled: yes
+Summarizer model: minimax-cn/MiniMax-M3.1-Flash (anthropic-messages)
+Thinking: off
+Kept window: 16000 tokens
+Summary length: not bounded by this package — the host sends no output ceiling and neither do we
+Host seam: ok — compact() arity 12; our stream function received {apiKey, cacheRetention, env, headers, sessionId, signal} and its result() was awaited
+Last degradation: none in this session
+```
+
+Every knob is settable from it, and each change is written back to the configuration file:
+
+```text
+/compaction enable | disable
+/compaction model provider/model | conversation
+/compaction thinking off | minimal | low | medium | high | xhigh | max
+/compaction window <tokens>
+```
+
+## Host-seam check
+
+Three seams this package depends on are not documented extension APIs: the argument list of the host's
+`compact()`, the point at which it calls its stream function, and that it awaits `result()` on
+whatever that function returns. All three are verified at activation — the arity, and an actual call
+through a stream function the package supplies, which needs no credentials and makes no request. A
+mismatch degrades to the host instead of letting the package misbehave, and the status view reports
+it. Tested signatures decide compatibility, not version text.
+
+The third is the one the package reads a response's stop reason through, which is how it refuses to
+persist a partial summary. Losing it would not break compaction — summaries would still be produced,
+just unchecked — so it is probed rather than assumed.
+
+## Install
+
+```sh
+pi install npm:@allenyolk/pi-compaction
+```
+
+Or take it from the [pi-extensions collection](../../README.md#install), or load it for one run:
+
+```sh
+pi -e ./packages/pi-compaction/src/index.ts
+```
+
+## Status
+
+Its development host, and the host its checks run against, is
+`@earendil-works/pi-coding-agent` 1.5.1 — the version whose seams were inspected. It adds no tools,
+so it does not change the host's prompt and tool declarations, and it never patches the host, edits
+an installed Pi or changes the host's compaction settings. It has no runtime dependencies and no peer
+dependency beyond the host itself.
+
+Tested platforms, known limits, rollback instructions, independent-review status and the list of what
+is *not* established live in [validation](docs/validation.md).

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@allenyolk/pi-compaction",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Choose the model and thinking level Pi compacts with, and never persist a summary that is not whole.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AllenYolk/pi-extensions.git",
+    "directory": "packages/pi-compaction"
+  },
+  "type": "module",
+  "license": "MIT",
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": "./src/index.ts",
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "compaction",
+    "summarizer",
+    "context"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --test test/*.test.mjs",
+    "check": "npm run typecheck && npm test"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "1.5.1"
+  }
+}

package/src/config.ts

@@ -0,0 +1,141 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+/** The word `/compaction model` and a hand-written config file use for the conversation model. */
+export const CONVERSATION_MODEL = 'conversation';
+
+export type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+
+/**
+ * What a compaction summarises with. `null` is the conversation model, so the default path never
+ * depends on a second provider being signed in.
+ */
+export interface Tuple {
+  model: string | null;
+  thinking: ThinkingLevel;
+}
+
+export const DEFAULT_THINKING: ThinkingLevel = 'medium';
+
+export const DEFAULT_KEPT_WINDOW_TOKENS = 16_000;
+
+/** The file as written. */
+export interface Config {
+  enabled: boolean;
+  /** `null` — the default — is the conversation model. */
+  summarizerModel: string | null;
+  thinking: ThinkingLevel;
+  keptWindowTokens: number;
+}
+
+/** What a compaction actually runs with. */
+export interface Effective {
+  enabled: boolean;
+  tuple: Tuple;
+  keptWindowTokens: number;
+}
+
+const LEVELS: ThinkingLevel[] = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+const FIELDS = ['enabled', 'summarizerModel', 'thinking', 'keptWindowTokens'];
+const MAX_TOKENS = 1_000_000;
+
+export const defaults = (): Config => ({
+  enabled: false,
+  summarizerModel: null,
+  thinking: DEFAULT_THINKING,
+  keptWindowTokens: DEFAULT_KEPT_WINDOW_TOKENS,
+});
+
+export function configPath(agentDir: string): string {
+  return join(agentDir, 'extensions', 'pi-compaction', 'config.json');
+}
+
+function integer(value: unknown, label: string, min: number): number {
+  if (typeof value !== 'number' || !Number.isInteger(value) || value < min || value > MAX_TOKENS) {
+    throw new Error(`${label} must be an integer from ${min} to ${MAX_TOKENS}`);
+  }
+  return value;
+}
+
+function parse(raw: unknown): Config {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('config must be an object');
+  const record = raw as Record<string, unknown>;
+  for (const key of Object.keys(record)) {
+    if (!FIELDS.includes(key)) throw new Error(`unknown field ${key}`);
+  }
+  const config = defaults();
+  if ('enabled' in record) {
+    if (typeof record.enabled !== 'boolean') throw new Error('enabled must be boolean');
+    config.enabled = record.enabled;
+  }
+  if ('summarizerModel' in record && record.summarizerModel !== null) {
+    const model = record.summarizerModel;
+    if (model === CONVERSATION_MODEL) {
+      config.summarizerModel = null;
+    } else if (typeof model !== 'string' || !/^[^/\s]+\/[^/\s]+$/.test(model)) {
+      throw new Error(`summarizerModel must be "provider/model", "${CONVERSATION_MODEL}" or null`);
+    } else {
+      config.summarizerModel = model;
+    }
+  }
+  if ('thinking' in record) {
+    if (!LEVELS.includes(record.thinking as ThinkingLevel)) throw new Error(`thinking must be ${LEVELS.join(', ')}`);
+    config.thinking = record.thinking as ThinkingLevel;
+  }
+  if ('keptWindowTokens' in record) config.keptWindowTokens = integer(record.keptWindowTokens, 'keptWindowTokens', 0);
+  return config;
+}
+
+/**
+ * A rejected configuration leaves compaction alone rather than half-applying it: the caller stays
+ * inert and reports the diagnostic.
+ */
+export function loadConfig(agentDir: string): { config?: Config; diagnostic?: string } {
+  const path = configPath(agentDir);
+  let text: string;
+  try {
+    text = readFileSync(path, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { config: defaults() };
+    return { diagnostic: `${path}: ${String(error)}; compaction stays stock Pi` };
+  }
+  try {
+    return { config: parse(JSON.parse(text)) };
+  } catch (error) {
+    return { diagnostic: `${path}: ${String(error)}; compaction stays stock Pi` };
+  }
+}
+
+/** The persisted shape: no absent keys, so a reload reads back exactly what was written. */
+function toRaw(config: Config): Record<string, unknown> {
+  return {
+    enabled: config.enabled,
+    summarizerModel: config.summarizerModel ?? null,
+    thinking: config.thinking,
+    keptWindowTokens: config.keptWindowTokens,
+  };
+}
+
+/** The same validation the file goes through, for a configuration assembled by the command. */
+export function validateConfig(config: Config): string | undefined {
+  try {
+    parse(toRaw(config));
+    return undefined;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
+export function saveConfig(agentDir: string, config: Config): void {
+  const path = configPath(agentDir);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(toRaw(config), null, 2)}\n`);
+}
+
+export function effective(config: Config): Effective {
+  return {
+    enabled: config.enabled,
+    keptWindowTokens: config.keptWindowTokens,
+    tuple: { model: config.summarizerModel, thinking: config.thinking },
+  };
+}

package/src/degradation.ts

@@ -0,0 +1,93 @@
+import type { AttemptOutcome } from './summarizer.ts';
+
+/**
+ * The announcement that ends a compaction, and the words it uses.
+ *
+ * A compaction this package could not complete hands back to stock Pi. That is the owner's explicit
+ * choice — availability over control, with a loud warning — so the announcement names the summarizer,
+ * the reason and what the session's behaviour now is, rather than printing a line and hoping.
+ */
+
+/** The custom session entry a degradation is recorded as. Custom entries carry no LLM context. */
+export const DEGRADATION_ENTRY = 'pi-compaction-degradation';
+
+/** The widget the announcement is pinned under, so a later compaction can take it down. */
+export const DEGRADATION_WIDGET = 'pi-compaction-degradation';
+
+/** Why the attempt failed, in the package's own words rather than the host's. */
+export function describeFailure(outcome: AttemptOutcome | undefined, error: unknown): string {
+  if (outcome?.toolCall) return 'the summarizer tried to call a tool instead of writing a summary';
+  const reason = outcome?.stopReason;
+  if (reason === 'error') return `the summarizer reported an error (${quote(messageOf(error))})`;
+  if (reason) {
+    return `the summarizer's response stopped with "${quote(reason)}" instead of finishing, `
+      + 'so the summary may be partial';
+  }
+  // No stop reason this package recognises: either the provider sent none, or it sent something not
+  // modelled here. A thrown error is then the only diagnostic there is, and quoting it beats printing
+  // the string "undefined" at the user.
+  if (error !== undefined) return `the summarizer did not produce a summary (${quote(messageOf(error))})`;
+  return outcome
+    ? "the summarizer's response carried no stop reason, so the package cannot prove it finished"
+    : 'the summarizer did not produce a summary';
+}
+
+const messageOf = (error: unknown): string => (error instanceof Error ? error.message : String(error));
+
+/**
+ * Provider-originated text, reduced to what it is being quoted for.
+ *
+ * An error message reaches the announcement, which is written to the terminal and pinned as a widget.
+ * Control characters there can rewrite the display, a newline breaks the one-fact-per-line shape the
+ * announcement depends on, and an unbounded message would push the rest of it off the screen.
+ */
+function quote(text: string): string {
+  const flattened = text
+    .replace(/[\u0000-\u001F\u007F-\u009F]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return flattened.length > 300 ? `${flattened.slice(0, 300)}…` : flattened;
+}
+
+/**
+ * Why an attempt whose responses were never observed is refused. Distinct from `describeFailure`'s
+ * unobserved case, which has a thrown error to quote: here `compact()` handed back a summary and this
+ * package never saw the responses that produced it, so it has proved nothing about it.
+ */
+export const UNOBSERVED_RESPONSE =
+  "the summarizer's responses were never observed, so the package cannot prove the summary is complete";
+
+export interface Degradation {
+  /** What the compaction was to summarise with, or what there was instead. */
+  summarizer: string;
+  /** Why the attempt failed. */
+  reason: string;
+}
+
+/**
+ * What a handback costs. It is not a change in summary length: this package sends no output ceiling
+ * and neither does stock Pi, so both produce a summary as long as the host's prompt and the model
+ * make it. What a handback gives up is the three things this package controls — the model, the
+ * thinking level, and the cut point.
+ */
+const HANDBACK_COST =
+  'stock Pi compacts with the conversation model, the session\'s own thinking level, and the host\'s '
+  + 'recent-token setting rather than this package\'s kept-window target. The summary length is '
+  + 'unaffected — neither path sends an output ceiling — but those three are the whole of what this '
+  + 'package controls, so a handback gives all of them up.';
+
+/**
+ * The announcement, as the lines the user reads. Line one is the headline; the rest name the
+ * summarizer, the reason, what the session's behaviour now is and what to do about it.
+ */
+export function announcement(degradation: Degradation): string[] {
+  return [
+    'degraded — compaction handed back to stock Pi',
+    `Summarizer: ${degradation.summarizer}`,
+    `Why: ${degradation.reason}`,
+    `Now: ${HANDBACK_COST}`,
+    'Next: /compaction model provider/model to summarise with a different model, /compaction '
+      + 'thinking off|minimal|low|medium|high|xhigh|max to change how hard it thinks, /compaction '
+      + 'window <tokens> to change the cut point, or /compaction disable to make stock Pi the default.',
+  ];
+}

package/src/index.ts

@@ -0,0 +1,264 @@
+import { compact, getAgentDir } from '@earendil-works/pi-coding-agent';
+import type {
+  ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionBeforeCompactEvent, SessionBeforeCompactResult,
+} from '@earendil-works/pi-coding-agent';
+import {
+  configPath,
+  CONVERSATION_MODEL,
+  defaults,
+  effective,
+  loadConfig,
+  saveConfig,
+  validateConfig,
+  type Config,
+  type ThinkingLevel,
+} from './config.ts';
+import { prepareCompaction } from './preparation.ts';
+import {
+  announcement,
+  DEGRADATION_ENTRY,
+  DEGRADATION_WIDGET,
+  describeFailure,
+  UNOBSERVED_RESPONSE,
+  type Degradation,
+} from './degradation.ts';
+import {
+  checkHostSeam,
+  hostRetryPolicy,
+  observingStream,
+  resolveSummarizerModel,
+  summarizerThinkingLevel,
+  type AttemptOutcome,
+  type SeamResult,
+} from './summarizer.ts';
+
+export default function piCompaction(pi: ExtensionAPI): void {
+  let config: Config = defaults();
+  let diagnostic: string | undefined;
+  let seam: Promise<SeamResult> | undefined;
+  /** The degradation raised inside a compaction, waiting for the compaction to settle. */
+  let pending: Degradation | undefined;
+
+  const reload = () => {
+    const loaded = loadConfig(getAgentDir());
+    config = loaded.config ?? defaults();
+    diagnostic = loaded.diagnostic;
+  };
+  const seamResult = () => (seam ??= checkHostSeam());
+  const report = (ctx: ExtensionContext, message: string, type: 'info' | 'warning' | 'error' = 'warning') => {
+    const line = `pi-compaction: ${message}`;
+    if (ctx.hasUI) ctx.ui.notify(line, type);
+    // A notification raised from inside a compaction does not always reach the terminal before the
+    // host repaints over it, and a warning that can be missed is not a warning.
+    console.error(line);
+  };
+
+  /**
+   * The durable half of a degradation, written once the compaction has settled.
+   *
+   * Anything raised inside `session_before_compact` is lost to the repaint: the host clears and
+   * rebuilds the transcript when the compaction ends, and a notification raised before that never
+   * reaches the terminal. So the announcement is pinned above the editor — chrome the repaint does
+   * not touch — and recorded as a custom session entry, which carries no LLM context and survives a
+   * restart. `/compaction` reads that entry back, which is the part that stays visible afterwards.
+   */
+  const settle = (ctx: ExtensionContext) => {
+    const degradation = pending;
+    pending = undefined;
+    if (!degradation) {
+      // A compaction that completed resolves whatever an earlier one degraded into.
+      if (ctx.hasUI) ctx.ui.setWidget(DEGRADATION_WIDGET, undefined);
+      return;
+    }
+    pi.appendEntry(DEGRADATION_ENTRY, degradation);
+    if (ctx.hasUI) ctx.ui.setWidget(DEGRADATION_WIDGET, announcement(degradation));
+  };
+
+  pi.on('session_start', (_event, ctx) => {
+    reload();
+    seam = undefined;
+    pending = undefined;
+    if (ctx.hasUI) ctx.ui.setWidget(DEGRADATION_WIDGET, undefined);
+    // Activation-time check: the status view reports it, and the hook awaits the same promise.
+    void seamResult();
+  });
+
+  pi.on('session_compact', (_event, ctx) => settle(ctx));
+  pi.on('session_compact_failed', (_event, ctx) => settle(ctx));
+
+  pi.on('session_shutdown', (_event, ctx) => {
+    config = defaults();
+    diagnostic = undefined;
+    seam = undefined;
+    pending = undefined;
+    if (ctx.hasUI) ctx.ui.setWidget(DEGRADATION_WIDGET, undefined);
+  });
+
+  pi.on('session_before_compact', async (event: SessionBeforeCompactEvent, ctx: ExtensionContext): Promise<SessionBeforeCompactResult | void> => {
+    const settings = effective(config);
+    const tuple = settings.tuple;
+    // Inert until enabled: installing the package changes nothing.
+    if (!settings.enabled) return;
+
+    /**
+     * Every handback goes through here, so a degradation is announced the same way whatever caused
+     * it. A cancellation is answered first: handing back would start a fresh compaction behind the
+     * user, which is the one thing a cancellation must never do.
+     */
+    const handBack = (summarizer: string, reason: string): SessionBeforeCompactResult | void => {
+      if (event.signal.aborted) return { cancel: true };
+      pending = { summarizer, reason };
+      report(ctx, announcement(pending).join('\n'), 'error');
+      return undefined;
+    };
+
+    const checked = await seamResult();
+    if (!checked.ok) return handBack('none — the seam was never reached', `host seam mismatch (${checked.detail})`);
+
+    const model = resolveSummarizerModel(tuple, ctx);
+    if (!model) {
+      const wanted = tuple.model === null ? 'the conversation model' : `summarizer model ${tuple.model}`;
+      return handBack(tuple.model ?? CONVERSATION_MODEL, `this host does not offer ${wanted}`);
+    }
+    const named = `${model.provider}/${model.id} (${model.api})`;
+    if (!ctx.modelRegistry.hasConfiguredAuth(model)) return handBack(named, 'the host has no configured credentials for it');
+
+    const prepared = prepareCompaction(event.branchEntries, event.preparation, settings.keptWindowTokens);
+    if (!prepared) {
+      return handBack(
+        named,
+        'the cut point leaves no history to summarise, so the host would carry the previous summary '
+        + 'forward and this package could not choose what produced it',
+      );
+    }
+
+    // One request. The model and its thinking level are two of the three things this package changes;
+    // the summary is otherwise the host's, at whatever length the host's prompt and the model produce.
+    //
+    // Responses are grouped by the context they came from. The host's retry policy calls the stream
+    // function again with the same context after a transient failure, and only the response it
+    // finally returns is the one `compact()` acted on — so a later response replaces an earlier one,
+    // and a failure that was retried away must not be read as this attempt's outcome. A split turn
+    // summarises two ranges through two contexts, and both of those have to be clean.
+    const outcomes = new Map<object, AttemptOutcome>();
+    let result;
+    try {
+      result = await compact(
+        prepared,
+        model,
+        undefined,
+        undefined,
+        event.customInstructions,
+        event.signal,
+        summarizerThinkingLevel(model, tuple) as never,
+        observingStream(ctx.modelRegistry, (group, seen) => { outcomes.set(group, seen); }),
+        undefined,
+        hostRetryPolicy(pi.getSettings()),
+        undefined,
+        ctx.sessionManager.getSessionId(),
+      );
+    } catch (error) {
+      if (event.signal.aborted) return { cancel: true };
+      return handBack(named, describeFailure([...outcomes.values()].at(-1), error));
+    }
+    if (event.signal.aborted) return { cancel: true };
+
+    /**
+     * The whole of this package's quality guarantee: a summary it cannot vouch for is never
+     * persisted. The host throws on an error and on a tool call, so those never reach here; it
+     * returns a partially written summary **unchanged** for any other stop reason, which is what this
+     * check exists to refuse.
+     *
+     * Every response the attempt kept is checked, not only the last one — see the grouping above —
+     * and a response with no stop reason this package recognises is refused too, because an
+     * unrecognised response is not a proven-complete one.
+     */
+    const responses = [...outcomes.values()];
+    const unclean = responses.find((seen) => seen.stopReason !== 'stop');
+    if (responses.length === 0 || unclean) {
+      return handBack(named, unclean ? describeFailure(unclean, undefined) : UNOBSERVED_RESPONSE);
+    }
+    return { compaction: result };
+  });
+
+  pi.registerCommand('compaction', {
+    description: 'Show or change which model compacts this session, and how hard it thinks',
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const [verb, value] = args.trim().split(/\s+/, 2);
+      if (!verb || verb === 'status') {
+        ctx.ui.notify(await status(ctx), 'info');
+        return;
+      }
+      const next: Config = { ...config };
+      switch (verb) {
+        case 'enable': next.enabled = true; break;
+        case 'disable': next.enabled = false; break;
+        case 'model':
+          if (!value) return void ctx.ui.notify(`usage: /compaction model provider/model | ${CONVERSATION_MODEL}`, 'error');
+          next.summarizerModel = value === CONVERSATION_MODEL ? null : value;
+          break;
+        case 'thinking':
+          if (!value) return void ctx.ui.notify('usage: /compaction thinking off|minimal|low|medium|high|xhigh|max', 'error');
+          next.thinking = value as ThinkingLevel;
+          break;
+        case 'window':
+          if (!value || !/^\d+$/.test(value)) return void ctx.ui.notify('usage: /compaction window <tokens>', 'error');
+          next.keptWindowTokens = Number(value);
+          break;
+        default:
+          ctx.ui.notify('unknown setting; try model, thinking, window, enable, disable', 'error');
+          return;
+      }
+      const invalid = validateConfig(next);
+      if (invalid) {
+        ctx.ui.notify(`pi-compaction: nothing changed; ${invalid}`, 'error');
+        return;
+      }
+      saveConfig(getAgentDir(), next);
+      config = next;
+      ctx.ui.notify(await status(ctx), 'info');
+    },
+  });
+
+  async function status(ctx: ExtensionCommandContext): Promise<string> {
+    const settings = effective(config);
+    const lines = [diagnostic ? `Config rejected: ${diagnostic}` : `Config: ${configPath(getAgentDir())}`];
+    lines.push(`Enabled: ${settings.enabled ? 'yes' : 'no'}`);
+    const tuple = settings.tuple;
+    const model = resolveSummarizerModel(tuple, ctx);
+    const wanted = tuple.model === null ? `${CONVERSATION_MODEL} model` : tuple.model;
+    const described = model ? `${model.provider}/${model.id} (${model.api})` : `${wanted} — not available on this host`;
+    lines.push(`Summarizer model: ${described}`);
+    if (model) {
+      const thinking = summarizerThinkingLevel(model, tuple);
+      // A model whose `thinkingLevelMap` marks the requested level unsupported gets the host's own
+      // clamp, and it then thinks anyway — so the level that was used is what gets reported.
+      const why = thinking === tuple.thinking ? ''
+        : tuple.thinking === 'off'
+          ? ` (clamped from off; this model has no off, so its reasoning phase still runs)`
+          : ` (clamped from ${tuple.thinking})`;
+      lines.push(`Thinking: ${thinking}${why}`);
+    } else {
+      lines.push(`Thinking: ${tuple.thinking}`);
+    }
+    lines.push(`Kept window: ${settings.keptWindowTokens} tokens`);
+    lines.push('Summary length: not bounded by this package — the host sends no output ceiling and neither do we');
+    const checked = await seamResult();
+    lines.push(`Host seam: ${checked.ok ? 'ok' : 'MISMATCH'} — ${checked.detail}`);
+    const degraded = lastDegradation(ctx);
+    lines.push(degraded
+      ? `Last degradation: summarizer ${degraded.summarizer} — ${degraded.reason}`
+      : 'Last degradation: none in this session');
+    return lines.join('\n');
+  }
+
+  /** The most recent degradation this package recorded in the session, if there is one. */
+  function lastDegradation(ctx: ExtensionCommandContext): Degradation | undefined {
+    const branch = ctx.sessionManager.getBranch();
+    for (let index = branch.length - 1; index >= 0; index--) {
+      const entry = branch[index];
+      if (entry.type === 'custom' && entry.customType === DEGRADATION_ENTRY) return entry.data as Degradation;
+    }
+    return undefined;
+  }
+}

package/src/preparation.ts

@@ -0,0 +1,97 @@
+import { buildSessionProjection, findCutPoint } from '@earendil-works/pi-coding-agent';
+import type { FileOperations, SessionEntry, SessionProjection } from '@earendil-works/pi-coding-agent';
+import type { SummarizationPreparation } from './summarizer.ts';
+
+type AgentMessage = SessionProjection['messages'][number];
+
+/**
+ * Cap for each of the two file blocks `compact()` appends to the summary. The blocks are an index
+ * of what a compaction covered; past a few dozen paths they are noise, and unbounded they are what
+ * grew a real session's last summary to 196 lines.
+ */
+export const MAX_FILE_LIST_ENTRIES = 40;
+
+/**
+ * Our own preparation: the host's compaction with our cut point.
+ *
+ * The host's recent-token setting bounds its preparation, not its result — the hook's
+ * `firstKeptEntryId` is used verbatim — so we choose the cut point ourselves and then own the
+ * consequence: the range we summarise has to reach our cut point, or the entries between the
+ * host's summarised range and our cut point would be dropped from the session's context without
+ * ever being summarised.
+ */
+export function prepareCompaction(
+  branchEntries: SessionEntry[],
+  host: SummarizationPreparation,
+  keptWindowTokens: number,
+): SummarizationPreparation | undefined {
+  const projected = buildSessionProjection(branchEntries).entries;
+  const previousIndex = projected.findIndex((entry) => entry.sourceEntry.type === 'compaction' && entry.messages.length > 0);
+  const boundaryStart = previousIndex >= 0 ? previousIndex + 1 : 0;
+  // shortcut: findCutPoint() measures the raw entries rather than the projected ones the host's own
+  // preparation uses, so an entry carrying a context edit counts at its full size and the kept window
+  // lands smaller than its target — the safe direction for base context. Correcting it means
+  // reimplementing the host's cut-point search over projected sizes, which is more duplication than
+  // the overshoot costs; do it if a measured kept window proves too thin.
+  const sources = projected.map((entry) => entry.sourceEntry);
+  const cut = findCutPoint(sources, boundaryStart, sources.length, keptWindowTokens);
+  const firstKept = projected[cut.firstKeptEntryIndex]?.sourceEntry;
+  if (!firstKept?.id) return undefined;
+
+  // Everything from the previous compaction's boundary up to our cut point, in one of the two
+  // ranges the host summarises. Nothing between them may fall through.
+  const collect = (from: number, to: number): AgentMessage[] =>
+    projected.slice(from, to).flatMap((entry) =>
+      entry.sourceEntry.type === 'compaction' ? [] : entry.messages.filter((message) => message.role !== 'system'),
+    );
+  const historyEnd = cut.isSplitTurn ? cut.turnStartIndex : cut.firstKeptEntryIndex;
+  const messagesToSummarize = collect(boundaryStart, historyEnd);
+  const turnPrefixMessages = cut.isSplitTurn ? collect(cut.turnStartIndex, cut.firstKeptEntryIndex) : [];
+  // Nothing to summarise. On a split turn with an empty history range the host carries the previous
+  // summary forward verbatim and appends a fresh turn prefix to it, so the result can only grow and
+  // no budget this package sets can bound it. Declining is the only honest answer.
+  if (messagesToSummarize.length === 0) return undefined;
+
+  const previous = previousIndex >= 0 ? projected[previousIndex].sourceEntry : undefined;
+  return {
+    firstKeptEntryId: firstKept.id,
+    messagesToSummarize,
+    turnPrefixMessages,
+    isSplitTurn: cut.isSplitTurn,
+    tokensBefore: host.tokensBefore,
+    previousSummary: host.previousSummary,
+    fileOps: curateFileOps(host.fileOps, previous),
+    settings: host.settings,
+  };
+}
+
+/**
+ * Bounded file lists, and no inheritance.
+ *
+ * The host seeds its file operations from the previous compaction's `details` unless that
+ * compaction came from a hook, which is how the lists used to compound across compactions. We drop
+ * that seed ourselves so the first compaction after a native one does not carry its lists either.
+ *
+ * shortcut: the host extracted these from its own summarised range, which ends at its cut point
+ * rather than ours, so paths touched only in the last few thousand tokens before our cut point are
+ * not listed. Extract from our own range when the summary's file index proves too thin.
+ */
+function curateFileOps(hostOps: FileOperations, previous: SessionEntry | undefined): FileOperations {
+  const inherited = previous?.type === 'compaction' && !previous.fromHook ? readDetails(previous.details) : undefined;
+  const cap = (values: Set<string>, drop: string[] | undefined): Set<string> => {
+    const excluded = new Set(drop ?? []);
+    return new Set([...values].filter((value) => !excluded.has(value)).sort().slice(0, MAX_FILE_LIST_ENTRIES));
+  };
+  return {
+    read: cap(hostOps.read, inherited?.readFiles),
+    written: cap(hostOps.written, inherited?.modifiedFiles),
+    edited: cap(hostOps.edited, inherited?.modifiedFiles),
+  };
+}
+
+function readDetails(details: unknown): { readFiles?: string[]; modifiedFiles?: string[] } | undefined {
+  if (!details || typeof details !== 'object') return undefined;
+  const record = details as { readFiles?: unknown; modifiedFiles?: unknown };
+  const strings = (value: unknown) => (Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : undefined);
+  return { readFiles: strings(record.readFiles), modifiedFiles: strings(record.modifiedFiles) };
+}

package/src/summarizer.ts

@@ -0,0 +1,279 @@
+import { compact, DEFAULT_COMPACTION_SETTINGS } from '@earendil-works/pi-coding-agent';
+import type { ExtensionContext, ModelRegistry } from '@earendil-works/pi-coding-agent';
+import type { ThinkingLevel, Tuple } from './config.ts';
+
+/**
+ * Every type this module needs is derived from `compact()`'s own signature. That signature is one of
+ * the three seams checked at activation, so deriving from it keeps the check and the call in step.
+ */
+type CompactArguments = Parameters<typeof compact>;
+export type SummarizerModel = CompactArguments[1];
+export type SummarizerStream = NonNullable<CompactArguments[7]>;
+/** The host does not export this name; `compact()`'s first parameter is the same type. */
+export type SummarizationPreparation = CompactArguments[0];
+type StreamOptions = NonNullable<Parameters<SummarizerStream>[2]>;
+
+const LEVELS: ThinkingLevel[] = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+
+export function resolveSummarizerModel(tuple: Tuple, ctx: ExtensionContext): SummarizerModel | undefined {
+  if (tuple.model === null) return ctx.model;
+  const separator = tuple.model.indexOf('/');
+  return ctx.modelRegistry.find(tuple.model.slice(0, separator), tuple.model.slice(separator + 1));
+}
+
+/** The host's own clamping: prefer a higher supported level, then a lower one. */
+export function clampThinkingLevel(model: SummarizerModel, level: ThinkingLevel): ThinkingLevel {
+  const available = supportedThinkingLevels(model);
+  if (available.includes(level)) return level;
+  const requested = LEVELS.indexOf(level);
+  if (requested === -1) return available[0] ?? 'off';
+  for (let index = requested; index < LEVELS.length; index++) {
+    if (available.includes(LEVELS[index]!)) return LEVELS[index]!;
+  }
+  for (let index = requested - 1; index >= 0; index--) {
+    if (available.includes(LEVELS[index]!)) return LEVELS[index]!;
+  }
+  return available[0] ?? 'off';
+}
+
+function supportedThinkingLevels(model: SummarizerModel): ThinkingLevel[] {
+  const map = (model as { reasoning?: boolean; thinkingLevelMap?: Record<string, unknown> });
+  if (!map.reasoning) return ['off'];
+  return LEVELS.filter((level) => {
+    const mapped = map.thinkingLevelMap?.[level];
+    if (mapped === null) return false;
+    return level === 'xhigh' || level === 'max' ? mapped !== undefined : true;
+  });
+}
+
+/**
+ * The level the summarizer runs at.
+ *
+ * A model that does not support the requested level gets the host's own clamp, so a preset can never
+ * produce a request the model rejects. A model whose `thinkingLevelMap` marks `off` unsupported
+ * therefore reasons even when `off` was asked for, and the status view reports the level that was
+ * actually used rather than the one that was requested.
+ */
+export function summarizerThinkingLevel(model: SummarizerModel, tuple: Tuple): ThinkingLevel {
+  return clampThinkingLevel(model, tuple.thinking);
+}
+
+/** What the provider's own response said about a summarization attempt. */
+export interface AttemptOutcome {
+  /** The response's `stopReason`; undefined when the provider sent none we recognise. */
+  stopReason?: string;
+  /** Whether the response tried to call a tool instead of writing a summary. */
+  toolCall: boolean;
+}
+
+/**
+ * The stream function this package owns.
+ *
+ * It exists for two reasons and injects nothing. The registry's own `streamSimple` resolves
+ * credentials for a summarizer on another provider, which `compact()`'s explicit api-key arguments
+ * cannot do for us. And it is where the response is read: the host turns an error and a tool call
+ * into thrown errors whose prose would otherwise have to be string-matched, and it returns a
+ * partially written summary **unchanged** for any other stop reason — `aborted` being the case the
+ * specification names. Refusing to persist one is this package's entire quality guarantee, so the
+ * stop reason has to be read from the response rather than inferred.
+ *
+ * That read rests on a third host seam: the host awaits `result()` on whatever this function returns,
+ * so the replacement installed below is the one it calls. Without it no outcome is recorded at all —
+ * a silent, quality-only failure, which is why `checkHostSeam` probes for it.
+ */
+export function observingStream(
+  registry: ModelRegistry,
+  observe?: (group: object, outcome: AttemptOutcome) => void,
+): SummarizerStream {
+  return ((model: SummarizerModel, context: unknown, options?: StreamOptions) => {
+    const stream = registry.streamSimple(model, context as never, options) as { result: () => Promise<unknown> };
+    if (!observe) return stream;
+    const result = stream.result.bind(stream);
+    stream.result = async () => {
+      const message = await result();
+      // The group is the context this response came from, and it is what separates a retry from a
+      // split turn. The host's retry policy calls the stream function again with the *same* context
+      // after a transient failure, and only the response it finally returns is the one `compact()`
+      // acts on — so a later response replaces an earlier one in that group, and a discarded failure
+      // must not be read as the attempt's outcome. A split turn summarises two ranges through two
+      // different contexts, and each of those has to be clean on its own.
+      observe(context as object, outcomeOf(message));
+      return message;
+    };
+    return stream;
+  }) as unknown as SummarizerStream;
+}
+
+function outcomeOf(message: unknown): AttemptOutcome {
+  const response = (message ?? {}) as { stopReason?: unknown; content?: unknown };
+  const content = Array.isArray(response.content) ? response.content : [];
+  return {
+    ...(typeof response.stopReason === 'string' ? { stopReason: response.stopReason } : {}),
+    toolCall: content.some((block) => (block as { type?: unknown } | null)?.type === 'toolCall'),
+  };
+}
+
+export interface RetryPolicy {
+  enabled: boolean;
+  maxRetries: number;
+  baseDelayMs: number;
+  maxAgentDelayMs: number;
+}
+
+/**
+ * The host's resolved retry policy for a summarization request.
+ *
+ * shortcut: this repeats `SettingsManager.getRetrySettings()` — the same four defaults over the raw
+ * merged settings — because an extension is handed merged rather than resolved settings. Passing no
+ * policy at all is worse than it looks: the host wraps every summarization call in
+ * `retryAssistantCall()` precisely so a transient stream drop does not fail the compaction, and that
+ * wrapper never retries without a policy. On a summary request that runs for minutes, a dropped
+ * socket would then fail the whole compaction on the first attempt — strictly worse than the native
+ * path it wraps. Read the resolved policy from the extension API when the host exposes one.
+ */
+export function hostRetryPolicy(settings: { retry?: Partial<RetryPolicy> }): RetryPolicy {
+  return {
+    enabled: settings.retry?.enabled ?? true,
+    maxRetries: settings.retry?.maxRetries ?? 3,
+    baseDelayMs: settings.retry?.baseDelayMs ?? 2_000,
+    maxAgentDelayMs: settings.retry?.maxAgentDelayMs ?? 60_000,
+  };
+}
+
+export interface SeamResult {
+  ok: boolean;
+  detail: string;
+}
+
+/**
+ * Three things the host does are not documented extension APIs: `compact()`'s argument list, the
+ * point at which it calls its stream function, and that it awaits `result()` on whatever that
+ * function returns. All three are checked rather than assumed — with an actual call through a stream
+ * function we supply, which needs no credentials and makes no request. A mismatch hands compaction
+ * back to the host instead of letting the package misbehave.
+ */
+export async function checkHostSeam(compactFn: typeof compact = compact): Promise<SeamResult> {
+  try {
+    return await probeSeam(compactFn);
+  } catch (error) {
+    return { ok: false, detail: `the seam check itself failed: ${String(error)}` };
+  }
+}
+
+async function probeSeam(compactFn: typeof compact): Promise<SeamResult> {
+  if (compactFn.length !== 12) {
+    return { ok: false, detail: `compact() takes ${compactFn.length} arguments, not 12` };
+  }
+  const seen: unknown[] = [];
+  let awaited = 0;
+  let produced = 0;
+  const stream: SummarizerStream = ((_model: unknown, _context: unknown, options?: StreamOptions) => {
+    seen.push(options);
+    return {
+      result: async () => {
+        awaited += 1;
+        produced += 1;
+        // The first attempt fails retryably, so a retry policy that reached the host's own wrapper
+        // shows up as a second call. Arity alone cannot prove the tenth argument is still the retry
+        // policy: every argument this package passes after the stream function used to be `undefined`,
+        // so a host that reordered them was harmless, and this is the first one where a wrong position
+        // would silently misroute a value the package depends on.
+        return produced === 1 ? probeErrorResponse() : probeResponse();
+      },
+    } as never;
+  }) as unknown as SummarizerStream;
+  const retry: RetryPolicy = { enabled: true, maxRetries: 1, baseDelayMs: 1, maxAgentDelayMs: 1 };
+  try {
+    await compactFn(
+      probePreparation(), probeModel(), undefined, undefined, undefined, undefined, 'off', stream,
+      undefined, retry, undefined, 'pi-compaction-seam-probe',
+    );
+  } catch (error) {
+    return { ok: false, detail: `compact() rejected a supplied stream function: ${String(error)}` };
+  }
+  const options = seen[0];
+  if (seen.length === 0 || !options || typeof options !== 'object') {
+    return { ok: false, detail: `the supplied stream function was called ${seen.length} times with ${typeof options} options` };
+  }
+  // The third seam. Without it no outcome is ever observed, so a partial summary cannot be told from
+  // a complete one and would be persisted.
+  if (awaited === 0) {
+    return {
+      ok: false,
+      detail: "compact() never awaited result() on the object our stream function returned, so a response's stopReason cannot be read",
+    };
+  }
+  if (produced < 2) {
+    return {
+      ok: false,
+      detail: 'compact() did not apply the retry policy passed in its tenth argument, so a host that '
+        + 'reordered its parameters would go undetected and the policy would be misrouted',
+    };
+  }
+  return {
+    ok: true,
+    detail: `compact() arity 12; our stream function received {${Object.keys(options).sort().join(', ')}}, `
+      + `its result() was awaited, and the retry policy we passed drove a retry (${produced} attempts)`,
+  };
+}
+
+/**
+ * A retryable failure. The message has to match the host's retryable-error pattern, or the probe's
+ * second call never happens and the retry-policy check would pass for the wrong reason.
+ */
+function probeErrorResponse() {
+  return {
+    role: 'assistant',
+    content: [],
+    stopReason: 'error',
+    errorMessage: 'server error',
+    provider: 'pi-compaction-seam-probe',
+    model: 'pi-compaction-seam-probe',
+    timestamp: Date.now(),
+    usage: {
+      input: 0, output: 0, cacheRead: 0, cacheWrite: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    },
+  };
+}
+
+function probeModel(): SummarizerModel {
+  return {
+    id: 'pi-compaction-seam-probe',
+    provider: 'pi-compaction-seam-probe',
+    name: 'pi-compaction seam probe',
+    api: 'pi-compaction-seam-probe',
+    reasoning: false,
+    input: ['text'],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 8_000,
+    maxTokens: 1_000,
+  } as unknown as SummarizerModel;
+}
+
+function probePreparation(): SummarizationPreparation {
+  return {
+    firstKeptEntryId: 'pi-compaction-seam-probe',
+    messagesToSummarize: [{ role: 'user', content: 'seam probe', timestamp: Date.now() }],
+    turnPrefixMessages: [],
+    isSplitTurn: false,
+    tokensBefore: 0,
+    fileOps: { read: new Set<string>(), written: new Set<string>(), edited: new Set<string>() },
+    settings: DEFAULT_COMPACTION_SETTINGS,
+  } as SummarizationPreparation;
+}
+
+function probeResponse() {
+  return {
+    role: 'assistant',
+    content: [{ type: 'text', text: 'seam probe' }],
+    stopReason: 'stop',
+    provider: 'pi-compaction-seam-probe',
+    model: 'pi-compaction-seam-probe',
+    timestamp: Date.now(),
+    usage: {
+      input: 0, output: 0, cacheRead: 0, cacheWrite: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    },
+  };
+}