indusagi-coding-agent 0.2.4 → 0.2.5

package/dist/types/console/overlays/approval-queue.d.ts

@@ -1,88 +0,0 @@
-/**
- * Approval queue — the headless, pure serializer behind the approval overlay.
- *
- * The permission gate may reach an `ask` decision while another approval prompt is
- * already on screen (e.g. a turn that batches several tool calls). The UI shows ONE
- * prompt at a time, so the pending requests are held in an ordered queue: each
- * `enqueue` parks a request, the HEAD is the prompt currently shown, and `settle`
- * resolves the head's parked promise then advances to the next. This module is a
- * pure reducer over an immutable {@link ApprovalQueueState} plus a couple of tiny
- * helpers — no React, no Ink, no timers — so the queue logic is unit-testable in
- * isolation (the overlay component only renders the head and dispatches settles).
- *
- * Each queued entry carries the parked promise's `resolve` (the gate awaits it) and
- * the request itself. Settling resolves with an {@link ApprovalChoice}; an
- * abort/clear settles every outstanding entry with `"deny"` so a cancelled turn
- * never hangs on a pending prompt.
- */
-import type { ApprovalChoice, PermissionMode } from "../../conductor";
-import type { ApprovalRequest } from "./approval";
-/** One parked approval request awaiting the user's choice. */
-export interface ApprovalEntry {
-    /** A stable id, unique within the queue's lifetime, used to settle the right one. */
-    readonly id: string;
-    /** The pending request the prompt renders. */
-    readonly request: ApprovalRequest;
-    /** Fulfil the gate's parked promise with the user's choice. Called exactly once. */
-    readonly resolve: (choice: ApprovalChoice) => void;
-}
-/**
- * The immutable queue state. The array is ordered oldest-first; the head (index 0)
- * is the request currently prompted. An empty queue means no prompt is showing.
- */
-export interface ApprovalQueueState {
-    /** The parked entries, oldest first; `[0]` is the active prompt. */
-    readonly entries: readonly ApprovalEntry[];
-}
-/** The empty queue — no approval prompt pending. */
-export declare const EMPTY_APPROVAL_QUEUE: ApprovalQueueState;
-/**
- * The closed action union the queue reducer folds:
- *   - `enqueue` — park a new request at the tail.
- *   - `settle`  — resolve the entry matching `id` with `choice` and drop it.
- *   - `clear`   — drop EVERY entry (the caller resolves each with `"deny"`).
- */
-export type ApprovalQueueEvent = {
-    readonly type: "enqueue";
-    readonly entry: ApprovalEntry;
-} | {
-    readonly type: "settle";
-    readonly id: string;
-} | {
-    readonly type: "clear";
-};
-/**
- * Fold one {@link ApprovalQueueEvent} over the queue, returning a fresh state.
- *
- * Pure and total: it never resolves a promise itself (the caller does that around
- * a `settle`/`clear`), it only mutates the ordered entry list. `enqueue` appends;
- * `settle` removes the entry with the matching `id` (a no-op when absent, e.g. a
- * double-settle); `clear` empties the queue.
- *
- * @param state the prior queue state
- * @param event the action to apply
- */
-export declare function approvalQueueReducer(state: ApprovalQueueState, event: ApprovalQueueEvent): ApprovalQueueState;
-/**
- * The active prompt — the head entry — or `undefined` when the queue is empty.
- *
- * @param state the queue state
- */
-export declare function activeApproval(state: ApprovalQueueState): ApprovalEntry | undefined;
-/**
- * Whether switching INTO `mode` mid-prompt should release (auto-allow) every
- * PARKED approval request.
- *
- * Only `bypass` qualifies: a parked entry already passed the deny-rule and
- * catastrophic-blocklist scans before it reached `ask`, and under bypass the
- * engine allows everything not denied — so settling the parked prompts with
- * `allow-once` matches exactly what the mode now means, and the run resumes
- * instead of idling behind a prompt the user just declared moot. Every other
- * mode keeps the prompts parked: `default`/`acceptEdits` still want the answer,
- * and `plan` must not auto-ALLOW a mutating call (the user can still deny).
- *
- * Pure; the component wires it to the actual settle.
- *
- * @param mode the permission mode just switched into
- */
-export declare function modeReleasesApprovals(mode: PermissionMode): boolean;

