indusagi 0.12.32 → 0.12.34

package/dist/types/smithy/persona/blueprint.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `AgentBlueprint` — the validated description of one agent Smithy can mint.
+ *
+ * A blueprint is the small, declarative spec that fully determines a generated
+ * agent: its name, a one-line description, the system prompt that gives it its
+ * voice, which slice of the tool surface it is trusted with, the model that backs
+ * it, and optional free-form tags for cataloguing. It is the unit that flows
+ * through Smithy's persona layer — profiles supply partial blueprints, the
+ * {@link defineAgent} generator merges and completes them, and the runtime
+ * adapter turns a finished blueprint into a runnable `AgentConfig`.
+ *
+ * Everything here is *data plus validation*. The shape is mirrored by a zod
+ * schema so a blueprint that arrives from disk, a profile table, or a user-typed
+ * spec is checked before anything downstream trusts it. The tool-collection
+ * literal union is intentionally identical to the three named collections the
+ * capabilities layer publishes (`read-only` / `coding` / `all`); it is kept as a
+ * local union so this schema validates standalone without importing that type.
+ */
+import { z } from "zod";
+/**
+ * The tool surface a generated agent is granted, named to match the capabilities
+ * layer's collections:
+ *   - `read-only` — observe the workspace and the web; never mutate.
+ *   - `coding`    — read-only plus write/edit/bash/todo/process.
+ *   - `all`       — every registered tool.
+ */
+export type ToolCollectionName = "read-only" | "coding" | "all";
+/** The complete, validated description of an agent to be generated. */
+export interface AgentBlueprint {
+    /** A short, file-safe identifier for the agent (e.g. `code-reviewer`). */
+    readonly name: string;
+    /** A one-line summary of what the agent is for. */
+    readonly description: string;
+    /** The system prompt that establishes the agent's role and behaviour. */
+    readonly systemPrompt: string;
+    /** Which slice of the built-in tool surface the agent may call. */
+    readonly toolCollection: ToolCollectionName;
+    /** The model id the agent's runs are bound to. */
+    readonly model: string;
+    /** Optional free-form labels for grouping and search. */
+    readonly tags?: readonly string[];
+}
+/** zod schema mirroring {@link AgentBlueprint}; the validation source of truth. */
+export declare const agentBlueprintSchema: z.ZodType<AgentBlueprint>;
+/** Raised when a candidate object fails {@link agentBlueprintSchema}. */
+export declare class BlueprintError extends Error {
+    /** The individual validation issues, in `path: message` form. */
+    readonly issues: readonly string[];
+    constructor(issues: readonly string[]);
+}
+/**
+ * Validate an arbitrary value as an {@link AgentBlueprint}, throwing a
+ * {@link BlueprintError} (with every issue collected) when it does not conform.
+ *
+ * Returns a fresh, typed object on success so callers never alias the input.
+ */
+export declare function validateBlueprint(candidate: unknown): AgentBlueprint;
+/**
+ * Non-throwing variant of {@link validateBlueprint}: returns the typed blueprint
+ * or `undefined`, for callers that prefer to branch rather than catch.
+ */
+export declare function tryValidateBlueprint(candidate: unknown): AgentBlueprint | undefined;
+/**
+ * Serialize a blueprint to canonical, stable, pretty-printed JSON.
+ *
+ * Keys are emitted in a fixed order (independent of the object's own key order)
+ * so two equal blueprints always produce byte-identical text — handy for diffing,
+ * caching, and writing to a manifest.
+ */
+export declare function serializeBlueprint(blueprint: AgentBlueprint): string;
+/**
+ * Parse JSON text back into a validated {@link AgentBlueprint}. Malformed JSON
+ * and schema failures both surface as a {@link BlueprintError}.
+ */
+export declare function deserializeBlueprint(text: string): AgentBlueprint;

