@deepseek-ai/dsh-client-ui-commands 0.0.1-rc.3

package/lib/index.js

@@ -0,0 +1,12 @@
+//#region lib/types/index.js
+/**
+* Command UI plugin, node half. Pure UI plugin: the empty apply exists so
+* the plugin appears in the host cordis.yml / Loader; the browser half ships
+* via exports["./client"], discovered through the package.json dsh.client
+* declaration. The host command registry itself mounts separately
+* (bootHost + CommandUiRuntime).
+*/
+/** Host plugin body — no host-side behavior for the command UI plugin. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/invariant.js

@@ -0,0 +1,24 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-client-ui-commands`.
+* @module @deepseek-ai/dsh-client-ui-commands/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-client-ui-commands";
+/** Cordis companion plugin name. */
+const name = "client-ui-commands-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: a browser-side source over the wire command
+* directory — it emits no cordis events and owns no cross-plugin mutable
+* state; dispatch and cache behavior are asserted by this package's specs.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

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

@@ -0,0 +1,16 @@
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { PopupSelectController } from './popup.ts';
+/** Injected business face of the popupSelect overlay entry. */
+export interface PopupSelectInjected {
+    /** The session's shell controller (state store + verbs; the view never touches the open-context type). */
+    popup: PopupSelectController;
+}
+/** Full shell props: injected face + the locale seat. */
+export type PopupSelectViewProps = PopupSelectInjected & PropsLocale<'command'>;
+/**
+ * Render the popupSelect shell overlay entry.
+ * @param props - injected face: the session's shell controller; `t` rides the standard locale seat.
+ * @returns the select card while open; null while closed.
+ */
+export declare function PopupSelectView({ popup, t }: PopupSelectViewProps): import("react").JSX.Element | null;
+//# sourceMappingURL=PopupSelectView.d.ts.map

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

@@ -0,0 +1,84 @@
+/**
+ * Frozen contract of the client command surface. Types only. The
+ * CommandUiRuntime (`ctx.commandUi`) implements this face; business packages
+ * consume `register` alone.
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import type { ClientSessionContext } from '@deepseek-ai/dsh-client-ui-input-trigger/client';
+/** Copy for an option that must be acknowledged before onSelect can run. */
+export interface SelectConfirmation {
+    readonly title: string;
+    readonly description: string;
+    readonly acknowledgeLabel: string;
+    readonly cancelLabel: string;
+    readonly confirmLabel: string;
+}
+/** One option row of a popupSelect shell. */
+export interface SelectOption {
+    readonly id: string;
+    readonly label: string;
+    readonly detail?: string;
+    readonly active?: boolean;
+    /** Optional in-page risk gate owned by the shared popup shell. */
+    readonly confirmation?: SelectConfirmation;
+}
+/**
+ * Business registration for the popupSelect command kind. Data is
+ * self-served: options/onSelect use the business package's own protocol.
+ * The shell component is owned by ui-commands; business never sees it. Both
+ * callbacks receive the ClientSessionContext captured at popup open.
+ */
+export type CommandUiSpec = {
+    readonly kind: 'popupSelect';
+    options(session: ClientSessionContext, signal: AbortSignal): Promise<readonly SelectOption[]>;
+    onSelect(option: SelectOption, session: ClientSessionContext): void | Promise<void>;
+};
+/**
+ * One client-owned command contribution: a slash-menu entry whose behavior
+ * lives entirely on the client (no host descriptor). Merged with the host
+ * catalog by name — a collision with a host command fails loud at candidate
+ * synthesis, never shadows.
+ */
+export interface CommandContribution {
+    /** Command name without the leading slash (unique across contributions). */
+    readonly name: string;
+    /** Menu row description. */
+    readonly description: string;
+    /** Capability filter, called with a fresh projection per candidate pass. */
+    available(session: ClientSessionContext): boolean;
+    /** The command's UI behavior (this phase: popupSelect only). */
+    readonly ui: CommandUiSpec;
+}
+/**
+ * A UI decoration hung on one HOST command: what its BARE invocation does on
+ * this client. Not a second command — the host command keeps its catalog
+ * row, its argument claim (space / argued enter), and its lifecycle logging;
+ * the decoration replaces only the bare menu-pick/enter with a popup whose
+ * onSelect typically submits a completed line back through command.execute.
+ * A decoration never manufactures a row: a name with no host catalog entry
+ * in the session's directory simply never reaches the decoration.
+ */
+export interface CommandDecoration {
+    /** The HOST command name this decorates (without the leading slash). */
+    readonly name: string;
+    /** Capability filter, called with a fresh projection per bare invocation. */
+    available(session: ClientSessionContext): boolean;
+    /** The bare-invocation UI (this phase: popupSelect only). */
+    readonly ui: CommandUiSpec;
+}
+/** The `ctx.commandUi` service face visible to business packages. */
+export interface CommandUiContract {
+    /**
+     * Register one client command contribution; effect disposer. Duplicate
+     * names throw at registration.
+     */
+    register(contribution: CommandContribution): () => void;
+    /**
+     * Hang a bare-invocation decoration on one host command; effect disposer.
+     * Duplicate names throw at registration.
+     */
+    decorate(decoration: CommandDecoration): () => void;
+    /** Resolve the per-session popup controller for one session scope (wiring/overlay layer). */
+    popupFor(actx: ClientContext): unknown;
+}
+//# sourceMappingURL=contract.d.ts.map

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

