@vidge/dsh-agent-hub 0.1.0-rc1

package/lib/types/patch-manager.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Managed-block editing for a profile's `cordis.patch.yml`.
+ *
+ * The plugin owns one contiguous block inside the user's patch file, delimited
+ * by a begin/end marker pair, and rewrites only that span — everything else the
+ * user wrote (other patches, their comments) survives byte for byte. The
+ * block's content is the loader patch that takes the loop engine over: it
+ * disables the base bundle's `agent-loop` row so this plugin's factory can
+ * register without colliding, because the harness admits exactly one
+ * AgentFactory:
+ *
+ *   # -- dsh-loop-engine managed block --
+ *   - id: agent-loop
+ *     disabled: true
+ *   # -- /dsh-loop-engine managed block --
+ *
+ * The block is now PERMANENT and engine-independent. Under per-session routing
+ * this plugin always owns the slot — it registers a router that dispatches to
+ * whichever engine a session belongs to, and it hosts the base in-process loop
+ * itself as one of those engines. The block therefore no longer carries an
+ * engine name and no longer changes when the user picks a different engine;
+ * that choice is now runtime state, not boot state.
+ *
+ * All functions here are pure string transforms — file I/O and durability live
+ * in the plugin's apply.
+ *
+ * @module dsh-agent-hub/patch-manager
+ */
+/**
+ * Begin marker of the plugin-managed span inside a profile patch file.
+ *
+ * Deliberately still spelled `dsh-loop-engine` after the package was renamed to
+ * `dsh-agent-hub`: this string is not a brand, it is the key by which the
+ * plugin recognizes a block it already wrote into the *user's* file. Renaming
+ * it would make every existing install fail to find its own span and append a
+ * second one, leaving two `agent-loop: disabled` rows in the patch list.
+ */
+export declare const MANAGED_BLOCK_BEGIN = "# -- dsh-loop-engine managed block";
+/** End marker of the plugin-managed span inside a profile patch file. */
+export declare const MANAGED_BLOCK_END = "# -- /dsh-loop-engine managed block --";
+/**
+ * Render the permanent managed block. The plugin always owns the AgentFactory
+ * slot, so the base `agent-loop` row is always disabled.
+ */
+export declare function renderManagedBlock(): string;
+/** Whether a patch-file text contains the managed block span. */
+export declare function hasManagedBlock(text: string): boolean;
+/**
+ * Ensure the permanent managed block is present, preserving every byte outside
+ * the managed span. Appends the span when absent; rewrites it in place when
+ * present, which also upgrades a legacy engine-tagged marker from the era when
+ * the block encoded the selected engine.
+ *
+ * This is a belt-and-braces layer, not the mechanism that disables the base
+ * loop. Disabling `agent-loop` is a boot-time fact and only the bundle patch can
+ * state it: the loader applies bundle layers while expanding entries, whereas
+ * this profile layer is applied afterwards and this very write happens inside
+ * apply() — by which point `AgentLoop`'s constructor has already claimed the
+ * sole AgentFactory slot. The row therefore lives in this package's own
+ * `cordis.patch.yml`, and what lands here merely re-disables an already-disabled
+ * row, which is idempotent. It is kept so a profile that pins an older bundle,
+ * or that lists `agent-loop` itself, still boots.
+ *
+ * The file must always parse as a top-level YAML *array*: app-boot's
+ * `parsePatchList` throws `must be a top-level YAML array of loader patch
+ * entries` on anything else, which fails the whole plugin tree — including this
+ * plugin's own `insert` row, so no agent factory registers at all.
+ *
+ * A fresh profile's file is `[]`, a complete flow-style document. Block
+ * sequence items cannot follow it, so the `[]` is dropped when the block goes
+ * in. The reverse direction no longer exists: the block is permanent, so it is
+ * never removed and can never leave a comments-only file behind.
+ *
+ * @param text - current patch-file text.
+ * @returns the rewritten patch-file text.
+ */
+export declare function applyManagedBlock(text: string): string;
+//# sourceMappingURL=patch-manager.d.ts.map

