pi-tuck 1.0.1 → 1.0.3

package/CHANGELOG.md

@@ -3,6 +3,47 @@
 All notable changes to pi-tuck. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow
 [Semantic Versioning](https://semver.org/).
 
+## [1.0.3] - 2026-10-31
+
+First npm release since 1.0.1: it also carries everything listed under 1.0.2, which was tagged but not published to npm. Releases are
+now published from GitHub Actions by npm trusted publishing, with provenance.
+
+### Added
+
+- `"cutAt"` in `pi-tuck.json` (and the `cutAt` option of `installCompaction`) sets the fraction of the input room at which a cut is triggered and
+  planned: a number above 0 and at most 1. The room still decides every refusal. A cut's receipt records `cutAt` when it is not 1.
+
+### Changed
+
+- Cuts happen once a request passes 60% of the input room (`cutAt` 0.6) instead of just under the whole room. Each cut leaves room to grow,
+  so fewer tokens are carried per request: in paired replays against cutting at the full room, answers held and billed input fell about 17%
+  at a 128k window and 10-14% at 32k, with prompt caching automatic or by explicit breakpoints. `{"cutAt": 1}` restores the earlier point.
+
+## [1.0.2] - 2026-10-31
+
+Tagged, not published to npm; 1.0.3 ships it.
+
+Measured before release with paired replays against 1.0.1 (same sessions, same model as agent and judge): no loss of answer accuracy at
+a 128k or a 32k window, and time questions answered as before.
+
+### Changed
+
+- A dialogue that does not fit the summary is now shortened, oldest assistant text first, instead of replaced by a ranked selection of
+  records. The newest assistant text that fits a third of the allowance is kept until user prompts have given way; a clip that would keep
+  no text is counted in one omission notice instead.
+- Records name the time of user turns only; assistant, tool and notice records no longer carry one. Recall still returns every
+  source's time.
+- Summaries are headed `TUCK-TRANSCRIPT/2` and hold one line of plain text per record (`#12 user @2026-10-30T14:00:00Z: text`) instead
+  of one JSON object, which makes them about 30 percent shorter on sessions where the assistant writes little and about 14 percent on
+  prose-heavy ones. A passage a clip leaves out names the call that reads it back (`tuck_recall {"index":12,"offset":523}`). Summaries
+  saved by 1.0.x (`TUCK-TRANSCRIPT/1`, and `VCC-TRANSCRIPT/1` before them) are read as before and keep their format when a native
+  omission filters them.
+
+### Fixed
+
+- In small windows a session that writes little prose cut again almost every tool round (174 cuts in 300 rounds at 32k), because the
+  recent turns kept native could fill the whole input room. They now take at most half of it.
+
 ## [1.0.1] - 2026-10-30
 
 First release on npm. 1.0.0 was tagged but never published; its notes below describe what 1.0.1 ships besides these changes.
@@ -62,6 +103,8 @@ Tagged, not published.
 Source preview on GitHub, not published to npm. Deterministic compaction with `pi_tuck_recall` and `pi_tuck_search`; semantic search
 opt-in, with a runtime the user had to supply.
 
+[1.0.3]: https://github.com/galyavin/pi-tuck/releases/tag/v1.0.3
+[1.0.2]: https://github.com/galyavin/pi-tuck/tree/v1.0.2
 [1.0.1]: https://github.com/galyavin/pi-tuck/releases/tag/v1.0.1
 [1.0.0]: https://github.com/galyavin/pi-tuck/tree/v1.0.0
 [0.2.1]: https://github.com/galyavin/pi-tuck/tree/e00fa99

package/README.md

@@ -8,13 +8,13 @@ by meaning.
 ## Install
 
 ```sh
-pi install npm:pi-tuck@1.0.1
+pi install npm:pi-tuck@1.0.3
 ```
 
 or straight from GitHub:
 
 ```sh
-pi install git:github.com/galyavin/pi-tuck@v1.0.1
+pi install git:github.com/galyavin/pi-tuck@v1.0.3
 ```
 
 Requires Pi 1.1 or later (tested on 1.1.0 and 1.4.0) on macOS or Linux. Semantic search (`tuck_search` by meaning) runs only on macOS
@@ -30,9 +30,10 @@ Start a new Pi session after installing.
 - the agent's other tool calls, such as shell commands, newest first (up to 30), without their output but with pointers to it;
 - your first prompt in the session, word for word (up to 12,000 characters).
 
-Tool output is left out of the summary; it stays in the session file. If the dialogue itself is too long for the room left, the summary
-keeps a ranked selection of records instead. Each summary ends with a short instruction to the agent: re-read a file before editing it,
-and look things up rather than guess.
+Tool output is left out of the summary; it stays in the session file. If the dialogue itself is too long for the room left, it is
+shortened, oldest assistant text first, instead of being replaced by a ranked selection. Each summary ends with a short instruction to
+the agent: re-read a file before editing it, and look things up rather than guess. The summary is plain text, one line per record
+(`#12 user: ...`, where 12 is the index `tuck_recall` takes); summaries written by earlier versions are still read.
 
 **`tuck_recall`** finds earlier text by keyword and reads any original message or tool result exactly, by the index shown in a summary.
 It can also write an original back out to a file.
@@ -58,6 +59,8 @@ with a window of 32k tokens or less, lower the reserve for that model in Pi's `s
 { "compaction": { "modelOverrides": { "my-provider/my-model": { "reserveTokens": 4096 } } } }
 ```
 
+**Cut point.** pi-tuck cuts once a request passes 60% of the input room, so each cut leaves room to grow and fewer tokens are carried (and billed) per request; measured against cutting at the full room, answers held and billed input fell 10-18%. Set `"cutAt"` in `pi-tuck.json` in Pi's agent folder (`~/.pi/agent`) to change it, a number above 0 and at most 1: `{ "cutAt": 1 }` restores cutting at the full room, a lower value cuts earlier and smaller. The guard is unaffected, because the whole room still decides which request is refused.
+
 ## Semantic search
 
 Semantic search is on by default and runs entirely on your Mac: an embedding model,

package/dist/index.d.ts

@@ -6,5 +6,6 @@ export { createSemanticRecall, SemanticRecallController } from "./src/semantic-r
 export type { SemanticRecallConfig, PriorResult, SemanticState } from "./src/semantic-recall.js";
 export { ensureSemanticRuntime } from "./src/setup.js";
 /** pi-tuck as a Pi extension: compaction and history recall always; semantic recall too, unless `pi-tuck.json` in Pi's agent folder
- * says `{"semanticRecall": false}`. Its runtime is set up in the background the first time a session starts. */
+ * says `{"semanticRecall": false}`. Its runtime is set up in the background the first time a session starts. The same file's `"cutAt"`
+ * (a number above 0 and at most 1) is the fraction of the input room a cut is triggered at, 1 by default. */
 export default function (pi: ExtensionAPI): Promise<void>;

package/dist/index.js

@@ -2,6 +2,7 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { readFileSync, realpathSync } from "node:fs";
 import { join, sep } from "node:path";
 import { installCompaction } from "./src/compaction.js";
+import { validCutAt } from "./src/budget.js";
 import { createSemanticRecall } from "./src/semantic-recall.js";
 import { defaultRoot } from "./src/assets.js";
 import { ensureSemanticRuntime } from "./src/setup.js";
@@ -10,13 +11,14 @@ export { inspectIncident, readableIncident } from "./src/diagnostic-replay.js";
 export { createSemanticRecall, SemanticRecallController } from "./src/semantic-recall.js";
 export { ensureSemanticRuntime } from "./src/setup.js";
 /** pi-tuck as a Pi extension: compaction and history recall always; semantic recall too, unless `pi-tuck.json` in Pi's agent folder
- * says `{"semanticRecall": false}`. Its runtime is set up in the background the first time a session starts. */
+ * says `{"semanticRecall": false}`. Its runtime is set up in the background the first time a session starts. The same file's `"cutAt"`
+ * (a number above 0 and at most 1) is the fraction of the input room a cut is triggered at, 1 by default. */
 export default async function (pi) {
     const semanticRecall = createSemanticRecall();
     // `/tuck-semantic off` holds for the rest of the session, including over a setup that finishes later.
     let off = false;
-    const handle = await installCompaction(pi, { semanticRecall, onSemanticSetting: async (enabled) => { off = !enabled; } });
     const settings = readSettings(join(getAgentDir(), "pi-tuck.json"));
+    const handle = await installCompaction(pi, { semanticRecall, cutAt: settings.cutAt, onSemanticSetting: async (enabled) => { off = !enabled; } });
     if (settings.semanticRecall === false)
         return;
     let session = 0, said = "", setup;
@@ -74,11 +76,12 @@ function readSettings(path) {
     }
     try {
         const value = JSON.parse(text);
-        if (value && typeof value === "object" && (value.semanticRecall === undefined || typeof value.semanticRecall === "boolean"))
+        if (value && typeof value === "object" && (value.semanticRecall === undefined || typeof value.semanticRecall === "boolean") &&
+            (value.cutAt === undefined || validCutAt(value.cutAt)))
             return value;
     }
     catch { /* reported below */ }
-    return { error: `${path} should be a JSON object like {"semanticRecall": false}` };
+    return { error: `${path} should be a JSON object like {"semanticRecall": false, "cutAt": 0.8}, with cutAt a number above 0 and at most 1` };
 }
 const reason = (error) => error instanceof Error ? error.message : String(error);
 const within = (path, folder) => path === folder || path.startsWith(folder.endsWith(sep) ? folder : folder + sep);

package/dist/src/budget.d.ts

@@ -16,8 +16,17 @@ export interface ToolShape {
 }
 /** Triggers fire this fraction of the room early. The margin absorbs request growth a boundary cannot see; it never enters the calibration factor. */
 export declare const TRIGGER_MARGIN_FRACTION = 0.02;
-/** The limit a cut is triggered at and preferably planned to; the exact room stays the limit of every throw and fault. */
-export declare const bandOf: (room: number) => number;
+/** Whether `value` is a cut point: a fraction of the room above 0 and at most 1. */
+export declare const validCutAt: (value: unknown) => value is number;
+/**
+ * The one owner of the band: the limit a cut is triggered at and preferably planned to. It is the room less the margin, or the cut point
+ * `cutAt` (a fraction of the room) when that is lower. The exact room stays the limit of every throw, fault and the complete-context guard,
+ * whatever the cut point. With `cutAt` 1 the band is the room less the margin alone.
+ */
+/** The default cut point: a cut once a request passes 60% of the room. Measured against 1 with paired replays (no answer loss) and billed
+ * input under automatic and explicit prompt caching (about 17% less at 128k, 10-14% at 32k). */
+export declare const DEFAULT_CUT_AT = 0.6;
+export declare const bandOf: (room: number, cutAt?: number) => number;
 /**
  * Replayed reasoning that Pi's estimator does not see. On the OpenAI Responses APIs an assistant turn's reasoning item rides in its thinking
  * block's `thinkingSignature` (encrypted) and is sent back with later requests (pi-ai openai-responses-shared; transform-messages skips
@@ -49,7 +58,7 @@ export declare const measurableConversationTokens: (messages: Messages, ctx: Ext
 /** Raw reserve for the cut planner: the window less the raw tokens that fit the target room, plus the input no cut can remove. */
 export declare const planningReserve: (window: number, targetRoom: number, factor: number, mandatory: number) => number;
 export type Target = "band" | "room";
-/** A planned cut: the conversation it leaves, and the summary view that produced it (whole dialogue or ranked). */
+/** A planned cut: the conversation it leaves, and the summary view that produced it (whole dialogue or shrunk). */
 export type Plan<D extends object = {}> = ({
     draft: true;
     after: number;
@@ -98,12 +107,16 @@ export type Verdict<D extends object = {}> = Exclude<Decision<D>, {
 }>;
 /**
  * Rule 4. The exact room is planned first. When its plan already lands below the band it is taken as it is (target "room"): it keeps the
- * room plan's content exactly, because every allowance of the planner is derived from the reserve and the band's is 2% smaller. Only
+ * room plan's content exactly, because every allowance of the planner is derived from the reserve and the band's is smaller. Only
  * otherwise is the band planned. Inside the band a cut is opportunistic, so a failed plan is never a fault and never falls back to the
  * room (a cut that still lands in the band would trigger again every round); the exact room would cut nothing there, so a band cut is
  * taken only when the room can plan a cut too and with the same mode (a lossy view the room could not even plan is a quality change with
  * no fault to prevent). At or above the room, where a cut is due, a band plan of another mode gives way to the room plan (today's
  * view), and a band plan stands when the room has none (a cut instead of a fault).
+ * A lean band, one the cut point binds (`band < bandOf(room)`), is planned first and the room plan landing below it is not taken for that:
+ * the room plan keeps a native tail of up to half the room, so it can land just under a band that far below the room, and the next round
+ * would cut again, freeing little. The room is planned only where the rules above use it: to compare the mode, or when the band has no plan
+ * and a cut is due. With the default cut point the band is never lean and the order and the decisions are those above.
  * The margin adds no new decision fault. Exceptions thrown by `plan` are not caught here: they are faults, and they now surface at
  * boundaries inside the band too, where no planner ran before the margin.
  */

package/dist/src/budget.js

@@ -4,8 +4,20 @@ import { measurableMessages, projectedMessages } from "./omissions.js";
 import { isDiscardedResponse } from "./protocol.js";
 /** Triggers fire this fraction of the room early. The margin absorbs request growth a boundary cannot see; it never enters the calibration factor. */
 export const TRIGGER_MARGIN_FRACTION = 0.02;
-/** The limit a cut is triggered at and preferably planned to; the exact room stays the limit of every throw and fault. */
-export const bandOf = (room) => room - Math.ceil(Math.max(0, room) * TRIGGER_MARGIN_FRACTION);
+/** Whether `value` is a cut point: a fraction of the room above 0 and at most 1. */
+export const validCutAt = (value) => typeof value === "number" && value > 0 && value <= 1;
+/**
+ * The one owner of the band: the limit a cut is triggered at and preferably planned to. It is the room less the margin, or the cut point
+ * `cutAt` (a fraction of the room) when that is lower. The exact room stays the limit of every throw, fault and the complete-context guard,
+ * whatever the cut point. With `cutAt` 1 the band is the room less the margin alone.
+ */
+/** The default cut point: a cut once a request passes 60% of the room. Measured against 1 with paired replays (no answer loss) and billed
+ * input under automatic and explicit prompt caching (about 17% less at 128k, 10-14% at 32k). */
+export const DEFAULT_CUT_AT = 0.6;
+export const bandOf = (room, cutAt = 1) => {
+    const positive = Math.max(0, room);
+    return Math.min(room - Math.ceil(positive * TRIGGER_MARGIN_FRACTION), Math.floor(positive * cutAt));
+};
 /** The APIs whose request converter (pi-ai openai-responses-shared) sends each signed thinking block back as an input reasoning item. */
 const REPLAYING_APIS = new Set(["openai-responses", "azure-openai-responses", "openai-codex-responses"]);
 /**
@@ -59,29 +71,40 @@ export const measurableConversationTokens = (messages, ctx, policy) => conversat
 export const planningReserve = (window, targetRoom, factor, mandatory) => window - Math.floor(targetRoom / factor) + mandatory;
 /**
  * Rule 4. The exact room is planned first. When its plan already lands below the band it is taken as it is (target "room"): it keeps the
- * room plan's content exactly, because every allowance of the planner is derived from the reserve and the band's is 2% smaller. Only
+ * room plan's content exactly, because every allowance of the planner is derived from the reserve and the band's is smaller. Only
  * otherwise is the band planned. Inside the band a cut is opportunistic, so a failed plan is never a fault and never falls back to the
  * room (a cut that still lands in the band would trigger again every round); the exact room would cut nothing there, so a band cut is
  * taken only when the room can plan a cut too and with the same mode (a lossy view the room could not even plan is a quality change with
  * no fault to prevent). At or above the room, where a cut is due, a band plan of another mode gives way to the room plan (today's
  * view), and a band plan stands when the room has none (a cut instead of a fault).
+ * A lean band, one the cut point binds (`band < bandOf(room)`), is planned first and the room plan landing below it is not taken for that:
+ * the room plan keeps a native tail of up to half the room, so it can land just under a band that far below the room, and the next round
+ * would cut again, freeing little. The room is planned only where the rules above use it: to compare the mode, or when the band has no plan
+ * and a cut is due. With the default cut point the band is never lean and the order and the decisions are those above.
  * The margin adds no new decision fault. Exceptions thrown by `plan` are not caught here: they are faults, and they now surface at
  * boundaries inside the band too, where no planner ran before the margin.
  */
 export function chooseCut(input) {
     const { before, mandatory, room, band, fits, plan, unreduced } = input;
-    const exact = plan("room");
-    if (exact.draft && exact.after < before && fits(exact.after + mandatory, band))
-        return { kind: "cut", target: "room", plan: exact };
+    const lands = (p) => p.draft && p.after < before && fits(p.after + mandatory, band);
+    let roomPlan;
+    const exact = () => roomPlan ??= plan("room");
+    if (band >= bandOf(room)) {
+        const e = exact();
+        if (lands(e))
+            return { kind: "cut", target: "room", plan: e };
+    }
     const preferred = plan("band");
     if (input.opportunistic) {
-        if (!(preferred.draft && preferred.after < before && fits(preferred.after + mandatory, band)))
+        if (!lands(preferred))
             return { kind: "none" };
-        return exact.draft && exact.mode === preferred.mode ? { kind: "cut", target: "band", plan: preferred } : { kind: "none" };
+        const e = exact();
+        return e.draft && e.mode === preferred.mode ? { kind: "cut", target: "band", plan: preferred } : { kind: "none" };
     }
+    const e = exact();
     let chosen = preferred, target = "band";
-    if (!preferred.draft || (exact.draft && exact.mode !== preferred.mode)) {
-        chosen = exact;
+    if (!preferred.draft || (e.draft && e.mode !== preferred.mode)) {
+        chosen = e;
         target = "room";
     }
     if (!chosen.draft)

package/dist/src/build-id.d.ts

@@ -1 +1 @@
-export declare const BUILD_ID = "2a0ebe00760f2226d888fbca503dbde44d32623cb644186a6dd2eef59b65fbe5";
+export declare const BUILD_ID = "72d28833b7180debd3ea6a7ca0308b000f8d27671b42c4d2b73dfaaa7bbdad59";

package/dist/src/build-id.js

@@ -1 +1 @@
-export const BUILD_ID = "2a0ebe00760f2226d888fbca503dbde44d32623cb644186a6dd2eef59b65fbe5";
+export const BUILD_ID = "72d28833b7180debd3ea6a7ca0308b000f8d27671b42c4d2b73dfaaa7bbdad59";

package/dist/src/compaction.d.ts

@@ -27,6 +27,10 @@ export interface CompactionOptions {
     /** Optional estimated complete-input ceiling, separate from physical output reservation.
      * The host owns final serialization/transport counting; this is not an exact wire-token cap. */
     activeInputTokens?: number | ((ctx: ExtensionContext) => number);
+    /** The cut point: a fraction of the input room, above 0 and at most 1 (default 1). A cut is triggered at, and preferably planned to, the band,
+     * which is the room less 2% of it, or this fraction of the room when that is lower; a lower value cuts earlier and leaves less. The exact room
+     * stays the limit of every throw, fault and the complete-context guard. Anything else is rejected when the compactor is installed. */
+    cutAt?: number;
     /** The response reserve: the input room is the context window less this. By default the room never exceeds the window less the model's
      * catalogue maximum output, because a transport may omit the output cap and the reply can then grow to that maximum. A host that knows its
      * transport's behavior declares an exact reserve with `responseExact: true`, and the room is then the window less `response` exactly. */

package/dist/src/compaction.js

@@ -5,7 +5,7 @@ import { exportSource } from "./source-export.js";
 import { isDeepStrictEqual } from "node:util";
 import { assertNativeToolRounds } from "./protocol.js";
 import { projectedMessages } from "./omissions.js";
-import { bandOf, chooseCut, conversationTokens, decideCut, gateCut, incomingEventTokens, incomingTokens, measurableConversationTokens, planningReserve, projectedConversationTokens, requestTokens, systemPart } from "./budget.js";
+import { DEFAULT_CUT_AT, bandOf, chooseCut, conversationTokens, decideCut, gateCut, incomingEventTokens, incomingTokens, measurableConversationTokens, planningReserve, projectedConversationTokens, requestTokens, systemPart, validCutAt } from "./budget.js";
 import { isContextOverflow } from "@earendil-works/pi-ai";
 import { convertToLlm, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
@@ -81,6 +81,9 @@ export function seedWindow(branch, key) {
     return initialWindow(key);
 }
 export async function installCompaction(pi, options = {}) {
+    const cutAt = options.cutAt ?? DEFAULT_CUT_AT;
+    if (!validCutAt(cutAt))
+        throw new Error("Invalid cut point: cutAt must be a number above 0 and at most 1");
     const semantic = options.semanticRecall ?? createSemanticRecall();
     let semanticTransition = Promise.resolve();
     let semanticRequest = 0;
@@ -101,7 +104,7 @@ export async function installCompaction(pi, options = {}) {
         }
     });
     const captureDraft = (draft, ctx, reserve, reason, tokensBefore, retainCurrentInput, operatorManual, previousSummary, budget) => recorder.measureInline(() => {
-        const attached = attachReceipt(draft, reason, reserve, ctx.model?.contextWindow ?? 0, { responseReserveTokens: budget?.response, hostInputTokens: budget?.host, mandatoryInputTokens: budget?.mandatory, target: budget?.target, triggerMarginTokens: budget?.margin, calibrationFactor: factor, calibrationWindow: [...ratios], calibrationIdentity: identity, activeInputCeilingTokens: lastCeiling });
+        const attached = attachReceipt(draft, reason, reserve, ctx.model?.contextWindow ?? 0, { responseReserveTokens: budget?.response, hostInputTokens: budget?.host, mandatoryInputTokens: budget?.mandatory, target: budget?.target, triggerMarginTokens: budget?.margin, ...(cutAt === 1 ? {} : { cutAt }), calibrationFactor: factor, calibrationWindow: [...ratios], calibrationIdentity: identity, activeInputCeilingTokens: lastCeiling });
         proposalId = receiptId(attached);
         if (recorder.enabled) {
             try {
@@ -204,7 +207,7 @@ export async function installCompaction(pi, options = {}) {
     // The cut planner's raw reserve for the target limit, on the same factor as every other consumer.
     const planReserve = (target, room, mandatory, ctx) => {
         identityFor(ctx);
-        return planningReserve(ctx.model?.contextWindow ?? 0, target === "band" ? bandOf(room) : room, factor, mandatory);
+        return planningReserve(ctx.model?.contextWindow ?? 0, target === "band" ? bandOf(room, cutAt) : room, factor, mandatory);
     };
     pi.on("message_end", (event, ctx) => {
         if (event.message.role !== "assistant")
@@ -268,10 +271,10 @@ export async function installCompaction(pi, options = {}) {
             throw new Error("Invalid active-input token ceiling");
         return Math.min((ctx.model?.contextWindow ?? 0) - response, ceiling ?? Infinity);
     };
-    // The exact room, and the band a cut is triggered at (budget.ts); every throw and every fault uses the exact room.
+    // The exact room, and the band a cut is triggered at (budget.ts, from this session's cutAt); every throw and every fault uses the exact room.
     const limits = (ctx) => {
         const { response } = requestReserve(ctx), room = inputRoom(response, ctx);
-        return { response, room, band: bandOf(room) };
+        return { response, room, band: bandOf(room, cutAt) };
     };
     const fits = (tokens, limit, ctx) => corrected(tokens, ctx) < limit;
     // The saved conversation and a cut's quantities are counted by the one function the guard counts with (strict, as the context hook is).

package/dist/src/diagnostics.d.ts

@@ -1,6 +1,6 @@
 import { type RecallPolicy } from './recall.js';
 import type { SessionEntry } from '@earendil-works/pi-coding-agent';
-export declare const DIAGNOSTIC_BUILD = "2a0ebe00760f2226d888fbca503dbde44d32623cb644186a6dd2eef59b65fbe5";
+export declare const DIAGNOSTIC_BUILD = "72d28833b7180debd3ea6a7ca0308b000f8d27671b42c4d2b73dfaaa7bbdad59";
 export interface Receipt {
     id: string;
     build: string;
@@ -15,6 +15,7 @@ export interface Receipt {
         mandatoryInputTokens?: number;
         target?: 'band' | 'room';
         triggerMarginTokens?: number;
+        cutAt?: number;
         calibrationFactor?: number;
         calibrationWindow?: number[];
         calibrationIdentity?: string;

package/dist/src/omissions.d.ts

@@ -2,7 +2,7 @@ import type { ExtensionContext, SessionEntry } from '@earendil-works/pi-coding-a
 import { type RecallPolicy } from './recall.js';
 /** Native branch edits supply exclusion; original global indices supply provenance. */
 export declare function omittedSourceIndices(entries: readonly SessionEntry[], branch: readonly SessionEntry[]): ReadonlySet<number>;
-/** Preserve surviving record bytes/order. No text matching or semantic inference. */
+/** Preserve surviving record bytes/order, and the summary's format (a v1 summary stays v1). No text matching or semantic inference. */
 export declare function filterOmittedSummary(summary: string, omitted: ReadonlySet<number>): string;
 /** Custom quotes carry native entry identity; no text matching or legacy fallback. */
 export declare function filterCustomQuotes(summary: string, entries: readonly SessionEntry[], branch: readonly SessionEntry[], policy?: RecallPolicy): string;

package/dist/src/omissions.js

@@ -1,5 +1,5 @@
 import { buildGlobalIndexById } from './tuck/core/global-indices.js';
-import { TRANSCRIPT_HEADER, parseRecords, splitSummary } from './tuck/core/transcript.js';
+import { parseRecords, splitSummary, transcriptHeader } from './tuck/core/transcript.js';
 import { createRecall } from './recall.js';
 /** Native branch edits supply exclusion; original global indices supply provenance. */
 export function omittedSourceIndices(entries, branch) {
@@ -13,24 +13,24 @@ export function omittedSourceIndices(entries, branch) {
         }
     return new Set([...edits].flatMap(([id, omitted]) => omitted && indices.has(id) ? [indices.get(id)] : []));
 }
-/** Preserve surviving record bytes/order. No text matching or semantic inference. */
+/** Preserve surviving record bytes/order, and the summary's format (a v1 summary stays v1). No text matching or semantic inference. */
 export function filterOmittedSummary(summary, omitted) {
     if (!omitted.size)
         return summary;
     const split = splitSummary(summary);
     if (!split)
         throw new Error('Cannot apply native source omission to an unsupported compaction summary');
-    const { body, closing } = split;
-    const records = parseRecords(body), lines = body ? body.split('\n') : [];
+    const { body, closing, version } = split;
+    const records = parseRecords(body, version), lines = body ? body.split('\n') : [];
     const retained = records.flatMap((record, i) => (record.sourceIndex !== undefined && omitted.has(record.sourceIndex)) || record.sourceIndices?.some(index => omitted.has(index)) ? [] : [lines[i]]);
-    return TRANSCRIPT_HEADER + '\n' + retained.join('\n') + closing;
+    return transcriptHeader(version) + '\n' + retained.join('\n') + closing;
 }
 /** Custom quotes carry native entry identity; no text matching or legacy fallback. */
 export function filterCustomQuotes(summary, entries, branch, policy = {}) {
     const split = splitSummary(summary);
     if (!split)
         throw new Error('Cannot resolve custom sources in an unsupported compaction summary');
-    const { body, closing } = split;
+    const { body, closing, version } = split;
     const omitted = new Set(branch.flatMap(entry => entry.type === 'context_edit' && entry.replacement === null ? [entry.targetId] : []));
     const eligible = createRecall(policy).isHistorySource, indices = buildGlobalIndexById(entries);
     const globalCounts = new Map(), branchSources = new Map();
@@ -42,7 +42,7 @@ export function filterCustomQuotes(summary, entries, branch, policy = {}) {
         branchSources.set(entry.id, found);
     }
     const lines = body ? body.split('\n') : [];
-    const records = parseRecords(body);
+    const records = parseRecords(body, version);
     const retained = records.flatMap((record, i) => {
         if (record.role !== 'custom')
             return [lines[i]];
@@ -56,7 +56,7 @@ export function filterCustomQuotes(summary, entries, branch, policy = {}) {
             return [];
         return [lines[i]];
     });
-    return TRANSCRIPT_HEADER + '\n' + retained.join('\n') + closing;
+    return transcriptHeader(version) + '\n' + retained.join('\n') + closing;
 }
 /** The saved conversation as this compactor delivers it: native omissions and ineligible custom quotes removed from summaries. */
 export function projectedMessages(messages, ctx, policy) {

package/dist/src/tuck/core/brief.d.ts

@@ -1,49 +1,19 @@
 import type { NormalizedBlock } from "../types.js";
-import type { SourceTime } from "./source-time.js";
 import { type TranscriptRecord } from "./transcript.js";
-export declare const isSegmentClosingAssistant: (blocks: NormalizedBlock[], index: number) => boolean;
-export declare const HEREDOC_OPEN_RE: RegExp;
-/**
- * If `lines[i]` opens a heredoc whose terminator actually appears on a later
- * line, return that terminator's line index; otherwise -1. Callers use -1 to
- * leave following lines intact instead of treating a stray `<<` (a shift op, a
- * quoted string, or a truncated body) as a heredoc and skipping real commands.
- */
-export declare const heredocCloseIndex: (lines: string[], i: number) => number;
-export type CallRecord = Extract<TranscriptRecord, {
-    kind: "tool_call";
+/** The user, assistant and notice blocks of a dialogue; tool blocks are never rendered. */
+export type DialogueBlock = Extract<NormalizedBlock, {
+    kind: "user" | "assistant" | "notice";
 }>;
-/** One record is independently decodable; source text cannot create structure. */
-export type ExcerptCache = WeakMap<NormalizedBlock, Map<string, TranscriptRecord[]>>;
-/** The assistant texts that close a segment: no further text before the next user turn or the end of the chronology. */
-export declare const segmentClosing: (chronology: NormalizedBlock[]) => Set<NormalizedBlock>;
+export declare const isDialogue: (block: NormalizedBlock) => block is DialogueBlock;
 /** A user or assistant text block the omission notices count when it is unselected: non-empty, and not rendered in the mandatory base. */
 export declare const isOmittable: (block: NormalizedBlock, mandatorySources?: ReadonlySet<number>) => boolean;
-/** `sources` are the distinct locators of the omitted blocks in ascending order; at most the first 9 decide the notice. */
+/** `sources` are the distinct locators of the omitted blocks in ascending order; at most the first 9 decide the notice. They are written
+ * as "#N" on the record's line. */
 export declare const omissionRecord: (role: "user" | "assistant", count: number, sources: number[], unlocated: boolean) => TranscriptRecord;
-export declare const planBrief: (blocks: NormalizedBlock[], full: Set<NormalizedBlock>, chronology: NormalizedBlock[], mandatorySources?: ReadonlySet<number>, includeOmissions?: boolean) => void;
-/** The original call that a selected complete receipt quotes; that call's own overview is then redundant. */
-export declare const receiptKey: (b: NormalizedBlock) => string | undefined;
-/** The receipt that would make this call redundant, when the call and its single receipt are fully identified. */
-export declare const coveredCallKey: (b: NormalizedBlock) => string | undefined;
-/** What one block renders in this brief, set by the plan and by the selected array around it. */
-export interface BlockView {
-    full: boolean;
-    closing: boolean;
-    mandatory?: ReadonlySet<number>;
-    bounded: boolean;
-    covered: boolean;
-}
-/** The records of one block alone: before identical calls merge and before source times are attached. */
-export declare const blockRecords: (b: NormalizedBlock, view: BlockView, cache?: ExcerptCache) => TranscriptRecord[];
-/** Whether `record` is the same call as the `previous` record, shown a second time. */
-export declare const repeatsCall: (previous: TranscriptRecord | undefined, record: TranscriptRecord) => previous is CallRecord & {
-    sourceIndex: number;
-};
-/** The earlier record of a repeated call, now also locating the later one. */
-export declare const absorbCall: (previous: TranscriptRecord, record: TranscriptRecord) => TranscriptRecord;
-/** A source time for each locator the record names; only briefs of times-carrying blocks have them. */
-export declare const noticeTimes: (blocks: NormalizedBlock[]) => Map<string, SourceTime>;
-export declare const decorateRecord: (record: TranscriptRecord, times: NormalizedBlock["sourceTimes"], entryTimes: ReadonlyMap<string, SourceTime>) => TranscriptRecord;
-export declare const buildBriefRecords: (blocks: NormalizedBlock[], cache?: ExcerptCache) => TranscriptRecord[];
-export declare const compileBrief: (blocks: NormalizedBlock[], cache?: ExcerptCache) => string;
+/** The word budgets of a clipped excerpt: the passages kept from the start of the text, and from its end. */
+export type Clip = readonly [headWords: number, tailWords: number];
+/** The records of one dialogue block alone, before source times are attached: its whole original text, or, with a `clip`, the excerpts
+ * that keep their sanitized-block spans around an omission. A mandatory source renders nothing: the adapter quotes it in its base. */
+export declare const blockRecords: (b: DialogueBlock, mandatory: ReadonlySet<number> | undefined, clip?: Clip) => TranscriptRecord[];
+/** A source time for each locator a user record names; only briefs of times-carrying blocks have them. */
+export declare const decorateRecord: (record: TranscriptRecord, times: NormalizedBlock["sourceTimes"]) => TranscriptRecord;