@comma-agents/tui 2.0.0-rc.0

package/dist/components/TitleIcon/index.d.ts

@@ -0,0 +1 @@
+export { TitleIcon } from "./TitleIcon";

package/dist/components/index.d.ts

@@ -0,0 +1,61 @@
+export type { BorderedPanelProps, BorderedPanelRenderProps, BorderedPanelTheme, } from "./BorderedPanel";
+export { BorderedPanel, BorderedPanelRender, useBorderedPanelTheme, } from "./BorderedPanel";
+export type { ButtonProps, ButtonRenderProps, ButtonTheme, ButtonVariant, } from "./Button";
+export { Button, ButtonRender, useButtonTheme } from "./Button";
+export type { ChatTextAreaProps, ChatTextAreaRenderProps, } from "./ChatTextArea";
+export { ChatTextArea, ChatTextAreaRender } from "./ChatTextArea";
+export { useChatTextAreaTheme } from "./ChatTextArea/ChatTextArea.theme";
+export type { CodeViewProps, CodeViewRenderProps } from "./CodeView";
+export { CodeView, CodeViewRender } from "./CodeView";
+export type { CodeViewTheme } from "./CodeView/CodeView.theme";
+export { useCodeViewTheme } from "./CodeView/CodeView.theme";
+export type { Command, CommandAction, CommandActionContext, CommandId, CommandPaletteProps, CommandPaletteRenderProps, } from "./CommandPalette";
+export { CommandPalette, CommandPaletteRender } from "./CommandPalette";
+export type { CommandPaletteTheme } from "./CommandPalette/CommandPalette.theme";
+export { useCommandPaletteTheme } from "./CommandPalette/CommandPalette.theme";
+export type { FrameProps, FrameRenderProps } from "./Frame";
+export { Frame, FrameRender } from "./Frame";
+export type { FrameTheme } from "./Frame/Frame.theme";
+export { useFrameTheme } from "./Frame/Frame.theme";
+export type { HideProps } from "./Hide";
+export { Hide } from "./Hide";
+export type { AgentMessageProps, AgentMessageRenderProps, MessageListProps, MessageListRenderProps, SystemMessageProps, SystemMessageRenderProps, UserMessageProps, UserMessageRenderProps, } from "./MessageList";
+export { AgentMessage, AgentMessageRender, MessageList, MessageListRender, SystemMessage, SystemMessageRender, UserMessage, UserMessageRender, } from "./MessageList";
+export type { MessageListTheme, RoleStyle, } from "./MessageList/MessageList.theme";
+export { useMessageListTheme } from "./MessageList/MessageList.theme";
+export type { ModalProps, ModalRenderProps, ModalSize } from "./Modal";
+export { Modal, ModalRender } from "./Modal";
+export type { ModalTheme } from "./Modal/Modal.theme";
+export { useModalTheme } from "./Modal/Modal.theme";
+export type { MouseContextValue, MouseListener, MouseProviderProps, } from "./MouseProvider";
+export { MouseProvider } from "./MouseProvider";
+export type { PermissionDecision, PermissionPromptProps, PermissionPromptRenderProps, } from "./PermissionPrompt";
+export { PermissionPrompt, PermissionPromptRender } from "./PermissionPrompt";
+export type { QuestionPromptProps, QuestionPromptRenderProps, } from "./QuestionPrompt";
+export { QuestionPrompt, QuestionPromptRender } from "./QuestionPrompt";
+export type { ScrollableListProps, ScrollableListRenderProps, } from "./ScrollableList";
+export { ScrollableList, ScrollableListRender } from "./ScrollableList";
+export type { ScrollableListTheme } from "./ScrollableList/ScrollableList.theme";
+export { useScrollableListTheme } from "./ScrollableList/ScrollableList.theme";
+export type { ScrollableViewProps, ScrollableViewRenderProps, ScrollableViewState, ScrollableViewTheme, } from "./ScrollableView";
+export { ScrollableView, ScrollableViewRender, useScrollableViewTheme, } from "./ScrollableView";
+export type { ScrollbarProps, ScrollbarRenderProps } from "./Scrollbar";
+export { Scrollbar, ScrollbarRender } from "./Scrollbar";
+export type { ScrollbarTheme } from "./Scrollbar/Scrollbar.theme";
+export { useScrollbarTheme } from "./Scrollbar/Scrollbar.theme";
+export type { SearchInputProps, SearchInputRenderProps } from "./SearchInput";
+export { SearchInput, SearchInputRender } from "./SearchInput";
+export type { SearchInputTheme } from "./SearchInput/SearchInput.theme";
+export { useSearchInputTheme } from "./SearchInput/SearchInput.theme";
+export type { SeparatorProps, SeparatorRenderProps, SeparatorTheme, } from "./Separator";
+export { Separator, SeparatorRender, useSeparatorTheme } from "./Separator";
+export type { StatusBarProps, StatusBarRenderProps } from "./StatusBar";
+export { StatusBar, StatusBarRender } from "./StatusBar";
+export type { StatusBarTheme, StatusInfo, } from "./StatusBar/StatusBar.theme";
+export { useStatusBarTheme } from "./StatusBar/StatusBar.theme";
+export type { TextAreaInputProps } from "./TextAreaInput";
+export { TextAreaInput } from "./TextAreaInput";
+export { useTextAreaInputTheme } from "./TextAreaInput/TextAreaInput.theme";
+export { TitleIcon } from "./TitleIcon";
+export type { TitleIconTheme } from "./TitleIcon/TitleIcon.theme";
+export { useTitleIconTheme } from "./TitleIcon/TitleIcon.theme";

