indusagi-coding-agent 0.2.8 → 0.2.10

package/src/window-budget/condenser.ts

@@ -0,0 +1,58 @@
+/**
+ * Window-budget — the condenser factory (the conductor-consumable seam).
+ *
+ * {@link createCondenser} ties the three pure pieces together into a single
+ * function the conductor can drop into its auto-compaction hook.
+ */
+import type {
+  AgentMessage,
+  BudgetPolicy,
+  Condenser,
+  CondenserDeps,
+  Summary,
+} from "./contract.js";
+import { isOverBudget } from "./budget/gate.js";
+import { planSlice } from "./budget/slice.js";
+import { condenseScope, summarize, type SummarizeDeps } from "./summarize/index.js";
+
+/**
+ * The fallback {@link BudgetPolicy} when the caller supplies none.
+ */
+export const AUTO_CONDENSE_POLICY: BudgetPolicy = {
+  triggerRatio: 0.75,
+  keepRecent: 6e3,
+  reserveTokens: 2048,
+};
+
+/**
+ * Build a {@link Condenser} from a {@link CondenserDeps} bundle. The result plugs
+ * straight into the conductor's `CondenseFn` seam.
+ */
+export function createCondenser(deps: CondenserDeps = {}): Condenser {
+  const policy = deps.policy ?? AUTO_CONDENSE_POLICY;
+  const model = deps.model;
+  const complete = deps.complete;
+  return async (messages: AgentMessage[]): Promise<AgentMessage[]> => {
+    if (!model) return messages;
+    if (!isOverBudget(messages, model, policy)) return messages;
+    const plan = planSlice(messages, policy);
+    if (plan.cut === 0 || plan.dropped.length === 0) {
+      return messages;
+    }
+    const summary = await summarize(plan.dropped, { complete, model });
+    return [summary.message, ...plan.kept];
+  };
+}
+
+/**
+ * Session-scope summarization: fold a slice of dropped messages into one digest
+ * for the active session.
+ */
+export function condense(
+  messages: AgentMessage[],
+  deps: Omit<SummarizeDeps, "scope"> = {},
+): Promise<Summary> {
+  return summarize(messages, { ...deps, scope: "session" });
+}
+
+export { condenseScope };

package/src/window-budget/contract.ts

