indusagi-coding-agent 0.2.3 → 0.2.5

package/dist/types/window-budget/contract.d.ts

@@ -1,182 +0,0 @@
-/**
- * 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/dist/types/window-budget/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * 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/dist/types/window-budget/microcompact.d.ts

@@ -1,68 +0,0 @@
-/**
- * Window-budget / microcompact — clear stale tool-result bodies in place.
- *
- * The cheapest token to reclaim is one that is already dead weight: the verbatim
- * body of a tool result the model has long since acted on. Once an agent has
- * read a file, run a search, or executed a command and moved several turns past
- * it, the full body of that result rarely needs to stay in the window — the
- * model's subsequent reasoning already captured what mattered. Yet those bodies
- * (a 2,000-line `read`, a noisy `bash` log, a wide `grep`) dominate the token
- * budget.
- *
- * **Microcompaction** runs *before* a full {@link condense}: it walks the
- * transcript, keeps the last few tool results verbatim (the model may still be
- * working with them), and replaces the body of every older compactable tool
- * result with a short sentinel. This reclaims tokens for free — no model call,
- * no summary round-trip — and often defers (or shrinks the input to) the real
- * condense.
- *
- * Shape note (this rebuild): a tool result is its OWN top-level
- * {@link ToolResultMessage} (`role: 'toolResult'`), not a block nested inside a
- * user message. Clearing one therefore means replacing *that message's*
- * `content` array with a single sentinel text block — never editing a sub-block
- * of some other message. We only clear results whose owning assistant `toolCall`
- * named a compactable tool, so structural/control results stay intact.
- *
- * Behavior-preserving by construction: when there is nothing to clear (no
- * compactable results, or every one is within the keep window) the *same input
- * reference* is returned, so a caller can cheaply detect a no-op.
- */
-import type { AgentMessage } from "./contract.js";
-/**
- * The placeholder spliced in where a stale tool-result body used to be. Kept
- * short on purpose — the whole point is to reclaim the tokens the original body
- * occupied — while still signalling to the model (and to a human reading the
- * transcript) that real content was elided rather than lost.
- */
-export declare const CLEARED_TOOL_RESULT = "[Old tool result content cleared]";
-/**
- * The wire names of tools whose results are safe to clear once stale.
- *
- * These are the read-mostly / output-heavy tools whose bodies are reconstructable
- * (re-read the file, re-run the search) and whose stale content the model has
- * already digested. Control/state tools (todo, memory, task) are deliberately
- * absent — their results can carry standing instructions the model still needs.
- */
-export declare const COMPACTABLE_TOOL_NAMES: ReadonlySet<string>;
-/**
- * Clear the bodies of stale compactable tool results, keeping the most recent
- * `keepRecent` of them verbatim.
- *
- * Walks the transcript, identifies every `role:'toolResult'` message that
- * belongs to a compactable tool call, keeps the last `keepRecent` (floored at 1
- * — `slice(-0)` would keep everything), and replaces each older one's `content`
- * with a single `{ type:'text', text: CLEARED_TOOL_RESULT }` block. Non-tool
- * messages, control-tool results, and already-cleared results are left exactly
- * as they were.
- *
- * Returns the **same input array reference** when nothing was cleared, so the
- * caller can detect a no-op by identity. Otherwise returns a new array; cleared
- * messages are fresh objects (the originals are not mutated).
- *
- * @param messages the active transcript, oldest-first
- * @param opts.keepRecent how many most-recent compactable results to keep
- *   verbatim (default {@link DEFAULT_KEEP_RECENT}, floored at 1)
- */
-export declare function clearStaleToolResults(messages: AgentMessage[], opts?: {
-    keepRecent?: number;
-}): AgentMessage[];

package/dist/types/window-budget/microcompact.test.d.ts