package/dist/types/console/overlays/approval.d.ts

@@ -1,104 +0,0 @@
-/**
- * Approval overlay — the interactive tool-permission prompt.
- *
- * This group owns the single modal kind raised when the permission gate reaches an
- * `ask` decision for a tool call: it shows the pending request (tool name, a short
- * rendering of the arguments, and any suggested allow-rule) and lets the user pick
- * one of three outcomes — allow this one call, allow it for the rest of the session
- * (which the gate turns into a session allow-rule), or deny it. It is mounted
- * unconditionally by {@link import("./host").OverlayHost}, which routes by
- * {@link ModalState.kind}; this component renders a dialog body only for its own
- * `approval` kind and is otherwise inert.
- *
- * The wiring is a parked promise: when the React layer builds the conductor's
- * approval resolver it returns a promise and stashes the request (plus the
- * promise's `resolve`) under {@link ModalState.payload}. This overlay reads that
- * payload, renders the choices, and on a pick calls `payload.resolve(choice)` then
- * closes the modal — handing control back to the gate, which proceeds or denies. An
- * Esc (the dialog's own close) resolves `"deny"` so a dismissed prompt never hangs
- * the in-flight turn. The actual select UI reuses the framework `ThemeDialog`
- * (a labelled, navigable pick-from-list with descriptions), so the overlay needs no
- * bespoke key handling.
- *
- * React/Ink are obtained the same way the other overlays do (default React export
- * from `indusagi/react-host`, `Box`/`Text` from `indusagi/react-host/ink`).
- */
-import { type ThemeDialogItem } from "indusagi/react-ink";
-import type { ApprovalChoice } from "../../conductor";
-import type { OverlayGroupProps } from "./pickers";
-/**
- * The pending tool-permission request a prompt is raised for. Mirrors the
- * arguments the conductor's approval resolver is handed for an `ask` decision.
- */
-export interface ApprovalRequest {
-    /** The tool the model asked to run (e.g. `"Bash"`, `"Edit"`). */
-    readonly toolName: string;
-    /** The validated arguments the tool would run with. */
-    readonly input: unknown;
-    /**
-     * Optional human-readable allow-rule suggestions the prompt surfaces (e.g.
-     * `"Bash(npm run test:*)"`), so the user knows what an "allow always" remembers.
-     */
-    readonly suggestions?: readonly string[];
-}
-/**
- * The opaque {@link ModalState.payload} the `approval` overlay narrows: the pending
- * request plus the resolver of the parked approval promise. The overlay calls
- * `resolve(choice)` exactly once, then closes the modal.
- */
-export interface ApprovalPayload {
-    /** The pending request to render. */
-    readonly request: ApprovalRequest;
-    /** Fulfil the parked approval promise with the user's choice. */
-    readonly resolve: (choice: ApprovalChoice) => void;
-}
-/**
- * The three offerable outcomes, in listing order. The `id` is the
- * {@link ApprovalChoice} the gate consumes; `label`/`description` are what the
- * prompt shows. Kept as data (not an `if`-ladder) so the choice→resolution mapping
- * is a pure table the headless test asserts against.
- */
-export declare const APPROVAL_CHOICES: readonly (ThemeDialogItem & {
-    id: ApprovalChoice;
-})[];
-/** The {@link ApprovalChoice} a dismissed (Esc) prompt resolves to. */
-export declare const DISMISS_CHOICE: ApprovalChoice;
-/**
- * Map a selected dialog `id` back to the {@link ApprovalChoice} the gate consumes.
- *
- * Pure and total: a recognised id maps to itself; anything unrecognised falls back
- * to {@link DISMISS_CHOICE} (`"deny"`) so a stray selection can never silently
- * allow a tool. This is the unit the headless test pins.
- *
- * @param id the `id` the {@link ThemeDialog} reported on select
- */
-export declare function choiceFromId(id: string): ApprovalChoice;
-/**
- * Narrow the opaque modal payload into a typed {@link ApprovalPayload}, or
- * `undefined` when it is not a well-formed approval request (a defensive guard —
- * the overlay renders nothing rather than crash on a malformed payload).
- *
- * @param payload the opaque {@link ModalState.payload}
- */
-export declare function readApprovalPayload(payload: unknown): ApprovalPayload | undefined;
-/**
- * Render a tool call's arguments as a single short, human-readable line for the
- * prompt body. A shell `command` (or any `command` field) shows verbatim;
- * otherwise a compact JSON encoding is used. Long values are elided so the prompt
- * never floods the terminal.
- *
- * @param input the validated tool arguments
- */
-export declare function summarizeInput(input: unknown): string;
-/**
- * The approval overlay group: the single `approval` modal kind.
- *
- * Renders the prompt body when the active modal is `approval` and its payload is a
- * well-formed {@link ApprovalPayload}; every other kind (and a malformed payload)
- * yields nothing. Unlike the session/auth groups this does NOT require the runtime
- * services bundle — the payload carries everything the prompt needs — so it works
- * on any mount path that wired a resolver.
- *
- * @param props the forwarded overlay props (modal, services, theme, dispatch, closer)
- */
-export declare function ApprovalOverlays(props: OverlayGroupProps): JSX.Element | null;

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