@@ -0,0 +1,70 @@
+/**
+ * Command-directory cache keyed by session: one entry per served catalog —
+ * every session is agent-backed, so `command.list({sessionId})` is the only
+ * request fields. Each entry keeps the single-flight / soft-hard invalidation
+ * / epoch-guard behavior of the original global cache; the session-key axis
+ * is the only extra dimension.
+ */
+import type { CommandDescriptor } from '@deepseek-ai/dsh-commands/types';
+import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client';
+export type { CommandDescriptor } from '@deepseek-ai/dsh-commands/types';
+/**
+ * cold = never pulled; pending = pull in flight with nothing servable;
+ * ready = snapshot serving (a soft-invalidate repull keeps this status);
+ * failed = last winning pull rejected, snapshot dropped.
+ */
+export type DirectoryStatus = 'cold' | 'pending' | 'ready' | 'failed';
+/** Injected pull (the service binds command.list off the root connection). */
+export type FetchCommands = (sessionId: SessionId) => Promise<readonly CommandDescriptor[]>;
+/** The session-keyed directory cache. Plain class — the owning service wires events and RPC. */
+export declare class CommandDirectory {
+    private readonly fetchCommands;
+    private readonly entries;
+    constructor(fetchCommands: FetchCommands);
+    /**
+     * Current cache status for one session.
+     * @param sessionId - session key.
+     * @returns the entry status (cold when never touched).
+     */
+    status(sessionId: SessionId): DirectoryStatus;
+    /**
+     * Synchronous exact-name lookup over one session's hot snapshot.
+     * @param sessionId - session key.
+     * @param name - command name without the leading slash.
+     * @returns the descriptor, or undefined when absent or the entry is not ready.
+     */
+    resolve(sessionId: SessionId, name: string): CommandDescriptor | undefined;
+    /** Soft invalidation (commands-changed): background repull on every touched key; ready snapshots keep serving. */
+    invalidateAll(): void;
+    /**
+     * Hard reset on reconnect: every entry drops its snapshot (the agent world
+     * may have changed shape across the generation) and prewarms.
+     */
+    resetConnected(): void;
+    /**
+     * Fire-and-forget prewarm of one session (the command source's scope-birth
+     * warm hook lands here).
+     * @param sessionId - session key.
+     */
+    warm(sessionId: SessionId): void;
+    /**
+     * Start one pull for one session. Publishes ready/failed only while it is
+     * still the key's latest pull (epoch guard); a ready snapshot is not
+     * demoted while the pull flies.
+     * @param sessionId - session key.
+     * @returns settled when this pull's outcome is published or discarded.
+     */
+    refresh(sessionId: SessionId): Promise<void>;
+    /**
+     * Strong-wait until one session's catalog is servable (the enter-
+     * adjudication "directory must be reached" rule): ready returns at once;
+     * cold/failed launch a fresh pull; pending joins the flying one. Rejects
+     * when the awaited pull fails or the signal aborts.
+     * @param sessionId - session key.
+     * @param signal - attempt-scoped abort (the SubmitAttempt signal).
+     * @returns the hot command snapshot.
+     */
+    ensureReady(sessionId: SessionId, signal: AbortSignal): Promise<readonly CommandDescriptor[]>;
+    private entry;
+}
+//# sourceMappingURL=directory.d.ts.map

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

