pi-tuck 1.0.1 → 1.0.4

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

@@ -1,14 +1,4 @@
-import { clip } from "./content.js";
-import { serializeRecords, transcriptUnits, TRANSCRIPT_UNIT_CHARACTERS, smallOriginalArguments, MAX_PRODUCER_ARGUMENT_CHARACTERS } from "./transcript.js";
-const TRUNCATE_USER = 256;
-const SEGMENT_CLOSING_ASSISTANT_HEAD_WORDS = 120;
-const SEGMENT_CLOSING_ASSISTANT_TAIL_WORDS = 120;
-const ASSISTANT_HEAD_WORDS = 80;
-const ASSISTANT_TAIL_WORDS = 120;
-// ── noise filtering ──
-const isNoiseUser = (text) => {
-    return !text.trim();
-};
+import { escapedLength } from "./transcript.js";
 // ── truncation ──
 // Unicode-aware word segmentation via Intl.Segmenter (built-in, zero dependency)
 const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
@@ -108,22 +98,26 @@ const passageRanges = (text) => {
         prose(cursor, text.length);
     return ranges;
 };
-/** Existing word/serialized budgets choose complete source passages, never
- * rewritten prose. Physical line wrapping does not define a prose candidate. */
-const excerptRecords = (text, role, sourceIndex, headLimit, tailLimit = 0, boundedChars = false) => {
+const analyze = (text) => {
     const passages = passageRanges(text);
-    const costs = passages.map(({ start, end }) => [...segmenter.segment(text.slice(start, end))]
-        .filter((seg) => isWord(seg) && !STOP_WORDS.has(seg.segment.toLowerCase())).length);
+    return { passages, costs: passages.map(({ start, end }) => [...segmenter.segment(text.slice(start, end))]
+            .filter((seg) => isWord(seg) && !STOP_WORDS.has(seg.segment.toLowerCase())).length) };
+};
+/** Existing word/serialized budgets choose complete source passages, never
+ * rewritten prose. Physical line wrapping does not define a prose candidate. A passage's serialized length is its length in a record line. */
+const excerptRecords = (text, { passages, costs }, role, sourceIndex, headLimit, tailLimit, readFrom) => {
     const charLimit = 1024;
     const identity = { role, ...(sourceIndex !== undefined ? { sourceIndex } : {}) };
-    if ((!boundedChars || text.length <= charLimit && JSON.stringify(text).length <= charLimit) && costs.reduce((sum, cost) => sum + cost, 0) <= headLimit + tailLimit)
+    // A line carries at least as many characters as the text, so a long text is over the limit without counting its escapes.
+    const fits = (from, to) => to - from <= charLimit && escapedLength(text.slice(from, to)) <= charLimit;
+    if (fits(0, text.length) && costs.reduce((sum, cost) => sum + cost, 0) <= headLimit + tailLimit)
         return [{ kind: "excerpt", ...identity, text }];
     let head = 0, headCost = 0, tail = passages.length, tailCost = 0;
-    while (head < tail && headCost + costs[head] <= headLimit && (!boundedChars || JSON.stringify(text.slice(0, passages[head].end)).length <= charLimit)) {
+    while (head < tail && headCost + costs[head] <= headLimit && fits(0, passages[head].end)) {
         headCost += costs[head++];
     }
     if (tailLimit > 0) {
-        while (tail > head && tailCost + costs[tail - 1] <= tailLimit && (!boundedChars || JSON.stringify(text.slice(passages[tail - 1].start)).length <= charLimit)) {
+        while (tail > head && tailCost + costs[tail - 1] <= tailLimit && fits(passages[tail - 1].start, text.length)) {
             tailCost += costs[--tail];
         }
     }
@@ -133,259 +127,51 @@ const excerptRecords = (text, role, sourceIndex, headLimit, tailLimit = 0, bound
     const records = [];
     if (headEnd)
         records.push({ kind: "excerpt", ...identity, text: text.slice(0, headEnd), span: span(0, headEnd) });
-    records.push({ kind: "omission", ...identity, reason: "source truncated; read source; omitted text may qualify retained quotations", span: span(headEnd, tailStart) });
+    records.push({ kind: "omission", ...identity, reason: readFrom(headEnd), span: span(headEnd, tailStart) });
     if (tailStart < text.length)
         records.push({ kind: "excerpt", ...identity, text: text.slice(tailStart), span: span(tailStart, text.length) });
     return records;
 };
-const nextRenderableBlock = (blocks, index) => {
-    for (let i = index + 1; i < blocks.length; i++) {
-        if (blocks[i].kind !== "tool_result")
-            return blocks[i];
-    }
-    return undefined;
-};
-export const isSegmentClosingAssistant = (blocks, index) => {
-    if (blocks[index]?.kind !== "assistant")
-        return false;
-    const next = nextRenderableBlock(blocks, index);
-    return !next || next.kind === "user";
-};
-// ── bash command compression ──
-export const HEREDOC_OPEN_RE = /(?<![\w)])<<-?\s*["']?([A-Za-z_]\w*)["']?/;
-/**
- * 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 const heredocCloseIndex = (lines, i) => {
-    const hd = lines[i].match(HEREDOC_OPEN_RE);
-    if (!hd)
-        return -1;
-    const term = hd[1];
-    for (let j = i + 1; j < lines.length; j++) {
-        if (lines[j].trim() === term)
-            return j;
-    }
-    return -1;
-};
-/** Source-relative call identities remain explicitly bounded. */
-const excerpt = (text, limit) => JSON.stringify(clip(text, limit)) + (text.length > limit ? " [truncated; read source]" : "");
-/** Exact serialized prefix only after a lossless JSON roundtrip. No argument interpretation. */
-const incompletePrefix = (text) => {
-    let end = Math.min(text.length, MAX_PRODUCER_ARGUMENT_CHARACTERS);
-    if (end < text.length && end > 0 && /[\uD800-\uDBFF]/u.test(text[end - 1]) && /[\uDC00-\uDFFF]/u.test(text[end]))
-        end--;
-    return JSON.stringify(text.slice(0, end)) + " [incomplete prefix; omitted text may qualify it; read original source]";
-};
-/** Small complete arguments remain unchanged; oversized valid originals expose an exact prefix. */
-const toolOneLiner = (name, args) => `* ${name} ` + (smallOriginalArguments(args)
-    ? `arguments=${JSON.stringify(args)}`
-    : smallOriginalArguments(args, Number.MAX_SAFE_INTEGER)
-        ? `serializedArgumentsPrefix=${incompletePrefix(JSON.stringify(args))}`
-        : "arguments omitted; read original source");
-/** Literal JSON fields avoid quoting JSON inside quoted transcript text.
- * Keep the old leading excerpt before adding whole members. Its existing row
- * unit allowance bounds the offer; full character/admission owners still apply. */
-const literalArguments = (baseline, args, facts) => {
-    const budget = transcriptUnits(serializeRecords([baseline])) * TRANSCRIPT_UNIT_CHARACTERS;
-    const charge = (record) => serializeRecords([record]).length;
-    const complete = { ...baseline, text: facts, arguments: args };
-    if (charge(complete) <= budget)
-        return complete;
-    const original = JSON.stringify(args);
-    let end = Math.min(original.length, MAX_PRODUCER_ARGUMENT_CHARACTERS);
-    if (end < original.length && /[\uD800-\uDBFF]/u.test(original[end - 1]) && /[\uDC00-\uDFFF]/u.test(original[end]))
-        end--;
-    const record = { ...baseline,
-        text: facts + " [incomplete arguments; omitted text may qualify them; read original source]",
-        argumentsJSONPrefix: original.slice(0, end) };
-    if (charge(record) > budget)
-        return baseline;
-    const members = Object.entries(args).map(([key, value], order) => ({ key, value, order,
-        cost: JSON.stringify({ [key]: value }).length })).sort((a, b) => a.cost - b.cost || a.order - b.order);
-    const selected = [];
-    const projected = () => Object.fromEntries([...selected].sort((a, b) => a.order - b.order).map(({ key, value }) => [key, value]));
-    for (const member of members) {
-        selected.push(member);
-        if (charge({ ...record, completeArgumentMembers: projected() }) > budget)
-            selected.pop();
-    }
-    if (selected.length)
-        record.completeArgumentMembers = projected();
-    // Search only complete code-point boundaries: escaped lone surrogates would
-    // otherwise make encoded prefix prices non-monotonic.
-    const ends = [end], ceiling = Math.min(original.length - 1, budget);
-    while (end < ceiling) {
-        const next = end + (/[\uD800-\uDBFF]/u.test(original[end]) && /[\uDC00-\uDFFF]/u.test(original[end + 1]) ? 2 : 1);
-        if (next > ceiling)
-            break;
-        ends.push(end = next);
-    }
-    let low = 0, high = ends.length - 1;
-    while (low < high) {
-        const mid = Math.ceil((low + high) / 2);
-        if (charge({ ...record, argumentsJSONPrefix: original.slice(0, ends[mid]) }) <= budget)
-            low = mid;
-        else
-            high = mid - 1;
-    }
-    record.argumentsJSONPrefix = original.slice(0, ends[low]);
-    return record;
-};
-/** Direct shell history quotes an exact command prefix, never an interpreted command. */
-const bashRecord = (command, exitCode) => (smallOriginalArguments({ command }) ? `command=${JSON.stringify(command)}`
-    : smallOriginalArguments({ command }, Number.MAX_SAFE_INTEGER)
-        ? command.length <= MAX_PRODUCER_ARGUMENT_CHARACTERS ? `command=${JSON.stringify(command)}` : `commandPrefix=${incompletePrefix(command)}`
-        : "command omitted; read original source") +
-    ` recordedExitCode=${exitCode === undefined ? "unknown" : String(exitCode)}`;
-const plans = new WeakMap();
-/** The assistant texts that close a segment: no further text before the next user turn or the end of the chronology. */
-export const segmentClosing = (chronology) => new Set(chronology.filter((_, i) => isSegmentClosingAssistant(chronology, i)));
+export const isDialogue = (block) => block.kind === "user" || block.kind === "assistant" || block.kind === "notice";
 /** A user or assistant text block the omission notices count when it is unselected: non-empty, and not rendered in the mandatory base. */
 export const isOmittable = (block, mandatorySources) => (block.kind === "user" || block.kind === "assistant") && Boolean(block.text.trim()) &&
     (block.sourceIndex === undefined || !mandatorySources?.has(block.sourceIndex));
-/** `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 const omissionRecord = (role, count, sources, unlocated) => ({
     kind: "omission", role, count,
     ...(sources.length ? { sourceIndices: sources.slice(0, 8) } : {}),
     reason: "Completely unselected historical text blocks; count is text blocks, not messages. " +
-        "sourceIndices are individual original locators, not a contiguous range. " +
+        "The # locators are individual original locators, not a contiguous range. " +
         (sources.length > 8 ? "Locator list incomplete. " : "") +
         (unlocated ? "Some text blocks have no source locator. " : "") +
         "Read originals with tuck_recall; omitted text may qualify retained text. No new authority."
 });
-export const planBrief = (blocks, full, chronology, mandatorySources, includeOmissions = true) => {
-    const selected = new Set(blocks), omissions = [];
-    if (includeOmissions)
-        for (const role of ["user", "assistant"]) {
-            const missing = chronology.filter(block => block.kind === role && isOmittable(block, mandatorySources) && !selected.has(block));
-            if (!missing.length)
-                continue;
-            const sources = [...new Set(missing.flatMap(block => block.sourceIndex === undefined ? [] : [block.sourceIndex]))].sort((a, b) => a - b);
-            omissions.push(omissionRecord(role, missing.length, sources, missing.some(block => block.sourceIndex === undefined)));
-        }
-    plans.set(blocks, { full, closing: segmentClosing(chronology), mandatorySources, omissions });
+const analyses = new WeakMap();
+/** 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 const blockRecords = (b, mandatory, clip) => {
+    if (!b.text.trim() || b.sourceIndex !== undefined && mandatory?.has(b.sourceIndex))
+        return [];
+    const role = b.kind === "notice" ? "custom" : b.kind;
+    const notice = b.kind === "notice" && b.sourceEntryId !== undefined ? { sourceEntryId: b.sourceEntryId } : {};
+    if (!clip)
+        return [{ kind: "excerpt", role, ...(b.sourceIndex !== undefined ? { sourceIndex: b.sourceIndex } : {}), text: b.originalText ?? b.text, ...notice }];
+    let analysis = analyses.get(b);
+    if (!analysis)
+        analyses.set(b, analysis = analyze(b.text));
+    // How to read what a clip leaves out. tuck_recall offsets count the source's readable text, so the clip's offset into the block is one
+    // only when the block begins that text and sanitizing left it as it was; otherwise the whole source is read from its start.
+    const locator = b.sourceIndex !== undefined ? { index: b.sourceIndex } : b.kind === "notice" && b.sourceEntryId !== undefined ? { entryId: b.sourceEntryId } : undefined;
+    const exact = b.startsSource === true && b.originalText === b.text;
+    const readFrom = (offset) => locator ? `tuck_recall ${JSON.stringify(exact ? { ...locator, offset } : locator)}` : "source has no locator to read it by";
+    return excerptRecords(b.text, analysis, role, b.sourceIndex, clip[0], clip[1], readFrom).map(record => ({ ...record, ...notice }));
 };
-/** The original call that a selected complete receipt quotes; that call's own overview is then redundant. */
-export const receiptKey = (b) => b.kind === "tool_result" && b.sourceIndex !== undefined && b.originalReceipt
-    ? JSON.stringify([b.originalReceipt.producer.sourceIndex, b.originalReceipt.producer.toolCallId,
-        b.originalReceipt.producer.toolName, b.sourceIndex, b.originalReceipt.isError]) : undefined;
-/** The receipt that would make this call redundant, when the call and its single receipt are fully identified. */
-export const coveredCallKey = (b) => {
-    const receipt = b.kind === "tool_call" ? b.receipt : undefined;
-    return b.kind === "tool_call" && smallOriginalArguments(b.args) && b.sourceIndex !== undefined && receipt &&
-        (receipt.status === "error" || receipt.status === "non-error") && receipt.sourceIndices.length === 1
-        ? JSON.stringify([b.sourceIndex, b.callId, b.name, receipt.sourceIndices[0], receipt.status === "error"]) : undefined;
-};
-/** The records of one block alone: before identical calls merge and before source times are attached. */
-export const blockRecords = (b, view, cache) => {
-    const records = [];
-    const identity = b.sourceIndex !== undefined ? { sourceIndex: b.sourceIndex } : {};
-    const excerpts = (block, role, head, tail = 0) => {
-        // The adapter already renders these complete sources in its mandatory base.
-        // Keep them visible to structural grouping without charging them twice.
-        if (block.sourceIndex !== undefined && view.mandatory?.has(block.sourceIndex))
-            return [];
-        if (view.full)
-            return [{ kind: "excerpt", role, ...identity, text: block.originalText ?? block.text, ...(block.kind === "notice" && block.sourceEntryId !== undefined ? { sourceEntryId: block.sourceEntryId } : {}) }];
-        const key = `${head}:${tail}:${view.bounded}`;
-        const saved = cache?.get(block)?.get(key);
-        if (saved)
-            return saved;
-        const result = excerptRecords(block.text, role, block.sourceIndex, head, tail, view.bounded).map(record => block.kind === "notice" && block.sourceEntryId !== undefined ? { ...record, sourceEntryId: block.sourceEntryId } : record);
-        if (cache) {
-            let variants = cache.get(block);
-            if (!variants) {
-                variants = new Map();
-                cache.set(block, variants);
-            }
-            variants.set(key, result);
-        }
-        return result;
-    };
-    if (b.kind === "user" || b.kind === "notice" || b.kind === "bash") {
-        if (b.kind === "bash") {
-            const stored = view.full ? "\nstoredShell=" + JSON.stringify({ historical: true,
-                output: b.output, cancelled: b.cancelled ?? "unknown", truncated: b.truncated ?? "unknown" }) : "";
-            records.push({ kind: "bash", role: "bashExecution", ...identity, text: bashRecord(b.command, b.exitCode) + stored });
-        }
-        else if (!isNoiseUser(b.text)) {
-            records.push(...excerpts(b, b.kind === "user" ? "user" : "custom", TRUNCATE_USER));
-        }
-    }
-    else if (b.kind === "assistant") {
-        if (b.text)
-            records.push(...excerpts(b, "assistant", view.closing ? SEGMENT_CLOSING_ASSISTANT_HEAD_WORDS : ASSISTANT_HEAD_WORDS, view.closing ? SEGMENT_CLOSING_ASSISTANT_TAIL_WORDS : ASSISTANT_TAIL_WORDS));
-    }
-    else if (b.kind === "tool_call") {
-        if (!b.name.trim() || view.covered)
-            return records;
-        const receipt = b.receipt;
-        const relation = receipt ? `; receipt=${receipt.status}` +
-            (receipt.sourceIndices.length ? ` source=${receipt.sourceIndices.map(n => `#${n}`).join(",")}` : "") : "";
-        const suffix = (b.callId ? ` call=${excerpt(b.callId, 160)}` : "") + relation;
-        const text = toolOneLiner(b.name, b.args) + suffix;
-        const sourceIndices = b.sourceIndex === undefined ? undefined :
-            [...new Set([b.sourceIndex, ...(receipt?.dependencyIndices ?? [])])].sort((a, b) => a - b);
-        const baseline = { kind: "tool_call", role: "assistant", ...identity,
-            ...(sourceIndices && sourceIndices.length > 1 ? { sourceIndices } : {}), text };
-        records.push(!smallOriginalArguments(b.args) && smallOriginalArguments(b.args, Number.MAX_SAFE_INTEGER)
-            ? literalArguments(baseline, b.args, `* ${b.name}${suffix}`) : baseline);
-    }
-    if (b.kind === "tool_result" && b.originalReceipt && b.sourceIndex !== undefined) {
-        const r = b.originalReceipt;
-        // One historical quote carries its own addressed producer, without a
-        // redundant overview for the same original event. Never create native tool messages.
-        records.push({ kind: "tool_receipt", role: "toolResult", sourceIndex: b.sourceIndex,
-            sourceIndices: [r.producer.sourceIndex, b.sourceIndex], historical: true,
-            isError: r.isError, text: r.text, producer: r.producer });
-    }
-    return records;
-};
-/** Derived tool summaries can share wording; provenance remains explicit. */
-const payloads = new WeakMap();
-const callPayload = (r) => {
-    let payload = payloads.get(r);
-    if (payload === undefined)
-        payloads.set(r, payload = JSON.stringify([r.text, r.arguments, r.argumentsJSONPrefix, r.completeArgumentMembers]));
-    return payload;
-};
-/** Whether `record` is the same call as the `previous` record, shown a second time. */
-export const repeatsCall = (previous, record) => record.kind === "tool_call" && record.sourceIndex !== undefined && previous?.kind === "tool_call" &&
-    previous.sourceIndex !== undefined && callPayload(previous) === callPayload(record);
-/** The earlier record of a repeated call, now also locating the later one. */
-export const absorbCall = (previous, record) => ({ ...previous, sourceIndices: [...new Set([...(previous.sourceIndices ?? [previous.sourceIndex]), ...(record.sourceIndices ?? [record.sourceIndex])])].sort((a, b) => a - b) });
-/** A source time for each locator the record names; only briefs of times-carrying blocks have them. */
-export const noticeTimes = (blocks) => new Map(blocks.flatMap(b => b.kind === "notice" && b.sourceEntryId && b.sourceTime ? [[b.sourceEntryId, b.sourceTime]] : []));
-export const decorateRecord = (record, times, entryTimes) => {
-    if (!times)
+/** A source time for each locator a user record names; only briefs of times-carrying blocks have them. */
+export const decorateRecord = (record, times) => {
+    // Times mark the user's turns only: on every record they cost a fifth to a third of the summary's tokens.
+    if (!times || record.role !== "user")
         return record;
-    if (record.sourceEntryId !== undefined)
-        return { ...record, sourceTime: entryTimes.get(record.sourceEntryId) ?? { basis: "unknown" } };
     const indices = record.sourceIndices ?? (record.sourceIndex === undefined ? [] : [record.sourceIndex]);
     return indices.length ? { ...record, sourceTimes: indices.map(sourceIndex => ({ sourceIndex, ...(times[sourceIndex] ?? { basis: "unknown" }) })) } : record;
 };
-export const buildBriefRecords = (blocks, cache) => {
-    const records = [];
-    const coveredCalls = new Set(blocks.flatMap(b => receiptKey(b) ?? []));
-    const plan = plans.get(blocks);
-    for (let i = 0; i < blocks.length; i++) {
-        const b = blocks[i];
-        const key = coveredCallKey(b);
-        const view = { full: Boolean(plan?.full.has(b)), closing: plan ? plan.closing.has(b) : isSegmentClosingAssistant(blocks, i),
-            mandatory: plan?.mandatorySources, bounded: Boolean(plan), covered: key !== undefined && coveredCalls.has(key) };
-        for (const record of blockRecords(b, view, cache)) {
-            const previous = records.at(-1);
-            if (repeatsCall(previous, record))
-                records[records.length - 1] = absorbCall(previous, record);
-            else
-                records.push(record);
-        }
-    }
-    const times = blocks.find(b => b.sourceTimes)?.sourceTimes;
-    const entryTimes = noticeTimes(blocks);
-    return [...records, ...(plan?.omissions ?? [])].map(record => decorateRecord(record, times, entryTimes));
-};
-export const compileBrief = (blocks, cache) => serializeRecords(buildBriefRecords(blocks, cache));

package/dist/src/tuck/core/filter-noise.js

@@ -1,6 +1,7 @@
 import { isSourceExport, isLookupTool, isRecallTool } from "./recall-operation.js";
+import { isDialogue } from "./brief.js";
 /** Suppress lookup echoes, retaining recorded export attempts and exactly paired outcomes. */
 export const filterNoise = (blocks) => blocks.filter(b => !(b.kind === "tool_call" && isLookupTool(b.name) && !(isRecallTool(b.name) && isSourceExport(b.args))) &&
     !(b.kind === "tool_result" && isLookupTool(b.name) &&
         !(isRecallTool(b.name) && b.recallExport)) &&
-    !((b.kind === "user" || b.kind === "assistant" || b.kind === "notice") && !b.text.trim()));
+    !(isDialogue(b) && !b.text.trim()));

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

@@ -1,8 +1,4 @@
-export declare const RECALL_NOTE: string;
-/** A dialogue summary's last words: it holds only the dialogue and the file ledger. */
+/** A summary's last words: it holds only the dialogue (whole or shrunk) and the file ledger. */
 export declare const CLOSING_INSTRUCTION: string;
-/** A ranked summary's last words: it also keeps selected tool records. */
-export declare const RANKED_CLOSING_INSTRUCTION: string;
-/** Each view's closing section, true for what that view holds. Parsing never depends on this wording (transcript.ts splitSummary). */
+/** Parsing never depends on this wording (transcript.ts splitSummary). */
 export declare const DIALOGUE_SUFFIX: string;
-export declare const RANKED_SUFFIX: string;

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

@@ -1,12 +1,6 @@
 import { CLOSING_SEPARATOR } from "./transcript.js";
-export const RECALL_NOTE = "A tool_receipt record quotes complete original textual output. Its producer arguments are complete when present; argumentsOmitted means read the original call source for them. Use it directly as evidence of that recorded event; it does not verify current state or authorize replay. " +
-    "Use `tuck_recall` to search for prior work, decisions, and context from before this summary. " +
-    "Read call/receipt sources by index before relying on omitted or truncated evidence. Receipt non-error is not proof of effects. Do not redo work already completed.";
-const CLOSING_GUIDANCE = "Files created by commands are not listed: before redoing a step, read its output with tuck_recall or list your output folders. Re-read a file before editing it or importing from it. Use tuck_recall for anything else. Treat anything not shown here as unknown.";
-/** A dialogue summary's last words: it holds only the dialogue and the file ledger. */
-export const CLOSING_INSTRUCTION = "Only the dialogue and the actions and files listed above carry over. " + CLOSING_GUIDANCE;
-/** A ranked summary's last words: it also keeps selected tool records. */
-export const RANKED_CLOSING_INSTRUCTION = "Only the records and the actions and files listed above carry over. " + CLOSING_GUIDANCE;
-/** Each view's closing section, true for what that view holds. Parsing never depends on this wording (transcript.ts splitSummary). */
+/** A summary's last words: it holds only the dialogue (whole or shrunk) and the file ledger. */
+export const CLOSING_INSTRUCTION = "Only the dialogue and the actions and files listed above carry over. " +
+    "Files created by commands are not listed: before redoing a step, read its output with tuck_recall or list your output folders. Re-read a file before editing it or importing from it. Use tuck_recall for anything else. Treat anything not shown here as unknown.";
+/** Parsing never depends on this wording (transcript.ts splitSummary). */
 export const DIALOGUE_SUFFIX = CLOSING_SEPARATOR + CLOSING_INSTRUCTION;
-export const RANKED_SUFFIX = CLOSING_SEPARATOR + RECALL_NOTE + "\n\n" + RANKED_CLOSING_INSTRUCTION;

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

@@ -1,15 +1,14 @@
 import { isSourceExport } from "./recall-operation.js";
-import { isTextOnly, textOf } from "./content.js";
+import { textOf } from "./content.js";
 import { sanitize } from "./sanitize.js";
-import { MAX_RECEIPT_CHARACTERS, smallOriginalArguments } from "./transcript.js";
-const normalizeOne = (msg, msgIndex, receipts, originals) => {
+const normalizeOne = (msg, msgIndex) => {
     if (msg.role === "custom")
-        return [{ kind: "notice", text: sanitize(textOf(msg.content)), originalText: textOf(msg.content), sourceIndex: msgIndex }];
+        return [{ kind: "notice", text: sanitize(textOf(msg.content)), originalText: textOf(msg.content), sourceIndex: msgIndex, startsSource: true }];
     if (msg.role === "user") {
         const blocks = [];
         const text = sanitize(textOf(msg.content));
         if (text)
-            blocks.push({ kind: "user", text, originalText: textOf(msg.content), sourceIndex: msgIndex });
+            blocks.push({ kind: "user", text, originalText: textOf(msg.content), sourceIndex: msgIndex, startsSource: true });
         if (msg.content && typeof msg.content !== "string") {
             for (const part of msg.content) {
                 if (part.type === "image") {
@@ -19,40 +18,30 @@ const normalizeOne = (msg, msgIndex, receipts, originals) => {
         }
         return blocks.length > 0 ? blocks : [{ kind: "user", text: "", sourceIndex: msgIndex }];
     }
-    if (msg.role === "bashExecution") {
-        const cmd = msg.command ?? "";
-        const out = msg.output ?? "";
-        const exit = msg.exitCode;
-        return [{ kind: "bash", command: cmd, output: out, exitCode: exit, cancelled: msg.cancelled, truncated: msg.truncated, sourceIndex: msgIndex }];
-    }
-    if (msg.role === "toolResult") {
-        const original = originals.get(msg.toolCallId);
-        return [{
-                kind: "tool_result",
-                name: msg.toolName,
-                text: sanitize(textOf(msg.content)),
-                sourceIndex: msgIndex,
-                originalReceipt: (original?.text.length ?? Infinity) <= MAX_RECEIPT_CHARACTERS ? original : undefined,
-            }];
-    }
+    if (msg.role === "bashExecution")
+        return [{ kind: "bash", sourceIndex: msgIndex }];
+    if (msg.role === "toolResult")
+        return [{ kind: "tool_result", name: msg.toolName, sourceIndex: msgIndex }];
     if (msg.role === "assistant") {
         if (!msg.content)
             return [];
         if (typeof msg.content === "string") {
-            return [{ kind: "assistant", text: sanitize(msg.content), originalText: msg.content, sourceIndex: msgIndex }];
+            return [{ kind: "assistant", text: sanitize(msg.content), originalText: msg.content, sourceIndex: msgIndex, startsSource: true }];
         }
         const blocks = [];
+        // The readable text of a message is its text and tool-call parts in order: only the first part starts it.
+        let readable = false;
         for (const part of msg.content) {
             if (part.type === "text") {
-                blocks.push({ kind: "assistant", text: sanitize(part.text), originalText: part.text, sourceIndex: msgIndex });
+                blocks.push({ kind: "assistant", text: sanitize(part.text), originalText: part.text, sourceIndex: msgIndex, ...(readable ? {} : { startsSource: true }) });
+                readable = true;
             }
             else if (part.type === "toolCall") {
+                readable = true;
                 blocks.push({
                     kind: "tool_call",
                     name: part.name,
                     args: part.arguments,
-                    callId: part.id,
-                    receipt: receipts.get(part.id),
                     sourceIndex: msgIndex,
                 });
             }
@@ -101,34 +90,17 @@ export const normalize = (messages, sourceIndices, receiptContext, sourceEntryId
                 order, index: context.sourceIndices[order], isError: msg.isError, content: msg.content });
         }
     });
-    const links = new Map();
-    const originals = new Map();
-    for (const [id, { calls, receipts }] of pairs) {
-        const call = calls[0], receipt = receipts[0];
-        const status = calls.length !== 1 || receipts.length > 1 ? "ambiguous" : !receipt ? "missing" :
-            receipt.name !== call.name || receipt.order <= call.order ? "ambiguous" : receipt.isError ? "error" : "non-error";
-        links.set(id, { status, sourceIndices: receipts.flatMap(r => r.index === undefined ? [] : [r.index]),
-            dependencyIndices: [...calls, ...receipts].flatMap(source => source.index === undefined ? [] : [source.index]) });
-        if ((status === "error" || status === "non-error") && call.index !== undefined && receipt.index !== undefined &&
-            Number.isSafeInteger(call.index) && call.index >= 0 && Number.isSafeInteger(receipt.index) && receipt.index > call.index &&
-            call.name.trim() && call.name.length <= 160 && id.length <= 160 && smallOriginalArguments(call.args, Number.MAX_SAFE_INTEGER) &&
-            isTextOnly(receipt.content)) {
-            const text = textOf(receipt.content);
-            if (text)
-                originals.set(id, {
-                    text, isError: receipt.isError,
-                    producer: { sourceIndex: call.index, toolName: call.name, toolCallId: id,
-                        ...(smallOriginalArguments(call.args) ? { arguments: call.args } : { argumentsOmitted: true }) },
-                });
-        }
-    }
-    return messages.flatMap((msg, i) => normalizeOne(msg, sourceIndices ? sourceIndices[i] : i, links, originals).map(block => {
-        if (block.kind === "tool_result" && msg.role === "toolResult" &&
-            ["error", "non-error"].includes(links.get(msg.toolCallId)?.status ?? "") &&
+    // A call paired with exactly one later receipt of the same tool has a recorded outcome. An export through recall keeps its outcome block.
+    const paired = (id) => {
+        const pair = pairs.get(id), call = pair?.calls[0], receipt = pair?.receipts[0];
+        return Boolean(pair && call && receipt && pair.calls.length === 1 && pair.receipts.length === 1 && receipt.name === call.name && receipt.order > call.order);
+    };
+    return messages.flatMap((msg, i) => normalizeOne(msg, sourceIndices ? sourceIndices[i] : i).map(block => {
+        if (block.kind === "tool_result" && msg.role === "toolResult" && paired(msg.toolCallId) &&
             isSourceExport(pairs.get(msg.toolCallId)?.calls[0]?.args))
             block = { ...block, recallExport: true };
         if (sourceTimes)
-            block = { ...block, sourceTime: sourceTimes[i], sourceTimes: timeByIndex };
+            block = { ...block, sourceTimes: timeByIndex };
         return block.kind === "notice" && sourceEntryIds?.[i] !== undefined ? { ...block, sourceEntryId: sourceEntryIds[i] } : block;
     }));
 };

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

@@ -0,0 +1,33 @@
+import type { NormalizedBlock } from "../types.js";
+export interface DialogueInput {
+    /** Normalized, noise-filtered blocks of the pre-cut history in chronological order: dialogue and tool blocks alike. */
+    blocks: NormalizedBlock[];
+    /** Sources the adapter quotes in its own base: they render as nothing here and are not counted as omitted. */
+    mandatorySourceIndices?: ReadonlySet<number>;
+    /** The source index of each original message and, when known, its entry id, for the original order of the records. */
+    sourceIndices: readonly (number | undefined)[];
+    sourceEntryIds?: readonly string[];
+}
+/** The configurations the ladder tries, in order; "none" is no configuration that fits. */
+export type Step = "whole" | `A${1 | 2 | 3}` | "B" | `C${1 | 2 | 3}` | "D" | "E1" | "E2" | "none";
+export interface Shrunk {
+    /** The summary text, or "" when nothing fits. */
+    text: string;
+    step: Step;
+    /** The length the ladder computed from per-unit lengths before it rendered `text`. */
+    size: number;
+}
+/** The whole pre-cut dialogue: user, assistant and notice records; tool actions and observations are omitted. "" when it renders nothing. */
+export declare const wholeDialogue: (input: DialogueInput) => string;
+/**
+ * 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.
+ */
+export declare const shrinkDialogue: (input: DialogueInput, limit: number) => Shrunk;