@@ -1,16 +0,0 @@
-/**
- * Window-budget / microcompact + rehydrate — unit tests for item #18.
- *
- * Three layers ride the condense path:
- *   1. microcompact ({@link clearStaleToolResults}) — blank older completed
- *      tool-result bodies to a sentinel, keeping the last N verbatim; no-op
- *      (same reference) otherwise.
- *   2. rehydration ({@link rehydrateRecentReads}) — re-attach the most-recently
- *      dropped file reads as synthetic user messages, deduped against the kept
- *      tail, honoring maxFiles / tokenBudget.
- *   3. circuit breaker — covered in the conductor suite (3 throwing condense
- *      calls stop further attempts, a success resets).
- *
- * Pure + network-free: no model is bound anywhere here.
- */
-export {};

package/dist/types/window-budget/rehydrate.d.ts

@@ -1,56 +0,0 @@
-/**
- * Window-budget / rehydrate — re-attach recently-read files after a condense.
- *
- * A full {@link condense} folds the dropped head of the transcript into one
- * summary message. That digest captures *what happened*, but it necessarily
- * loses the verbatim bodies of files the agent had just read — and those bodies
- * are often exactly the working context the next turn needs (the file it was
- * mid-edit on, the config it was reasoning about). Re-reading them costs a tool
- * round-trip and, worse, the model may not realize it needs to.
- *
- * **Post-compact rehydration** softens that cliff: after the slice is dropped,
- * it scans the *dropped* messages for `read` results, takes the most-recent
- * handful that aren't already visible in the kept tail, and re-attaches their
- * bodies as synthetic user messages ("[Restored file after compaction] …") under
- * a token budget. The model keeps its working files without a re-read, while the
- * older surrounding chatter still gets compressed away.
- *
- * Shape note (this rebuild): a read's *body* lives in its own top-level
- * {@link ToolResultMessage} (`role:'toolResult'`), and the read's *path* lives in
- * the owning assistant `toolCall.arguments.path` (the read tool's arg is `path`,
- * not `file_path`). We pair each dropped `read` call with its result by
- * `toolCallId`, dedup against paths still visible in the kept tail, and emit the
- * most-recent survivors under a token cap.
- *
- * Behavior-preserving by construction: returns an empty array whenever there is
- * nothing to restore (no dropped reads, all already visible, or the budget is
- * exhausted), so the caller can splice the result unconditionally.
- */
-import type { AgentMessage } from "./contract.js";
-/** Prefix marking a synthetic message that restores a file body post-compaction. */
-export declare const RESTORED_FILE_PREFIX = "[Restored file after compaction]";
-/**
- * Build the synthetic user messages that re-attach the most-recently-read files
- * dropped by a condense.
- *
- * Scans `dropped` for `read` calls + result bodies, drops any path still visible
- * in `kept`, sorts the survivors most-recent-first, takes up to `maxFiles`, and
- * emits each as a `user` message of the form
- * `"[Restored file after compaction] <path>\n<body>"` — stopping once the running
- * token estimate would exceed `tokenBudget`. The returned messages are ordered
- * oldest-restored-first so they read naturally when spliced after the summary.
- *
- * Returns an **empty array** when nothing is restorable, so the caller can splice
- * the result unconditionally (`[summary, ...restored, ...kept]`).
- *
- * @param dropped the condensed-away head slice (original bodies, pre-summary)
- * @param kept    the verbatim tail that survives the condense
- * @param opts.maxFiles    cap on restored files (default {@link DEFAULT_MAX_FILES})
- * @param opts.tokenBudget token ceiling for the restored block (default {@link DEFAULT_TOKEN_BUDGET})
- * @param opts.readToolName wire name of the read tool (default `"read"`)
- */
-export declare function rehydrateRecentReads(dropped: AgentMessage[], kept: AgentMessage[], opts?: {
-    maxFiles?: number;
-    tokenBudget?: number;
-    readToolName?: string;
-}): AgentMessage[];

package/dist/types/window-budget/summarize/condense.d.ts