@@ -1,17 +0,0 @@
-/**
- * Approval overlay — headless unit tests for the pure logic behind the prompt.
- *
- * Rendering an Ink dialog headlessly is brittle, so these tests pin the two pure
- * pieces the interactive overlay is built from — exactly the bar the task sets:
- *
- *   1. The choice→resolution mapping ({@link choiceFromId}) + the payload narrowing
- *      ({@link readApprovalPayload}) + the argument summary ({@link summarizeInput}):
- *      a selected dialog row maps to the {@link ApprovalChoice} the gate consumes, a
- *      malformed payload is rejected, and a stray id falls back to `deny`.
- *   2. The queue reducer ({@link approvalQueueReducer}) + head selector
- *      ({@link activeApproval}): requests serialise oldest-first, a settle drops the
- *      matching entry (and a double-settle is inert), and a clear empties the queue.
- *
- * No React, no Ink, no conductor — just the exported functions.
- */
-export {};

package/dist/types/console/overlays/auth.d.ts

@@ -1,31 +0,0 @@
-/**
- * Auth overlays — the sign-in / sign-out and plugin dialogs.
- *
- * This group owns the four modal kinds tied to credentials and host-supplied
- * overlays: the provider sign-in launcher (`signIn`), the sign-out confirmation
- * (`signOut`), the in-flight OAuth device/redirect flow (`oauth`), and a
- * plugin-supplied select/confirm/input/custom overlay (`plugin`). It is mounted
- * unconditionally by {@link import("./host").OverlayHost}, which routes by
- * {@link ModalState.kind}; this component renders a dialog body only for one of
- * its own kinds and is otherwise inert.
- *
- * Each kind drives an {@link OverlayServices} handle then returns to the
- * composer: `signIn` enumerates the merged provider directory and hands a
- * browser provider off to the `oauth` kind (api-key providers post a status and
- * close); `signOut` lists the saved accounts across providers and removes the
- * chosen one through the vault; `oauth` runs the framework login flow, threading
- * its url/prompt/progress callbacks into a local overlay state the dialog reads;
- * `plugin` presents the host-supplied surface name and closes. React/Ink are
- * obtained the same way the surface component is (default React export from
- * `indusagi/react-host`, `Box`/`Text` from `indusagi/react-host/ink`).
- */
-import type { OverlayGroupProps } from "./pickers";
-/**
- * The auth overlay group: sign-in, sign-out, OAuth, and plugin overlays.
- *
- * Renders a dialog body only when the active modal kind is one of this group's
- * own; every other kind (and an absent {@link OverlayServices}) yields nothing.
- *
- * @param props the forwarded overlay props
- */
-export declare function AuthOverlays(props: OverlayGroupProps): JSX.Element | null;

