@qilin-agent/client-ui-conversation 0.0.0-stage → 3.1.4

package/lib/types/client/queue/QueueDock.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { ImageAttachmentRef } from '@qilin-agent/attachment';
+import type { PropsLocale, PropsRuntime } from '@qilin-agent/client-ui-slots';
+import type { QueueAction } from '@qilin-agent/api-session-controller/types';
+import type { MessageId } from '@qilin-agent/llm/brand';
+/** Queue operations injected by the session-scoped registration. */
+export interface QueueDockInjected {
+    updateQueue: (itemId: MessageId, action: QueueAction) => Promise<void>;
+    notify: (level: 'info' | 'error', text: string) => void;
+    /** Resolve one durable queued image into a session-scoped browser URL. */
+    loadImage: (attachment: ImageAttachmentRef) => Promise<string>;
+}
+/** Full props of a dock entry: InputZone owner share + session standard kit + global seat + the locale seat. */
+export type QueueDockProps = PropsRuntime<'conversation.input.dock'> & QueueDockInjected & PropsLocale<'conversation'>;
+/**
+ * Queue strip: one item renders directly; multiple items default to a
+ * collapsible count header; an empty queue renders nothing. Local submissions
+ * show sending status and disabled actions until their Host queue rows arrive.
+ */
+export declare function QueueDock({ useSession, useProjection, updateQueue, notify, loadImage, t }: QueueDockProps): import("react").JSX.Element | null;
+/** Registers queue actions backed by the session-scoped conversation service. */
+export declare const queueDockEntry: {
+    name: string;
+    inject: string[];
+    apply(ctx: Context): void;
+};
+//# sourceMappingURL=QueueDock.d.ts.map