@@ -0,0 +1,184 @@
+// @ts-nocheck
+// Type declarations recovered from dist/types (no runtime body)
+/**
+ * Window-budget contract — the FROZEN type surface of the context-window
+ * budgeting subsystem (Phase 3, subsystem 05).
+ *
+ * A long-running coding session accrues messages — user turns, assistant turns,
+ * tool calls and their results — until the transcript approaches the model's
+ * context window. This subsystem keeps the session usable by *condensing* older
+ * history into a single structured summary message while keeping a verbatim
+ * tail of the most-recent turns. It answers three questions:
+ *
+ *   1. **Budget**  — *when* are we over budget? A {@link BudgetPolicy} carries
+ *      config-sourced thresholds (no magic literals); {@link isOverBudget}
+ *      decides from a real {@link TokenEstimate}.
+ *   2. **Slice**   — *where* do we cut? {@link planSlice} computes a
+ *      {@link CondensePlan} via a forward prefix-sum + binary search over a
+ *      cumulative-token array, never splitting a tool_call from its tool_result.
+ *   3. **Condense** — *how* do we compress the dropped portion? A
+ *      {@link Condenser} flattens the dropped messages, asks an injectable model
+ *      completer for a structured {@link Summary}, and returns the rebuilt
+ *      transcript (summary + kept tail).
+ *
+ * This file declares *only* shapes plus the function-type seams — no behavior,
+ * no I/O, no prompt strings. Every later window-budget module (the meter, the
+ * slice planner, the condenser, the branch archivist, the prompt templates, and
+ * the public barrel) is written against the names declared here.
+ *
+ * Design stance:
+ *   - Thresholds are **configuration, not constants**. {@link BudgetPolicy}
+ *     fields are supplied by the caller; this module bakes in no fixed token
+ *     fingerprints. Defaults, if any, live in the implementation and are
+ *     computed relative to the model's own context window.
+ *   - Branch-summarization is **not a separate engine**. It collapses into the
+ *     condenser behind a {@link CondenseScope} flag (`"session" | "branch"`),
+ *     so there is one prompt-assembly path, one token estimator, one slicer.
+ *   - The model completer is **injectable** ({@link CompleteFn}, default the
+ *     framework's `completeSimple`) so the condenser runs in tests with no
+ *     network.
+ *   - The produced condenser is **conductor-consumable**: a {@link Condenser}
+ *     is structurally a conductor `CondenseFn`
+ *     (`(messages: AgentMessage[]) => AgentMessage[] | Promise<AgentMessage[]>`),
+ *     so a {@link CondenserDeps}-built condenser plugs straight into the
+ *     conductor's auto-compaction seam.
+ *
+ * Framework anchors (all from the `indusagi` package — the sibling rebuilt
+ * framework this app targets):
+ *   - `AgentMessage`                          ← `indusagi/agent`
+ *   - `Model`, `Usage`, `completeSimple` (and its `Api`/`AssistantMessage`/
+ *     `Context`/`SimpleStreamOptions`/`StreamLogger` shapes) ← `indusagi/ai`
+ *
+ * This module never re-declares these; it composes them.
+ */
+import type { AgentMessage } from "indusagi/agent";
+import type { Api, AssistantMessage, Context, Model, SimpleStreamOptions, StreamLogger, Usage } from "indusagi/ai";
+/** Re-exported framework vocabulary window-budget consumers routinely need. */
+export type { AgentMessage, Model, Usage };
+/**
+ * The config-sourced thresholds that govern when and how the transcript is
+ * condensed. Every field is a *number the caller supplies* — there are no magic
+ * token literals baked into this contract. An implementation may
+ * provide defaults, but they are configuration values, not protected constants,
+ * and deliberately differ from the legacy fingerprints.
+ */
+export interface BudgetPolicy {
+    /**
+     * Fraction of the model's `contextWindow` at which condensing is triggered,
+     * in `(0, 1]`. The meter is "over budget" once the estimated context tokens
+     * cross `contextWindow * triggerRatio`. Expressing the trigger as a ratio
+     * (rather than an absolute reserve) keeps it window-relative and free of
+     * baked-in token counts.
+     */
+    readonly triggerRatio: number;
+    /**
+     * How much of the recent transcript to keep verbatim, measured in estimated
+     * tokens. The slice planner preserves a tail of at least this many tokens
+     * (snapped to a legal boundary) and condenses everything before it.
+     */
+    readonly keepRecent: number;
+    /**
+     * Optional token headroom to subtract from the window before the trigger is
+     * evaluated — a safety margin so a condense fires *before* the very next turn
+     * would overflow. When omitted, only {@link triggerRatio} governs the trigger.
+     */
+    readonly reserveTokens?: number;
+}
+/**
+ * The outcome of measuring a transcript against a model's window. Anchors on the
+ * provider's authoritative `usage` count when available (`anchored: true`) and
+ * falls back to a rough char/role estimate otherwise; either way `contextTokens`
+ * is the figure {@link isOverBudget} compares to `contextWindow`.
+ */
+export interface TokenEstimate {
+    /** Best estimate of tokens currently occupying the context window. */
+    readonly contextTokens: number;
+    /** The model's total context window, in tokens (`Model.contextWindow`). */
+    readonly contextWindow: number;
+    /**
+     * `true` when {@link contextTokens} is anchored on a real provider `usage`
+     * figure (only trailing, post-usage messages are estimated); `false` when the
+     * whole figure is a heuristic estimate.
+     */
+    readonly anchored: boolean;
+}
+/**
+ * The pre-computed result of {@link planSlice}: the chosen cut index and the
+ * resulting partition of the transcript.
+ *
+ * The cut is found by a *forward* prefix-sum + binary search: build a cumulative
+ * estimated-token array over the messages, binary-search for the boundary index
+ * nearest `total - keepRecent`, then nudge to the closest *legal* boundary —
+ * never landing between a `toolCall` and its `toolResult`.
+ *
+ * Invariants:
+ *   - `kept.length + dropped.length === messages.length`
+ *   - `dropped` is the prefix `messages[0 .. cut)` (the older slice to condense)
+ *   - `kept`    is the suffix `messages[cut ..]` (the verbatim recent tail)
+ *   - `cut` is `0` when nothing is condensable (everything kept).
+ */
+export interface CondensePlan {
+    /** Index of the legal cut boundary: `dropped = messages.slice(0, cut)`. */
+    readonly cut: number;
+    /** The verbatim recent tail preserved as-is (`messages.slice(cut)`). */
+    readonly kept: AgentMessage[];
+    /** The older slice to be folded into a {@link Summary} (`messages.slice(0, cut)`). */
+    readonly dropped: AgentMessage[];
+}
+/**
+ * Which kind of condensing run this is — the flag that collapses
+ * branch-summarization into the single condenser path:
+ *   - `"session"` — condense the *active* transcript in place (the trigger /
+ *     overflow path); keeps a recent tail, summarizes the head.
+ *   - `"branch"`  — archive an *abandoned* branch into one summary message so its
+ *     context isn't lost on tree navigation; no verbatim tail is retained.
+ */
+export type CondenseScope = "session" | "branch";
+/**
+ * The structured result of summarizing a slice of dropped messages: a single
+ * synthetic {@link AgentMessage} that stands in for the messages it covers.
+ */
+export interface Summary {
+    /** The synthetic summary message to splice into the rebuilt transcript. */
+    readonly message: AgentMessage;
+    /** How many source messages this summary replaces. */
+    readonly coveredCount: number;
+}
+/**
+ * The injectable model-completion function. Structurally identical to the
+ * framework's `completeSimple`, so the real `completeSimple` is the drop-in
+ * default and a test can pass a no-network stub of the same shape. The
+ * condenser uses this single call to turn flattened transcript text into a
+ * {@link Summary}.
+ */
+export type CompleteFn = <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions, logger?: StreamLogger) => Promise<AssistantMessage>;
+/**
+ * A condenser: takes the active branch's messages and returns the rebuilt
+ * transcript (condensed head + verbatim tail, or the input unchanged when there
+ * is nothing to do).
+ *
+ * This type is **structurally compatible with the conductor's `CondenseFn`**
+ * (`(messages: AgentMessage[]) => AgentMessage[] | Promise<AgentMessage[]>`), so
+ * the result of the condenser factory plugs directly into the conductor's
+ * auto-compaction seam with no adapter.
+ */
+export type Condenser = (messages: AgentMessage[]) => AgentMessage[] | Promise<AgentMessage[]>;
+/**
+ * Dependencies for building a {@link Condenser}. All fields are optional so a
+ * bare `createCondenser()` yields a working, network-free-testable condenser:
+ *   - `complete` defaults to the framework's `completeSimple`.
+ *   - `policy` defaults to the implementation's config-sourced thresholds.
+ *   - `model` is the summarization model; when omitted the condenser may fall
+ *     back to a no-op (return input unchanged) rather than guess a model.
+ */
+export interface CondenserDeps {
+    /**
+     * The injectable model completer (default: framework `completeSimple`). Inject
+     * a stub of {@link CompleteFn} shape to run the condenser with no network.
+     */
+    readonly complete?: CompleteFn;
+    /** The model used to write the summary. When omitted, condensing is a no-op. */
+    readonly model?: Model<Api>;
+    /** The config-sourced budget thresholds (default: implementation defaults). */
+    readonly policy?: BudgetPolicy;
+}

