pi-tuck 1.0.16 → 1.0.18

package/dist/src/tuck/core/shrink.js

@@ -1,4 +1,4 @@
-import { blockRecords, decorateRecord, isDialogue, isOmittable, omissionRecord } from "./brief.js";
+import { blockRecords, decorateRecord, isDialogue, isOmittable, omissionRecord, userPrefixRecords } from "./brief.js";
 import { DIALOGUE_SUFFIX } from "./format.js";
 import { orderByOriginalSource } from "./source-order.js";
 import { serializeRecord, serializeTranscript, TRANSCRIPT_HEADER } from "./transcript.js";
@@ -6,10 +6,9 @@ const ROLES = ["user", "assistant", "notice"];
 /** The lossy variants of a unit, least clipped first: the words kept from the start of its text and from its end. */
 const TIERS = {
     assistant: [[80, 120], [40, 40], [16, 0]],
-    user: [[256, 0], [64, 0], [24, 0]],
+    user: [],
     notice: [[256, 0]],
 };
-const TOOLS_OMITTED = { kind: "omission", reason: "Historical tool actions and observations omitted; read original sources with tuck_recall" };
 const rendered = (records) => ({ records, cost: records.reduce((n, r) => n + serializeRecord(r).length + 1, 0) });
 const WHOLE = { drop: 0, tier: 0, end: 0 };
 /** The units of one role in chronological order, with each variant's cost summed over every prefix. */
@@ -23,7 +22,26 @@ const createLane = (role, units, mandatory, decorate) => {
     // nothing and its unit is counted in the role's one omission notice, like a dropped unit: a notice per empty clip would cost more than text.
     const NONE = { records: [], cost: 0 };
     const emptied = [new Uint8Array(n)];
-    const emptyCounts = [new Int32Array(n + 1)];
+    const counts = new Int32Array(n + 1), unknown = new Int32Array(n + 1);
+    const minimum = new Float64Array(n + 1).fill(Infinity), maximum = new Float64Array(n + 1).fill(-Infinity);
+    const firstBySource = new Map(), lastBySource = new Map();
+    let monotone = true, previousSource = -1;
+    units.forEach((block, at) => {
+        const selected = isOmittable(block, mandatory), source = block.sourceIndex;
+        counts[at + 1] = counts[at] + Number(selected);
+        unknown[at + 1] = unknown[at] + Number(selected && source === undefined);
+        minimum[at + 1] = Math.min(minimum[at], selected && source !== undefined ? source : Infinity);
+        maximum[at + 1] = Math.max(maximum[at], selected && source !== undefined ? source : -Infinity);
+        if (source !== undefined) {
+            if (source < previousSource)
+                monotone = false;
+            previousSource = source;
+            if (!firstBySource.has(source))
+                firstBySource.set(source, at);
+            lastBySource.set(source, at);
+        }
+    });
+    const tallies = [];
     /** Level t holds each unit's tier-t variant. A clip that would not make the unit smaller is not taken, so sizes never grow with t. */
     const level = (t) => {
         while (levels.length <= t) {
@@ -41,65 +59,76 @@ const createLane = (role, units, mandatory, decorate) => {
                 }
                 return clipped.cost < previous[i].cost ? clipped : previous[i];
             });
-            const counts = new Int32Array(n + 1);
-            empty.forEach((e, i) => counts[i + 1] = counts[i] + e);
+            const tally = { count: new Int32Array(n + 1), unknown: new Int32Array(n + 1),
+                minSuffix: new Float64Array(n + 1).fill(Infinity), maxSuffix: new Float64Array(n + 1).fill(-Infinity), partial: new Int32Array(n + 1) };
+            units.forEach((block, at) => {
+                tally.count[at + 1] = tally.count[at] + empty[at];
+                tally.unknown[at + 1] = tally.unknown[at] + Number(Boolean(empty[at]) && block.sourceIndex === undefined);
+                tally.partial[at + 1] = tally.partial[at] + Number(isOmittable(block, mandatory) && block.sourceIndex !== undefined &&
+                    next[at].records.some(record => record.kind === "excerpt") && next[at].records.some(record => record.kind === "omission"));
+            });
+            for (let at = n - 1; at >= 0; at--) {
+                const source = empty[at] ? units[at].sourceIndex : undefined;
+                tally.minSuffix[at] = Math.min(tally.minSuffix[at + 1], source ?? Infinity);
+                tally.maxSuffix[at] = Math.max(tally.maxSuffix[at + 1], source ?? -Infinity);
+            }
+            tallies[levels.length] = tally;
             levels.push(next);
             sums.push(prefix(next));
             emptied.push(empty);
-            emptyCounts.push(counts);
         }
         return levels[t];
     };
     const sum = (t) => { level(t); return sums[t]; };