package/lib/types/client/service.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Scope-addressed conversation send, cancel, and history orchestration.
+ *
+ * Scope addressing rides the cordis Service tracker: property access through
+ * `ctx.conversation` rebinds `this.ctx` to the caller's context, so methods
+ * read the session tag with `scopeOf`. Mutable state must remain reachable
+ * through one property read; assignment through the tracker proxy and `#`
+ * private fields bypass that rebinding.
+ */
+import { Service } from '@qilin-agent/kylin';
+import type { Context } from '@qilin-agent/kylin';
+import type { SessionFace } from '@qilin-agent/api-session-controller/client';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { SnapshotStore } from '@qilin-agent/client-store';
+import type { ComposerAttachment, DraftFileUpload } from './contract/slots.ts';
+import type { QueueAction } from '@qilin-agent/api-session-controller/types';
+import type { MessageId } from '@qilin-agent/llm/brand';
+import type { ComposerBlocks } from './contract/composer-blocks.ts';
+import type { DraftAttachmentId, DraftAttachmentSerializationResult, SessionInputResolver, SubmitOutcome } from './contract/input.ts';
+import type { InputSubmitMode } from './contract/composer-submission.ts';
+/**
+ * The outward conversation face (`ctx.conversation`): the scope-addressed
+ * verbs and the input registry other plugins may reach — and exactly what a
+ * test fake must supply.
+ */
+export interface IConversation {
+    /** The per-session input machine registry (SessionInputResolver face). */
+    readonly input: SessionInputResolver;
+    /**
+     * The per-session composer-block registry: how a plugin the composer
+     * cannot import makes a session's input inert with its own reason.
+     */
+    readonly blocks: ComposerBlocks;
+    /**
+     * Send a prompt into the caller scope's session (queued turn).
+     * @param text - prompt text, sent verbatim as one text block.
+     * @returns completion; business failures reject (and land in promptError).
+     */
+    send(text: string): Promise<void>;
+    /**
+     * Apply one edit, remove, or Steer operation to a pending queue occurrence.
+     * @param itemId - agent-owned inbox occurrence identity.
+     * @param action - requested queue operation.
+     * @returns completion; converged QueueDock races resolve, while other failures reject.
+     */
+    updateQueue(itemId: MessageId, action: QueueAction): Promise<void>;
+    /**
+     * Cancel the scoped session's in-flight turn while preserving its pending Queue.
+     * @returns completion; failures reject as in send.
+     */
+    cancel(): Promise<void>;
+    /**
+     * Pull one older history page for the scoped session.
+     * @returns completion of the page pull.
+     */
+    loadOlder(): Promise<void>;
+}
+/** Unsupported browser-declared image type, localized by the UI boundary. */
+export declare class UnsupportedImageMediaTypeError extends Error {
+    /** Browser-declared MIME value, possibly empty. */
+    readonly mediaType: string;
+    /** @param mediaType - Browser-declared MIME value, possibly empty. */
+    constructor(mediaType: string);
+}
+/** Scope-addressed conversation service (root singleton, provided as `conversation`). */
+export declare class ConversationController extends Service implements IConversation {
+    /** The per-session input machine registry (SessionInputResolver face). */
+    readonly input: SessionInputResolver;
+    /** The per-session composer-block registry. */
+    readonly blocks: ComposerBlocks;
+    /** Live upload state per file-kind draft; images never appear here. */
+    readonly fileUploads: SnapshotStore<Record<string, DraftFileUpload>>;
+    private readonly draftAttachments;
+    private readonly fileUploadOperations;
+    private readonly pendingFileUploads;
+    private readonly fileUploadQueue;
+    private activeFileUploads;
+    private readonly maxConcurrentFileUploads;
+    /**
+     * @param ctx - owning root context (the plugin apply context; the service
+     * registers itself and follows that fiber's lifetime).
+     * @param config - carries the SessionInputResolver and composer-block registry
+     * constructed by the plugin apply (the same instances the slot inject
+     * factories close over).
+     */
+    constructor(ctx: Context, config: {
+        input: SessionInputResolver;
+        blocks: ComposerBlocks;
+        maxConcurrentFileUploads: number;
+    });
+    /**
+     * Send a prompt into the scoped session. Business failures also land in the
+     * session snapshot's promptError (object-layer state); the rejection here
+     * exists for caller choreography (the composer restores the draft on it).
+     * @param text - prompt text, sent verbatim as one text block.
+     */
+    send(text: string): Promise<void>;
+    /**
+     * Submit ordered draft attachments with text through one host admission. A local
+     * submission echo enters the session snapshot synchronously; serialization
+     * and the prompt round-trip start after the browser can paint it. On the
+     * echo's observed retirement seeds admitted image previews into the durable
+     * cache and removes every attachment from the draft registry. On failure,
+     * every attachment remains registered so the composer can restore it.
+     * @param session - target session.
+     * @param text - serialized prompt text.
+     * @param attachmentIds - ordered draft-local attachment ids.
+     * @param mode - queue or steer delivery selected by composer policy.
+     * @param signal - optional cancellation for the complete Host admission.
+     * @returns the Host admission outcome; local attachment preparation failures reject.
+     */
+    sendSession(session: SessionFace, text: string, attachmentIds: readonly DraftAttachmentId[], mode: InputSubmitMode, signal?: AbortSignal): Promise<SubmitOutcome>;
+    /**
+     * Create runtime-only draft attachments. Files whose browser MIME is an
+     * accepted image type become image drafts (object URL preview, bytes sent
+     * with the prompt); every other file becomes a file draft whose background
+     * upload starts immediately and remains owned by this service across Session
+     * navigation until completion or explicit removal.
+     * @param sessionId - target Agent-scope identity.
+     * @param files - browser files to register.
+     * @returns ordered draft descriptors.
+     */
+    createDrafts(sessionId: SessionId, files: readonly File[]): readonly ComposerAttachment[];
+    /**
+     * Restart one failed file upload.
+     * @param sessionId - target Agent-scope identity.
+     * @param id - draft attachment id whose upload previously failed.
+     */
+    retryFileUpload(sessionId: SessionId, id: DraftAttachmentId): void;
+    /**
+     * Stage carried file drafts again for a new Session.
+     * @param sessionId - target Agent-scope identity after a Workspace switch.
+     * @param ids - carried draft attachment ids.
+     */
+    rebindDraftFiles(sessionId: SessionId, ids: readonly DraftAttachmentId[]): void;
+    private beginFileUpload;
+    /** Start queued upload Workers until the configured concurrency is occupied. */
+    private pumpFileUploads;
+    /**
+     * Resolve ordered input-state ids to runtime-owned draft attachments.
+     * @param ids - draft attachment ids.
+     * @returns descriptors that remain live, in requested order.
+     */
+    resolveDraftAttachments(ids: readonly DraftAttachmentId[]): readonly ComposerAttachment[];
+    /**
+     * Serialize ordered draft attachments to command-submit wire payloads without
+     * sending or releasing them. Images are encoded; generic files cite receipts
+     * from their completed background uploads and never reread browser bytes.
+     * @param attachmentIds - ordered draft-local attachment ids.
+     * @returns wire payloads in id order.
+     */
+    serializeDraftAttachments(attachmentIds: readonly DraftAttachmentId[]): Promise<DraftAttachmentSerializationResult>;
+    /**
+     * Release one browser-owned draft attachment, aborting its active upload.
+     * @param id - draft attachment id.
+     */
+    releaseDraftAttachment(id: DraftAttachmentId): void;
+    /**
+     * Release a set of browser-owned draft attachments.
+     * @param attachments - descriptors to release.
+     */
+    releaseDraftAttachments(attachments: readonly ComposerAttachment[]): void;
+    /** Apply one operation to a pending queue occurrence. */
+    updateQueue(itemId: MessageId, action: QueueAction): Promise<void>;
+    /** Cancel the scoped session's in-flight turn while preserving Queue (failures land in promptError and reject, as in send). */
+    cancel(): Promise<void>;
+    /** Pull one older history page for the scoped Session. */
+    loadOlder(): Promise<void>;
+    /** Resolve the caller scope's session face or throw on root contexts. */
+    private scopedSession;
+    /** Read the caller's session scope tag via the sessions service; root contexts fail loud. */
+    private scopeId;
+    private requireSessions;
+    /**
+     * Settle one submission's draft attachments when its echo retires. Observed:
+     * each image leaves the registry, handing its preview URL to the durable
+     * image cache (seeded under the admitted reference so the transcript node
+     * renders immediately while the cache reads canonical bytes) or revoking it
+     * when the cache already holds that reference. Failed: nothing changes;
+     * the ids stay registered for the composer's rail restore.
+     */
+    private settleSubmittedAttachments;
+    /** Canonical base64 wire form of one browser image file. */
+    private encodeImage;
+}
+/**
+ * Whether a browser-declared MIME selects the image draft path.
+ * @param value - browser-declared MIME string from the picked file.
+ * @returns true when the platform supports previewing and uploading it as an image.
+ */
+export declare function isImageMediaType(value: string): boolean;
+//# sourceMappingURL=service.d.ts.map

