indusagi 0.12.32 → 0.12.33

package/dist/types/react-ink/components/dialogs/ModelDialog.d.ts

@@ -0,0 +1,9 @@
+import type { Model } from "indusagi/ai";
+interface ModelDialogProps {
+    models: Model<any>[];
+    search?: string;
+    onClose: () => void;
+    onSelect: (model: Model<any>) => void | Promise<void>;
+}
+export declare function ModelDialog({ models, onClose, onSelect, search }: ModelDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/OAuthDialog.d.ts

@@ -0,0 +1,9 @@
+import type { OAuthOverlayState } from "../../types.js";
+interface OAuthDialogProps {
+    state: OAuthOverlayState;
+    onClose: () => void;
+    onChange: (next: Partial<OAuthOverlayState>) => void;
+    onSubmit: () => void | Promise<void>;
+}
+export declare function OAuthDialog({ onChange, onClose, onSubmit, state }: OAuthDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/ScopedModelsDialog.d.ts

@@ -0,0 +1,9 @@
+import type { Model } from "indusagi/ai";
+interface ScopedModelsDialogProps {
+    models: Model<any>[];
+    selectedIds: string[];
+    onClose: () => void;
+    onSave: (selectedIds: string[]) => void | Promise<void>;
+}
+export declare function ScopedModelsDialog({ models, onClose, onSave, selectedIds }: ScopedModelsDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/SelectableDialog.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from "indusagi/react-host";
+interface SelectableDialogProps<T> {
+    title: string;
+    subtitle?: string;
+    items: T[];
+    isActive?: boolean;
+    searchEnabled?: boolean;
+    emptyText: string;
+    noSearchResultsText?: string;
+    onClose: () => void;
+    onSelect: (item: T) => void | Promise<void>;
+    getSearchText?: (item: T) => string;
+    renderItem: (item: T, selected: boolean, index: number) => ReactNode;
+}
+export declare function SelectableDialog<T>({ title, subtitle, items, isActive, searchEnabled, emptyText, noSearchResultsText, onClose, onSelect, getSearchText, renderItem, }: SelectableDialogProps<T>): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/SessionDialog.d.ts

@@ -0,0 +1,13 @@
+import type { SessionInfo } from "../../types.js";
+import { type SessionBrowserProgress } from "../../utils/session-browser.js";
+interface SessionDialogProps {
+    currentSessions: SessionInfo[];
+    currentSessionPath?: string;
+    onClose: () => void;
+    onSelect: (session: SessionInfo) => void | Promise<void>;
+    onLoadAllSessions: (onProgress?: (progress: SessionBrowserProgress) => void) => Promise<SessionInfo[]>;
+    onDeleteSession?: (session: SessionInfo) => void | Promise<void>;
+    onRenameSession?: (session: SessionInfo, name: string) => void | Promise<void>;
+}
+export declare function SessionDialog({ currentSessionPath, currentSessions, onClose, onDeleteSession, onLoadAllSessions, onRenameSession, onSelect, }: SessionDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/SettingsDialog.d.ts

@@ -0,0 +1,14 @@
+export interface SettingsDialogItem {
+    id: string;
+    label: string;
+    description: string;
+    value: string;
+    values: string[];
+    onChange: (value: string) => void | Promise<void>;
+}
+interface SettingsDialogProps {
+    items: SettingsDialogItem[];
+    onClose: () => void;
+}
+export declare function SettingsDialog({ items, onClose }: SettingsDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/StartupSessionPicker.d.ts

@@ -0,0 +1,9 @@
+import type { SessionInfo } from "../../types.js";
+interface StartupSessionPickerProps {
+    sessions: SessionInfo[];
+    totalCount: number;
+    onClose: () => void;
+    onSelect: (session: SessionInfo) => void | Promise<void>;
+}
+export declare function StartupSessionPicker({ onClose, onSelect, sessions, totalCount }: StartupSessionPickerProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/ThemeDialog.d.ts

@@ -0,0 +1,7 @@
+interface ThemeDialogProps {
+    themes: string[];
+    onClose: () => void;
+    onSelect: (themeName: string) => void | Promise<void>;
+}
+export declare function ThemeDialog({ themes, onClose, onSelect }: ThemeDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/TreeDialog.d.ts

@@ -0,0 +1,8 @@
+import type { SessionTreeOption } from "../../types.js";
+interface TreeDialogProps {
+    items: SessionTreeOption[];
+    onClose: () => void;
+    onSelect: (item: SessionTreeOption) => void | Promise<void>;
+}
+export declare function TreeDialog({ items, onClose, onSelect }: TreeDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/UserMessageDialog.d.ts

@@ -0,0 +1,8 @@
+import type { UserMessageOption } from "../../types.js";
+interface UserMessageDialogProps {
+    items: UserMessageOption[];
+    onClose: () => void;
+    onSelect: (item: UserMessageOption) => void | Promise<void>;
+}
+export declare function UserMessageDialog({ items, onClose, onSelect }: UserMessageDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/AssistantMessage.d.ts

@@ -0,0 +1,12 @@
+import type { AssistantMessage, ToolResultMessage } from "indusagi/ai";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface AssistantMessageProps {
+    message: AssistantMessage;
+    showImages: boolean;
+    showThinking: boolean;
+    expandToolOutputs?: boolean;
+    theme: InkThemeAdapter;
+    toolResults?: ToolResultMessage[];
+}
+export declare function AssistantMessageView({ expandToolOutputs, message, showImages, showThinking, theme, toolResults, }: AssistantMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/BashMessage.d.ts

@@ -0,0 +1,8 @@
+import type { BashExecutionMessage } from "indusagi/agent";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface BashMessageProps {
+    message: BashExecutionMessage;
+    theme: InkThemeAdapter;
+}
+export declare function BashMessageView({ message, theme }: BashMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/BranchSummaryMessage.d.ts

@@ -0,0 +1,8 @@
+import type { BranchSummaryMessage } from "indusagi/agent";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface BranchSummaryMessageProps {
+    message: BranchSummaryMessage;
+    theme: InkThemeAdapter;
+}
+export declare function BranchSummaryMessageView({ message, theme }: BranchSummaryMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/CompactionMessage.d.ts

@@ -0,0 +1,8 @@
+import type { CompactionSummaryMessage } from "indusagi/agent";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface CompactionMessageProps {
+    message: CompactionSummaryMessage;
+    theme: InkThemeAdapter;
+}
+export declare function CompactionMessageView({ message, theme }: CompactionMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/CustomMessage.d.ts

@@ -0,0 +1,9 @@
+import type { CustomMessage } from "indusagi/agent";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface CustomMessageProps {
+    message: CustomMessage;
+    showImages: boolean;
+    theme: InkThemeAdapter;
+}
+export declare function CustomMessageView({ message, showImages, theme }: CustomMessageProps): JSX.Element | null;
+export {};

package/dist/types/react-ink/components/messages/SkillInvocationMessage.d.ts

@@ -0,0 +1,7 @@
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface SkillInvocationMessageProps {
+    content: string;
+    theme: InkThemeAdapter;
+}
+export declare function SkillInvocationMessage({ content, theme }: SkillInvocationMessageProps): JSX.Element | null;
+export {};

package/dist/types/react-ink/components/messages/ToolCallMessage.d.ts

@@ -0,0 +1,8 @@
+import type { ToolCall } from "indusagi/ai";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface ToolCallMessageProps {
+    toolCall: ToolCall;
+    theme: InkThemeAdapter;
+}
+export declare function ToolCallMessage({ theme, toolCall }: ToolCallMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/ToolResultBlock.d.ts

@@ -0,0 +1,12 @@
+import type { ToolCall, ToolResultMessage } from "indusagi/ai";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface ToolResultBlockProps {
+    message: ToolResultMessage;
+    showImages: boolean;
+    theme: InkThemeAdapter;
+    expanded?: boolean;
+    nested?: boolean;
+    toolCall?: ToolCall;
+}
+export declare function ToolResultBlock({ expanded, message, nested, showImages, theme, toolCall }: ToolResultBlockProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/UserMessage.d.ts

@@ -0,0 +1,9 @@
+import type { UserMessage } from "indusagi/ai";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface UserMessageProps {
+    message: UserMessage;
+    theme: InkThemeAdapter;
+    showImages: boolean;
+}
+export declare function UserMessageView({ message, showImages, theme }: UserMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/index.d.ts

@@ -0,0 +1,34 @@
+export * from "./types.js";
+export * from "./theme-adapter.js";
+export * from "./components/ChangelogBlock.js";
+export * from "./components/DisplayBlockView.js";
+export * from "./components/Footer.js";
+export * from "./components/MessageList.js";
+export * from "./components/MessageRow.js";
+export * from "./components/StatusLine.js";
+export * from "./components/TaskPanel.js";
+export * from "./components/ToolEventBlock.js";
+export * from "./components/dialogs/DialogFrame.js";
+export * from "./components/dialogs/LoginDialog.js";
+export * from "./components/dialogs/ModelDialog.js";
+export * from "./components/dialogs/OAuthDialog.js";
+export * from "./components/dialogs/ScopedModelsDialog.js";
+export * from "./components/dialogs/SelectableDialog.js";
+export * from "./components/dialogs/SessionDialog.js";
+export * from "./components/dialogs/SettingsDialog.js";
+export * from "./components/dialogs/StartupSessionPicker.js";
+export * from "./components/dialogs/ThemeDialog.js";
+export * from "./components/dialogs/TreeDialog.js";
+export * from "./components/dialogs/UserMessageDialog.js";
+export * from "./components/messages/AssistantMessage.js";
+export * from "./components/messages/BashMessage.js";
+export * from "./components/messages/BranchSummaryMessage.js";
+export * from "./components/messages/CompactionMessage.js";
+export * from "./components/messages/CustomMessage.js";
+export * from "./components/messages/SkillInvocationMessage.js";
+export * from "./components/messages/ToolCallMessage.js";
+export * from "./components/messages/ToolResultBlock.js";
+export * from "./components/messages/UserMessage.js";
+export * from "./utils/message-groups.js";
+export * from "./utils/selection-dialog.js";
+export * from "./utils/tool-display.js";

package/dist/types/react-ink/theme-adapter.d.ts

@@ -0,0 +1,9 @@
+export interface InkThemeAdapter {
+    name: string;
+    colors: Record<string, string>;
+    color: (key: string, text: string) => string;
+    background: (key: string, text: string, textKey?: string) => string;
+    dim: (text: string) => string;
+    muted: (text: string) => string;
+}
+export declare function createThemeAdapter(themeName: string, colors: Record<string, string>): InkThemeAdapter;

package/dist/types/react-ink/types.d.ts

@@ -0,0 +1,133 @@
+import type { AgentMessage, ThinkingLevel } from "indusagi/agent";
+import type { AuthInputPrompt, AuthRedirectInfo, Model } from "indusagi/ai";
+export type StatusKind = "info" | "success" | "warning" | "error" | "busy";
+export interface StatusMessage {
+    kind: StatusKind;
+    text: string;
+}
+export interface ToolExecutionState {
+    toolCallId: string;
+    toolName: string;
+    argsText: string;
+    status: "running" | "success" | "error";
+    outputText: string;
+    args?: unknown;
+    output?: unknown;
+    updatedAt: number;
+}
+export interface PendingMessageItem {
+    id: string;
+    mode: "steer" | "followUp";
+    text: string;
+    source: "session" | "compaction";
+}
+export interface UserMessageOption {
+    entryId: string;
+    text: string;
+    preview: string;
+}
+export interface SessionTreeOption {
+    id: string | null;
+    label: string;
+    depth: number;
+    isLeaf: boolean;
+    isCurrent: boolean;
+}
+export interface LoginProviderOption {
+    id: string;
+    label: string;
+    authKind: "oauth" | "apiKey";
+}
+export interface SavedAccountOption {
+    provider: string;
+    accountId: string;
+    label: string;
+}
+export interface OAuthOverlayState {
+    kind: "oauth";
+    providerId: string;
+    providerName: string;
+    mode: "oauth" | "apiKey";
+    inputLabel: string;
+    inputValue: string;
+    accountId: string;
+    accountName: string;
+    authInfo?: AuthRedirectInfo;
+    prompt?: AuthInputPrompt;
+    progress?: string;
+}
+export interface SessionInfo {
+    id: string;
+    path: string;
+    name?: string;
+    modified: Date;
+    lastModified: number;
+    size?: number;
+    cwd?: string;
+    messageCount?: number;
+    firstMessage?: string;
+    allMessagesText?: string;
+}
+export interface SessionStats {
+    sessionFile?: string;
+    sessionId: string;
+    userMessages: number;
+    assistantMessages: number;
+    toolCalls: number;
+    toolResults: number;
+    totalMessages: number;
+    tokens: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    cost: number;
+}
+export interface SessionSnapshot {
+    messages: AgentMessage[];
+    model: Model<any> | undefined;
+    thinkingLevel: ThinkingLevel;
+    isStreaming: boolean;
+    isCompacting: boolean;
+    isBashRunning: boolean;
+    pendingMessageCount: number;
+    pendingToolCallCount: number;
+    sessionId: string;
+    sessionFile: string | undefined;
+    sessionName: string | undefined;
+    cwd: string;
+    autoCompactEnabled: boolean;
+    leafId: string | null | undefined;
+    error?: string;
+    stats: SessionStats;
+    contextUsage?: {
+        tokens: number;
+        contextWindow: number;
+        percent: number;
+    };
+}
+export interface StartupNotice {
+    kind: StatusKind;
+    text: string;
+}
+export interface StartupChangelog {
+    latestVersion: string;
+    markdown: string;
+}
+export interface StartupDiagnosticsSection {
+    title: string;
+    lines: string[];
+    tone?: "default" | "warning" | "error";
+}
+export interface StartupDiagnostics {
+    sections: StartupDiagnosticsSection[];
+}
+export interface UiDisplayBlock {
+    id: string;
+    kind: "changelog";
+    title: string;
+    markdown: string;
+    timestamp: number;
+}

package/dist/types/react-ink/utils/message-groups.d.ts

@@ -0,0 +1,25 @@
+import type { AgentMessage } from "indusagi/agent";
+import type { AssistantMessage, ImageContent, TextContent, ToolCall, ToolResultMessage, UserMessage } from "indusagi/ai";
+export declare function previewText(value: string, maxLength?: number): string;
+export declare function safeStringify(value: unknown): string;
+export declare function extractToolText(value: unknown, showImages: boolean): string;
+export declare function previewMultiline(value: string, options?: {
+    maxLines?: number;
+    maxChars?: number;
+}): string;
+export declare function formatUserContent(content: UserMessage["content"], showImages: boolean): string;
+export declare function splitAssistantMessage(message: AssistantMessage, showThinking: boolean): {
+    text: string;
+    thinking: string[];
+    toolCalls: ToolCall[];
+};
+export declare function formatToolCall(toolCall: ToolCall): string;
+export declare function formatToolResult(message: ToolResultMessage, showImages: boolean): string;
+export declare function formatCustomContent(content: string | (TextContent | ImageContent)[], showImages: boolean): string;
+export declare function formatMessageTimestamp(timestamp: number): string;
+export declare function extractMessagePreview(message: AgentMessage): string;
+export declare function parseSkillInvocation(content: string): {
+    name: string;
+    location: string;
+    userMessage?: string;
+} | null;

package/dist/types/react-ink/utils/selection-dialog.d.ts

@@ -0,0 +1,2 @@
+export declare function matchesSearchQuery(value: string, query: string): boolean;
+export declare function wrapSelectionIndex(current: number, direction: 1 | -1, length: number): number;

package/dist/types/react-ink/utils/session-browser.d.ts

@@ -0,0 +1,27 @@
+import type { SessionInfo } from "../types.js";
+export type SessionSortMode = "recent" | "relevance";
+export type SessionScope = "current" | "all";
+type TokenKind = "fuzzy" | "phrase";
+interface ParsedSearchQuery {
+    mode: "tokens" | "regex";
+    tokens: {
+        kind: TokenKind;
+        value: string;
+    }[];
+    regex: RegExp | null;
+    error?: string;
+}
+export interface SessionBrowserProgress {
+    loaded: number;
+    total: number;
+}
+export declare function wrapSelectionIndex(current: number, direction: 1 | -1, length: number): number;
+export declare function parseSessionSearchQuery(query: string): ParsedSearchQuery;
+export declare function filterAndSortSessions(sessions: SessionInfo[], query: string, sortMode: SessionSortMode): {
+    items: SessionInfo[];
+    error?: string;
+};
+export declare function formatSessionAge(lastModified: number): string;
+export declare function formatSessionSize(bytes: number): string;
+export declare function shrinkSessionId(id: string): string;
+export {};

package/dist/types/react-ink/utils/tool-display.d.ts

@@ -0,0 +1,21 @@
+import type { ToolCall, ToolResultMessage } from "indusagi/ai";
+import type { ToolExecutionState } from "../types.js";
+export interface ToolCardDescriptor {
+    title: string;
+    summary?: string;
+    body?: string;
+    emptyText: string;
+}
+interface ToolSource {
+    toolName: string;
+    args?: unknown;
+    output?: unknown;
+    fallbackArgsText?: string;
+    fallbackOutputText?: string;
+    showImages?: boolean;
+}
+export declare function describeToolSource(source: ToolSource): ToolCardDescriptor;
+export declare function describeToolExecution(tool: ToolExecutionState): ToolCardDescriptor;
+export declare function describeToolCall(toolCall: ToolCall): ToolCardDescriptor;
+export declare function describeToolResult(message: ToolResultMessage, showImages: boolean, args?: unknown): ToolCardDescriptor;
+export {};

package/dist/types/runtime/cadence/cadence.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Behavioural tests for the pure cadence FSM. Each test threads signals through
+ * the bound step function and asserts on the derived snapshot and the requested
+ * effects — no I/O, no mocks of the outside world.
+ */
+export {};

package/dist/types/runtime/cadence/fold.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Folding emissions into an assistant turn.
+ *
+ * The reducer keeps the in-flight assistant {@link Turn} as an ordinary
+ * immutable value and grows it one {@link Emission} at a time. These helpers do
+ * that growth purely: each returns a brand-new block list (or turn, or usage)
+ * rather than mutating its argument. Streaming a response means appending text
+ * and reasoning deltas, opening tool-call blocks and concatenating their
+ * argument fragments, and summing token accounting.
+ *
+ * While arguments stream in, a tool-call block's `input` holds the raw,
+ * still-growing JSON string. {@link sealToolArgs} converts those strings into
+ * parsed values once the stream ends, so partial JSON never escapes the turn.
+ * A terminal `done` emission's fully-assembled blocks supersede the accumulated
+ * ones entirely.
+ */
+import type { AssistantTurn, Block, Emission, ToolCallBlock, Usage } from "../../llmgateway/contract";
+/** A neutral, all-zero usage accumulator. */
+export declare const ZERO_USAGE: Usage;
+/** Sum two usage records field by field, preserving present cache tiers only. */
+export declare function addUsage(base: Usage, more: Usage): Usage;
+/** Parse an accumulated argument buffer, tolerating empty/invalid JSON. */
+export declare function parseToolArgs(raw: string): unknown;
+/**
+ * Fold a single emission into a block list, returning a new list.
+ *
+ * Text and thinking deltas extend the trailing block of their kind when one is
+ * open, otherwise they start a fresh one. A `tool_call_start` opens a new
+ * tool-call block whose `input` begins as an empty raw buffer; each
+ * `tool_call_delta` concatenates onto that buffer in place. A terminal `done`
+ * replaces the whole list with the reply's authoritative blocks. Emissions that
+ * carry no content leave the list untouched (the same array reference is
+ * returned, which callers may use to detect "no change").
+ */
+export declare function foldBlocks(blocks: readonly Block[], emission: Emission): readonly Block[];
+/**
+ * Finalize an assistant turn after its stream ends: every tool-call block whose
+ * `input` is still a raw JSON string is parsed into a structured value. Returns
+ * the same turn reference when nothing needed sealing.
+ */
+export declare function sealToolArgs(turn: AssistantTurn): AssistantTurn;
+/**
+ * Fold an emission into an assistant turn, returning a new turn. A thin wrapper
+ * over {@link foldBlocks} that preserves the `assistant` role.
+ */
+export declare function foldTurn(turn: AssistantTurn, emission: Emission): AssistantTurn;
+/** Collect the tool-call blocks present in an assistant turn, in order. */
+export declare function toolCallsOf(turn: AssistantTurn): readonly ToolCallBlock[];

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

@@ -0,0 +1,12 @@
+/**
+ * The cadence — the pure finite-state machine that drives a run.
+ *
+ * This barrel exposes the reducer factory and its supporting fold helpers. A
+ * host binds {@link cadence} to a static {@link import("../contract").AgentConfig}
+ * to obtain a `(state, signal) => { state, effects }` step function, threads
+ * signals through it, and interprets the returned effects. Everything here is
+ * pure: no I/O, no awaiting, no mutation of inputs.
+ */
+export type { Transition, StepFn } from "./reducer";
+export { cadence, initialSnapshot } from "./reducer";
+export { ZERO_USAGE, addUsage, parseToolArgs, foldBlocks, foldTurn, sealToolArgs, toolCallsOf, } from "./fold";

package/dist/types/runtime/cadence/reducer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The pure finite-state machine at the heart of the runtime.
+ *
+ * {@link step} takes the current immutable {@link RunSnapshot} and one incoming
+ * {@link Signal}, and returns the next snapshot plus the {@link Effect}s a driver
+ * must perform. It performs no I/O and never awaits; every transition derives a
+ * fresh snapshot (the input is treated as frozen) and a flat list of effects.
+ *
+ * The agent loop is encoded as a transition table rather than nested control
+ * flow:
+ *
+ *   submit                         → invoke_model              · phase invoking
+ *   emission (text/thinking)       → fold + publish delta      · phase streaming
+ *   emission (tool start/delta)    → fold + tool_started       · phase streaming
+ *   emission (usage)               → accumulate usage          · (phase kept)
+ *   emission (error)               → faulted                   · phase faulted
+ *   stream_end · has tool calls    → run_tool × N              · phase dispatching
+ *   stream_end · no tool calls     → persist + settled         · phase settled
+ *   tool_settled · more pending    → (mark done, keep waiting) · phase dispatching
+ *   tool_settled · all done        → append tool turn,         · phase invoking
+ *                                     invoke_model (next turn)
+ *   compacted                      → splice summary,           · phase invoking
+ *                                     invoke_model
+ *   abort                          → faulted (aborted)         · phase faulted
+ *   fault                          → faulted                   · phase faulted
+ *
+ * Bind the machine to its static {@link AgentConfig} with {@link cadence}; the
+ * returned function has the exact `(state, signal) => { state, effects }` shape.
+ */
+import type { AgentConfig, Effect, RunSnapshot, Signal } from "../contract";
+/** The result of one transition: the next snapshot and the effects to run. */
+export interface Transition {
+    readonly state: RunSnapshot;
+    readonly effects: Effect[];
+}
+/** A reducer bound to its static configuration. */
+export type StepFn = (state: RunSnapshot, signal: Signal) => Transition;
+/**
+ * Build a clean starting snapshot for a session. Phase is `idle` until the
+ * first `submit` signal arrives.
+ */
+export declare function initialSnapshot(sessionId: string, model: string, runId?: string): RunSnapshot;
+/** A factory binding the FSM to its static config. */
+export declare function cadence(config: AgentConfig): StepFn;