package/dist/hooks/index.d.ts

@@ -0,0 +1,27 @@
+export type { BreakpointState } from "./useBreakpoint";
+export { useBreakpoint } from "./useBreakpoint";
+export type { ChatMessage, ChatRun, ChatRunId, ChatRunsContextProviderProps, ChatRunsContextType, ChatStatus, CreateRunInit, MessageRole, UseChatState, } from "./useChat";
+export { ChatRunsContextProvider, useChat, useChatActions, useChatLifecycle, useChatRuns, useChatState, } from "./useChat";
+export type { ClientMessageOf, ClientMessageType, DaemonCommandMap, DaemonCommandType, DaemonContextProviderProps, DaemonContextValue, DaemonMessageListener, DaemonMessageOf, DaemonMessageType, } from "./useDaemon";
+export { DaemonContextProvider, useDaemon, useDaemonCommand, useDaemonSubscription, } from "./useDaemon";
+export type { DebugRenderColors, DebugRenderOptions, DebugRenderRef, RenderReason, } from "./useDebugRender";
+export { useDebugRender } from "./useDebugRender";
+export type { LogEntry, LogLevel, LogStore, LogStoreListener, LogsState, } from "./useLogs";
+export { createLogStore, useLogs } from "./useLogs";
+export type { ModalContextProviderProps, ModalContextType, ModalControls, ModalEntry, ModalId, } from "./useModal";
+export { ModalContextProvider, useModal } from "./useModal";
+export type { MouseEvent, MouseEventKind, MouseModifiers } from "./useMouse";
+export { isInsideRef, isMouseEscape, parseMouseEvents } from "./useMouse";
+export type { UseMouseClickOptions } from "./useMouseClick";
+export { useMouseClick } from "./useMouseClick";
+export type { UseMouseHoverOptions, UseMouseHoverResult, } from "./useMouseHover";
+export { useMouseHover } from "./useMouseHover";
+export type { MouseScrollDirection, MouseScrollEvent, UseMouseWheelScrollOptions, } from "./useMouseWheelScroll";
+export { useMouseWheelScroll } from "./useMouseWheelScroll";
+export type { RegionDimensions, RegionHandle, RegionOptions, RegionPosition, } from "./useRegion";
+export { useRegion } from "./useRegion";
+export { TOOL_SPINNER_FRAMES, TOOL_SPINNER_INTERVAL_MS, useToolSpinner, } from "./useToolSpinner";
+export type { UserConfig, UserConfigContextProviderProps, UserConfigContextType, } from "./useUserConfig";
+export { DEFAULT_USER_CONFIG, resolveDefaultConfigFilePath, UserConfigContextProvider, useUserConfig, } from "./useUserConfig";
+export type { UseWebSocketConfig, WebSocketState, WebSocketStatus, } from "./useWebSocket";
+export { useWebSocket } from "./useWebSocket";

package/dist/hooks/useBreakpoint/index.d.ts

@@ -0,0 +1,2 @@
+export { useBreakpoint } from "./useBreakpoint";
+export type { BreakpointState } from "./useBreakpoint.types";

package/dist/hooks/useBreakpoint/useBreakpoint.d.ts

@@ -0,0 +1,15 @@
+import type { BreakpointState } from "./useBreakpoint.types";
+/**
+ * Track terminal dimensions and provide breakpoint query helpers.
+ *
+ * Uses Ink's `useStdout()` to listen for resize events and resolves the
+ * active breakpoint from the theme's `breakpoints` tokens (mobile-first).
+ *
+ * @example
+ * ```tsx
+ * const { breakpoint, above, below } = useBreakpoint();
+ * if (below("md")) return <CompactView />;
+ * return <FullView />;
+ * ```
+ */
+export declare function useBreakpoint(): BreakpointState;

package/dist/hooks/useBreakpoint/useBreakpoint.types.d.ts