package/src/window-budget/index.ts

@@ -0,0 +1,19 @@
+// @ts-nocheck
+// Type declarations recovered from dist/types (no runtime body)
+/**
+ * Window-budget — public barrel.
+ *
+ * The context-window budgeting subsystem: token measurement, slice planning,
+ * and transcript condensing (with branch-archival collapsed in behind a scope
+ * flag). Re-exports the frozen contract types plus the live functions: the
+ * budget math (estimateTokens / isOverBudget / planSlice), the summarization core
+ * (summarize / condenseScope), and the conductor-consumable condenser factory
+ * (createCondenser / condense).
+ */
+export type { AgentMessage, BudgetPolicy, CompleteFn, CondensePlan, Condenser, CondenserDeps, CondenseScope, Model, Summary, TokenEstimate, Usage, } from "./contract.js";
+export { budgetLimit, estimateMessageTokens, estimateTokens, isOverBudget, planSlice, prefixTokens, } from "./budget/index.js";
+export { buildSummaryPrompt, CONDENSER_BRIEF, flattenTranscript, summarize, } from "./summarize/index.js";
+export type { SummarizeDeps } from "./summarize/index.js";
+export { AUTO_CONDENSE_POLICY, condense, condenseScope, createCondenser } from "./condenser.js";
+export { CLEARED_TOOL_RESULT, clearStaleToolResults, COMPACTABLE_TOOL_NAMES, } from "./microcompact.js";
+export { rehydrateRecentReads, RESTORED_FILE_PREFIX } from "./rehydrate.js";

package/src/window-budget/microcompact.ts

