indusagi-coding-agent 0.1.59 → 0.1.61

package/dist/types/conductor/signal-hub/translate.d.ts

@@ -0,0 +1,74 @@
+/**
+ * translateAgentEvent — the framework-event → {@link SessionSignal} projector.
+ *
+ * The framework `Agent` emits a fine-grained {@link AgentEvent} stream for its
+ * own loop (lifecycle, per-turn, per-message, per-tool). The conductor does not
+ * leak that union to consumers; it projects each framework event down to zero or
+ * more *product-level* {@link SessionSignal}s, which then flow through the
+ * {@link SignalHub}. This module is that projection — and nothing else: it is a
+ * pure, side-effect-free function over a single event.
+ *
+ * Why a table, not a `switch`:
+ *   - The mapping is keyed on the framework event's `type` discriminant, so it is
+ *     expressed as a {@link TranslatorTable} — one entry per `AgentEventType`.
+ *     The table type is `{ [K in AgentEventType]: (ev) => SessionSignal[] }`, so
+ *     adding a framework event variant is a compile error until a rule exists for
+ *     it. Exhaustiveness is enforced by the type system, not by a `default` arm.
+ *   - Each rule receives the precisely-narrowed event member (via
+ *     {@link ExtractAgentEvent}) and returns the signals it produces.
+ *
+ * Mapping rules (framework `type` → product signals):
+ *   - `agent_start` / `turn_start` / `message_start` / `agent_end`
+ *                                → `[]`  (loop bookkeeping; not product-visible)
+ *   - `message_end`              → one `prompt` { text } for a *user* message
+ *                                   (the turn is now committed), one `fault` for
+ *                                   an errored *assistant* message, else `[]`
+ *   - `tool_execution_start`     → one `tool_start`  { id, name }
+ *   - `tool_execution_update`    → `[]`  (partial tool progress is not surfaced)
+ *   - `tool_execution_end`       → one `tool_end`    { id, ok: !isError }
+ *   - `turn_end`                 → one `turn_end`    { usage }
+ *   - `message_update`           → delegated to the inner streaming dispatch on
+ *                                   `assistantMessageEvent.type`:
+ *        · `text_delta`     → one `text`     { delta }
+ *        · `thinking_delta` → one `thinking` { delta }
+ *        · `error`          → one `fault`    { model fault }
+ *        · everything else  → `[]`
+ *
+ * Faults: a streaming `error` sub-event becomes a typed `model` fault. The
+ * conductor layers its own `aborted` / `tool` / `persistence` / `overflow`
+ * faults elsewhere; the translator only mints the one fault the framework
+ * stream actually carries.
+ */
+import type { AgentEvent, AgentEventType, ExtractAgentEvent } from "indusagi/agent";
+import { type SessionSignal } from "../contract";
+/** A rule mapping one narrowed framework event member to product signals. */
+type TranslatorRule<TType extends AgentEventType> = (event: ExtractAgentEvent<TType>) => SessionSignal[];
+/**
+ * The dispatch table: exactly one rule per framework {@link AgentEventType}.
+ *
+ * Declaring it as a full mapped type means the compiler rejects the module until
+ * every framework event variant has a rule — the exhaustiveness guarantee.
+ */
+type TranslatorTable = {
+    [K in AgentEventType]: TranslatorRule<K>;
+};
+/**
+ * The frozen mapping from each framework event variant to product signals.
+ *
+ * Exported for testing/inspection; production code calls
+ * {@link translateAgentEvent}, which is the table applied.
+ */
+export declare const TRANSLATOR_TABLE: TranslatorTable;
+/**
+ * Translate a single framework {@link AgentEvent} into the product-level
+ * {@link SessionSignal}s it produces (zero, one, or — for future fan-out — many).
+ *
+ * Pure and total: every framework event variant has a rule (enforced by
+ * {@link TranslatorTable}), so this never throws on a known event and returns
+ * `[]` for events that carry no product meaning.
+ *
+ * @param event a framework agent loop event
+ * @returns the ordered product signals derived from it
+ */
+export declare function translateAgentEvent(event: AgentEvent): SessionSignal[];
+export {};

