indusagi-coding-agent 0.2.4 → 0.2.5

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,76 +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;
-    /**
-     * Credential for the summarization model's provider, forwarded to the
-     * completer. Required in practice for sessions whose key is resolved
-     * per-call (server tier) rather than from an environment variable.
-     */
-    readonly apiKey?: string;
-    /**
-     * 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,124 +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, type SessionPermissionPolicy } 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;
-    /**
-     * Resolve the current server-tier gateway routing map (provider -> gateway
-     * base url). Called FRESH on every `run()` — never cached — so a mid-session
-     * `/login` (to "Indus Server") is always picked up on the very next subagent
-     * call. Mirrors {@link getApiKey}, which is likewise invoked per-request
-     * rather than resolved once at construction.
-     */
-    readonly getGatewayBaseUrls?: () => Promise<Record<string, string>>;
-    /**
-     * The parent session's live permission policy: the SAME mutable rule list the
-     * parent gate reads plus a live getter onto the conductor's current mode. When
-     * present, every spawned workflow subagent runs under a RESOLVER-LESS gate
-     * built from it — deny/ask rules, plan-mode enforcement, and the
-     * catastrophic-bash blocklist apply per inner tool call, and a mid-run mode
-     * switch (Shift+Tab) retargets the very next subagent tool call. A subagent
-     * cannot prompt, so an `ask` decision deterministically denies. Absent (a bare
-     * test construction), the subagent runs ungated as before.
-     */
-    readonly permissionPolicy?: SessionPermissionPolicy;
-}
-/**
- * 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 {};

package/dist/types/workflow-engine/display.d.ts

@@ -1,148 +0,0 @@
-/**
- * Workflow progress snapshot model + text renderer.
- *
- * The engine emits lifecycle callbacks (phase started, agent started/ended,
- * log) which a host folds into a {@link WorkflowSnapshot}. This module owns the
- * snapshot's pure data shape, the two pure recompute helpers, and the
- * `renderWorkflowText` / `renderWorkflowLines` renderers that turn a snapshot
- * into the `◆ Workflow:` progress tree shown live in the tool result.
- *
- * The renderer is a verbatim behavioral port of pi-dynamic-workflows'
- * `src/display.ts` — same `◆ Workflow: name (x/y done)` header, same per-phase
- * `▶/✓` markers with `done/total · running · errors · skipped` counts, same
- * `    #id <glyph> label` subagent rows, same status glyphs
- * (`○ queued`, `● running`, `✓ done`, `✗ error`, `- skipped`), same "Unphased"
- * group, same trailing `log:` lines.
- *
- * Unlike pi, this file carries NO framework-UI bindings (no `ExtensionContext`,
- * no widget display). The card/console wiring that consumes these renderers
- * lands in stage 2; here we expose only the pure snapshot + string surface.
- */
-import type { WorkflowMeta } from "./parse";
-/** Lifecycle status of a single workflow subagent row. */
-export type WorkflowAgentStatus = "queued" | "running" | "done" | "error" | "skipped";
-/** One subagent's row in the live progress tree. */
-export interface WorkflowAgentSnapshot {
-    /** 1-based id, the order the agent started in. */
-    id: number;
-    /** Short human label for the agent (defaulted from phase + index if absent). */
-    label: string;
-    /** The phase the agent belongs to, if any. */
-    phase?: string;
-    /** The task prompt the agent was given. */
-    prompt: string;
-    /** Current lifecycle status. */
-    status: WorkflowAgentStatus;
-    /** Optional short preview of the agent's result. */
-    resultPreview?: string;
-    /** Optional error summary when the agent failed or was skipped. */
-    error?: string;
-    /** Wall-clock ms when the subagent started (for the live elapsed counter). */
-    startedAt?: number;
-    /** Wall-clock ms when the subagent settled (caps the elapsed counter). */
-    endedAt?: number;
-    /** Cumulative input tokens the subagent has spent. */
-    tokensIn?: number;
-    /** Cumulative output tokens the subagent has spent. */
-    tokensOut?: number;
-    /** How many tool calls the subagent has started. */
-    toolCount?: number;
-    /** The tool the subagent is running right now, if any. */
-    currentTool?: string;
-    /** The last tool the subagent finished (when nothing is running). */
-    lastTool?: string;
-}
-/** The full live progress model for one workflow run. */
-export interface WorkflowSnapshot {
-    /** Workflow name (from `meta.name`). */
-    name: string;
-    /** Workflow description (from `meta.description`). */
-    description?: string;
-    /** Declared/observed phase titles, in order. */
-    phases: string[];
-    /** The phase currently active (last `phase()` call). */
-    currentPhase?: string;
-    /** Log lines emitted via `log()`. */
-    logs: string[];
-    /** Every subagent row, in start order. */
-    agents: WorkflowAgentSnapshot[];
-    /** Total agents seen. */
-    agentCount: number;
-    /** Agents currently running. */
-    runningCount: number;
-    /** Agents finished successfully. */
-    doneCount: number;
-    /** Agents that errored. */
-    errorCount: number;
-    /** Total run duration once complete. */
-    durationMs?: number;
-    /** The workflow's final returned value once complete. */
-    result?: unknown;
-}
-/** Tunables for the text renderer (how much of the tree to show). */
-export interface WorkflowDisplayOptions {
-    /** Max subagent rows shown per phase (most recent kept). Default 8. */
-    maxAgents?: number;
-    /** Max trailing log lines shown. Default 2. */
-    maxLogs?: number;
-    /** Append a short result preview to each agent row. Default false. */
-    showResultPreviews?: boolean;
-    /**
-     * Soft cap on total tree lines for the LIVE render. Default 9 — headroom under
-     * the framework `TaskPanel` 10-line clamp so a running agent is never cut off
-     * by a trailing `…`. Completed phases collapse to one line each, and if the
-     * tree is still over budget the OLDEST completed phases collapse into a single
-     * `… N earlier phases done` line (running/current phases are never collapsed).
-     * Pass a large value (e.g. the settled/final render, or Ctrl+O expand) to show
-     * everything in full.
-     */
-    maxLines?: number;
-}
-/**
- * Build an empty snapshot for a freshly parsed workflow `meta`.
- *
- * @param meta the workflow header
- */
-export declare function createWorkflowSnapshot(meta: WorkflowMeta): WorkflowSnapshot;
-/**
- * Recompute the derived counts (`agentCount`/`runningCount`/`doneCount`/
- * `errorCount`) from the `agents` array. Pure — returns a new snapshot.
- *
- * @param snapshot the snapshot whose counts to refresh
- */
-export declare function recomputeWorkflowSnapshot(snapshot: WorkflowSnapshot): WorkflowSnapshot;
-/**
- * Render the snapshot as the `◆ Workflow:` progress tree (array of lines).
- *
- * The per-agent metrics segment (elapsed seconds, token spend, tool activity) is
- * computed at render time from `now` so the seconds tick on every render even
- * during a long silent tool call. Keep `now` an explicit param so the renderer
- * stays pure and testable.
- *
- * @param snapshot the progress model
- * @param options render tunables
- * @param now the current wall-clock ms used to compute live elapsed seconds
- */
-export declare function renderWorkflowLines(snapshot: WorkflowSnapshot, options?: WorkflowDisplayOptions, now?: number): string[];
-/**
- * Render the snapshot as a single string for the tool result.
- *
- * For the LIVE (not-completed) render the `◆ Workflow:` header already says the
- * run is in progress, so no extra header line is added — this saves a line under
- * the framework `TaskPanel` 10-line clamp. The final (completed) render keeps the
- * explicit `Workflow completed` header.
- *
- * @param snapshot the progress model
- * @param completed whether the run has finished
- * @param options render tunables
- * @param now the current wall-clock ms used to compute live elapsed seconds
- */
-export declare function renderWorkflowText(snapshot: WorkflowSnapshot, completed?: boolean, options?: WorkflowDisplayOptions, now?: number): string;
-/**
- * One-line preview of an arbitrary result value (string passthrough, else
- * JSON), truncated to `max` chars. Used to fill `resultPreview`.
- *
- * @param value the result to preview
- * @param max max preview length
- */
-export declare function preview(value: unknown, max?: number): string;

package/dist/types/workflow-engine/display.test.d.ts

@@ -1 +0,0 @@
-export {};