@@ -0,0 +1,38 @@
+/**
+ * Command UI plugin, browser half: CommandUiRuntime (`ctx.commandUi`) owning the
+ * capability-keyed directory cache, the '/' command source, the client
+ * contribution registry, and the per-session popupSelect controllers; the
+ * popupSelect shell self-registers into conversation.input.overlay with
+ * per-session resolution.
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import { CommandUiRuntime } from './service.ts';
+import { type CommandKey } from './locales.ts';
+export { CommandUiRuntime } from './service.ts';
+export { CommandDirectory } from './directory.ts';
+export type { CommandDescriptor, DirectoryStatus } from './directory.ts';
+export { filterOptions, PopupSelectController } from './popup.ts';
+export type { PopupSelectDeps, PopupSpec, PopupState, TokenSegment } from './popup.ts';
+export type { PopupSelectInjected, PopupSelectViewProps } from './PopupSelectView.tsx';
+export type { CommandContribution, CommandDecoration, CommandUiContract, CommandUiSpec, SelectConfirmation, SelectOption, } from './contract.ts';
+export type { CommandKey } from './locales.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        commandUi: CommandUiRuntime;
+    }
+}
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The popupSelect shell's copy. */
+        command: CommandKey;
+    }
+}
+/** Required services: the '/' source registry, session scopes, commands Remote, and locale registry. */
+export declare const inject: string[];
+/**
+ * Client plugin body: mount the service, then register the popupSelect shell
+ * into the input overlay once its declarer is up.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,24 @@
+/** `command` namespace dictionaries (the popupSelect shell's copy). */
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: {
+    'search.placeholder': string;
+    'search.aria': string;
+    'status.loading': string;
+    'status.applying': string;
+    'status.empty': string;
+    'overlay.aria': string;
+    'listbox.aria': string;
+};
+/** The command namespace key union. */
+export type CommandKey = keyof typeof zh;
+/** English dictionary, checked complete against the zh key set. */
+export declare const en: {
+    'search.placeholder': string;
+    'search.aria': string;
+    'status.loading': string;
+    'status.applying': string;
+    'status.empty': string;
+    'overlay.aria': string;
+    'listbox.aria': string;
+};
+//# sourceMappingURL=locales.d.ts.map

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