@@ -1,70 +0,0 @@
-/**
- * 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 that stands in for the slice it covers.
- *
- * Both condensing scopes flow through this one function:
- *   - `"session"` — the active-session checkpoint (head condensed, tail kept by
- *     the caller).
- *   - `"branch"`  — an abandoned branch archived into one message.
- * The only difference is the scope flag forwarded into {@link buildSummaryPrompt}
- * (which selects the framing line). {@link condenseScope} is the thin
- * branch-archival entrypoint that pins `scope: "branch"`.
- *
- * The completer is injectable ({@link SummarizeDeps.complete}, default the
- * framework's `completeSimple`) so tests run with no network — pass a stub that
- * returns a canned {@link AssistantMessage}. When no `model` is supplied there is
- * nothing to call, so {@link summarize} degrades to a deterministic local digest
- * rather than guessing a model — keeping it usable in a bare/offline build.
- */
-import type { AgentMessage, CompleteFn, CondenseScope, Model, Summary } from "../contract.js";
-import { flattenTranscript } from "./prompt.js";
-/**
- * What {@link summarize} needs. Every field is optional so the function is
- * network-free-testable: omit `model` for a local fallback digest, or inject a
- * `complete` stub for a scripted model response.
- */
-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;
-    /**
-     * Optional cap on the digest size, in tokens, forwarded to the completer's
-     * `maxTokens`. A modest ceiling keeps the summary itself from eating the
-     * window. When omitted the model's own default applies.
-     */
-    readonly maxTokens?: number;
-}
-/**
- * Summarize a slice of dropped messages into a single synthetic {@link Summary}.
- *
- * One code path for both scopes — `deps.scope` (default `"session"`) only changes
- * the prompt framing. With a `model` bound it calls `deps.complete`
- * (default `completeSimple`) once with {@link CONDENSER_BRIEF} as the system
- * prompt and {@link buildSummaryPrompt} as the user turn; otherwise it returns a
- * deterministic local digest. Never throws on an empty model reply — it falls
- * back to the local digest so a {@link Summary} is always produced.
- *
- * @returns a {@link Summary} whose `message` replaces the `coveredCount` source
- *          messages it summarizes.
- */
-export declare function summarize(messages: AgentMessage[], deps?: SummarizeDeps): Promise<Summary>;
-/**
- * Branch-archival entrypoint: condense an abandoned branch into one summary
- * message. A thin wrapper that pins `scope: "branch"` and delegates to
- * {@link summarize} — the branch case is the same machinery, not a separate
- * engine.
- */
-export declare function condenseScope(messages: AgentMessage[], deps?: Omit<SummarizeDeps, "scope">): Promise<Summary>;
-/** Re-export the flattener so callers can preview what the model will receive. */
-export { flattenTranscript };

package/dist/types/window-budget/summarize/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * 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";

package/dist/types/window-budget/summarize/prompt.d.ts