@@ -0,0 +1,18 @@
+import type { BreakpointName } from "../../Theme";
+/** Result returned by `useBreakpoint()`. */
+export interface BreakpointState {
+    /** Current terminal width in columns. */
+    readonly columns: number;
+    /** Current terminal height in rows. */
+    readonly rows: number;
+    /** The active breakpoint name based on terminal width. */
+    readonly breakpoint: BreakpointName;
+    /** Resolved container width for the active breakpoint. `undefined` means full width. */
+    readonly containerWidth: number | undefined;
+    /** True when terminal width is at least the given breakpoint. */
+    readonly above: (name: BreakpointName) => boolean;
+    /** True when terminal width is below the given breakpoint. */
+    readonly below: (name: BreakpointName) => boolean;
+    /** True when terminal width is between two breakpoints (inclusive lower, exclusive upper). */
+    readonly between: (lower: BreakpointName, upper: BreakpointName) => boolean;
+}

package/dist/hooks/useChat/index.d.ts

@@ -0,0 +1,22 @@
+export { useChat } from "./useChat";
+export { ChatRunsContextProvider } from "./useChat.context";
+export type { ChatMessage, ChatRun, ChatRunId, ChatRunsContextProviderProps, ChatRunsContextType, ChatStatus, CreateRunInit, MessageRole, MessageSegment, PendingChatExecution, PendingPermissionRequest, PendingQuestionRequest, PersistedRunMeta, RunOverview, RunStatus, RunSummary, UseChatState, } from "./useChat.types";
+export type { UseChatActionsResult } from "./useChatActions";
+export { useChatActions } from "./useChatActions";
+export type { ChatInputRequestResult } from "./useChatInputRequests";
+export { useChatInputRequests } from "./useChatInputRequests";
+export type { UseChatLifecycleResult } from "./useChatLifecycle";
+export { useChatLifecycle } from "./useChatLifecycle";
+export type { ChatPermissionRequestResult } from "./useChatPermissionRequests";
+export { useChatPermissionRequests } from "./useChatPermissionRequests";
+export type { ChatQuestionRequestResult } from "./useChatQuestionRequests";
+export { useChatQuestionRequests } from "./useChatQuestionRequests";
+export type { ChatRunLifecycle } from "./useChatRunLifecycle";
+export { useChatRunLifecycle } from "./useChatRunLifecycle";
+export { useChatRuns } from "./useChatRuns";
+export type { UseChatStateResult } from "./useChatState";
+export { useChatState } from "./useChatState";
+export type { ChatSteeringResult } from "./useChatSteering";
+export { useChatSteering } from "./useChatSteering";
+export type { PersistedRunListResult } from "./usePersistedRunList";
+export { usePersistedRunList } from "./usePersistedRunList";

package/dist/hooks/useChat/useChat.context.d.ts

@@ -0,0 +1,7 @@
+import type { ChatRunsContextProviderProps, ChatRunsStore } from "./useChat.types";
+export declare const ChatRunsContext: import("react").Context<ChatRunsStore | null>;
+/**
+ * Provide global chat-run state and compose the hooks that own each logical
+ * block of run behavior.
+ */
+export declare function ChatRunsContextProvider({ children, }: ChatRunsContextProviderProps): React.ReactElement;

package/dist/hooks/useChat/useChat.d.ts

@@ -0,0 +1,11 @@
+import type { ChatRunId, UseChatState } from "./useChat.types";
+/**
+ * Bind a view to a single chat run.
+ *
+ * When no matching run exists, the returned view exposes empty values;
+ * `startStrategy` is still functional and will create a new run.
+ *
+ * Must be called inside both a `<DaemonContextProvider>` and a
+ * `<ChatRunsContextProvider>`.
+ */
+export declare function useChat(chatRunId: ChatRunId | null): UseChatState;

package/dist/hooks/useChat/useChat.types.d.ts

