paseo-dsh-direct 0.2.13 → 0.2.15

package/OVERVIEW.md

@@ -14,6 +14,7 @@ Runs DeepSeek Harness (`dsh`) as a native Paseo agent provider. Paseo clients (d
 - Create, resume, cancel and close sessions; model list and mode switching from the Paseo UI.
 - Token usage and context-window fill in Paseo's usage meter.
 - DSH branding (name and icon) in the provider list.
+- On Paseo 0.14, answers the host's idle runtime cleanup query and refuses cleanup while supported DSH checks find pending work (agents, inboxes, maintenance, background jobs, subagent completion delivery, goals, reminders). After the host releases a persisted session runtime, the next message resumes the same native DSH session.
 
 ## Processes and environment
 

package/client/settings-screen.tsx

@@ -1,17 +1,16 @@
-import { useSettings } from "@getpaseo/plugin/client";
+import { useSettings, type PluginSurfaceProps } from "@getpaseo/plugin/client";
 import { ScrollView } from "@getpaseo/plugin/client/react-native";
-import { SettingsAction, SettingsInput, SettingsRow, SettingsSection } from "@getpaseo/plugin/client/ui";
+import { SettingsAction, SettingsInput, SettingsRow } from "@getpaseo/plugin/client/ui";
+import SettingsSection from "./settings-section.js";
 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.";
-const PROFILE_HINT =
-  'Name of the dsh profile to launch. PASEO_DSH_PROFILE overrides this; leave it empty to use the "paseo" profile.';
+const EXECUTABLE_HINT = "DSH command or path; environment takes priority";
+const PROFILE_HINT = "Default: paseo, unless set by environment";
 
 /** Edits the dsh executable and profile that the server reads when it launches a bridge. */
-export default function DshSettingsScreen() {
+export default function DshSettingsScreen({ theme }: PluginSurfaceProps) {
   const settings = useSettings(DSH_SETTINGS);
   const draftState = useRef<{ revision: string | undefined; edits: { executable?: string; profile?: string } }>({
     revision: undefined,
@@ -21,7 +20,7 @@ export default function DshSettingsScreen() {
   if (settings.status === "loading") {
     return (
       <ScrollView>
-        <SettingsSection title="DeepSeek Harness">
+        <SettingsSection title="Connection" theme={theme}>
           <SettingsRow label="Loading settings" />
         </SettingsSection>
       </ScrollView>
@@ -30,9 +29,9 @@ export default function DshSettingsScreen() {
   if (settings.status === "error") {
     return (
       <ScrollView>
-        <SettingsSection title="DeepSeek Harness">
+        <SettingsSection title="Connection" theme={theme}>
           <SettingsRow label="Settings unavailable" error={settings.error} />
-          <SettingsAction label="Retry" actionLabel="Retry" onPress={() => void settings.reload()} />
+          <SettingsAction label="Load settings" actionLabel="Retry" onPress={() => void settings.reload()} />
         </SettingsSection>
       </ScrollView>
     );
@@ -40,9 +39,9 @@ export default function DshSettingsScreen() {
   if (settings.status === "invalid") {
     return (
       <ScrollView>
-        <SettingsSection title="DeepSeek Harness">
-          <SettingsRow label="Stored settings are invalid" error={settings.error} hint="They are ignored until you reset them." />
-          <SettingsAction label="Reset" actionLabel="Reset" onPress={() => void settings.reset()} disabled={settings.saving} />
+        <SettingsSection title="Connection" theme={theme}>
+          <SettingsRow label="Saved settings are invalid" error={settings.error} hint="Reset to use default settings" />
+          <SettingsAction label="Restore defaults" actionLabel="Reset" onPress={() => void settings.reset()} disabled={settings.saving} />
         </SettingsSection>
       </ScrollView>
     );
@@ -65,10 +64,10 @@ export default function DshSettingsScreen() {
 
   return (
     <ScrollView>
-      <SettingsSection title="DeepSeek Harness">
+      <SettingsSection title="Connection" theme={theme}>
         <SettingsInput
           key={`executable-${revision}`}
-          label="dsh executable"
+          label="Executable"
           hint={EXECUTABLE_HINT}
           placeholder="dsh"
           initialValue={values.executable ?? ""}
@@ -79,7 +78,7 @@ export default function DshSettingsScreen() {
         />
         <SettingsInput
           key={`profile-${revision}`}
-          label="dsh profile"
+          label="Profile"
           hint={PROFILE_HINT}
           placeholder="paseo"
           initialValue={values.profile ?? ""}
@@ -89,15 +88,15 @@ export default function DshSettingsScreen() {
           disabled={settings.saving}
         />
         <SettingsAction
-          label="Apply settings"
-          hint={settings.saveError ?? "Changes apply to new sessions."}
+          label="Save settings"
+          hint="Applies to new sessions"
           error={settings.saveError}
           actionLabel={settings.saving ? "Saving" : "Save"}
           onPress={save}
           disabled={settings.saving}
         />
       </SettingsSection>
-      <SubagentSettings launchRevision={revision} launchSaving={settings.saving} />
+      <SubagentSettings theme={theme} launchRevision={revision} launchSaving={settings.saving} />
     </ScrollView>
   );
 }

package/client/settings-section.tsx

@@ -0,0 +1,22 @@
+import type { PluginSurfaceProps } from "@getpaseo/plugin/client";
+import type { ReactNode } from "react";
+import { Text, View } from "react-native";
+
+/** Keep section titles more prominent than field labels in every host theme. */
+export default function SettingsSection({ title, theme, children }: {
+  title: string;
+  theme: PluginSurfaceProps["theme"];
+  children: ReactNode;
+}) {
+  return (
+    <View style={{ marginBottom: 24 }}>
+      <Text
+        accessibilityRole="header"
+        style={{ color: theme.colors.foreground, fontSize: 18, fontWeight: "600", marginHorizontal: 16, marginBottom: 8 }}
+      >
+        {title}
+      </Text>
+      <View>{children}</View>
+    </View>
+  );
+}

package/client/subagent-settings.tsx

@@ -1,7 +1,8 @@
-import { useRpc } from "@getpaseo/plugin/client";
-import { SettingsAction, SettingsInput, SettingsRow, SettingsSection, SettingsSwitch } from "@getpaseo/plugin/client/ui";
+import { useRpc, type PluginSurfaceProps } from "@getpaseo/plugin/client";
+import { Modal, SettingsAction, SettingsInput, SettingsRow, SettingsSwitch } from "@getpaseo/plugin/client/ui";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useState } from "react";
+import SettingsSection from "./settings-section.js";
 import {
   readSubagentSettings,
   saveSubagentSettings,
@@ -30,7 +31,8 @@ function errorMessage(error: unknown): string {
 }
 
 /** Keeps edits tied to the exact profile and revision returned by the daemon. */
-export default function SubagentSettings({ launchRevision, launchSaving }: {
+export default function SubagentSettings({ theme, launchRevision, launchSaving }: {
+  theme: PluginSurfaceProps["theme"];
   launchRevision: string;
   launchSaving: boolean;
 }) {
@@ -47,6 +49,7 @@ export default function SubagentSettings({ launchRevision, launchSaving }: {
   });
   const [draft, setDraft] = useState<Draft | null>(null);
   const [search, setSearch] = useState("");
+  const [editorOpen, setEditorOpen] = useState(false);
   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;
@@ -88,13 +91,12 @@ export default function SubagentSettings({ launchRevision, launchSaving }: {
 
   if (!view || !selection) {
     return (
-      <SettingsSection title="Subagent models">
+      <SettingsSection theme={theme} title="Subagents">
         <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} />}
+        {query.isError && <SettingsAction label="Load models" actionLabel="Retry" onPress={refresh} disabled={busy} />}
       </SettingsSection>
     );
   }
@@ -134,70 +136,66 @@ export default function SubagentSettings({ launchRevision, launchSaving }: {
     edit({ ...selection, allowedModels: [...routes.values()] });
   };
 
-  return (
+  // Older clients expose the same UI module without Modal; keep their inline editor.
+  const hasModal = typeof Modal !== "undefined" && Modal.Content != null;
+  const feedback = (
     <>
-      <SettingsSection title="Subagent models">
+      {conflict && (
+        <SettingsRow label="Settings changed elsewhere" hint="Discard your edits and reload the saved settings" />
+      )}
+      {query.isError && (
+        <SettingsRow label="Could not refresh models" error={errorMessage(query.error)} hint={dirty ? "Your edits are kept; discard and refresh to retry" : "The previous list is shown; refresh to retry"} />
+      )}
+      {launchChanged && (
+        <SettingsRow label="Connection settings changed" error="These edits belong to the previous connection. Discard and refresh before saving." />
+      )}
+      {!view.supported && (
+        <SettingsRow
+          label="Model selection unavailable"
+          hint={view.reason ?? "Choose a profile that supports model selection, then refresh."}
+        />
+      )}
+      {view.failedProviders.length > 0 && (
         <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."
+          label="Some providers could not load models"
+          hint={`${view.failedProviders.join(", ")} · Saved choices kept; refresh to retry`}
         />
-        {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." />
-        )}
+      )}
+      {view.supported && !view.initialized && (
+        <SettingsRow label="No saved selection" hint="Choose models and save, or check your providers if the list is empty" />
+      )}
+      {missingCount > 0 && (
+        <SettingsRow label={`${missingCount} selected ${missingCount === 1 ? "model is" : "models are"} missing from this catalog`} hint="Saved choices are kept unless you remove them" />
+      )}
+    </>
+  );
+  const editor = (
+    <>
+      <SettingsSection theme={theme} title="Selection">
+        <SettingsRow
+          label={`${selection.allowedModels.length} selected · ${view.models.length} available · Profile: ${view.profile}`}
+          hint="Closing keeps your unsaved changes"
+          error={emptyEnabled ? "Select at least one model, or turn off Use selected models." : undefined}
+        />
+        {feedback}
+      </SettingsSection>
+      <SettingsSection theme={theme} title="Model selection">
         <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."
+          label="Use selected models"
+          hint="Turn off to use the profile’s default behavior"
           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}
-        />
+        <SettingsInput label="Search" placeholder="Name, ID or provider" initialValue={search} onChangeText={setSearch} />
       </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" : ""})`}>
+        <SettingsSection theme={theme} 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."}`}
+              hint={model.name === model.model ? (model.available ? undefined : "Not in this catalog") : `${model.model}${model.available ? "" : " · Not in this catalog"}`}
               value={selectedKeys.has(subagentRouteKey(model))}
               onValueChange={(checked) => toggle(model, checked)}
               disabled={busy || !view.supported}
@@ -205,15 +203,32 @@ export default function SubagentSettings({ launchRevision, launchSaving }: {
           ))}
         </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."} />
+      {view.supported && groups.size === 0 && (
+        <SettingsSection theme={theme} title="Models">
+          <SettingsRow label={term ? "No matching models" : "No models available"} hint={term ? "Try a different name, ID or provider" : "Check your providers, then refresh"} />
         </SettingsSection>
       )}
-      <SettingsSection title="Save subagent settings">
+      <SettingsSection theme={theme} title="All models">
+        <SettingsAction
+          label="Available models"
+          hint="Includes models hidden by your search"
+          actionLabel="Select all"
+          onPress={selectAvailable}
+          disabled={busy || !view.supported || view.models.length === 0 || view.models.every((model) => selectedKeys.has(subagentRouteKey(model)))}
+        />
+        <SettingsAction label="Selected models" hint="Clears every choice, including models not shown" 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 edits first" : undefined}
+          actionLabel={query.isError ? "Retry" : "Refresh"}
+          onPress={refresh}
+          disabled={busy || dirty}
+        />
+      </SettingsSection>
+      <SettingsSection theme={theme} title="Changes">
         <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."}
+          label={save.isSuccess ? "Settings saved" : "Save selection"}
+          hint="Applies to new sessions"
           error={saveError}
           actionLabel={save.isPending ? "Saving" : "Save"}
           onPress={() => {
@@ -222,8 +237,28 @@ export default function SubagentSettings({ launchRevision, launchSaving }: {
           }}
           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)} />
+        <SettingsAction label="Reload saved settings" hint="Discards your unsaved changes" actionLabel="Discard and refresh" onPress={discardAndRefresh} disabled={busy || (!dirty && !save.isError)} />
+      </SettingsSection>
+    </>
+  );
+
+  return (
+    <>
+      <SettingsSection theme={theme} title="Subagents">
+        <SettingsAction
+          label={`Model selection: ${selection.enabled ? "On" : "Off"}${save.isPending ? " · Saving…" : dirty ? " · Unsaved changes" : ""}`}
+          hint={`${selection.allowedModels.length} selected · ${view.models.length} available`}
+          actionLabel={!hasModal && editorOpen ? "Close editor" : "Edit models"}
+          onPress={() => setEditorOpen((value) => hasModal || !value)}
+          error={emptyEnabled ? "Select at least one model, or turn off Use selected models." : saveError}
+        />
+        {feedback}
       </SettingsSection>
+      {hasModal ? (
+        <Modal title="Subagent models" open={editorOpen} onOpenChange={setEditorOpen}>
+          <Modal.Content>{editor}</Modal.Content>
+        </Modal>
+      ) : editorOpen ? editor : null}
     </>
   );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-dsh-direct",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "description": "DeepSeek Harness Direct Provider Plugin for Paseo",
   "repository": {
     "type": "git",
@@ -33,8 +33,8 @@
     "!server/generated-version.ts"
   ],
   "peerDependencies": {
-    "@getpaseo/client": "0.12.0",
-    "@getpaseo/protocol": "0.12.0",
+    "@getpaseo/client": "0.14.0",
+    "@getpaseo/protocol": "0.14.0",
     "react": "~19.1.0",
     "react-native": ">=0.81.5",
     "zod": "^4.4.3"
@@ -57,7 +57,7 @@
     }
   },
   "devDependencies": {
-    "@getpaseo/plugin": "0.12.0",
+    "@getpaseo/plugin": "0.14.0",
     "@tanstack/react-query": "^5.105.0",
     "@types/mdast": "^4.0.4",
     "@types/node": "^24.0.0",
@@ -67,6 +67,7 @@
     "mdast-util-from-markdown": "^2.0.3",
     "mdast-util-gfm": "^3.1.0",
     "micromark-extension-gfm": "^3.0.0",
+    "react-native": "0.81.5",
     "tsx": "^4.22.4",
     "typescript": "^5.9.3",
     "zod": "^4.4.3"

package/server/dsh/bridge.ts

@@ -45,6 +45,7 @@ const METHODS = new Set<keyof BridgeMethods>([
   "session.commands",
   "session.command",
   "session.cancel",
+  "session.can_stop_runtime",
   "interaction.respond",
 ]);
 

package/server/dsh/host.ts

@@ -30,6 +30,10 @@ export interface HostAgent {
   id: string;
   ctx: HostContext;
   session: HostSession;
+  inbox?: {
+    readonly nextTurn: readonly unknown[];
+    readonly nextStep: readonly unknown[];
+  };
   options: ModelSelection;
   status: "idle" | "running";
   followup(message: unknown): void;
@@ -92,6 +96,8 @@ export interface HostServices {
   };
   agents: {
     get(id: string): HostAgent | undefined;
+    list?(): HostAgent[];
+    isOwnedBy?(id: string, owner: HostAgent): boolean;
     create(options: AgentOptions): Promise<HostHandle>;
     resume(options: AgentOptions): Promise<HostHandle>;
   };
@@ -199,6 +205,28 @@ export interface HostServices {
       | undefined
     >;
   };
+  jobs?: {
+    list(
+      caller?: string,
+    ): Array<{
+      id: string;
+      owner?: string;
+      status: "running" | "stopping" | "completed" | "killed" | "failed";
+    }>;
+  };
+  goals?: {
+    get(
+      agent: HostAgent,
+    ):
+      | {
+          phase?: string;
+          activation?: string;
+        }
+      | undefined;
+  };
+  schedule?: {
+    list(request: { sessionId: string }): Promise<readonly unknown[]>;
+  };
   userQuestions: object | undefined;
   appReady: { onReady(listener: () => void): () => void } | undefined;
   appExit: ((code: number) => void) | undefined;
@@ -216,6 +244,7 @@ export interface HostHelpers {
 export type ApprovalOutcome =
   "allowed-once" | "rejected" | "cancelled" | "unavailable";
 export interface HostEvents {
+  "schedule/changed": () => void;
   "session/created": (session: HostSession) => void;
   "session/event": (session: HostSession, event: DshSessionEvent) => void;
   "agent/assistant-stream": (payload: {
@@ -244,4 +273,16 @@ export interface HostEvents {
     },
     next: () => Promise<{ answers: QuestionAnswer[] }>,
   ) => Promise<{ answers: QuestionAnswer[] }>;
+  "subagent/start": (info: {
+    runId: string;
+    id: string;
+    provider?: string;
+    local?: boolean;
+  }) => void;
+  "subagent/end": (info: {
+    runId: string;
+    id: string;
+    provider?: string;
+    local?: boolean;
+  }) => void;
 }

package/server/dsh/runtime-safety.ts

@@ -0,0 +1,244 @@
+import type { HostAgent, HostContext } from "./host.js";
+
+/**
+ * Tracks published subagent runs between `subagent/start` and `subagent/end`.
+ *
+ * The subagent manager emits `subagent/end` only after an activation's
+ * teardown finishes, its completion notice is delivered to the parent inbox,
+ * and parent ownership is released. While a run is in this table, stopping the
+ * bridge would lose an external child or a local child's settlement notice.
+ */
+export class SubagentRunTracker {
+  private readonly activeByRoot = new Map<string, Set<string>>();
+  private readonly rootByRun = new Map<string, string | undefined>();
+
+  /**
+   * Subscribe inside a root session's `setup(agentCtx)` so direct delegations
+   * of that root always resolve to `rootId`, even for external backends whose
+   * child id is not in `ctx.agents` or `session/created`.
+   */
+  observeRootScope(rootId: string, agentCtx: HostContext): void {
+    agentCtx.on("subagent/start", (info) => {
+      if (typeof info?.runId === "string" && info.runId) {
+        this.startRun(rootId, info.runId);
+      }
+    });
+    agentCtx.on("subagent/end", (info) => {
+      if (typeof info?.runId === "string" && info.runId) {
+        this.endRun(info.runId);
+      }
+    });
+  }
+
+  /**
+   * Observe every process-level run, including external children whose parent
+   * is outside the bridge-owned session tree.
+   */
+  observeHost(
+    ctx: HostContext,
+    resolveRoot: (childId: string) => string | undefined,
+  ): Array<() => void> {
+    return [
+      ctx.on("subagent/start", (info) => {
+        if (typeof info?.runId !== "string" || !info.runId) return;
+        if (this.rootByRun.has(info.runId)) return;
+        const rootId =
+          typeof info.id === "string" ? resolveRoot(info.id) : undefined;
+        this.startRun(rootId, info.runId);
+      }),
+      ctx.on("subagent/end", (info) => {
+        if (typeof info?.runId === "string" && info.runId) {
+          this.endRun(info.runId);
+        }
+      }),
+    ];
+  }
+
+  hasActiveRuns(rootId?: string): boolean {
+    return rootId === undefined
+      ? this.rootByRun.size > 0
+      : (this.activeByRoot.get(rootId)?.size ?? 0) > 0;
+  }
+
+  clearRoot(rootId: string): void {
+    const runs = this.activeByRoot.get(rootId);
+    if (runs) {
+      for (const runId of runs) this.rootByRun.delete(runId);
+      this.activeByRoot.delete(rootId);
+    }
+  }
+
+  clearAll(): void {
+    this.activeByRoot.clear();
+    this.rootByRun.clear();
+  }
+
+  private startRun(rootId: string | undefined, runId: string): void {
+    const existing = this.rootByRun.get(runId);
+    if (existing && existing !== rootId) {
+      this.activeByRoot.get(existing)?.delete(runId);
+    }
+    this.rootByRun.set(runId, rootId);
+    if (rootId === undefined) return;
+    let set = this.activeByRoot.get(rootId);
+    if (!set) {
+      set = new Set();
+      this.activeByRoot.set(rootId, set);
+    }
+    set.add(runId);
+  }
+
+  private endRun(runId: string): void {
+    const rootId = this.rootByRun.get(runId);
+    this.rootByRun.delete(runId);
+    if (!rootId) return;
+    const set = this.activeByRoot.get(rootId);
+    if (!set) return;
+    set.delete(runId);
+    if (set.size === 0) this.activeByRoot.delete(rootId);
+  }
+}
+
+export interface RuntimeSafetyInput {
+  ctx: HostContext;
+  sessionId: string;
+  rootAgent: HostAgent | undefined;
+  hasBridgeActivity: () => boolean;
+  hasActiveSubagentRuns: () => boolean;
+}
+
+/**
+ * Decide whether releasing this DSH session runtime loses in-flight work.
+ *
+ * This query is strictly read-only: it never cancels, disposes, mutates, or
+ * leaves behind uncancelled listeners. Any missing required inspection surface
+ * or thrown error fails closed (`false`).
+ */
+export async function canStopSessionRuntime(
+  input: RuntimeSafetyInput,
+): Promise<boolean> {
+  let disposeScheduleObserver: (() => void) | undefined;
+  try {
+    if (input.hasBridgeActivity() || input.hasActiveSubagentRuns()) return false;
+    const root = input.rootAgent;
+    if (!root || String(root.id) !== input.sessionId) return false;
+    const agents = input.ctx.get("agents");
+    const jobs = input.ctx.get("jobs");
+    const goals = input.ctx.get("goals");
+    const schedule = input.ctx.get("schedule");
+    if (
+      !agents ||
+      typeof agents.get !== "function" ||
+      typeof agents.list !== "function" ||
+      !jobs ||
+      typeof jobs.list !== "function" ||
+      (goals && typeof goals.get !== "function") ||
+      (schedule && typeof schedule.list !== "function")
+    ) {
+      return false;
+    }
+
+    let scheduleChanged = false;
+    if (schedule) {
+      disposeScheduleObserver = input.ctx.on("schedule/changed", () => {
+        scheduleChanged = true;
+      });
+    }
+    // Stopping the bridge exits the entire DSH process, including agents
+    // started by the profile or schedule runtime outside this session's tree.
+    const readAgents = (): HostAgent[] => {
+      if (agents.get(input.sessionId) !== root) return [];
+      const live = agents.list!();
+      return Array.isArray(live) && live.includes(root) ? live : [];
+    };
+    const liveAgents = readAgents();
+    if (liveAgents.length === 0 || !(await areAgentsQuiescent(liveAgents))) return false;
+    if (schedule) {
+      for (const agent of liveAgents) {
+        const active = await schedule.list({ sessionId: String(agent.id) });
+        if (!Array.isArray(active) || active.length > 0) return false;
+      }
+    }
+
+    // Schedule reads yield to arbitrary runtime work. Probe maintenance again,
+    // then re-read every synchronous veto before returning the decision.
+    if (!(await areAgentsQuiescent(liveAgents))) return false;
+    const currentAgents = readAgents();
+    if (
+      scheduleChanged ||
+      input.hasBridgeActivity() ||
+      input.hasActiveSubagentRuns() ||
+      currentAgents.length !== liveAgents.length ||
+      currentAgents.some((agent) => !liveAgents.includes(agent))
+    ) {
+      return false;
+    }
+    for (const agent of liveAgents) {
+      if (!isAgentSynchronouslyIdle(agent)) return false;
+      const goal = goals?.get(agent);
+      if (goal?.phase === "active" && goal.activation === "armed") return false;
+    }
+    // No caller filter: jobs can outlive their owner agent's registry entry.
+    const views = jobs.list();
+    if (
+      !Array.isArray(views) || views.some(
+        (job) => job?.status === "running" || job?.status === "stopping",
+      )
+    ) return false;
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try {
+      disposeScheduleObserver?.();
+    } catch {
+      return false;
+    }
+  }
+}
+
+function isAgentSynchronouslyIdle(agent: HostAgent): boolean {
+  if (agent.status !== "idle") return false;
+  const inbox = agent.inbox;
+  if (
+    !inbox ||
+    !Array.isArray(inbox.nextTurn) ||
+    !Array.isArray(inbox.nextStep)
+  ) {
+    return false;
+  }
+  return inbox.nextTurn.length === 0 && inbox.nextStep.length === 0;
+}
+
+// Repeated safety queries during a long maintenance job must not attach another
+// whenIdle continuation to the same unfinished activity on every request.
+const idleObservations = new WeakMap<
+  HostAgent,
+  { state: "pending" | "idle" | "failed" }
+>();
+
+async function areAgentsQuiescent(agents: readonly HostAgent[]): Promise<boolean> {
+  const observations = [];
+  for (const agent of agents) {
+    if (!isAgentSynchronouslyIdle(agent) || typeof agent.whenIdle !== "function") {
+      return false;
+    }
+    let observation = idleObservations.get(agent);
+    if (!observation || observation.state !== "pending") {
+      observation = { state: "pending" };
+      idleObservations.set(agent, observation);
+      const current = observation;
+      void Promise.resolve(agent.whenIdle()).then(
+        () => { current.state = "idle"; },
+        () => { current.state = "failed"; },
+      );
+    }
+    observations.push(observation);
+  }
+  // DSH's async whenIdle awaits activityDone and checks that its identity has
+  // not changed. Allow that resolved-promise path to finish without waiting for
+  // pending maintenance, timers, or attaching listeners to a long-lived race.
+  await Promise.resolve().then(() => undefined).then(() => undefined);
+  return observations.every((observation) => observation.state === "idle") &&
+    agents.every(isAgentSynchronouslyIdle);
+}

package/server/dsh/service.ts

@@ -19,6 +19,7 @@ import type {
   SlashCommand,
 } from "../../shared/bridge-protocol.js";
 import { SubagentSettings } from "./subagent-settings.js";
+import { canStopSessionRuntime, SubagentRunTracker } from "./runtime-safety.js";
 import { slashLine } from "../../shared/bridge-protocol.js";
 import type {
   ApprovalOutcome,
@@ -147,6 +148,7 @@ export class BridgeService {
   private stopTask?: Promise<{}>;
   private readonly subagentSettings: SubagentSettings;
   private subagentSettingsInitializationError?: Error;
+  private readonly subagentRuns = new SubagentRunTracker();
 
   constructor(
     private readonly ctx: HostContext,
@@ -157,11 +159,12 @@ export class BridgeService {
     this.subagentSettings = new SubagentSettings(ctx, profile);
     this.subscriptions.push(
       ctx.on("session/created", (session) => {
-        if (session.header.parentSession)
+        if (session.header.parentSession) {
           this.parent.set(
             String(session.id),
             String(session.header.parentSession),
           );
+        }
       }),
     );
     this.subscriptions.push(
@@ -237,6 +240,11 @@ export class BridgeService {
         });
       }),
     );
+    this.subscriptions.push(
+      ...this.subagentRuns.observeHost(ctx, (childId) =>
+        this.rootForId(childId),
+      ),
+    );
   }
 
   /**
@@ -316,13 +324,19 @@ export class BridgeService {
   }
 
   private rootFor(agent: HostAgent | undefined): string | undefined {
-    let id = agent?.id && String(agent.id);
+    return agent && this.rootForId(String(agent.id), agent);
+  }
+
+  private rootForId(
+    sessionId: string,
+    agent = this.ctx.get("agents")?.get(sessionId),
+  ): string | undefined {
+    let id: string | undefined = sessionId;
     const seen = new Set<string>();
     while (id && !seen.has(id)) {
       if (this.tracked.has(id)) return id;
       seen.add(id);
-      id =
-        this.parent.get(id) ??
+      id = this.parent.get(id) ??
         (id === agent?.id ? agent.session.header.parentSession : undefined);
     }
     return undefined;
@@ -581,6 +595,13 @@ export class BridgeService {
         );
         result = {};
         break;
+      case "session.can_stop_runtime":
+        result = {
+          canStop: await this.canStopRuntime(
+            nonempty(params.sessionId, "sessionId"),
+          ),
+        };
+        break;
       case "session.close":
         await this.close(nonempty(params.sessionId, "sessionId"));
         result = {};
@@ -815,6 +836,7 @@ export class BridgeService {
         this.tracked.delete(id);
         this.preapproved.delete(id);
         this.lastUsage.delete(id);
+        this.subagentRuns.clearRoot(id);
       },
     );
     return task;
@@ -853,6 +875,7 @@ export class BridgeService {
       assembled: undefined,
     };
     const setup = async (agentCtx: HostContext) => {
+      this.subagentRuns.observeRootScope(id, agentCtx);
       this.helpers?.installModelSelection(agentCtx, modelRef);
       await presets.mount(agentCtx, preset.id);
       if (params.systemPrompt) {
@@ -950,6 +973,23 @@ export class BridgeService {
     pending.finish({ answers: params.answers });
   }
 
+  private canStopRuntime(sessionId: string): Promise<boolean> {
+    return canStopSessionRuntime({
+      ctx: this.ctx,
+      sessionId,
+      rootAgent: this.owned.get(sessionId)?.handle.agent,
+      hasBridgeActivity: () =>
+        this.stopping ||
+        this.opening.has(sessionId) ||
+        this.closing.has(sessionId) ||
+        this.commandAborts.has(sessionId) ||
+        [...this.interactions.values()].some(
+          (pending) => pending.request.sessionId === sessionId,
+        ),
+      hasActiveSubagentRuns: () => this.subagentRuns.hasActiveRuns(),
+    });
+  }
+
   private close(id: string): Promise<void> {
     const previous = this.closing.get(id);
     if (previous) return previous;
@@ -964,6 +1004,7 @@ export class BridgeService {
       this.tracked.delete(id);
       this.preapproved.delete(id);
       this.lastUsage.delete(id);
+      this.subagentRuns.clearRoot(id);
     })();
     this.closing.set(id, task);
     void task.finally(() => this.closing.delete(id)).catch(() => undefined);
@@ -978,6 +1019,7 @@ export class BridgeService {
       const results = await Promise.allSettled(
         [...this.owned.keys()].map((id) => this.close(id)),
       );
+      this.subagentRuns.clearAll();
       for (const dispose of this.subscriptions.splice(0)) dispose();
       if (results.some((result) => result.status === "rejected"))
         throw new Error("One or more DSH sessions failed to close");

package/server/provider.ts

@@ -48,6 +48,7 @@ const CAPABILITIES = [
   "prompt.command",
   "prompt.image",
   "prompt.steer",
+  "session.can_stop_runtime",
   "session.configure",
   "session.list",
   "session.persistence",
@@ -57,6 +58,8 @@ const CAPABILITIES = [
 ] as const;
 const PERMISSION_PRESET_SETTING = "permissionPreset";
 const PLAN_MODE_SETTING = "planMode";
+// Leave room for the host's ten-second safety-query deadline and IPC overhead.
+const RUNTIME_SAFETY_TIMEOUT_MS = 5_000;
 
 type DetectVersion = (
   executable: string,
@@ -104,6 +107,11 @@ interface SessionState {
   planMode: boolean;
   pendingInteractions: Map<string, InteractionRequest>;
   lane: Promise<void>;
+  /** Includes admitted input still waiting for its dispatch microtask or lane. */
+  pendingOperations: number;
+  /** Reject a safety snapshot if any input or native activity happened meanwhile. */
+  activityRevision: number;
+  ready: boolean;
   closed: boolean;
 }
 
@@ -216,13 +224,22 @@ function createConnection(
     async send(input) {
       if (closed) throw new Error("Provider connection is closed");
       validateAdmission(input, sessions, capabilities);
+      const operationSession = input.type !== "session.can_stop_runtime" && "sessionId" in input
+        ? sessions.get(input.sessionId)
+        : undefined;
+      if (operationSession) {
+        operationSession.pendingOperations += 1;
+        operationSession.activityRevision += 1;
+      }
       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));
+      }).catch((error) => failInput(input, error, emit)).finally(() => {
+        if (operationSession) operationSession.pendingOperations -= 1;
+      });
       if (input.type === "session.open") {
         pendingOpens.add(pending);
         void pending.then(() => pendingOpens.delete(pending));
@@ -265,6 +282,7 @@ function listenToSessionBridge(
   return [
     session.bridge.on("session.event", ({ sessionId, event }) => {
       if (!isCurrentSession(sessionId)) return;
+      session.activityRevision += 1;
       // The prompt path emits its own bubble with the clientMessageId.
       if (event.type === "user/message" && session.dispatch?.kind === "prompt") return;
       if (event.type === "turn/start") {
@@ -309,10 +327,12 @@ function listenToSessionBridge(
     }),
     session.bridge.on("session.stream", ({ sessionId, frame }) => {
       if (!isCurrentSession(sessionId)) return;
+      session.activityRevision += 1;
       for (const projected of session.projector.projectStream(frame)) emit(projected);
     }),
     session.bridge.on("session.status", ({ sessionId, status }) => {
       if (!isCurrentSession(sessionId)) return;
+      session.activityRevision += 1;
       if (status === "running") {
         if (session.dispatch) session.dispatch.sawRunning = true;
         return;
@@ -325,6 +345,7 @@ function listenToSessionBridge(
     }),
     session.bridge.on("session.usage", ({ sessionId, usage }) => {
       if (!isCurrentSession(sessionId)) return;
+      session.activityRevision += 1;
       emit({
         type: "session.usage",
         sessionId: session.paseoId,
@@ -334,6 +355,7 @@ function listenToSessionBridge(
     }),
     session.bridge.on("interaction.request", (interaction) => {
       if (!isCurrentSession(interaction.sessionId)) return;
+      session.activityRevision += 1;
       session.pendingInteractions.set(interaction.requestId, interaction);
       emit({
         type: "session.permission",
@@ -343,6 +365,7 @@ function listenToSessionBridge(
     }),
     session.bridge.on("interaction.closed", ({ requestId, sessionId }) => {
       if (!isCurrentSession(sessionId) || !session.pendingInteractions.delete(requestId)) return;
+      session.activityRevision += 1;
       emit({
         type: "session.permission_resolved",
         sessionId: session.paseoId,
@@ -424,6 +447,9 @@ async function dispatch(input: ProviderInput, state: DispatchState): Promise<voi
     case "session.configure":
       await enqueue(requireSession(state.sessions, input.sessionId), () => configureSession(input, state));
       return;
+    case "session.can_stop_runtime":
+      await canStopRuntime(input, state);
+      return;
     case "session.close":
       await closeSession(input, state);
       return;
@@ -529,6 +555,9 @@ async function openSession(
       planMode: latestPlanMode(opened.events),
       pendingInteractions: new Map(),
       lane: Promise.resolve(),
+      pendingOperations: 0,
+      activityRevision: 0,
+      ready: false,
       closed: false,
     };
     state.sessions.set(input.sessionId, session);
@@ -569,6 +598,8 @@ async function openSession(
     session.projector.seed(session.open.events);
   }
   await warnOnDshVersionMismatch(session, state);
+  if (state.isClosed() || session.closed) return;
+  session.ready = true;
   state.emit({ type: "session.ready", requestId: input.requestId, sessionId: input.sessionId });
 }
 
@@ -825,6 +856,54 @@ async function respondToPermission(
   }
 }
 
+async function canStopRuntime(
+  input: Extract<ProviderInput, { type: "session.can_stop_runtime" }>,
+  state: DispatchState,
+): Promise<void> {
+  const session = requireSession(state.sessions, input.sessionId);
+  if (!isProviderSessionIdle(session)) {
+    state.emit({
+      type: "session.can_stop_runtime",
+      requestId: input.requestId,
+      sessionId: input.sessionId,
+      canStop: false,
+    });
+    return;
+  }
+  const revision = session.activityRevision;
+  const result = await session.bridge.request(
+    "session.can_stop_runtime",
+    { sessionId: session.nativeId },
+    RUNTIME_SAFETY_TIMEOUT_MS,
+  );
+  if (typeof result?.canStop !== "boolean") {
+    throw new Error("Invalid DSH runtime safety response");
+  }
+  const canStop =
+    result.canStop &&
+    state.sessions.get(input.sessionId) === session &&
+    session.activityRevision === revision &&
+    isProviderSessionIdle(session);
+  state.emit({
+    type: "session.can_stop_runtime",
+    requestId: input.requestId,
+    sessionId: input.sessionId,
+    canStop,
+  });
+}
+
+function isProviderSessionIdle(session: SessionState): boolean {
+  return (
+    session.ready &&
+    !session.closed &&
+    session.config.persist &&
+    !session.activeTurnId &&
+    !session.dispatch &&
+    session.pendingInteractions.size === 0 &&
+    session.pendingOperations === 0
+  );
+}
+
 async function closeSession(
   input: Extract<ProviderInput, { type: "session.close" }>,
   state: DispatchState,
@@ -860,6 +939,7 @@ function validateAdmission(
     if (sessions.has(input.sessionId)) throw new Error(`Session already exists: ${input.sessionId}`);
     return;
   }
+  if (input.type === "session.can_stop_runtime") return;
   if ("sessionId" in input && !sessions.has(input.sessionId)) {
     throw new Error(`Unknown session: ${input.sessionId}`);
   }

package/shared/bridge-protocol.ts

@@ -204,6 +204,10 @@ export interface BridgeMethods {
     result: {};
   };
   "session.cancel": { params: { sessionId: string }; result: {} };
+  "session.can_stop_runtime": {
+    params: { sessionId: string };
+    result: { canStop: boolean };
+  };
   "session.close": { params: { sessionId: string }; result: {} };
   "interaction.respond": {
     params: {