package/dist/types/console/overlays/boards.d.ts

@@ -1,55 +0,0 @@
-/**
- * Saffron picker boards — the themed `/settings` and `/model` overlays styled to
- * the "IndusCode Saffron · Settings · Config" design.
- *
- * The framework ships plain (un-themed) `SettingsDialog` / `ModelDialog`. These
- * boards are the console's own theme-aware replacements for those two pickers: a
- * saffron tab-pill header, a teal-bordered search box with a magnifier and a
- * block caret, a two-column list whose values are tinted by kind (on/true →
- * green, off/false → dim, everything else → teal), a windowed "↓ N more" hint,
- * and a top-ruled footer of key hints. They reuse the framework's pure
- * {@link matchesSearchQuery} / {@link wrapSelectionIndex} helpers (and the
- * {@link SettingsDialogItem} shape) so only the *presentation* is re-authored,
- * not the filter/navigation logic.
- *
- * All colour comes through the framework {@link InkThemeAdapter} the overlay
- * group already holds, so the boards recolour with the active scheme; the one
- * raw-hex touch is the chalk tab-pill (dark text on the accent fill), which has
- * no theme role to resolve against.
- */
-import { type InkThemeAdapter, type SettingsDialogItem } from "indusagi/react-ink";
-import type { Model } from "indusagi/ai";
-/** What the {@link SettingsBoard} renders. */
-export interface SettingsBoardProps {
-    /** The framework adapter that turns token roles into terminal colours. */
-    readonly theme: InkThemeAdapter;
-    /** The settings rows to present and cycle. */
-    readonly items: readonly SettingsDialogItem[];
-    /** Invoked when the board is dismissed. */
-    readonly onClose: () => void;
-}
-/**
- * The saffron `/settings` board: a filterable, value-cycling settings list in the
- * design's look. Up/Down move (wrapping), Left/Right or Enter cycle the value,
- * typing filters, Ctrl+U clears, Esc closes.
- */
-export declare function SettingsBoard({ theme, items, onClose }: SettingsBoardProps): JSX.Element;
-/** What the {@link ModelBoard} renders. */
-export interface ModelBoardProps {
-    /** The framework adapter that turns token roles into terminal colours. */
-    readonly theme: InkThemeAdapter;
-    /** The selectable models. */
-    readonly models: readonly Model<any>[];
-    /** Optional initial search query. */
-    readonly search?: string;
-    /** Invoked with the chosen model. */
-    readonly onSelect: (model: Model<any>) => void | Promise<void>;
-    /** Invoked when the board is dismissed. */
-    readonly onClose: () => void;
-}
-/**
- * The saffron `/model` board: a filterable model list in the design's look.
- * Up/Down move (wrapping), Enter selects, typing filters, Ctrl+U clears, Esc
- * closes.
- */
-export declare function ModelBoard({ theme, models, onClose, onSelect, search }: ModelBoardProps): JSX.Element;

package/dist/types/console/overlays/host.d.ts