@@ -0,0 +1,209 @@
+import type { AgentStreamEventWire, ContextUsageWire, ConversationInputWire, ConversationRecordWire, ConversationRetentionEventWire, RequestPermissionMessage, RequestQuestionMessage, RunOverview, RunStatus, RunSummary, Usage } from "@comma-agents/daemon";
+import type { Dispatch, SetStateAction } from "react";
+import type { WebSocketStatus } from "../useWebSocket/useWebSocket.types";
+/** Stable identifier shared by the TUI and daemon for the run's life. */
+export type ChatRunId = string;
+/** Sender role for display purposes. */
+export type MessageRole = "user" | "agent" | "system";
+/** Narrow the daemon's stream event union to a specific event kind. */
+type StreamEventOf<EventKind extends AgentStreamEventWire["type"]> = Extract<AgentStreamEventWire, {
+    type: EventKind;
+}>;
+/**
+ * A single segment within an agent's message body.
+ *
+ * Segments accumulate the daemon's `agent_streaming` wire events
+ * (`AgentStreamEventWire`) into render state: ordered, typed body parts the
+ * UI can render with the right affordance (collapsed tool call panel, dimmed
+ * thinking block, code-formatted result, etc.). `tool-call` and `tool-result`
+ * segments are the wire events verbatim; `text` and `thinking` segments add a
+ * `streaming` flag because consecutive deltas are folded into one segment
+ * that closes when the stream ends.
+ */
+export type MessageSegment = (StreamEventOf<"text"> & {
+    /** Whether this text segment is still receiving streaming tokens. */
+    readonly streaming: boolean;
+}) | StreamEventOf<"tool-call"> | StreamEventOf<"tool-result"> | StreamEventOf<"retention"> | (StreamEventOf<"thinking"> & {
+    /** Whether the reasoning stream is still receiving tokens. */
+    readonly streaming: boolean;
+});
+/** A single message in the chat log. */
+export interface ChatMessage {
+    readonly id: string;
+    readonly role: MessageRole;
+    /** Agent name (or "you" for user, "system" for system messages). */
+    readonly sender: string;
+    /**
+     * Full accumulated text for the message.
+     *
+     * For `user` and `system` messages this is the only body. For `agent`
+     * messages this is a flattened concatenation of all `text`-type segments,
+     * preserved primarily for backwards compatibility with consumers that
+     * don't yet understand `segments`.
+     */
+    readonly text: string;
+    /**
+     * Ordered, typed body parts for richer rendering (tool calls, reasoning,
+     * MCP, etc.). When omitted, consumers should fall back to `text`.
+     */
+    readonly segments?: readonly MessageSegment[];
+    /** Whether this message is still receiving streaming tokens. */
+    readonly streaming: boolean;
+    /** Tool call id of the `launch_strategy` invocation that spawned this message. */
+    readonly parentToolCallId?: string;
+    /** Provider/model identifier used for this agent call. */
+    readonly model?: string;
+    /** Maximum model context tokens, when known. */
+    readonly contextWindow?: number;
+    /** Final token usage reported by the model. */
+    readonly usage?: Usage;
+    /** Final model-step context usage. */
+    readonly contextUsage?: ContextUsageWire;
+    /** Completion timestamp for finished agent calls. */
+    readonly completedAt?: number;
+    readonly timestamp: number;
+}
+/**
+ * UI lifecycle status for a chat run.
+ *
+ * Extends the daemon's `RunStatus` union (`pending | running | completed |
+ * error | cancelled`) with TUI-only states that the daemon does not model:
+ * - `idle` — run exists but hasn't started a run yet.
+ * - `waiting_input` — derived from an unanswered `request_input`.
+ * - `waiting_permission` — derived from an unanswered `request_permission`.
+ * - `waiting_question` — derived from an unanswered `request_question`.
+ */
+export type ChatStatus = RunStatus | "idle" | "waiting_input" | "waiting_permission" | "waiting_question";
+/** User-initiated execution waiting for daemon preparation or execution. */
+export interface PendingChatExecution {
+    readonly mode: "start" | "continue";
+    readonly input: string | null;
+    /** Request id for the currently pending prepare/start/continue command. */
+    readonly requestId: string;
+    /** Locally queued user message for a continuation, if one was rendered. */
+    readonly queuedMessageId?: string;
+}
+/** A single chat run's state — 1:1 with a strategy run. */
+export interface ChatRun {
+    /** Stable run identifier and map key. */
+    readonly id: ChatRunId;
+    /** Run id assigned by the daemon after `strategy_started`. */
+    readonly daemonRunId: string | null;
+    /** Human-readable label (strategy name or file path). */
+    readonly label: string;
+    /** Path to the strategy file being run. */
+    readonly strategyPath: string | null;
+    /**
+     * Name of the strategy used for this run, when known. Runs started via
+     * `startStrategy` learn this from `strategy_started`. May be null until the
+     * daemon reports it.
+     */
+    readonly strategyName: string | null;
+    /** UI lifecycle status (see `ChatStatus`). */
+    readonly status: ChatStatus;
+    /** Mirror of the daemon's `RunStatus` for this run, if known. */
+    readonly runStatus: RunStatus | null;
+    /** Latest error message, or null. */
+    readonly error: string | null;
+    /** Execution waiting for daemon preparation or execution. */
+    readonly pendingExecution: PendingChatExecution | null;
+    /** Agent currently waiting for user input, or null. */
+    readonly pendingInputAgent: string | null;
+    /**
+     * Queue of `request_permission` messages awaiting user decisions, stored
+     * as received. The head (index 0) is the currently-displayed prompt; its
+     * `requestId` is echoed back in the `permission_decision` reply.
+     */
+    readonly pendingPermissionRequests: readonly RequestPermissionMessage[];
+    /**
+     * Queue of `request_question` messages awaiting user answers, stored as
+     * received. The head's `requestId` is echoed back in `question_response`.
+     */
+    readonly pendingQuestionRequests: readonly RequestQuestionMessage[];
+    /** Accumulated messages for this run. */
+    readonly messages: readonly ChatMessage[];
+    /** Stack of active `launch_strategy` tool-call ids for nested strategy output. */
+    readonly activeLaunchStrategyIds: readonly string[];
+    /** Creation timestamp (ms since epoch). */
+    readonly createdAt: number;
+    /** Last-updated timestamp (ms since epoch). */
+    readonly updatedAt: number;
+}
+/** Pending daemon permission request rendered by the chat UI. */
+export type PendingPermissionRequest = RequestPermissionMessage;
+/** Pending daemon question request rendered by the chat UI. */
+export type PendingQuestionRequest = RequestQuestionMessage;
+/** @internal Shared state contracts used by the chat run operation hooks. */
+export type ChatRunsState = ReadonlyMap<ChatRunId, ChatRun>;
+/** @internal Setter for the provider-owned chat run collection. */
+export type SetChatRuns = Dispatch<SetStateAction<ChatRunsState>>;
+/** Initial overrides accepted by `createChatRun`. */
+export interface CreateRunInit {
+    /** Human-readable label. Defaults to "New run". */
+    readonly label?: string;
+    /** Strategy file path, if known at creation time. */
+    readonly strategyPath?: string;
+}
+/** Lightweight metadata for a daemon-persisted run. */
+export type PersistedRunMeta = RunOverview;
+export type PersistedConversationRecord = ConversationRecordWire;
+export type PersistedConversationRetentionEvent = ConversationRetentionEventWire;
+export type PersistedConversationInput = ConversationInputWire;
+/** Value exposed by `ChatRunsContext`. */
+export interface ChatRunsContextType {
+    /** All runs keyed by their stable run id. */
+    readonly chatRuns: ReadonlyMap<ChatRunId, ChatRun>;
+}
+/** Internal writable store shared by chat run domain hooks. */
+export interface ChatRunsStore extends ChatRunsContextType {
+    readonly setChatRuns: SetChatRuns;
+}
+/** Props for the `ChatRunsContextProvider` component. */
+export interface ChatRunsContextProviderProps {
+    /** Child elements that can consume chat run state. */
+    readonly children: React.ReactNode;
+}
+/**
+ * Value returned by `useChat()` — a view of a single run with bound action methods.
+ *
+ * When the provided `chatRunId` doesn't match any run, all fields return
+ * empty/null values and action methods other than `startStrategy` are no-ops.
+ */
+export interface UseChatState {
+    /** Id of the run this view is bound to, or null. */
+    readonly chatRunId: ChatRunId | null;
+    readonly messages: readonly ChatMessage[];
+    readonly status: ChatStatus;
+    readonly error: string | null;
+    readonly pendingInputAgent: string | null;
+    /** Name of the strategy that produced this run, if known. */
+    readonly strategyName: string | null;
+    /** Strategy file path, if known. */
+    readonly strategyPath: string | null;
+    /** Current pending permission request (head of queue), or null. */
+    readonly pendingPermissionRequest: RequestPermissionMessage | null;
+    /** Current pending question request (head of queue), or null. */
+    readonly pendingQuestionRequest: RequestQuestionMessage | null;
+    /** Alias for `daemonRunId` — preserved for back-compatibility. */
+    readonly runId: string | null;
+    /** Current daemon WebSocket connection status. */
+    readonly connectionStatus: WebSocketStatus;
+    /** Create a new run and start a strategy on it. Returns the stable run id. */
+    readonly startStrategy: (strategyPath: string, input?: string, cwd?: string, manifestPath?: string) => ChatRunId;
+    /** Send user input to the bound run. No-op if no run or no pending input. */
+    readonly sendInput: (text: string) => void;
+    /**
+     * Queue a steering message for the bound run. No-op unless the run is
+     * live and running/pending.
+     */
+    readonly sendSteer: (text: string) => void;
+    /** Resolve the pending permission request for the bound run. */
+    readonly sendPermissionDecision: (decision: "allow" | "deny" | "allow-session" | "deny-session") => void;
+    /** Resolve the pending question request for the bound run. */
+    readonly sendQuestionResponse: (response: string) => void;
+    /** Clear the bound run's UI projection. No-op if no run. */
+    readonly reset: () => void;
+    /** Send `stop_run` for the bound run. No-op if no run is active. */
+    readonly stop: () => void;
+}
+export type { RunOverview, RunStatus, RunSummary };