package/lib/types/client/settings/ContentWidthRow.d.ts

@@ -0,0 +1,26 @@
+/**
+ * General Settings row for the transcript content width. The pill carries the
+ * persisted width — the word for the adaptive column clamp, otherwise the px
+ * value — and steps it by CONTENT_WIDTH_STEP. Reverting to the clamp is an
+ * explicit action, never a stepper bound.
+ */
+import type { SnapshotStore } from '@qilin-agent/client-store';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@qilin-agent/client-ui-slots';
+/** Registration-side preference face. */
+export interface ContentWidthRowInjected {
+    hooks: {
+        /** Persisted transcript width bound as useContentWidth. */
+        contentWidth: SnapshotStore<number>;
+    };
+    /** Persist a width, or {@link CONTENT_WIDTH_ADAPTIVE} to return to the adaptive clamp. */
+    setContentWidth: (px: number) => void;
+}
+/** Full Settings-row props. */
+export type ContentWidthRowProps = PropsRuntime<'settings.general.item'> & PropsLocale<'conversation'> & InjectFace<ContentWidthRowInjected>;
+/**
+ * Render the transcript width row.
+ * @param props - composed Settings slot props.
+ * @returns the preference row.
+ */
+export declare function ContentWidthRow({ t, useContentWidth, setContentWidth }: ContentWidthRowProps): import("react").JSX.Element;
+//# sourceMappingURL=ContentWidthRow.d.ts.map

package/lib/types/client/settings/EnterBehaviorRow.d.ts

@@ -0,0 +1,21 @@
+import type { SnapshotStore } from '@qilin-agent/client-store';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@qilin-agent/client-ui-slots';
+import type { BusyEnterBehavior } from '../contract/composer-submission.ts';
+/** Registration-side preference face. */
+export interface EnterBehaviorRowInjected {
+    hooks: {
+        /** Persisted busy-state preference bound as useBusyEnter. */
+        busyEnter: SnapshotStore<BusyEnterBehavior>;
+    };
+    /** Change the busy-state plain-Enter behavior. */
+    setBusyEnter: (behavior: BusyEnterBehavior) => void;
+}
+/** Full Settings-row props. */
+export type EnterBehaviorRowProps = PropsRuntime<'settings.general.item'> & PropsLocale<'conversation'> & InjectFace<EnterBehaviorRowInjected>;
+/**
+ * Render the busy-state Enter behavior selector.
+ * @param props - composed Settings slot props.
+ * @returns the preference row.
+ */
+export declare function EnterBehaviorRow({ useBusyEnter, setBusyEnter, t }: EnterBehaviorRowProps): import("react").JSX.Element;
+//# sourceMappingURL=EnterBehaviorRow.d.ts.map

