paseo-dsh-direct 0.2.11 → 0.2.13

package/OVERVIEW.md

@@ -21,6 +21,6 @@ Runs DeepSeek Harness (`dsh`) as a native Paseo agent provider. Paseo clients (d
 - **Executable lookup.** In order: the `PASEO_DSH_EXECUTABLE` environment variable, the executable field of the DeepSeek Harness settings screen, the Paseo setting `agents.providers.dsh-pi.command`, then `dsh` on `PATH`.
 - **Profile.** The plugin launches `dsh --profile paseo`. If `<DSH_HOME>/profiles/paseo` does not exist, it is created once by running `dsh --profile paseo --from-default-profile web --dump-config`. `DSH_HOME` defaults to `~/.dsh`. Setting `PASEO_DSH_PROFILE`, or the profile field of the DeepSeek Harness settings screen (the variable wins), selects another existing profile instead; a missing one is reported as an error, not created.
 - **Environment variables read by the plugin.** `PASEO_DSH_EXECUTABLE`, `PASEO_DSH_PROFILE`, and `DSH_HOME` (to locate the profile directory).
-- **Settings screen.** Executable and profile can also be set under Settings → DeepSeek Harness; changes apply to new sessions.
+- **Settings screen.** Set the executable and profile, and search or select the models subagents may use. Changes apply to new sessions. When the DSH profile has no explicit subagent model settings, the plugin initially selects all currently available models and persists the choice in that profile. Existing choices are preserved; newly added models require selection. Profiles without writable subagent settings show this feature as unavailable.
 - **Environment passed to `dsh`.** The child inherits the Paseo daemon's environment.
 - **Network.** The plugin makes no network requests itself. Model API calls are made by `dsh` according to its own configuration.

package/README.md

@@ -13,7 +13,7 @@ In Paseo, open **Settings → Plugins → Install Plugin** and paste either the
 | Your dsh | npm | Git |
 |---|---|---|
 | `0.2.x` | `npm:paseo-dsh-direct` | `https://github.com/Jecvay/paseo-dsh-direct` |
-| `0.1.x` | `npm:paseo-dsh-direct@dsh-0.1` | CLI only: `paseo plugin install https://github.com/Jecvay/paseo-dsh-direct --ref release/0.1` |
+| `0.1.x` | `npm:paseo-dsh-direct@dsh-0.1` | CLI only: `paseo plugin install https://github.com/Jecvay/paseo-dsh-direct --ref rel/0.1` |
 
 To update, run on the daemon machine (the app's plugin menu has no update entry):
 
@@ -47,6 +47,8 @@ The provider supports streamed assistant and reasoning output, tool execution an
 
 The plugin uses the DSH profile `paseo`. On first start it creates that profile from DSH's official `web` template (`~/.dsh/profiles/paseo`, or under `$DSH_HOME` when set). Model routes, the default model, and permission presets go in `~/.dsh/profiles/paseo/cordis.patch.yml`. The executable and the profile can be set on the **DeepSeek Harness** screen in Paseo's settings (fields `dsh executable` and `dsh profile`). The executable is chosen in this order: `PASEO_DSH_EXECUTABLE`, the settings screen, `agents.providers.dsh-pi.command` in the Paseo configuration, then `dsh` on `PATH`. The profile is chosen from `PASEO_DSH_PROFILE`, then the settings screen, then `paseo`; a profile named explicitly is not created automatically. Changed settings apply to new sessions; running sessions keep their `dsh`. If the Paseo Daemon has plugin loading disabled, enable `pluginsEnabled` in its configuration before installing the plugin.
 
+The **Subagent models** section on that settings screen lets you search models by name or provider, select individual models, select all, clear the list, or disable model selection. On first initialization, the plugin selects all currently available models and saves the choice in the DSH profile. Existing choices, including an explicit disabled setting, are preserved; newly added models require selection. Changes apply to new sessions with a supported preset. See [settings behavior](docs/client-architecture.md#设置页).
+
 If a native session is still held by another DSH client (such as a terminal UI), release it there before importing or resuming it from Paseo.
 
 ## Install from source

package/README.zh.md

@@ -13,7 +13,7 @@
 | 你的 dsh | npm | Git |
 |---|---|---|
 | `0.2.x` | `npm:paseo-dsh-direct` | `https://github.com/Jecvay/paseo-dsh-direct` |
-| `0.1.x` | `npm:paseo-dsh-direct@dsh-0.1` | 只能用命令行：`paseo plugin install https://github.com/Jecvay/paseo-dsh-direct --ref release/0.1` |
+| `0.1.x` | `npm:paseo-dsh-direct@dsh-0.1` | 只能用命令行：`paseo plugin install https://github.com/Jecvay/paseo-dsh-direct --ref rel/0.1` |
 
 更新插件在 daemon 所在机器上运行（App 的插件菜单里没有更新入口）：
 
@@ -47,6 +47,8 @@ Provider 支持连续正文和思考输出、工具执行与审批、用户问
 
 插件使用名为 `paseo` 的 DSH profile。首次启动时，插件用 DSH 官方的 `web` 模板自动创建它（位置是 `~/.dsh/profiles/paseo`；设置了 `$DSH_HOME` 时在其下）。模型路由、默认模型和权限预设写在 `~/.dsh/profiles/paseo/cordis.patch.yml`。可在 Paseo 设置里的 **DeepSeek Harness** 页（`dsh executable`、`dsh profile` 两项）指定可执行文件与 profile。可执行文件的选择顺序：`PASEO_DSH_EXECUTABLE`、设置页、Paseo 配置的 `agents.providers.dsh-pi.command`、`PATH` 里的 `dsh`。profile 的选择顺序：`PASEO_DSH_PROFILE`、设置页、默认的 `paseo`；显式指定的 profile 不会被自动创建。改动对新会话生效，已在运行的会话继续使用原来的 `dsh`。如果 Paseo Daemon 默认关闭插件加载，请先在配置中启用 `pluginsEnabled`。
 
+同一设置页的 **Subagent models** 区域可以按名称或提供方搜索模型、逐项勾选、全选、清空或关闭选模。首次初始化会选中当前可用的全部模型并保存到 DSH profile；已有选择（包括显式关闭）会保留，后续新增模型需要手动勾选。改动对支持选模的 preset 的新会话生效，详见[设置页说明](docs/client-architecture.md#设置页)。
+
 如果原生会话仍被另一个 DSH 客户端（如终端界面）占用，请先在那里释放，再从 Paseo 导入或恢复。
 
 ## 从源码安装

package/client/settings-screen.tsx

@@ -3,6 +3,7 @@ import { ScrollView } from "@getpaseo/plugin/client/react-native";
 import { SettingsAction, SettingsInput, SettingsRow, SettingsSection } from "@getpaseo/plugin/client/ui";
 import { useRef } from "react";
 import { DSH_SETTINGS } from "../shared/settings.js";
+import SubagentSettings from "./subagent-settings.js";
 
 const EXECUTABLE_HINT =
   "Path or command of dsh. PASEO_DSH_EXECUTABLE overrides this; leave it empty to use the Paseo provider command or dsh on PATH.";
@@ -96,6 +97,7 @@ export default function DshSettingsScreen() {
           disabled={settings.saving}
         />
       </SettingsSection>
+      <SubagentSettings launchRevision={revision} launchSaving={settings.saving} />
     </ScrollView>
   );
 }

package/client/subagent-settings.tsx

@@ -0,0 +1,229 @@
+import { useRpc } from "@getpaseo/plugin/client";
+import { SettingsAction, SettingsInput, SettingsRow, SettingsSection, SettingsSwitch } from "@getpaseo/plugin/client/ui";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useState } from "react";
+import {
+  readSubagentSettings,
+  saveSubagentSettings,
+  subagentRouteKey,
+  type SubagentRoute,
+  type SubagentSelection,
+  type SubagentSettingsView,
+  type SubagentSettingsSave,
+} from "../shared/subagent-settings.js";
+
+type Draft = {
+  view: SubagentSettingsView;
+  selection: SubagentSelection;
+  launchRevision: string;
+};
+type ModelRow = SubagentRoute & { name: string; providerName: string; available: boolean };
+
+function sameSelection(left: SubagentSelection, right: SubagentSelection): boolean {
+  const keys = new Set(left.allowedModels.map(subagentRouteKey));
+  return left.enabled === right.enabled && keys.size === right.allowedModels.length &&
+    right.allowedModels.every((model) => keys.has(subagentRouteKey(model)));
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** Keeps edits tied to the exact profile and revision returned by the daemon. */
+export default function SubagentSettings({ launchRevision, launchSaving }: {
+  launchRevision: string;
+  launchSaving: boolean;
+}) {
+  const readSettings = useRpc(readSubagentSettings);
+  const saveSettings = useRpc(saveSubagentSettings);
+  const queryClient = useQueryClient();
+  const queryKey = ["dsh-subagent-settings", launchRevision];
+  const query = useQuery({
+    queryKey,
+    queryFn: () => readSettings({}),
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false,
+    retry: false,
+  });
+  const [draft, setDraft] = useState<Draft | null>(null);
+  const [search, setSearch] = useState("");
+  const dirty = draft !== null && !sameSelection(draft.selection, draft.view.selection);
+  // A background read or a saved launch-setting change must never replace pending edits.
+  const activeDraft = dirty ? draft : null;
+  const view = activeDraft?.view ?? query.data;
+  const selection = activeDraft?.selection ?? view?.selection;
+  const launchChanged = activeDraft !== null && activeDraft.launchRevision !== launchRevision;
+  const save = useMutation({
+    mutationFn: ({ input }: { input: SubagentSettingsSave; launchRevision: string }) => saveSettings(input),
+    onSuccess: (saved, submitted) => {
+      queryClient.setQueryData(["dsh-subagent-settings", submitted.launchRevision], saved);
+      setDraft(null);
+    },
+  });
+  const saveError = save.error ? errorMessage(save.error) : undefined;
+  const conflict = saveError !== undefined && /changed|conflict|revision|stale/i.test(saveError);
+  const busy = save.isPending || query.isFetching || launchSaving;
+
+  const refresh = () => {
+    if (dirty || busy) return;
+    save.reset();
+    void query.refetch();
+  };
+  const discardAndRefresh = () => {
+    if (busy) return;
+    setDraft(null);
+    save.reset();
+    void query.refetch();
+  };
+  const edit = (next: SubagentSelection) => {
+    if (!view || busy) return;
+    // Keep a conflict visible until the user explicitly discards and refreshes.
+    if (!conflict) save.reset();
+    setDraft({
+      view,
+      selection: next,
+      launchRevision: activeDraft?.launchRevision ?? launchRevision,
+    });
+  };
+
+  if (!view || !selection) {
+    return (
+      <SettingsSection title="Subagent models">
+        <SettingsRow
+          label={query.isError ? "Could not load subagent models" : "Loading subagent models"}
+          error={query.isError ? errorMessage(query.error) : undefined}
+          hint="Models and saved choices come from the active dsh profile."
+        />
+        {query.isError && <SettingsAction label="Load models again" actionLabel="Retry" onPress={refresh} disabled={busy} />}
+      </SettingsSection>
+    );
+  }
+
+  const selectedKeys = new Set(selection.allowedModels.map(subagentRouteKey));
+  const models = new Map<string, ModelRow>(view.models.map((model) => [
+    subagentRouteKey(model), { ...model, available: true },
+  ]));
+  // Keep missing saved rows visible even after unchecking, until Save or Discard.
+  for (const route of [...view.selection.allowedModels, ...selection.allowedModels]) {
+    const key = subagentRouteKey(route);
+    if (!models.has(key)) {
+      models.set(key, { ...route, name: route.model, providerName: route.provider, available: false });
+    }
+  }
+  const term = search.trim().toLocaleLowerCase();
+  const groups = new Map<string, { name: string; rows: ModelRow[] }>();
+  for (const model of models.values()) {
+    if (term && ![model.name, model.model, model.provider, model.providerName]
+      .some((value) => value.toLocaleLowerCase().includes(term))) continue;
+    const group = groups.get(model.provider) ?? { name: model.providerName, rows: [] };
+    group.rows.push(model);
+    groups.set(model.provider, group);
+  }
+  const missingCount = selection.allowedModels.filter((route) => !models.get(subagentRouteKey(route))?.available).length;
+  const emptyEnabled = selection.enabled && selection.allowedModels.length === 0;
+  const toggle = (model: SubagentRoute, checked: boolean) => {
+    const key = subagentRouteKey(model);
+    const remaining = selection.allowedModels.filter((route) => subagentRouteKey(route) !== key);
+    edit({ ...selection, allowedModels: checked ? [...remaining, { provider: model.provider, model: model.model }] : remaining });
+  };
+  const selectAvailable = () => {
+    const routes = new Map(selection.allowedModels.map((route) => [subagentRouteKey(route), route]));
+    for (const model of view.models) {
+      routes.set(subagentRouteKey(model), { provider: model.provider, model: model.model });
+    }
+    edit({ ...selection, allowedModels: [...routes.values()] });
+  };
+
+  return (
+    <>
+      <SettingsSection title="Subagent models">
+        <SettingsRow
+          label={`Profile: ${view.profile}`}
+          hint="Saved changes apply only to new sessions. The first initialization selects all available models; models added later stay unselected until you choose them."
+        />
+        {query.isError && (
+          <SettingsRow label="Could not refresh models" error={errorMessage(query.error)} hint="The last loaded list is still shown. Retry after discarding any pending edits." />
+        )}
+        {launchChanged && (
+          <SettingsRow label="dsh launch settings changed" error="Your model edits still belong to the previously loaded profile. Discard changes and refresh before saving." />
+        )}
+        {!view.supported && (
+          <SettingsRow
+            label="Subagent model selection is unavailable"
+            hint={view.reason ?? "The current dsh profile does not support subagent model selection. Choose a supported profile and refresh."}
+          />
+        )}
+        {view.failedProviders.length > 0 && (
+          <SettingsRow
+            label="Some providers could not load models"
+            hint={`${view.failedProviders.join(", ")}. Their saved selections are preserved. Refresh to retry loading them.`}
+          />
+        )}
+        {!view.initialized && (
+          <SettingsRow label="Model selection has not been initialized" hint="No initial selection has been saved. If the catalog is empty, check your providers and refresh once models are available." />
+        )}
+        <SettingsSwitch
+          label="Enable subagent model selection"
+          hint="Allow new sessions to choose subagent models from the selected list. Turning this off keeps your model choices."
+          value={selection.enabled}
+          onValueChange={(enabled) => edit({ ...selection, enabled })}
+          disabled={busy || !view.supported}
+        />
+        <SettingsRow
+          label={`${selection.allowedModels.length} selected · ${view.models.length} available`}
+          hint={missingCount > 0 ? `${missingCount} selected model(s) are not in the current catalog. You can keep or remove them below.` : "New models are never added to your saved selection automatically."}
+          error={emptyEnabled ? "Select at least one model, or turn off model selection before saving." : undefined}
+        />
+        <SettingsInput label="Search models" placeholder="Name, model ID, or provider" initialValue={search} onChangeText={setSearch} />
+        <SettingsAction
+          label="Select all available models"
+          hint="Includes all providers, even models hidden by search. Keeps saved models that are currently unavailable."
+          actionLabel="Select all"
+          onPress={selectAvailable}
+          disabled={busy || !view.supported || view.models.length === 0 || view.models.every((model) => selectedKeys.has(subagentRouteKey(model)))}
+        />
+        <SettingsAction label="Clear model selection" hint="Clears every selection, including models hidden by search." actionLabel="Clear" onPress={() => edit({ ...selection, allowedModels: [] })} disabled={busy || !view.supported || selectedKeys.size === 0} />
+        <SettingsAction
+          label={query.isFetching ? "Refreshing models" : "Refresh models"}
+          hint={dirty ? "Save or discard your changes before refreshing." : "Reload the catalog and saved selection for the active profile."}
+          actionLabel={query.isError ? "Retry" : "Refresh"}
+          onPress={refresh}
+          disabled={busy || dirty}
+        />
+      </SettingsSection>
+      {[...groups].sort(([left], [right]) => left.localeCompare(right)).map(([provider, group]) => (
+        <SettingsSection key={provider} title={`${group.name} (${group.rows.filter((model) => selectedKeys.has(subagentRouteKey(model))).length}/${group.rows.length}${term ? " matching" : ""})`}>
+          {group.rows.sort((left, right) => left.name.localeCompare(right.name) || left.model.localeCompare(right.model)).map((model) => (
+            <SettingsSwitch
+              key={subagentRouteKey(model)}
+              label={model.name}
+              hint={`${model.provider} / ${model.model}${model.available ? "" : " · Not in the current catalog; uncheck to remove from saved selection."}`}
+              value={selectedKeys.has(subagentRouteKey(model))}
+              onValueChange={(checked) => toggle(model, checked)}
+              disabled={busy || !view.supported}
+            />
+          ))}
+        </SettingsSection>
+      ))}
+      {groups.size === 0 && (
+        <SettingsSection title="Models">
+          <SettingsRow label={term ? "No models match your search" : "No models are available"} hint={term ? "Try another name, model ID, or provider." : "Check your provider configuration, then refresh the catalog."} />
+        </SettingsSection>
+      )}
+      <SettingsSection title="Save subagent settings">
+        <SettingsAction
+          label={save.isSuccess ? "Subagent settings saved" : "Apply model selection"}
+          hint={conflict ? "Settings changed elsewhere. Your edits are still here; discard changes and refresh to load the latest version." : "Changes apply only to new sessions. Existing sessions keep their current model selection."}
+          error={saveError}
+          actionLabel={save.isPending ? "Saving" : "Save"}
+          onPress={() => {
+            if (!dirty || busy || emptyEnabled || conflict || launchChanged || !view.supported || query.isError) return;
+            save.mutate({ input: { profile: view.profile, revision: view.revision, selection }, launchRevision });
+          }}
+          disabled={!dirty || busy || emptyEnabled || conflict || launchChanged || !view.supported || query.isError}
+        />
+        <SettingsAction label="Discard changes and reload saved selection" actionLabel="Discard and refresh" onPress={discardAndRefresh} disabled={busy || (!dirty && !save.isError)} />
+      </SettingsSection>
+    </>
+  );
+}

package/index.server.ts

@@ -5,14 +5,39 @@ import { currentDshConfigured } from "./server/dsh-config.js";
 import { defaultDshCommand } from "./server/dsh-spawn.js";
 import { DSH_BRIDGE_SOURCE } from "./server/generated-bridge.js";
 import { createDshProvider } from "./server/provider.js";
+import type { ProviderLaunch } from "@getpaseo/plugin/server/provider";
+import { createSubagentSettingsAccess } from "./server/subagent-settings.js";
+import { readSubagentSettings, saveSubagentSettings } from "./shared/subagent-settings.js";
 
 export default function contribute(server: PluginServerContext) {
   const settings = server.registerSettings(DSH_SETTINGS);
   // Read per call, not once: a changed setting applies to new sessions and new catalog discovery.
   const configured = () => currentDshConfigured(process.env, settings);
+  let providerLaunch: ProviderLaunch | undefined;
+  const subagents = createSubagentSettingsAccess({
+    target: async () => ({ configured: await configured(), launch: providerLaunch }),
+    open: ({ configured: { executable, profile }, launch }) => launchDshBridge({
+      bridgeSource: DSH_BRIDGE_SOURCE, executable, profile, providerLaunch: launch,
+    }),
+  });
+  // Provider discovery supplies the same resolved command and environment used for sessions.
+  const refreshLaunch = async (paseo: import("@getpaseo/client").PaseoApi) => {
+    await paseo.providers.refresh({ providers: ["dsh-pi"] });
+    const result = await paseo.providers.listModels("dsh-pi");
+    if (result.error) throw new Error(result.error);
+  };
+  server.handle(readSubagentSettings, async (_input, { paseo }) => {
+    await refreshLaunch(paseo);
+    return subagents.read();
+  });
+  server.handle(saveSubagentSettings, async (input, { paseo }) => {
+    await refreshLaunch(paseo);
+    return subagents.save(input);
+  });
   server.registerProvider(
     createDshProvider({
       configured,
+      observeLaunch: (launch) => { providerLaunch = launch; },
       command: defaultDshCommand(process.env),
       createBridge: async (launch) => {
         const { executable, profile } = await configured();
@@ -20,5 +45,5 @@ export default function contribute(server: PluginServerContext) {
       },
     }),
   );
-  return () => {};
+  return () => subagents.dispose();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-dsh-direct",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "DeepSeek Harness Direct Provider Plugin for Paseo",
   "repository": {
     "type": "git",
@@ -58,6 +58,7 @@
   },
   "devDependencies": {
     "@getpaseo/plugin": "0.12.0",
+    "@tanstack/react-query": "^5.105.0",
     "@types/mdast": "^4.0.4",
     "@types/node": "^24.0.0",
     "@types/react": "~19.2.0",

package/server/dsh/bridge.ts

@@ -32,6 +32,8 @@ export function safeError(error: unknown): string {
 const METHODS = new Set<keyof BridgeMethods>([
   "bridge.initialize",
   "bridge.shutdown",
+  "subagent.settings.read",
+  "subagent.settings.save",
   "session.list",
   "session.read",
   "session.open",

package/server/dsh/host.ts

@@ -66,7 +66,30 @@ interface AgentOptions {
   agentOptions: ModelSelection;
   setup(ctx: HostContext, agent: HostAgent): Promise<void>;
 }
+export interface HostSettingsDescriptor {
+  ns: string;
+  revision: number;
+  value: unknown;
+  base?: unknown;
+  user?: unknown;
+}
+export interface HostSettings {
+  readonly writable?: boolean;
+  readonly documentPath: string;
+  describe(options: { redactSecrets: true }): HostSettingsDescriptor[];
+  mutate(
+    ns: string,
+    ops: readonly { op: "set"; path: readonly string[]; value: unknown }[],
+    expectedRevision: number,
+  ): Promise<void>;
+}
 export interface HostServices {
+  settings?: HostSettings;
+  configEditor?: {
+    configuration(): Array<{
+      entry: { options: { id: string; config?: unknown } };
+    }>;
+  };
   agents: {
     get(id: string): HostAgent | undefined;
     create(options: AgentOptions): Promise<HostHandle>;

package/server/dsh/service.ts

@@ -18,6 +18,7 @@ import type {
   PromptPart,
   SlashCommand,
 } from "../../shared/bridge-protocol.js";
+import { SubagentSettings } from "./subagent-settings.js";
 import { slashLine } from "../../shared/bridge-protocol.js";
 import type {
   ApprovalOutcome,
@@ -144,6 +145,8 @@ export class BridgeService {
   private readonly titles = new Map<string, string>();
   private stopping = false;
   private stopTask?: Promise<{}>;
+  private readonly subagentSettings: SubagentSettings;
+  private subagentSettingsInitializationError?: Error;
 
   constructor(
     private readonly ctx: HostContext,
@@ -151,6 +154,7 @@ export class BridgeService {
     private readonly profile = "paseo",
     private readonly helpers?: HostHelpers,
   ) {
+    this.subagentSettings = new SubagentSettings(ctx, profile);
     this.subscriptions.push(
       ctx.on("session/created", (session) => {
         if (session.header.parentSession)
@@ -453,6 +457,15 @@ export class BridgeService {
           }, catalog: { models: [], presets: [] }, missing } satisfies BridgeInitializeResult;
           break;
         }
+        try {
+          await this.subagentSettings.initialize();
+          this.subagentSettingsInitializationError = undefined;
+        } catch (error) {
+          this.subagentSettingsInitializationError = new Error(
+            `Subagent settings initialization failed: ${error instanceof Error ? error.message : String(error)}`,
+          );
+          console.error(this.subagentSettingsInitializationError.message);
+        }
         result = {
           protocolVersion: 1,
           profile: this.profile,
@@ -467,6 +480,14 @@ export class BridgeService {
         } satisfies BridgeInitializeResult;
         break;
       }
+      case "subagent.settings.read":
+        if (this.subagentSettingsInitializationError) throw this.subagentSettingsInitializationError;
+        result = await this.subagentSettings.read();
+        break;
+      case "subagent.settings.save":
+        result = await this.subagentSettings.save(params);
+        this.subagentSettingsInitializationError = undefined;
+        break;
       case "session.list":
         result = { sessions: await this.listSessions(listParams(params)) };
         break;

package/server/dsh/subagent-settings.ts

@@ -0,0 +1,179 @@
+import { createHash } from "node:crypto";
+import type {
+  SubagentRoute,
+  SubagentSelection,
+  SubagentSettingsSave,
+  SubagentSettingsView,
+} from "../../shared/subagent-settings.js";
+import type { HostContext, HostServices, HostSettings, HostSettingsDescriptor } from "./host.js";
+
+const NAMESPACE = "subagent-model-selection-settings";
+type Catalog = Pick<SubagentSettingsView, "models" | "failedProviders">;
+interface Snapshot {
+  settings: HostSettings;
+  descriptor: HostSettingsDescriptor;
+  initialized: boolean;
+  selection: SubagentSelection;
+  revision: string;
+}
+
+function record(value: unknown): Record<string, unknown> {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Invalid subagent settings object");
+  return value as Record<string, unknown>;
+}
+function routeKey(route: SubagentRoute): string {
+  return JSON.stringify([route.provider, route.model]);
+}
+function validateSelection(input: unknown): SubagentSelection {
+  const value = record(input);
+  if (typeof value.enabled !== "boolean" || !Array.isArray(value.allowedModels))
+    throw new Error("Subagent settings require enabled and allowedModels");
+  const allowedModels = value.allowedModels.map((input): SubagentRoute => {
+    const route = record(input);
+    if (typeof route.provider !== "string" || !route.provider.trim() ||
+        typeof route.model !== "string" || !route.model.trim())
+      throw new Error("Subagent model routes require nonempty provider and model ids");
+    return { provider: route.provider, model: route.model };
+  });
+  if (new Set(allowedModels.map(routeKey)).size !== allowedModels.length)
+    throw new Error("A subagent model may only be selected once");
+  if (value.enabled && allowedModels.length === 0)
+    throw new Error("Select at least one model before enabling model selection");
+  return { enabled: value.enabled, allowedModels };
+}
+
+// Object insertion order and process-local revisions must not invalidate tokens
+// carried between the short-lived read and save bridges. Array order is meaningful.
+function canonical(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value !== null && typeof value === "object")
+    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
+      .map(([key, child]) => [key, canonical(child)]));
+  return value;
+}
+
+/** Accesses only native DSH services; the shared module is a type-only boundary. */
+export class SubagentSettings {
+  constructor(private readonly ctx: HostContext, private readonly profile: string) {}
+
+  private snapshot(): Snapshot | undefined {
+    let settings: HostSettings | undefined;
+    let editor: HostServices["configEditor"];
+    try {
+      settings = this.ctx.get("settings");
+      editor = this.ctx.get("configEditor");
+    } catch {
+      // Older profiles can omit these optional services entirely.
+      return undefined;
+    }
+    if (!settings || typeof settings.describe !== "function" ||
+        typeof settings.mutate !== "function" || settings.writable === false ||
+        !editor || !("configuration" in editor) || typeof editor.configuration !== "function")
+      return undefined;
+    const descriptor = settings.describe({ redactSecrets: true }).find(row => row.ns === NAMESPACE);
+    const entry = editor.configuration().find(row => row.entry.options.id === NAMESPACE)?.entry;
+    if (!descriptor || !entry) return undefined;
+    if (!Number.isSafeInteger(descriptor.revision) || descriptor.revision < 0)
+      throw new Error("Invalid DSH settings revision");
+    const raw = entry.options.config ?? {};
+    const config = record(raw);
+    const initialized = Object.hasOwn(config, "enabled") || Object.hasOwn(config, "allowedModels");
+    const selection = validateSelection(descriptor.value);
+    const revision = createHash("sha256").update(JSON.stringify(canonical({
+      profile: this.profile,
+      documentPath: settings.documentPath,
+      raw,
+      value: descriptor.value,
+      base: descriptor.base,
+      user: descriptor.user,
+    }))).digest("hex");
+    return { settings, descriptor, initialized, selection, revision };
+  }
+
+  private unsupported(): SubagentSettingsView {
+    return {
+      supported: false, profile: this.profile,
+      reason: "This DSH profile does not provide writable subagent model settings.",
+      revision: "", initialized: false,
+      selection: { enabled: false, allowedModels: [] }, models: [], failedProviders: [],
+    };
+  }
+
+  private async catalog(): Promise<Catalog> {
+    const llm = this.ctx.get("llm");
+    const models: Catalog["models"] = [];
+    const failedProviders: string[] = [];
+    const seen = new Set<string>();
+    for (const provider of llm.listProviders()) {
+      try {
+        for (const model of await llm.listModels(provider.id)) {
+          const route = { provider: provider.id, model: model.id };
+          const key = routeKey(route);
+          if (seen.has(key)) continue;
+          seen.add(key);
+          models.push({ ...route, name: model.name ?? model.id, providerName: provider.name ?? provider.id });
+        }
+      } catch {
+        failedProviders.push(provider.id);
+      }
+    }
+    return { models, failedProviders };
+  }
+
+  private view(snapshot: Snapshot, catalog: Catalog): SubagentSettingsView {
+    return {
+      supported: true, profile: this.profile,
+      revision: snapshot.revision, initialized: snapshot.initialized,
+      selection: snapshot.selection, ...catalog,
+    };
+  }
+
+  private async mutate(snapshot: Snapshot, selection: SubagentSelection): Promise<void> {
+    await snapshot.settings.mutate(NAMESPACE, [
+      { op: "set", path: ["enabled"], value: selection.enabled },
+      { op: "set", path: ["allowedModels"], value: selection.allowedModels },
+    ], snapshot.descriptor.revision);
+  }
+
+  /** Capture the revision before discovery so another writer always wins. */
+  async initialize(): Promise<void> {
+    const snapshot = this.snapshot();
+    if (!snapshot || snapshot.initialized) return;
+    const catalog = await this.catalog();
+    if (catalog.models.length === 0) return;
+    try {
+      await this.mutate(snapshot, {
+        enabled: true,
+        allowedModels: catalog.models.map(({ provider, model }) => ({ provider, model })),
+      });
+    } catch (error) {
+      if (error !== null && typeof error === "object" && "code" in error &&
+          error.code === "SETTINGS_CONFLICT" && this.snapshot()?.initialized) return;
+      throw error;
+    }
+  }
+
+  async read(): Promise<SubagentSettingsView> {
+    if (!this.snapshot()) return this.unsupported();
+    const catalog = await this.catalog();
+    const current = this.snapshot();
+    if (!current) return this.unsupported();
+    return this.view(current, catalog);
+  }
+
+  async save(input: unknown): Promise<SubagentSettingsView> {
+    const value = record(input);
+    if (value.profile !== this.profile) throw new Error("DSH profile changed; reload settings before saving");
+    if (typeof value.revision !== "string" || !value.revision)
+      throw new Error("Subagent settings revision is required");
+    const selection = validateSelection(value.selection);
+    const request: SubagentSettingsSave = { profile: this.profile, revision: value.revision, selection };
+    const snapshot = this.snapshot();
+    if (!snapshot) return this.unsupported();
+    if (request.revision !== snapshot.revision)
+      throw new Error("Subagent settings changed; reload settings before saving");
+    await this.mutate(snapshot, request.selection);
+    return this.read();
+  }
+}

package/server/provider.ts

@@ -65,6 +65,8 @@ type DetectVersion = (
 
 interface DshProviderOptions {
   createBridge(launch?: SessionLaunch): Promise<DshBridge>;
+  /** Share the daemon-resolved launch with settings RPCs targeting the same provider. */
+  observeLaunch?(launch: SessionLaunch["providerLaunch"]): void;
   /**
    * The environment and settings-screen choices, read on every call so a changed
    * setting applies to new sessions. The executable outranks the `launch` Paseo
@@ -112,6 +114,7 @@ export function createDshProvider(options: DshProviderOptions): ProviderRegistra
     description: "Direct connection to the local DeepSeek Harness (dsh)",
     icon: "dsh.svg",
     getCatalogCacheKey: async (request) => {
+      options.observeLaunch?.(request.launch);
       const configured = (await options.configured?.()) ?? {};
       const launch = describeDshLaunch(resolveDshLaunch(configured.executable, request.launch));
       const scope = request.scope === "workspace" ? request.cwd : "global";
@@ -119,6 +122,7 @@ export function createDshProvider(options: DshProviderOptions): ProviderRegistra
     },
     command: [options.command ?? "dsh"],
     async status(request) {
+      options.observeLaunch?.(request?.launch);
       return dshStatus(
         resolveDshLaunch((await options.configured?.())?.executable, request?.launch),
         request?.launch?.env,
@@ -128,6 +132,7 @@ export function createDshProvider(options: DshProviderOptions): ProviderRegistra
     async connect(request) {
       if (!request.versions.includes(1)) throw new Error("Provider protocol version 1 is required");
       const providerLaunch = request.launch;
+      options.observeLaunch?.(providerLaunch);
       const createBridge = (launch?: SessionLaunch) =>
         options.createBridge(providerLaunch ? { ...launch, providerLaunch } : launch);
       const bridge = await createBridge();
@@ -183,7 +188,23 @@ function createConnection(
 ): ProviderConnection {
   const listeners = new Set<(event: ProviderEvent) => void>();
   const sessions = new Map<string, SessionState>();
+  const pendingOpens = new Set<Promise<void>>();
+  const openingBridges = new Set<DshBridge>();
+  const bridgeClosures = new WeakMap<DshBridge, Promise<void>>();
+  const cleanupErrors: unknown[] = [];
   let closed = false;
+  let closePromise: Promise<void> | undefined;
+  const closeBridge = (bridge: DshBridge): Promise<void> => {
+    let closing = bridgeClosures.get(bridge);
+    if (!closing) {
+      closing = Promise.resolve().then(() => bridge.close()).catch((error) => {
+        cleanupErrors.push(error);
+        throw error;
+      });
+      bridgeClosures.set(bridge, closing);
+    }
+    return closing;
+  };
   const emit = (event: ProviderEvent) => {
     if (closed) return;
     for (const listener of listeners) listener(event);
@@ -195,28 +216,41 @@ function createConnection(
     async send(input) {
       if (closed) throw new Error("Provider connection is closed");
       validateAdmission(input, sessions, capabilities);
-      queueMicrotask(() => {
-        void dispatch(input, { discoveryBridge, createBridge, sessions, emit, capabilities, detectVersion, launchEnv }).catch(
-          (error) => failInput(input, error, emit),
-        );
-      });
+      const pending = Promise.resolve().then(async () => {
+        if (closed) return;
+        await dispatch(input, {
+          discoveryBridge, createBridge, sessions, emit, capabilities, detectVersion, launchEnv,
+          openingBridges, closeBridge, isClosed: () => closed,
+        });
+      }).catch((error) => failInput(input, error, emit));
+      if (input.type === "session.open") {
+        pendingOpens.add(pending);
+        void pending.then(() => pendingOpens.delete(pending));
+      }
     },
     onEvent(listener) {
       listeners.add(listener);
       return () => listeners.delete(listener);
     },
-    async close() {
-      if (closed) return;
+    close() {
+      if (closePromise) return closePromise;
       closed = true;
-      const bridges = [discoveryBridge];
+      const bridges = new Set([discoveryBridge, ...openingBridges]);
       for (const session of sessions.values()) {
         session.closed = true;
         session.releaseBridgeListeners.forEach((release) => release());
-        bridges.push(session.bridge);
+        bridges.add(session.bridge);
       }
       sessions.clear();
       listeners.clear();
-      await Promise.all(bridges.map((bridge) => bridge.close()));
+      closePromise = (async () => {
+        await Promise.allSettled([
+          ...Array.from(bridges, closeBridge),
+          ...pendingOpens,
+        ]);
+        if (cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, "Could not close DSH bridges");
+      })();
+      return closePromise;
     },
   };
 }
@@ -358,6 +392,9 @@ interface DispatchState {
   capabilities: readonly string[];
   detectVersion: DetectVersion;
   launchEnv: Readonly<Record<string, string>> | undefined;
+  openingBridges: Set<DshBridge>;
+  closeBridge(bridge: DshBridge): Promise<void>;
+  isClosed(): boolean;
 }
 
 async function dispatch(input: ProviderInput, state: DispatchState): Promise<void> {
@@ -447,8 +484,10 @@ async function openSession(
     ephemeral: !input.config.persist,
     mcpServers: bridgeMcpServers(input.config.mcpServers),
   });
+  state.openingBridges.add(bridge);
   let session: SessionState | undefined;
   try {
+    if (state.isClosed()) return;
     // Resume from DSH's durable model and preset. Paseo fills catalog defaults into
     // open config, so forwarding them would accidentally overwrite native history.
     const selection = nativeId
@@ -468,11 +507,13 @@ async function openSession(
         ? { preapprovedTools: preapprovedTools(input.config) }
         : {}),
     });
+    if (state.isClosed()) return;
     const title = nativeId ? undefined : input.config.title?.trim();
     const [commands] = await Promise.all([
       fetchCommands(bridge, opened.sessionId),
       title ? bridge.request("session.rename", { sessionId: opened.sessionId, title }) : undefined,
     ]);
+    if (state.isClosed()) return;
     session = {
       paseoId: input.sessionId,
       nativeId: opened.sessionId,
@@ -496,10 +537,18 @@ async function openSession(
       await setPlanMode(session, true);
     }
   } catch (error) {
-    if (session) state.sessions.delete(input.sessionId);
-    await bridge.close();
+    if (session) {
+      session.closed = true;
+      session.releaseBridgeListeners.forEach((release) => release());
+      state.sessions.delete(input.sessionId);
+    }
+    await state.closeBridge(bridge);
     throw error;
+  } finally {
+    state.openingBridges.delete(bridge);
+    if (state.isClosed()) await state.closeBridge(bridge);
   }
+  if (state.isClosed()) return;
   state.emit({
     type: "session.opened",
     requestId: input.requestId,
@@ -1080,12 +1129,28 @@ function questionAnswers(
   return questions.map((question) => {
     const key = question.header ?? question.id;
     const raw = answers?.[key];
-    const selected = typeof raw === "string" ? raw.split(",").map((value) => value.trim()).filter(Boolean) : [];
-    const known = new Set((question.options ?? []).map((option) => option.label));
-    const custom = selected.find((value) => !known.has(value));
+    if (typeof raw !== "string" || raw.length === 0) return { id: question.id, selected: [] };
+    const labels = (question.options ?? []).map((option) => option.label);
+    if (!question.multiSelect) {
+      return labels.includes(raw)
+        ? { id: question.id, selected: [raw] }
+        : { id: question.id, selected: [], custom: raw };
+    }
+    // Paseo joins checked labels and the optional typed answer with ", ".
+    // Match complete labels (longest first), keeping the remaining text intact.
+    const candidates = labels.filter(Boolean).sort((left, right) => right.length - left.length);
+    const selected: string[] = [];
+    let custom = raw;
+    while (custom.length > 0) {
+      const label = candidates.find((value) =>
+        !selected.includes(value) && (custom === value || custom.startsWith(`${value}, `)));
+      if (label === undefined) break;
+      selected.push(label);
+      custom = custom === label ? "" : custom.slice(label.length + 2);
+    }
     return {
       id: question.id,
-      selected: selected.filter((value) => known.has(value)),
+      selected,
       ...(custom ? { custom } : {}),
     };
   });

package/server/subagent-settings.ts

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+import type { ProviderLaunch } from "@getpaseo/plugin/server/provider";
+import type { SubagentSettingsSave, SubagentSettingsView } from "../shared/subagent-settings.js";
+import type { DshConfigured } from "./dsh-config.js";
+import { DEFAULT_PROFILE, resolveDshHome, resolveDshLaunch, type DshBridge } from "./bridge-client.js";
+
+interface SettingsTarget {
+  configured: DshConfigured;
+  launch?: ProviderLaunch;
+}
+
+/** Bind a draft to its effective installation and profile without exposing launch credentials. */
+export function subagentSettingsTargetKey({ configured, launch }: SettingsTarget): string {
+  const command = resolveDshLaunch(configured.executable, launch);
+  return createHash("sha256").update(JSON.stringify([
+    command,
+    configured.profile ?? DEFAULT_PROFILE,
+    resolveDshHome(launch?.env ?? process.env),
+  ])).digest("hex");
+}
+
+/** Each settings operation owns a short-lived bridge; no agent or background worker is retained. */
+export function createSubagentSettingsAccess(options: {
+  target(): Promise<SettingsTarget>;
+  open(target: SettingsTarget): Promise<DshBridge>;
+}) {
+  let disposed = false;
+  const pending = new Set<Promise<unknown>>();
+  const run = (input?: SubagentSettingsSave): Promise<SubagentSettingsView> => {
+    if (disposed) return Promise.reject(new Error("Plugin is shutting down"));
+    const task = (async () => {
+      const target = await options.target();
+      const key = subagentSettingsTargetKey(target);
+      let revision: string | undefined;
+      if (input) {
+        const prefix = `${key}:`;
+        if (!input.revision.startsWith(prefix) || input.profile !== (target.configured.profile ?? DEFAULT_PROFILE)) {
+          throw new Error("DSH launch settings changed. Reload before saving.");
+        }
+        revision = input.revision.slice(prefix.length);
+      }
+      if (disposed) throw new Error("Plugin is shutting down");
+      const bridge = await options.open(target);
+      try {
+        if (disposed) throw new Error("Plugin is shutting down");
+        const view = input
+          ? await bridge.request("subagent.settings.save", { ...input, revision: revision! })
+          : await bridge.request("subagent.settings.read", {});
+        return { ...view, revision: `${key}:${view.revision}` };
+      } finally {
+        await bridge.close();
+      }
+    })();
+    pending.add(task);
+    void task.then(() => pending.delete(task), () => pending.delete(task));
+    return task;
+  };
+  return {
+    read: () => run(),
+    save: (input: SubagentSettingsSave) => run(input),
+    async dispose() {
+      disposed = true;
+      await Promise.allSettled(pending);
+    },
+  };
+}

package/server/timeline.ts

@@ -480,32 +480,55 @@ function timeline(
 
 function toolDetail(name: string, args: JsonObject): ProviderToolCallDetail {
   const normalized = name.toLowerCase();
-  if (/shell|bash|exec|command/u.test(normalized)) {
+
+  // DSH's built-in tools are matched by exact name. Substring patterns get the
+  // common ones wrong (`todo_write` is not a file write, `read_image` is not a
+  // text read), and they would also claim unrelated MCP tools.
+  if (normalized === "bash" || normalized === "pwsh") {
+    // An empty command during streaming keeps the card from showing the raw
+    // half-parsed JSON; the final frame fills it in.
     return {
       type: "shell",
-      command: stringValue(args.command) ?? stringValue(args.cmd) ?? stringifyValue(args),
-      cwd: stringValue(args.cwd),
+      command: stringValue(args.command) ?? "",
+      cwd: stringValue(args.workdir),
+    };
+  }
+  if (normalized === "read" || normalized === "read_image") {
+    return {
+      type: "read",
+      filePath: stringValue(args.file_path) ?? "",
+      offset: numberValue(args.offset),
+      limit: numberValue(args.limit),
     };
   }
-  const filePath = stringValue(args.filePath) ?? stringValue(args.path) ?? "";
-  if (/read/u.test(normalized)) {
-    return { type: "read", filePath, offset: numberValue(args.offset), limit: numberValue(args.limit) };
+  if (normalized === "write") {
+    return {
+      type: "write",
+      filePath: stringValue(args.file_path) ?? "",
+      content: stringValue(args.content),
+    };
   }
-  if (/edit|patch/u.test(normalized)) {
+  if (normalized === "edit") {
     return {
       type: "edit",
-      filePath,
-      oldString: stringValue(args.oldString) ?? stringValue(args.old_string),
-      newString: stringValue(args.newString) ?? stringValue(args.new_string),
-      unifiedDiff: stringValue(args.patch) ?? stringValue(args.diff),
+      filePath: stringValue(args.file_path) ?? "",
+      oldString: stringValue(args.old_string),
+      newString: stringValue(args.new_string),
     };
   }
-  if (/write/u.test(normalized)) {
-    return { type: "write", filePath, content: stringValue(args.content) };
+  if (normalized === "grep") {
+    return { type: "search", query: stringValue(args.pattern) ?? "", toolName: "grep" };
   }
-  if (/search|grep|glob/u.test(normalized)) {
-    return { type: "search", query: stringValue(args.query) ?? stringValue(args.pattern) ?? "" };
+  if (normalized === "glob") {
+    return { type: "search", query: stringValue(args.pattern) ?? "", toolName: "glob" };
   }
+  if (normalized === "web_fetch") {
+    return { type: "fetch", url: stringValue(args.url) ?? "" };
+  }
+
+  // Everything else, including MCP tools, keeps a generic detail carrying the
+  // raw arguments. Guessing a card type from the name would render MCP tools as
+  // file operations.
   return { type: "unknown", input: { raw: stringifyValue(args) }, output: {} };
 }
 

package/shared/bridge-protocol.ts

@@ -1,3 +1,5 @@
+import type { SubagentSettingsSave, SubagentSettingsView } from "./subagent-settings.js";
+
 /** The package-owned JSONL boundary. No DSH or Node runtime imports. */
 export const BRIDGE_PROTOCOL_VERSION = 1 as const;
 export type JsonObject = Record<string, unknown>;
@@ -160,6 +162,8 @@ export interface CommandResult {
 }
 export interface BridgeMethods {
   "bridge.initialize": { params: {}; result: BridgeInitializeResult };
+  "subagent.settings.read": { params: {}; result: SubagentSettingsView };
+  "subagent.settings.save": { params: SubagentSettingsSave; result: SubagentSettingsView };
   "session.list": {
     params: { cwd?: string; query?: string; limit?: number };
     result: { sessions: SessionSummary[] };

package/shared/subagent-settings.ts

@@ -0,0 +1,60 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const subagentRouteSchema = z.object({
+  provider: z.string().min(1),
+  model: z.string().min(1),
+});
+export type SubagentRoute = z.infer<typeof subagentRouteSchema>;
+
+export const subagentSelectionSchema = z.object({
+  enabled: z.boolean(),
+  allowedModels: z.array(subagentRouteSchema),
+}).superRefine((value, ctx) => {
+  if (value.enabled && value.allowedModels.length === 0) {
+    ctx.addIssue({ code: "custom", message: "Select at least one model before enabling model selection." });
+  }
+  const keys = value.allowedModels.map(subagentRouteKey);
+  if (new Set(keys).size !== keys.length) {
+    ctx.addIssue({ code: "custom", message: "A model may only be selected once." });
+  }
+});
+export type SubagentSelection = z.infer<typeof subagentSelectionSchema>;
+
+export const subagentSettingsViewSchema = z.object({
+  supported: z.boolean(),
+  profile: z.string(),
+  reason: z.string().optional(),
+  revision: z.string(),
+  initialized: z.boolean(),
+  selection: subagentSelectionSchema,
+  models: z.array(subagentRouteSchema.extend({
+    name: z.string(),
+    providerName: z.string(),
+  })),
+  failedProviders: z.array(z.string()),
+});
+export type SubagentSettingsView = z.infer<typeof subagentSettingsViewSchema>;
+
+export const subagentSettingsSaveSchema = z.object({
+  profile: z.string(),
+  revision: z.string().min(1),
+  selection: subagentSelectionSchema,
+});
+export type SubagentSettingsSave = z.infer<typeof subagentSettingsSaveSchema>;
+
+export const readSubagentSettings = defineRpc({
+  name: "subagent-settings.read",
+  input: z.object({}),
+  output: subagentSettingsViewSchema,
+});
+export const saveSubagentSettings = defineRpc({
+  name: "subagent-settings.save",
+  input: subagentSettingsSaveSchema,
+  output: subagentSettingsViewSchema,
+});
+
+/** Preserve exact provider/model pairs, including model ids containing slashes. */
+export function subagentRouteKey(route: SubagentRoute): string {
+  return JSON.stringify([route.provider, route.model]);
+}