package/dist/hooks/useChat/useChat.utils.d.ts

@@ -0,0 +1,18 @@
+import type { ChatMessage, ChatRun, ChatRunId, CreateRunInit, PersistedConversationInput, PersistedConversationRecord, PersistedConversationRetentionEvent } from "./useChat.types";
+/** Construct a fresh local chat run in the idle state. */
+export declare function createInitialChatRun(chatRunId: ChatRunId, init: CreateRunInit): ChatRun;
+/** Return the innermost active spawned-strategy tool-call id for a run. */
+export declare function getActiveLaunchStrategyId(chatRun: ChatRun): string | undefined;
+/** Create an opaque id for a TUI-local chat message. */
+export declare function createLocalChatMessageId(chatRunId: ChatRunId): string;
+/**
+ * Project daemon conversation records into chat messages for display.
+ *
+ * Human inputs come from `inputs` (the genuine run-start / continuation
+ * prompts), each anchored before the first agent record of its segment. A
+ * record's own `userMessage` is the input fed *into* that agent — which for a
+ * downstream agent is the upstream agent's output — so it is intentionally not
+ * rendered, to mirror the live (non-rehydrated) transcript and avoid duplicate,
+ * mislabeled bubbles.
+ */
+export declare function conversationRecordsToChatMessages(chatRunId: ChatRunId, records: readonly PersistedConversationRecord[], retentionEvents?: readonly PersistedConversationRetentionEvent[], inputs?: readonly PersistedConversationInput[]): readonly ChatMessage[];