package/dist/types/smithy/persona/define-agent.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `defineAgent` — the single blueprint generator, and `toAgentConfig` — the
+ * bridge from a finished blueprint into the runtime's `AgentConfig`.
+ *
+ * Where a naive design ships a family of `createReviewAgent` / `createCoderAgent`
+ * / `createResearchAgent` factories that differ only by a tool factory and a few
+ * prompt lines, Smithy ships *one* generator over a data table. {@link defineAgent}
+ * takes a caller's spec (which must at least name the agent), optionally seeds it
+ * from a starter {@link PROFILES | profile}, merges the two with the spec winning
+ * on every field, fills any remaining gap from a baseline default, and validates
+ * the completed object as an {@link AgentBlueprint}. The result is a fully-formed,
+ * checked blueprint — or a {@link BlueprintError} if the merge could not satisfy
+ * the schema.
+ *
+ * {@link toAgentConfig} is the second half: it turns that validated blueprint into
+ * the immutable `AgentConfig` the agent runtime consumes, resolving the named tool
+ * collection into a runnable `ToolBox` via the capabilities layer.
+ */
+import type { AgentConfig } from "../../runtime";
+import { type AgentBlueprint } from "./blueprint";
+/** The minimum a caller must supply: at least the agent's name. */
+export type AgentSpec = Partial<AgentBlueprint> & {
+    name: string;
+};
+/**
+ * Build a complete, validated {@link AgentBlueprint} from a partial spec and an
+ * optional starter profile.
+ *
+ * Precedence, highest first: the caller's `spec`, then the named `profile`'s
+ * defaults, then the module {@link BASELINE}. `tags` from the spec replace (do not
+ * merge with) the profile's tags, so a caller stays in full control of labelling.
+ *
+ * @param spec    The caller's blueprint fragment; must include `name`.
+ * @param profile Optional starter profile name (e.g. `coder`); ignored if absent.
+ * @throws BlueprintError when the merged result fails schema validation, or when
+ *         a non-empty `profile` does not name a known profile.
+ */
+export declare function defineAgent(spec: AgentSpec, profile?: string): AgentBlueprint;
+/**
+ * Project a validated {@link AgentBlueprint} onto the runtime's immutable
+ * {@link AgentConfig}.
+ *
+ * The blueprint's `systemPrompt` becomes the config's `system` preamble, the
+ * `model` is passed through, and the named `toolCollection` is resolved into a
+ * runnable `ToolBox` by the capabilities layer. `cwd` roots the resulting tools
+ * at a working directory (defaults to the process cwd inside `toolBox`).
+ *
+ * @param blueprint A blueprint that has already passed {@link defineAgent}.
+ * @param cwd       Optional working directory the tools operate within.
+ */
+export declare function toAgentConfig(blueprint: AgentBlueprint, cwd?: string): AgentConfig;

package/dist/types/smithy/persona/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Smithy persona layer — public surface.
+ *
+ * The blueprint type + its validation/serialization helpers, the starter profile
+ * table, and the single {@link defineAgent} generator with its {@link toAgentConfig}
+ * runtime bridge. Together these turn a partial spec into a validated, runnable
+ * agent description.
+ */
+export { agentBlueprintSchema, BlueprintError, validateBlueprint, tryValidateBlueprint, serializeBlueprint, deserializeBlueprint, } from "./blueprint";
+export type { AgentBlueprint, ToolCollectionName } from "./blueprint";
+export { PROFILES, PROFILE_NAMES, isProfileName, getProfile, } from "./profiles";
+export type { AgentProfile, ProfileName } from "./profiles";
+export { defineAgent, toAgentConfig } from "./define-agent";
+export type { AgentSpec } from "./define-agent";

package/dist/types/smithy/persona/profiles.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `PROFILES` — Smithy's starter agent templates.
+ *
+ * A *profile* is a named, partial {@link AgentBlueprint}: the sensible-default
+ * skeleton for a common kind of agent. It is deliberately incomplete — it never
+ * fixes a `name` (that is the one thing a caller must always supply) — but it
+ * pins the defaults that distinguish, say, a read-only researcher from a
+ * file-mutating coder: the tool collection, a baseline model, a starter system
+ * prompt, and a description.
+ *
+ * The {@link defineAgent} generator merges a chosen profile *under* a caller's
+ * spec (spec wins on every field) and validates the result. So the profile table
+ * collapses what would otherwise be a family of near-identical `create*Agent`
+ * factory functions into one data table plus one generator. Adding a new kind of
+ * starter agent is a single entry here, not a new function.
+ *
+ * All prose below — every description and system prompt — is original to this
+ * codebase.
+ */
+import type { AgentBlueprint } from "./blueprint";
+/**
+ * A profile is a partial blueprint with `name` removed: the one field a profile
+ * never decides on the caller's behalf.
+ */
+export type AgentProfile = Partial<Omit<AgentBlueprint, "name">>;
+/** The names of the starter profiles this module ships. */
+export type ProfileName = "coder" | "researcher" | "reviewer";
+/**
+ * The starter profile table.
+ *
+ * Each entry is a complete-enough skeleton that, combined with a name, validates
+ * as a blueprint on its own — so `defineAgent({ name }, "researcher")` works with
+ * no further input.
+ */
+export declare const PROFILES: Readonly<Record<ProfileName, AgentProfile>>;
+/** The profile names as an array, for menus and validation. */
+export declare const PROFILE_NAMES: readonly ProfileName[];
+/** Type guard: whether a string names a known profile. */
+export declare function isProfileName(value: string): value is ProfileName;
+/**
+ * Look up a profile by name. Returns the partial blueprint, or `undefined` when
+ * the name is not in the table.
+ */
+export declare function getProfile(name: string): AgentProfile | undefined;