@@ -0,0 +1,154 @@
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import type { TokenSpan } from '@deepseek-ai/dsh-client-ui-input-trigger/client';
+import type { SelectOption } from './contract.ts';
+/**
+ * The command token segment snapshotted at shell-open time, replayed to the
+ * injected {@link PopupSelectDeps.consume} callback after a successful
+ * selection. The Input side guards it: a menu-path span consumes iff draftRev
+ * is unchanged, an enter-path line iff the trimmed draft still equals the
+ * bare token.
+ */
+export type TokenSegment = {
+    readonly via: 'menu';
+    readonly span: TokenSpan;
+} | {
+    readonly via: 'enter';
+    readonly token: string;
+};
+/**
+ * Structural business spec the shell settles against — the popupSelect half
+ * of CommandUiSpec, generic in the context value the opener captures (the
+ * session wiring passes its session projection; the controller only carries
+ * it from open() to the callbacks).
+ */
+export interface PopupSpec<TCtx> {
+    /** Load the option rows once per open (retry after failure reuses the same signal). */
+    options(context: TCtx, signal: AbortSignal): Promise<readonly SelectOption[]>;
+    /** Settle the picked option against the open-time context. */
+    onSelect(option: SelectOption, context: TCtx): void | Promise<void>;
+}
+/** Injected session-wiring callbacks of one controller (tests pass fakes). */
+export interface PopupSelectDeps {
+    /**
+     * Consume the open-time token segment after a successful onSelect (the
+     * wiring dispatches the consume-token event to the opening session).
+     * @param segment - the open-time token segment snapshot.
+     * @returns whether the token was consumed; false (CAS miss) is benign and
+     * never retried.
+     */
+    consume(segment: TokenSegment): boolean;
+    /** Return focus to the session composer (successful settle and Escape close paths). */
+    focusComposer(): void;
+}
+/** Popup shell state (the shell component renders from here; closed = render null). */
+export interface PopupState {
+    readonly open: boolean;
+    /** Command name the shell is open for (null while closed). */
+    readonly command: string | null;
+    /** Options-load lifecycle; 'failed' keeps the shell open for retry(). */
+    readonly status: 'pending' | 'ready' | 'failed';
+    /** Options as loaded — never re-fetched per keystroke; views render {@link filterOptions} over them. */
+    readonly options: readonly SelectOption[];
+    /** Local filter text over the loaded options. */
+    readonly search: string;
+    /** Highlight index into the filtered row list (0 when empty/pending). */
+    readonly active: number;
+    /** A select() settlement is in flight: further select/search/highlight no-op until it settles. */
+    readonly submitting: boolean;
+    /** Option waiting for explicit risk acknowledgement; null during normal selection. */
+    readonly confirming: SelectOption | null;
+    /** Caller-controlled checkbox state for the pending confirmation. */
+    readonly acknowledged: boolean;
+    /** Surfaced settlement failure (options load or onSelect); null when none. */
+    readonly error: string | null;
+}
+/**
+ * Filter option rows against the shell's local search text (case-insensitive
+ * substring over label and detail; blank search keeps every row).
+ * @param options - the loaded rows.
+ * @param search - the shell's search text.
+ * @returns the rows the shell shows and highlights over.
+ */
+export declare function filterOptions(options: readonly SelectOption[], search: string): readonly SelectOption[];
+/**
+ * Headless controller of one session's popupSelect shell. Late settlements
+ * lose their write rights through binding identity: dismiss/dispose/reopen
+ * swap the binding, so a settling options fetch or onSelect that no longer
+ * matches writes nothing and consumes nothing.
+ */
+export declare class PopupSelectController<TCtx = unknown> {
+    private readonly deps;
+    /** Shell state store (the overlay component subscribes here). */
+    readonly state: SnapshotStore<PopupState>;
+    private binding;
+    /**
+     * @param deps - session-wiring callbacks (token consumption + composer focus).
+     */
+    constructor(deps: PopupSelectDeps);
+    /**
+     * Open the shell for one command: publish pending state and fetch options
+     * once through the business spec. A reopen supersedes the previous shell
+     * (its options fetch is aborted, its late settlements are dropped).
+     * @param command - command name the shell serves.
+     * @param spec - the registered popupSelect spec.
+     * @param context - open-time context snapshot, handed verbatim to options/onSelect.
+     * @param segment - open-time token segment snapshot for post-select consumption.
+     */
+    open(command: string, spec: PopupSpec<TCtx>, context: TCtx, segment: TokenSegment): void;
+    /** Run the one options fetch of a binding; settlement rights die with the binding. */
+    private load;
+    /** Re-run a failed options fetch (search survives; no-op unless status is 'failed'). */
+    retry(): void;
+    /**
+     * Replace the local search text (pure local filter — the provider is never
+     * re-queried) and rebase the highlight onto the new filtered list.
+     * @param search - the shell search input's text.
+     */
+    setSearch(search: string): void;
+    /**
+     * Move the highlight across the filtered rows (wraps around; no-op unless
+     * options are ready and no selection is in flight).
+     * @param dir - +1 down, -1 up.
+     */
+    move(dir: 1 | -1): void;
+    /**
+     * Set the highlight directly (pointer hover; no-op unless ready, idle, and
+     * in filtered range).
+     * @param index - filtered-row index.
+     */
+    highlight(index: number): void;
+    /**
+     * Select one filtered row: single-flight — the first call enters
+     * `submitting` and later calls no-op until it settles. Success consumes the
+     * open-time token segment (a false CAS answer is benign), closes, and
+     * returns focus to the composer. Failure keeps the shell open with search,
+     * highlight, and token intact, surfaces the error, and re-arms select as
+     * the retry.
+     * @param index - filtered-row index (callers pass the highlight or the clicked row).
+     * @returns settled when the attempt has closed the shell or surfaced its failure.
+     */
+    select(index: number): Promise<void>;
+    /**
+     * Update the explicit checkbox for the currently pending risk gate.
+     * @param acknowledged - whether the user has acknowledged the displayed risk.
+     */
+    acknowledge(acknowledged: boolean): void;
+    /** Cancel only the risk gate and return to the still-open option picker. */
+    cancelConfirmation(): void;
+    /** Settle the gated option only after the checkbox is acknowledged. */
+    confirm(): Promise<void>;
+    /** Run the business settlement for an already admitted option. */
+    private settle;
+    /**
+     * Close the shell; aborts a flying options fetch and revokes settlement
+     * rights. An outside pointer interaction dismisses plainly (the click's own
+     * target takes focus); Escape passes focusComposer to return focus explicitly.
+     * @param opts - focusComposer: also restore composer focus (Escape path).
+     */
+    dismiss(opts?: {
+        readonly focusComposer?: boolean;
+    }): void;
+    /** Scope-teardown disposer: abort in-flight work and clear state (no focus side effect). */
+    dispose(): void;
+}
+//# sourceMappingURL=popup.d.ts.map

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