@@ -1,56 +0,0 @@
-/**
- * Window-budget — summarization prompt assembly (re-authored).
- *
- * When the transcript crosses budget, the older head is *condensed* into one
- * synthetic message. This module turns the dropped slice of {@link AgentMessage}s
- * into the single text payload handed to the model completer. Two pieces ship
- * here:
- *
- *   1. {@link CONDENSER_BRIEF} — the system-prompt brief that frames the model as
- *      a *recorder*, not a continuation of the chat: read the transcript as data
- *      and emit only the structured digest.
- *   2. {@link buildSummaryPrompt} — flattens the dropped messages into a tagged
- *      block and appends the section template the model fills in.
- *
- * OWN VOCABULARY (an original prompt design):
- *   - Section headings are `# Objective / # Guardrails /
- *     # Status (Shipped / Active / Stuck) / # Rationale / # Plan / # Carryover`.
- *   - The transcript is wrapped in `<scrollback>…</scrollback>` and a prior digest
- *     (the branch-archival / iterative-refresh path) in
- *     `<carried-digest>…</carried-digest>`.
- *   - Per-message lines use `» role:` markers (`» you`, `» agent`,
- *     `» agent.plan`, `» agent.call`, `» tool`).
- *
- * No token math, no model calls, no I/O here — only string assembly. The scope
- * flag selects the framing line (active-session checkpoint vs abandoned-branch
- * archive); everything else is one code path.
- */
-import type { AgentMessage, CondenseScope } from "../contract.js";
-/**
- * The system-prompt brief for the condenser model. Frames the request as a
- * record-keeping task — the model must NOT answer, continue, or act on the
- * conversation; it only transcribes it into the fixed section layout. Re-authored
- * wording; shares no sentences with the legacy `SUMMARIZATION_SYSTEM_PROMPT`.
- */
-export declare const CONDENSER_BRIEF: string;
-/**
- * Flatten a list of messages into a single `\n`-joined block of `» role:` lines.
- * Exported so the condenser can reuse it for diagnostics/tests.
- */
-export declare function flattenTranscript(messages: AgentMessage[]): string;
-/**
- * Build the full summarization prompt for a slice of dropped messages.
- *
- * The result is one string: the scope framing, the flattened transcript wrapped
- * in `<scrollback>`, an optional carried digest wrapped in `<carried-digest>`
- * (the iterative-refresh / branch-archival input), and the section template the
- * model fills in. Pass this as the user turn to the injectable completer; pair it
- * with {@link CONDENSER_BRIEF} as the system prompt.
- *
- * @param messages  the dropped prefix to summarize
- * @param scope     `"session"` (active checkpoint) or `"branch"` (archive)
- * @param priorDigest  an optional earlier digest to refresh/extend, threaded in
- *                      under `<carried-digest>` so the model merges rather than
- *                      re-derives. Omit for a first-pass condense.
- */
-export declare function buildSummaryPrompt(messages: AgentMessage[], scope: CondenseScope, priorDigest?: string): string;

package/dist/types/window-budget/window-budget.test.d.ts

@@ -1,18 +0,0 @@
-/**
- * Window-budget — Phase 3 / subsystem 05 unit tests.
- *
- * Pure, network-free coverage of the context-window budgeting subsystem:
- *   1. estimateTokens grows with content.
- *   2. isOverBudget is false under the threshold, true over it.
- *   3. planSlice keeps the recent tail and never splits a toolCall/toolResult
- *      pair — even when the ideal cut lands mid tool-group it snaps to a safe
- *      boundary.
- *   4. createCondenser (with a scripted, no-network completer) condenses an
- *      over-budget transcript to a smaller [summary, ...recent] list, and leaves
- *      an under-budget transcript unchanged.
- *   5. condenseScope("branch") produces a branch-flavored digest.
- *
- * No network: the only model call path is exercised through an injected
- * {@link CompleteFn} stub that returns a canned {@link AssistantMessage}.
- */
-export {};

package/dist/types/workflow-engine/agent-runner.d.ts