package/dist/types/smithy/runtime/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Smithy runtime layer — public surface.
+ *
+ * The stateful session-level bookkeeping that backs a Smithy build. For now this
+ * is the {@link ToolLedger}, which keeps an append-only account of tool
+ * executions and the running per-tool aggregates derived from them.
+ */
+export { ToolLedger } from "./tool-ledger";
+export type { ToolEvent, LedgerEntry, ToolTally, LedgerSummary, } from "./tool-ledger";

package/dist/types/smithy/runtime/tool-ledger.d.ts

@@ -0,0 +1,130 @@
+/**
+ * `ToolLedger` — a stateful record of tool activity across a build session.
+ *
+ * While Smithy designs an agent it leans on the underlying runtime tools (read a
+ * file, run a command, search the tree, and so on). Something has to keep a
+ * running account of which tools fired, with what, and whether each call landed.
+ * The old shape of this was a pure reducer: a single function folded a list of
+ * executions into a fresh summary on every call, recomputing the whole picture
+ * from the start each time it was asked.
+ *
+ * This module replaces that fold with a long-lived object. A `ToolLedger` owns
+ * its history and is mutated as the session runs. It keeps two things in step:
+ *
+ *   - an *append-only log* — every {@link record} call pushes one
+ *     {@link LedgerEntry} onto the end and nothing is ever rewritten or removed;
+ *   - a set of *derived aggregates* — per-tool counts and a failure tally that are
+ *     advanced incrementally on each append, never rebuilt by re-walking the log.
+ *
+ * Because the aggregates ride along with the log, {@link summary} is a cheap read
+ * of already-settled numbers rather than a fold. {@link reset} returns the ledger
+ * to its just-constructed state so one instance can serve a fresh session.
+ *
+ * The class holds no I/O and no clock of its own beyond an optional caller-stamped
+ * time on each record; it only accounts for what it is told.
+ */
+/** A single tool invocation as the ledger was asked to remember it. */
+export interface ToolEvent {
+    /** The tool's name, e.g. `read-file` or `run-command`. */
+    readonly tool: string;
+    /** The arguments the tool was called with, as the caller saw them. */
+    readonly input?: unknown;
+    /** Whatever the tool produced (a result, an error payload, anything). */
+    readonly output?: unknown;
+    /** Whether the call is considered to have succeeded. */
+    readonly ok: boolean;
+}
+/**
+ * One settled row of the ledger: the event the caller recorded, plus the
+ * bookkeeping the ledger stamped onto it as it filed the row.
+ */
+export interface LedgerEntry extends ToolEvent {
+    /** 1-based position in the append order; also the count after this row. */
+    readonly seq: number;
+    /** When the row was filed (epoch ms), defaulting to filing time. */
+    readonly at: number;
+}
+/** The per-tool slice of a {@link LedgerSummary}. */
+export interface ToolTally {
+    /** Total calls recorded for this tool. */
+    readonly calls: number;
+    /** How many of those calls succeeded (`ok: true`). */
+    readonly ok: number;
+    /** How many failed (`ok: false`); always `calls - ok`. */
+    readonly failed: number;
+}
+/**
+ * A point-in-time digest of everything the ledger has seen.
+ *
+ * `byTool` carries one {@link ToolTally} per distinct tool name. The top-level
+ * fields are session-wide rollups so a caller never has to sum the map by hand.
+ */
+export interface LedgerSummary {
+    /** Total calls recorded across every tool. */
+    readonly total: number;
+    /** Total successful calls across every tool. */
+    readonly ok: number;
+    /** Total failed calls across every tool. */
+    readonly failed: number;
+    /** Number of distinct tool names that have fired at least once. */
+    readonly tools: number;
+    /** Per-tool breakdown, keyed by tool name. */
+    readonly byTool: Record<string, ToolTally>;
+}
+/**
+ * A stateful, append-style account of tool executions for one build session.
+ *
+ * Construct one per session, feed it each tool result through {@link record}, and
+ * read {@link entries} or {@link summary} whenever a snapshot is wanted. The
+ * derived counts are kept current as records arrive, so reads never re-fold the
+ * log.
+ */
+export declare class ToolLedger {
+    /** The append-only history; never spliced, only pushed. */
+    private readonly log;
+    /** Live per-tool counters, advanced one record at a time. */
+    private readonly counters;
+    /** Session-wide rollups, kept in step with {@link counters}. */
+    private totalCalls;
+    private totalOk;
+    private totalFailed;
+    /**
+     * File one tool execution.
+     *
+     * Appends a stamped {@link LedgerEntry} to the log and advances the per-tool and
+     * session-wide aggregates by exactly this one event. Returns the filed entry so
+     * a caller can read its assigned `seq` / `at`.
+     *
+     * @param event  The execution to remember.
+     * @param at     Optional epoch-ms timestamp; defaults to `Date.now()`.
+     */
+    record(event: ToolEvent, at?: number): LedgerEntry;
+    /**
+     * The append-only log, oldest first.
+     *
+     * Returns a shallow copy so a caller cannot mutate the ledger's history through
+     * the returned array. The {@link LedgerEntry} rows are themselves read-only.
+     */
+    entries(): readonly LedgerEntry[];
+    /**
+     * A digest built from the live aggregates — counts per tool and the failure
+     * tally — without re-walking the log.
+     *
+     * The returned object is a fresh, detached snapshot: the `byTool` map and each
+     * tally are copied out so later records don't reach back into it.
+     */
+    summary(): LedgerSummary;
+    /** True once at least one execution has been recorded. */
+    get size(): number;
+    /**
+     * Clear the log and every derived aggregate, returning the ledger to its
+     * freshly-constructed state so the same instance can serve a new session.
+     */
+    reset(): void;
+    /**
+     * Fold a single freshly-filed entry into the running aggregates. This is the
+     * only place the counters move, which is what keeps {@link summary} a read
+     * rather than a recomputation.
+     */
+    private advance;
+}