@@ -1,45 +0,0 @@
-/**
- * OverlayHost — the single mount point for every modal overlay.
- *
- * The console surface raises overlays by writing a {@link ModalState} into the
- * reducer; this component is the one place that turns that state into a rendered
- * dialog. Rather than a hand-written `switch` over {@link ModalKind}, it mounts
- * three group components unconditionally and forwards each the same props — the
- * active {@link ModalState}, the {@link OverlayServices} runtime, the theme
- * adapter, the {@link ConsoleDispatch}, and a `closeModal` callback. Each group
- * owns a disjoint slice of the kind space and renders a body only for its own
- * kinds:
- *
- *   - {@link PickerOverlays}   — `models`, `scopedModels`, `theme`, `settings`.
- *   - {@link SessionOverlays}  — `sessions`, `tree`, `userTurns`.
- *   - {@link AuthOverlays}     — `signIn`, `signOut`, `oauth`, `plugin`.
- *   - {@link ApprovalOverlays} — `approval` (the tool-permission prompt).
- *
- * When no overlay is raised (`kind === "none"`) the host renders nothing, so the
- * composer keeps focus and the groups are never mounted needlessly.
- */
-import type { ConsoleDispatch, InkThemeAdapter, ModalState, OverlayServices } from "../contract";
-/**
- * The props the console surface threads into {@link OverlayHost}.
- *
- * The same five fields are forwarded verbatim to each overlay group; the host
- * adds no routing logic of its own beyond the `none` short-circuit.
- */
-export interface OverlayHostProps {
-    /** The active modal overlay (kind + opaque payload). */
-    readonly modal: ModalState;
-    /** The runtime handles overlays drive; absent on headless mount paths. */
-    readonly services?: OverlayServices;
-    /** The framework adapter that turns token roles into terminal colours. */
-    readonly theme: InkThemeAdapter;
-    /** Dispatch a reducer event to mutate console state. */
-    readonly dispatch: ConsoleDispatch;
-    /** Drop the active overlay back to the composer. */
-    readonly closeModal: () => void;
-}
-/**
- * Render the active modal overlay, or nothing when none is raised.
- *
- * @param props the modal state, runtime services, theme, dispatch, and closer
- */
-export declare function OverlayHost(props: OverlayHostProps): JSX.Element | null;

package/dist/types/console/overlays/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * Overlays subsystem — public barrel.
- *
- * Re-exports the single overlay mount point ({@link OverlayHost}) plus the three
- * group components it forwards to ({@link PickerOverlays}, {@link SessionOverlays},
- * {@link AuthOverlays}) and the shared prop shapes. The console surface imports
- * the overlay host from `src/console/overlays` rather than reaching into the
- * individual modules; the dialog bodies are filled by a later pass.
- */
-export { OverlayHost, type OverlayHostProps } from "./host";
-export { PickerOverlays, type OverlayGroupProps } from "./pickers";
-export { SessionOverlays } from "./sessions";
-export { AuthOverlays } from "./auth";
-export { ApprovalOverlays, choiceFromId, readApprovalPayload, summarizeInput, APPROVAL_CHOICES, DISMISS_CHOICE, type ApprovalRequest, type ApprovalPayload, } from "./approval";
-export { approvalQueueReducer, activeApproval, modeReleasesApprovals, EMPTY_APPROVAL_QUEUE, type ApprovalEntry, type ApprovalQueueState, type ApprovalQueueEvent, } from "./approval-queue";

package/dist/types/console/overlays/pickers.d.ts

@@ -1,37 +0,0 @@
-/**
- * Picker overlays — the selection dialogs raised over the transcript.
- *
- * This group owns the four modal kinds that present a list to pick from: the
- * single-model picker (`models`), the per-scope model picker (`scopedModels`),
- * the colour-scheme picker (`theme`), and the settings list (`settings`). It is
- * mounted unconditionally by {@link import("./host").OverlayHost}; the host
- * routes by {@link ModalState.kind}, so this component only renders a dialog
- * body for one of its own kinds and is otherwise inert.
- */
-import type { ConsoleDispatch, InkThemeAdapter, ModalState, OverlayServices } from "../contract";
-/**
- * The props every overlay group receives, forwarded verbatim from
- * {@link import("./host").OverlayHost}.
- */
-export interface OverlayGroupProps {
-    /** The active modal overlay (kind + opaque payload). */
-    readonly modal: ModalState;
-    /** The runtime handles overlays drive; absent on headless mount paths. */
-    readonly services?: OverlayServices;
-    /** The framework adapter that turns token roles into terminal colours. */
-    readonly theme: InkThemeAdapter;
-    /** Dispatch a reducer event to mutate console state. */
-    readonly dispatch: ConsoleDispatch;
-    /** Drop the active overlay back to the composer. */
-    readonly closeModal: () => void;
-}
-/**
- * The picker overlay group: models, scoped models, theme, and settings.
- *
- * Renders the framework dialog matching the active modal kind, and nothing for
- * any kind owned by another group. With no runtime services attached (headless
- * and test mounts) every kind renders nothing.
- *
- * @param props the forwarded overlay props
- */
-export declare function PickerOverlays(props: OverlayGroupProps): JSX.Element | null;