package/dist/hooks/useChat/useChatActions.d.ts

@@ -0,0 +1,10 @@
+import type { ChatRunId } from "./useChat.types";
+export interface UseChatActionsResult {
+    readonly sendInput: (text: string) => void;
+    readonly sendSteer: (text: string) => void;
+    readonly sendPermissionDecision: (decision: "allow" | "deny" | "allow-session" | "deny-session") => void;
+    readonly sendQuestionResponse: (response: string) => void;
+    readonly reset: () => void;
+    readonly stop: () => void;
+}
+export declare function useChatActions(chatRunId: ChatRunId | null): UseChatActionsResult;

package/dist/hooks/useChat/useChatAgentMessages/index.d.ts

@@ -0,0 +1 @@
+export { useChatAgentMessages } from "./useChatAgentMessages";

package/dist/hooks/useChat/useChatAgentMessages/useChatAgentMessages.d.ts

@@ -0,0 +1,2 @@
+/** Project streamed and completed agent output into local chat messages. */
+export declare function useChatAgentMessages(): void;

package/dist/hooks/useChat/useChatInputRequests/index.d.ts

@@ -0,0 +1,2 @@
+export { useChatInputRequests } from "./useChatInputRequests";
+export type { ChatInputRequestResult } from "./useChatInputRequests.types";

package/dist/hooks/useChat/useChatInputRequests/useChatInputRequests.d.ts

@@ -0,0 +1,3 @@
+import type { ChatInputRequestResult } from "./useChatInputRequests.types";
+/** Submit user input for a pending daemon input request. */
+export declare function useChatInputRequests(subscribeToDaemon?: boolean): ChatInputRequestResult;

package/dist/hooks/useChat/useChatInputRequests/useChatInputRequests.types.d.ts

@@ -0,0 +1,4 @@
+import type { ChatRunId } from "../useChat.types";
+export interface ChatInputRequestResult {
+    readonly sendInput: (chatRunId: ChatRunId, text: string) => void;
+}

package/dist/hooks/useChat/useChatLifecycle.d.ts

@@ -0,0 +1,5 @@
+import type { ChatRunId } from "./useChat.types";
+export interface UseChatLifecycleResult {
+    readonly startStrategy: (strategyPath: string, input?: string, cwd?: string, manifestPath?: string) => ChatRunId;
+}
+export declare function useChatLifecycle(): UseChatLifecycleResult;

package/dist/hooks/useChat/useChatPermissionRequests/index.d.ts

@@ -0,0 +1,2 @@
+export { useChatPermissionRequests } from "./useChatPermissionRequests";
+export type { ChatPermissionRequestResult } from "./useChatPermissionRequests.types";

package/dist/hooks/useChat/useChatPermissionRequests/useChatPermissionRequestSubscriptions.d.ts

@@ -0,0 +1,2 @@
+/** Project daemon permission requests into local chat runs. */
+export declare function useChatPermissionRequestSubscriptions(): void;

package/dist/hooks/useChat/useChatPermissionRequests/useChatPermissionRequests.d.ts