package/dist/types/conductor/skill-parse/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Skill-parse subsystem — public barrel.
+ *
+ * Re-exports the re-derived skill-invocation block parser: the attribute-scanning
+ * {@link parseSkillInvocation} hand parser and its structured {@link SkillInvocation}
+ * result. Consumers (the conductor's submit path) import from
+ * `src/conductor/skill-parse` rather than reaching into `parse`.
+ */
+export { parseSkillInvocation } from "./parse";
+export type { SkillInvocation } from "./parse";

package/dist/types/conductor/skill-parse/parse.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Skill-invocation block parser — an attribute-scanning hand parser.
+ *
+ * The coding agent lets a turn carry a *skill invocation*: an XML-ish opener tag
+ * that names a capability card to run, optionally locates its on-disk file, and
+ * wraps a trailing user message (the body) the skill should act on. The shape is
+ * the framework Agent-Skills convention:
+ *
+ *   ```
+ *   <skill name="commit-helper" location="/abs/path/SKILL.md">
+ *   please tidy the staged diff and write a message
+ *   </skill>
+ *   ```
+ *
+ * This module re-derives that parse from the *format spec*, deliberately NOT as
+ * one monolithic capture regex. It is a small hand-written scanner: it walks the
+ * input, finds the opener, scans `key=value` attributes one at a time (handling
+ * single- or double-quoted and bare values, with `&amp;`/`&lt;`/`&gt;`/`&quot;`/
+ * `&#39;` entity decoding), then captures the body up to the matching close tag.
+ * Reading attributes incrementally — rather than matching the whole block in a
+ * single pattern — is what makes this an independent implementation and lets the
+ * parser keep *every* attribute the author wrote, not just a fixed `name`/
+ * `location` pair.
+ *
+ * Block grammar (informal):
+ *   block   := WS? '<' TAG WS attrs? WS? '>' body '</' TAG WS? '>'
+ *   TAG     := 'skill'            (case-insensitive)
+ *   attrs   := (attr WS?)*
+ *   attr    := key ('=' value)?
+ *   key     := [A-Za-z_][A-Za-z0-9_:.-]*
+ *   value   := '"' ... '"' | '\'' ... '\'' | bare           (bare stops at WS / '>')
+ *   body    := any text, captured verbatim up to the close tag
+ *
+ * A valid block must (a) be the leading content of the text (only leading
+ * whitespace may precede the opener), (b) name the `skill` tag, (c) carry a
+ * non-empty `name` attribute, and (d) be closed by `</skill>`. Anything else
+ * yields `null`, signalling "this turn is ordinary text, not a skill call".
+ */
+/**
+ * The structured result of a successful parse.
+ *
+ *   - `name` — the value of the required `name` attribute (the skill to run).
+ *   - `args` — every attribute the opener carried, keyed by (lower-cased) name,
+ *     including `name` itself and any `location`/custom keys. A bare attribute
+ *     with no `=value` maps to the empty string.
+ *   - `body` — the verbatim text between the opener and the `</skill>` close,
+ *     with a single leading and trailing newline trimmed (the common case where
+ *     the opener/closer sit on their own lines) but inner whitespace preserved.
+ */
+export interface SkillInvocation {
+    readonly name: string;
+    readonly args: Record<string, string>;
+    readonly body: string;
+}
+/**
+ * Parse a skill-invocation block out of `text`.
+ *
+ * Walks the string by hand: skips leading whitespace, confirms a `<skill …>`
+ * opener, scans each attribute into an `args` record, captures the body up to the
+ * matching `</skill>`, and decodes entities. Returns the structured invocation,
+ * or `null` when the text is not a well-formed leading skill block (ordinary
+ * turns simply parse to `null`).
+ *
+ * @param text the raw turn text that may begin with a skill block
+ * @returns the parsed `{ name, args, body }`, or `null` if not a skill block
+ */
+export declare function parseSkillInvocation(text: string): SkillInvocation | null;

package/dist/types/conductor/submit.test.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Phase 2 conductor — submit()/resume() BEHAVIORAL tests.
+ *
+ * These exercise the live turn loop of {@link createSessionConductor} end-to-end,
+ * but with zero network and zero disk. Everything heavy is injected:
+ *
+ *   - a scripted fake {@link AgentLike} whose `prompt()` drives a pre-recorded
+ *     sequence of framework {@link AgentEvent}s through the conductor's stored
+ *     subscriber and mutates its own `state.messages` (so `#persistTail` has a
+ *     tail to commit);
+ *   - an in-memory {@link TranscriptStore} (default {@link memoryBackend}, no disk);
+ *   - a fresh {@link SignalHub};
+ *   - a {@link ModelMatcher} over a {@link ModelCatalog} built from a stub
+ *     {@link CatalogSource} so `options.modelId` resolves;
+ *   - `deps.sleep` stubbed to a no-op so retry backoff never actually waits.
+ *
+ * The four behaviors covered (per the Phase 2 plan):
+ *   1. multi-turn tool loop  — ordered text/tool_start/tool_end/turn_end signals,
+ *      settled `idle` state with accumulated usage, persisted transcript nodes.
+ *   2. fault + retry         — transient streaming error auto-retries then settles;
+ *      a hard model fault lands `faulted` with a typed {@link ConductorFault} and a
+ *      `{ kind: "fault" }` signal.
+ *   3. branch / resume       — a second conductor over the same store resumes the
+ *      session and reconstructs the persisted branch (head/leaf).
+ *   4. compaction            — autoCompact + a tiny compactAt + a scripted condense
+ *      fn fire a `{ kind: "compacted" }` signal and invoke condense.
+ */
+export {};

package/dist/types/conductor/transcript-store/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * transcript-store — the conductor's persistent, branchable transcript.
+ *
+ * Two cooperating pieces:
+ *   - {@link TranscriptStore} — the append-only node tree bound to one session:
+ *     `append`, `branchAt`, `pathTo`, `load`, with a pluggable storage backend.
+ *   - the serialization bridge (re-exported below) — encode/decode the
+ *     `indus/transcript@1` NDJSON line shape and project a branch down to the
+ *     framework `AgentMessage[]` / LLM `Message[]`.
+ *
+ * Consumers (the conductor's submit/resume path) import the store and the
+ * serialization helpers from `src/conductor/transcript-store` rather than reaching
+ * into the individual modules.
+ */
+export { TranscriptStore, memoryBackend, fsBackend, replay, type TranscriptBackend, type TranscriptState, type TranscriptClock, type TranscriptStoreOptions, } from "./store";
+export { roleForMessage, encodeEntry, encodeHead, parseSessionText, branchToMessages, branchToLlmMessages, importLegacyFile, importLegacyText, resolveLegacyMessages, type ParsedSessionFile, } from "./serialize";

package/dist/types/conductor/transcript-store/serialize.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Transcript serialization — the bridge between the conductor's on-disk
+ * {@link TranscriptEntry} vocabulary and the framework's {@link AgentMessage}
+ * shapes.
+ *
+ * Two distinct directions live here, and the split is deliberate:
+ *
+ *   1. **Conductor ⇄ conductor** — encoding a {@link TranscriptEntry} to/from a
+ *      single NDJSON line in the `indus/transcript@1` format. This is the
+ *      conductor's *own* envelope (`schema`/`id`/`prev`/`role`/`message`/`at`/
+ *      `meta`). The store owns these field names; they are our own, not any
+ *      framework-internal session schema.
+ *
+ *   2. **Conductor ⇄ framework** — projecting a transcript branch down to the
+ *      `AgentMessage[]` the agent loop consumes, and (for migration) lifting a
+ *      legacy framework session file *up* into transcript entries. Here we
+ *      **delegate the actual message serialization to the framework**: the
+ *      framework's published loader/context helpers know how to parse and resolve
+ *      the legacy on-disk schema, and we keep those internal schema literals
+ *      inside the framework package rather than re-declaring them in the app.
+ *
+ * The role discriminant on a {@link TranscriptEntry} is the conductor's own —
+ * `role` here labels the *node*, not the LLM message. We derive it from the
+ * carried {@link AgentMessage}'s `role` field so a round-trip is faithful, but
+ * the transcript can also hold conductor-only nodes (`condense`, `note`) that the
+ * framework message union has no direct counterpart for.
+ */
+import type { AgentMessage } from "indusagi/agent";
+import type { Message } from "indusagi/ai";
+import type { SessionHead, TranscriptEntry, TranscriptRole } from "../contract";
+/**
+ * Derive the conductor's node {@link TranscriptRole} from a framework
+ * {@link AgentMessage}.
+ *
+ * The framework message union uses `role` values (`user`/`assistant`/`toolResult`
+ * plus the custom app messages). We fold those onto the transcript's own role
+ * vocabulary. Anything we don't recognize (custom/notification-style messages)
+ * is filed as a `note` node so it persists without claiming an LLM turn role.
+ */
+export declare function roleForMessage(message: AgentMessage): TranscriptRole;
+/** Encode one {@link TranscriptEntry} to its NDJSON entry line (no newline). */
+export declare function encodeEntry(entry: TranscriptEntry): string;
+/** Encode the {@link SessionHead} to its NDJSON head line (no newline). */
+export declare function encodeHead(head: SessionHead): string;
+/** The result of parsing a whole session file: its head plus its entries. */
+export interface ParsedSessionFile {
+    readonly head: SessionHead | null;
+    readonly entries: TranscriptEntry[];
+}
+/**
+ * Parse the raw text of a conductor session file into a head + entries.
+ *
+ * Tolerant by design: blank lines are skipped, malformed lines are dropped, and
+ * lines whose `schema` does not match `indus/transcript@1` are ignored. The last
+ * head line wins (a file should carry exactly one, written first and rewritten on
+ * branch). Entries keep file order.
+ */
+export declare function parseSessionText(sessionId: string, text: string): ParsedSessionFile;
+/**
+ * Project a resolved transcript branch down to the framework `AgentMessage[]`
+ * the agent loop consumes.
+ *
+ * The branch is the root→leaf node list (the store's reducer produces it). We
+ * pull the carried `content` payloads and hand them straight to the agent; they
+ * are already framework messages. Conductor-only nodes whose payload is not a
+ * real message would be filtered by the framework's own `convertToLlm` at call
+ * time, so we keep them here and let the loop's converter decide.
+ */
+export declare function branchToMessages(branch: readonly TranscriptEntry[]): AgentMessage[];
+/**
+ * Convert a transcript branch to *LLM-ready* `Message[]`, delegating entirely to
+ * the framework's {@link convertToLlm}.
+ *
+ * This is the one place that must understand how each `AgentMessage` variant
+ * (including the framework's custom `bashExecution`/`branchSummary`/… messages)
+ * collapses into a plain LLM message — and that knowledge stays in the framework.
+ * The conductor never re-implements it.
+ */
+export declare function branchToLlmMessages(branch: readonly TranscriptEntry[]): Message[];
+/**
+ * Lift a *legacy framework session file* into conductor {@link TranscriptEntry}
+ * nodes, for one-way migration/import.
+ *
+ * The legacy file is the framework's own internal JSONL format. We do **not**
+ * parse its schema ourselves — we call the framework's published loader (or its
+ * in-memory text parser), then map only the message-bearing entries onto our
+ * envelope. Every framework-internal schema literal stays behind that call.
+ *
+ * Non-message bookkeeping entries (model/thinking changes, labels, raw
+ * compaction markers) are dropped from the imported transcript: their effect is
+ * already folded into the resolved messages we keep, and the conductor tracks
+ * model/thinking in its own state rather than as transcript nodes.
+ */
+export declare function importLegacyFile(filePath: string): TranscriptEntry[];
+/** As {@link importLegacyFile}, but from already-loaded text (testing/import). */
+export declare function importLegacyText(text: string): TranscriptEntry[];
+/**
+ * Resolve a legacy framework file straight to the `AgentMessage[]` of its active
+ * branch, delegating to the framework's {@link buildSessionContext}.
+ *
+ * Useful when the goal is to *seed* a fresh conductor session from a legacy one
+ * without reproducing its tree: the framework walks its own parent links and
+ * applies its own compaction/branch-summary resolution, and we receive a flat
+ * message list to re-append as new transcript nodes.
+ */
+export declare function resolveLegacyMessages(filePath: string): AgentMessage[];

package/dist/types/conductor/transcript-store/store.d.ts

@@ -0,0 +1,170 @@
+/**
+ * TranscriptStore — the conductor's persistent, branchable transcript.
+ *
+ * Replaces pi's `SessionManager`, but with the conductor's own vocabulary and a
+ * deliberately different internal model. The transcript is an append-only **tree**
+ * of {@link TranscriptEntry} nodes: every node names its `parent`, a single
+ * {@link SessionHead} tracks the active `leaf`, and the active conversation is the
+ * `parent`-chain walked from that leaf back to a root.
+ *
+ * Design stance (an independent persistence model):
+ *   - **Reducer-friendly.** The on-disk form is a flat NDJSON log; the in-memory
+ *     view is rebuilt by a pure {@link replay} reducer over that log. State is a
+ *     value derived from the log, never mutated in place behind the scenes.
+ *   - **Fresh envelope.** Lines carry the `indus/transcript@1` schema with our own
+ *     field names (`prev`, `at`, `kind`), delegated to {@link module:serialize} —
+ *     not any framework-internal session-manager schema.
+ *   - **Branch = move the head.** {@link branchAt} repoints the leaf at an earlier
+ *     node; the next {@link append} becomes that node's child, forking a new path
+ *     without rewriting history.
+ *   - **`pathTo` is the read primitive.** {@link pathTo} resolves the root→leaf
+ *     branch (the message list the agent replays); the conductor's `resume` calls
+ *     it to rehydrate.
+ *
+ * The store is storage-pluggable: a {@link TranscriptBackend} abstracts where bytes
+ * live, so tests inject an in-memory backend and the conductor binds a filesystem
+ * one. Construction is synchronous and empty; {@link load} hydrates from a backend.
+ */
+import type { AgentMessage, SessionHead, TranscriptEntry, TranscriptRole } from "../contract";
+import { TRANSCRIPT_SCHEMA } from "../contract";
+/**
+ * Where a transcript's NDJSON log lives. The store appends lines and, on branch,
+ * rewrites the whole file; a backend supplies those three primitives plus a way
+ * to resolve a session id to its location. All methods may be async.
+ *
+ * The default {@link fsBackend} maps a session id to `<dir>/<sessionId>.ndjson`;
+ * tests pass an in-memory backend so no disk is touched.
+ */
+export interface TranscriptBackend {
+    /** Absolute location (path/key) a session id persists to. */
+    locate(sessionId: string): string;
+    /** Read the full NDJSON text for a session, or `null` if absent. */
+    read(sessionId: string): Promise<string | null>;
+    /** Append one already-encoded NDJSON line (no trailing newline) to a session. */
+    append(sessionId: string, line: string): Promise<void>;
+    /** Replace the whole NDJSON text for a session (used after a branch). */
+    rewrite(sessionId: string, text: string): Promise<void>;
+}
+/** An in-memory backend — the default when no persistence is wired. */
+export declare function memoryBackend(): TranscriptBackend;
+/**
+ * A filesystem backend rooted at `dir`. Lazily imports `node:fs`/`node:path` so
+ * the module stays usable in non-Node test contexts that pass {@link memoryBackend}.
+ */
+export declare function fsBackend(dir: string): TranscriptBackend;
+/**
+ * The immutable derived state of a transcript: the node table keyed by id, plus
+ * the current head. A pure value produced by {@link replay}; the store holds one
+ * and swaps it wholesale on each mutation rather than mutating fields.
+ */
+export interface TranscriptState {
+    /** Every node, keyed by id, in insertion order. */
+    readonly nodes: ReadonlyMap<string, TranscriptEntry>;
+    /** The active head (session id + current leaf). */
+    readonly head: SessionHead;
+}
+/** A clock + id seam so tests get deterministic ids/timestamps. */
+export interface TranscriptClock {
+    /** Mint a fresh, sortable node id. */
+    readonly id: () => string;
+    /** The current instant as an ISO-8601 string. */
+    readonly now: () => string;
+}
+/**
+ * Rebuild a {@link TranscriptState} from an ordered entry list and a leaf.
+ *
+ * Pure and total: the same inputs always yield the same state. The reducer just
+ * indexes the entries by id (later ids overwrite earlier — append-only logs never
+ * collide, but a rewrite stays idempotent) and pins the head. Replacing pi's
+ * mutate-in-place index with an explicit reducer is the divergence.
+ */
+export declare function replay(sessionId: string, entries: readonly TranscriptEntry[], leaf: string | null): TranscriptState;
+/** Tuning seams for a {@link TranscriptStore}. All optional. */
+export interface TranscriptStoreOptions {
+    /** Where bytes live; defaults to {@link memoryBackend}. */
+    readonly backend?: TranscriptBackend;
+    /** Id/timestamp source; defaults to ULID + wall clock. */
+    readonly clock?: TranscriptClock;
+}
+/**
+ * An append-only, branchable transcript bound to one session id.
+ *
+ * Construct (empty), then either {@link append} fresh nodes or {@link load} a
+ * persisted session. Every mutation appends to the backend and swaps the derived
+ * {@link TranscriptState}. Reads (`pathTo`, `messages`, `head`) are O(branch
+ * depth) walks over the in-memory node table.
+ */
+export declare class TranscriptStore {
+    #private;
+    constructor(sessionId: string, options?: TranscriptStoreOptions);
+    /** The session id this store is bound to. */
+    get sessionId(): string;
+    /** The current head (session id + active leaf). */
+    get head(): SessionHead;
+    /** Number of nodes currently in the transcript. */
+    get size(): number;
+    /** Backend location this session persists to (for diagnostics/UI). */
+    locate(sessionId?: string): string;
+    /** Look up a single node by id. */
+    get(id: string): TranscriptEntry | undefined;
+    /**
+     * Append a framework {@link AgentMessage} as a child of the current leaf and
+     * advance the head onto it. The node role is derived from the message (or
+     * overridden via `role`). Persists the new line, then returns the new node.
+     *
+     * This is the conductor's per-message write: one call per produced message in
+     * a settled turn.
+     */
+    append(content: AgentMessage, role?: TranscriptRole, meta?: Readonly<Record<string, unknown>>): Promise<TranscriptEntry>;
+    /**
+     * Repoint the head at an earlier node, forking a branch. The next {@link append}
+     * becomes a child of `id`; existing nodes are untouched. Rewrites the head line.
+     *
+     * @throws if `id` is not a known node.
+     */
+    branchAt(id: string): Promise<void>;
+    /**
+     * Reset the head to before any node; the next {@link append} starts a new root.
+     * Used when re-editing the very first turn.
+     */
+    reset(): Promise<void>;
+    /**
+     * Abandon the current conversation and begin a fresh, empty session under a new
+     * id. All nodes are dropped and the leaf is reset to null, so {@link messages}
+     * is empty and the next {@link append} starts a new root; subsequent writes
+     * persist to the new session's backing file (the old one is left intact on
+     * disk). This is the `/clear` (new-session) primitive — distinct from
+     * {@link reset}, which keeps the nodes and id and only rewinds the head.
+     */
+    startNewSession(sessionId: string): void;
+    /**
+     * Resolve the active branch: the root→leaf node list reached by walking
+     * `parent` links up from `leaf` (or from `from` when given), reversed to
+     * chronological order.
+     *
+     * This is the conductor's read primitive — `resume` rehydrates the agent from
+     * `pathTo()`, and the turn loop projects it to messages via {@link messages}.
+     * Returns `[]` for an empty transcript or a dangling leaf.
+     */
+    pathTo(from?: string): TranscriptEntry[];
+    /** The active branch projected to the framework {@link AgentMessage} list. */
+    messages(from?: string): AgentMessage[];
+    /**
+     * Hydrate this store from a persisted session, replacing its current state.
+     *
+     * Reads the backend, parses it with {@link parseSessionText}, and rebuilds state
+     * via the {@link replay} reducer. If the file carried no head line, the head is
+     * pinned to the deepest leaf reachable from the entries. Returns `true` when a
+     * session was found and loaded, `false` when the backend had nothing.
+     */
+    load(sessionId?: string): Promise<boolean>;
+    /**
+     * Open a persisted session by id, returning a hydrated store (or `null` if the
+     * backend has no such session). The static counterpart to {@link load}.
+     */
+    static open(sessionId: string, options?: TranscriptStoreOptions): Promise<TranscriptStore | null>;
+    /** A point-in-time copy of the derived state (for inspection/testing). */
+    state(): TranscriptState;
+}
+/** Re-export the schema literal for callers building stores directly. */
+export { TRANSCRIPT_SCHEMA };

package/dist/types/console/components/Banner.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Banner — the masthead the console renders above the transcript.
+ *
+ * The startup chrome the surface mounts once at the top of a session: an
+ * original block-letter wordmark rendered in the box-drawing palette and tinted
+ * with the accent/signal role, a version + brand line beneath it, and a compact
+ * bordered "Session" panel of at-a-glance facts (the bound model id and the
+ * working directory). It reads nothing but its props, holds no state, and runs
+ * no effects — purely presentational Ink primitives themed through the framework
+ * {@link InkThemeAdapter}.
+ *
+ * The wordmark is the "INDUS CODE" brand masthead rendered in the ANSI-Shadow
+ * block-figlet style from the `█ ║ ═ ╔ ╗ ╚ ╝` box-drawing family — the same
+ * masthead the shipped console shows, so both surfaces share one identity. The
+ * glyph rows are plain data tinted with the accent role at render time.
+ */
+import { type InkThemeAdapter } from "indusagi/react-ink";
+import type { StartupChangelog, StartupMap, StartupNotice } from "../startup";
+/** What the {@link Banner} renders. */
+export interface BannerProps {
+    /** The framework adapter that turns token roles into terminal colours. */
+    readonly theme: InkThemeAdapter;
+    /** Canonical id of the model bound to the session. */
+    readonly modelId: string;
+    /** Working directory the session is scoped to. */
+    readonly workspace: string;
+    /** The product version shown on the brand line (e.g. the package VERSION). */
+    readonly version: string;
+    /** Whether to render the extra diagnostics line. */
+    readonly verbose?: boolean;
+    /**
+     * When set, the big wordmark + Startup Map are suppressed in favour of a
+     * single compact header line. Wired from the verbose / quiet-startup flag.
+     */
+    readonly quiet?: boolean;
+    /** The gathered session resources rendered as the Startup Map panel. */
+    readonly startup?: StartupMap;
+    /** Out-of-band lines drawn above the wordmark (errors, warnings, info). */
+    readonly notices?: readonly StartupNotice[];
+    /** The changelog survey rendered as a "What is new" block on a version bump. */
+    readonly changelog?: StartupChangelog;
+}
+/**
+ * Render the console masthead.
+ *
+ * In the default (loud) mode this is the block-letter wordmark, the brand /
+ * version line, the optional notices region, the bordered Startup Map, and the
+ * changelog block. The {@link BannerProps.quiet} flag collapses all of that to a
+ * single compact header line (brand + version + model), still carrying the
+ * notices and a condensed changelog so nothing important is silently dropped.
+ *
+ * @param props the wordmark context, version, session facts, and startup chrome
+ */
+export declare function Banner({ theme, modelId, workspace, version, verbose, quiet, startup, notices, changelog, }: BannerProps): JSX.Element;

package/dist/types/console/components/Composer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Composer — the prompt-input surface (the renamed input row).
+ *
+ * Presentational only: it renders the live buffer with a visible caret, a busy
+ * affordance while a turn is in flight, and — when the parent has computed one —
+ * a completion window of slash/path {@link Suggestion}s with the highlighted
+ * entry marked. All key handling lives in the parent {@link TerminalConsole}'s
+ * `useInput` handler (which composes the pure keymap / paste / completion
+ * modules); the Composer just draws the state it is handed.
+ *
+ * The caret is drawn by splitting the buffer at the caret offset and inverting
+ * the character under it (or a trailing space at end-of-buffer), so the surface
+ * needs no terminal cursor control.
+ */
+import type { InkThemeAdapter } from "indusagi/react-ink";
+import type { Suggestion } from "../input";
+/** What the {@link Composer} renders. */
+export interface ComposerProps {
+    /** The framework adapter that turns token roles into terminal colours. */
+    readonly theme: InkThemeAdapter;
+    /** The live composer buffer. */
+    readonly buffer: string;
+    /** Caret offset within {@link buffer}, in characters. */
+    readonly caret: number;
+    /** Whether a turn is in flight (input is visually disabled). */
+    readonly busy: boolean;
+    /** The completion candidates to show, or empty for no window. */
+    readonly suggestions: readonly Suggestion[];
+    /** Index of the highlighted suggestion within {@link suggestions}. */
+    readonly highlight: number;
+}
+/**
+ * Render the prompt-input row plus any completion window.
+ *
+ * @param props the buffer/caret/suggestion state to display
+ */
+export declare function Composer({ theme, buffer, caret, busy, suggestions, highlight, }: ComposerProps): JSX.Element;

package/dist/types/console/components/StatusBar.d.ts

@@ -0,0 +1,31 @@
+/**
+ * StatusBar — the bottom chrome strip of the console.
+ *
+ * Composes the framework's `StatusLine` (the transient toast row) above its
+ * `Footer` (the persistent session/usage strip), both fed from a projected
+ * {@link SessionSnapshot}. The console owns no rendering of its own here — it
+ * threads the resolved theme adapter and the current snapshot/status into the
+ * framework components, which do the layout. Purely presentational.
+ *
+ * (Renamed surface: the console's status strip.)
+ */
+import { type InkThemeAdapter, type SessionSnapshot, type StatusMessage } from "indusagi/react-ink";
+/** What the {@link StatusBar} renders. */
+export interface StatusBarProps {
+    /** The framework adapter that turns token roles into terminal colours. */
+    readonly theme: InkThemeAdapter;
+    /** The projected session snapshot the framework strips read. */
+    readonly snapshot: SessionSnapshot;
+    /** The active VCS branch, or `null` when not in a repo. */
+    readonly branch: string | null;
+    /** How many auth providers are available (shown in the footer). */
+    readonly providerCount: number;
+    /** The transient status toast, when one is showing. */
+    readonly status?: StatusMessage;
+}
+/**
+ * Render the toast row above the footer strip.
+ *
+ * @param props the snapshot + status to display
+ */
+export declare function StatusBar({ theme, snapshot, branch, providerCount, status, }: StatusBarProps): JSX.Element;

package/dist/types/console/components/TerminalConsole.d.ts

@@ -0,0 +1,32 @@
+/**
+ * TerminalConsole — the top-level Ink application for the interactive console.
+ *
+ * This is the surface the host process renders to drive a session from a live
+ * terminal. It owns one {@link consoleReducer} store, subscribes to the
+ * conductor's {@link SessionSignal} stream and projects each signal into reducer
+ * events (so the transcript view grows as the agent streams), renders the
+ * framework `MessageList` / `Footer` / `StatusLine` plus the console's own
+ * {@link Composer} / {@link StatusBar} / {@link Banner}, and translates raw key
+ * events — through the pure keymap / paste / completion modules — into reducer
+ * dispatches and conductor calls.
+ *
+ * The component is deliberately thin: every *decision* lives in a pure module
+ * (the reducer, the keymap, the slash resolver, the completion source, the paste
+ * coalescer). The surface holds only the live values those pure functions need
+ * carried between keystrokes — the chord latch, the paste vault, the highlighted
+ * suggestion index — and the timers, and it wires events in and renders state
+ * out. Nothing here parses keys or mutates state inline.
+ *
+ * Hooks note: `useReducer` / `useRef` / `useCallback` are obtained from the
+ * default React export of `indusagi/react-host` (only `useState`/`useEffect`/
+ * `useMemo` are named exports there). `Box` / `Text` / `useInput` come from
+ * `indusagi/react-host/ink`; the message/footer/dialog components from
+ * `indusagi/react-ink`.
+ */
+import type { ConsoleProps } from "../contract";
+/**
+ * The interactive console surface.
+ *
+ * @param props the conductor to drive, the resolved theme, and the slash registry
+ */
+export declare function TerminalConsole(props: ConsoleProps): JSX.Element;

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

@@ -0,0 +1,19 @@
+/**
+ * Console subsystem — unit tests over the PURE modules.
+ *
+ * The interactive surface itself (the Ink mount) is verified by eye; these tests
+ * pin the *decisions* that live in the pure, dependency-free modules the surface
+ * composes:
+ *
+ *   1. the reducer transitions (transcript append, busy toggle, theme switch);
+ *   2. the theme having both schemes and an OWN, re-derived accent palette
+ *      (no forbidden upstream hex appears);
+ *   3. slash resolution matching `/model` and `/composio` and parsing args;
+ *   4. the keymap mapping Enter / Ctrl-C to the right console intent;
+ *   5. paste coalescing batching a large clipboard burst behind a marker;
+ *   6. completion suggesting slash names and file paths.
+ *
+ * Everything under test is a plain function over plain data — no Ink, no timers,
+ * no conductor runtime — so the suite needs no React host.
+ */
+export {};