package/dist/types/console/overlays/sessions.d.ts

@@ -1,29 +0,0 @@
-/**
- * Session overlays — the transcript navigation dialogs.
- *
- * This group owns the three modal kinds that browse persisted or in-flight
- * transcript state: the session resume/list picker (`sessions`), the
- * transcript-tree navigator (`tree`), and the prior-user-turn picker
- * (`userTurns`) used when branching or forking. It is mounted unconditionally
- * by {@link import("./host").OverlayHost}, which routes by
- * {@link ModalState.kind}; this component renders a dialog body only for one of
- * its own kinds and is otherwise inert.
- *
- * Each body maps the app's session vocabulary onto the framework dialog prop
- * shapes: a {@link import("../../sessions").SavedSession} becomes a
- * `SessionInfo`, a {@link import("../../sessions").BranchNode} becomes a
- * `SessionTreeOption`, and a {@link import("../../sessions").PriorTurn} becomes
- * a `UserMessageOption`. Async catalog/tree/turn loads run in `useEffect`; every
- * confirm drives the matching service then closes the modal. When the runtime
- * {@link OverlayServices} bundle is absent, the group renders nothing.
- */
-import type { OverlayGroupProps } from "./pickers";
-/**
- * The session overlay group: sessions, tree, and prior-turn pickers.
- *
- * Renders the dialog body matching the active modal kind, or nothing for a kind
- * this group does not own (or when no runtime services are wired in).
- *
- * @param props the forwarded overlay props (modal, services, theme, dispatch, closer)
- */
-export declare function SessionOverlays(props: OverlayGroupProps): JSX.Element | null;

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

@@ -1,51 +0,0 @@
-/**
- * Console reducer — the single pure fold over {@link ConsoleState}.
- *
- * The whole terminal surface is reduced from one immutable {@link ConsoleState}
- * value, mutated only by dispatching a {@link ConsoleEvent} into
- * {@link consoleReducer}. This module is the one place those transitions live:
- * it is a pure function (no React, no I/O, no timers) that, given a prior state
- * and an event, returns a *fresh* state — it never mutates its input. That makes
- * every transition unit-testable in isolation and keeps the surface component a
- * thin shell that only wires events in and renders the result out.
- *
- * The transitions fall into a few families, mirroring the {@link ConsoleEvent}
- * grouping:
- *
- *   - **Composer edits** (`buffer:*`, `caret:*`) splice and navigate the live
- *     input buffer, keeping the caret clamped into `[0, buffer.length]`.
- *   - **History recall** (`history:*`) walks the submitted-input ring, stashing
- *     the live buffer on the way in and restoring it on the way out.
- *   - **Transcript view** (`rows:*`, `block:append`) appends and patches the
- *     rendered rows projected from the conductor's {@link SessionSignal} stream
- *     (the surface translates each signal into a row event).
- *   - **Overlays / status / theme / toggles / busy** flip the small UI-local
- *     flags the surface reads to decide what chrome to render.
- *
- * Live session data (messages, usage, model) is *not* stored here — it is read
- * straight from the conductor snapshot — so this state stays purely UI-local and
- * the reducer never needs to know about the agent loop.
- */
-import { type ConsoleEvent, type ConsoleState } from "./contract";
-/**
- * Fold a {@link ConsoleEvent} into a {@link ConsoleState}, returning a fresh
- * state.
- *
- * Pure and total: every event has a defined transition, and the input state is
- * never mutated. The `switch` is exhaustive over the event union, so adding an
- * event without handling it is a compile error.
- *
- * @param state the prior console state
- * @param event the action to apply
- */
-export declare function consoleReducer(state: ConsoleState, event: ConsoleEvent): ConsoleState;
-/**
- * Build the initial {@link ConsoleState} a console mounts with.
- *
- * Starts from the frozen {@link EMPTY_CONSOLE_STATE} seed and overlays any
- * caller-supplied UI preferences (scheme, the display toggles). Pure and
- * deterministic — no runtime is consulted — so the first render is stable.
- *
- * @param overrides optional UI-local preferences to seed
- */
-export declare function initConsoleState(overrides?: Partial<ConsoleState>): ConsoleState;