@@ -0,0 +1,95 @@
+/**
+ * Window-budget / microcompact — clear stale tool-result bodies in place.
+ */
+import type { AgentMessage } from "./contract.js";
+
+/**
+ * The placeholder spliced in where a stale tool-result body used to be.
+ */
+export const CLEARED_TOOL_RESULT = "[Old tool result content cleared]";
+
+/**
+ * The wire names of tools whose results are safe to clear once stale.
+ */
+export const COMPACTABLE_TOOL_NAMES: ReadonlySet<string> = new Set([
+  "read",
+  "grep",
+  "find",
+  "ls",
+  "glob",
+  "bash",
+  "websearch",
+  "webfetch",
+  "edit",
+  "write",
+]);
+
+const DEFAULT_KEEP_RECENT = 6;
+
+function isRecord3(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function collectCompactableToolIds(messages: AgentMessage[]): Set<string> {
+  const ids = new Set<string>();
+  for (const message of messages) {
+    if (!isRecord3(message) || message.role !== "assistant") continue;
+    const content = Array.isArray(message.content) ? message.content : [];
+    for (const block of content) {
+      if (!isRecord3(block) || block.type !== "toolCall") continue;
+      const name = typeof block.name === "string" ? block.name : "";
+      const id = typeof block.id === "string" ? block.id : "";
+      if (id.length > 0 && COMPACTABLE_TOOL_NAMES.has(name)) ids.add(id);
+    }
+  }
+  return ids;
+}
+
+function isAlreadyCleared(message: AgentMessage): boolean {
+  if (!isRecord3(message)) return false;
+  const content = (message as { content?: unknown }).content;
+  if (!Array.isArray(content) || content.length !== 1) return false;
+  const block = content[0];
+  return (
+    isRecord3(block) &&
+    block.type === "text" &&
+    block.text === CLEARED_TOOL_RESULT
+  );
+}
+
+/**
+ * Clear the bodies of stale compactable tool results, keeping the most recent
+ * `keepRecent` of them verbatim.
+ */
+export function clearStaleToolResults(
+  messages: AgentMessage[],
+  opts: { keepRecent?: number } = {},
+): AgentMessage[] {
+  const keepRecent = Math.max(1, opts.keepRecent ?? DEFAULT_KEEP_RECENT);
+  const compactableIds = collectCompactableToolIds(messages);
+  if (compactableIds.size === 0) return messages;
+  const clearAt = new Set<number>();
+  let kept = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!isRecord3(message) || message.role !== "toolResult") continue;
+    const id = typeof (message as { toolCallId?: unknown }).toolCallId === "string"
+      ? (message as { toolCallId: string }).toolCallId
+      : "";
+    if (!compactableIds.has(id)) continue;
+    if (kept < keepRecent) {
+      kept++;
+      continue;
+    }
+    if (isAlreadyCleared(message as AgentMessage)) continue;
+    clearAt.add(i);
+  }
+  if (clearAt.size === 0) return messages;
+  return messages.map((message, i) => {
+    if (!clearAt.has(i)) return message;
+    return {
+      ...message,
+      content: [{ type: "text", text: CLEARED_TOOL_RESULT }],
+    };
+  });
+}

package/src/window-budget/rehydrate.ts