package/lib/types/client/skeleton/ContextMeter.d.ts

@@ -0,0 +1,14 @@
+/** Composer context-occupancy meter: a ring and percentage below the card fed by the
+ * `contextPressure` projection, with a click-open panel of the heuristic
+ * `contextBreakdown` composition (system prompt, tools, conversation).
+ * Renders nothing until a provider reports both pressure and a route
+ * capacity. */
+import type { UseProjection } from '@qilin-agent/api-session-controller/client';
+import type { ComposerBarProps } from '../contract/slots.ts';
+export interface ContextMeterProps {
+    useProjection: UseProjection;
+    /** The owning bar's locale seat, passed down as a plain prop. */
+    t: ComposerBarProps['t'];
+}
+export declare function ContextMeter({ useProjection, t }: ContextMeterProps): import("react").JSX.Element | null;
+//# sourceMappingURL=ContextMeter.d.ts.map

package/lib/types/client/skeleton/ConversationContent.d.ts

@@ -0,0 +1,8 @@
+import type { ConversationContentProps } from '../contract/slots.ts';
+/**
+ * Render the shared Conversation body and its occurrence-selected local Components.
+ * @param props - Factory input, standard Session sources, and Conversation seats.
+ * @returns the Conversation view, Composer, and optional width controls.
+ */
+export declare function ConversationContent(props: ConversationContentProps): import("react").JSX.Element;
+//# sourceMappingURL=ConversationContent.d.ts.map

package/lib/types/client/skeleton/ConversationHeader.d.ts

@@ -0,0 +1,8 @@
+import type { ConversationHeaderProps } from '../contract/slots.ts';
+/**
+ * Keeps global navigation available before a Session exists.
+ * @param props - Optional Session sources and authorized header slots.
+ * @returns The persistent header with any selected Session's title and views.
+ */
+export declare function ConversationHeader({ sessionId, useSession, useConversation, renderSlot }: ConversationHeaderProps): import("react").JSX.Element;
+//# sourceMappingURL=ConversationHeader.d.ts.map

package/lib/types/client/skeleton/ConversationMainPanel.d.ts

@@ -0,0 +1,3 @@
+import type { ConversationSlotProps } from '../contract/slots.ts';
+export declare function ConversationMainPanel(props: ConversationSlotProps): import("react").JSX.Element;
+//# sourceMappingURL=ConversationMainPanel.d.ts.map

package/lib/types/client/skeleton/ConversationPanel.d.ts

@@ -0,0 +1,9 @@
+/** Root-scoped main occupant; Session binding belongs to its Conversation child. */
+import type { PropsRenderSlots, PropsRuntime } from '@qilin-agent/client-ui-slots';
+/**
+ * Render the Conversation with optional current-Session binding.
+ * @param props - main-slot inputs and the declared Conversation renderer.
+ * @returns the Conversation subtree.
+ */
+export declare function ConversationPanel({ renderSlot }: PropsRuntime<'main'> & PropsRenderSlots<'main.conversation'>): import("react").ReactNode;
+//# sourceMappingURL=ConversationPanel.d.ts.map

package/lib/types/client/skeleton/ConversationRoot.d.ts

@@ -0,0 +1,5 @@
+import type { ConversationSlotProps } from '../contract/slots.ts';
+/** Full props composed from the slot contract. */
+export type ConversationRootProps = ConversationSlotProps;
+export declare function ConversationRoot(props: ConversationRootProps): import("react").JSX.Element;
+//# sourceMappingURL=ConversationRoot.d.ts.map

package/lib/types/client/skeleton/ConversationSession.d.ts

