@linxiraos/pi-snapcompact 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [1.3.0] - 2026-10-18
+
+### Breaking Changes
+
+- `providerImageBudget(provider)` and `providerFrameBudget(provider)` became `providerImageBudget(model)` and `providerFrameBudget(model)`, and `maxFramesForDataBudget(shape)` became `maxFramesForDataBudget(shape, budget)` with a required byte budget ([#15434](https://github.com/can1357/oh-my-pi/pull/15434) by [@will-bogusz](https://github.com/will-bogusz))
+- Removed `PROVIDER_IMAGE_BUDGETS` and `FRAME_DATA_BYTES_BUDGET`: image counts come from the catalog's `image-count-budget` rules, and frame byte budgets from `frameDataBytesBudget(model)` (`DEFAULT_FRAME_DATA_BYTES_BUDGET` where the host has none) ([#15434](https://github.com/can1357/oh-my-pi/pull/15434) by [@will-bogusz](https://github.com/will-bogusz))
+
+### Added
+
+- Added `plannedFrameTokens` and `Shape.frameTokensVerified`: archive sizing charges a frame its own price when the reader's `image-tokenization` rule is `verified`, and at least `FRAME_TOKEN_ESTIMATE` otherwise ([#15442](https://github.com/can1357/oh-my-pi/pull/15442) by [@will-bogusz](https://github.com/will-bogusz))
+- Added `viewWithoutThinking()`, `textWithoutThinking()`, `readerIncludesThinking()` and an optional `Archive.withoutThinking` variant, so an archive rendered with reasoning can be read by a model that must not see it; without a stored variant the view keeps only reasoning-free text and no frames ([#15436](https://github.com/can1357/oh-my-pi/pull/15436) by [@will-bogusz](https://github.com/will-bogusz))
+
+### Fixed
+
+- Fixed snapcompact frames for Claude and GPT on Cursor, including its `default` (Auto) route, being drawn at 1568–1932px, which Cursor shrank to 1024px before the model read them; frames now render at the host's catalog `image-max-edge` ([#15448](https://github.com/can1357/oh-my-pi/pull/15448) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed re-rendering an archive without reasoning keeping every paragraph after the first of a multi-paragraph `¶think:` section ([#15436](https://github.com/can1357/oh-my-pi/pull/15436) by [@will-bogusz](https://github.com/will-bogusz))
+
 ## [1.2.0] - 2026-10-12
 
 - 版本线推进至 1.1.28；本版无独立用户可见变化。

package/README.md

@@ -15,17 +15,19 @@ Built for [omp](https://github.com/can1357/oh-my-pi)'s compaction pipeline, but
 
 Frame shapes are provider-aware, chosen by SQuAD recall evals (see `research/`) against real provider billing:
 
-| Reader | Default shape | Notes |
-| --- | --- | --- |
-| Anthropic | `11on16-bw` | X.org 8x13 glyphs on an 11px advance; high-res Claude lines get 1932px frames |
-| Google | `8on22-bw` @2048 | X.org 8x13 glyphs on a 22px pitch; Gemini bills a fixed per-image budget, so larger frames are free chars |
-| OpenAI | `8on22-bw` | X.org 8x13 glyphs on a 22px pitch, sent at `detail: "original"` |
-| Unknown | Anthropic shape | Per-provider image-count budgets guard against gateways that silently drop frames |
+| Reader    | Default shape    | Notes                                                                                                     |
+| --------- | ---------------- | --------------------------------------------------------------------------------------------------------- |
+| Anthropic | `11on16-bw`      | X.org 8x13 glyphs on an 11px advance; high-res Claude lines get 1932px frames                             |
+| Google    | `8on22-bw` @2048 | X.org 8x13 glyphs on a 22px pitch; Gemini bills a fixed per-image budget, so larger frames are free chars |
+| OpenAI    | `8on22-bw`       | X.org 8x13 glyphs on a 22px pitch, sent at `detail: "original"`                                           |
+| Unknown   | Anthropic shape  | Per-provider image-count budgets guard against gateways that silently drop frames                         |
 
-`resolveShape({ api, id })` matches the model id, not just the wire API — a Claude routed through Vertex or OpenRouter keeps its Claude shape. Frames are priced by the reading model's lineage: its catalog `image-tokenization` rule (so that Claude is billed as Claude, and Opus 4.6 under the standard 1,568-token tier), falling back to the catalog rule for the wire API carrying the request when the lineage has none. A reader with neither costs `FRAME_TOKEN_ESTIMATE` per frame.
+`resolveShape({ api, id })` matches the model id, not just the wire API — a Claude routed through Vertex or OpenRouter keeps its Claude shape. Frames are priced by the reading model's lineage: its catalog `image-tokenization` rule (so that Claude is billed as Claude, and Opus 4.6 under the standard 1,568-token tier), falling back to the catalog rule for the wire API carrying the request when the lineage has none. A reader with neither costs `FRAME_TOKEN_ESTIMATE` per frame. Archive sizing (`plannedFrameTokens`) charges each frame its own price when the rule is `verified` against provider billing, and at least `FRAME_TOKEN_ESTIMATE` otherwise.
 
 Bitmap shapes keep their provider-tuned geometry and draw missing glyphs through the embedded Silver TrueType fallback one character at a time; East Asian (CJK/Kana/Hangul) glyphs render full-width across two cells so they stay legible in the narrow ASCII grid. Selecting `silver16-bw` uses Silver for the whole frame.
 
+A host that downscales images before the model reads them (catalog `image-max-edge`; Cursor fits Claude and GPT images into 1024×1024) gets frames rendered at that edge, forced variants included, so the glyphs reach the model at the size they were drawn.
+
 ## Install
 
 ```sh
@@ -42,8 +44,8 @@ Render arbitrary text into LLM image blocks:
 import { renderMany, frames, resolveShape } from "@linxiraos/pi-snapcompact";
 
 const images = renderMany(longText, { model }); // ImageContent[], first page first
-const count = frames(longText, { model });      // frame count without rendering
-const shape = resolveShape(model);              // eval-optimal Shape for the reader
+const count = frames(longText, { model }); // frame count without rendering
+const shape = resolveShape(model); // eval-optimal Shape for the reader
 ```
 
 Run a full compaction pass over prepared messages:
@@ -58,11 +60,11 @@ const result = await compact(preparation, { model });
 
 ## API surface
 
-- **Compaction**: `compact`, `CompactionPreparation`, `CompactionResult`, `getPreservedArchive`, `images`, `historyBlocks`
+- **Compaction**: `compact`, `CompactionPreparation`, `CompactionResult`, `getPreservedArchive`, `images`, `historyBlocks`, `capFrameDataBytes`
 - **Rendering**: `render`, `renderMany`, `frames`, `geometry`
 - **Shapes**: `SHAPES`, `SHAPE_VARIANTS`, `resolveShape`, `resolveShapeForText`, `idealShapeVariant`, `isShape`, `isShapeVariantName`
 - **Text**: `serializeConversation`, `normalize`, `scanRenderability`, `renderabilityProbeText`, `dimStopwords`, `wrap`
-- **Budgets**: `providerImageBudget`, `MAX_FRAMES_DEFAULT`, `FRAME_TOKEN_ESTIMATE`, `frameBilling`, `frameTokens`, `frameBillingKey`, `HQ_EDGE_FRAMES`
+- **Budgets**: `providerImageBudget`, `frameDataBytesBudget`, `MAX_FRAMES_DEFAULT`, `FRAME_TOKEN_ESTIMATE`, `frameBilling`, `frameTokens`, `frameBillingKey`, `plannedFrameTokens`, `HQ_EDGE_FRAMES`
 - **File ops**: `createFileOps`, `computeFileLists`, `upsertFileOperations`
 
 ## References

package/THIRD-PARTY-NOTICES.txt

@@ -8,8 +8,8 @@ no rights in third-party code, fonts, data, or marks identified below.
 PYTHON DEPENDENCY DISTRIBUTION ROLE
 ===================================
 
-omp-rpc has no third-party runtime dependencies. robomp declares FastAPI,
-Uvicorn, HTTPX, Pydantic, pydantic-settings, python-dotenv, Click, and omp-rpc
+zeta-rpc has no third-party runtime dependencies. robomp declares FastAPI,
+Uvicorn, HTTPX, Pydantic, pydantic-settings, python-dotenv, Click, and zeta-rpc
 as ordinary installer-resolved dependencies. The Python wheels do not vendor
 those projects; each dependency remains a separately installed distribution
 carrying its own license metadata and files. Container/system assemblers must
@@ -79,9 +79,9 @@ uutils coreutils (https://github.com/uutils/coreutils), MIT
 --------------------------------------------------------------------------------
 Covers: base32, base64, basename, cat, cksum (shared checksum machinery),
 b2sum, md5sum, sha1sum, sha224sum, sha256sum, sha384sum, sha512sum, comm, cp,
-cut, date, dirname, head, hostname, ln, ls, mkdir, mktemp, mv, nproc, paste,
-printenv, readlink, realpath, rm, seq, sort, stat, tac, tail, tee, touch, tr,
-truncate, uname, uniq, wc, whoami, yes.
+cut, date, dirname, head, hostname, ln, ls, mkdir, mktemp, mv, nl, nproc,
+paste, printenv, readlink, realpath, rm, seq, sort, stat, tac, tail, tee,
+touch, tr, truncate, uname, uniq, wc, whoami, yes.
 
   Copyright (c) uutils developers
 
@@ -824,6 +824,56 @@ public licenses.
 
 Creative Commons may be contacted at creativecommons.org.
 
+-------------------------------------------------------------------------------
+scripts/brand/fonts/ANSI Shadow.flf, scripts/brand/fonts/mini.flf
+
+Two FIGlet font files from the standard FIGlet font distribution — the
+figlet.org font set shipped by figlet.js
+(https://github.com/patorjk/figlet.js/tree/master/fonts), fetched from
+figlet.js 1.8.0 — vendored so the welcome/splash brand art
+(`packages/tui/src/prompt/welcome.ts`) is generated reproducibly and offline
+by `bun scripts/brand/generate-logo-art.ts`. Both files are unmodified and
+retain their original FIGlet headers. They are build-time inputs only: no font
+file or font data is compiled into, or shipped with, a Zeta release artifact.
+The fonts' own headers carry their terms:
+
+- `ANSI Shadow.flf` — "ANSI Shadow". Author unknown ("Font Author: ?" in the
+  header); a TheDraw-archive font converted with the FIGlet font editor
+  (http://patorjk.com/figfont-editor). Distributed under the FIGlet font
+  license as carried by the standard FIGlet font set: free to use and
+  redistribute with the header intact.
+- `mini.flf` — "mini" by Glenn Chappell (4/93), from figlet release 2.1
+  (12 Aug 1994), "Includes ISO Latin-1"; modified by Paul Burton
+  <solution@earthlink.net> 12/96. Header grant: "Permission is hereby given to
+  modify this font, as long as the modifier's name is placed on a comment
+  line."
+
+FIGlet renderer — `figlet` 1.8.0 (https://github.com/patorjk/figlet.js), a
+root devDependency used only to generate the art at build time; it is not
+imported by any runtime bundle or shipped artifact.
+
+  MIT License
+
+  Copyright (C) 2014-present Patrick Gillespie and other contributors
+
+  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.
+
 BUN / NPM DEPENDENCY INVENTORY
 ==============================
 This inventory is traversed from bun.lock, not from the host node_modules tree.

package/dist/types/snapcompact.d.ts

@@ -32,11 +32,9 @@
  *   billing (32px × 1.2, 10k-patch budget at `detail: "original"`) is
  *   area-proportional, so resolution cannot improve chars/$ — 1568 stays.
  *   `detail: "high"` would downgrade (2,500-patch cap); `original` is sent.
- * - **Unknown providers** default to `8on22-bw`. `providerImageBudget` still
- *   caps per-request images per provider so inline imaging cannot flood a
- *   request with attachments, but the old OpenRouter-specific 8-image cap is
- *   gone; routers now use the same permissive budget as direct
- *   Anthropic/Claude lines unless configured otherwise upstream.
+ * - **Unknown providers** default to `8on22-bw`. `providerImageBudget` caps
+ *   per-request images at the deployment's catalog `image-count-budget`, so
+ *   inline imaging cannot flood a request with attachments.
  *
  * The per-frame token estimate follows the reading model's catalog
  * `image-tokenization` rule (its lineage, not the gateway), so Claude behind
@@ -44,13 +42,17 @@
  * Models without a lineage rule fall back to the catalog rule for their wire
  * API; a reader with neither costs {@link FRAME_TOKEN_ESTIMATE} per frame.
  *
+ * A host that downscales every image before the model reads it (catalog
+ * `image-max-edge`, e.g. Cursor) gets frames rendered at that edge instead,
+ * so glyphs reach the model at the size they were drawn.
+ *
  * The whole pass is local and deterministic — no LLM call, no API key, no
  * latency beyond rendering. Rasterization and PNG encoding happen in native
  * code (`renderSnapcompactPng` in `crates/pi-natives/src/snapcompact.rs`).
  * Frames persist in the compaction entry's `preserveData` and are
  * re-attached to the compaction summary message on every context rebuild.
  */
-import type { Api, ImageContent, Message, TextContent } from "@linxiraos/pi-ai";
+import type { Api, ImageContent, Message, Model, TextContent } from "@linxiraos/pi-ai";
 import { type ImageSize, type ImageTokenization, type ImageTokenizationTarget } from "@linxiraos/pi-catalog/compat/image-tokenization";
 /** One eval-validated frame shape: font, cell, ink, repetition, and size. */
 export interface Shape {
@@ -78,11 +80,13 @@ export interface Shape {
     frameSize: number;
     /** Per-frame billed-token estimate for the shape's target provider. */
     frameTokenEstimate: number;
+    /** `frameTokenEstimate` comes from a catalog rule measured against provider billing. */
+    frameTokensVerified?: boolean;
     /** Resolution hint attached to frame images (OpenAI-only). */
     imageDetail?: ImageContent["detail"];
 }
 /** Geometry half of a {@link Shape}: everything except provider billing. */
-export type ShapeGeometry = Omit<Shape, "frameTokenEstimate" | "imageDetail">;
+export type ShapeGeometry = Omit<Shape, "frameTokenEstimate" | "frameTokensVerified" | "imageDetail">;
 /**
  * Frame variants exercised by the SQuAD evals in `research/` that the native
  * renderer reproduces faithfully, keyed by their research names. Font codes:
@@ -269,6 +273,11 @@ export declare function frameBilling(target: ShapeTarget | undefined): FrameBill
 export declare function frameBillingKey(billing: FrameBilling): string;
 /** Billed-token estimate for one rendered frame of `size` under `billing`. */
 export declare function frameTokens(billing: FrameBilling, size: ImageSize): number;
+/**
+ * Per-frame tokens archive sizing charges `shape`: its own price when provider
+ * billing verified it, else at least {@link FRAME_TOKEN_ESTIMATE}.
+ */
+export declare function plannedFrameTokens(shape: Shape): number;
 /** Eval-validated shapes, keyed by the provider family they won on. */
 export declare const SHAPES: {
     /** `11on16-bw`: 8x13 glyphs on an 11px advance (extra tracking), black ink.
@@ -312,7 +321,8 @@ export interface ShapeTarget {
  * Pick the frame shape for a reader. An explicit `variant` (anything but
  * `"auto"`) forces that geometry; otherwise the model id selects the
  * eval-winning shape — and frame size — for its model line, falling back to
- * the API family's winner when the model is unmeasured. Billing (token
+ * the API family's winner when the model is unmeasured. Either way the frame
+ * is no wider than the host's catalog `image-max-edge`. Billing (token
  * estimate, detail hint) is computed for the resolved frame size from the
  * model's catalog image rule. Accepts a full pi-ai `Model` or any
  * `{ api, id }` subset.
@@ -340,44 +350,46 @@ export declare const MAX_FRAMES_DEFAULT = 80;
  *  foveated archive — the session head (oldest) and the slice just before the
  *  text region (newest) — with the denser low-quality tier filling the middle. */
 export declare const HQ_EDGE_FRAMES = 3;
-/** Conservative per-frame token estimate for archive sizing and for frames of
- *  unknown size — the upper bound across shapes: high-res Claude frames hit the
- *  4,784 visual-token cap, billed at +5% margin (ceil(4784 * 1.05)). Keeps the
- *  overflow guard from undercounting a high-res archive at the raised
- *  {@link MAX_FRAMES_DEFAULT}. */
+/** Conservative per-frame token estimate for sizing archives whose frame price
+ *  is not billing-verified, and for frames of unknown size — the upper bound
+ *  across shapes: high-res Claude frames hit the 4,784 visual-token cap, billed
+ *  at +5% margin (ceil(4784 * 1.05)). Keeps the overflow guard from
+ *  undercounting a high-res archive at the raised {@link MAX_FRAMES_DEFAULT}. */
 export declare const FRAME_TOKEN_ESTIMATE = 5024;
 /** Conservative upper bound for one persisted frame's base64 payload. The
  *  measured high-res Anthropic `8x13`/`11on16` PNG frames sit around 159 KB;
  *  170 KB leaves margin for denser glyph pages without permitting multi-MB
  *  standing request bodies at large context windows. */
 export declare const FRAME_DATA_BYTES_ESTIMATE = 170000;
-/** Maximum snapcompact image base64 carried in every rebuilt provider request.
- *  Above this, provider backends can accept the HTTP body but fail mid-stream
+/** Frame payload cap for a deployment without a catalog `inline-image-byte-budget`:
+ *  an unmeasured backend can accept the HTTP body and still fail mid-stream
  *  with opaque 5xx errors. Keep this independent from visual-token budgeting:
  *  a 1M-token model can afford 70 images on paper, but not the resulting
  *  ~11 MB JSON payload on every turn. */
-export declare const FRAME_DATA_BYTES_BUDGET = 3000000;
-/** Frame-count cap implied by {@link FRAME_DATA_BYTES_BUDGET} for frames
- *  rendered by `shape`. {@link AREA_PRICED_VARIANTS} below 1932px are charged
+export declare const DEFAULT_FRAME_DATA_BYTES_BUDGET = 3000000;
+/** Base64 image bytes the archive frames riding every request to `model` may
+ *  carry: half the deployment's inline-image byte budget, else
+ *  {@link DEFAULT_FRAME_DATA_BYTES_BUDGET}. Frames are the oldest images in the
+ *  request, so the send-time byte clamp evicts them first; the other half stays
+ *  free for live screenshots. */
+export declare function frameDataBytesBudget(model: Model | undefined): number;
+/** Frame-count cap a `budget` of base64 bytes implies for frames rendered by
+ *  `shape`. {@link AREA_PRICED_VARIANTS} below 1932px are charged
  *  {@link FRAME_DATA_BYTES_ESTIMATE} scaled by pixel area; every other shape
  *  pays the full estimate. */
-export declare function maxFramesForDataBudget(shape: ShapeGeometry): number;
+export declare function maxFramesForDataBudget(shape: ShapeGeometry, budget: number): number;
 /** Base64 byte length for persisted snapcompact frames. */
 export declare function frameDataBytes(frames: readonly Pick<Frame, "data">[]): number;
-/**
- * Per-request image-count budgets by provider id. These cap how many images an
- * entire request may carry (archive/system-prompt/tool-result imaging combined).
- * The values are conservative policy caps under the vendor hard limits
- * (Anthropic 100, OpenAI 500, Gemini ~2500); unknown providers fall to a safe
- * floor rather than sending unbounded attachments.
- */
-export declare const PROVIDER_IMAGE_BUDGETS: Record<string, number>;
-/** Safe floor for unknown providers (strictest mainstream measured: Groq ~5). */
+/** Safe floor for a deployment whose catalog rules set no `image-count-budget`
+ *  (strictest mainstream measured: Groq ~5). */
 export declare const DEFAULT_PROVIDER_IMAGE_BUDGET = 5;
-/** Per-request image budget for `provider`; unknown providers get the floor. */
-export declare function providerImageBudget(provider: string | undefined): number;
-/** Archive frame cap for `provider`: image budget, never above {@link MAX_FRAMES_DEFAULT}. */
-export declare function providerFrameBudget(provider: string | undefined): number;
+/** Most images one request to `model`'s deployment may carry, archive,
+ *  system-prompt and tool-result imaging combined. */
+export declare function providerImageBudget(model: Model | undefined): number;
+/** Archive frame cap for `model`: its image budget, never above {@link MAX_FRAMES_DEFAULT}. */
+export declare function providerFrameBudget(model: Model | undefined): number;
+/** Whether `model` may get a fresh `read` result as frames (catalog `snapcompact-image-reads`, opt-in). */
+export declare function readerImagesReadResults(model: Model): boolean;
 /** Key under `CompactionEntry.preserveData` holding the frame archive. */
 export declare const PRESERVE_KEY = "snapcompact";
 /** One developed snapcompact frame: a base64 PNG plus its reading geometry. */
@@ -419,6 +431,15 @@ export interface Archive {
     textHead?: string;
     /** Newest text region kept verbatim around the imaged middle. */
     textTail?: string;
+    /** The same history re-rendered for a reader that excludes assistant
+     *  reasoning ({@link SerializeOptions.includeThinking} `false`), when this
+     *  archive carries it. Read through {@link viewWithoutThinking}. */
+    withoutThinking?: ArchiveView;
+}
+/** What a reader gets for one compaction: the summary text and the archive it introduces. */
+export interface ArchiveView {
+    summary: string;
+    archive: Archive;
 }
 export interface Geometry {
     /** Characters per row (per-column line width when `columns === 2`). */
@@ -515,7 +536,8 @@ export interface SerializeOptions {
      *  louder than archived tool noise. Defaults to `true`. */
     dimToolResults?: boolean;
     /** Serialize assistant reasoning as `¶think:` sections. Defaults to `true`.
-     *  Callers archiving for a Claude/Anthropic-dialect model set this `false`:
+     *  Callers archiving for a reader whose classifier refuses quoted reasoning
+     *  ({@link readerIncludesThinking} `false`) set this `false`:
      *  the archive frames are replayed as text into every later request, and
      *  reasoning rendered back to Claude trips its `reasoning_extraction`
      *  classifier (issue #6093). */
@@ -586,7 +608,8 @@ export declare function renderMany(text: string, options?: RenderManyOptions): P
  *  For doc shapes this wraps the text once and counts pages of `2 * rows`
  *  lines; for grid shapes it divides by the frame capacity. */
 export declare function frames(text: string, options?: Pick<RenderManyOptions, "shape" | "model" | "frameSize">): number;
-/** Validate and extract a persisted frame archive from `preserveData`. */
+/** Validate and extract a persisted frame archive from `preserveData`, with its
+ *  {@link Archive.withoutThinking} variant when that is valid too. */
 export declare function getPreservedArchive(preserveData: Record<string, unknown> | undefined): Archive | undefined;
 /** Drop the persisted frame archive ({@link PRESERVE_KEY}) from `preserveData`,
  *  returning the remaining state — or `undefined` when nothing else remains, so
@@ -620,6 +643,39 @@ export declare function images(archive: Archive): ImageContent[];
  *  Runtime-only; reconstructed from {@link Archive} on each context rebuild
  *  instead of persisted on the session entry. */
 export declare function historyBlocks(archive: Archive, options?: HistoryBlockOptions): (TextContent | ImageContent)[];
+/**
+ * Re-applies a smaller frame byte budget to blocks {@link historyBlocks} already built: keeps the newest frames that
+ * fit, priced as {@link historyBlocks} prices them, and replaces each run of dropped frames with one omission notice.
+ * Returns `blocks` itself when every frame fits.
+ */
+export declare function capFrameDataBytes(blocks: (TextContent | ImageContent)[], maxFrameDataBytes: number): (TextContent | ImageContent)[];
+/**
+ * Whether an archive read by `model` may carry assistant reasoning. The archive
+ * replays as text into every later request, and a reader whose classifier
+ * refuses reasoning quoted back into its input (the `classifier-cot-extraction`
+ * catalog axis, set for Claude: `reasoning_extraction`, issue #6093) gets
+ * `¶think:` sections and their legend left out.
+ */
+export declare function readerIncludesThinking(model: Model): boolean;
+/** Whether a snapcompact summary declares `¶think:` reasoning scopes: true for
+ *  archives rendered with {@link SerializeOptions.includeThinking}, and for
+ *  summaries written before that legend was gated on it. */
+export declare function summaryIncludesThinking(summary: string): boolean;
+/** `text` (a summary or archive source, raw or normalized) without its
+ *  `¶think:` sections, and with the reasoning scope dropped from any legend. */
+export declare function textWithoutThinking(text: string): string;
+/**
+ * What a reader that excludes assistant reasoning reads for a compaction
+ * whose summary is `summary` and archive `archive`: the archive's
+ * {@link Archive.withoutThinking} variant when it carries one, the original
+ * when its summary declares no reasoning, else a fail-closed text-only form.
+ * That form keeps no frames (pixels cannot be scrubbed), takes its text edges
+ * from the source after every `¶think:` section is removed (so a section
+ * crossing an edge cannot leak), counts the dropped middle as truncated, and
+ * re-renders the summary without the reasoning legend; `details` restores its
+ * file list.
+ */
+export declare function viewWithoutThinking(summary: string, archive: Archive, details?: CompactionDetails): ArchiveView;
 /**
  * Run a snapcompact compaction over prepared messages. Fully local: serializes
  * the discarded history, appends it to the accumulated archive source text, and

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@linxiraos/pi-snapcompact",
-	"version": "1.2.0",
+	"version": "1.3.0",
 	"description": "Bitmap-frame context compression for vision-capable LLMs",
 	"homepage": "https://linxira-os.github.io/zeta/",
 	"author": "Linxira-OS",
@@ -24,21 +24,21 @@
 	"types": "./dist/types/index.d.ts",
 	"scripts": {
 		"check": "oxlint . && oxfmt --check --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts' && bun run check:types",
-		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"check:types": "tsc -p tsconfig.json --noEmit",
 		"lint": "oxlint .",
 		"test": "bun test --parallel",
 		"fix": "oxlint --fix --fix-suggestions . && bun run fmt",
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@linxiraos/pi-ai": "1.2.0",
-		"@linxiraos/pi-catalog": "1.2.0",
-		"@linxiraos/pi-natives": "1.2.0",
-		"@linxiraos/pi-utils": "1.2.0",
-		"@linxiraos/pi-wire": "1.2.0"
+		"@linxiraos/pi-ai": "1.3.0",
+		"@linxiraos/pi-catalog": "1.3.0",
+		"@linxiraos/pi-natives": "1.3.0",
+		"@linxiraos/pi-utils": "1.3.0",
+		"@linxiraos/pi-wire": "1.3.0"
 	},
 	"devDependencies": {
-		"@types/bun": "^1.3.14"
+		"@types/bun": "1.4.3"
 	},
 	"engines": {
 		"bun": ">=1.3.14"

package/src/snapcompact.d.ts

@@ -32,11 +32,9 @@
  *   billing (32px × 1.2, 10k-patch budget at `detail: "original"`) is
  *   area-proportional, so resolution cannot improve chars/$ — 1568 stays.
  *   `detail: "high"` would downgrade (2,500-patch cap); `original` is sent.
- * - **Unknown providers** default to `8on22-bw`. `providerImageBudget` still
- *   caps per-request images per provider so inline imaging cannot flood a
- *   request with attachments, but the old OpenRouter-specific 8-image cap is
- *   gone; routers now use the same permissive budget as direct
- *   Anthropic/Claude lines unless configured otherwise upstream.
+ * - **Unknown providers** default to `8on22-bw`. `providerImageBudget` caps
+ *   per-request images at the deployment's catalog `image-count-budget`, so
+ *   inline imaging cannot flood a request with attachments.
  *
  * The per-frame token estimate follows the reading model's catalog
  * `image-tokenization` rule (its lineage, not the gateway), so Claude behind
@@ -44,13 +42,17 @@
  * Models without a lineage rule fall back to the catalog rule for their wire
  * API; a reader with neither costs {@link FRAME_TOKEN_ESTIMATE} per frame.
  *
+ * A host that downscales every image before the model reads it (catalog
+ * `image-max-edge`, e.g. Cursor) gets frames rendered at that edge instead,
+ * so glyphs reach the model at the size they were drawn.
+ *
  * The whole pass is local and deterministic — no LLM call, no API key, no
  * latency beyond rendering. Rasterization and PNG encoding happen in native
  * code (`renderSnapcompactPng` in `crates/pi-natives/src/snapcompact.rs`).
  * Frames persist in the compaction entry's `preserveData` and are
  * re-attached to the compaction summary message on every context rebuild.
  */
-import type { Api, ImageContent, Message, TextContent } from "@linxiraos/pi-ai";
+import type { Api, ImageContent, Message, Model, TextContent } from "@linxiraos/pi-ai";
 import { type ImageSize, type ImageTokenization, type ImageTokenizationTarget } from "@linxiraos/pi-catalog/compat/image-tokenization";
 /** One eval-validated frame shape: font, cell, ink, repetition, and size. */
 export interface Shape {
@@ -78,11 +80,13 @@ export interface Shape {
     frameSize: number;
     /** Per-frame billed-token estimate for the shape's target provider. */
     frameTokenEstimate: number;
+    /** `frameTokenEstimate` comes from a catalog rule measured against provider billing. */
+    frameTokensVerified?: boolean;
     /** Resolution hint attached to frame images (OpenAI-only). */
     imageDetail?: ImageContent["detail"];
 }
 /** Geometry half of a {@link Shape}: everything except provider billing. */
-export type ShapeGeometry = Omit<Shape, "frameTokenEstimate" | "imageDetail">;
+export type ShapeGeometry = Omit<Shape, "frameTokenEstimate" | "frameTokensVerified" | "imageDetail">;
 /**
  * Frame variants exercised by the SQuAD evals in `research/` that the native
  * renderer reproduces faithfully, keyed by their research names. Font codes:
@@ -269,6 +273,11 @@ export declare function frameBilling(target: ShapeTarget | undefined): FrameBill
 export declare function frameBillingKey(billing: FrameBilling): string;
 /** Billed-token estimate for one rendered frame of `size` under `billing`. */
 export declare function frameTokens(billing: FrameBilling, size: ImageSize): number;
+/**
+ * Per-frame tokens archive sizing charges `shape`: its own price when provider
+ * billing verified it, else at least {@link FRAME_TOKEN_ESTIMATE}.
+ */
+export declare function plannedFrameTokens(shape: Shape): number;
 /** Eval-validated shapes, keyed by the provider family they won on. */
 export declare const SHAPES: {
     /** `11on16-bw`: 8x13 glyphs on an 11px advance (extra tracking), black ink.
@@ -312,7 +321,8 @@ export interface ShapeTarget {
  * Pick the frame shape for a reader. An explicit `variant` (anything but
  * `"auto"`) forces that geometry; otherwise the model id selects the
  * eval-winning shape — and frame size — for its model line, falling back to
- * the API family's winner when the model is unmeasured. Billing (token
+ * the API family's winner when the model is unmeasured. Either way the frame
+ * is no wider than the host's catalog `image-max-edge`. Billing (token
  * estimate, detail hint) is computed for the resolved frame size from the
  * model's catalog image rule. Accepts a full pi-ai `Model` or any
  * `{ api, id }` subset.
@@ -340,44 +350,46 @@ export declare const MAX_FRAMES_DEFAULT = 80;
  *  foveated archive — the session head (oldest) and the slice just before the
  *  text region (newest) — with the denser low-quality tier filling the middle. */
 export declare const HQ_EDGE_FRAMES = 3;
-/** Conservative per-frame token estimate for archive sizing and for frames of
- *  unknown size — the upper bound across shapes: high-res Claude frames hit the
- *  4,784 visual-token cap, billed at +5% margin (ceil(4784 * 1.05)). Keeps the
- *  overflow guard from undercounting a high-res archive at the raised
- *  {@link MAX_FRAMES_DEFAULT}. */
+/** Conservative per-frame token estimate for sizing archives whose frame price
+ *  is not billing-verified, and for frames of unknown size — the upper bound
+ *  across shapes: high-res Claude frames hit the 4,784 visual-token cap, billed
+ *  at +5% margin (ceil(4784 * 1.05)). Keeps the overflow guard from
+ *  undercounting a high-res archive at the raised {@link MAX_FRAMES_DEFAULT}. */
 export declare const FRAME_TOKEN_ESTIMATE = 5024;
 /** Conservative upper bound for one persisted frame's base64 payload. The
  *  measured high-res Anthropic `8x13`/`11on16` PNG frames sit around 159 KB;
  *  170 KB leaves margin for denser glyph pages without permitting multi-MB
  *  standing request bodies at large context windows. */
 export declare const FRAME_DATA_BYTES_ESTIMATE = 170000;
-/** Maximum snapcompact image base64 carried in every rebuilt provider request.
- *  Above this, provider backends can accept the HTTP body but fail mid-stream
+/** Frame payload cap for a deployment without a catalog `inline-image-byte-budget`:
+ *  an unmeasured backend can accept the HTTP body and still fail mid-stream
  *  with opaque 5xx errors. Keep this independent from visual-token budgeting:
  *  a 1M-token model can afford 70 images on paper, but not the resulting
  *  ~11 MB JSON payload on every turn. */
-export declare const FRAME_DATA_BYTES_BUDGET = 3000000;
-/** Frame-count cap implied by {@link FRAME_DATA_BYTES_BUDGET} for frames
- *  rendered by `shape`. {@link AREA_PRICED_VARIANTS} below 1932px are charged
+export declare const DEFAULT_FRAME_DATA_BYTES_BUDGET = 3000000;
+/** Base64 image bytes the archive frames riding every request to `model` may
+ *  carry: half the deployment's inline-image byte budget, else
+ *  {@link DEFAULT_FRAME_DATA_BYTES_BUDGET}. Frames are the oldest images in the
+ *  request, so the send-time byte clamp evicts them first; the other half stays
+ *  free for live screenshots. */
+export declare function frameDataBytesBudget(model: Model | undefined): number;
+/** Frame-count cap a `budget` of base64 bytes implies for frames rendered by
+ *  `shape`. {@link AREA_PRICED_VARIANTS} below 1932px are charged
  *  {@link FRAME_DATA_BYTES_ESTIMATE} scaled by pixel area; every other shape
  *  pays the full estimate. */
-export declare function maxFramesForDataBudget(shape: ShapeGeometry): number;
+export declare function maxFramesForDataBudget(shape: ShapeGeometry, budget: number): number;
 /** Base64 byte length for persisted snapcompact frames. */
 export declare function frameDataBytes(frames: readonly Pick<Frame, "data">[]): number;
-/**
- * Per-request image-count budgets by provider id. These cap how many images an
- * entire request may carry (archive/system-prompt/tool-result imaging combined).
- * The values are conservative policy caps under the vendor hard limits
- * (Anthropic 100, OpenAI 500, Gemini ~2500); unknown providers fall to a safe
- * floor rather than sending unbounded attachments.
- */
-export declare const PROVIDER_IMAGE_BUDGETS: Record<string, number>;
-/** Safe floor for unknown providers (strictest mainstream measured: Groq ~5). */
+/** Safe floor for a deployment whose catalog rules set no `image-count-budget`
+ *  (strictest mainstream measured: Groq ~5). */
 export declare const DEFAULT_PROVIDER_IMAGE_BUDGET = 5;
-/** Per-request image budget for `provider`; unknown providers get the floor. */
-export declare function providerImageBudget(provider: string | undefined): number;
-/** Archive frame cap for `provider`: image budget, never above {@link MAX_FRAMES_DEFAULT}. */
-export declare function providerFrameBudget(provider: string | undefined): number;
+/** Most images one request to `model`'s deployment may carry, archive,
+ *  system-prompt and tool-result imaging combined. */
+export declare function providerImageBudget(model: Model | undefined): number;
+/** Archive frame cap for `model`: its image budget, never above {@link MAX_FRAMES_DEFAULT}. */
+export declare function providerFrameBudget(model: Model | undefined): number;
+/** Whether `model` may get a fresh `read` result as frames (catalog `snapcompact-image-reads`, opt-in). */
+export declare function readerImagesReadResults(model: Model): boolean;
 /** Key under `CompactionEntry.preserveData` holding the frame archive. */
 export declare const PRESERVE_KEY = "snapcompact";
 /** One developed snapcompact frame: a base64 PNG plus its reading geometry. */
@@ -419,6 +431,15 @@ export interface Archive {
     textHead?: string;
     /** Newest text region kept verbatim around the imaged middle. */
     textTail?: string;
+    /** The same history re-rendered for a reader that excludes assistant
+     *  reasoning ({@link SerializeOptions.includeThinking} `false`), when this
+     *  archive carries it. Read through {@link viewWithoutThinking}. */
+    withoutThinking?: ArchiveView;
+}
+/** What a reader gets for one compaction: the summary text and the archive it introduces. */
+export interface ArchiveView {
+    summary: string;
+    archive: Archive;
 }
 export interface Geometry {
     /** Characters per row (per-column line width when `columns === 2`). */
@@ -515,7 +536,8 @@ export interface SerializeOptions {
      *  louder than archived tool noise. Defaults to `true`. */
     dimToolResults?: boolean;
     /** Serialize assistant reasoning as `¶think:` sections. Defaults to `true`.
-     *  Callers archiving for a Claude/Anthropic-dialect model set this `false`:
+     *  Callers archiving for a reader whose classifier refuses quoted reasoning
+     *  ({@link readerIncludesThinking} `false`) set this `false`:
      *  the archive frames are replayed as text into every later request, and
      *  reasoning rendered back to Claude trips its `reasoning_extraction`
      *  classifier (issue #6093). */
@@ -586,7 +608,8 @@ export declare function renderMany(text: string, options?: RenderManyOptions): P
  *  For doc shapes this wraps the text once and counts pages of `2 * rows`
  *  lines; for grid shapes it divides by the frame capacity. */
 export declare function frames(text: string, options?: Pick<RenderManyOptions, "shape" | "model" | "frameSize">): number;
-/** Validate and extract a persisted frame archive from `preserveData`. */
+/** Validate and extract a persisted frame archive from `preserveData`, with its
+ *  {@link Archive.withoutThinking} variant when that is valid too. */
 export declare function getPreservedArchive(preserveData: Record<string, unknown> | undefined): Archive | undefined;
 /** Drop the persisted frame archive ({@link PRESERVE_KEY}) from `preserveData`,
  *  returning the remaining state — or `undefined` when nothing else remains, so
@@ -620,6 +643,39 @@ export declare function images(archive: Archive): ImageContent[];
  *  Runtime-only; reconstructed from {@link Archive} on each context rebuild
  *  instead of persisted on the session entry. */
 export declare function historyBlocks(archive: Archive, options?: HistoryBlockOptions): (TextContent | ImageContent)[];
+/**
+ * Re-applies a smaller frame byte budget to blocks {@link historyBlocks} already built: keeps the newest frames that
+ * fit, priced as {@link historyBlocks} prices them, and replaces each run of dropped frames with one omission notice.
+ * Returns `blocks` itself when every frame fits.
+ */
+export declare function capFrameDataBytes(blocks: (TextContent | ImageContent)[], maxFrameDataBytes: number): (TextContent | ImageContent)[];
+/**
+ * Whether an archive read by `model` may carry assistant reasoning. The archive
+ * replays as text into every later request, and a reader whose classifier
+ * refuses reasoning quoted back into its input (the `classifier-cot-extraction`
+ * catalog axis, set for Claude: `reasoning_extraction`, issue #6093) gets
+ * `¶think:` sections and their legend left out.
+ */
+export declare function readerIncludesThinking(model: Model): boolean;
+/** Whether a snapcompact summary declares `¶think:` reasoning scopes: true for
+ *  archives rendered with {@link SerializeOptions.includeThinking}, and for
+ *  summaries written before that legend was gated on it. */
+export declare function summaryIncludesThinking(summary: string): boolean;
+/** `text` (a summary or archive source, raw or normalized) without its
+ *  `¶think:` sections, and with the reasoning scope dropped from any legend. */
+export declare function textWithoutThinking(text: string): string;
+/**
+ * What a reader that excludes assistant reasoning reads for a compaction
+ * whose summary is `summary` and archive `archive`: the archive's
+ * {@link Archive.withoutThinking} variant when it carries one, the original
+ * when its summary declares no reasoning, else a fail-closed text-only form.
+ * That form keeps no frames (pixels cannot be scrubbed), takes its text edges
+ * from the source after every `¶think:` section is removed (so a section
+ * crossing an edge cannot leak), counts the dropped middle as truncated, and
+ * re-renders the summary without the reasoning legend; `details` restores its
+ * file list.
+ */
+export declare function viewWithoutThinking(summary: string, archive: Archive, details?: CompactionDetails): ArchiveView;
 /**
  * Run a snapcompact compaction over prepared messages. Fully local: serializes
  * the discarded history, appends it to the accumulated archive source text, and

package/src/snapcompact.ts

@@ -32,11 +32,9 @@
  *   billing (32px × 1.2, 10k-patch budget at `detail: "original"`) is
  *   area-proportional, so resolution cannot improve chars/$ — 1568 stays.
  *   `detail: "high"` would downgrade (2,500-patch cap); `original` is sent.
- * - **Unknown providers** default to `8on22-bw`. `providerImageBudget` still
- *   caps per-request images per provider so inline imaging cannot flood a
- *   request with attachments, but the old OpenRouter-specific 8-image cap is
- *   gone; routers now use the same permissive budget as direct
- *   Anthropic/Claude lines unless configured otherwise upstream.
+ * - **Unknown providers** default to `8on22-bw`. `providerImageBudget` caps
+ *   per-request images at the deployment's catalog `image-count-budget`, so
+ *   inline imaging cannot flood a request with attachments.
  *
  * The per-frame token estimate follows the reading model's catalog
  * `image-tokenization` rule (its lineage, not the gateway), so Claude behind
@@ -44,6 +42,10 @@
  * Models without a lineage rule fall back to the catalog rule for their wire
  * API; a reader with neither costs {@link FRAME_TOKEN_ESTIMATE} per frame.
  *
+ * A host that downscales every image before the model reads it (catalog
+ * `image-max-edge`, e.g. Cursor) gets frames rendered at that edge instead,
+ * so glyphs reach the model at the size they were drawn.
+ *
  * The whole pass is local and deterministic — no LLM call, no API key, no
  * latency beyond rendering. Rasterization and PNG encoding happen in native
  * code (`renderSnapcompactPng` in `crates/pi-natives/src/snapcompact.rs`).
@@ -51,17 +53,21 @@
  * re-attached to the compaction summary message on every context rebuild.
  */
 
-import type { Api, ImageContent, Message, TextContent } from "@linxiraos/pi-ai";
+import type { Api, ImageContent, Message, Model, TextContent } from "@linxiraos/pi-ai";
+import { reachesOfficialEndpoint } from "@linxiraos/pi-ai/providers/anthropic-state";
+import { resolveCatalogPolicy } from "@linxiraos/pi-catalog/compat/catalog-policy";
 import {
 	type ImageSize,
 	type ImageTokenization,
 	type ImageTokenizationTarget,
 	imageTokens,
+	resolveImageMaxEdge,
 	resolveImageTokenization,
 } from "@linxiraos/pi-catalog/compat/image-tokenization";
+import { resolveImageCountBudget, resolveInlineImageByteBudget } from "@linxiraos/pi-catalog/compat/request-size";
 import { classifyModel, compareRevision, parseRevision } from "@linxiraos/pi-catalog/identity";
 import { renderSnapcompactPng, snapcompactSupportedChars } from "@linxiraos/pi-natives";
-import { formatGroupedPaths, prompt } from "@linxiraos/pi-utils";
+import { formatGroupedPaths, isRecord, prompt } from "@linxiraos/pi-utils";
 import { INTENT_FIELD } from "@linxiraos/pi-wire";
 import fileOperationsTemplate from "./prompts/file-operations.md" with { type: "text" };
 import snapcompactSummaryPrompt from "./prompts/snapcompact-summary.md" with { type: "text" };
@@ -96,12 +102,14 @@ export interface Shape {
 	frameSize: number;
 	/** Per-frame billed-token estimate for the shape's target provider. */
 	frameTokenEstimate: number;
+	/** `frameTokenEstimate` comes from a catalog rule measured against provider billing. */
+	frameTokensVerified?: boolean;
 	/** Resolution hint attached to frame images (OpenAI-only). */
 	imageDetail?: ImageContent["detail"];
 }
 
 /** Geometry half of a {@link Shape}: everything except provider billing. */
-export type ShapeGeometry = Omit<Shape, "frameTokenEstimate" | "imageDetail">;
+export type ShapeGeometry = Omit<Shape, "frameTokenEstimate" | "frameTokensVerified" | "imageDetail">;
 
 /**
  * Frame variants exercised by the SQuAD evals in `research/` that the native
@@ -273,7 +281,22 @@ export function frameTokens(billing: FrameBilling, size: ImageSize): number {
 function priceShape(base: ShapeGeometry, target: ShapeTarget | undefined): Shape {
 	const billing = frameBilling(target);
 	const frameTokenEstimate = frameTokens(billing, { width: base.frameSize, height: base.frameSize });
-	return { ...base, frameTokenEstimate, ...(billing.imageDetail && { imageDetail: billing.imageDetail }) };
+	return {
+		...base,
+		frameTokenEstimate,
+		...(billing.rule?.verified && { frameTokensVerified: true }),
+		...(billing.imageDetail && { imageDetail: billing.imageDetail }),
+	};
+}
+
+/**
+ * Per-frame tokens archive sizing charges `shape`: its own price when provider
+ * billing verified it, else at least {@link FRAME_TOKEN_ESTIMATE}.
+ */
+export function plannedFrameTokens(shape: Shape): number {
+	return shape.frameTokensVerified
+		? shape.frameTokenEstimate
+		: Math.max(FRAME_TOKEN_ESTIMATE, shape.frameTokenEstimate);
 }
 
 /** Eval-validated shapes, keyed by the provider family they won on. */
@@ -320,6 +343,7 @@ export function isShape(value: unknown): value is Shape {
 		shape.frameSize > 0 &&
 		typeof shape.frameTokenEstimate === "number" &&
 		shape.frameTokenEstimate > 0 &&
+		(shape.frameTokensVerified === undefined || typeof shape.frameTokensVerified === "boolean") &&
 		(detail === undefined || detail === "auto" || detail === "low" || detail === "high" || detail === "original")
 	);
 }
@@ -414,16 +438,23 @@ export interface ShapeTarget {
  * Pick the frame shape for a reader. An explicit `variant` (anything but
  * `"auto"`) forces that geometry; otherwise the model id selects the
  * eval-winning shape — and frame size — for its model line, falling back to
- * the API family's winner when the model is unmeasured. Billing (token
+ * the API family's winner when the model is unmeasured. Either way the frame
+ * is no wider than the host's catalog `image-max-edge`. Billing (token
  * estimate, detail hint) is computed for the resolved frame size from the
  * model's catalog image rule. Accepts a full pi-ai `Model` or any
  * `{ api, id }` subset.
  */
 export function resolveShape(model?: ShapeTarget, variant?: ShapeVariantName | "auto"): Shape {
-	if (variant && variant !== "auto") return priceShape(SHAPE_VARIANTS[variant], model);
+	if (variant && variant !== "auto") return priceShape(fitHostImageEdge(SHAPE_VARIANTS[variant], model), model);
 	const ideal = model?.id ? idealShapeVariant(model.id) : undefined;
 	const base = SHAPE_VARIANTS[ideal?.variant ?? FAMILY_VARIANT[apiFamily(model?.api)]];
-	return priceShape(ideal?.frameSize ? { ...base, frameSize: ideal.frameSize } : base, model);
+	return priceShape(fitHostImageEdge(ideal?.frameSize ? { ...base, frameSize: ideal.frameSize } : base, model), model);
+}
+
+/** Shrink `base` to the longest image edge `target`'s host passes to the model. */
+function fitHostImageEdge(base: ShapeGeometry, target: ShapeTarget | undefined): ShapeGeometry {
+	const maxEdge = target ? resolveImageMaxEdge(target) : undefined;
+	return maxEdge !== undefined && base.frameSize > maxEdge ? { ...base, frameSize: maxEdge } : base;
 }
 
 const CJK_HEAVY_MIN_WIDE_CHARS = 8;
@@ -483,11 +514,11 @@ export const MAX_FRAMES_DEFAULT = 80;
  *  text region (newest) — with the denser low-quality tier filling the middle. */
 export const HQ_EDGE_FRAMES = 3;
 
-/** Conservative per-frame token estimate for archive sizing and for frames of
- *  unknown size — the upper bound across shapes: high-res Claude frames hit the
- *  4,784 visual-token cap, billed at +5% margin (ceil(4784 * 1.05)). Keeps the
- *  overflow guard from undercounting a high-res archive at the raised
- *  {@link MAX_FRAMES_DEFAULT}. */
+/** Conservative per-frame token estimate for sizing archives whose frame price
+ *  is not billing-verified, and for frames of unknown size — the upper bound
+ *  across shapes: high-res Claude frames hit the 4,784 visual-token cap, billed
+ *  at +5% margin (ceil(4784 * 1.05)). Keeps the overflow guard from
+ *  undercounting a high-res archive at the raised {@link MAX_FRAMES_DEFAULT}. */
 export const FRAME_TOKEN_ESTIMATE = 5024;
 
 /** Conservative upper bound for one persisted frame's base64 payload. The
@@ -496,22 +527,32 @@ export const FRAME_TOKEN_ESTIMATE = 5024;
  *  standing request bodies at large context windows. */
 export const FRAME_DATA_BYTES_ESTIMATE = 170_000;
 
-/** Maximum snapcompact image base64 carried in every rebuilt provider request.
- *  Above this, provider backends can accept the HTTP body but fail mid-stream
+/** Frame payload cap for a deployment without a catalog `inline-image-byte-budget`:
+ *  an unmeasured backend can accept the HTTP body and still fail mid-stream
  *  with opaque 5xx errors. Keep this independent from visual-token budgeting:
  *  a 1M-token model can afford 70 images on paper, but not the resulting
  *  ~11 MB JSON payload on every turn. */
-export const FRAME_DATA_BYTES_BUDGET = 3_000_000;
+export const DEFAULT_FRAME_DATA_BYTES_BUDGET = 3_000_000;
+
+/** Base64 image bytes the archive frames riding every request to `model` may
+ *  carry: half the deployment's inline-image byte budget, else
+ *  {@link DEFAULT_FRAME_DATA_BYTES_BUDGET}. Frames are the oldest images in the
+ *  request, so the send-time byte clamp evicts them first; the other half stays
+ *  free for live screenshots. */
+export function frameDataBytesBudget(model: Model | undefined): number {
+	const inlineBudget = model ? resolveInlineImageByteBudget(model, reachesOfficialEndpoint(model)) : undefined;
+	return inlineBudget === undefined ? DEFAULT_FRAME_DATA_BYTES_BUDGET : Math.floor(inlineBudget / 2);
+}
 
 /** Default edge variants whose frames shrink with pixel area. Inkier variants
  *  keep the full {@link FRAME_DATA_BYTES_ESTIMATE} at any frame size. */
 const AREA_PRICED_VARIANTS: readonly ShapeGeometry[] = [SHAPE_VARIANTS["8on22-bw"], SHAPE_VARIANTS["11on16-bw"]];
 
-/** Frame-count cap implied by {@link FRAME_DATA_BYTES_BUDGET} for frames
- *  rendered by `shape`. {@link AREA_PRICED_VARIANTS} below 1932px are charged
+/** Frame-count cap a `budget` of base64 bytes implies for frames rendered by
+ *  `shape`. {@link AREA_PRICED_VARIANTS} below 1932px are charged
  *  {@link FRAME_DATA_BYTES_ESTIMATE} scaled by pixel area; every other shape
  *  pays the full estimate. */
-export function maxFramesForDataBudget(shape: ShapeGeometry): number {
+export function maxFramesForDataBudget(shape: ShapeGeometry, budget: number): number {
 	const areaPriced = AREA_PRICED_VARIANTS.some(
 		variant =>
 			variant.font === shape.font &&
@@ -525,7 +566,7 @@ export function maxFramesForDataBudget(shape: ShapeGeometry): number {
 	);
 	const areaRatio = areaPriced ? (shape.frameSize / HIGH_RES_ANTHROPIC_VARIANT.frameSize) ** 2 : 1;
 	const frameBytes = Math.min(FRAME_DATA_BYTES_ESTIMATE, Math.ceil(FRAME_DATA_BYTES_ESTIMATE * areaRatio));
-	return Math.max(1, Math.floor(FRAME_DATA_BYTES_BUDGET / frameBytes));
+	return Math.max(1, Math.floor(budget / frameBytes));
 }
 
 /** Base64 byte length for persisted snapcompact frames. */
@@ -533,36 +574,27 @@ export function frameDataBytes(frames: readonly Pick<Frame, "data">[]): number {
 	return frames.reduce((sum, frame) => sum + frame.data.length, 0);
 }
 
-/**
- * Per-request image-count budgets by provider id. These cap how many images an
- * entire request may carry (archive/system-prompt/tool-result imaging combined).
- * The values are conservative policy caps under the vendor hard limits
- * (Anthropic 100, OpenAI 500, Gemini ~2500); unknown providers fall to a safe
- * floor rather than sending unbounded attachments.
- */
-export const PROVIDER_IMAGE_BUDGETS: Record<string, number> = {
-	anthropic: 90,
-	"amazon-bedrock": 90,
-	openai: 200,
-	"openai-codex": 200,
-	google: 200,
-	"google-vertex": 200,
-	"google-gemini-cli": 200,
-	openrouter: 90,
-	umans: 10,
-};
-
-/** Safe floor for unknown providers (strictest mainstream measured: Groq ~5). */
+/** Safe floor for a deployment whose catalog rules set no `image-count-budget`
+ *  (strictest mainstream measured: Groq ~5). */
 export const DEFAULT_PROVIDER_IMAGE_BUDGET = 5;
 
-/** Per-request image budget for `provider`; unknown providers get the floor. */
-export function providerImageBudget(provider: string | undefined): number {
-	return (provider !== undefined ? PROVIDER_IMAGE_BUDGETS[provider] : undefined) ?? DEFAULT_PROVIDER_IMAGE_BUDGET;
+/** Most images one request to `model`'s deployment may carry, archive,
+ *  system-prompt and tool-result imaging combined. */
+export function providerImageBudget(model: Model | undefined): number {
+	return (
+		(model ? resolveImageCountBudget(model, reachesOfficialEndpoint(model)) : undefined) ??
+		DEFAULT_PROVIDER_IMAGE_BUDGET
+	);
+}
+
+/** Archive frame cap for `model`: its image budget, never above {@link MAX_FRAMES_DEFAULT}. */
+export function providerFrameBudget(model: Model | undefined): number {
+	return Math.min(providerImageBudget(model), MAX_FRAMES_DEFAULT);
 }
 
-/** Archive frame cap for `provider`: image budget, never above {@link MAX_FRAMES_DEFAULT}. */
-export function providerFrameBudget(provider: string | undefined): number {
-	return Math.min(providerImageBudget(provider), MAX_FRAMES_DEFAULT);
+/** Whether `model` may get a fresh `read` result as frames (catalog `snapcompact-image-reads`, opt-in). */
+export function readerImagesReadResults(model: Model): boolean {
+	return resolveCatalogPolicy(model).snapcompactImageReads === true;
 }
 
 /** Key under `CompactionEntry.preserveData` holding the frame archive. */
@@ -612,6 +644,16 @@ export interface Archive {
 	textHead?: string;
 	/** Newest text region kept verbatim around the imaged middle. */
 	textTail?: string;
+	/** The same history re-rendered for a reader that excludes assistant
+	 *  reasoning ({@link SerializeOptions.includeThinking} `false`), when this
+	 *  archive carries it. Read through {@link viewWithoutThinking}. */
+	withoutThinking?: ArchiveView;
+}
+
+/** What a reader gets for one compaction: the summary text and the archive it introduces. */
+export interface ArchiveView {
+	summary: string;
+	archive: Archive;
 }
 
 export interface Geometry {
@@ -803,7 +845,8 @@ export interface SerializeOptions {
 	 *  louder than archived tool noise. Defaults to `true`. */
 	dimToolResults?: boolean;
 	/** Serialize assistant reasoning as `¶think:` sections. Defaults to `true`.
-	 *  Callers archiving for a Claude/Anthropic-dialect model set this `false`:
+	 *  Callers archiving for a reader whose classifier refuses quoted reasoning
+	 *  ({@link readerIncludesThinking} `false`) set this `false`:
 	 *  the archive frames are replayed as text into every later request, and
 	 *  reasoning rendered back to Claude trips its `reasoning_extraction`
 	 *  classifier (issue #6093). */
@@ -1736,9 +1779,8 @@ export function frames(text: string, options?: Pick<RenderManyOptions, "shape" |
 // Archive helpers
 // ============================================================================
 
-/** Validate and extract a persisted frame archive from `preserveData`. */
-export function getPreservedArchive(preserveData: Record<string, unknown> | undefined): Archive | undefined {
-	const candidate = preserveData?.[PRESERVE_KEY];
+/** Validate one persisted archive object (frames, counters, text regions). */
+function validateArchive(candidate: unknown): Archive | undefined {
 	if (!candidate || typeof candidate !== "object") return undefined;
 	const archive = candidate as Archive;
 	const frames = Array.isArray(archive.frames)
@@ -1769,6 +1811,18 @@ export function getPreservedArchive(preserveData: Record<string, unknown> | unde
 	};
 }
 
+/** Validate and extract a persisted frame archive from `preserveData`, with its
+ *  {@link Archive.withoutThinking} variant when that is valid too. */
+export function getPreservedArchive(preserveData: Record<string, unknown> | undefined): Archive | undefined {
+	const slot = preserveData?.[PRESERVE_KEY];
+	const archive = validateArchive(slot);
+	if (!archive || !isRecord(slot) || !isRecord(slot.withoutThinking)) return archive;
+	const { summary, archive: variant } = slot.withoutThinking;
+	if (typeof summary !== "string" || !summary) return archive;
+	const variantArchive = validateArchive(variant);
+	return variantArchive ? { ...archive, withoutThinking: { summary, archive: variantArchive } } : archive;
+}
+
 /** Drop the persisted frame archive ({@link PRESERVE_KEY}) from `preserveData`,
  *  returning the remaining state — or `undefined` when nothing else remains, so
  *  an empty `{}` is never persisted. Callers strip the archive once its frames
@@ -1971,6 +2025,53 @@ export function historyBlocks(archive: Archive, options: HistoryBlockOptions = {
 	return blocks;
 }
 
+/**
+ * Re-applies a smaller frame byte budget to blocks {@link historyBlocks} already built: keeps the newest frames that
+ * fit, priced as {@link historyBlocks} prices them, and replaces each run of dropped frames with one omission notice.
+ * Returns `blocks` itself when every frame fits.
+ */
+export function capFrameDataBytes(
+	blocks: (TextContent | ImageContent)[],
+	maxFrameDataBytes: number,
+): (TextContent | ImageContent)[] {
+	const kept = new Set<number>();
+	let usedBytes = 0;
+	let dropped = false;
+	for (let index = blocks.length - 1; index >= 0; index--) {
+		const block = blocks[index];
+		if (block.type !== "image") continue;
+		if (usedBytes + block.data.length > maxFrameDataBytes) {
+			dropped = true;
+			continue;
+		}
+		usedBytes += block.data.length;
+		kept.add(index);
+	}
+	if (!dropped) return blocks;
+
+	const capped: (TextContent | ImageContent)[] = [];
+	let omittedFrames = 0;
+	let omittedBytes = 0;
+	const flushOmitted = (): void => {
+		if (omittedFrames === 0) return;
+		capped.push({ type: "text", text: omittedFrameNotice(omittedFrames, omittedBytes) });
+		omittedFrames = 0;
+		omittedBytes = 0;
+	};
+	for (let index = 0; index < blocks.length; index++) {
+		const block = blocks[index];
+		if (block.type === "image" && !kept.has(index)) {
+			omittedFrames++;
+			omittedBytes += block.data.length;
+			continue;
+		}
+		flushOmitted();
+		capped.push(block);
+	}
+	flushOmitted();
+	return capped;
+}
+
 // ============================================================================
 // Compaction entry point
 // ============================================================================
@@ -2105,29 +2206,133 @@ function planArchive(text: string, high: Shape, low: Shape, maxFrames: number):
 	};
 }
 
+const THINK_LABEL = "¶think:";
+
+/** A scope label opening a serialized section, at the start of a line in raw
+ *  (`\n`) or normalized ({@link NEWLINE_GLYPH}) archive text. */
+const SECTION_START = new RegExp(`(?<=^|[\\n${NEWLINE_GLYPH}])(?=¶(?:user|think|ai|call):)`);
+
+const TRAILING_LINE_BREAKS = new RegExp(`[\\n${NEWLINE_GLYPH}]+$`);
+
 /**
- * Drop `¶think:` sections from serialized archive source text.
+ * Drop every `¶think:` section from archive source text: its label line and
+ * every following line up to the next scope label.
  *
- * Archives written before {@link SerializeOptions.includeThinking} existed bake
- * reasoning into their kept source; replaying it to Claude trips the
- * `reasoning_extraction` classifier (issue #6093). Re-compaction re-renders the
- * whole unfolded source, so scrubbing the prior text heals a poisoned session
- * at its next compaction. Conservative by construction: only sections that
- * start with `¶think:` at a section boundary are dropped.
+ * Archives rendered with {@link SerializeOptions.includeThinking} (or before it
+ * existed) bake reasoning into their kept source; replaying it to Claude trips
+ * the `reasoning_extraction` classifier (issue #6093). Re-rendering for a reader
+ * that excludes thinking scrubs the prior text with this. Paragraph breaks
+ * inside a thought are line breaks like any other, so a section ends only at
+ * the next label; a label inside a dimmed tool-output body is output text.
  */
 function stripThinkingSections(text: string): string {
-	return text
-		.split(NEWLINE_GLYPH)
-		.map(segment =>
-			segment
-				.split(/\n\n(?=¶(?:user|think|ai|call):)/)
-				.filter(section => !section.startsWith("¶think:"))
-				.join("\n\n"),
-		)
-		.filter(segment => segment.length > 0)
+	const sections: string[] = [];
+	let dimOpen = false;
+	for (const piece of text.split(SECTION_START)) {
+		if (dimOpen) sections[sections.length - 1] += piece;
+		else sections.push(piece);
+		const on = piece.lastIndexOf(DIM_ON);
+		const off = piece.lastIndexOf(DIM_OFF);
+		if (on !== off) dimOpen = on > off;
+	}
+	const kept = sections.filter(section => !section.startsWith(THINK_LABEL));
+	if (kept.length === sections.length) return text;
+	const stripped = kept.join("");
+	// A dropped final section leaves its predecessor's line break dangling.
+	return sections.at(-1)?.startsWith(THINK_LABEL) ? stripped.replace(TRAILING_LINE_BREAKS, "") : stripped;
+}
+
+/**
+ * Whether an archive read by `model` may carry assistant reasoning. The archive
+ * replays as text into every later request, and a reader whose classifier
+ * refuses reasoning quoted back into its input (the `classifier-cot-extraction`
+ * catalog axis, set for Claude: `reasoning_extraction`, issue #6093) gets
+ * `¶think:` sections and their legend left out.
+ */
+export function readerIncludesThinking(model: Model): boolean {
+	return resolveCatalogPolicy(model).classifierCotExtraction !== true;
+}
+
+/** Whether a snapcompact summary declares `¶think:` reasoning scopes: true for
+ *  archives rendered with {@link SerializeOptions.includeThinking}, and for
+ *  summaries written before that legend was gated on it. */
+export function summaryIncludesThinking(summary: string): boolean {
+	return summary.includes(THINK_LABEL);
+}
+
+/** The reasoning scope in a scope legend, current and earlier summary wordings
+ *  alike, wherever it sits: a summary, or one archived inside another archive. */
+const LEGEND_REASONING_SCOPE =
+	/`¶user:`, `¶think:`, (`¶ai:`, (?:and )?`¶call:`:? (?:open )?user, )assistant reasoning, /g;
+
+/** `text` (a summary or archive source, raw or normalized) without its
+ *  `¶think:` sections, and with the reasoning scope dropped from any legend. */
+export function textWithoutThinking(text: string): string {
+	return stripThinkingSections(text).replace(LEGEND_REASONING_SCOPE, "`¶user:`, $1");
+}
+
+const PREVIOUS_SUMMARY_HEAD = "[Summary of earlier history]";
+
+/**
+ * `archive`'s kept source as a reader that excludes reasoning may unfold it.
+ * An archive persisted without {@link Archive.text} keeps only its edges, and
+ * the tail's lines before its first scope label continue a section cut off in
+ * the dropped middle, whose scope is unknown; they are left out.
+ */
+function sourceForReaderWithoutThinking(archive: Archive): string {
+	if (archive.text) return archive.text;
+	const tail = archive.textTail ?? "";
+	const labelled = tail.search(SECTION_START);
+	return [archive.textHead, labelled < 0 ? "" : tail.slice(labelled)]
+		.filter((part): part is string => typeof part === "string" && part.length > 0)
 		.join(NEWLINE_GLYPH);
 }
 
+/**
+ * What a reader that excludes assistant reasoning reads for a compaction
+ * whose summary is `summary` and archive `archive`: the archive's
+ * {@link Archive.withoutThinking} variant when it carries one, the original
+ * when its summary declares no reasoning, else a fail-closed text-only form.
+ * That form keeps no frames (pixels cannot be scrubbed), takes its text edges
+ * from the source after every `¶think:` section is removed (so a section
+ * crossing an edge cannot leak), counts the dropped middle as truncated, and
+ * re-renders the summary without the reasoning legend; `details` restores its
+ * file list.
+ */
+export function viewWithoutThinking(summary: string, archive: Archive, details?: CompactionDetails): ArchiveView {
+	if (archive.withoutThinking) return archive.withoutThinking;
+	if (!summaryIncludesThinking(summary)) return { summary, archive };
+	const source = sourceForReaderWithoutThinking(archive);
+	const text = textWithoutThinking(source);
+	const headChars = archive.textHead?.length ?? 0;
+	const tailChars = archive.textTail?.length ?? 0;
+	const fits = headChars + tailChars >= text.length;
+	const textHead = fits ? text : text.slice(0, headChars);
+	const textTail = fits || tailChars === 0 ? "" : text.slice(text.length - tailChars);
+	const truncatedChars = archive.truncatedChars + (fits ? 0 : text.length - headChars - tailChars);
+	const files = details ? formatFileList(details.readFiles, details.modifiedFiles) : "";
+	return {
+		summary:
+			textHead.length === 0 && files.length === 0
+				? "No prior history."
+				: prompt.render(snapcompactSummaryPrompt, {
+						frameCount: 0,
+						truncatedChars,
+						includedPreviousSummary: text.startsWith(PREVIOUS_SUMMARY_HEAD),
+						files: files.length > 0 ? files : undefined,
+						includeThinking: false,
+					}),
+		archive: {
+			frames: [],
+			totalChars: textHead.length + textTail.length,
+			truncatedChars,
+			...(text ? { text } : {}),
+			...(textHead ? { textHead } : {}),
+			...(textTail ? { textTail } : {}),
+		},
+	};
+}
+
 /**
  * Run a snapcompact compaction over prepared messages. Fully local: serializes
  * the discarded history, appends it to the accumulated archive source text, and
@@ -2153,21 +2358,23 @@ export async function compact<TMessage = Message>(
 	const llmMessages = (options?.convertToLlm ?? defaultConvertToLlm)(messages);
 	const serialized = serializeConversation(llmMessages, options);
 	const previousArchive = getPreservedArchive(previousPreserveData);
+	const excludeThinking = options?.includeThinking === false;
 	const previousTextRaw =
-		previousArchive?.text ??
-		[previousArchive?.textHead, previousArchive?.textTail]
-			.filter((part): part is string => typeof part === "string" && part.length > 0)
-			.join(NEWLINE_GLYPH);
+		excludeThinking && previousArchive
+			? sourceForReaderWithoutThinking(previousArchive)
+			: (previousArchive?.text ??
+				[previousArchive?.textHead, previousArchive?.textTail]
+					.filter((part): part is string => typeof part === "string" && part.length > 0)
+					.join(NEWLINE_GLYPH));
 	// Legacy archives may carry `¶think:` sections from before includeThinking
-	// existed; scrub them when this compaction excludes thinking so the
-	// re-rendered archive stops replaying reasoning (issue #6093). They may
-	// also carry data URLs a pre-guard slice cut at any offset; heal those in
-	// archive context before the text is folded into the new source.
+	// existed, and any archive may carry an earlier summary's reasoning legend;
+	// scrub both when this compaction excludes thinking so the re-rendered
+	// archive stops replaying reasoning (issue #6093). They may also carry data
+	// URLs a pre-guard slice cut at any offset; heal those in archive context
+	// before the text is folded into the new source.
 	const previousTextHealed = elideDataUrls(previousTextRaw, "archive");
 	const previousText =
-		options?.includeThinking === false && previousTextHealed.length > 0
-			? stripThinkingSections(previousTextHealed)
-			: previousTextHealed;
+		excludeThinking && previousTextHealed.length > 0 ? textWithoutThinking(previousTextHealed) : previousTextHealed;
 	const hasPreviousText = previousText.length > 0;
 	const includedPreviousSummary = !hasPreviousText && !!previousSummary;
 	const shapeProbeText = renderabilityProbeText(serialized, previousPreserveData, previousSummary);
@@ -2183,7 +2390,8 @@ export async function compact<TMessage = Message>(
 	let archiveText = normalize(serialized, { shape: high });
 
 	if (includedPreviousSummary && previousSummary) {
-		const head = `[Summary of earlier history] ${normalize(previousSummary, { shape: high })}`;
+		const lead = excludeThinking ? textWithoutThinking(previousSummary) : previousSummary;
+		const head = `${PREVIOUS_SUMMARY_HEAD} ${normalize(lead, { shape: high })}`;
 		archiveText = archiveText.length > 0 ? `${head} [Recent conversation] ${archiveText}` : head;
 	}