@@ -0,0 +1,136 @@
+/**
+ * Window-budget / rehydrate — re-attach recently-read files after a condense.
+ */
+import type { AgentMessage } from "./contract.js";
+import { estimateMessageTokens } from "./budget/estimate.js";
+
+/** Prefix marking a synthetic message that restores a file body post-compaction. */
+export const RESTORED_FILE_PREFIX = "[Restored file after compaction]";
+
+const DEFAULT_MAX_FILES = 5;
+const DEFAULT_TOKEN_BUDGET = 8e3;
+const DEFAULT_READ_TOOL_NAME = "read";
+
+function isRecord4(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function resultBodyText(message: AgentMessage): string {
+  if (!isRecord4(message)) return "";
+  const content = (message as { content?: unknown }).content;
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const block of content) {
+    if (
+      isRecord4(block) &&
+      block.type === "text" &&
+      typeof block.text === "string"
+    ) {
+      parts.push(block.text);
+    }
+  }
+  return parts.join("\n");
+}
+
+function collectVisibleReadPaths(kept: AgentMessage[], readToolName: string): Set<string> {
+  const paths = new Set<string>();
+  for (const message of kept) {
+    if (!isRecord4(message) || message.role !== "assistant") continue;
+    const content = Array.isArray(message.content) ? message.content : [];
+    for (const block of content) {
+      if (!isRecord4(block) || block.type !== "toolCall") continue;
+      if (block.name !== readToolName) continue;
+      const args = isRecord4(block.arguments) ? block.arguments : undefined;
+      const path = args && typeof args.path === "string" ? args.path : "";
+      if (path.length > 0) paths.add(path);
+    }
+  }
+  return paths;
+}
+
+interface DroppedRead {
+  order: number;
+  path: string;
+  body: string;
+}
+
+function collectDroppedReads(
+  dropped: AgentMessage[],
+  readToolName: string,
+): DroppedRead[] {
+  const calls = new Map<string, { path: string; order: number }>();
+  for (let i = 0; i < dropped.length; i++) {
+    const message = dropped[i];
+    if (!isRecord4(message) || message.role !== "assistant") continue;
+    const content = Array.isArray(message.content) ? message.content : [];
+    for (const block of content) {
+      if (!isRecord4(block) || block.type !== "toolCall") continue;
+      if (block.name !== readToolName) continue;
+      const id = typeof block.id === "string" ? block.id : "";
+      const args = isRecord4(block.arguments) ? block.arguments : undefined;
+      const path = args && typeof args.path === "string" ? args.path : "";
+      if (id.length > 0 && path.length > 0) calls.set(id, { path, order: i });
+    }
+  }
+  if (calls.size === 0) return [];
+  const byPath = new Map<string, DroppedRead>();
+  for (let i = 0; i < dropped.length; i++) {
+    const message = dropped[i];
+    if (!isRecord4(message) || message.role !== "toolResult") continue;
+    if ((message as { isError?: unknown }).isError === true) continue;
+    const id = typeof (message as { toolCallId?: unknown }).toolCallId === "string"
+      ? (message as { toolCallId: string }).toolCallId
+      : "";
+    const call = calls.get(id);
+    if (call === undefined) continue;
+    const body = resultBodyText(message as AgentMessage);
+    if (body.length === 0) continue;
+    byPath.set(call.path, { order: i, path: call.path, body });
+  }
+  return [...byPath.values()];
+}
+
+/**
+ * Build the synthetic user messages that re-attach the most-recently-read files
+ * dropped by a condense.
+ */
+export function rehydrateRecentReads(
+  dropped: AgentMessage[],
+  kept: AgentMessage[],
+  opts: {
+    maxFiles?: number;
+    tokenBudget?: number;
+    readToolName?: string;
+  } = {},
+): AgentMessage[] {
+  const maxFiles = Math.max(0, opts.maxFiles ?? DEFAULT_MAX_FILES);
+  const tokenBudget = Math.max(0, opts.tokenBudget ?? DEFAULT_TOKEN_BUDGET);
+  const readToolName = opts.readToolName ?? DEFAULT_READ_TOOL_NAME;
+  if (maxFiles === 0 || tokenBudget === 0) return [];
+  const reads = collectDroppedReads(dropped, readToolName);
+  if (reads.length === 0) return [];
+  const visible = collectVisibleReadPaths(kept, readToolName);
+  const candidates = reads
+    .filter((r) => !visible.has(r.path))
+    .sort((a, b) => b.order - a.order)
+    .slice(0, maxFiles);
+  if (candidates.length === 0) return [];
+  const restored: AgentMessage[] = [];
+  let spent = 0;
+  for (const read of candidates) {
+    const message: AgentMessage = {
+      role: "user",
+      content: `${RESTORED_FILE_PREFIX} ${read.path}\n${read.body}`,
+      timestamp: Date.now(),
+    };
+    const cost = estimateMessageTokens(message);
+    if (spent + cost > tokenBudget && restored.length > 0) break;
+    if (spent + cost > tokenBudget && restored.length === 0) {
+      restored.push(message);
+      break;
+    }
+    restored.push(message);
+    spent += cost;
+  }
+  return restored.reverse();
+}

package/src/window-budget/summarize/condense.ts