package/lib/types/router.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Per-session engine routing: the single AgentFactory slot owner, plus the
+ * service shadows that let every engine keep its unmodified registration calls
+ * while its three siblings are mounted alongside it.
+ *
+ * The harness admits exactly one AgentFactory (`ctx.agents.setFactory` throws
+ * on a second registration), which historically forced the engine to be a
+ * process-wide choice. This module inverts that: one {@link LoopEngineRouter}
+ * occupies the slot for the life of the process and dispatches each call to
+ * the engine that owns the session, so four engines coexist and a session's
+ * engine is fixed at creation.
+ *
+ * The engines themselves are untouched. Each is a `Service` whose constructor
+ * runs `ctx.effect(() => ctx.agents.setFactory(this))`; mounting one through a
+ * context whose `agents` member is {@link shadowAgents} redirects that call
+ * into router registration instead. `ctx.isolate('agents')` cannot do this —
+ * a second `AgentRegistry` calls `ctx.accessor('agent', …)`, which is not
+ * isolate-scoped, and the duplicate declaration fails the fiber — so the shadow
+ * wraps the *same* registry and overrides exactly one method.
+ *
+ * {@link shadowSystemPrompt} resolves the second collision the same way, for
+ * the prompt variables every engine constructor registers under the same names.
+ *
+ * @module dsh-agent-hub/router
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AgentFactory, AgentHandle, CreateAgentOptions, ResumeAgentOptions } from '@deepseek-ai/dsh-agent';
+import type { LoopEngineId } from './settings.ts';
+/**
+ * The subset of the agent registry the shadow must reproduce. Only
+ * `setFactory` is intercepted; everything else forwards to the real service.
+ */
+interface AgentsLike {
+    setFactory(factory: AgentFactory): () => void;
+}
+/**
+ * Wrap the real `agents` service so `setFactory` registers with the router
+ * instead of the harness slot.
+ *
+ * Every other member forwards to the real registry. Methods are bound to the
+ * target rather than the proxy: `AgentRegistry` keeps its state in private
+ * fields, and an unbound method invoked with the proxy as receiver would trip
+ * the brand check on those fields.
+ *
+ * @param agents - the real `ctx.agents` service.
+ * @param capture - receives the factory an engine tries to register; its return is handed back as the disposer.
+ * @returns a stand-in service to install via `ctx.extend({ agents })`.
+ */
+export declare function shadowAgents<T extends AgentsLike>(agents: T, capture: (factory: AgentFactory) => () => void): T;
+/** Resolve the engine that owns a session being resumed. */
+export type EngineResolver = (sessionId: string) => Promise<LoopEngineId> | LoopEngineId;
+/**
+ * The subset of the system-prompt service the shadow must reproduce. Only
+ * `variable` is intercepted; everything else forwards to the real service.
+ */
+interface SystemPromptLike {
+    variable(name: string, provider: (context: any) => string | undefined): () => void;
+}
+/**
+ * Wrap the real `systemPrompt` service so a prompt-variable name that a sibling
+ * engine already claimed is ignored instead of throwing.
+ *
+ * Every engine constructor registers `provider`, `model`, and `cwd` on its
+ * mount context. That context carries no scope tag, so all three registrations
+ * target the one global prompt layer and the second engine to mount dies with
+ * `prompt variable "provider" is already registered`. Under the old design only
+ * one engine was ever mounted, so the collision could not arise; hosting all
+ * four makes it certain.
+ *
+ * Scoping the mount contexts would not help: an agent mints its own scope with
+ * `createScope(loopCtx, this)` and no `parent`, so `scopeChainOf(agent)` is just
+ * `[agent]` — a variable parked on an engine-level scope would be invisible to
+ * that engine's own agents. Deduplicating on the global layer is therefore the
+ * correct level.
+ *
+ * Collapsing the three registrations to one is sound because they are
+ * byte-identical across the engines and engine-independent by construction:
+ * each reads the *assembling* agent's own options (`context.agent?.options`) or
+ * its session header, so whichever engine registered first serves every
+ * engine's agents with that agent's own values.
+ *
+ * @param systemPrompt - the real `ctx.systemPrompt` service.
+ * @param claim - decides whether this context may own `name`; false means a sibling already did.
+ * @returns a stand-in service to install via `ctx.extend({ systemPrompt })`.
+ */
+export declare function shadowSystemPrompt<T extends SystemPromptLike>(systemPrompt: T, claim: (name: string) => boolean): T;
+/** Compose extra per-agent registrations into the caller's setup callback. */
+export type SetupDecorator = (engine: LoopEngineId, agentCtx: Context) => void;
+/** Wiring the router needs from the plugin that owns it. */
+export interface RouterOptions {
+    /**
+     * The engine a new session gets when it carries no reservation: the profile
+     * default from settings.
+     */
+    engineForNewSession(): LoopEngineId;
+    /**
+     * Record a new session's engine durably, before the engine creates it.
+     *
+     * Takes the session's `meta` rather than its id alone: the persistence
+     * backend keys a session's artifact directory by `cwd`, so a record written
+     * without it lands in a directory no resume will look in.
+     */
+    remember(meta: {
+        readonly id: string;
+        readonly cwd?: string;
+    }, engine: LoopEngineId): Promise<void>;
+    /** Recover a persisted session's engine. */
+    resolve: EngineResolver;
+    /**
+     * Registers engine-specific per-agent contributions (skill providers) into
+     * the agent's own scope layer. Invoked with the scope-tagged `agentCtx` the
+     * engine passes to `setup`, so the harness's layered skill registry filters
+     * them to that session automatically.
+     */
+    decorateSetup?: SetupDecorator;
+}
+/**
+ * The process's sole AgentFactory. Holds one candidate per engine and forwards
+ * `createAgent` / `resume` to the right one.
+ *
+ * Forwarding is contract-compliant by construction: both factory methods are
+ * per-call and take the caller's `ownerCtx`, which the contract requires the
+ * implementation to attach lifecycle to ("it must not infer ownership from the
+ * factory object's registration context"). The router passes it through
+ * verbatim, so the engine owns the transaction exactly as if it had been
+ * registered directly.
+ */
+export declare class LoopEngineRouter implements AgentFactory {
+    private readonly options;
+    private readonly engines;
+    /**
+     * Engines claimed for session ids that do not exist yet.
+     *
+     * Agent creation is eager — the harness calls `createAgent` when a session is
+     * opened, not when its first prompt is sent — so a client that wants a
+     * specific engine cannot ask for it after the fact. Instead it mints the
+     * session id itself, reserves the engine here, and only then asks the host to
+     * create that id. Insertion order is the eviction order (Map preserves it).
+     */
+    private readonly reservations;
+    constructor(options: RouterOptions);
+    /**
+     * Claim an engine for a session id the caller is about to create.
+     *
+     * The reservation is consumed by the first `createAgent` for that id, so it
+     * cannot leak into a later session that happens to reuse the id.
+     *
+     * @param sessionId - id the caller will pass to session creation.
+     * @param engine - engine that session must run on.
+     */
+    reserve(sessionId: string, engine: LoopEngineId): void;
+    /**
+     * Take the engine a new session should run on: its reservation when it has
+     * one, the profile default otherwise.
+     */
+    private claim;
+    /**
+     * Register one engine's factory as a routing candidate.
+     * @param engine - the engine id this factory implements.
+     * @param factory - the engine's factory, captured from its `setFactory` call.
+     * @returns a disposer that withdraws the candidate.
+     */
+    register(engine: LoopEngineId, factory: AgentFactory): () => void;
+    /** The shadow to install on the context that mounts `engine`. */
+    shadowFor<T extends AgentsLike>(engine: LoopEngineId, agents: T): T;
+    /**
+     * Look up a mounted engine, failing loud when it is selected but absent.
+     * A silent fallback would run the session on an engine that cannot read its
+     * history, which is the exact defect per-session routing exists to remove.
+     */
+    private factoryFor;
+    /** Wrap the caller's setup so the engine's per-agent registrations land in the agent's scope. */
+    private withSetup;
+    /**
+     * Create a session on the engine it reserved, or on the profile default when
+     * it made no reservation. The engine is recorded durably *before* delegation:
+     * a crash between the two leaves an orphan record (harmless — no session ever
+     * reads it), whereas the reverse order would leave a session whose engine
+     * cannot be recovered.
+     *
+     * `options.meta.cwd` is forwarded to the record so the sidecar lands in the
+     * same per-project directory the backend will write the session into.
+     */
+    createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+    /** Resume a session on the engine that created it. */
+    resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
+}
+export {};
+//# sourceMappingURL=router.d.ts.map

