paseo-dsh-direct 0.2.10 → 0.2.12

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.10",
+  "version": "0.2.12",
   "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/bridge-client.ts

@@ -17,6 +17,15 @@ import type {
 type Method = keyof BridgeMethods;
 type Notification = keyof BridgeNotifications;
 
+/**
+ * Default deadline for one bridge request. `session.list` title folds decode a
+ * whole session log per row, so callers list large histories with a wider
+ * deadline instead of raising this for every method.
+ */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+/** Deadline for listing sessions: a cold title fold costs seconds per hundred sessions. */
+export const LIST_SESSIONS_TIMEOUT_MS = 120_000;
+
 export interface DshBridge {
   readonly initialized: BridgeInitializeResult;
   /** The resolved `dsh` executable this bridge was launched with (see `resolveDshLaunch`). */
@@ -26,6 +35,7 @@ export interface DshBridge {
   request<Name extends Method>(
     method: Name,
     params: BridgeMethods[Name]["params"],
+    timeoutMs?: number,
   ): Promise<BridgeMethods[Name]["result"]>;
   on<Name extends Notification>(
     method: Name,
@@ -471,6 +481,7 @@ class JsonlBridgeClient implements DshBridge {
   request<Name extends Method>(
     method: Name,
     params: BridgeMethods[Name]["params"],
+    timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
   ): Promise<BridgeMethods[Name]["result"]> {
     if (this.terminalError) return Promise.reject(this.terminalError);
     if (this.closing && method !== "bridge.shutdown") {
@@ -481,7 +492,7 @@ class JsonlBridgeClient implements DshBridge {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`DSH bridge request timed out: ${method}`));
-      }, 30_000);
+      }, timeoutMs);
       this.pending.set(id, { resolve, reject, timeout });
       const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
       this.child.stdin.write(payload, (error) => {

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,
@@ -140,8 +141,12 @@ export class BridgeService {
   private readonly subscriptions: Array<() => void> = [];
   /** Last usage payload sent per session, so an unchanged fold is not re-sent. */
   private readonly lastUsage = new Map<string, string>();
+  /** Folded titles per session id, so repeated import listings stay cheap. */
+  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,
@@ -149,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)
@@ -262,7 +268,11 @@ export class BridgeService {
         }
       | undefined;
     const pressure = values.contextPressure as
-      | { contextWindow?: number; pressureTokens?: number }
+      | {
+          contextWindow?: number;
+          pressureTokens?: number;
+          projectedTokens?: number;
+        }
       | undefined;
     const usage: BridgeUsage = {};
     if (typeof tokens?.uncachedInputTokens === "number")
@@ -271,8 +281,16 @@ export class BridgeService {
       usage.cachedInputTokens = tokens.cacheReadTokens;
     if (typeof tokens?.outputTokens === "number")
       usage.outputTokens = tokens.outputTokens;
-    if (typeof pressure?.pressureTokens === "number")
-      usage.contextWindowUsedTokens = pressure.pressureTokens;
+    // `projectedTokens` folds the shadow price of an adjacent compaction into
+    // the last request's prompt size, so the meter drops as soon as a
+    // compaction lands instead of waiting for the next request. dsh before
+    // 0.2.1 writes no shadow price and the field is absent: fall back to the
+    // raw prompt size.
+    const used =
+      typeof pressure?.projectedTokens === "number"
+        ? pressure.projectedTokens
+        : pressure?.pressureTokens;
+    if (typeof used === "number") usage.contextWindowUsedTokens = used;
     if (typeof pressure?.contextWindow === "number")
       usage.contextWindowMaxTokens = pressure.contextWindow;
     // The units materialize at zero before any provider usage lands, so a
@@ -439,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,
@@ -453,29 +480,17 @@ export class BridgeService {
         } satisfies BridgeInitializeResult;
         break;
       }
-      case "session.list": {
-        const query = this.ctx.get("sessionQuery");
-        const records = await query.listSessions();
-        const sessions: SessionSummary[] = records.map((record) => ({
-          ...record.header,
-        }));
-        // The official bulk title read owns live/cold source and validation.
-        if (typeof query.readTitleSnapshots === "function") {
-          const titles = await query.readTitleSnapshots(
-            sessions.map((session) => session.id),
-          );
-          for (let i = 0; i < sessions.length; i++) {
-            const result = titles[i];
-            const title =
-              result?.status === "fulfilled"
-                ? result.value.title?.title
-                : undefined;
-            if (typeof title === "string") sessions[i]!.title = title;
-          }
-        }
-        result = { sessions };
+      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;
-      }
       case "session.read":
         result = await this.ctx
           .get("sessionQuery")
@@ -622,6 +637,72 @@ export class BridgeService {
     );
   }
 
+  /**
+   * List native sessions for Paseo's import picker.
+   *
+   * `readTitleSnapshots` decodes each requested session's log to fold its
+   * title, which costs seconds per hundred sessions on a large history, so
+   * titles are folded only for the rows this call returns: cwd and query
+   * filter first, then newest first, then the limit. Folded titles are cached
+   * for this bridge's lifetime; a title renamed outside Paseo keeps its cached
+   * value until the bridge is replaced, while live sessions carry their header
+   * title regardless.
+   */
+  private async listSessions(
+    params: { cwd?: string; query?: string; limit?: number },
+  ): Promise<SessionSummary[]> {
+    const query = this.ctx.get("sessionQuery");
+    const records = await query.listSessions();
+    let sessions = records
+      .map((record) => ({ ...record.header }))
+      .filter((session) => !params.cwd || session.cwd === params.cwd);
+    if (params.query) {
+      // A title query needs every title, so this path folds the whole history.
+      await this.foldTitles(query, sessions);
+      const needle = params.query.toLowerCase();
+      sessions = sessions.filter(
+        (session) =>
+          session.title?.toLowerCase().includes(needle) ||
+          session.id.toLowerCase().includes(needle),
+      );
+    }
+    sessions.sort((left, right) => right.createdAt - left.createdAt);
+    if (params.limit !== undefined && sessions.length > params.limit)
+      sessions = sessions.slice(0, params.limit);
+    await this.foldTitles(query, sessions);
+    return sessions;
+  }
+
+  /** Fill in cached titles, reading only the sessions this bridge has not folded yet. */
+  private async foldTitles(
+    query: HostServices["sessionQuery"],
+    sessions: SessionSummary[],
+  ): Promise<void> {
+    if (typeof query.readTitleSnapshots !== "function") return;
+    // The official bulk title read owns live/cold source and validation. A
+    // header that already carries a title is live and needs no fold at all.
+    const missing = sessions.filter(
+      (session) => !session.title && !this.titles.has(session.id),
+    );
+    if (missing.length > 0) {
+      const titles = await query.readTitleSnapshots(
+        missing.map((session) => session.id),
+      );
+      for (let i = 0; i < missing.length; i++) {
+        const result = titles[i];
+        const title =
+          result?.status === "fulfilled"
+            ? result.value.title?.title
+            : undefined;
+        if (typeof title === "string") this.titles.set(missing[i]!.id, title);
+      }
+    }
+    for (const session of sessions) {
+      const title = this.titles.get(session.id);
+      if (title !== undefined) session.title = title;
+    }
+  }
+
   /** Registered commands first; a skill never shadows a command of the same name. */
   private async slashCommands(agent: HostAgent): Promise<SlashCommand[]> {
     const commands: SlashCommand[] = (this.ctx.get("commands")?.list(agent) ?? []).map(
@@ -971,6 +1052,31 @@ function validateContent(value: unknown): PromptPart[] {
   return parts;
 }
 
+function listParams(params: Record<string, unknown>): {
+  cwd?: string;
+  query?: string;
+  limit?: number;
+} {
+  const result: { cwd?: string; query?: string; limit?: number } = {};
+  if (params.cwd !== undefined) result.cwd = nonempty(params.cwd, "cwd");
+  if (params.query !== undefined) {
+    if (typeof params.query !== "string")
+      throw new Error("query must be a string");
+    const query = params.query.trim();
+    if (query) result.query = query;
+  }
+  if (params.limit !== undefined) {
+    if (
+      typeof params.limit !== "number" ||
+      !Number.isSafeInteger(params.limit) ||
+      params.limit < 1
+    )
+      throw new Error("limit must be a positive integer");
+    result.limit = params.limit;
+  }
+  return result;
+}
+
 function validateOpen(params: Record<string, unknown>): SessionOpenParams {
   const result: SessionOpenParams = { cwd: nonempty(params.cwd, "cwd") };
   if (params.sessionId !== undefined)

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

@@ -27,6 +27,7 @@ import { slashLine } from "../shared/bridge-protocol.js";
 import {
   DEFAULT_PROFILE,
   describeDshLaunch,
+  LIST_SESSIONS_TIMEOUT_MS,
   resolveDshLaunch,
   type BridgeMcpServer,
   type DshBridge,
@@ -64,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
@@ -111,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";
@@ -118,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,
@@ -127,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();
@@ -404,8 +410,18 @@ async function listSessions(
   input: Extract<ProviderInput, { type: "sessions" }>,
   state: DispatchState,
 ): Promise<void> {
-  const result = await state.discoveryBridge.request("session.list", {});
   const query = input.query?.trim().toLowerCase();
+  // Filtering and truncation run in the bridge so title folds only cover the
+  // rows Paseo will actually show; the local filters stay as a second net.
+  const result = await state.discoveryBridge.request(
+    "session.list",
+    {
+      ...(input.cwd ? { cwd: input.cwd } : {}),
+      ...(query ? { query } : {}),
+      ...(input.limit !== undefined ? { limit: input.limit } : {}),
+    },
+    LIST_SESSIONS_TIMEOUT_MS,
+  );
   const rows = result.sessions
     .filter((session): session is typeof session & { cwd: string } => Boolean(session.cwd))
     .filter((session) => !input.cwd || session.cwd === input.cwd)

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/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,7 +162,12 @@ export interface CommandResult {
 }
 export interface BridgeMethods {
   "bridge.initialize": { params: {}; result: BridgeInitializeResult };
-  "session.list": { params: {}; result: { sessions: SessionSummary[] } };
+  "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[] };
+  };
   "session.read": { params: { sessionId: string }; result: SessionSnapshot };
   "session.open": { params: SessionOpenParams; result: SessionOpenResult };
   "session.prompt": {

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]);
+}