dsh-llm-fallbacks 0.3.4 → 0.4.0-alpha.1

package/dist/override.d.ts

@@ -0,0 +1,39 @@
+/**
+ * RouteChanged effort rule for config overrides (plan dsh-012-subagent-routing
+ * T4; spec D3).
+ *
+ * Pure, host-free module: plain seed config plus a target route in, the
+ * overridden config out. The effort handling mirrors the upstream
+ * `resolveChildAgentOptions` rule (deepseek-harness
+ * `subagent/src/child-agent.ts:117`): a changed provider+model route drops the
+ * seed's route-owned `reasoningEffort` so the selected model resolves its own
+ * default, unless an effort is explicitly named for the override; an
+ * unchanged route keeps the seed effort. Policy-independent by design — the
+ * same rule applies on every override path whether the subagent routing
+ * policy is on or off (spec D3). Never throws.
+ *
+ * @module dsh-llm-fallbacks/override
+ */
+import type { LlmCallConfig } from '@deepseek-ai/dsh-llm';
+/** Reasoning-effort value carried by `LlmCallConfig.reasoningEffort`. */
+export type LlmReasoningEffort = NonNullable<LlmCallConfig['reasoningEffort']>;
+/**
+ * Override a request config with a target route under the upstream
+ * routeChanged effort rule (spec D3):
+ *
+ * - An explicitly named effort always survives — it wins over the seed effort
+ *   on either route (upstream semantics: the request overrides the parent).
+ * - Same provider+model route → the seed `reasoningEffort` is preserved.
+ * - Route changed without an explicit effort → the seed effort is dropped
+ *   (never carry a stale effort into a different provider/model route).
+ *
+ * @param seed - the caller's current request config.
+ * @param to - the effective target route.
+ * @param explicitEffort - an effort explicitly named for this override.
+ * @returns a fresh config routed to `to` with the effort rule applied; never
+ * mutates `seed`.
+ */
+export declare function overrideConfigWithRouteRule(seed: LlmCallConfig, to: {
+    provider: string;
+    model: string;
+}, explicitEffort?: LlmReasoningEffort): LlmCallConfig;