package/dist/types/smithy/smithy.test.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Smithy build-session tests.
+ *
+ * These exercise the agent-builder end to end with NO real I/O and NO network:
+ * the interview is driven by a scripted `ask` that returns canned answers, the
+ * knowledge pack is read from the on-disk manifest the loader ships beside it,
+ * and tool collections are resolved through the real capabilities layer (which
+ * only describes tools here — none are run).
+ *
+ * Coverage:
+ *   (1) FlagReader parses a flag line into a SmithyConfig; bad/missing values throw.
+ *   (2) defineAgent merges a spec over a profile, validates, and rejects a bad name.
+ *   (3) buildInteractive over a scripted ask() produces the expected blueprint and
+ *       records the steps on the ToolLedger and into the TranscriptModel.
+ *   (4) buildFromConfig (non-interactive) yields a blueprint whose toAgentConfig
+ *       resolves tools from the right collection.
+ *   (5) loadKnowledge reads the manifest plus at least three guides.
+ *   (6) TranscriptModel redacts a secret-looking token and collapses a huge blob.
+ */
+export {};

package/dist/types/smithy/ui/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Smithy UI layer — public surface.
+ *
+ * The render seam between the gateway's wire transcript and a person: the
+ * {@link TranscriptModel} visitor that sanitizes and projects turns into a
+ * {@link RenderTranscript}, and the minimal text {@link ForgeView} seam (with its
+ * default {@link ConsoleForgeView}) the builder loop talks to. No terminal
+ * toolkit is imported here; a richer view is added by implementing `ForgeView`.
+ */
+export { TranscriptModel, DEFAULT_VISITORS, DEFAULT_SANITIZE_OPTIONS, ConsoleForgeView, formatTranscript, } from "./transcript";
+export type { RenderBlockKind, RenderRole, RenderBlock, RenderTurn, RenderTranscript, SanitizeOptions, VisitContext, BlockVisitor, VisitorTable, ForgeView, } from "./transcript";

package/dist/types/smithy/ui/transcript.d.ts