@@ -0,0 +1,3 @@
+import type { ChatPermissionRequestResult } from "./useChatPermissionRequests.types";
+/** Submit decisions for pending daemon permission requests. */
+export declare function useChatPermissionRequests(): ChatPermissionRequestResult;

package/dist/hooks/useChat/useChatPermissionRequests/useChatPermissionRequests.types.d.ts

@@ -0,0 +1,4 @@
+import type { ChatRunId } from "../useChat.types";
+export interface ChatPermissionRequestResult {
+    readonly sendPermissionDecision: (chatRunId: ChatRunId, decision: "allow" | "deny" | "allow-session" | "deny-session") => void;
+}

package/dist/hooks/useChat/useChatQuestionRequests/index.d.ts

@@ -0,0 +1,2 @@
+export { useChatQuestionRequests } from "./useChatQuestionRequests";
+export type { ChatQuestionRequestResult } from "./useChatQuestionRequests.types";

package/dist/hooks/useChat/useChatQuestionRequests/useChatQuestionRequestSubscriptions.d.ts

@@ -0,0 +1,2 @@
+/** Project daemon questions into local chat runs. */
+export declare function useChatQuestionRequestSubscriptions(): void;

package/dist/hooks/useChat/useChatQuestionRequests/useChatQuestionRequests.d.ts

@@ -0,0 +1,3 @@
+import type { ChatQuestionRequestResult } from "./useChatQuestionRequests.types";
+/** Submit responses for pending daemon questions. */
+export declare function useChatQuestionRequests(): ChatQuestionRequestResult;

package/dist/hooks/useChat/useChatQuestionRequests/useChatQuestionRequests.types.d.ts

@@ -0,0 +1,4 @@
+import type { ChatRunId } from "../useChat.types";
+export interface ChatQuestionRequestResult {
+    readonly sendQuestionResponse: (chatRunId: ChatRunId, response: string) => void;
+}

package/dist/hooks/useChat/useChatRunLifecycle/index.d.ts

@@ -0,0 +1,2 @@
+export { useChatRunLifecycle } from "./useChatRunLifecycle";
+export type { ChatRunLifecycle } from "./useChatRunLifecycle.types";

package/dist/hooks/useChat/useChatRunLifecycle/useChatRunLifecycle.d.ts

@@ -0,0 +1,3 @@
+import type { ChatRunLifecycle } from "./useChatRunLifecycle.types";
+/** Own commands initiated by the user and local run collection management. */
+export declare function useChatRunLifecycle(): ChatRunLifecycle;

package/dist/hooks/useChat/useChatRunLifecycle/useChatRunLifecycle.types.d.ts

@@ -0,0 +1,11 @@
+import type { DiscoveredStrategy } from "@comma-agents/core";
+import type { ChatRunId, PersistedRunMeta } from "../useChat.types";
+export interface ChatRunLifecycle {
+    readonly startStrategy: (strategyPath: string, input?: string, cwd?: string, manifestPath?: string) => ChatRunId;
+    readonly continueRun: (chatRunId: ChatRunId, strategy: DiscoveredStrategy, input: string) => void;
+    readonly loadPersistedRun: (meta: PersistedRunMeta) => ChatRunId;
+    readonly stopChatRun: (chatRunId: ChatRunId) => void;
+    readonly resetChatRun: (chatRunId: ChatRunId) => void;
+    readonly removeChatRun: (chatRunId: ChatRunId) => void;
+    readonly clearAllChatRuns: () => void;
+}

package/dist/hooks/useChat/useChatRunLifecycle/useChatRunLifecycleSubscriptions.d.ts

@@ -0,0 +1,2 @@
+/** Project daemon run lifecycle events into local chat runs. */
+export declare function useChatRunLifecycleSubscriptions(): void;

package/dist/hooks/useChat/useChatRunStore/index.d.ts

@@ -0,0 +1 @@
+export { useChatRunStore } from "./useChatRunStore";

package/dist/hooks/useChat/useChatRunStore/useChatRunStore.d.ts

@@ -0,0 +1,3 @@
+import type { ChatRunsStore } from "../useChat.types";
+/** Access the internal writable chat run store from a chat domain hook. */
+export declare function useChatRunStore(): ChatRunsStore;

package/dist/hooks/useChat/useChatRuns.d.ts

@@ -0,0 +1,10 @@
+import type { ChatRunsContextType } from "./useChat.types";
+/**
+ * Access shared chat run state.
+ *
+ * Use this when a component needs awareness of multiple runs at once
+ * (e.g. a run switcher). For single-run views, prefer `useChat()`.
+ *
+ * Must be called inside a `<ChatRunsContextProvider>`.
+ */
+export declare function useChatRuns(): ChatRunsContextType;

package/dist/hooks/useChat/useChatState.d.ts