package/dist/recovery.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Half-open recovery state machine (plan fallbacks-half-open-recovery Task 2).
+ *
+ * `RecoveryStore` tracks per-route consecutive-failure counters and half-open
+ * episode flags, keyed `${provider}/${model}` via `selectorKey`. It is held
+ * per-agent on `AgentFallbackState` and is session-scoped in-memory (same
+ * lifetime as the cooldown store; a restart resets every route to a flat
+ * first cooldown).
+ *
+ * The store is pure logic — zero imports, the cooldown.ts purity precedent —
+ * so it is unit-testable without a host (recovery.spec.ts imports this module
+ * directly).
+ *
+ * State machine (plan P2):
+ * 1. `recordFailure` — a suppression write: increments the consecutive-failure
+ *    counter and clears any half-open episode (rule 1).
+ * 2. `escalatedCooldownMs` — bounded geometric escalation of the suppression
+ *    duration (rule 2).
+ * 3. `markHalfOpen` — an expired cooldown leaves the route half-open for one
+ *    logged probe (rule 3).
+ * 4. `tryMarkProbeLogged` — the once-per-episode admission marker, not a gate
+ *    (rule 4).
+ * 5. `isHalfOpen` — probe-failure gate for the no-surviving-target path
+ *    (rule 5b).
+ * 6. `close` — an observed completion closes the circuit, only from half-open
+ *    (rule 6).
+ *
+ * @module dsh-llm-fallbacks/recovery
+ */
+/** Escalation multiplier applied per consecutive failure (rule 2). */
+export declare const ESCALATION_MULTIPLIER = 2;
+/** Escalation ceiling: 1 hour (rule 2). */
+export declare const ESCALATION_CAP_MS = 3600000;
+/**
+ * Bounded geometric escalation of the suppression duration (rule 2):
+ * `max(ms, min(ESCALATION_CAP_MS, ms * ESCALATION_MULTIPLIER ** (n - 1)))`
+ * for `n >= 1`. `n = 1` is flat `ms`; the `max(ms, ...)` floor keeps
+ * escalation from ever shortening below the configured flat cooldown when
+ * `ms >= ESCALATION_CAP_MS`; `ms = 0` degenerates to today's flat-0
+ * semantics.
+ */
+export declare function escalatedCooldownMs(ms: number, n: number): number;
+/**
+ * Per-route half-open recovery state (plan P2). Pure logic — no host
+ * dependencies, no `@deepseek-ai/*` imports.
+ */
+export declare class RecoveryStore {
+    private entries;
+    /**
+     * Record a suppression write for `key` (rule 1): increments the
+     * consecutive-failure counter and clears any in-progress half-open episode
+     * (a failure while half-open re-suppresses escalated — rule 5). Returns the
+     * new counter value `n`; the caller computes the escalated duration with
+     * {@link escalatedCooldownMs}.
+     */
+    recordFailure(key: string): number;
+    /**
+     * Open a half-open episode for `key` (rule 3): the lapsed cooldown leaves
+     * the route half-open for one logged probe. Resets the per-episode probe
+     * marker; the consecutive-failure counter survives the episode so a probe
+     * failure escalates to `n + 1` (rule 5). Creates the entry on first sight
+     * (mid-session mode flips can surface a cooldown entry with no recovery
+     * entry — rule 8).
+     */
+    markHalfOpen(key: string, until: number): void;
+    /**
+     * Mark the episode's one logged admission (rule 4). Returns `true` only for
+     * the first admission of a half-open episode; later admissions while the
+     * episode is unresolved return `false` and route normally (the marker is
+     * not a gate — there is no admission limit).
+     */
+    tryMarkProbeLogged(key: string): boolean;
+    /** True while `key` has an in-progress half-open episode (rule 5b gate). */
+    isHalfOpen(key: string): boolean;
+    /**
+     * Close the circuit for `key` (rule 6): acts only when the entry exists and
+     * is half-open — the entry is deleted (counter reset by deletion, preference
+     * fully restored). A completion observed while the route is actively
+     * suppressed, or with no entry, is a no-op: a stale in-flight success must
+     * not cancel a fresher escalated re-suppression.
+     */
+    close(key: string): void;
+    /**
+     * The in-progress half-open episodes, in insertion order (display path —
+     * plan P4). `untilEpochMs` is the lapsed expiry epoch that drives the
+     * `/fallbacks` marker row.
+     */
+    halfOpenEntries(): Array<{
+        key: string;
+        untilEpochMs: number;
+    }>;
+}

package/dist/route-allowlist.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Route identity and allowlist intersection on resolved candidates (plan
+ * dsh-012-subagent-routing T2; spec D1 ∩ D2).
+ *
+ * Pure, host-free module: plain route data in, results out. Route identity is
+ * the EXACT provider string plus the EXACT model string — no aliasing, no
+ * case-folding, no catalog-id substitution (spec Terms). Intersections run on
+ * RESOLVED candidates (concrete provider+model after the chain candidate
+ * pipeline); this module never resolves chains or expands wildcards — the
+ * caller passes already-resolved candidates in.
+ *
+ * Fail-closed direction: an empty allowlist contains nothing and an empty
+ * intersection yields `undefined` — the caller must skip the
+ * plugin-originated route rather than fall back to an unproven one (spec D1).
+ * Never throws.
+ *
+ * @module dsh-llm-fallbacks/route-allowlist
+ */
+import type { PolicyRoute } from './subagent-policy.ts';
+/** One resolved chain candidate: a selector anchored to a concrete model id. */
+export type ResolvedCandidate = {
+    readonly provider: string;
+    readonly model?: string;
+};
+/**
+ * Normalize resolved chain candidates into detached plain routes. Candidates
+ * without a concrete model id are dropped (they are not routes); every
+ * surviving entry is a fresh object, so the result never aliases the
+ * caller's candidate list.
+ */
+export declare function resolvedRoutes(candidates: readonly ResolvedCandidate[]): PolicyRoute[];
+/**
+ * Whether the route is on the allowlist under exact route identity: both the
+ * provider and the model strings must equal an allowed route exactly.
+ */
+export declare function routeOnAllowlist(route: PolicyRoute, allowedModels: readonly PolicyRoute[]): boolean;
+/**
+ * The first resolved candidate that is on the allowlist, preserving the
+ * candidate order (the chain's first in-allowlist entry wins), or `undefined`
+ * when the intersection is empty — the caller then skips the inject / switch
+ * and the host seed stands (spec D1 ∩ D2).
+ */
+export declare function firstAllowedCandidate(resolved: readonly PolicyRoute[], allowedModels: readonly PolicyRoute[]): PolicyRoute | undefined;