@@ -0,0 +1,183 @@
+/**
+ * `TranscriptModel` — a visitor over a build-conversation transcript.
+ *
+ * Smithy's agent-building session is, underneath, an ordinary model conversation:
+ * an ordered list of {@link Turn}s, each a bag of typed {@link Block}s. Before any
+ * of that can be shown to a person — or written to a session log — it has to be
+ * *cleaned* and *projected*: secrets stripped, runaway whitespace collapsed, giant
+ * blobs (a pasted file, a base64 image) redacted to a short placeholder, and the
+ * whole thing reshaped from the gateway's wire vocabulary into a small, flat,
+ * render-friendly form. The original sanitizers did this as a scatter of
+ * `normalize*` helpers; this module folds them into a single disciplined visitor.
+ *
+ * The visitor is *table-driven*. {@link TranscriptModel} holds one
+ * {@link BlockVisitor} per block kind; walking a turn is a `switch`-free dispatch
+ * through that table, so adding a new block kind is adding one table entry, never
+ * editing a ladder. Each visitor is a pure function `(block, ctx) => RenderBlock |
+ * null`; returning `null` drops the block (e.g. an empty text fragment that
+ * collapsed to nothing). The sanitizers themselves are likewise pure string
+ * transforms composed in a fixed order, so the projection is deterministic and
+ * trivially testable.
+ *
+ * `accept(turns)` is the one public entry point: it walks every turn, runs each
+ * block through its visitor, and returns a {@link RenderTranscript}. Nothing here
+ * touches a terminal — rendering lives behind the {@link ForgeView} text seam.
+ */
+import type { Block, CommandBlock, ImageBlock, TextBlock, ThinkingBlock, ToolCallBlock, ToolResultBlock, Turn } from "../../llmgateway/contract";
+/** The kind of every block in a projected transcript (mirrors {@link Block}). */
+export type RenderBlockKind = "text" | "thinking" | "tool_call" | "tool_result" | "image" | "command";
+/** A speaker label, derived from a {@link Turn}'s role. */
+export type RenderRole = "user" | "assistant" | "tool";
+/**
+ * One sanitized, flattened content fragment ready to render.
+ *
+ * Every block kind collapses to this single shape: a `kind` tag, a one-line
+ * `label` naming the fragment for a viewer, and the cleaned `text` to show. The
+ * optional `redacted` flag marks fragments whose body was replaced by a
+ * placeholder (a long blob, binary media, a secret), so a renderer can style
+ * them differently.
+ */
+export interface RenderBlock {
+    /** Which block kind this projection came from. */
+    readonly kind: RenderBlockKind;
+    /** A short, human-readable label (e.g. `tool · read_file`). */
+    readonly label: string;
+    /** The sanitized, render-ready body text. */
+    readonly text: string;
+    /** True when {@link text} is a placeholder standing in for omitted content. */
+    readonly redacted?: boolean;
+}
+/** A single projected turn: a speaker plus its surviving render blocks. */
+export interface RenderTurn {
+    /** The speaker, projected from the source turn's role. */
+    readonly role: RenderRole;
+    /** The sanitized blocks, in source order, with dropped blocks removed. */
+    readonly blocks: readonly RenderBlock[];
+}
+/** The full result of {@link TranscriptModel.accept}: a render-ready transcript. */
+export interface RenderTranscript {
+    /** Every projected turn, in source order. */
+    readonly turns: readonly RenderTurn[];
+    /** Count of fragments whose body was redacted across the whole transcript. */
+    readonly redactionCount: number;
+}
+/**
+ * Tunable thresholds for the sanitizing passes.
+ *
+ * Defaults are deliberately conservative: collapse whitespace always, redact any
+ * single fragment longer than {@link maxLength} characters, and replace anything
+ * that matches a secret pattern. A caller can widen or tighten these per session.
+ */
+export interface SanitizeOptions {
+    /** Bodies longer than this (in characters) are redacted to a placeholder. */
+    readonly maxLength: number;
+    /** Extra regexes whose matches are masked, on top of the built-in set. */
+    readonly secretPatterns: readonly RegExp[];
+}
+/** The default sanitizing thresholds used when a caller passes none. */
+export declare const DEFAULT_SANITIZE_OPTIONS: SanitizeOptions;
+/** The per-block context a visitor receives alongside the block it projects. */
+export interface VisitContext {
+    /** The sanitizing thresholds in force for this walk. */
+    readonly options: SanitizeOptions;
+    /** The role of the turn the block belongs to. */
+    readonly role: RenderRole;
+}
+/**
+ * A visitor for one block kind: a pure projection from a typed block to a
+ * {@link RenderBlock}, or `null` to drop the block from the output.
+ */
+export type BlockVisitor<B extends Block> = (block: B, ctx: VisitContext) => RenderBlock | null;
+/** The complete dispatch table: one visitor keyed by each {@link Block} kind. */
+export interface VisitorTable {
+    readonly text: BlockVisitor<TextBlock>;
+    readonly thinking: BlockVisitor<ThinkingBlock>;
+    readonly tool_call: BlockVisitor<ToolCallBlock>;
+    readonly tool_result: BlockVisitor<ToolResultBlock>;
+    readonly image: BlockVisitor<ImageBlock>;
+    readonly command: BlockVisitor<CommandBlock>;
+}
+/**
+ * The default visitor table — the projection rules the original `normalize*`
+ * helpers encoded, gathered into one place.
+ *
+ * Each entry sanitizes the block's salient text, attaches a descriptive label,
+ * and returns a {@link RenderBlock}. Text fragments that collapse to nothing are
+ * dropped (`null`); images never carry their bytes into the projection (the
+ * base64 payload is always redacted to a one-line descriptor).
+ */
+export declare const DEFAULT_VISITORS: VisitorTable;
+/**
+ * A visitor over a build-conversation transcript.
+ *
+ * Construct one with optional sanitize {@link SanitizeOptions} and an optional
+ * override {@link VisitorTable}, then call {@link accept} with a turn list to get
+ * back a sanitized, render-ready {@link RenderTranscript}. The model is stateless
+ * between calls — every `accept` is independent — so a single instance can be
+ * reused across as many transcripts as a session produces.
+ */
+export declare class TranscriptModel {
+    private readonly options;
+    private readonly visitors;
+    constructor(options?: Partial<SanitizeOptions>, visitors?: Partial<VisitorTable>);
+    /**
+     * Walk `turns`, sanitize and project every block, and return the result.
+     *
+     * Turns are visited in order; within each turn, blocks are dispatched through
+     * the visitor table by kind. A visitor returning `null` drops its block. A turn
+     * is kept even when all its blocks drop (an empty {@link RenderTurn}) so the
+     * speaker sequence is preserved for the renderer.
+     */
+    accept(turns: readonly Turn[]): RenderTranscript;
+    /**
+     * Dispatch one block to its visitor.
+     *
+     * The `block.kind` tag narrows the union, and the matching table entry — typed
+     * to that exact variant — does the projection. There is no `switch`: the table
+     * *is* the dispatch.
+     */
+    private visit;
+}
+/**
+ * The minimal text seam Smithy renders through.
+ *
+ * Deliberately tiny — two methods — and free of any terminal toolkit, so the
+ * builder loop can `show` lines of a projected transcript and `ask` the user for
+ * their next instruction without ever importing Ink or coupling to a UI. A richer
+ * view (a TUI, a web pane) is slotted in later by implementing this interface.
+ */
+export interface ForgeView {
+    /** Present one already-formatted line to the user. */
+    show(line: string): void;
+    /** Prompt the user with `question` and resolve their typed answer. */
+    ask(question: string): Promise<string>;
+}
+/**
+ * The default {@link ForgeView}: stdout for output, a readline prompt for input.
+ *
+ * It writes each shown line straight to the output stream (a trailing newline is
+ * added) and reads a single line of input per `ask` via Node's `readline`. The
+ * readline interface is created lazily on the first `ask` and closed by
+ * {@link close}, so a view that only ever `show`s never opens an input handle.
+ */
+export declare class ConsoleForgeView implements ForgeView {
+    private readonly output;
+    private readonly input;
+    private rl;
+    constructor(output?: NodeJS.WritableStream, input?: NodeJS.ReadableStream);
+    show(line: string): void;
+    ask(question: string): Promise<string>;
+    /** Close the underlying readline interface, if one was ever opened. */
+    close(): void;
+    /** Open the readline interface on first use; reuse it thereafter. */
+    private ensureReadline;
+}
+/**
+ * Format a {@link RenderTranscript} as flat lines for a {@link ForgeView}.
+ *
+ * A small convenience so a caller can pipe a projected transcript straight to
+ * `view.show`. Each block becomes a labelled line (or block of lines for
+ * multi-line bodies); turns are separated by a blank line. This lives next to the
+ * model because it is the natural pairing of "project, then show".
+ */
+export declare function formatTranscript(transcript: RenderTranscript): string[];