dsh-loop-engine 1.0.0-rc7 → 1.0.0-rc9

package/lib/invariant.js

@@ -1,6 +1,5 @@
 // src/settings.ts
 import z from "@deepseek-ai/schemastery";
-import { settingsNamespace } from "@deepseek-ai/dsh-settings";
 var LOOP_ENGINE_IDS = ["in-process", "claude-code", "codex", "pi", "kimi"];
 var LOOP_ENGINE_SETTINGS_SCHEMA = z.object({
   engine: z.union([z.const("in-process"), z.const("claude-code"), z.const("codex"), z.const("pi"), z.const("kimi")]).default("in-process"),
@@ -18,6 +17,8 @@ function renderManagedBlock(engine) {
     `${MANAGED_BLOCK_BEGIN}${engine} --`,
     "- id: agent-loop",
     "  disabled: true",
+    "- id: command-goal",
+    "  disabled: true",
     END_MARKER_LINE
   ].join("\n");
 }

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

@@ -9,7 +9,7 @@
  * @module dsh-loop-engine/client/badge
  */
 import type { JSX } from 'react';
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
 import type { LoopEngineState } from './store.ts';
 import type { en } from './locales.ts';

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

@@ -13,7 +13,7 @@
  * @module dsh-loop-engine/client/composer
  */
 import { type JSX } from 'react';
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
 import type { LoopEngineStore, LoopEngineState } from './store.ts';
 import type { en } from './locales.ts';

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

@@ -12,7 +12,7 @@
  * @module dsh-loop-engine/client
  */
 import { type JSX } from 'react';
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
 import type { LoopEngineStore, LoopEngineState } from './store.ts';
 import type { en } from './locales.ts';

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

@@ -5,7 +5,7 @@
  * Export discipline: packages/client/AGENTS.md.
  * @module dsh-loop-engine/client
  */
-import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
 import { type LoopEngineKey } from './locales.ts';
 export type { LoopEngineSectionInjected, LoopEngineSectionProps } from './LoopEngineSection.tsx';
 export type { LoopEngineBadgeInjected, LoopEngineBadgeProps } from './LoopEngineBadge.tsx';

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

@@ -34,6 +34,8 @@ export interface LoopEngineKey {
     confirmAction: string;
     /** Cancel action label. */
     cancelAction: string;
+    /** Accessible close-button label of the confirmation dialog. */
+    closeLabel: string;
     /** Notice shown while the Claude Code engine owns the slot: model selection is native. */
     claudeModelNotice: string;
 }

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

@@ -3,7 +3,8 @@
  * and the store publishes a render-safe snapshot plus the write path.
  * @module dsh-loop-engine/client/store
  */
-import type { SettingsScope, SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SettingsScope } from '@deepseek-ai/dsh-client-ui-settings/client';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { LoopEngineId } from '../settings.ts';
 /** State rendered by the loop engine section. */
 export interface LoopEngineState {

package/lib/types/driver-core/ownership.d.ts

@@ -9,11 +9,10 @@
  *
  * @module dsh-loop-engine/driver-core/ownership
  */
-import { FiberState } from '@deepseek-ai/cordis';
 import type { Context } from '@deepseek-ai/cordis';
 import type { SessionId } from '@deepseek-ai/dsh-session';
 /** Fiber states that cannot own or serve a new lifecycle. */
-export declare const INACTIVE_STATES: ReadonlySet<FiberState>;
+export declare const INACTIVE_STATES: ReadonlySet<number>;
 /** Factory-level ownership: live agent teardowns plus load-time tracking. */
 export declare class FactoryOwnership {
     private readonly fiber;

package/lib/types/engine-claude/agent.d.ts

@@ -12,6 +12,8 @@ import type { Scope } from '@deepseek-ai/dsh-scope';
 import type { Session, SessionId, UserMessage } from '@deepseek-ai/dsh-session';
 import type { Context } from '@deepseek-ai/cordis';
 import type { ResolvedConfig } from './types.ts';
+/** Provider route label used for logged header snapshots and message provenance. */
+export declare const PROVIDER = "claude-code";
 /** Drives one session through turn and step boundaries on Claude Code. */
 export declare class ClaudeCodeAgent implements Agent {
     private loopCtx;

package/lib/types/engine-claude/loop.d.ts

@@ -70,12 +70,34 @@ export declare class ClaudeCodeLoop extends Service implements AgentFactory {
     private setupAndPublish;
     /**
      * Create an agent and session under one caller-supplied identity, owned by
-     * the accessing fiber.
+     * the accessing fiber. When a persistence backend is mounted, the session's
+     * durable identity is stored before publication.
      * @param ownerCtx - caller context that structurally owns the lifecycle.
      * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
      * @returns the published handle.
      */
     createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+    /**
+     * Take a fresh session's write ownership when persistence is mounted.
+     * Nothing is appended here: the constructor seed (which never re-emits
+     * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
+     * publication commit point, so a failed or cancelled setup closes an
+     * unmaterialized handle and leaves no stored residue — the same id can be
+     * created again.
+     * @param session - the unpublished session to store.
+     * @param signal - optional cancellation forwarded to the backend create.
+     * @returns the owned handle and stored cursor, or `undefined` without a backend.
+     */
+    private createStoredSession;
+    /**
+     * Durably store the session events appended since the last stored cursor.
+     * Pre-publication appends (constructor seed markers, setup-window events)
+     * never re-emit through `session/event`, so publication must flush them
+     * through the handle before live events start routing into it.
+     * @param stored - the session's owned handle and stored cursor, if any.
+     * @param session - the unpublished session whose suffix is stored.
+     */
+    private appendUnstoredSuffix;
     /**
      * Resume an owned agent from the configured persistence service.
      * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
@@ -83,7 +105,7 @@ export declare class ClaudeCodeLoop extends Service implements AgentFactory {
      * @returns the published handle.
      */
     resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
-    /** Resume through an explicit persistence handle. */
+    /** Resume through an explicit persistence service. */
     private resumeWith;
 }
 //# sourceMappingURL=loop.d.ts.map

package/lib/types/engine-claude/mapping.d.ts

@@ -8,11 +8,11 @@
  */
 import type { BetaMessage, BetaRawMessageStreamEvent, BetaUsage } from '@anthropic-ai/sdk/resources/beta/messages/messages.mjs';
 import type { MessageParam } from '@anthropic-ai/sdk/resources';
-import { CallId, type ContentBlock, type StreamChunk, type TokenUsage, type ToolResultMessage } from '@deepseek-ai/dsh-llm';
+import { ToolCallId, type ContentBlock, type StreamChunk, type TokenUsage, type ToolResultMessage } from '@deepseek-ai/dsh-llm';
 /** One tool invocation surfaced from a Claude Code assistant message. */
 export interface MappedToolCall {
     /** SDK tool_use id, reused as the dsh call-id so results pair. */
-    readonly callId: CallId;
+    readonly callId: ToolCallId;
     /** Tool name exactly as the SDK reported it. */
     readonly name: string;
     /** Raw JSON arguments string as the SDK produced them. */
@@ -63,7 +63,7 @@ export declare function mapToolResults(message: MessageParam): ToolResultMessage
 export declare function mapUsage(usage: BetaUsage): TokenUsage;
 /** Per-block-index tool-call identity captured at `content_block_start`, reused by `input_json_delta`. */
 export interface StreamToolCall {
-    readonly callId: CallId;
+    readonly callId: ToolCallId;
     readonly name: string;
 }
 /**

package/lib/types/engine-codex/agent.d.ts

@@ -17,6 +17,8 @@ import type { Scope } from '@deepseek-ai/dsh-scope';
 import type { Session, SessionId, UserMessage } from '@deepseek-ai/dsh-session';
 import type { Context } from '@deepseek-ai/cordis';
 import type { ResolvedConfig } from './types.ts';
+/** Provider route label used for logged header snapshots and message provenance. */
+export declare const PROVIDER = "codex";
 /** Drives one session through turn and step boundaries on Codex. */
 export declare class CodexAgent implements Agent {
     private loopCtx;

package/lib/types/engine-codex/appserver/mapping.d.ts

@@ -8,7 +8,7 @@
  * @module dsh-loop-engine/engine-codex/appserver/mapping
  */
 import type { TokenUsage, ToolResultMessage } from '@deepseek-ai/dsh-llm';
-import { CallId } from '@deepseek-ai/dsh-llm';
+import { ToolCallId } from '@deepseek-ai/dsh-llm';
 /** Map app-server turn usage to dsh TokenUsage. */
 export declare function mapUsage(usage: {
     inputTokens: number;
@@ -25,7 +25,7 @@ export declare function mapCommandExecution(item: {
     status?: string;
 }): {
     call: {
-        callId: CallId;
+        callId: ToolCallId;
         name: string;
         arguments: string;
     };
@@ -38,7 +38,7 @@ export declare function mapFileChange(item: {
     status?: string;
 }): {
     call: {
-        callId: CallId;
+        callId: ToolCallId;
         name: string;
         arguments: string;
     };
@@ -58,7 +58,7 @@ export declare function mapMcpToolCall(item: {
     };
 }): {
     call: {
-        callId: CallId;
+        callId: ToolCallId;
         name: string;
         arguments: string;
     };

package/lib/types/engine-codex/loop.d.ts

@@ -73,12 +73,34 @@ export declare class CodexLoop extends Service implements AgentFactory {
     private setupAndPublish;
     /**
      * Create an agent and session under one caller-supplied identity, owned by
-     * the accessing fiber.
+     * the accessing fiber. When a persistence backend is mounted, the session's
+     * durable identity is stored before publication.
      * @param ownerCtx - caller context that structurally owns the lifecycle.
      * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
      * @returns the published handle.
      */
     createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+    /**
+     * Take a fresh session's write ownership when persistence is mounted.
+     * Nothing is appended here: the constructor seed (which never re-emits
+     * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
+     * publication commit point, so a failed or cancelled setup closes an
+     * unmaterialized handle and leaves no stored residue — the same id can be
+     * created again.
+     * @param session - the unpublished session to store.
+     * @param signal - optional cancellation forwarded to the backend create.
+     * @returns the owned handle and stored cursor, or `undefined` without a backend.
+     */
+    private createStoredSession;
+    /**
+     * Durably store the session events appended since the last stored cursor.
+     * Pre-publication appends (constructor seed markers, setup-window events)
+     * never re-emit through `session/event`, so publication must flush them
+     * through the handle before live events start routing into it.
+     * @param stored - the session's owned handle and stored cursor, if any.
+     * @param session - the unpublished session whose suffix is stored.
+     */
+    private appendUnstoredSuffix;
     /**
      * Resume an owned agent from the configured persistence service.
      * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
@@ -86,7 +108,7 @@ export declare class CodexLoop extends Service implements AgentFactory {
      * @returns the published handle.
      */
     resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
-    /** Resume through an explicit persistence handle. */
+    /** Resume through an explicit persistence service. */
     private resumeWith;
 }
 //# sourceMappingURL=loop.d.ts.map

package/lib/types/engine-kimi/agent.d.ts

@@ -17,6 +17,8 @@ import type { Session, SessionId, UserMessage } from '@deepseek-ai/dsh-session';
 import type { Context } from '@deepseek-ai/cordis';
 import type { ResolvedConfig } from './types.ts';
 import type { KimiSpawnCapability } from './process.ts';
+/** Provider route label used for logged header snapshots and message provenance. */
+export declare const PROVIDER = "kimi";
 /** Drives one session through turn and step boundaries on Kimi Code. */
 export declare class KimiAgent implements Agent {
     private loopCtx;

package/lib/types/engine-kimi/commands.d.ts

@@ -16,6 +16,13 @@
  * the goal form). `skill:` commands are already carried by the dsh skill
  * injection seam and Kimi's own shorthand, so they are not duplicated here.
  *
+ * `model` is deliberately absent even though the CLI has it: the dsh web
+ * client owns a `/model` contribution, and a same-named host command makes
+ * `ui-commands` throw the whole command menu source away, leaving only the
+ * skill group. `/goal` stays: the managed block disables dsh's `command-goal`
+ * row for hosted engines, so the slot is free and the CLI's own goal mode
+ * takes it over.
+ *
  * @module dsh-loop-engine/engine-kimi/commands
  */
 import type { CommandDefinition, CommandInvocation, CommandResult } from '../commands.ts';

package/lib/types/engine-kimi/loop.d.ts

@@ -67,12 +67,34 @@ export declare class KimiLoop extends Service implements AgentFactory {
     private setupAndPublish;
     /**
      * Create an agent and session under one caller-supplied identity, owned by
-     * the accessing fiber.
+     * the accessing fiber. When a persistence backend is mounted, the session's
+     * durable identity is stored before publication.
      * @param ownerCtx - caller context that structurally owns the lifecycle.
      * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
      * @returns the published handle.
      */
     createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+    /**
+     * Take a fresh session's write ownership when persistence is mounted.
+     * Nothing is appended here: the constructor seed (which never re-emits
+     * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
+     * publication commit point, so a failed or cancelled setup closes an
+     * unmaterialized handle and leaves no stored residue — the same id can be
+     * created again.
+     * @param session - the unpublished session to store.
+     * @param signal - optional cancellation forwarded to the backend create.
+     * @returns the owned handle and stored cursor, or `undefined` without a backend.
+     */
+    private createStoredSession;
+    /**
+     * Durably store the session events appended since the last stored cursor.
+     * Pre-publication appends (constructor seed markers, setup-window events)
+     * never re-emit through `session/event`, so publication must flush them
+     * through the handle before live events start routing into it.
+     * @param stored - the session's owned handle and stored cursor, if any.
+     * @param session - the unpublished session whose suffix is stored.
+     */
+    private appendUnstoredSuffix;
     /**
      * Resume an owned agent from the configured persistence service.
      * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
@@ -80,7 +102,7 @@ export declare class KimiLoop extends Service implements AgentFactory {
      * @returns the published handle.
      */
     resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
-    /** Resume through an explicit persistence handle. */
+    /** Resume through an explicit persistence service. */
     private resumeWith;
 }
 //# sourceMappingURL=loop.d.ts.map

package/lib/types/engine-pi/agent.d.ts

@@ -17,6 +17,8 @@ import type { Session, SessionId, UserMessage } from '@deepseek-ai/dsh-session';
 import type { Context } from '@deepseek-ai/cordis';
 import type { ResolvedConfig } from './types.ts';
 import { type PiSpawnCapability } from './rpc/client.ts';
+/** Provider route label used for logged header snapshots and message provenance. */
+export declare const PROVIDER = "pi";
 /** Drives one session through turn and step boundaries on Pi. */
 export declare class PiAgent implements Agent {
     private loopCtx;
@@ -107,6 +109,14 @@ export declare class PiAgent implements Agent {
     private modelLabel;
     /** Append the request header snapshot once per loop instance. */
     private assertRequestHeader;
+    /**
+     * The harness Session's web-side model selection, if any was stored. The
+     * durable `model/selection` event carries `{ provider, model, ... }`; when a
+     * user picked a model via `/model`, this is the newest pick, and it overrides
+     * the deployment config (which stays the fallback). Returns `undefined` when
+     * no selection was stored, so the deployment config governs.
+     */
+    private dynamicModel;
     /** Build the `pi --mode rpc` argv/cwd/env for one step's child process. */
     private spawnSpec;
     /**

package/lib/types/engine-pi/loop.d.ts

@@ -14,6 +14,7 @@ import { Service } from '@deepseek-ai/cordis';
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 import type { AgentFactory, AgentHandle, CreateAgentOptions, ResumeAgentOptions } from '@deepseek-ai/dsh-agent';
+import type { PiModelEntry } from './probe.ts';
 import type { PiProcess, PiSpawnSpec } from './rpc/client.ts';
 import type { PiSandboxMode, ResolvedConfig } from './types.ts';
 /** Pi CLI sandbox modes a deployment may pin. */
@@ -38,6 +39,10 @@ export interface Config {
     thinkingLevel?: string;
     /** Explicit environment entries passed to the `pi` child. */
     env?: Record<string, string>;
+    /** Shared Pi model catalog holder; the loop writes its `pi --list-models` probe result here. */
+    piCatalogHolder?: {
+        entries: readonly PiModelEntry[];
+    };
 }
 /** Schema of the Pi loop plugin configuration. */
 export declare const Config: z<Config>;
@@ -77,12 +82,34 @@ export declare class PiLoop extends Service implements AgentFactory {
     private setupAndPublish;
     /**
      * Create an agent and session under one caller-supplied identity, owned by
-     * the accessing fiber.
+     * the accessing fiber. When a persistence backend is mounted, the session's
+     * durable identity is stored before publication.
      * @param ownerCtx - caller context that structurally owns the lifecycle.
      * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
      * @returns the published handle.
      */
     createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+    /**
+     * Take a fresh session's write ownership when persistence is mounted.
+     * Nothing is appended here: the constructor seed (which never re-emits
+     * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
+     * publication commit point, so a failed or cancelled setup closes an
+     * unmaterialized handle and leaves no stored residue — the same id can be
+     * created again.
+     * @param session - the unpublished session to store.
+     * @param signal - optional cancellation forwarded to the backend create.
+     * @returns the owned handle and stored cursor, or `undefined` without a backend.
+     */
+    private createStoredSession;
+    /**
+     * Durably store the session events appended since the last stored cursor.
+     * Pre-publication appends (constructor seed markers, setup-window events)
+     * never re-emit through `session/event`, so publication must flush them
+     * through the handle before live events start routing into it.
+     * @param stored - the session's owned handle and stored cursor, if any.
+     * @param session - the unpublished session whose suffix is stored.
+     */
+    private appendUnstoredSuffix;
     /**
      * Resume an owned agent from the configured persistence service.
      * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
@@ -90,7 +117,7 @@ export declare class PiLoop extends Service implements AgentFactory {
      * @returns the published handle.
      */
     resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
-    /** Resume through an explicit persistence handle. */
+    /** Resume through an explicit persistence service. */
     private resumeWith;
 }
 //# sourceMappingURL=loop.d.ts.map

package/lib/types/engine-pi/probe.d.ts

@@ -0,0 +1,23 @@
+import type { PiProcess, PiSpawnSpec } from './rpc/client.ts';
+/** One discoverable Pi model: the raw two-part identity `pi` exposes. */
+export interface PiModelEntry {
+    readonly provider: string;
+    readonly model: string;
+}
+/**
+ * Parse the output of `pi --list-models`: a column-aligned table whose first
+ * two columns are `provider` and `model`. The header row and blank lines are
+ * skipped; long model ids simply occupy more columns. Splitting on 2+ spaces
+ * yields provider and model in the first two fields regardless of alignment.
+ */
+export declare function parsePiModelList(output: string): PiModelEntry[];
+/**
+ * Spawn `pi --list-models` and return the parsed model entries. Failures
+ * (non-zero exit, no stdout, spawn throw) resolve to an empty array so the
+ * catalog stays advisory and a probe glitch never breaks the engine mount.
+ * @param bin - the Pi CLI entrypoint (from `piCliEntrypoint()`); becomes spec.argv[0].
+ * @param spawn - the process-spawn adapter; `piSubprocessSpec` prepends the node
+ *   prefix, so spec.argv must NOT carry it.
+ */
+export declare function probePiModels(bin: string, spawn: (spec: PiSpawnSpec) => PiProcess): Promise<readonly PiModelEntry[]>;
+//# sourceMappingURL=probe.d.ts.map

package/lib/types/index.d.ts

@@ -17,6 +17,22 @@
  * The settings section is seeded from the block so the UI mirrors the file,
  * and a committed settings change writes the block (only when it differs).
  *
+ * A hosted engine also takes over the session's command and skill surface:
+ * the block disables dsh's `command-goal` row, and the plugin authors a
+ * stripped copy of the `standard` agent preset into the user preset root
+ * (see `preset.ts`) and steers the `agent-presets` roster default to it, so
+ * new sessions get the engine's commands and skills instead of the dsh-native
+ * ones an external engine cannot honor. Switching back to `in-process`
+ * restores the previous default.
+ *
+ * While a hosted engine is mounted the plugin also serves its provider route
+ * label (`claude-code` / `codex` / `pi` / `kimi`) from the llm registry with
+ * a model-less placeholder adapter (see `provider-route.ts`): the engine logs
+ * that label into each session's request/header, and the web host refuses a
+ * turn whose session selection names a provider no adapter serves — without
+ * the placeholder the second prompt of every hosted session would fail with
+ * `model-unavailable`.
+ *
  * @module dsh-loop-engine
  */
 import { Context } from '@deepseek-ai/cordis';

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

@@ -12,8 +12,17 @@
  *   # -- dsh-loop-engine managed block: claude-code --
  *   - id: agent-loop
  *     disabled: true
+ *   - id: command-goal
+ *     disabled: true
  *   # -- /dsh-loop-engine managed block --
  *
+ * The `command-goal` row goes down with the loop: a hosted engine owns the
+ * session's command surface, and dsh's `/goal` would otherwise collide with
+ * an engine's own goal command (Kimi) or dangle over a goal service nothing
+ * drives (the other engines). The remaining dsh-native commands (`/export`,
+ * `/feedback`, `/permission`) are engine-agnostic session/settings controls
+ * that keep working under a hosted engine, so they stay.
+ *
  * `in-process` renders an absent block (the base bundle's `agent-loop` row
  * stays active and supplies the factory), so switching back removes the span
  * entirely. Any other engine renders the same disable block, and the begin

package/lib/types/preset.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Hosted-engine agent preset: a managed copy of the deployment's `standard`
+ * preset with the dsh-native command and skill rows stripped.
+ *
+ * A hosted engine (Claude Code, Codex, Pi, Kimi) owns its session's command
+ * and skill surface: the engine's own slash commands and skill providers are
+ * registered globally by the plugin, and the dsh-native equivalents would only
+ * duplicate or mislead — dsh `/plan` is advisory prompt text an external
+ * engine never assembles, dsh `/compact` cannot shrink a context the engine's
+ * child process holds, and dsh skills would sit next to the engine's own
+ * catalog. Those rows live inside the agent-preset composition, which a
+ * profile patch cannot reach, so the plugin authors a stripped preset into the
+ * user preset root (`$DSH_HOME/.agent-presets/<id>`) and steers the roster's
+ * default at runtime (see the plugin's apply).
+ *
+ * The preset is REGENERATED from the current `standard` composition on every
+ * boot that needs it: text on disk is never authoritative, so a harness
+ * upgrade that changes `standard` flows through. The file is plain YAML the
+ * loader already accepts — the strip is a line transform that preserves
+ * everything it does not drop byte for byte, comments included.
+ *
+ * @module dsh-loop-engine/preset
+ */
+/** Preset id the plugin authors into the user preset root. */
+export declare const HOSTED_PRESET_ID = "loop-engine";
+/** Harness-home-relative directory of locally authored presets (mirrors `USER_PRESET_DIR` in `dsh-agent-presets`). */
+export declare const USER_PRESET_DIR = ".agent-presets";
+/** The composition file that makes a directory a preset. */
+export declare const COMPOSITION_FILE = "agent.cordis.yml";
+/** The display-metadata file beside a preset's composition. */
+export declare const METADATA_FILE = "preset.yml";
+/** Source preset the hosted preset derives from. */
+export declare const SOURCE_PRESET_ID = "standard";
+/**
+ * Top-level rows stripped from the source preset for hosted engines:
+ * - `skill-filesystem` / `tool-skill`: the dsh skill surface — each engine
+ *   registers its own skill provider globally;
+ * - `tool-goal`: the model-facing goal tool — the managed block already
+ *   disables dsh's `/goal` command for hosted engines;
+ * - `planning`: dsh plan mode — its only model-visible effect is a system
+ *   prompt section an external engine never assembles;
+ * - `compaction`: dsh `/compact` and auto-compaction — a hosted engine owns
+ *   its context and its own `/compact` (Claude, Kimi).
+ */
+export declare const STRIPPED_ROWS: readonly ["skill-filesystem", "tool-skill", "tool-goal", "planning", "compaction"];
+/**
+ * Remove top-level entries by id from a preset composition, preserving every
+ * other byte. Each entry owns the comment/blank run directly above its opener
+ * — that run is the entry's section heading and drops with it — except the
+ * run above the FIRST entry, which is the file header and stays. Entries
+ * without an `id` opener are always kept: the transform touches only what it
+ * can name.
+ * @param text - the source composition.
+ * @param ids - top-level row ids to strip.
+ * @returns the stripped composition.
+ */
+export declare function stripPresetRows(text: string, ids?: readonly string[]): string;
+/** Minimal read seam over the host's preset roster (`AgentPresets.read`). */
+export interface PresetCompositionSource {
+    /** Read one preset's composition text; throws when the id is unknown. */
+    read(id: string): Promise<string>;
+}
+/**
+ * Regenerate the hosted-engine preset under the dsh home's user preset root
+ * from the roster's `standard` preset. Idempotent: an up-to-date directory is
+ * untouched, so no standing mount sees a spurious file-stamp change.
+ * @param dshHome - the resolved harness home.
+ * @param source - the roster's composition reader.
+ * @returns whether any file was written.
+ * @throws when the source preset cannot be read or the writes fail.
+ */
+export declare function ensureHostedPreset(dshHome: string, source: PresetCompositionSource): Promise<boolean>;
+//# sourceMappingURL=preset.d.ts.map

package/lib/types/provider-route.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Hosted-engine provider route placeholders.
+ *
+ * Every hosted engine logs its sessions' request/header with its own provider
+ * label (`claude-code`, `codex`, `pi`, `kimi`) rather than a model endpoint the
+ * harness llm registry serves — the engine owns its model natively. The web
+ * host derives a session's model selection from that header and refuses a turn
+ * whose provider no registered adapter serves, so without a placeholder route
+ * the SECOND prompt of every hosted session fails with `model-unavailable`.
+ * The placeholder serves the label while advertising no models; catalog groups
+ * that advertise nothing are dropped, so the model picker is unchanged.
+ *
+ * @module dsh-loop-engine/provider-route
+ */
+import type { GenerateOptions, LlmModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import type { LoopEngineId } from './settings.ts';
+import type { PiModelEntry } from './engine-pi/probe.ts';
+/** Provider route label each hosted engine logs into its sessions' request/header. */
+export declare const HOSTED_PROVIDER_ROUTES: Readonly<Record<Exclude<LoopEngineId, 'in-process'>, string>>;
+/** Injectable catalog source a hosted engine route can advertise over the placeholder. */
+export interface HostedEngineRouteAdapterOptions {
+    /**
+     * Optional model catalog generator. When present, `listModels` advertises
+     * these entries under this route's provider label; when absent, the catalog
+     * stays empty (the default, "engine owns its models" behavior).
+     */
+    readonly listModels?: () => readonly PiModelEntry[];
+}
+/**
+ * Placeholder adapter serving one hosted engine's provider route label. It
+ * inherits the empty catalog and default metadata (the engine's model is not a
+ * harness-selectable endpoint), and {@link stream} fails loud: a call reaching
+ * it means a real model query was routed to an engine that owns its model
+ * natively — a wiring bug, not a request to serve.
+ */
+export declare class HostedEngineRouteAdapter extends LlmAdapter {
+    private readonly label;
+    private readonly options;
+    /**
+     * @param label - the provider route label this placeholder serves.
+     * @param options - optional catalog source; omit for an empty catalog.
+     */
+    constructor(label: string, options?: HostedEngineRouteAdapterOptions);
+    /** Advertise the injected Pi models (if any) under this route's provider label. */
+    listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
+    stream(_options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
+//# sourceMappingURL=provider-route.d.ts.map

package/lib/types/settings.d.ts

@@ -2,10 +2,10 @@
  * 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
+ * halves agree on the section name: the node half brands it as a
+ * `SettingsNamespace`, 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-loop-engine/settings
@@ -26,6 +26,6 @@ export interface LoopEngineSettings {
 }
 /** 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. */
+/** The shared literal branded as a settings namespace on the node side. */
 export declare function loopEngineSettingsNamespace(): SettingsNamespace;
 //# sourceMappingURL=settings.d.ts.map