package/dist/state.d.ts

@@ -29,6 +29,8 @@
  */
 import type { FallbackSwitchReason } from './events.ts';
 import { CooldownStore, StepFailureSet } from './cooldown.ts';
+import { RecoveryStore } from './recovery.ts';
+import type { RecoveryPolicy } from './config.ts';
 /** Decision awaiting application at the next `agent/request` boundary (spec §5.1). */
 export interface PendingSwitch {
     from: {
@@ -42,6 +44,46 @@ export interface PendingSwitch {
     role: string;
     reason: FallbackSwitchReason;
 }
+/**
+ * One plugin-originated subagent switch the host allowlist blocked (plan
+ * dsh-012-subagent-routing T3; spec D1). The intersection of the resolved
+ * candidates with the effective allowlist was empty while the 0.3.5 walk
+ * would have switched — the attempt is recorded in-memory only (issue #52:
+ * no durable session write) for the Subagents card warning (spec D4/T5).
+ */
+export interface BlockedSwitchAttempt {
+    /** Epoch ms when the switch was blocked. */
+    at: number;
+    /** The route the 0.3.5 walk would have switched to (exact provider+model). */
+    route: {
+        provider: string;
+        model: string;
+    };
+    /** The failure reason that triggered the would-be switch. */
+    reason: FallbackSwitchReason;
+}
+/**
+ * How the effective subagent chain head was chosen (plan dsh-012-subagent-routing
+ * T5 / T2 M3). Lives on a per-agent map (mirrors {@link BlockedSwitchAttempt}),
+ * not on {@link AgentFallbackState} — recording a head is not a switch intent
+ * (F-004: the fallback store grows only inside `commit()`).
+ */
+export type ChainHeadSource = 'authorized' | 'injected';
+/**
+ * The effective chain head for one subagent, plus the source label the
+ * Subagents card renders (spec D4). In-memory only (issue #52).
+ */
+export interface EffectiveChainHead {
+    /** Epoch ms when this head was recorded (recency for the card snapshot). */
+    at: number;
+    /** Exact provider+model of the effective chain head. */
+    route: {
+        provider: string;
+        model: string;
+    };
+    /** `authorized` = host spawn preserved; `injected` = plugin role-inject. */
+    source: ChainHeadSource;
+}
 /** The current (turn, step)'s failed-model set and switch budget (spec §5.1). */
 export interface StepFailures {
     turn: number;
@@ -64,6 +106,8 @@ export interface AgentFallbackState {
     stepFailures: StepFailures;
     /** `provider/model → expiry epoch ms`; lazily expired on read. */
     cooldown: CooldownStore;
+    /** Half-open recovery bookkeeping (plan fallbacks-half-open-recovery P2). */
+    recovery: RecoveryStore;
 }
 /**
  * The `Map<agent.id, AgentFallbackState>` store plus the state-machine
@@ -107,6 +151,27 @@ export declare class FallbackStateStore {
     clearStepState(state: AgentFallbackState): void;
     /** Suppress `key` until `untilEpochMs` (`Infinity` for `revertPolicy: 'never'`). */
     suppress(state: AgentFallbackState, key: string, untilEpochMs: number): void;
-    /** Lazy cooldown read: expired entries are dropped on read (spec §5.1). */
-    isSuppressed(state: AgentFallbackState, key: string, now?: number): boolean;
+    /**
+     * Lazy cooldown read (spec §5.1; plan fallbacks-half-open-recovery P2
+     * rule 3). Under `'timer'` (the default) today's body runs verbatim:
+     * expired entries are dropped on read. Under `'half-open'` the raw `until`
+     * is read via `CooldownStore.peek` (no lazy drop): absent ⇒ false;
+     * `until > now` ⇒ true; `until <= now` ⇒ the entry is dropped via the
+     * existing `isSuppressed` and the route is marked half-open, returning
+     * false. `Infinity` (`revertPolicy: 'never'`) never satisfies `until <=
+     * now` ⇒ the never short-circuit is structural on the read side.
+     */
+    isSuppressed(state: AgentFallbackState, key: string, now?: number, recovery?: RecoveryPolicy): boolean;
+    /**
+     * Bulk half-open transition for the display path (plan P4): walks the
+     * cooldown keys applying rule 3 per key. A pure no-op under `'timer'` —
+     * internal state and output stay byte-identical in default mode.
+     */
+    syncRecovery(state: AgentFallbackState, now: number, mode: RecoveryPolicy): void;
+    /**
+     * Observed completion ⇒ close the circuit (plan P2 rule 6): acts only when
+     * the entry exists and is half-open; otherwise a no-op (a stale in-flight
+     * success must not cancel a fresher escalated re-suppression).
+     */
+    observeSuccess(state: AgentFallbackState, key: string): void;
 }

package/dist/subagent-policy.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Subagent routing policy reader (plan dsh-012-subagent-routing T1; spec D1).
+ *
+ * Pure, host-free module: plain data in, results out. It resolves the
+ * effective subagent model-selection policy from two snapshots the wiring
+ * layer extracts from the host:
+ *
+ * 1. the session's `subagent/model-selection-policy` event payload, read
+ *    STRUCTURALLY — the upstream reader is not published from
+ *    `@deepseek-ai/dsh-tool-subagent` and throws on malformed payloads,
+ *    which is incompatible with the fail-closed no-throw requirement;
+ * 2. the host settings service snapshot (`SubagentModelSelectionConfig`
+ *    `.current()`), typed via a type-only peer import that is erased at emit.
+ *
+ * The session event wins over settings (ADR read order). Anything present but
+ * unreadable yields `'unprovable'` (fail-closed): callers must not emit a
+ * plugin-originated route they cannot prove is allowed. This module never
+ * throws.
+ *
+ * @module dsh-llm-fallbacks/subagent-policy
+ */
+import type { SubagentModelSelectionSettings } from '@deepseek-ai/dsh-tool-subagent/model-selection-settings';
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /**
+         * Host-recorded route policy for a model-selectable subagent session.
+         * The payload shape mirrors upstream exactly, so a future published
+         * upstream augmentation merges identically. Read structurally by this
+         * plugin; never written here.
+         */
+        'subagent/model-selection-policy': {
+            /** Exact routes this session may select explicitly for a child. */
+            allowedModels: {
+                provider: string;
+                model: string;
+            }[];
+        };
+    }
+}
+/** One exact child LLM route (structural twin of upstream `AllowedModelRoute`). */
+export type PolicyRoute = {
+    readonly provider: string;
+    readonly model: string;
+};
+/**
+ * Effective subagent routing policy for one session.
+ *
+ * - `disabled`: host policy off or absent — selection matches pre-policy
+ *   (0.3.5) behavior.
+ * - `enabled`: an allowlist is proven; plugin-originated routes must stay
+ *   inside it.
+ * - `unprovable`: the policy is on but unreadable (malformed event payload,
+ *   or enabled settings with a malformed route list) — fail-closed; no
+ *   plugin-originated route may be emitted.
+ */
+export type EffectivePolicy = {
+    readonly state: 'disabled';
+} | {
+    readonly state: 'enabled';
+    readonly allowedModels: readonly PolicyRoute[];
+} | {
+    readonly state: 'unprovable';
+};
+/** Outcome of the structural session-event read. */
+export type SessionPolicyEventRead = {
+    readonly ok: true;
+    readonly allowedModels: PolicyRoute[];
+} | {
+    readonly ok: false;
+    readonly present: true;
+} | {
+    readonly ok: false;
+    readonly present: false;
+};
+/** Settings snapshot consumed by the reader — plain structural data, no host objects. */
+export type PolicySettings = {
+    readonly enabled: boolean;
+    readonly allowedModels: readonly PolicyRoute[];
+};
+/** Assignability guard: fails typecheck if the peer's settings shape drifts from the reader's snapshot contract. */
+type AssertSettingsShape<T extends PolicySettings> = T;
+/**
+ * The host settings service snapshot type, re-exported from the published
+ * peer subpath (type-only). Wiring reads the service's `current()` and passes
+ * the result in as plain data; if upstream drifts, this alias fails typecheck
+ * instead of drifting silently at runtime (plan ADR).
+ */
+export type PeerSettingsSnapshot = AssertSettingsShape<SubagentModelSelectionSettings>;
+/**
+ * Structurally read the session's `subagent/model-selection-policy` event.
+ * Never throws: a present-but-malformed payload is reported, not raised.
+ *
+ * Recency (qc fix wave S-asym — deliberate asymmetry, both sides mirror
+ * upstream): this read takes the FIRST occurrence, exactly like the upstream
+ * reader's `.find` — the host writes the policy event at most once per
+ * session (its ensure-guard checks the reader before appending), so a second
+ * occurrence would already be off-contract. The re-emittable
+ * `model/selection` log is the opposite: `authorized-route.ts`
+ * `lastModelSelection` scans backwards because upstream's selection
+ * projection folds to the newest entry.
+ *
+ * @param events - plain event descriptors (`type` + optional `data`) captured
+ *   from the session by the wiring layer.
+ * @returns the detached route list when the event is present and valid;
+ *   otherwise a presence flag distinguishing "no policy event" (pure
+ *   inheritance path) from "policy event unreadable" (fail-closed).
+ */
+export declare function readSessionPolicyEvent(events: readonly {
+    type: string;
+    data?: unknown;
+}[]): SessionPolicyEventRead;
+/**
+ * Resolve the effective policy from the session-event read and the settings
+ * snapshot. The session event wins over settings (ADR read order).
+ * Fail-closed: a present-but-malformed event, or enabled settings with a
+ * malformed route list, yields `'unprovable'`. Never throws.
+ *
+ * @param event - result of {@link readSessionPolicyEvent}.
+ * @param settings - settings service snapshot, or undefined when the host
+ *   does not compose the service.
+ */
+export declare function effectivePolicy(event: SessionPolicyEventRead, settings: PolicySettings | undefined): EffectivePolicy;
+export {};