-    // The notice for a dropped prefix of p units: how many unselected text blocks, the first locators, and whether some have none.
-    let tally;
-    /** The notice for the units a setting omits: the dropped prefix, and the clips in [drop, end) that kept no text. */
-    const omission = ({ drop, tier, end }) => {
+    /** Prefix and clip tallies price every setting in O(1) for chronological
+     * session indices. Rendering a candidate never walks its dropped prefix. */
+    const omission = ({ drop, tier, end, take }) => {
         if (role === "notice")
             return undefined;
-        if (!tally) {
-            tally = { counts: new Int32Array(n + 1), unlocated: new Uint8Array(n + 1), smallest: new Array(n + 1) };
-            let smallest = [], count = 0, unlocated = 0;
-            tally.smallest[0] = smallest;
-            units.forEach((block, i) => {
-                if (isOmittable(block, mandatory)) {
-                    count++;
-                    const source = block.sourceIndex;
-                    if (source === undefined)
-                        unlocated = 1;
-                    else if (!smallest.includes(source) && (smallest.length < 9 || source < smallest[8])) {
-                        smallest = [...smallest, source].sort((a, b) => a - b).slice(0, 9);
+        if (tier > 0)
+            level(tier);
+        let count = counts[drop], unlocated = unknown[drop] > 0;
+        let min = minimum[drop], max = maximum[drop];
+        if (end > drop && tier > 0) {
+            const tally = tallies[tier];
+            count += tally.count[end] - tally.count[drop];
+            unlocated ||= tally.unknown[end] > tally.unknown[drop];
+            if (end === n) {
+                min = Math.min(min, tally.minSuffix[drop]);
+                max = Math.max(max, tally.maxSuffix[drop]);
+            }
+            else
+                for (let at = drop; at < end; at++)
+                    if (emptied[tier][at] && units[at].sourceIndex !== undefined) {
+                        min = Math.min(min, units[at].sourceIndex);
+                        max = Math.max(max, units[at].sourceIndex);
                     }
+            if (Number.isFinite(min)) {
+                if (monotone) {
+                    const from = Math.max(drop, firstBySource.get(min)), through = Math.min(end, lastBySource.get(max) + 1);
+                    if (through > from)
+                        count += tally.partial[through] - tally.partial[from];
                 }
-                tally.counts[i + 1] = count;
-                tally.unlocated[i + 1] = unlocated;
-                tally.smallest[i + 1] = smallest;
-            });
-        }
-        let count = tally.counts[drop], unlocated = tally.unlocated[drop] === 1, sources = tally.smallest[drop];
-        if (end > drop && tier > 0) {
-            level(tier);
-            const empty = emptied[tier], counts = emptyCounts[tier];
-            count += counts[end] - counts[drop];
-            if (counts[end] > counts[drop]) {
-                // Text blocks of one message share a locator: collect distinct ones, enough to tell whether the shown list is complete.
-                const extra = new Set();
-                for (let i = drop; i < end && (extra.size < 9 || !unlocated); i++)
-                    if (empty[i]) {
-                        const source = units[i].sourceIndex;
-                        if (source === undefined)
-                            unlocated = true;
-                        else if (extra.size < 9)
-                            extra.add(source);
+                else
+                    for (let at = drop; at < end; at++) {
+                        const source = units[at].sourceIndex, records = levels[tier][at].records;
+                        if (source !== undefined && source >= min && source <= max && isOmittable(units[at], mandatory) &&
+                            records.some(record => record.kind === "excerpt") && records.some(record => record.kind === "omission"))
+                            count++;
                     }
-                sources = [...new Set([...sources, ...extra])].sort((a, b) => a - b).slice(0, 9);
             }
         }
-        return count ? decorate(omissionRecord(role, count, sources, unlocated)) : undefined;
+        if (take !== undefined && Number.isFinite(min)) {
+            const block = units[drop], source = block.sourceIndex;
+            if (source !== undefined && source >= min && source <= max && isOmittable(block, mandatory) &&
+                userPrefixRecords(block, mandatory, take).some(record => record.kind === "omission"))
+                count++;
+        }
+        return count ? decorate(omissionRecord(role, count, Number.isFinite(min) ? [min, max] : [], unlocated)) : undefined;
     };
     const omissionCosts = new Map();
     const omissionCost = (setting) => {
-        const key = `${setting.drop}:${setting.tier}:${setting.end}`;
+        const key = `${setting.drop}:${setting.tier}:${setting.end}:${setting.take ?? ""}`;
         let cost = omissionCosts.get(key);
         if (cost === undefined) {
             const record = omission(setting);
@@ -107,20 +136,25 @@ const createLane = (role, units, mandatory, decorate) => {
         }
         return cost;
     };
+    const prefixAt = (at, take) => rendered(userPrefixRecords(units[at], mandatory, take).map(decorate));
     return {
-        n, level, sum, omission,
-        cost: ({ drop, tier, end }) => sums[0][n] - sums[0][Math.max(drop, end)] + (end > drop ? sum(tier)[end] - sum(tier)[drop] : 0) + omissionCost({ drop, tier, end }),
+        n, level, sum, omission, prefixAt,
+        cost: ({ drop, tier, end, take }) => take !== undefined
+            ? sums[0][n] - sums[0][drop + 1] + prefixAt(drop, take).cost + omissionCost({ drop, tier: 0, end: 0, take })
+            : sums[0][n] - sums[0][Math.max(drop, end)] + (end > drop ? sum(tier)[end] - sum(tier)[drop] : 0) + omissionCost({ drop, tier, end }),
     };
 };
 /** The units of a dialogue and what any configuration of them renders, by arithmetic over per-unit lengths or as the summary text. */
-const createDialogue = (input) => {
+const prepareDialogue = (input) => {
     const dialogue = input.blocks.filter(isDialogue);
     const times = dialogue.find(block => block.sourceTimes)?.sourceTimes;
     const decorate = (record) => decorateRecord(record, times);
     const lanes = Object.fromEntries(ROLES.map(role => [role, createLane(role, dialogue.filter(block => block.kind === role), input.mandatorySourceIndices, decorate)]));
     const seen = { user: 0, assistant: 0, notice: 0 };
     const order = dialogue.map(block => ({ role: block.kind, i: seen[block.kind]++ }));
-    const tools = input.blocks.length > dialogue.length ? rendered([TOOLS_OMITTED]) : undefined;
+    const receipts = input.blocks.filter(block => block.kind === "tool_result" &&
+        (block.sourceIndex === undefined || !input.mandatorySourceIndices?.has(block.sourceIndex)));
+    const tools = receipts.length ? rendered([omissionRecord("toolResult", receipts.length, [...new Set(receipts.flatMap(block => block.sourceIndex === undefined ? [] : [block.sourceIndex]))], receipts.some(block => block.sourceIndex === undefined))]) : undefined;
     const overhead = TRANSCRIPT_HEADER.length + DIALOGUE_SUFFIX.length;
     /** The length of the summary text of a configuration: its header, one line per record, and the closing section; 0 when it has no record. */
     const size = (config) => {
@@ -132,7 +166,8 @@ const createDialogue = (input) => {
         for (const { role, i } of order) {
             const { drop, tier, end } = config[role];
             if (i >= drop)
-                records.push(...lanes[role].level(i < end ? tier : 0)[i].records);
+                records.push(...(i === drop && config[role].take !== undefined
+                    ? lanes[role].prefixAt(i, config[role].take).records : lanes[role].level(i < end ? tier : 0)[i].records));
         }
         for (const role of ROLES) {
             const record = lanes[role].omission(config[role]);
@@ -146,73 +181,98 @@ const createDialogue = (input) => {
     };
     return { lanes, size, text };
 };
+const dialogues = new WeakMap();
+const createDialogue = (input) => {
+    let dialogue = dialogues.get(input);
+    if (!dialogue)
+        dialogues.set(input, dialogue = prepareDialogue(input));
+    return dialogue;
+};
 /** The whole pre-cut dialogue: user, assistant and notice records; tool actions and observations are omitted. "" when it renders nothing. */
 export const wholeDialogue = (input) => {
     const { text } = createDialogue(input);
     return text({ user: WHOLE, assistant: WHOLE, notice: WHOLE });
 };
-/**
- * The same dialogue shrunk until its summary text is at most `limit` characters, oldest first. The first configuration that fits wins:
- *   A. the newest k assistant units whole, the older ones clipped to tier 1, 2, 3 (the largest k that fits, for each tier in turn);
- *   B. the newest assistant units that fit a third of the limit whole, the older ones at tier 3 with the oldest d dropped;
- *   C. the newest assistant units that fit a third of the limit at tier 3, the rest dropped; then the oldest u user units clipped to tier 1, 2, 3;
- *   D. every user unit at tier 3, the oldest dropped;
- *   E. the oldest notices dropped, then the oldest of the remaining assistant units.
- * Every step is a one-parameter family whose size is read from prefix sums of the per-unit lengths, so a step costs O(units). A notice is clipped
- * to its one tier in every configuration but the whole dialogue. The size is arithmetic over unit lengths; the rendered text has the last say:
- * a configuration whose text is over the limit is passed over.
- */
+/** Lower ranks of the single fill: the existing recent assistant third, then
+ * more user turns newest first, then the remaining dialogue newest first.
+ * Each lane grows only from its recent end; complete passages remain atomic. */
 export const shrinkDialogue = (input, limit) => {
     const { lanes, size, text } = createDialogue(input);
     const { user, assistant, notice } = lanes;
-    const clipped = { drop: 0, tier: 1, end: notice.n };
-    const found = (step, config) => {
-        const length = size(config);
-        if (length > limit)
-            return undefined;
+    const gone = (lane) => ({ drop: lane.n, tier: 0, end: 0 });
+    const config = { user: gone(user), assistant: gone(assistant), notice: gone(notice) };
+    const result = (step) => {
         const summary = text(config);
-        return summary.length <= limit ? { text: summary, step, size: length } : undefined;
+        return summary.length <= limit ? { text: summary, step, size: summary.length } : { text: "", step: "none", size: 0 };
     };
-    const gone = (lane) => ({ drop: lane.n, tier: 3, end: lane.n });
-    const tiers = [1, 2, 3];
-    let hit = found("whole", { user: WHOLE, assistant: WHOLE, notice: WHOLE });
-    if (hit)
-        return hit;
-    for (const t of tiers)
-        for (let k = assistant.n; k >= 0; k--)
-            if (hit = found(`A${t}`, { user: WHOLE, assistant: { drop: 0, tier: t, end: assistant.n - k }, notice: clipped }))
-                return hit;
-    // The newest assistant units that fit a third of the limit whole are kept until users have given way: B clips and drops only older ones.
-    // A clip can keep no text at all, so the third is sized on whole units; when the newest alone is over the third, it keeps its largest clip
-    // that fits and still has text.
+    if (size({ user: WHOLE, assistant: WHOLE, notice: WHOLE }) <= limit) {
+        Object.assign(config, { user: WHOLE, assistant: WHOLE, notice: WHOLE });
+        return result("whole");
+    }
+    if (size(config) > limit)
+        return { text: "", step: "none", size: 0 };
+    // Preserve exactly shrinkDialogue's recent-third definition: newest whole
+    // units that fit a third, or the newest unit's largest nonempty passage clip.
     let kept = 0;
     while (kept < assistant.n && assistant.sum(0)[assistant.n] - assistant.sum(0)[kept] > limit / 3)
         kept++;
-    let recent = { drop: kept, tier: 3, end: kept };
+    let recent = { drop: kept, tier: 0, end: 0 };
     if (kept === assistant.n && assistant.n > 0)
-        for (const t of tiers) {
-            const cost = assistant.level(t)[assistant.n - 1].cost;
+        for (const tier of [1, 2, 3]) {
+            const cost = assistant.level(tier)[assistant.n - 1].cost;
             if (cost > 0 && cost <= limit / 3) {
-                recent = { drop: assistant.n - 1, tier: t, end: assistant.n };
+                recent = { drop: assistant.n - 1, tier, end: assistant.n };
                 break;
             }
         }
-    for (let d = 0; d <= recent.drop; d++)
-        if (hit = found("B", { user: WHOLE, assistant: { ...recent, drop: d }, notice: clipped }))
-            return hit;
-    // From here users give way, and the assistant keeps only that recent third.
-    for (const t of tiers)
-        for (let u = 0; u <= user.n; u++)
-            if (hit = found(`C${t}`, { user: { drop: 0, tier: t, end: u }, assistant: recent, notice: clipped }))
-                return hit;
-    for (let d = 0; d <= user.n; d++)
-        if (hit = found("D", { user: { drop: d, tier: 3, end: user.n }, assistant: recent, notice: clipped }))
-            return hit;
-    for (let d = 0; d <= notice.n; d++)
-        if (hit = found("E1", { user: gone(user), assistant: recent, notice: { drop: d, tier: 1, end: notice.n } }))
-            return hit;
-    for (let d = recent.drop; d <= assistant.n; d++)
-        if (hit = found("E2", { user: gone(user), assistant: { ...recent, drop: d }, notice: gone(notice) }))
-            return hit;
-    return { text: "", step: "none", size: 0 };
+    const trySetting = (role, setting) => {
+        const previous = config[role];
+        config[role] = setting;
+        if (size(config) <= limit)
+            return true;
+        config[role] = previous;
+        return false;
+    };
+    if (!trySetting("assistant", recent)) {
+        for (let drop = recent.drop + 1; drop <= assistant.n; drop++)
+            if (trySetting("assistant", { ...recent, drop }))
+                break;
+    }
+    // The user lane is filled before older assistant units. If its next whole
+    // unit cannot fit, keep its largest exact prefix that fits, then continue
+    // with the lower ranks. No fixed task/head character cap participates.
+    for (let drop = user.n - 1; drop >= 0; drop--) {
+        if (trySetting("user", { drop, tier: 0, end: 0 }))
+            continue;
+        const block = input.blocks.filter(isDialogue).filter(block => block.kind === "user")[drop];
+        if (block.kind === "user" && block.image)
+            break;
+        let low = 0, high = (block.originalText ?? block.text).length - 1;
+        while (low < high) {
+            const take = Math.ceil((low + high) / 2);
+            if (trySetting("user", { drop, tier: 0, end: 0, take }))
+                low = take;
+            else
+                high = take - 1;
+        }
+        if (low > 0)
+            trySetting("user", { drop, tier: 0, end: 0, take: low });
+        break;
+    }
+    for (let drop = config.assistant.drop - 1; drop >= 0; drop--) {
+        if (trySetting("assistant", { drop, tier: 0, end: 0 }))
+            continue;
+        for (const tier of [1, 2, 3])
+            if (assistant.level(tier)[drop].records.some(record => record.kind === "excerpt") &&
+                trySetting("assistant", { drop, tier, end: Math.max(drop + 1, recent.end) }))
+                break;
+        break;
+    }
+    for (let drop = notice.n - 1; drop >= 0; drop--) {
+        if (trySetting("notice", { drop, tier: 0, end: 0 }))
+            continue;
+        trySetting("notice", { drop, tier: 1, end: drop + 1 });
+        break;
+    }
+    return result("ranked");
 };

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

@@ -1,11 +1,6 @@
 import type { CompilerMessage } from "../types.js";
 export interface CompileInput {
     messages: CompilerMessage[];
-    /** Eligible original branch only: receipt identity and order. */
-    receiptContext?: {
-        messages: CompilerMessage[];
-        sourceIndices: Array<number | undefined>;
-    };
     /** Native session-global source indices parallel to messages. */
     sourceIndices?: Array<number | undefined>;
     /** Actual native entry IDs parallel to originals, not inferred from text. */
@@ -18,12 +13,6 @@ export interface CompileInput {
         mandatorySourceIndices?: ReadonlySet<number>;
     };
 }
-/** The whole pre-cut dialogue: user, assistant and notice records; tool actions and observations are omitted.
- * This disposable view grants neither present authority nor native tool execution. */
-export declare const compileDialogue: (input: CompileInput) => string;
-/** The dialogue shrunk to `ranking.maxBriefChars`, oldest assistant text first (see `shrinkDialogue`); "" when nothing fits. */
-export declare const compileShrunkDialogue: (input: CompileInput & {
-    ranking: {
-        maxBriefChars: number;
-    };
-}) => string;
+/** Compile the lower ranks once under their remaining serialized amount.
+ * `step` describes the result for diagnostics; it does not select another plan. */
+export declare const compileDialogue: (input: CompileInput) => import("./shrink.js").Shrunk;

package/dist/src/tuck/core/summarize.js

@@ -1,22 +1,11 @@
 import { normalize } from "./normalize.js";
 import { filterNoise } from "./filter-noise.js";
-import { shrinkDialogue, wholeDialogue } from "./shrink.js";
-// A cut offers the whole dialogue and then, when it does not fit, the shrunk one, from the same input: normalize it once. The blocks are
-// never mutated, and keeping the same objects also keeps their cached passage analyses.
-const inputs = new WeakMap();
-const dialogueInput = (input) => {
-    let prepared = inputs.get(input);
-    if (!prepared)
-        inputs.set(input, prepared = {
-            blocks: filterNoise(normalize(input.messages, input.sourceIndices, input.receiptContext, input.sourceEntryIds, input.sourceTimes)),
-            mandatorySourceIndices: input.ranking?.mandatorySourceIndices,
-            sourceIndices: input.sourceIndices ?? input.messages.map((_, index) => index),
-            sourceEntryIds: input.sourceEntryIds,
-        });
-    return prepared;
-};
-/** The whole pre-cut dialogue: user, assistant and notice records; tool actions and observations are omitted.
- * This disposable view grants neither present authority nor native tool execution. */
-export const compileDialogue = (input) => wholeDialogue(dialogueInput(input));
-/** The dialogue shrunk to `ranking.maxBriefChars`, oldest assistant text first (see `shrinkDialogue`); "" when nothing fits. */
-export const compileShrunkDialogue = (input) => shrinkDialogue(dialogueInput(input), input.ranking.maxBriefChars).text;
+import { shrinkDialogue } from "./shrink.js";
+/** Compile the lower ranks once under their remaining serialized amount.
+ * `step` describes the result for diagnostics; it does not select another plan. */
+export const compileDialogue = (input) => shrinkDialogue({
+    blocks: filterNoise(normalize(input.messages, input.sourceIndices, input.sourceEntryIds, input.sourceTimes)),
+    mandatorySourceIndices: input.ranking?.mandatorySourceIndices,
+    sourceIndices: input.sourceIndices ?? input.messages.map((_, index) => index),
+    sourceEntryIds: input.sourceEntryIds,
+}, input.ranking?.maxBriefChars ?? Infinity);

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

@@ -13,6 +13,11 @@ interface RecordFields {
     role?: "user" | "assistant" | "custom" | "bashExecution" | "toolResult";
     sourceIndex?: number;
     sourceIndices?: number[];
+    /** Inclusive original message-index bounds of a counted omission. */
+    sourceRange?: {
+        start: number;
+        end: number;
+    };
     text?: string;
     span?: {
         coordinateSpace: "sanitized-block";

package/dist/src/tuck/core/transcript.js

@@ -15,6 +15,13 @@ export const smallOriginalArguments = (value, maxCharacters = MAX_PRODUCER_ARGUM
         return false;
     }
 };
+const validSourceRange = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const range = value;
+    return Object.keys(range).length === 2 && Object.keys(range).every(key => key === "start" || key === "end") &&
+        Number.isSafeInteger(range.start) && range.start >= 0 && Number.isSafeInteger(range.end) && range.start <= range.end;
+};
 /** The format this build writes. */
 export const TRANSCRIPT_HEADER = "TUCK-TRANSCRIPT/2";
 /** The format of 1.0.x summaries: one JSON object per line. Read, never written. */
@@ -48,15 +55,19 @@ const LEGACY_RECEIPT_RANGE_NOTICE = RECEIPT_RANGE_NOTICE.replace("tuck_recall",
  *   record    = [ locator " " ] role [ " " id ] [ " " time ] [ " " span ] ":" ...                      excerpt
  *             | [ locator " " ] [ role [ " " id ] " " ] "omitted" [ " " time ] [ " " span ] ":" ...      omission of part of one source,
  *                                                                                                         or, with no role, of the tool history
+ *             | role " omitted " count " #" index "-#" index ":" ...                             counted inclusive index range
  *             | role " omitted " count [ " " locator-time { " " locator-time } ] ":" ...               omission of unselected text blocks
  *             | [ locator " " ] title ":" ...                                                          section (file ledger, action trail)
  *   locator   = "#" index                      the source's session-wide index, as tuck_recall {"index"} takes it
  *   locator-time = locator [ "@" time-value ]  every locator of a record has a time, or none does
- *   role      = "user" | "assistant" | "custom"
+ *   role      = "user" | "assistant" | "custom" | "toolResult" (omissions only)
  *   id        = a JSON string                  the native entry id of a custom notice (role "custom" only)
  *   time      = "@" time-value                 the recorded time of the locator that precedes the role (a record that has one)
  *   time-value = UTC | "journal:" UTC | "unknown"   UTC is the message time, "journal:" UTC the session file's time of the entry
  *   span      = "[chars " start "-" end " of " total "]"     the characters of the source text block the text covers or the omission leaves out
+ *   // New grouped omissions carry a count and inclusive index bounds. The count
+ *   // is dropped units of that role inside the bounds, not the width of the range.
+ *   // Older per-source pointer lists and generic tool notices remain readable.
  *   count     = index                          how many text blocks the omission counts
  *   title     = capital letter, then letters, digits, "_" and "-"
  *   index     = "0" | nonzero digit, then digits   a safe integer, no sign, no leading zero
@@ -120,12 +131,18 @@ export const serializeRecord = (record) => {
     if (record.kind !== "excerpt" && record.kind !== "omission")
         return refuse(record);
     const { role, sourceIndex, sourceEntryId, span } = record, omission = record.kind === "omission";
-    if (role !== undefined && !["user", "assistant", "custom"].includes(role) || role === undefined && (!omission || sourceEntryId !== undefined) ||
+    if (role !== undefined && !["user", "assistant", "custom", ...(omission ? ["toolResult"] : [])].includes(role) || role === undefined && (!omission || sourceEntryId !== undefined) ||
         sourceEntryId !== undefined && (role !== "custom" || typeof sourceEntryId !== "string"))
         refuse(record);
     const who = (sourceEntryId === undefined ? "" : ` ${JSON.stringify(sourceEntryId)}`);
     if (omission && record.count !== undefined) {
-        only("kind", "role", "count", "sourceIndices", "reason", "sourceTimes");
+        only("kind", "role", "count", "sourceIndices", "sourceRange", "reason", "sourceTimes");
+        if (record.sourceRange !== undefined) {
+            const range = record.sourceRange;
+            if (!validSourceRange(range) || record.sourceIndices !== undefined || record.sourceTimes !== undefined || role === undefined || typeof record.reason !== "string")
+                refuse(record);
+            return line(`${role} omitted ${index(record.count)} #${index(range.start)}-#${index(range.end)}`, record.reason);
+        }
         const locators = record.sourceIndices ?? [], stamped = times(locators);
         if (role === undefined || typeof record.reason !== "string")
             refuse(record);
@@ -148,8 +165,9 @@ const unescapeText = (text) => text.replace(/\\([\\nr])?/g, (_, c) => c === unde
 // Sticky patterns: each is matched at the position the line has been read up to.
 const INDEX = "(0|[1-9]\\d*)";
 const TIME = "(unknown|(?:journal:)?\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?Z)";
-const LOCATOR = new RegExp(`#${INDEX} `, "y"), ROLE = /user|assistant|custom/y, OMITTED = /omitted/y;
+const LOCATOR = new RegExp(`#${INDEX} `, "y"), ROLE = /user|assistant|custom|toolResult/y, OMITTED = /omitted/y;
 const ID = / ("(?:[^"\\\u0000-\u001f]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*")/y, SPACE_OMITTED = / omitted/y, COUNT = new RegExp(` ${INDEX}`, "y");
+const INDEX_RANGE = new RegExp(` #${INDEX}-#${INDEX}`, "y");
 const LOCATOR_TIME = new RegExp(` #${INDEX}(?:@${TIME})?`, "y"), TIME_TOKEN = new RegExp(` @${TIME}`, "y");
 const SPAN = new RegExp(` \\[chars ${INDEX}-${INDEX} of ${INDEX}\\]`, "y"), TITLE_TOKEN = /[A-Z][A-Za-z0-9_-]*/y;
 /** One line of TUCK-TRANSCRIPT/2, as the record the build that wrote it held (its fields in the order that build emits them). */
@@ -185,6 +203,9 @@ const parseLine = (line) => {
         record = { kind: "section", title, text, ...common };
     }
     else if (count) {
+        const range = take(INDEX_RANGE);
+        if (range)
+            return { kind: "omission", role, count: integer(count[1]), sourceRange: { start: integer(range[1]), end: integer(range[2]) }, reason: end() };
         const items = [];
         for (let item; (item = take(LOCATOR_TIME));)
             items.push({ sourceIndex: integer(item[1]), ...(item[2] !== undefined ? { time: timeOf(item[2]) } : {}) });
@@ -223,6 +244,8 @@ const validate = (r) => {
         (v.sourceIndex !== undefined && !integer(v.sourceIndex)) ||
         (v.sourceEntryId !== undefined && (typeof v.sourceEntryId !== "string" || !v.sourceEntryId || v.sourceEntryId.length > 200 ||
             v.role !== "custom" || !["excerpt", "omission"].includes(v.kind))) ||
+        (v.sourceRange !== undefined && (v.kind !== "omission" || v.count === undefined || v.sourceIndices !== undefined || v.sourceTimes !== undefined ||
+            v.role === undefined || !validSourceRange(v.sourceRange))) ||
         (v.sourceIndices !== undefined && (!Array.isArray(v.sourceIndices) || !v.sourceIndices.every(integer))) ||
         (v.kind !== "omission" && typeof v.text !== "string") ||
         (v.kind === "omission" && typeof v.reason !== "string") ||

package/dist/src/tuck/types.d.ts

@@ -21,6 +21,7 @@ export type NormalizedBlock = {
     sourceTimes?: Record<number, import("./core/source-time.js").SourceTime>;
 } & ({
     kind: "user";
+    image?: true;
     text: string;
     originalText?: string;
     sourceIndex?: number;
@@ -47,7 +48,6 @@ export type NormalizedBlock = {
     kind: "tool_result";
     name: string;
     sourceIndex?: number;
-    recallExport?: true;
 } | {
     kind: "bash";
     sourceIndex?: number;

package/dist/src/tuck.d.ts

@@ -5,8 +5,11 @@ import { type RecallPolicy, type PreparedKeywordQuery, type RecordedAttempt, typ
 type AgentMessage = Parameters<typeof convertToLlm>[0][number];
 type Cut = import("./tuck/cut.js").OwnCutResult;
 /** Counts a projection of the conversation exactly as the triggers, the post-cut checks and the guard do (budget.ts). */
-export type Measure = (messages: AgentMessage[]) => number;
-/** The summary view that produced a draft: the whole pre-cut dialogue, or the same dialogue shrunk to the allowance. Both carry the file ledger. */
+export type Measure = ((messages: AgentMessage[]) => number) & {
+    /** The same per-message estimate, including any temporary native result clip. */
+    messageTokens?: (message: AgentMessage) => number;
+};
+/** Diagnostic description of the single ranked compiler result. Never a decision input. */
 export type DraftMode = "dialogue" | "shrunk";
 type Draft = {
     compaction: Pick<Extract<SessionEntry, {
@@ -49,23 +52,17 @@ export interface Tuck {
         charsPerToken: number;
     };
     buildGlobalIndexById(entries: readonly SessionEntry[]): Map<string, number>;
-    /** The dialogue shrunk to `ranking.maxBriefChars`, oldest assistant text first; "" when not even the least of it fits. */
-    compileShrunkDialogue(input: {
+    /** Fill the lower ranks once within the remaining serialized amount. */
+    compileDialogue(input: {
         messages: AgentMessage[];
         sourceIndices: (number | undefined)[];
         sourceEntryIds?: readonly string[];
         sourceTimes?: readonly SourceTime[];
-        receiptContext?: {
-            messages: AgentMessage[];
-            sourceIndices: (number | undefined)[];
-        };
         ranking: {
             maxBriefChars: number;
             mandatorySourceIndices?: ReadonlySet<number>;
         };
-    }): string;
-    /** The whole pre-cut dialogue view; "" offers none, and the shrunk view is used. */
-    compileDialogue(input: Parameters<Tuck["compileShrunkDialogue"]>[0]): string;
+    }): ReturnType<typeof compileDialogue>;
     prepareKeywordQuery(query: string): PreparedKeywordQuery;
     searchEntriesDetailed(entries: SearchHit[], messages: Message[], query: string, tuning: {
         relativeFloor: number;
@@ -74,13 +71,8 @@ export interface Tuck {
         hits: SearchHit[];
     };
 }
+import { compileDialogue } from "./tuck/core/summarize.js";
 export declare const tuck: Tuck;
-/** The one historical allowance: at most 25% of remaining estimated room, for both views.
- * The whole dialogue is offered only within it (plus actual preview/headroom guards);
- * otherwise the same dialogue is shrunk to fit it. The 4-character conversion matches pinned Pi's
- * summary estimator, not a provider-token guarantee. Mandatory sources (current input,
- * initiating prompt, file ledger) are already charged in base. */
-export declare function historicalAllowance(window: number, reserve: number, base: number, before: number): number;
 /** Uses pi-tuck's own cut, calibrated maximum tail and dialogue compiler; Pi owns persistence and continuation. */
 export declare function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy?: RecallPolicy, retainCurrentInput?: boolean, operatorManual?: boolean, newPrompt?: boolean): Draft;
 /** Shared compiler observes canonical branch and current token estimate; no native preparation utility. */