@@ -0,0 +1,103 @@
+/**
+ * Window-budget — model-driven summarization.
+ *
+ * {@link summarize} is the single condensing primitive: given the dropped prefix
+ * of a transcript and a {@link SummarizeDeps} bundle, it flattens those messages,
+ * asks the injectable model completer to write a structured digest, and returns a
+ * synthetic {@link Summary} message.
+ */
+import type { AgentMessage, CompleteFn, CondenseScope, Model, Summary } from "../contract.js";
+import { completeSimple } from "indusagi/ai";
+import { CONDENSER_BRIEF, buildSummaryPrompt, flattenTranscript } from "./prompt.js";
+
+export interface SummarizeDeps {
+  /** Injectable completer (default: framework `completeSimple`). */
+  readonly complete?: CompleteFn;
+  /** The summarization model. When omitted, a deterministic local digest is used. */
+  readonly model?: Model<Model<string>["api"]>;
+  /** Which kind of condense this is; defaults to `"session"`. */
+  readonly scope?: CondenseScope;
+  /** An earlier digest to refresh/extend (iterative-refresh / branch carry-in). */
+  readonly priorDigest?: string;
+  /** Cancellation signal forwarded to the completer. */
+  readonly signal?: AbortSignal;
+  /** Credential for the summarization model's provider, forwarded to the completer. */
+  readonly apiKey?: string;
+  /** Optional cap on the digest size, in tokens. */
+  readonly maxTokens?: number;
+}
+
+const DIGEST_HEADER = "[session digest \u2014 older turns condensed]";
+const BRANCH_HEADER = "[branch digest \u2014 archived from a path not taken]";
+
+function toSummaryMessage(digest: string, scope: CondenseScope): AgentMessage {
+  const header = scope === "branch" ? BRANCH_HEADER : DIGEST_HEADER;
+  return {
+    role: "user",
+    content: `${header}\n\n${digest}`,
+    timestamp: Date.now(),
+  };
+}
+
+function textOf(message: { content: Array<{ type: string; text?: string }> }): string {
+  const parts: string[] = [];
+  for (const block of message.content) {
+    if (block.type === "text" && block.text && block.text.trim()) parts.push(block.text);
+  }
+  return parts.join("\n").trim();
+}
+
+function localFallbackDigest(messages: AgentMessage[], priorDigest?: string): string {
+  const lines: string[] = [
+    `# Carryover`,
+    `${messages.length} earlier message(s) were elided without a summarization model bound.`,
+  ];
+  if (priorDigest && priorDigest.trim()) {
+    lines.push("", priorDigest.trim());
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Summarize a slice of dropped messages into a single synthetic {@link Summary}.
+ */
+export async function summarize(
+  messages: AgentMessage[],
+  deps: SummarizeDeps = {},
+): Promise<Summary> {
+  const scope = deps.scope ?? "session";
+  const coveredCount = messages.length;
+  if (!deps.model) {
+    const digest = localFallbackDigest(messages, deps.priorDigest);
+    return { message: toSummaryMessage(digest, scope), coveredCount };
+  }
+  const prompt = buildSummaryPrompt(messages, scope, deps.priorDigest);
+  const context = {
+    systemPrompt: CONDENSER_BRIEF,
+    messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+  };
+  const options = {
+    reasoning: "high",
+    ...(deps.maxTokens !== undefined ? { maxTokens: deps.maxTokens } : {}),
+    ...(deps.signal ? { signal: deps.signal } : {}),
+    ...(deps.apiKey !== undefined ? { apiKey: deps.apiKey } : {}),
+  };
+  const complete = deps.complete ?? completeSimple;
+  const reply = await complete(deps.model, context, options);
+  const digest = textOf(reply as { content: Array<{ type: string; text?: string }> });
+  const finalDigest = digest || localFallbackDigest(messages, deps.priorDigest);
+  return { message: toSummaryMessage(finalDigest, scope), coveredCount };
+}
+
+/**
+ * Branch-archival entrypoint: condense an abandoned branch into one summary
+ * message.
+ */
+export function condenseScope(
+  messages: AgentMessage[],
+  deps: Omit<SummarizeDeps, "scope"> = {},
+): Promise<Summary> {
+  return summarize(messages, { ...deps, scope: "branch" });
+}
+
+export { flattenTranscript };

package/src/window-budget/summarize/index.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+// Type declarations recovered from dist/types (no runtime body)
+/**
+ * Window-budget — summarization subsystem barrel.
+ *
+ * Model-driven condensing of the dropped transcript prefix into one synthetic
+ * summary message, with re-authored prompts (new section names + a new tag
+ * vocabulary). Branch-archival folds in behind the scope flag — `condenseScope`
+ * is the branch entrypoint over the same `summarize` core.
+ */
+export { buildSummaryPrompt, CONDENSER_BRIEF, flattenTranscript, } from "./prompt.js";
+export { condenseScope, summarize } from "./condense.js";
+export type { SummarizeDeps } from "./condense.js";
+export type { AgentMessage, CompleteFn, CondenseScope, Model, Summary, } from "../contract.js";