pi-tuck 1.0.1 → 1.0.3

package/src/tuck/core/brief.ts

@@ -1,19 +1,5 @@
 import type { NormalizedBlock } from "../types";
-import { clip } from "./content";
-import type { SourceTime } from "./source-time";
-import { serializeRecords, transcriptUnits, TRANSCRIPT_UNIT_CHARACTERS, smallOriginalArguments, MAX_PRODUCER_ARGUMENT_CHARACTERS, type TranscriptRecord } from "./transcript";
-
-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: string): boolean => {
-  return !text.trim();
-};
+import { escapedLength, type TranscriptRecord } from "./transcript";
 
 // ── truncation ──
 
@@ -98,288 +84,83 @@ const passageRanges = (text: string): { start: number; end: number }[] => {
   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: string, role: "user" | "assistant" | "custom", sourceIndex: number | undefined,
-  headLimit: number, tailLimit = 0, boundedChars = false): TranscriptRecord[] => {
+/** The passages of a text and the words each costs. Segmenting is most of the work of a clip, so a block is analyzed once for every clip. */
+interface Analysis { passages: { start: number; end: number }[]; costs: number[] }
+const analyze = (text: string): Analysis => {
   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: string, { passages, costs }: Analysis, role: "user" | "assistant" | "custom", sourceIndex: number | undefined,
+  headLimit: number, tailLimit: number, readFrom: (offset: number) => string): TranscriptRecord[] => {
   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)
+  if (escapedLength(text) <= charLimit && 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)) { headCost += costs[head++]!; }
+  while (head < tail && headCost + costs[head]! <= headLimit && escapedLength(text.slice(0, passages[head]!.end)) <= charLimit) { 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)) { tailCost += costs[--tail]!; }
+    while (tail > head && tailCost + costs[tail - 1]! <= tailLimit && escapedLength(text.slice(passages[tail - 1]!.start)) <= charLimit) { tailCost += costs[--tail]!; }
   }
   const headEnd = head ? passages[head - 1]!.end : 0;
   const tailStart = tail < passages.length ? passages[tail]!.start : text.length;
   const span = (start: number, end: number) => ({ coordinateSpace: "sanitized-block" as const, start, end, totalCharacters: text.length });
   const records: TranscriptRecord[] = [];
   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: NormalizedBlock[], index: number): NormalizedBlock | undefined => {
-  for (let i = index + 1; i < blocks.length; i++) {
-    if (blocks[i].kind !== "tool_result") return blocks[i];
-  }
-  return undefined;
-};
-
-export const isSegmentClosingAssistant = (blocks: NormalizedBlock[], index: number): boolean => {
-  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: string[], i: number): number => {
-  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: string, limit: number): string =>
-  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: string): string => {
-  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: string, args: Record<string, unknown>): string =>
-  `* ${name} ` + (smallOriginalArguments(args)
-    ? `arguments=${JSON.stringify(args)}`
-    : smallOriginalArguments(args, Number.MAX_SAFE_INTEGER)
-      ? `serializedArgumentsPrefix=${incompletePrefix(JSON.stringify(args))}`
-      : "arguments omitted; read original source");
-
-export type CallRecord = Extract<TranscriptRecord, { kind: "tool_call" }>;
-/** 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: CallRecord, args: Record<string, unknown>, facts: string): CallRecord => {
-  const budget = transcriptUnits(serializeRecords([baseline])) * TRANSCRIPT_UNIT_CHARACTERS;
-  const charge = (record: CallRecord) => serializeRecords([record]).length;
-  const complete: CallRecord = { ...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: CallRecord = { ...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: typeof members = [];
-  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: string, exitCode: number | undefined): string =>
-  (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)}`;
-
-/** One record is independently decodable; source text cannot create structure. */
-export type ExcerptCache = WeakMap<NormalizedBlock, Map<string, TranscriptRecord[]>>;
-// Ephemeral rendering decisions belong to the selected array, not source blocks.
-// Measurement and final rendering therefore use the same representation.
-interface BriefPlan { full: Set<NormalizedBlock>; closing: Set<NormalizedBlock>; mandatorySources?: ReadonlySet<number>; omissions: TranscriptRecord[] }
-const plans = new WeakMap<NormalizedBlock[], BriefPlan>();
-
-/** 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: NormalizedBlock[]): Set<NormalizedBlock> =>
-  new Set(chronology.filter((_, i) => isSegmentClosingAssistant(chronology, i)));
+/** The user, assistant and notice blocks of a dialogue; tool blocks are never rendered. */
+export type DialogueBlock = Extract<NormalizedBlock, { kind: "user" | "assistant" | "notice" }>;
+export const isDialogue = (block: NormalizedBlock): block is DialogueBlock => 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: NormalizedBlock, mandatorySources?: ReadonlySet<number>): boolean =>
   (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: "user" | "assistant", count: number, sources: number[], unlocated: boolean): TranscriptRecord => ({
   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: NormalizedBlock[], full: Set<NormalizedBlock>, chronology: NormalizedBlock[], mandatorySources?: ReadonlySet<number>, includeOmissions = true): void => {
-  const selected = new Set(blocks), omissions: TranscriptRecord[] = [];
-  if (includeOmissions) for (const role of ["user", "assistant"] as const) {
-    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 });
-};
-
-/** The original call that a selected complete receipt quotes; that call's own overview is then redundant. */
-export const receiptKey = (b: NormalizedBlock): string | undefined => 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: NormalizedBlock): string | undefined => {
-  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;
-};
-
-/** 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 const blockRecords = (b: NormalizedBlock, view: BlockView, cache?: ExcerptCache): TranscriptRecord[] => {
-  const records: TranscriptRecord[] = [];
-  const identity = b.sourceIndex !== undefined ? { sourceIndex: b.sourceIndex } : {};
-  const excerpts = (block: NormalizedBlock & { text: string; originalText?: string }, role: "user" | "assistant" | "custom", head: number, 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" as const, 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: CallRecord = { 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<CallRecord, string>();
-const callPayload = (r: CallRecord): string => {
-  let payload = payloads.get(r);
-  if (payload === undefined) payloads.set(r, payload = JSON.stringify([r.text, r.arguments, r.argumentsJSONPrefix, r.completeArgumentMembers]));
-  return payload;
+const analyses = new WeakMap<DialogueBlock, Analysis>();
+
+/** 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 const blockRecords = (b: DialogueBlock, mandatory: ReadonlySet<number> | undefined, clip?: Clip): TranscriptRecord[] => {
+  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: number) => 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 }));
 };
-/** Whether `record` is the same call as the `previous` record, shown a second time. */
-export const repeatsCall = (previous: TranscriptRecord | undefined, record: TranscriptRecord): previous is CallRecord & { sourceIndex: number } =>
-  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: TranscriptRecord, record: TranscriptRecord): TranscriptRecord =>
-  ({ ...previous, sourceIndices: [...new Set([...(previous.sourceIndices ?? [previous.sourceIndex!]), ...(record.sourceIndices ?? [record.sourceIndex!])])].sort((a, b) => a - b) } as TranscriptRecord);
 
