@oh-my-pi/snapcompact 18.10.3 → 18.11.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [18.10.4] - 2026-10-13
+
+### Added
+
+- 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 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))
+
 ## [18.10.3] - 2026-10-12
 
 ### Breaking Changes

package/dist/types/snapcompact.d.ts

@@ -431,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`). */
@@ -527,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). */
@@ -598,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
@@ -638,6 +649,33 @@ export declare function historyBlocks(archive: Archive, options?: HistoryBlockOp
  * 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": "@oh-my-pi/snapcompact",
-	"version": "18.10.3",
+	"version": "18.11.0",
 	"description": "Bitmap-frame context compression for vision-capable LLMs",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -34,11 +34,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.10.3",
-		"@oh-my-pi/pi-catalog": "18.10.3",
-		"@oh-my-pi/pi-natives": "18.10.3",
-		"@oh-my-pi/pi-utils": "18.10.3",
-		"@oh-my-pi/pi-wire": "18.10.3"
+		"@oh-my-pi/pi-ai": "18.11.0",
+		"@oh-my-pi/pi-catalog": "18.11.0",
+		"@oh-my-pi/pi-natives": "18.11.0",
+		"@oh-my-pi/pi-utils": "18.11.0",
+		"@oh-my-pi/pi-wire": "18.11.0"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/snapcompact.ts

@@ -67,7 +67,7 @@ import {
 import { resolveImageCountBudget, resolveInlineImageByteBudget } from "@oh-my-pi/pi-catalog/compat/request-size";
 import { classifyModel, compareRevision, parseRevision } from "@oh-my-pi/pi-catalog/identity";
 import { renderSnapcompactPng, snapcompactSupportedChars } from "@oh-my-pi/pi-natives";
-import { formatGroupedPaths, prompt } from "@oh-my-pi/pi-utils";
+import { formatGroupedPaths, isRecord, prompt } from "@oh-my-pi/pi-utils";
 import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
 import fileOperationsTemplate from "./prompts/file-operations.md" with { type: "text" };
 import snapcompactSummaryPrompt from "./prompts/snapcompact-summary.md" with { type: "text" };
@@ -644,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 {
@@ -835,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). */
@@ -1768,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)
@@ -1801,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
@@ -2184,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
@@ -2232,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);
@@ -2262,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;
 	}