package/lib/types/rpc.d.ts

@@ -0,0 +1,113 @@
+/**
+ * The `/loop-engine` Connection RPC channel: the browser's only route to the
+ * node half's per-session engine state.
+ *
+ * Two facts about the harness make this channel necessary rather than merely
+ * convenient:
+ *
+ *  - **Agent creation is eager.** `createAgent` fires when a session is
+ *    *opened*, not when its first prompt is sent, so by the time a user can
+ *    click anything in the composer the engine is already chosen. A client that
+ *    wants a specific engine must therefore say so *before* creating the
+ *    session — hence `bind`, which reserves an engine for a session id the
+ *    client mints itself.
+ *  - **The engine lives in a node-side sidecar.** Nothing in the session log,
+ *    header, or settings carries it (see {@link ../engine-record.ts} for why
+ *    each of those is closed), so the browser cannot read it from any existing
+ *    projection — hence `resolve`.
+ *
+ * A custom Connection channel is the smallest seam that provides both. The
+ * alternative, a `@Remote` service on the typert gateway, would work on the
+ * host but requires hand-written strict zod descriptors on the client
+ * (`requireStrictDescriptor` rejects reflection-derived ones), which is a large
+ * contract surface for two internal methods. This plugin owns both ends of this
+ * channel, so it validates its own payloads and needs no codec at all.
+ *
+ * @module dsh-agent-hub/rpc
+ */
+import { type LoopEngineId } from './settings.ts';
+/** Channel path this plugin owns. Reserved names (`/api`) are refused by the host. */
+export declare const LOOP_ENGINE_RPC_CHANNEL = "/loop-engine";
+/** Carrier-neutral result shape the Connection RPC transport expects back. */
+export type RpcResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+        readonly details: object;
+    };
+};
+/** One logical endpoint handler, as `connection.rpc.handle` supplies it. */
+export type RpcHandler = (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<RpcResult<unknown>>;
+/**
+ * Trust fence the host applies before a request reaches this channel's handler.
+ *
+ * `trusted-host` accepts any authority in the deployment's configured
+ * `trustedHosts`; `loopback` narrows to loopback only. This channel takes
+ * `trusted-host` because it must work wherever the composer works — a dsh
+ * reachable over a LAN authority serves the same UI, and a stricter fence would
+ * 403 the seat's own requests on exactly those deployments.
+ */
+export type ConnectionRpcAuthority = 'trusted-host' | 'loopback';
+/** Registration policy `rpc.handle` requires for a channel. */
+export interface ConnectionRpcHandlerOptions {
+    /** Browser authority accepted by every endpoint in this channel. */
+    readonly authority: ConnectionRpcAuthority;
+}
+/**
+ * The host Connection surface this module borrows. Declared structurally so the
+ * plugin needs no peer dependency on the connection package, and so a profile
+ * without a Connection (headless, SDK) degrades instead of failing to mount.
+ *
+ * `options` is **required**, and getting that wrong fails in a way worth
+ * spelling out: the host reads `options.authority` on the first line of
+ * `register`, so omitting the argument throws `Cannot read properties of
+ * undefined (reading 'authority')` *inside the effect*. Cordis swallows that
+ * into the fiber, the plugin keeps running, every engine still works — and the
+ * route is simply never added, so every request to the channel falls through to
+ * the plugin-bundle server and comes back 405. Nothing logs at the default
+ * level. Structural typing is what let this compile: the declaration below is
+ * the plugin's own, so it cannot disagree with the installed package unless it
+ * is kept in step with it by hand.
+ */
+export interface ConnectionLike {
+    readonly rpc: {
+        handle(channel: string, handler: RpcHandler, options: ConnectionRpcHandlerOptions): () => Promise<void>;
+    };
+}
+/** The router operations this channel drives. */
+export interface EngineRpcTarget {
+    /** Claim an engine for a session id the client is about to create. */
+    reserve(sessionId: string, engine: LoopEngineId): void;
+    /** Read back the engine a session is actually bound to. */
+    recall(sessionId: string): Promise<LoopEngineId>;
+    /** The profile default, for a session that has no record yet. */
+    fallback(): LoopEngineId;
+}
+/**
+ * Build the `/loop-engine` handler.
+ *
+ * Exported separately from {@link installEngineRpc} so the endpoints are
+ * testable without a Connection.
+ *
+ * @param target - the router and record store operations to drive.
+ * @returns the handler to register on the channel.
+ */
+export declare function createEngineRpcHandler(target: EngineRpcTarget): RpcHandler;
+/**
+ * Register the channel when the profile has a Connection.
+ *
+ * The Connection is injected conditionally by the gateway, so a headless or SDK
+ * profile legitimately has none. There the plugin keeps working — per-session
+ * routing is a node-side property — and only the browser controls degrade.
+ *
+ * @param connection - the host connection, or undefined when absent.
+ * @param register - installs the handler under the plugin's effect lifecycle.
+ * @param target - the router and record store operations to drive.
+ * @returns whether the channel was registered.
+ */
+export declare function installEngineRpc(connection: ConnectionLike | undefined, register: (install: () => () => Promise<void>, label: string) => void, target: EngineRpcTarget): boolean;
+//# sourceMappingURL=rpc.d.ts.map

package/lib/types/settings.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared loop-engine identity, namespace, and schema.
+ *
+ * The namespace literal lives in the zero-import `./namespace.ts` so both
+ * halves agree on the section name: the node half brands it through
+ * `settingsNamespace()` (a runtime value), while the browser half imports the
+ * same literal without pulling the host-side `dsh-settings` service into the
+ * client bundle (cross-plugin value imports go through cordis services, and
+ * `settings-scope.ts` follows the same discipline).
+ *
+ * @module dsh-agent-hub/settings
+ */
+import z from '@deepseek-ai/schemastery';
+import type { SettingsNamespace } from '@deepseek-ai/dsh-settings';
+import { type LoopEngineId } from './namespace.ts';
+export { LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL } from './namespace.ts';
+export { LOOP_ENGINE_IDS, type LoopEngineId } from './namespace.ts';
+/** Stored and composed loop engine selection. */
+export interface LoopEngineSettings {
+    /** The engine future Agents are created on. */
+    engine: LoopEngineId;
+    /** Whether the composer's loop engine picker is shown on the chat page. */
+    showInComposer: boolean;
+}
+/** Schema of the loop engine settings section. */
+export declare const LOOP_ENGINE_SETTINGS_SCHEMA: z<LoopEngineSettings>;
+/** Brand the shared literal through the settings API on the node side. */
+export declare function loopEngineSettingsNamespace(): SettingsNamespace;
+//# sourceMappingURL=settings.d.ts.map

package/lib/types/skills.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Claude Code skill provider: discovers skills from the project's `.claude/`
+ * directory, the user-level `~/.claude/skills/` directory, and the project's
+ * `CLAUDE.md` file, using the same YAML-frontmatter + markdown format as DSH
+ * skills.
+ *
+ * @module dsh-agent-hub/skills
+ */
+export interface SkillInvocationPolicy {
+    readonly modelInvocable: boolean;
+    readonly userInvocable: boolean;
+}
+export type SkillSource = string;
+export interface SkillCandidate {
+    readonly name: string;
+    readonly description: string;
+    readonly whenToUse?: string;
+    readonly invocation: SkillInvocationPolicy;
+    readonly source: SkillSource;
+    readonly provider: string;
+    readonly rank: number;
+    readonly locator: unknown;
+    readonly path?: string;
+    readonly resourceBase?: {
+        readonly kind: string;
+        readonly path: string;
+    };
+}
+export interface SkillDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly whenToUse?: string;
+    readonly invocation: SkillInvocationPolicy;
+    readonly source: SkillSource;
+    readonly provider: string;
+    readonly content: string;
+    readonly path?: string;
+    readonly resourceBase?: {
+        readonly kind: string;
+        readonly path: string;
+    };
+}
+export interface SkillLookupOptions {
+    readonly cwd?: string;
+    readonly signal?: AbortSignal;
+}
+export interface SkillProvider {
+    readonly name: string;
+    list(options: SkillLookupOptions): Promise<readonly SkillCandidate[] | {
+        candidates: readonly SkillCandidate[];
+        complete: boolean;
+    }>;
+    get(candidate: SkillCandidate, options: SkillLookupOptions): Promise<SkillDefinition | undefined>;
+}
+export interface SkillProviderControl {
+    readonly signal: AbortSignal;
+    invalidate(): void;
+}
+/** One parsed agents-skill standard skill: frontmatter metadata plus the body. */
+export interface ParsedSkill {
+    name: string;
+    description: string;
+    whenToUse?: string;
+    invocation: SkillInvocationPolicy;
+    content: string;
+}
+/**
+ * Parse one agents-skill standard file: YAML frontmatter (`name`,
+ * `description`, optional `whenToUse`/`disable-model-invocation`/
+ * `user-invocable`) plus the markdown body.
+ * @param raw - the raw file content.
+ * @returns the parsed skill, or `undefined` when the file is not a skill.
+ */
+export declare function parseSkillFile(raw: string): ParsedSkill | undefined;
+/**
+ * Skill provider that discovers skills from Claude Code's standard locations:
+ *   - `<project>/.claude/skills/` — project skills
+ *   - `~/.claude/skills/` — personal skills
+ * Each location accepts both Claude Code layouts: a `<name>/SKILL.md`
+ * directory (its directory becomes the resource base) and a flat `<name>.md`
+ * file. `CLAUDE.md` in the project root is also read when it carries skill
+ * frontmatter.
+ */
+export declare class ClaudeCodeSkillProvider implements SkillProvider {
+    private readonly control;
+    readonly name = "claude-code";
+    constructor(control: SkillProviderControl);
+    list(options: SkillLookupOptions): Promise<readonly SkillCandidate[]>;
+    get(candidate: SkillCandidate, _options: SkillLookupOptions): Promise<SkillDefinition | undefined>;
+}
+export declare function findProjectRoot(cwd: string): Promise<string>;
+export default ClaudeCodeSkillProvider;
+//# sourceMappingURL=skills.d.ts.map

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@vidge/dsh-agent-hub",
+  "description": "Per-session agent loop engine router for DSH — run Claude Code, Codex, pi, or the in-process loop per session, all on DSH's unified session, LLM, and tracing substrate",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.1.0-rc1",
+  "repository": "github:vidgewong/dsh-agent-hub",
+  "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"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts",
+    "cordis.patch.yml"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "node build.mjs",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-api-remotes"
+      ],
+      "platform": "web"
+    }
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "0.93.0",
+    "@deepseek-ai/schemastery": "3.18.1"
+  },
+  "optionalDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.220",
+    "@earendil-works/pi-coding-agent": "0.84.3",
+    "@openai/codex": "0.149.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-agent-loop": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-invariants": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.1-rc.2 || 0.1.2-alpha.2",
+    "@deepseek-ai/dsh-scope": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-persistence": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-settings": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-subprocess": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-timeout": "0.1.1-rc.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-attachment": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-agent-loop": "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-store": "0.1.2-alpha.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-slots": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-home-paths": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-subprocess-local": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.1-rc.2",
+    "@types/node": "^22.20.0",
+    "@types/react": "^19.0.0",
+    "@vitest/coverage-v8": "^4.1.8",
+    "esbuild": "^0.28.2",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "vite": "^7.0.0",
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.1.8",
+    "yaml": "^2.9.0"
+  }
+}