package/dist/virtual-adapter.d.ts

@@ -31,6 +31,7 @@
  * @module dsh-llm-fallbacks/virtual-adapter
  */
 import type { Context } from '@deepseek-ai/cordis';
+import { LlmAdapter, type GenerateOptions, type LlmImageRequestPricing, type LlmModelInfo, type LlmResolvedModelInfo, type LlmRuntime, type StreamChunk } from '@deepseek-ai/dsh-llm';
 import type { FallbacksConfig } from './config.ts';
 /** Provider route of the virtual adapter (exact string, spec lock). */
 export declare const FALLBACKS_PROVIDER = "FallbacksChain";
@@ -78,6 +79,54 @@ export declare function firstDispatchableExactHead(chain: readonly string[]): Ef
  * @param modelDisplayName - catalog/resolved name; falls back to the id.
  */
 export declare function pickerDisplayName(config: FallbacksConfig, now?: Date, modelDisplayName?: string): string;
+/**
+ * The virtual adapter (P1/P3). `stream()` is a thin head-delegate, never a
+ * second routing engine: no chain walk, cooldown, caps, revert bookkeeping,
+ * or state writes live here — those stay in the `agent/request` /
+ * `agent/request-error` listeners. Exported so the defensive guard paths
+ * the registration lifecycle cannot reach (a registered route whose `llm`
+ * vanished mid-teardown) stay unit-testable by direct construction.
+ */
+export declare class FallbacksChainAdapter extends LlmAdapter {
+    private readonly readConfig;
+    private readonly getLlm;
+    constructor(readConfig: () => FallbacksConfig, getLlm: () => LlmRuntime | undefined);
+    /** Minimal honest descriptor (P3) — the provider route IS the display name. */
+    providerInfo(provider: string): {
+        id: string;
+        name: string;
+    };
+    /** Advisory catalog: one virtual row; `name` is the live picker label. */
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    /**
+     * Proxy the current effective head's model metadata when resolvable (P3):
+     * modalities/context-window/reasoning follow the head — the truthful
+     * answer for the CURRENT head. Permissive default otherwise; never throws.
+     */
+    resolveModel(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    /**
+     * Route-accurate image pricing (0.1.2 adoption): the virtual row has no
+     * pricing of its own — the virtual `provider`/`model` arguments are
+     * intentionally ignored. Resolves the SAME effective head `stream()`
+     * dispatches and delegates through the runtime lookup, so the token
+     * meter gets exactly the answer the concrete route's adapter would give
+     * (including `undefined`). Never throws: an unresolvable head, a
+     * vanished `llm`, or a throwing delegate degrades to `undefined` — the
+     * token meter's neutral estimate.
+     */
+    imageRequestPricing(_provider: string, _model: string): LlmImageRequestPricing | undefined;
+    /**
+     * Thin head-delegate (P1): resolve the effective chain head and dispatch
+     * that REAL pair through the host LLM runtime. Throws an explicit
+     * `LlmError` only when there is no real pair to delegate to: an empty
+     * effective chain, an undispatchable head (wildcard / malformed /
+     * self-route — the recursion guard), or a vanished `llm` runtime. The
+     * runtime normalizes the throw into a terminal error finish chunk, so the
+     * documented listener-order degradation stays graceful instead of a hard
+     * outage.
+     */
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
 /**
  * Install the virtual adapter registration lifecycle (P2).
  *

package/package.json

@@ -5,7 +5,7 @@
     "dsh",
     "dsh-plugin"
   ],
-  "version": "0.3.4",
+  "version": "0.4.0-alpha.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -32,7 +32,6 @@
     },
     "client": {
       "inject": [
-        "@deepseek-ai/dsh-client-runtime",
         "@deepseek-ai/dsh-client-ui-settings-plugins",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-ui-conversation",
@@ -60,25 +59,30 @@
     "use-sync-external-store": "^1.6.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-api-gateway": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-api-remotes": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-connection": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-locale": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-runtime": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-settings-plugins": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-commands": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-typert-registry": "^0.1.1-rc.2",
-    "@deepseek-ai/schemastery": "^3.18.1",
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-agent": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-api-gateway": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-api-remotes": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-api-session-controller": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-connection": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-locale": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-store": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-chat": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-settings-plugins": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-commands": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-llm": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-llm-retry": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-settings": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-tool-subagent": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-typert-registry": "^0.1.2-alpha.2",
+    "@deepseek-ai/schemastery": "^3.18.2",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/scripts/build-client.ts

@@ -2,8 +2,9 @@
  * Client bundle build: emits the closure-factory CJS artifact the dsh web
  * loader consumes — `window.__ModuleLoader__.load({ id: 'dsh-llm-fallbacks',
  * factory: (require) => { … return module.exports; } })`. Externals resolve
- * through the loader module table (platform seed entries + the documented
- * `@deepseek-ai/dsh-client-runtime/client` exemption); everything else
+ * through the loader module table (the platform seed entries — in 0.1.2 the
+ * former runtime exemption is folded into the `@deepseek-ai/dsh-client-store`
+ * platform module, the client half's one VALUE import); everything else
  * inlines.
  *
  * Build tool: `tsdown` (rolldown) — the same tool the dsh host itself uses
@@ -47,9 +48,12 @@ const OUT_FILE = 'index.js'
 
 /**
  * Frozen loader module table (dsh mechanism-guide): the plan-documented
- * composition = PLATFORM_MODULES (7 entries, `web/src/platform.ts:8-12`)
- * + the PRELOADED_CLIENT_EXTERNALS (`@deepseek-ai/dsh-client-runtime/client`,
- * `web/src/platform.ts:15-17`). rc.8 dropped `dsh-client-web-react` (deleted
+ * composition = PLATFORM_MODULES (8 entries in 0.1.2, `web/src/platform.ts:8-15`
+ * — the old runtime `./client` exemption became the
+ * `@deepseek-ai/dsh-client-store` platform module, so the store VALUE import
+ * stays external and resolves from the host loader table) + the
+ * PRELOADED_CLIENT_EXTERNALS (empty in 0.1.2, `web/src/platform.ts:16-17`).
+ * rc.8 dropped `dsh-client-web-react` (deleted
  * package — the uSES bridge is vendored in `src/client/use-snapshot.ts`),
  * `dsh-client-ui-attachment` and `dsh-client-schema-form` from the platform
  * table. `@deepseek-ai/cordis` is the in-box cordis framework (dsh-advisor
@@ -63,9 +67,9 @@ export const CLIENT_EXTERNALS: readonly string[] = [
   'react-dom',
   'react-dom/client',
   '@deepseek-ai/cordis',
+  '@deepseek-ai/dsh-client-store',
   '@deepseek-ai/dsh-client-ui-slots',
   '@deepseek-ai/dsh-client-ui-primitives',
-  '@deepseek-ai/dsh-client-runtime/client',
 ]
 
 /**