package/dist/types/console/slash/builtins.d.ts

@@ -1,33 +0,0 @@
-/**
- * The built-in slash catalog — the single ordered source of truth.
- *
- * The catalog is assembled from three static topic groups, each its own module
- * under `./commands/`: transcript/session control, the workbench pickers
- * (model/models-for/theme/settings/help/keys/whats-new/debug), and the
- * integration bridges (login/logout/mcp/memory/composio/copy/export/share). On
- * top of those it splices in the *dynamic* rows — one `/skill:<name>` per
- * discovered Agent-Skills capability card and one `/<template-name>` per
- * discovered prompt-template macro — produced by {@link buildDynamicCommands}.
- *
- * There is no command `if`-ladder anywhere: adding a static command is appending
- * a row to one of the groups, and the dynamic rows are discovered at module load
- * from the standard skill/macro roots (returning nothing, never an error, when
- * those roots are absent). The registry index, the completion matcher, and the
- * family grouping are all *derived* from {@link SLASH_COMMANDS} (see
- * `registry.ts`).
- *
- * Listing order is intentional: transcript controls first (the verbs a new user
- * meets), then the workbench pickers, then the integration bridges, and finally
- * the discovered skills and templates.
- */
-import type { SlashCommand } from "../contract";
-/** The family labels the catalog groups commands under (for `/help`). */
-export { FAMILY } from "./commands/shared";
-/**
- * The built-in catalog — every command row in listing order.
- *
- * Consumers fold this into a {@link SlashRegistry} via `buildRegistry`; the index
- * by name/alias, the family grouping, and the completion matcher are all derived
- * from this one array.
- */
-export declare const SLASH_COMMANDS: readonly SlashCommand[];

package/dist/types/console/slash/commands/dynamic.d.ts

@@ -1,57 +0,0 @@
-/**
- * Dynamic slash commands — capability cards and prompt templates as registry rows.
- *
- * The static catalog (`./builtins`) is hand-maintained, but two command families
- * are *discovered* at startup rather than written by hand: the Agent-Skills
- * capability cards ({@link SkillCard}s loaded from `SKILL.md` files) and the
- * user/project prompt templates ({@link Macro}s loaded from `*.md` macro files).
- * This module turns whatever was discovered into ordinary {@link SlashCommand}
- * rows so they sit in the same registry as the built-ins, complete the same way,
- * and resolve through the same dispatcher.
- *
- * Two row shapes are produced:
- *
- *   - `/skill:<name>` — invoking it submits an Agent-Skills *invocation block*
- *     (`<skill name="…" location="…">body</skill>`) as a normal turn, which is
- *     exactly what the agent loop recognises to load and run that skill. The
- *     trailing argument string becomes the skill body, so `/skill:commit tidy the
- *     diff` runs the `commit` card against "tidy the diff".
- *   - `/<template-name>` — invoking it expands the macro body against the
- *     trailing arguments (the single-pass `$arg` model from the briefing layer)
- *     and submits the result as a normal turn.
- *
- * Both return a `{ kind: "prompt" }` outcome so the dispatcher hands the produced
- * text to the conductor as a turn; neither reaches into a backend the console
- * does not own. When nothing was discovered, {@link buildDynamicCommands} returns
- * an empty array, so splicing it into the catalog is always safe.
- */
-import type { Macro, SkillCard } from "../../../briefing";
-import type { SlashCommand } from "../../contract";
-/**
- * The discovered material a dynamic catalog is built from.
- *
- * Both fields are optional and default to empty: a caller that only loaded
- * skills passes `{ skills }`, one that only loaded templates passes `{ templates }`,
- * and a caller with neither passes `{}` (or nothing) and gets back `[]`.
- */
-export interface DynamicCommandSources {
-    /** Capability cards discovered from `SKILL.md` files. */
-    readonly skills?: readonly SkillCard[];
-    /** Prompt templates discovered from `*.md` macro files. */
-    readonly templates?: readonly Macro[];
-}
-/**
- * Project discovered skills and templates into {@link SlashCommand} rows.
- *
- * Skill rows are listed first (namespaced under `skill:`), then the template
- * rows. A name claimed by an earlier row — including any of the static built-ins
- * a caller will concatenate these ahead of — is the registry's problem to reject
- * at assembly time; this function only suppresses *self*-collisions so a template
- * whose name duplicates a skill's `skill:`-prefixed token (impossible) or another
- * template (first wins) cannot crash the build. When no sources are supplied the
- * result is an empty array, never an error.
- *
- * @param sources the discovered skills and templates
- * @returns the dynamic command rows, skills first then templates
- */
-export declare function buildDynamicCommands(sources?: DynamicCommandSources): SlashCommand[];