@@ -0,0 +1,21 @@
+/** Strict per-session header/body content inserted into the resident conversation layout. */
+import type { ConversationSessionHeaderSlotProps, ConversationSessionSlotProps } from '../contract/slots.ts';
+/** Full props composed from the strict session body contract. */
+export type ConversationSessionProps = ConversationSessionSlotProps;
+/** Full props composed from the strict session header contract. */
+export type ConversationSessionHeaderProps = ConversationSessionHeaderSlotProps;
+/**
+ * Renders the Session-specific half of the resident header: breadcrumbs,
+ * Session actions, utilities, and the View tab strip.
+ * @param props - Session identity, parent-owned chrome visibility, view ledger, navigation, render, and locale shares.
+ * @returns the title row and, with more than one View, the tab strip.
+ */
+export declare function ConversationSessionHeader({ sessionId, hideChrome, useSessions, useConversationViews, useStore, renderSlot, open, selectView, t, }: ConversationSessionHeaderProps): import("react").JSX.Element;
+/**
+ * Renders the active Session view inside the resident scrollport and keeps
+ * the input draft mirrored while blank Hero chrome is visible.
+ * @param props - Strict Session input/store, view ledger, and render shares.
+ * @returns the active view area, or null while the Session remains blank.
+ */
+export declare function ConversationSession(props: ConversationSessionProps): import("react").JSX.Element;
+//# sourceMappingURL=ConversationSession.d.ts.map

package/lib/types/client/skeleton/ConversationWidthControls.d.ts

@@ -0,0 +1,14 @@
+import type { ConversationWidthControlsProps } from '../contract/slots.ts';
+/**
+ * Install the main Conversation width axis and render its drag handles.
+ *
+ * The width is the Host settings document's durable value, read through the
+ * injected content-width hook and written back through `setContentWidth`, so a
+ * drag and the Settings row share one source of truth. The preference is read
+ * through a ref, so a width change never rebuilds the measurement observer; the
+ * second effect republishes when it moves.
+ * @param props - Mounted Conversation body, presentation phase, and the durable width share.
+ * @returns two active-phase width handles, or no controls outside the active phase.
+ */
+export declare function ConversationWidthControls({ container, phase, useContentWidth, setContentWidth, }: ConversationWidthControlsProps): import("react").JSX.Element[] | null;
+//# sourceMappingURL=ConversationWidthControls.d.ts.map

package/lib/types/client/skeleton/DefaultConversationViews.d.ts

@@ -0,0 +1,9 @@
+import type { ConversationSessionSlotProps } from '../contract/slots.ts';
+/**
+ * Renders the active Session view inside the resident scrollport and keeps
+ * the input draft mirrored while blank Hero chrome is visible.
+ * @param props - Strict Session input/store, view ledger, and render shares.
+ * @returns the active view area, or null while the Session remains blank.
+ */
+export declare function DefaultConversationViews({ view, useSession, useConversation, useConversationViews, useInput, inputActions, useStore, actions, renderSlot, bindDraftMirror, openView, }: ConversationSessionSlotProps): import("react").JSX.Element | null;
+//# sourceMappingURL=DefaultConversationViews.d.ts.map

package/lib/types/client/skeleton/EmptyHero.d.ts