-/** A source time for each locator the record names; only briefs of times-carrying blocks have them. */
-export const noticeTimes = (blocks: NormalizedBlock[]): Map<string, SourceTime> =>
-  new Map(blocks.flatMap(b => b.kind === "notice" && b.sourceEntryId && b.sourceTime ? [[b.sourceEntryId, b.sourceTime] as const] : []));
-export const decorateRecord = (record: TranscriptRecord, times: NormalizedBlock["sourceTimes"], entryTimes: ReadonlyMap<string, SourceTime>): TranscriptRecord => {
-  if (!times) return record;
-  if (record.sourceEntryId !== undefined) return { ...record, sourceTime: entryTimes.get(record.sourceEntryId) ?? { basis: "unknown" as const } };
+/** A source time for each locator a user record names; only briefs of times-carrying blocks have them. */
+export const decorateRecord = (record: TranscriptRecord, times: NormalizedBlock["sourceTimes"]): TranscriptRecord => {
+  // 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;
   const indices = record.sourceIndices ?? (record.sourceIndex === undefined ? [] : [record.sourceIndex]);
   return indices.length ? { ...record, sourceTimes: indices.map(sourceIndex => ({ sourceIndex, ...(times[sourceIndex] ?? { basis: "unknown" as const }) })) } : record;
 };
-
-export const buildBriefRecords = (blocks: NormalizedBlock[], cache?: ExcerptCache): TranscriptRecord[] => {
-  const records: TranscriptRecord[] = [];
-  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: NormalizedBlock[], cache?: ExcerptCache): string =>
-  serializeRecords(buildBriefRecords(blocks, cache));

package/src/tuck/core/format.ts

@@ -1,13 +1,6 @@
 import { CLOSING_SEPARATOR } from "./transcript";
-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/src/tuck/core/normalize.ts

@@ -1,15 +1,14 @@
 import { isSourceExport } from "./recall-operation";
-import type { CompilerMessage, NormalizedBlock, ReceiptLink, HistoricalReceipt } from "../types";
-import { isTextOnly, textOf } from "./content";
+import type { CompilerMessage, NormalizedBlock } from "../types";
+import { textOf } from "./content";
 import { sanitize } from "./sanitize";
-import { MAX_RECEIPT_CHARACTERS, smallOriginalArguments } from "./transcript";
 
-const normalizeOne = (msg: CompilerMessage, msgIndex: number | undefined, receipts: Map<string, ReceiptLink>, originals: Map<string, HistoricalReceipt>): NormalizedBlock[] => {
-  if (msg.role === "custom") return [{ kind: "notice", text: sanitize(textOf(msg.content)), originalText: textOf(msg.content), sourceIndex: msgIndex }];
+const normalizeOne = (msg: CompilerMessage, msgIndex: number | undefined): NormalizedBlock[] => {
+  if (msg.role === "custom") return [{ kind: "notice", text: sanitize(textOf(msg.content)), originalText: textOf(msg.content), sourceIndex: msgIndex, startsSource: true }];
   if (msg.role === "user") {
     const blocks: NormalizedBlock[] = [];
     const text = sanitize(textOf(msg.content));
-    if (text) blocks.push({ kind: "user", text, originalText: textOf(msg.content), sourceIndex: msgIndex });
+    if (text) 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") {
@@ -27,34 +26,28 @@ const normalizeOne = (msg: CompilerMessage, msgIndex: number | undefined, receip
     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 === "toolResult") return [{ kind: "tool_result", name: msg.toolName, text: sanitize(textOf(msg.content)), 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: NormalizedBlock[] = [];
+    // 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 as const }) });
+        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,
         });
       }
@@ -103,30 +96,14 @@ export const normalize = (
         order, index: context.sourceIndices[order], isError: msg.isError, content: msg.content });
     }
   });
-  const links = new Map<string, ReceiptLink>();
-  const originals = new Map<string, HistoricalReceipt>();
-  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 as const }) },
-      });
-    }
-  }
-  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: string): boolean => {
+    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 };
+    if (sourceTimes) block = { ...block, sourceTimes: timeByIndex };
     return block.kind === "notice" && sourceEntryIds?.[i] !== undefined ? { ...block, sourceEntryId: sourceEntryIds[i] } : block; }));
 };