package/dist/types/console/slash/commands/dynamic.test.d.ts

@@ -1,9 +0,0 @@
-/**
- * Dynamic command group — focused tests.
- *
- * The builder turns discovered capability cards and prompt-template macros into
- * {@link SlashCommand} rows. Each row's `run` is driven against a scripted
- * {@link SlashContext} so its produced outcome (a `prompt` carrying the skill
- * invocation block or the expanded template) is asserted directly.
- */
-export {};

package/dist/types/console/slash/commands/integrations.d.ts

@@ -1,28 +0,0 @@
-/**
- * Integration slash commands — auth launchers, the external bridges, and the
- * clipboard / export / share I/O verbs.
- *
- * This group is the console's seam onto everything that lives *outside* a single
- * turn: signing in and out of a provider, wiring the MCP and memory surfaces,
- * connecting an external SaaS bridge, and moving the transcript out of the
- * terminal (clipboard, HTML export, a share link). The handlers do real work
- * where a backing capability exists — they render the live transcript to HTML
- * through the {@link publishTranscript} publisher, drive an {@link MCPClientPool}
- * over the workspace MCP config, reflect the working-memory card from the
- * capability deck, and reach the Composio catalog through the SaaS gateway — and
- * fall back to an *informative* status (never a dead placeholder) when a backend
- * is unreachable in the current environment.
- *
- * The two family commands (`/memory`, `/composio`) are built from
- * {@link SubCommand} tables via {@link familyRunner}, so their verb dispatch is a
- * lookup, not an `if`-ladder. Overlay surfaces (`mcp`, `memory`, `composio`)
- * carry the *gathered* text into the plugin modal payload, so the dialog renders
- * the real state the command collected rather than a fixed line.
- */
-import type { SlashCommand } from "../../contract";
-/**
- * The integration command group: auth launchers, the MCP/memory/composio
- * bridges, and the clipboard / export / share I/O verbs. Appended to the slash
- * registry by the integrator alongside the other groups.
- */
-export declare const integrationCommands: SlashCommand[];

package/dist/types/console/slash/commands/integrations.test.d.ts

@@ -1,18 +0,0 @@
-/**
- * Integration slash commands — focused behavioral tests.
- *
- * Each handler is exercised through a scripted fake {@link SlashContext} that
- * records the overlay requests (`openModal`) and status toasts (`setStatus`) the
- * handlers raise. The coverage walks every command and family verb:
- *   1. The auth/bridge launchers (`/login`, `/logout`, `/mcp`) open the right
- *      modal kind, and a named `/login` threads the provider into the payload.
- *   2. `/memory` reflects the real working-memory card (status / tools / on /
- *      off) and carries the gathered text into the plugin overlay.
- *   3. `/composio` reports the missing-key state specifically when no
- *      `COMPOSIO_API_KEY` is configured, and warns on a missing connect target.
- *   4. `/copy` extracts the newest assistant prose and writes it through the
- *      injected clipboard, warning when there is nothing to copy.
- *   5. `/export` renders the live transcript to an HTML file (and warns on an
- *      empty transcript); `/share` reuses that path and degrades informatively.
- */
-export {};