@@ -0,0 +1,49 @@
+import type { ReactNode, RefObject } from 'react';
+import type { ConversationContentProps } from '../contract/slots.ts';
+/** The owner's locale seat type, passed to hero chrome as a plain prop. */
+type HeroTranslate = ConversationContentProps['t'];
+/**
+ * Basename label for the workspace chip (the shared derivation);
+ * separator-only paths echo the raw cwd.
+ * @param cwd - workspace directory path (non-empty).
+ * @returns chip label.
+ */
+export declare function workspaceLabel(cwd: string): string;
+/**
+ * The workspace chip (folder + label + chevron), always interactive: before
+ * the first message the workspace stays switchable — picking another one
+ * moves the New Session flow to that workspace's blank session. Without a
+ * label the chip renders its placeholder state: closed folder + the
+ * "Choose workspace" call to action.
+ * @param props.label - chip label (see {@link workspaceLabel}); omitted → placeholder.
+ * @param props.menuOpen - menu expansion echo.
+ * @param props.onClick - menu toggle.
+ * @returns the chip button element.
+ */
+export declare function WorkspaceChip({ buttonRef, label, menuOpen, onClick, t }: {
+    buttonRef?: RefObject<HTMLButtonElement>;
+    label?: string | undefined;
+    menuOpen?: boolean;
+    onClick?: () => void;
+    t: HeroTranslate;
+}): import("react").JSX.Element;
+/** Hero chrome props. The workspace row rides the InputBar accessory hole, not here. */
+export interface HeroShellProps {
+    /** The owner's locale seat, passed down as a plain prop. */
+    t: HeroTranslate;
+    /** Authorized renderer for the hero brand-mark slot. */
+    renderSlot: ConversationContentProps['renderSlot'];
+    /** Overlay content after the stack (modals). */
+    children?: ReactNode;
+}
+/**
+ * Render the hero chrome (brand mark, greeting, tagline; no composer, no
+ * workspace row). The ambient wordmark behind the text is decoration: it carries
+ * the product name at a size that reads as background rather than a second
+ * headline, and it is hidden from the accessibility tree.
+ * @param props - see {@link HeroShellProps}.
+ * @returns the centered hero element tree.
+ */
+export declare function HeroShell({ t, renderSlot, children }: HeroShellProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=EmptyHero.d.ts.map

package/lib/types/client/skeleton/InputBar.d.ts

@@ -0,0 +1,18 @@
+/** The default composer body: the 'conversation.composer.bar' slot entry.
+ * Machine state arrives through the standard provide channel
+ * (useInput + inputActions); the keyboard/DOM command face and stop arrive
+ * through this entry's own inject, whose hooks compartment binds
+ * useNotices/useLexicon; layout-phase inputs (variant and placeholder) ride
+ * the owner props. Session facts
+ * (running/removed/promptError) are self-selected via useSession.
+ *
+ * The text surface is the shell-owned Lexical editor bound here through
+ * ComposerContentEditable; chips render as decorator portals, and the
+ * keymap registers submit/menu/paste gestures on the editor command layer.
+ * The no-session state renders the SAME div inert as the Workspace-picker
+ * trigger instead of a parallel tree.
+ */
+import type { ComposerBarProps } from '../contract/slots.ts';
+export type InputBarProps = ComposerBarProps;
+export declare const InputBar: import("react").MemoExoticComponent<({ useSession, useInput, inputActions, keyboard, addFiles, removeAttachment, resolveDraftAttachments, retryFileUpload, toggleCommandMenu, stop, t, renderSlot, useBusyEnter, useFileUploads, useNotices, useLexicon, useMenuLauncher, useProjection, sessionId, variant, disabled: inert, blocked, workspacePickerOpen, onRequestWorkspace, placeholder, accessory, }: InputBarProps) => import("react").JSX.Element>;
+//# sourceMappingURL=InputBar.d.ts.map

package/lib/types/client/skeleton/TodoPanel.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '@qilin-agent/kylin';
+import type { PropsLocale, PropsRuntime } from '@qilin-agent/client-ui-slots';
+import type { TodoItem } from '@qilin-agent/tool-todo/client';
+export interface TodoPanelProps {
+    /** The session's current plan (empty renders nothing) — selected by the dock adapter. */
+    todos: readonly TodoItem[];
+    /** The dock entry's locale seat, passed down as a plain prop. */
+    t: TodoDockProps['t'];
+}
+export declare function TodoPanel({ todos, t }: TodoPanelProps): import("react").JSX.Element | null;
+/** Props for the projected todo dock. */
+export type TodoDockProps = PropsRuntime<'conversation.input.dock'> & PropsLocale<'conversation'>;
+/** Renders the current todo projection, or nothing when it is absent. */
+export declare function TodoDock({ useProjection, t }: TodoDockProps): import("react").JSX.Element;
+/** Registers the projected todo dock. */
+export declare const todoDockEntry: {
+    name: string;
+    inject: string[];
+    apply(ctx: Context): void;
+};
+//# sourceMappingURL=TodoPanel.d.ts.map

package/lib/types/client/skeleton/control-row-layout.d.ts

@@ -0,0 +1,10 @@
+/** Content-sized model collapse for the composer's two control groups. */
+/**
+ * Collapse the model text only when the expanded controls cannot share a line.
+ * The model seat consumes the row's inherited display variables; wrapping remains
+ * available when even the icon cannot fit. Each notification is measured synchronously.
+ * @param row - Composer control row with its leading and trailing groups.
+ * @returns Disconnect the layout observers and font listener.
+ */
+export declare function observeControlRow(row: HTMLElement): () => void;
+//# sourceMappingURL=control-row-layout.d.ts.map

package/lib/types/client/skeleton/safari.d.ts

@@ -0,0 +1,18 @@
+/** Safari-specific textarea layout recovery for the conversation composer. */
+/** Browser identity fields needed to distinguish Safari from other WebKit-based browsers. */
+export interface BrowserIdentity {
+    readonly userAgent: string;
+    readonly vendor: string;
+}
+/**
+ * Detect Safari's `Version/... Safari/...` form while excluding known alternate iOS browser tokens.
+ * @param identity - Browser user-agent and vendor values.
+ * @returns Whether the identity should use the Safari-specific recovery.
+ */
+export declare function isSafariBrowser(identity: BrowserIdentity): boolean;
+/**
+ * Repair Safari's stale native textarea layout and the scrollport auto height it can contaminate.
+ * @param input - Composer textarea whose own scrollable overflow must stay zero.
+ */
+export declare function repairSafariTextareaLayout(input: HTMLTextAreaElement | null): void;
+//# sourceMappingURL=safari.d.ts.map

package/lib/types/client/stop-sequence.d.ts

@@ -0,0 +1,32 @@
+/** Two independent Escape presses addressed to one Conversation occurrence and live turn. */
+import type { SessionId } from '@qilin-agent/session/types';
+/** Freshly resolved cancellation target; occurrence and region preserve focus ownership. */
+export interface StopTarget {
+    readonly sessionId: SessionId;
+    readonly turn: number;
+    /** Materialized Session binding identity; replacement invalidates an earlier press. */
+    readonly generation: object;
+    readonly region: Element;
+    readonly cancel: () => void;
+}
+/** One short-lived first press, cleared before an accepted cancellation runs. */
+export declare class StopSequence {
+    private readonly intervalMs;
+    private readonly release;
+    private first;
+    private timer;
+    /**
+     * @param intervalMs - validated maximum time between independent presses.
+     * @param release - releases observations retained by the pending first press.
+     */
+    constructor(intervalMs: number, release: () => void);
+    /** Clear the first press and its expiry timer. */
+    reset(): void;
+    /**
+     * Accept one eligible, non-repeated Escape against freshly resolved current state.
+     * @param target - live turn and actual focused input region.
+     * @returns whether this press requested cancellation.
+     */
+    press(target: StopTarget): boolean;
+}
+//# sourceMappingURL=stop-sequence.d.ts.map

package/lib/types/client/stop-shortcut.d.ts

@@ -0,0 +1,17 @@
+/** Fixed Escape routing into the current Conversation turn's scoped cancellation. */
+import type { ISessions, SessionBinding } from '@qilin-agent/api-session-controller/client';
+import type { Shortcuts } from '@qilin-agent/client-shortcuts/client';
+import type { UiSession } from '@qilin-agent/client-ui-session/client';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { ObservableSnapshot } from '@qilin-agent/client-store';
+/**
+ * Subscribe fixed input to the same Session cancellation used by the stop button.
+ * @param shortcuts - window keyboard arbitration and validated sequence interval.
+ * @param sessions - live Session identities and lifecycle sources.
+ * @param openTurn - stable current-turn source for a live Session binding.
+ * @param uiSession - current pending-interaction status.
+ * @param cancel - scoped stop operation that preserves Queue and reports failures.
+ * @returns disposer releasing the input subscription, pending watches and expiry timer.
+ */
+export declare function installStopShortcut(shortcuts: Shortcuts, sessions: ISessions, openTurn: (binding: SessionBinding) => ObservableSnapshot<number | undefined>, uiSession: UiSession, cancel: (sessionId: SessionId) => void): () => void;
+//# sourceMappingURL=stop-shortcut.d.ts.map

package/lib/types/client/stores.d.ts

@@ -0,0 +1,24 @@
+/** Per-session Conversation store shared by the shell body and header. */
+import { type EngineStoreHandle } from '@qilin-agent/client-store';
+import type { SessionId } from '@qilin-agent/session/types';
+import type { ConversationStoreState } from './contract/views.ts';
+/** Declared write set for the Conversation shell. */
+type ConversationActions = {
+    setDraft: (draft: ConversationStoreState, text: string) => void;
+    setView: (draft: ConversationStoreState, view: string) => void;
+    openView: (draft: ConversationStoreState, view: string, focus: string) => void;
+    completeViewRequest: (draft: ConversationStoreState) => void;
+};
+/**
+ * Declare per-session draft persistence and View selection.
+ * @returns the store handle.
+ */
+export declare function createConversationStore(): EngineStoreHandle<ConversationStoreState, ConversationActions>;
+/**
+ * Read the persisted View preference before the Slot store is materialized.
+ * @param sessionId - Session-scoped persistence suffix.
+ * @returns the preferred View id, or null when storage has no usable value.
+ */
+export declare function readConversationViewPreference(sessionId: SessionId): string | null;
+export {};
+//# sourceMappingURL=stores.d.ts.map

package/lib/types/client/view-selection.d.ts

@@ -0,0 +1,11 @@
+import type { ViewTab } from './contract/views.ts';
+/** Registered identity of the trajectory View; hidden while Developer tools are off. */
+export declare const TRAJECTORY_VIEW_ID = "trajectory";
+/**
+ * Resolve a preferred registered View, then Chat, without choosing another View.
+ * @param tabs - currently registered Views.
+ * @param selectedId - preferred View identity, when one is stored.
+ * @returns the selected View, Chat fallback, or undefined when neither is registered.
+ */
+export declare function resolveActiveView(tabs: readonly ViewTab[], selectedId: string | null): ViewTab | undefined;
+//# sourceMappingURL=view-selection.d.ts.map

package/lib/types/conversation-settings.d.ts

@@ -0,0 +1,38 @@
+/** Conversation preferences stored in the Host user-settings document. */
+import z from '@qilin-agent/schemastery';
+/** Settings namespace owned by the conversation plugin. */
+export declare const CONVERSATION_SETTINGS_NAMESPACE = "ui-conversation";
+/** Field carrying the delivery mode for plain Enter while an agent is busy. */
+export declare const BUSY_ENTER_FIELD = "busyEnter";
+/** Field carrying the transcript content width. */
+export declare const CONTENT_WIDTH_FIELD = "contentWidth";
+/** Busy-Enter behaviors accepted at settings and input boundaries. */
+export declare const BUSY_ENTER_BEHAVIORS: readonly ["queue", "steer"];
+/** Configurable meaning of plain Enter while the addressed agent is busy. */
+export type BusyEnterBehavior = typeof BUSY_ENTER_BEHAVIORS[number];
+/** Default preserves Enter-as-Queue for running conversations. */
+export declare const DEFAULT_BUSY_ENTER_BEHAVIOR: BusyEnterBehavior;
+/**
+ * Content width that leaves the transcript to the layout's adaptive clamp
+ * (`clamp(680px, 64% of the column, 920px)`); any other value is an explicit
+ * width in px.
+ */
+export declare const CONTENT_WIDTH_ADAPTIVE = 0;
+/** Narrowest explicit content width (px); the layout center-column floor. */
+export declare const CONTENT_WIDTH_MIN = 640;
+/** Widest persistable content width (px), bounding a hand-edited settings document. */
+export declare const CONTENT_WIDTH_MAX = 2400;
+/** Increment one stepper click moves the content width (px). */
+export declare const CONTENT_WIDTH_STEP = 20;
+/** Content width before the user picks one. */
+export declare const DEFAULT_CONTENT_WIDTH = 0;
+/** Durable conversation section shared by the Host schema and the browser scope. */
+export interface ConversationSettings {
+    /** Delivery mode for plain Enter while the addressed agent is busy. */
+    busyEnter: BusyEnterBehavior;
+    /** Transcript content width in px, or {@link CONTENT_WIDTH_ADAPTIVE} for the layout clamp. */
+    contentWidth: number;
+}
+/** Durable conversation schema; also the wire envelope the browser scope validates against. */
+export declare const ConversationSettingsSchema: z<ConversationSettings>;
+//# sourceMappingURL=conversation-settings.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,9 @@
+/** Host registration for browser conversation preferences. */
+import type { Context } from '@qilin-agent/kylin';
+export { BUSY_ENTER_BEHAVIORS, BUSY_ENTER_FIELD, CONVERSATION_SETTINGS_NAMESPACE, CONTENT_WIDTH_ADAPTIVE, CONTENT_WIDTH_FIELD, CONTENT_WIDTH_MAX, CONTENT_WIDTH_MIN, CONTENT_WIDTH_STEP, DEFAULT_BUSY_ENTER_BEHAVIOR, DEFAULT_CONTENT_WIDTH, type BusyEnterBehavior, type ConversationSettings, } from './conversation-settings.ts';
+/**
+ * Register the durable conversation section when a settings provider exists.
+ * @param ctx - Host context whose optional settings service owns the section.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map