@@ -1,105 +0,0 @@
-/**
- * createWorkflowAgentRunner — the live {@link WorkflowAgentRunner} that makes the
- * `workflow` tool's `agent()` global spawn real subagents.
- *
- * The pure {@link "./engine"} engine delegates every `agent(prompt, opts)` call
- * to an injected {@link WorkflowAgentRunner}; this module supplies the production
- * implementation. Each subagent run spins a *fresh, isolated* framework
- * {@link Agent} — the same `facade/bot` Agent the conductor and the `task`
- * delegate-runner drive — bound to the parent's model id and credential
- * resolver, given the `'authoring'` capability deck.
- *
- * Two properties matter:
- *
- *   1. **Recursion guard.** The deck is built via `provisionDeck("authoring", …)`,
- *      whose profile EXCLUDES the app-novel cards — including the new `workflow`
- *      card (registered all-profile-only in {@link "../capability-deck"}). A
- *      workflow subagent therefore cannot itself call `workflow` (nor `task`).
- *
- *   2. **Structured output.** When the script passes `opts.schema`, the runner
- *      adds the {@link createStructuredOutputTool} `structured_output` tool to the
- *      deck and appends the pi "final action MUST be structured_output" contract
- *      to the prompt. Because the framework `AgentToolResult` has no `terminate`
- *      flag, the tool does NOT end the loop early — the runner instead runs the
- *      subagent to completion, then returns `capture.value` (throwing if the
- *      subagent never called it). With no schema it returns the final assistant
- *      text (the {@link finalAssistantText} pattern, identical to delegate-runner).
- *
- * Cancellation is forwarded: an already-aborted signal short-circuits and an
- * abort raised mid-run calls `agent.abort()`.
- *
- * The model catalog/matcher is built ONCE at create time (the conductor pattern);
- * each `run()` resolves the per-call `opts.model` (falling back to the runner's
- * default `modelId`) against that single matcher. The `spawn` option is a pure
- * test seam — a unit test drives the runner with an in-memory fake instead of a
- * real network round-trip.
- */
-import { type AgentMessage } from "../conductor";
-import { type AgentTool } from "../capability-deck";
-import { type AgentEvent } from "indusagi/agent";
-import type { WorkflowAgentRunner } from "./engine";
-/**
- * The minimal subagent surface the runner drives.
- *
- * A real framework {@link Agent} satisfies this structurally; a test passes a
- * lightweight fake via {@link WorkflowAgentRunnerOptions.spawn}. Only the pieces
- * the runner touches are named.
- */
-export interface WorkflowSubAgent {
-    prompt(input: string): Promise<void>;
-    abort(): void;
-    /**
-     * Subscribe to the framework `Agent` event stream; returns an unsubscribe
-     * thunk. Optional on the structural fake — when absent the runner simply skips
-     * live activity reporting (the run still completes and returns its result).
-     */
-    subscribe?(fn: (event: AgentEvent) => void): () => void;
-    readonly state: {
-        messages: readonly AgentMessage[];
-        error?: string;
-        usage?: unknown;
-    };
-}
-/** The deck of tools handed to a spawned subagent. */
-export interface WorkflowSpawnContext {
-    /** The base tools for this run (the `'authoring'` deck, recursion-guarded). */
-    readonly tools: AgentTool[];
-    /** The resolved system prompt for this subagent. */
-    readonly systemPrompt: string;
-}
-/** Configuration for {@link createWorkflowAgentRunner}. */
-export interface WorkflowAgentRunnerOptions {
-    /** The default model id a subagent runs under when the script names none. */
-    readonly modelId: string;
-    /** The working directory the subagent's deck is scoped to. */
-    readonly cwd: string;
-    /**
-     * Per-call credential resolver, forwarded to the framework `Agent` unchanged.
-     * Omitted from the agent options entirely when undefined so the framework
-     * env-var lookup still wins.
-     */
-    readonly getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
-    /**
-     * The base system prompt prepended to every subagent. A sensible default is
-     * used when omitted.
-     */
-    readonly system?: string;
-    /**
-     * Test seam: build the subagent instead of constructing a real framework
-     * `Agent`. When omitted the runner uses `new Agent`.
-     */
-    readonly spawn?: (prompt: string, context: WorkflowSpawnContext) => WorkflowSubAgent;
-}
-/**
- * Build a live {@link WorkflowAgentRunner} the host wires into the deck context.
- *
- * The model catalog/matcher is built once up front (the conductor pattern); each
- * `run()` resolves `opts.model ?? modelId` against it. A schema request wires the
- * `structured_output` capture tool and the structured contract; a model that does
- * not resolve throws out of `run()` so the engine maps it to an `agent ... failed`
- * log + a `null` branch (the engine's per-branch failure-to-null semantics).
- *
- * @param opts the model id, cwd, credential/system, and optional test seam
- * @returns a runner satisfying the engine's {@link WorkflowAgentRunner} contract
- */
-export declare function createWorkflowAgentRunner(opts: WorkflowAgentRunnerOptions): WorkflowAgentRunner;

package/dist/types/workflow-engine/agent-runner.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * createWorkflowAgentRunner — focused unit tests driven through the `spawn` seam.
- *
- * No model is resolved and no network is touched: each test passes an in-memory
- * fake subagent via `opts.spawn`, so the test exercises the runner's prompt
- * assembly, structured-output capture, final-text extraction, and abort wiring.
- */
-export {};