@@ -0,0 +1,17 @@
+import type { RequestPermissionMessage, RequestQuestionMessage } from "@comma-agents/daemon";
+import type { WebSocketStatus } from "../useWebSocket/useWebSocket.types";
+import type { ChatMessage, ChatRunId, ChatStatus } from "./useChat.types";
+export interface UseChatStateResult {
+    readonly chatRunId: ChatRunId | null;
+    readonly messages: readonly ChatMessage[];
+    readonly status: ChatStatus;
+    readonly error: string | null;
+    readonly pendingInputAgent: string | null;
+    readonly strategyName: string | null;
+    readonly strategyPath: string | null;
+    readonly pendingPermissionRequest: RequestPermissionMessage | null;
+    readonly pendingQuestionRequest: RequestQuestionMessage | null;
+    readonly runId: string | null;
+    readonly connectionStatus: WebSocketStatus;
+}
+export declare function useChatState(chatRunId: ChatRunId | null): UseChatStateResult;

package/dist/hooks/useChat/useChatSteering/index.d.ts

@@ -0,0 +1,2 @@
+export { useChatSteering } from "./useChatSteering";
+export type { ChatSteeringResult } from "./useChatSteering.types";

package/dist/hooks/useChat/useChatSteering/useChatSteering.d.ts

@@ -0,0 +1,3 @@
+import type { ChatSteeringResult } from "./useChatSteering.types";
+/** Send steering messages to live chat runs. */
+export declare function useChatSteering(subscribeToDaemon?: boolean): ChatSteeringResult;

package/dist/hooks/useChat/useChatSteering/useChatSteering.types.d.ts

@@ -0,0 +1,4 @@
+import type { ChatRunId } from "../useChat.types";
+export interface ChatSteeringResult {
+    readonly sendSteer: (chatRunId: ChatRunId, text: string) => void;
+}

package/dist/hooks/useChat/useChatStepMessages/index.d.ts

@@ -0,0 +1 @@
+export { useChatStepMessages } from "./useChatStepMessages";

package/dist/hooks/useChat/useChatStepMessages/useChatStepMessages.d.ts

@@ -0,0 +1,2 @@
+/** Project daemon step lifecycle events into system chat messages. */
+export declare function useChatStepMessages(): void;

package/dist/hooks/useChat/usePersistedRunList/index.d.ts

@@ -0,0 +1,2 @@
+export { usePersistedRunList } from "./usePersistedRunList";
+export type { PersistedRunListResult } from "./usePersistedRunList.types";

package/dist/hooks/useChat/usePersistedRunList/usePersistedRunList.d.ts

@@ -0,0 +1,3 @@
+import type { PersistedRunListResult } from "./usePersistedRunList.types";
+/** Pair persisted run list requests with daemon run list results. */
+export declare function usePersistedRunList(): PersistedRunListResult;

package/dist/hooks/useChat/usePersistedRunList/usePersistedRunList.types.d.ts

@@ -0,0 +1,5 @@
+import type { RunOverview } from "@comma-agents/daemon";
+export interface PersistedRunListResult {
+    readonly persistedRuns: readonly RunOverview[];
+    readonly fetchPersistedRuns: (cwd?: string) => void;
+}

package/dist/hooks/useDaemon/index.d.ts

@@ -0,0 +1,6 @@
+export { useDaemon } from "./useDaemon";
+export { DaemonContextProvider } from "./useDaemon.context";
+export type { DaemonContextProviderProps, DaemonContextValue, } from "./useDaemon.types";
+export type { DaemonCommandMap, DaemonCommandType, } from "./useDaemonCommand";
+export { useDaemonCommand } from "./useDaemonCommand";
+export { useDaemonSubscription } from "./useDaemonSubscription";

package/dist/hooks/useDaemon/useDaemon.context.d.ts

@@ -0,0 +1,18 @@
+import type { DaemonContextProviderProps, DaemonContextValue } from "./useDaemon.types";
+export declare const DaemonContext: import("react").Context<DaemonContextValue | null>;
+/**
+ * Provides a shared WebSocket connection to the daemon.
+ *
+ * Connects eagerly on mount via `useWebSocket`. Incoming daemon messages
+ * are validated against the DaemonMessage Zod union and dispatched to
+ * listeners registered via `ctx.on(type, callback)`.
+ *
+ * @param props - Provider configuration including the daemon WebSocket URL.
+ * @example
+ * ```tsx
+ * <DaemonContextProvider url="ws://localhost:7422/ws">
+ *   <App />
+ * </DaemonContextProvider>
+ * ```
+ */
+export declare function DaemonContextProvider({ url, children, }: DaemonContextProviderProps): import("react/jsx-runtime").JSX.Element;