pi-midcompact 0.2.1

package/src/messages.ts

@@ -0,0 +1,116 @@
+import type { MessageLike, SessionEntryLike } from "./types.js";
+
+export function stableStringify(value: unknown): string {
+  return JSON.stringify(sortValue(value));
+}
+
+function sortValue(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (!value || typeof value !== "object") return value;
+  const input = value as Record<string, unknown>;
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(input).sort()) out[key] = sortValue(input[key]);
+  return out;
+}
+
+function fnv1a64(text: string): string {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mask = 0xffffffffffffffffn;
+  const bytes = new TextEncoder().encode(text);
+  for (const byte of bytes) {
+    hash ^= BigInt(byte);
+    hash = (hash * prime) & mask;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+
+export function messageKey(message: MessageLike): string {
+  const timestamp = typeof message.timestamp === "number" ? message.timestamp : 0;
+  return `${message.role}:${timestamp}:${fnv1a64(stableStringify(message))}`;
+}
+
+export function contentText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const out: string[] = [];
+  for (const raw of content) {
+    if (!raw || typeof raw !== "object") continue;
+    const part = raw as Record<string, unknown>;
+    if (part.type === "text" && typeof part.text === "string") out.push(part.text);
+    else if (part.type === "thinking" && typeof part.thinking === "string") out.push(part.thinking);
+    else if (part.type === "toolCall") {
+      const name = typeof part.name === "string" ? part.name : "tool";
+      const args = "arguments" in part ? part.arguments : {};
+      out.push(`${name}(${safeJson(args)})`);
+    }
+  }
+  return out.join("\n");
+}
+
+function safeJson(value: unknown): string {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+export function messageText(message: MessageLike): string {
+  if (message.role === "toolResult") {
+    const name = message.toolName ?? "tool";
+    return `tool_result ${name}: ${contentText(message.content)}`;
+  }
+  const pieces = [contentText(message.content)];
+  if (typeof message.command === "string") pieces.push(`$ ${message.command}`);
+  if (typeof message.output === "string") pieces.push(message.output);
+  if (typeof message.summary === "string") pieces.push(message.summary);
+  return pieces.filter(Boolean).join("\n");
+}
+
+export function toolCalls(message: MessageLike): Array<{ id: string; name: string; arguments?: unknown }> {
+  if (message.role !== "assistant" || !Array.isArray(message.content)) return [];
+  const calls: Array<{ id: string; name: string; arguments?: unknown }> = [];
+  for (const raw of message.content) {
+    if (!raw || typeof raw !== "object") continue;
+    const part = raw as Record<string, unknown>;
+    if (part.type !== "toolCall") continue;
+    if (typeof part.id !== "string" || typeof part.name !== "string") continue;
+    calls.push({ id: part.id, name: part.name, arguments: part.arguments });
+  }
+  return calls;
+}
+
+export function approxTokens(text: string): number {
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+
+export function truncate(text: string, limit: number): string {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= limit) return normalized;
+  return `${normalized.slice(0, Math.max(0, limit - 1))}…`;
+}
+
+export function mapEntryIds(messages: MessageLike[], branch: readonly SessionEntryLike[]): Array<string | undefined> {
+  const queues = new Map<string, string[]>();
+  for (const entry of branch) {
+    if (entry.type !== "message" || !entry.message) continue;
+    const key = messageKey(entry.message);
+    const queue = queues.get(key) ?? [];
+    queue.push(entry.id);
+    queues.set(key, queue);
+  }
+  return messages.map((message) => {
+    const queue = queues.get(messageKey(message));
+    return queue?.shift();
+  });
+}
+
+export function renderMessage(message: MessageLike): string {
+  if (message.role === "user") return `User: ${messageText(message)}`;
+  if (message.role === "assistant") return `Assistant: ${messageText(message)}`;
+  if (message.role === "toolResult") return `Tool result (${message.toolName ?? "tool"}): ${contentText(message.content)}`;
+  if (message.role === "bashExecution") return `Bash: ${message.command ?? ""}\n${message.output ?? ""}`;
+  if (message.role === "custom") return `Custom: ${messageText(message)}`;
+  return `${message.role}: ${messageText(message)}`;
+}

package/src/plan.ts

@@ -0,0 +1,93 @@
+import type { Atom, DraftPlan, DraftRange, DraftTelemetry } from "./types.js";
+import { estimateCompressedTokens } from "./projection.js";
+import { formatTelemetry } from "./telemetry.js";
+
+export function emptyDraft(transactionId: string): DraftPlan {
+  return { version: 1, transactionId, revision: 0, ranges: [] };
+}
+
+export function addDraftRange(
+  draft: DraftPlan,
+  atoms: Atom[],
+  input: { start: string; end: string; summary: string; topic?: string },
+): DraftPlan {
+  const start = atoms.find((atom) => atom.ref === input.start);
+  const end = atoms.find((atom) => atom.ref === input.end);
+  if (!start || !end) throw new Error("Unknown atom ref; run locate again against the current anchor snapshot.");
+  if (start.index > end.index) throw new Error("start must not occur after end.");
+  const selected = atoms.slice(start.index, end.index + 1);
+  if (selected.length === 0) throw new Error("Empty range.");
+  const unsafe = selected.find((atom) => !atom.compressible || !atom.protocolClosed || atom.kind === "compressed");
+  if (unsafe) throw new Error(`Range crosses protected atom ${unsafe.ref} (${unsafe.kind}). Split the plan around it.`);
+  const overlaps = draft.ranges.some((range) => !(end.index < range.startIndex || start.index > range.endIndex));
+  if (overlaps) throw new Error("Range overlaps an existing draft range.");
+  const id = nextDraftId(draft);
+  const range: DraftRange = {
+    id,
+    startRef: start.ref,
+    endRef: end.ref,
+    startIndex: start.index,
+    endIndex: end.index,
+    topic: input.topic,
+    summary: input.summary,
+    entryIds: selected.flatMap((atom) => atom.entryIds),
+    messageKeys: selected.flatMap((atom) => atom.messageKeys),
+    originalApproxTokens: selected.reduce((sum, atom) => sum + atom.approxTokens, 0),
+    compressedApproxTokens: estimateCompressedTokens(input.summary, input.topic),
+    startPreview: start.preview,
+    endPreview: end.preview,
+  };
+  return { ...draft, revision: draft.revision + 1, ranges: [...draft.ranges, range].sort((a, b) => a.startIndex - b.startIndex) };
+}
+
+export function updateDraftRange(
+  draft: DraftPlan,
+  draftId: string,
+  patch: { summary?: string; topic?: string },
+): DraftPlan {
+  const target = draft.ranges.find((range) => range.id === draftId);
+  if (!target) throw new Error(`Unknown draft range ${draftId}.`);
+  const summary = patch.summary ?? target.summary;
+  const topic = patch.topic ?? target.topic;
+  return {
+    ...draft,
+    revision: draft.revision + 1,
+    ranges: draft.ranges.map((range) => range.id === draftId
+      ? { ...range, summary, topic, compressedApproxTokens: estimateCompressedTokens(summary, topic) }
+      : range),
+  };
+}
+
+export function removeDraftRange(draft: DraftPlan, draftId: string): DraftPlan {
+  if (!draft.ranges.some((range) => range.id === draftId)) throw new Error(`Unknown draft range ${draftId}.`);
+  return { ...draft, revision: draft.revision + 1, ranges: draft.ranges.filter((range) => range.id !== draftId) };
+}
+
+function nextDraftId(draft: DraftPlan): string {
+  let max = 0;
+  for (const range of draft.ranges) {
+    const match = /^d(\d+)$/.exec(range.id);
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  return `d${max + 1}`;
+}
+
+export function formatDraft(draft: DraftPlan, telemetry?: DraftTelemetry): string {
+  const lines: string[] = [];
+  if (telemetry) lines.push(formatTelemetry(telemetry), "");
+  if (draft.ranges.length === 0) {
+    lines.push(`Draft v${draft.revision}: no compression ranges.`);
+    return lines.join("\n");
+  }
+  const before = draft.ranges.reduce((sum, range) => sum + range.originalApproxTokens, 0);
+  const after = draft.ranges.reduce((sum, range) => sum + range.compressedApproxTokens, 0);
+  lines.push(`Draft v${draft.revision}: ${draft.ranges.length} range(s), ~${before} → ~${after} tokens`);
+  for (const range of draft.ranges) {
+    lines.push(`\n${range.id}: ${range.startRef} → ${range.endRef}${range.topic ? ` | ${range.topic}` : ""}`);
+    lines.push(`~${range.originalApproxTokens} → ~${range.compressedApproxTokens} tokens`);
+    lines.push(`summary: ${range.summary}`);
+    lines.push(`start: ${range.startPreview}`);
+    if (range.endRef !== range.startRef) lines.push(`end: ${range.endPreview}`);
+  }
+  return lines.join("\n");
+}

package/src/projection.ts

@@ -0,0 +1,61 @@
+import type { CompressionBlock, CompressionState, MessageLike } from "./types.js";
+import { approxTokens, messageKey } from "./messages.js";
+
+export function summaryMessage(block: CompressionBlock, timestamp = Date.now()): MessageLike {
+  const topic = block.topic ? `: ${block.topic}` : "";
+  return {
+    role: "custom",
+    customType: "midcompact-summary",
+    content: [
+      `[Midcompact summary ${block.id}${topic}]`,
+      block.summary,
+      "",
+      `Original block: ${block.id}`,
+      `Use midcompact(action=\"recall\", ref=\"${block.id}\") if exact details are needed.`,
+    ].join("\n"),
+    display: true,
+    details: {
+      blockId: block.id,
+      originalApproxTokens: block.originalApproxTokens,
+      topic: block.topic,
+    },
+    timestamp,
+  } as MessageLike;
+}
+
+export function projectMessages(messages: MessageLike[], state?: CompressionState): MessageLike[] {
+  if (!state?.blocks.length) return messages;
+  const keys = messages.map(messageKey);
+  const replacements: Array<{ start: number; end: number; block: CompressionBlock }> = [];
+  for (const block of state.blocks) {
+    const found = findSubsequence(keys, block.messageKeys);
+    if (!found) continue; // fail open: never delete content if the persisted locator no longer resolves exactly
+    replacements.push({ start: found.start, end: found.end, block });
+  }
+  replacements.sort((a, b) => a.start - b.start);
+  for (let i = 1; i < replacements.length; i += 1) {
+    if (replacements[i]!.start <= replacements[i - 1]!.end) return messages; // corrupted/overlapping state: fail open
+  }
+  const out = [...messages];
+  for (const replacement of [...replacements].reverse()) {
+    const first = messages[replacement.start];
+    const timestamp = typeof first?.timestamp === "number" ? first.timestamp : Date.now();
+    out.splice(replacement.start, replacement.end - replacement.start + 1, summaryMessage(replacement.block, timestamp));
+  }
+  return out;
+}
+
+function findSubsequence(haystack: string[], needle: string[]): { start: number; end: number } | undefined {
+  if (needle.length === 0 || needle.length > haystack.length) return undefined;
+  outer: for (let start = 0; start <= haystack.length - needle.length; start += 1) {
+    for (let offset = 0; offset < needle.length; offset += 1) {
+      if (haystack[start + offset] !== needle[offset]) continue outer;
+    }
+    return { start, end: start + needle.length - 1 };
+  }
+  return undefined;
+}
+
+export function estimateCompressedTokens(summary: string, topic?: string): number {
+  return approxTokens(`${topic ?? ""}\n${summary}`) + 40;
+}

package/src/renderers.ts

@@ -0,0 +1,67 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Box, Text } from "@earendil-works/pi-tui";
+
+import { STATE_ENTRY } from "./state.js";
+import { formatPercent, formatTokenCount } from "./telemetry.js";
+import type { CompressionState } from "./types.js";
+
+export function registerStateRenderer(pi: ExtensionAPI): void {
+  pi.registerEntryRenderer<CompressionState>(STATE_ENTRY, (entry, { expanded }, theme) => {
+    const state = entry.data;
+    const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+    if (!state) {
+      box.addChild(new Text(theme.fg("dim", "[midcompact] state unavailable"), 0, 0));
+      return box;
+    }
+    const commit = state.lastCommit;
+    const saved = state.blocks.reduce(
+      (sum, block) => sum + Math.max(0, block.originalApproxTokens - block.compressedApproxTokens),
+      0,
+    );
+    const added = commit?.addedRangeCount ?? 0;
+    const headline = [
+      theme.fg("success", "✓ MIDCOMPACT"),
+      added ? `+${added} range${added === 1 ? "" : "s"}` : `${state.blocks.length} active block${state.blocks.length === 1 ? "" : "s"}`,
+      `${state.blocks.length} active`,
+      `~${formatTokenCount(saved)} saved`,
+    ].join(" · ");
+    box.addChild(new Text(headline, 0, 0));
+
+    if (commit?.anchorUsage?.contextWindow && commit.projectedTokens !== null) {
+      box.addChild(new Text(
+        theme.fg(
+          "dim",
+          `anchor ${formatPercent(commit.anchorUsage.percent)} → projected ${formatPercent(commit.projectedPercent, true)} ` +
+            `(~${formatTokenCount(commit.projectedTokens)}/${formatTokenCount(commit.anchorUsage.contextWindow)})`,
+        ),
+        0,
+        0,
+      ));
+    }
+
+    if (expanded) {
+      const addedSet = new Set(commit?.addedBlockIds ?? []);
+      const blocks = addedSet.size ? state.blocks.filter((block) => addedSet.has(block.id)) : state.blocks;
+      for (const block of blocks) {
+        const title = `${block.id}${block.topic ? ` · ${block.topic}` : ""} · ~${formatTokenCount(block.originalApproxTokens)} → ~${formatTokenCount(block.compressedApproxTokens)}`;
+        box.addChild(new Text(theme.fg("accent", title), 0, 0));
+        box.addChild(new Text(theme.fg("dim", block.summary), 1, 0));
+      }
+      box.addChild(new Text(theme.fg("dim", "Original history retained; use midcompact recall when exact details are needed."), 0, 0));
+    }
+    return box;
+  });
+}
+
+export function stateTreeLabel(state: CompressionState): string {
+  const commit = state.lastCommit;
+  const added = commit?.addedRangeCount ?? 0;
+  const saved = commit?.estimatedSavedTokens ?? state.blocks.reduce(
+    (sum, block) => sum + Math.max(0, block.originalApproxTokens - block.compressedApproxTokens),
+    0,
+  );
+  const projection = commit?.projectedPercent === null || commit?.projectedPercent === undefined
+    ? ""
+    : ` · →~${formatPercent(commit.projectedPercent, false)}`;
+  return `midcompact${added ? ` +${added}` : ""} · ~${formatTokenCount(saved)} saved${projection}`;
+}

package/src/review-ui.ts

@@ -0,0 +1,198 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+
+import { formatPercent, formatTokenCount } from "./telemetry.js";
+import type { Atom, DraftPlan, DraftRange, DraftTelemetry, ReviewAction } from "./types.js";
+
+export async function showReviewUi(
+  ctx: ExtensionCommandContext,
+  atoms: Atom[],
+  draft: DraftPlan,
+  telemetry: DraftTelemetry,
+): Promise<ReviewAction> {
+  if (ctx.mode !== "tui") return { action: "close" };
+
+  return ctx.ui.custom<ReviewAction>((tui, theme, _keybindings, done) => {
+    let scrollOffset = 0;
+    let selectedRange = draft.ranges.length ? 0 : -1;
+    let expandSelected = false;
+    let jumpToSelected = true;
+
+    const selected = (): DraftRange | undefined => selectedRange >= 0 ? draft.ranges[selectedRange] : undefined;
+
+    const component = {
+      render(width: number): string[] {
+        const w = Math.max(30, width);
+        const rows = Math.max(12, tui.terminal.rows);
+        const border = (text: string) => theme.fg("border", text);
+        const dim = (text: string) => theme.fg("dim", text);
+        const accent = (text: string) => theme.fg("accent", text);
+        const success = (text: string) => theme.fg("success", text);
+        const warning = (text: string) => theme.fg("warning", text);
+        const bodyWidth = Math.max(20, w - 4);
+        const framed = (text: string) => `${border("│")} ${truncateToWidth(text, bodyWidth, "…", true)} ${border("│")}`;
+        const horizontal = (left: string, mid = "─", right = "─") => border(`${left}${mid.repeat(Math.max(0, w - 2))}${right}`);
+
+        const header: string[] = [];
+        header.push(horizontal("╭", "─", "╮"));
+        header.push(framed(accent(theme.bold(`Midcompact Review · Draft v${draft.revision}`))));
+        header.push(framed(formatUsageLine(telemetry, theme)));
+        header.push(framed(dim("This is awareness, not a target. Review the linear anchor snapshot before /midcompact commit.")));
+        header.push(horizontal("├", "─", "┤"));
+
+        const range = selected();
+        const selectedInfo: string[] = [];
+        if (range) {
+          selectedInfo.push(framed(`${accent("Selected")} ${range.id}  ${range.startRef} → ${range.endRef}${range.topic ? `  ${range.topic}` : ""}`));
+          selectedInfo.push(framed(dim(`~${formatTokenCount(range.originalApproxTokens)} → ~${formatTokenCount(range.compressedApproxTokens)} tokens`)));
+          for (const line of wrapTextWithAnsi(`${accent("Summary:")} ${range.summary}`, bodyWidth)) selectedInfo.push(framed(line));
+          selectedInfo.push(horizontal("├", "─", "┤"));
+        }
+
+        const body: string[] = [];
+        const atomLineStarts = new Map<number, number>();
+        for (const atom of atoms) {
+          atomLineStarts.set(atom.index, body.length);
+          const owner = owningRange(atom.index, draft.ranges);
+          const isSelected = Boolean(range && owner?.id === range.id);
+          const isRangeStart = owner?.startIndex === atom.index;
+          const isRangeEnd = owner?.endIndex === atom.index;
+          const rangeMark = owner ? (isRangeStart ? "┌" : isRangeEnd ? "└" : "│") : " ";
+          const selectionMark = isSelected ? "▶" : " ";
+          const policy = owner ? warning(owner.id) : success("KEEP");
+          const token = dim(`~${formatTokenCount(atom.approxTokens)}`);
+          const oneLine = firstLine(atom.preview);
+          body.push(framed(`${selectionMark}${rangeMark} ${policy} ${atom.ref} [${atom.kind}] ${token}  ${oneLine}`));
+          if (expandSelected && isSelected) {
+            const detail = wrapTextWithAnsi(atom.preview, Math.max(10, bodyWidth - 4));
+            for (const detailLine of detail.slice(1, 8)) body.push(framed(dim(`    ${detailLine}`)));
+          }
+        }
+        if (!body.length) body.push(framed(dim("(No atoms in anchor snapshot.)")));
+
+        const footerRows = 4;
+        const viewportHeight = Math.max(5, rows - header.length - selectedInfo.length - footerRows - 2);
+        if (jumpToSelected && range) {
+          scrollOffset = atomLineStarts.get(range.startIndex) ?? scrollOffset;
+          jumpToSelected = false;
+        }
+        const maxOffset = Math.max(0, body.length - viewportHeight);
+        scrollOffset = Math.max(0, Math.min(scrollOffset, maxOffset));
+        const visible = body.slice(scrollOffset, scrollOffset + viewportHeight);
+        while (visible.length < viewportHeight) visible.push(framed(""));
+
+        const top = body.length ? scrollOffset + 1 : 0;
+        const bottom = Math.min(body.length, scrollOffset + viewportHeight);
+        const footer = [
+          horizontal("├", "─", "┤"),
+          framed(dim(`Lines ${top}-${bottom} of ${body.length} · n/p select range · ↑↓/PgUp/PgDn scroll · x expand selected`)),
+          framed(dim("e edit summary · t edit topic · d remove selected range · Enter/Esc close")),
+          horizontal("╰", "─", "╯"),
+        ];
+        return [...header, ...selectedInfo, ...visible, ...footer];
+      },
+      invalidate(): void {},
+      handleInput(data: string): void {
+        if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter) || data === "q") {
+          done({ action: "close" });
+          return;
+        }
+        if ((data === "n" || matchesKey(data, Key.right)) && draft.ranges.length) {
+          selectedRange = (selectedRange + 1 + draft.ranges.length) % draft.ranges.length;
+          jumpToSelected = true;
+          tui.requestRender();
+          return;
+        }
+        if ((data === "p" || matchesKey(data, Key.left)) && draft.ranges.length) {
+          selectedRange = (selectedRange - 1 + draft.ranges.length) % draft.ranges.length;
+          jumpToSelected = true;
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.up) || data === "k") {
+          scrollOffset = Math.max(0, scrollOffset - 1);
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.down) || data === "j") {
+          scrollOffset += 1;
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.pageUp)) {
+          scrollOffset = Math.max(0, scrollOffset - 12);
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.pageDown)) {
+          scrollOffset += 12;
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.home)) {
+          scrollOffset = 0;
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.end)) {
+          scrollOffset = Number.MAX_SAFE_INTEGER;
+          tui.requestRender();
+          return;
+        }
+        if (data === "x") {
+          expandSelected = !expandSelected;
+          jumpToSelected = true;
+          tui.requestRender();
+          return;
+        }
+        const range = selected();
+        if (!range) return;
+        if (data === "e") done({ action: "edit-summary", draftId: range.id });
+        else if (data === "t") done({ action: "edit-topic", draftId: range.id });
+        else if (data === "d") done({ action: "remove", draftId: range.id });
+      },
+    };
+    return component;
+  });
+}
+
+export function buildReviewText(atoms: Atom[], draft: DraftPlan, telemetry: DraftTelemetry): string {
+  const lines = [
+    `Midcompact Review · Draft v${draft.revision}`,
+    plainUsageLine(telemetry),
+    "This is awareness, not a target.",
+    "",
+  ];
+  for (const atom of atoms) {
+    const owner = owningRange(atom.index, draft.ranges);
+    lines.push(`${owner ? owner.id : "KEEP"} ${atom.ref} [${atom.kind}] ~${formatTokenCount(atom.approxTokens)} ${firstLine(atom.preview)}`);
+  }
+  if (draft.ranges.length) {
+    lines.push("", "Proposed summaries:");
+    for (const range of draft.ranges) lines.push(`${range.id} ${range.startRef} → ${range.endRef}: ${range.summary}`);
+  }
+  return lines.join("\n");
+}
+
+function owningRange(atomIndex: number, ranges: DraftRange[]): DraftRange | undefined {
+  return ranges.find((range) => atomIndex >= range.startIndex && atomIndex <= range.endIndex);
+}
+
+function firstLine(text: string): string {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+function plainUsageLine(telemetry: DraftTelemetry): string {
+  const anchor = telemetry.contextWindow === null
+    ? "anchor usage unavailable"
+    : `${formatTokenCount(telemetry.anchorTokens)}/${formatTokenCount(telemetry.contextWindow)} (${formatPercent(telemetry.anchorPercent)})`;
+  const projected = telemetry.projectedTokens === null || telemetry.contextWindow === null
+    ? "projected unavailable"
+    : `~${formatTokenCount(telemetry.projectedTokens)}/${formatTokenCount(telemetry.contextWindow)} (${formatPercent(telemetry.projectedPercent, true)})`;
+  return `Anchor ${anchor} · Draft selected ~${formatTokenCount(telemetry.selectedOriginalApproxTokens)}→~${formatTokenCount(telemetry.selectedCompressedApproxTokens)} · Projected ${projected}`;
+}
+
+function formatUsageLine(telemetry: DraftTelemetry, theme: ExtensionCommandContext["ui"]["theme"]): string {
+  const label = theme.fg("accent", "Context");
+  return `${label}: ${plainUsageLine(telemetry)}`;
+}

package/src/state.ts

@@ -0,0 +1,64 @@
+import type { CompressionState, DraftPlan, SessionEntryLike, TransactionState } from "./types.js";
+
+export const STATE_ENTRY = "midcompact-state";
+export const TXN_ENTRY = "midcompact-transaction";
+export const DRAFT_ENTRY = "midcompact-draft";
+
+interface CustomEntryLike extends SessionEntryLike {
+  data?: unknown;
+}
+
+export function emptyCompressionState(): CompressionState {
+  return { version: 1, createdAt: new Date().toISOString(), blocks: [] };
+}
+
+export function restoreCompressionState(entries: readonly unknown[]): CompressionState | undefined {
+  let latest: CompressionState | undefined;
+  for (const raw of entries) {
+    const entry = raw as CustomEntryLike;
+    if (entry.type !== "custom" || entry.customType !== STATE_ENTRY) continue;
+    if (isCompressionState(entry.data)) latest = entry.data;
+  }
+  return latest;
+}
+
+export function restoreTransaction(entries: readonly unknown[]): { transaction?: TransactionState; draft?: DraftPlan } {
+  let transaction: TransactionState | undefined;
+  let draft: DraftPlan | undefined;
+  for (const raw of entries) {
+    const entry = raw as CustomEntryLike;
+    if (entry.type !== "custom") continue;
+    if (entry.customType === TXN_ENTRY && isTransaction(entry.data)) {
+      transaction = entry.data;
+      draft = undefined;
+      continue;
+    }
+    if (entry.customType === DRAFT_ENTRY && transaction && isDraft(entry.data) && entry.data.transactionId === transaction.id) {
+      draft = entry.data;
+    }
+  }
+  return { transaction, draft };
+}
+
+export function isCompressionState(value: unknown): value is CompressionState {
+  if (!value || typeof value !== "object") return false;
+  const state = value as Record<string, unknown>;
+  if (state.version !== 1 || typeof state.createdAt !== "string" || !Array.isArray(state.blocks)) return false;
+  return state.blocks.every((raw) => {
+    if (!raw || typeof raw !== "object") return false;
+    const block = raw as Record<string, unknown>;
+    return typeof block.id === "string" && typeof block.summary === "string" && Array.isArray(block.entryIds) && Array.isArray(block.messageKeys);
+  });
+}
+
+function isTransaction(value: unknown): value is TransactionState {
+  if (!value || typeof value !== "object") return false;
+  const tx = value as Record<string, unknown>;
+  return tx.version === 1 && typeof tx.id === "string" && typeof tx.anchorEntryId === "string" && typeof tx.startedAt === "string";
+}
+
+function isDraft(value: unknown): value is DraftPlan {
+  if (!value || typeof value !== "object") return false;
+  const plan = value as Record<string, unknown>;
+  return plan.version === 1 && typeof plan.transactionId === "string" && typeof plan.revision === "number" && Array.isArray(plan.ranges);
+}