@@ -0,0 +1,121 @@
+/**
+ * CommandUiRuntime (`ctx.commandUi`): the '/' command source over the
+ * session-keyed directory, the client-contribution registry, and the
+ * per-session popupSelect controllers. Candidate synthesis merges the host
+ * catalog with contributions by availability, then fuzzy query/position
+ * filtering; a host/contribution name collision fails loud. Every execute
+ * addresses the session's agent by sessionId — sessions are always
+ * agent-backed.
+ */
+import { Service } from '@deepseek-ai/cordis';
+import type { Context } from '@deepseek-ai/cordis';
+import type { CommandResult } from '@deepseek-ai/dsh-commands/types';
+import type { ClientContext, SessionId } from '@deepseek-ai/dsh-client-runtime/client';
+import type { ClientSessionContext } from '@deepseek-ai/dsh-client-ui-input-trigger/client';
+import type { CommandContribution, CommandDecoration, CommandUiContract } from './contract.ts';
+import { PopupSelectController } from './popup.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Events {
+        /**
+         * This browser client completed one admitted Host command execution.
+         * Other clients receive the durable command nodes but never this local
+         * submission acknowledgment.
+         * @param sessionId - Session addressed by the local submission.
+         * @param name - Executed command name without the leading slash.
+         * @param result - Host command result returned to this browser.
+         * @mode emit
+         */
+        'command/executed'(sessionId: SessionId, name: string, result: CommandResult): void;
+    }
+}
+/** Command surface: session-keyed directory + '/' source + contribution registry + per-session popups. */
+export declare class CommandUiRuntime extends Service implements CommandUiContract {
+    static inject: string[];
+    private readonly directory;
+    private readonly live;
+    /**
+     * @param ctx - owning root context (plugin fiber; the service registers
+     * itself as `command` and follows that fiber's lifetime).
+     */
+    constructor(ctx: Context);
+    /**
+     * Register one client command contribution; effect disposer (rides the
+     * caller's fiber). Duplicate names throw.
+     * @param contribution - the contribution (descriptor + availability + popup spec).
+     * @returns the disposer removing the registration.
+     */
+    register(contribution: CommandContribution): () => void;
+    /**
+     * Hang a bare-invocation decoration on one host command; effect disposer
+     * (rides the caller's fiber). Duplicate names throw.
+     * @param decoration - host command name + availability + popup spec.
+     * @returns the disposer removing the registration.
+     */
+    decorate(decoration: CommandDecoration): () => void;
+    /**
+     * Resolve the per-session popup controller (lazy; dies with the session
+     * scope). The controller's consume callback dispatches the scoped
+     * consume-token event back to this session; focusComposer reaches the
+     * composer through the overlay slot currency.
+     * @param actx - session-scope ctx.
+     * @returns the resident controller.
+     */
+    popupFor(actx: ClientContext): PopupSelectController<ClientSessionContext>;
+    /** Composer focus hooks by session (the overlay wiring binds the textarea focus here). */
+    private readonly focusHooks;
+    /**
+     * Bind one session's composer-focus hook (overlay slot wiring; unbind on unmount).
+     * @param id - session id.
+     * @param focus - textarea focus callback.
+     * @returns the unbind disposer.
+     */
+    bindComposerFocus(id: SessionId, focus: () => void): () => void;
+    /** Menu candidates: host catalog + contribution availability, then position filtering and fuzzy name ranking. */
+    private candidates;
+    /** Decision table, menu column: contribution/decorated-host → popup; host input → claim; host bare → detached execute. */
+    private dispatch;
+    /** Decision table, space column: hot-key sync check; only host leadingInput claims. */
+    private matchSpace;
+    /**
+     * Decision table, enter column. Strong-waits the session's catalog (a
+     * warmup failure rejects — never a silent downgrade). Contributions and
+     * bare host commands act on the bare token only; leadingInput claims
+     * args-tolerant.
+     */
+    private matchEnter;
+    /** Open the session's popup for one contribution or decoration (menu pick / bare enter). */
+    private openPopup;
+    /** Build the leadingInput claim: token `/name ` + the command.execute submit transaction. */
+    private leadingClaim;
+    /**
+     * The command.execute transaction, addressed to the session's agent — pure
+     * admission semantics. An unmatched line reports an error outcome (the
+     * composer's immediate admission feedback); an admitted command reports
+     * plain success regardless of its handler outcome, because the host
+     * executor durably logged the lifecycle (`command/run`/`command/done`) and
+     * the outcome renders as a persistent flow node — the composer never
+     * echoes it. Transport failures throw.
+     */
+    private execute;
+    /** Publish the local acknowledgment without letting an observer change command admission. */
+    private notifyExecuted;
+    /** Log one contained `command/executed` observer failure. */
+    private warnExecutedListenerFailure;
+    /**
+     * Fire-and-forget execute for the internal ('handled') paths. Outcomes are
+     * NOT surfaced here: the host executor durably logs the command lifecycle
+     * (`command/run`/`command/done`), and the mux-broadcast events render as a
+     * persistent flow node on every tab. Only a transport/admission failure —
+     * which never entered a handler and therefore never logged — falls back to
+     * the composer notice as immediate feedback.
+     */
+    private runDetached;
+    /** Dispatch a consume-token event to one session (menu-pick / bare-enter execute paths). */
+    private consumeVia;
+    /** Route an admission/transport failure to the session's composer notice channel (scope gone = attempt died with it). */
+    private noticeFor;
+    /** id → actx interchange (registered exchange point: this service coordinates for projection-only sources). */
+    private scopeFor;
+    private sessions;
+}
+//# sourceMappingURL=service.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Command UI plugin, node half. Pure UI plugin: the empty apply exists so
+ * the plugin appears in the host cordis.yml / Loader; the browser half ships
+ * via exports["./client"], discovered through the package.json dsh.client
+ * declaration. The host command registry itself mounts separately
+ * (bootHost + CommandUiRuntime).
+ */
+/** Host plugin body — no host-side behavior for the command UI plugin. */
+export declare function apply(): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-client-ui-commands`.
+ * @module @deepseek-ai/dsh-client-ui-commands/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "client-ui-commands-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@deepseek-ai/dsh-client-ui-commands",
+  "description": "Client command surface: global directory cache, '/' source, three command UI kinds, popupSelect registry",
+  "version": "0.0.1-rc.3",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/ui-commands"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-input-trigger",
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ],
+      "platform": "web"
+    }
+  },
+  "license": "BSD-3-Clause",
+  "dependencies": {
+    "clsx": "^2.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.2.0",
+    "@deepseek-ai/dsh-api-remotes": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-locale": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-ui-input-trigger": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-commands": "^0.0.1-rc.3",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1",
+    "@deepseek-ai/dsh-client-runtime": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.3"
+  },
+  "devDependencies": {
+    "@types/react": "~18.3.1",
+    "react": "^18.2.0",
+    "@deepseek-ai/dsh-api-remotes": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-connection": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-locale": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-runtime": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-test-runtime": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-ui-input-trigger": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-commands": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.3",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "scripts": {
+    "bundle": "tsdown",
+    "watch": "tsdown --watch"
+  }
+}