@omercnet/paseo-omp 5.1.1-next.336.1 → 5.1.1-next.340.1

package/OVERVIEW.md

@@ -11,6 +11,7 @@ OMP adds an agent provider for the OMP coding agent, plus an OMP sidebar and wor
 - Edit OMP settings and project configuration for the default store or a named profile.
 - Manage OMP's own plugins, and view quota history, memory, hub processes, session history and a support report.
 - An **MCP** composer control runs OMP's MCP management in the current session, with authorization prompts shown in the chat.
+- While OMP subagents run, a row under each `task` card in the conversation lets you steer one with a message or stop it after confirmation. It needs OMP 18.4.9 or newer.
 - OMP agents can call Paseo's orchestration tools with the optional `serverId` argument and `list_hosts` to delegate work to other connected Paseo hosts.
 
 ## Reads and sends

package/README.md

@@ -31,7 +31,7 @@ paseo plugin install npm:@omercnet/paseo-omp@<version>
 paseo plugin ls paseo-omp
 ```
 
-Open the **OMP** sidebar to review the provider-profile contract, choose which composer pills appear, browse and edit native scalar settings, manage OMP-native plugins, verify runtime health, and generate a bounded support report under **Help**. The same tabs are available in the workspace OMP panel, except for the global Composer preference tab. Then create an agent and select **OMP Plugin**. Its optional **MCP** composer control runs OMP-native management commands in the current session; setup questions and authorization stay in that chat timeline, where OAuth can open in a workspace-scoped Paseo Browser or on the current device. Composer pill preferences are shared by clients connected to the same host; normal use requires no other plugin-specific settings.
+Open the **OMP** sidebar to review the provider-profile contract, choose which composer pills appear, browse and edit native scalar settings, manage OMP-native plugins, verify runtime health, and generate a bounded support report under **Help**. The same tabs are available in the workspace OMP panel, except for the global Composer preference tab. Then create an agent and select **OMP Plugin**. Its optional **MCP** composer control runs OMP-native management commands in the current session; setup questions and authorization stay in that chat timeline, where OAuth can open in a workspace-scoped Paseo Browser or on the current device. While OMP subagents run, a row under each `task` card in the conversation lets you steer or stop one of them; this needs OMP 18.4.9 or newer. Composer pill preferences are shared by clients connected to the same host; normal use requires no other plugin-specific settings.
 
 - [Install, update, rollback, and local development](docs/installation.md)
 - [Configuration and every provider option](docs/configuration.md)
@@ -84,7 +84,7 @@ Scoring is deliberately mechanical so releases remain comparable:
 | `session.revert.both` | **0%** | Not advertised because OMP cannot atomically rewind conversation and workspace files. |
 | `session.revert.conversation` | **100%** | Native branch-based conversation rewind, replay deduplication, ownership transfer, and failure quarantine. |
 | `session.revert.files` | **0%** | Not advertised because OMP does not expose a native file-only rewind contract. |
-| `session.subsession` | **100%** | Direct and nested OMP subagents become Paseo child sessions with lifecycle, ancestry, progress, and replay. |
+| `session.subsession` | **100%** | Direct and nested OMP subagents become Paseo child sessions with lifecycle, ancestry, progress, and replay. Paseo's child sessions are read-only, so the provider also publishes a plugin timeline row under each `task` card that steers or stops one running child through OMP's `steer_subagent` and `cancel_subagent` (OMP 18.4.9 or newer) without stopping the parent turn. |
 | `session.unarchive` | **0%** | Not advertised; there is no native OMP archive state to reverse. |
 | `permission` | **100%** | Typed tool permissions when negotiated, with a bounded generic interaction fallback for OMP 18.1.15. Allow, deny, cancel, timeout, and interruption are covered. |
 | `permission.tool_policy` | **0%** | Not advertised. Exact MCP preapproval policy cannot be preserved through OMP `set_host_tools`, so the plugin fails closed instead of broadening access. |

package/client/subagents-state.ts

@@ -0,0 +1,108 @@
+import type { OmpSubagentStrip } from "../shared/subagents";
+
+export type OmpSubagentRow = OmpSubagentStrip["subagents"][number];
+
+/**
+ * One row of a subagent strip at a time owns the stop confirmation, the steering draft, or the
+ * pending request. The state keeps that row as last listed, so its draft stays visible after the
+ * subagent leaves the strip.
+ */
+export type SubagentStripState =
+  | { kind: "idle" }
+  | { kind: "confirming-stop"; subagent: OmpSubagentRow }
+  | { kind: "steering"; subagent: OmpSubagentRow; draft: string }
+  | { kind: "stopping"; subagent: OmpSubagentRow }
+  | { kind: "sending"; subagent: OmpSubagentRow; draft: string };
+
+export type SubagentStripAction =
+  | { type: "request-stop"; subagent: OmpSubagentRow }
+  | { type: "start-steer"; subagent: OmpSubagentRow }
+  | { type: "edit-draft"; draft: string }
+  | { type: "dismiss" }
+  | { type: "submit" }
+  | { type: "settled" }
+  | { type: "failed" };
+
+type PendingState = Extract<SubagentStripState, { kind: "stopping" | "sending" }>;
+
+export const INITIAL_SUBAGENT_STRIP_STATE: SubagentStripState = { kind: "idle" };
+
+export function isSendableDraft(draft: string): boolean {
+  return draft.trim().length > 0;
+}
+
+export function isSubagentRequestPending(state: SubagentStripState): state is PendingState {
+  return state.kind === "stopping" || state.kind === "sending";
+}
+
+/** The subagent a row's controls belong to while it owns the strip, or `null`. */
+export function activeSubagent(state: SubagentStripState): OmpSubagentRow | null {
+  return state.kind === "idle" ? null : state.subagent;
+}
+
+/**
+ * The request a submit starts from this state, or `null` when it starts none. A submit while a
+ * request is pending starts nothing, so a repeated press cannot send a second steering message.
+ */
+export function requestedSubmission(state: SubagentStripState): PendingState | null {
+  if (isSubagentRequestPending(state)) return null;
+  const next = subagentStripReducer(state, { type: "submit" });
+  return isSubagentRequestPending(next) ? next : null;
+}
+
+export function subagentStripReducer(
+  state: SubagentStripState,
+  action: SubagentStripAction,
+): SubagentStripState {
+  if (isSubagentRequestPending(state)) return settle(state, action);
+  switch (action.type) {
+    case "request-stop":
+      return { kind: "confirming-stop", subagent: action.subagent };
+    case "start-steer":
+      return { kind: "steering", subagent: action.subagent, draft: "" };
+    case "edit-draft":
+      return state.kind === "steering" ? { ...state, draft: action.draft } : state;
+    case "dismiss":
+      return INITIAL_SUBAGENT_STRIP_STATE;
+    case "submit":
+      if (state.kind === "confirming-stop") return { kind: "stopping", subagent: state.subagent };
+      if (state.kind === "steering" && isSendableDraft(state.draft)) {
+        return { kind: "sending", subagent: state.subagent, draft: state.draft };
+      }
+      return state;
+    default:
+      return state;
+  }
+}
+
+/** A failed send reopens its draft for another try; every other outcome closes the row. */
+function settle(state: PendingState, action: SubagentStripAction): SubagentStripState {
+  if (action.type === "settled") return INITIAL_SUBAGENT_STRIP_STATE;
+  if (action.type !== "failed") return state;
+  return state.kind === "sending"
+    ? { kind: "steering", subagent: state.subagent, draft: state.draft }
+    : INITIAL_SUBAGENT_STRIP_STATE;
+}
+
+export function stopOutcomeMessage(cancelled: boolean): string {
+  return cancelled ? "Subagent stopped" : "The subagent had already finished";
+}
+
+/** The host's RPC error keeps the handler's text in `userMessage`, without transport details. */
+export function subagentRequestError(cause: unknown): string {
+  if (cause instanceof Error) {
+    const userMessage: unknown = Reflect.get(cause, "userMessage");
+    return typeof userMessage === "string" && userMessage ? userMessage : cause.message;
+  }
+  return "The OMP subagent request failed";
+}
+
+/** Compact elapsed time, such as `42s`, `3m`, or `1h 5m`. */
+export function formatElapsed(milliseconds: number): string {
+  const seconds = Math.max(0, Math.floor(milliseconds / 1_000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  return minutes % 60 === 0 ? `${hours}h` : `${hours}h ${minutes % 60}m`;
+}

package/client/subagents-strip.tsx

@@ -0,0 +1,391 @@
+import {
+  type PluginHostProps,
+  type PluginTimelineItemProps,
+  useRpc,
+} from "@getpaseo/plugin/client";
+import { Icon, TextInput, useToast } from "@getpaseo/plugin/client/ui";
+import { useEffect, useMemo, useReducer, useState } from "react";
+import { Pressable, Text, View } from "react-native";
+import {
+  cancelOmpSubagent,
+  OMP_SUBAGENT_STEER_MAX_LENGTH,
+  type OmpSubagentStrip as OmpSubagentStripData,
+  steerOmpSubagent,
+} from "../shared/subagents";
+import {
+  activeSubagent,
+  formatElapsed,
+  INITIAL_SUBAGENT_STRIP_STATE,
+  isSendableDraft,
+  isSubagentRequestPending,
+  type OmpSubagentRow,
+  requestedSubmission,
+  type SubagentStripAction,
+  type SubagentStripState,
+  stopOutcomeMessage,
+  subagentRequestError,
+  subagentStripReducer,
+} from "./subagents-state";
+
+const ROW_HEIGHT = 28;
+
+function createStyles(theme: PluginHostProps["theme"], compact: boolean) {
+  return {
+    root: { gap: 2, paddingVertical: 2 },
+    row: {
+      flexDirection: "row" as const,
+      alignItems: "center" as const,
+      gap: 8,
+      height: ROW_HEIGHT,
+      paddingLeft: compact ? 2 : 4,
+    },
+    dot: { width: 6, height: 6, borderRadius: 3, backgroundColor: theme.colors.accent },
+    dotFinished: { backgroundColor: theme.colors.foregroundMuted },
+    agent: { color: theme.colors.foreground, fontSize: 13, flexShrink: 0 },
+    description: { color: theme.colors.foregroundMuted, fontSize: 13, flexShrink: 1, minWidth: 0 },
+    elapsed: {
+      color: theme.colors.foregroundMuted,
+      fontSize: 12,
+      fontVariant: ["tabular-nums" as const],
+    },
+    actions: { flexDirection: "row" as const, alignItems: "center" as const, gap: 2 },
+    iconButton: {
+      width: 24,
+      height: 24,
+      borderRadius: 6,
+      alignItems: "center" as const,
+      justifyContent: "center" as const,
+    },
+    textButton: {
+      height: 24,
+      paddingHorizontal: 8,
+      borderRadius: 6,
+      justifyContent: "center" as const,
+    },
+    hovered: { backgroundColor: theme.colors.surface2 },
+    disabled: { opacity: 0.5 },
+    stopLabel: { color: theme.colors.statusDanger, fontSize: 12 },
+    keepLabel: { color: theme.colors.foregroundMuted, fontSize: 12 },
+    tooltip: {
+      position: "absolute" as const,
+      bottom: 28,
+      right: 0,
+      paddingHorizontal: 6,
+      paddingVertical: 2,
+      borderRadius: 6,
+      backgroundColor: theme.colors.surface2,
+      borderWidth: 1,
+      borderColor: theme.colors.border,
+    },
+    tooltipText: { color: theme.colors.foreground, fontSize: 11 },
+    input: {
+      flexBasis: 360,
+      flexShrink: 1,
+      minWidth: 0,
+      height: 24,
+      paddingHorizontal: 8,
+      borderRadius: 6,
+      borderWidth: 1,
+      borderColor: theme.colors.border,
+      backgroundColor: theme.colors.surface1,
+      color: theme.colors.foreground,
+      fontSize: 13,
+    },
+  };
+}
+
+type Styles = ReturnType<typeof createStyles>;
+
+/** Re-renders once per second while `active`, for elapsed times. */
+function useSecondTick(active: boolean): number {
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    if (!active) return;
+    const timer = setInterval(() => setNow(Date.now()), 1_000);
+    return () => clearInterval(timer);
+  }, [active]);
+  return now;
+}
+
+/**
+ * Running OMP subagents of one `task` call, published by the provider below its tool card. Paseo
+ * shows provider subagents read-only, so the plugin adds steer and stop here.
+ */
+export function OmpSubagentStrip({
+  agentId,
+  item,
+  theme,
+  layout,
+}: PluginTimelineItemProps<OmpSubagentStripData>) {
+  const cancel = useRpc(cancelOmpSubagent);
+  const steer = useRpc(steerOmpSubagent);
+  const toast = useToast();
+  const styles = useMemo(() => createStyles(theme, layout.compact), [theme, layout.compact]);
+  const [state, dispatch] = useReducer(subagentStripReducer, INITIAL_SUBAGENT_STRIP_STATE);
+  const listed = item.data.subagents;
+  const active = activeSubagent(state);
+  const unlisted = active && !listed.some((row) => row.id === active.id) ? active : null;
+  const now = useSecondTick(listed.length > 0);
+
+  async function submit(): Promise<void> {
+    const request = requestedSubmission(state);
+    dispatch({ type: "submit" });
+    if (!request) return;
+    try {
+      if (request.kind === "stopping") {
+        const result = await cancel({ agentId, subagentId: request.subagent.id });
+        toast.show(stopOutcomeMessage(result.cancelled), {
+          variant: result.cancelled ? "success" : "default",
+        });
+      } else {
+        await steer({ agentId, subagentId: request.subagent.id, message: request.draft });
+        toast.show("Message sent to the subagent", { variant: "success" });
+      }
+      dispatch({ type: "settled" });
+    } catch (cause) {
+      toast.error(subagentRequestError(cause));
+      dispatch({ type: "failed" });
+    }
+  }
+
+  if (listed.length === 0 && !unlisted) return null;
+  return (
+    <View style={styles.root}>
+      {listed.map((row) => (
+        <SubagentRow
+          key={row.id}
+          row={row}
+          listed
+          now={now}
+          state={state}
+          styles={styles}
+          theme={theme}
+          dispatch={dispatch}
+          submit={submit}
+        />
+      ))}
+      {unlisted ? (
+        <SubagentRow
+          row={unlisted}
+          listed={false}
+          now={now}
+          state={state}
+          styles={styles}
+          theme={theme}
+          dispatch={dispatch}
+          submit={submit}
+        />
+      ) : null}
+    </View>
+  );
+}
+
+interface RowProps {
+  row: OmpSubagentRow;
+  /** False keeps the row that owns a draft visible after its subagent leaves the strip. */
+  listed: boolean;
+  now: number;
+  state: SubagentStripState;
+  styles: Styles;
+  theme: PluginHostProps["theme"];
+  dispatch: (action: SubagentStripAction) => void;
+  submit(): Promise<void>;
+}
+
+function SubagentRow(props: RowProps) {
+  const { row, listed, now, state, styles } = props;
+  const owner = activeSubagent(state)?.id === row.id ? state : null;
+  const steering = owner?.kind === "steering" || owner?.kind === "sending";
+  return (
+    <View style={styles.row}>
+      <View style={[styles.dot, listed ? null : styles.dotFinished]} />
+      <Text numberOfLines={1} style={styles.agent}>
+        {row.agent}
+      </Text>
+      {steering ? (
+        <SteerControls {...props} />
+      ) : (
+        <>
+          <Text numberOfLines={1} style={styles.description}>
+            {row.description ?? ""}
+          </Text>
+          {owner?.kind === "confirming-stop" || owner?.kind === "stopping" ? (
+            <StopConfirmation {...props} />
+          ) : (
+            <>
+              <Text style={styles.elapsed}>
+                {listed ? formatElapsed(now - row.runningSince) : "finished"}
+              </Text>
+              {listed ? <RowActions {...props} /> : null}
+            </>
+          )}
+        </>
+      )}
+    </View>
+  );
+}
+
+function RowActions({ row, state, styles, theme, dispatch }: RowProps) {
+  const pending = isSubagentRequestPending(state);
+  return (
+    <View style={styles.actions}>
+      <IconButton
+        icon="MessageSquare"
+        label="Steer: send this subagent a message at its next step"
+        disabled={pending}
+        styles={styles}
+        theme={theme}
+        onPress={() => dispatch({ type: "start-steer", subagent: row })}
+      />
+      <IconButton
+        icon="CircleStop"
+        label="Stop this subagent and its nested subagents; the parent keeps running"
+        disabled={pending}
+        styles={styles}
+        theme={theme}
+        onPress={() => dispatch({ type: "request-stop", subagent: row })}
+      />
+    </View>
+  );
+}
+
+function StopConfirmation({ state, styles, dispatch, submit }: RowProps) {
+  const stopping = state.kind === "stopping";
+  return (
+    <View style={styles.actions}>
+      <TextButton
+        label={stopping ? "Stopping..." : "Stop"}
+        accessibilityLabel="Confirm stopping this subagent"
+        labelStyle={styles.stopLabel}
+        disabled={stopping}
+        styles={styles}
+        onPress={() => void submit()}
+      />
+      <TextButton
+        label="Keep"
+        accessibilityLabel="Keep this subagent running"
+        labelStyle={styles.keepLabel}
+        disabled={stopping}
+        styles={styles}
+        onPress={() => dispatch({ type: "dismiss" })}
+      />
+    </View>
+  );
+}
+
+function SteerControls({ row, state, styles, theme, dispatch, submit }: RowProps) {
+  const sending = state.kind === "sending";
+  const draft = state.kind === "steering" || state.kind === "sending" ? state.draft : "";
+  return (
+    <>
+      <TextInput
+        accessibilityLabel={`Message for ${row.agent}`}
+        autoFocus
+        editable={!sending}
+        maxLength={OMP_SUBAGENT_STEER_MAX_LENGTH}
+        onChangeText={(text) => dispatch({ type: "edit-draft", draft: text })}
+        onKeyPress={(event) => {
+          if (event.nativeEvent.key === "Escape") dispatch({ type: "dismiss" });
+        }}
+        onSubmitEditing={() => void submit()}
+        placeholder="Message the subagent"
+        placeholderTextColor={theme.colors.foregroundMuted}
+        style={styles.input}
+        value={draft}
+      />
+      <View style={styles.actions}>
+        <IconButton
+          icon="SendHorizontal"
+          label="Send to the subagent (Enter)"
+          disabled={sending || !isSendableDraft(draft)}
+          styles={styles}
+          theme={theme}
+          onPress={() => void submit()}
+        />
+        <IconButton
+          icon="X"
+          label="Close (Esc)"
+          disabled={sending}
+          styles={styles}
+          theme={theme}
+          onPress={() => dispatch({ type: "dismiss" })}
+        />
+      </View>
+    </>
+  );
+}
+
+function IconButton({
+  icon,
+  label,
+  disabled,
+  styles,
+  theme,
+  onPress,
+}: {
+  icon: string;
+  label: string;
+  disabled: boolean;
+  styles: Styles;
+  theme: PluginHostProps["theme"];
+  onPress(): void;
+}) {
+  const [hovered, setHovered] = useState(false);
+  return (
+    <View>
+      <Pressable
+        accessibilityRole="button"
+        accessibilityLabel={label}
+        disabled={disabled}
+        onHoverIn={() => setHovered(true)}
+        onHoverOut={() => setHovered(false)}
+        onPress={onPress}
+        style={[
+          styles.iconButton,
+          hovered && !disabled ? styles.hovered : null,
+          disabled ? styles.disabled : null,
+        ]}
+      >
+        <Icon name={icon} size={14} color={theme.colors.foregroundMuted} />
+      </Pressable>
+      {hovered && !disabled ? (
+        <View pointerEvents="none" style={styles.tooltip}>
+          <Text numberOfLines={1} style={styles.tooltipText}>
+            {label}
+          </Text>
+        </View>
+      ) : null}
+    </View>
+  );
+}
+
+function TextButton({
+  label,
+  accessibilityLabel,
+  labelStyle,
+  disabled,
+  styles,
+  onPress,
+}: {
+  label: string;
+  accessibilityLabel: string;
+  labelStyle: Styles["stopLabel"];
+  disabled: boolean;
+  styles: Styles;
+  onPress(): void;
+}) {
+  const [hovered, setHovered] = useState(false);
+  return (
+    <Pressable
+      accessibilityRole="button"
+      accessibilityLabel={accessibilityLabel}
+      disabled={disabled}
+      onHoverIn={() => setHovered(true)}
+      onHoverOut={() => setHovered(false)}
+      onPress={onPress}
+      style={[styles.textButton, hovered && !disabled ? styles.hovered : null]}
+    >
+      <Text style={labelStyle}>{label}</Text>
+    </Pressable>
+  );
+}

package/index.client.tsx

@@ -38,6 +38,7 @@ import {
   HUB_SIDEBAR_ITEM_ID,
   loadHubSnapshot,
 } from "./client/sidebar-compat";
+import { OmpSubagentStrip } from "./client/subagents-strip";
 import {
   type ComposerPillSettings,
   composerPillSettings,
@@ -48,6 +49,7 @@ import { OMP_MCP_AUTH_TIMELINE_KIND, ompMcpAuthorizationTimelineSchema } from ".
 import { type OmpStore, storeForProvider } from "./shared/omp-store";
 import { ompImageTimelineSchema, transformOmpImageToolItem } from "./shared/provider-image";
 import { listOmpQuotas } from "./shared/quota";
+import { OMP_SUBAGENT_STRIP_KIND, ompSubagentStripSchema } from "./shared/subagents";
 
 const PAGE_LIMIT = 200;
 const MAX_PAGES = 10;
@@ -237,6 +239,12 @@ export default function contribute(client: PluginClientContext) {
     schema: ompMcpAuthorizationTimelineSchema,
     Component: OmpMcpAuthorizationCard,
   });
+  const removeSubagentStripRenderer = client.addTimelineRenderer({
+    kind: OMP_SUBAGENT_STRIP_KIND,
+    version: 1,
+    schema: ompSubagentStripSchema,
+    Component: OmpSubagentStrip,
+  });
   const removeImageTransformer = client.addTimelineTransformer({
     id: "omp-images",
     query: { itemType: "tool_call" },
@@ -544,6 +552,7 @@ export default function contribute(client: PluginClientContext) {
     pills.clear();
     removeImageRenderer();
     removeMcpAuthorizationRenderer();
+    removeSubagentStripRenderer();
     removeImageTransformer();
     removeOpenConfig();
     removeConfigEntry();

package/index.server.ts

@@ -29,6 +29,11 @@ import { OmpSessionLimit } from "./server/provider/session-limit";
 import { resolveGetOmpProviderHealth } from "./server/provider-diagnostics";
 import { resolveListOmpQuotas } from "./server/quota";
 import { resolveListOmpSessions } from "./server/sessions";
+import {
+  OmpSubagentControlRegistry,
+  resolveCancelOmpSubagent,
+  resolveSteerOmpSubagent,
+} from "./server/subagents";
 import { resolveGetOmpSupportReport } from "./server/support-diagnostics";
 import { composerPillSettings } from "./shared/composer-pill-settings";
 import { listHubProcesses, tailHubLog } from "./shared/hub";
@@ -48,6 +53,7 @@ import { getOmpProviderHealth } from "./shared/provider-diagnostics";
 import { providerLaunchSettings } from "./shared/provider-launch-settings";
 import { listOmpQuotas } from "./shared/quota";
 import { listOmpSessions } from "./shared/sessions";
+import { cancelOmpSubagent, steerOmpSubagent } from "./shared/subagents";
 import { getOmpSupportReport } from "./shared/support-diagnostics";
 
 function scoped<T extends { store?: OmpStore }, R>(handler: (input: T) => R) {
@@ -68,6 +74,7 @@ export default function contribute(server: PluginServerContext) {
     return current.status === "ready" ? current.values.maxSessions : undefined;
   });
   const removeSessionLimitListener = launchSettings.subscribe(() => sessionLimit.refresh());
+  const subagentControlRegistry = new OmpSubagentControlRegistry();
   const protocolViolations = new OmpProtocolViolationCollector();
   const operationalFailures = new OmpOperationalFailureCollector();
   const profiles = discoverOmpProfilesSync();
@@ -77,6 +84,7 @@ export default function contribute(server: PluginServerContext) {
       createProfileOmpProvider(profile, {
         browserAuthorizationRegistry,
         sessionLimit,
+        subagentControlRegistry,
         reportProtocolViolation: protocolViolations.report,
         reportOperationalFailure: operationalFailures.report,
         resolveHostInheritEnv,
@@ -104,6 +112,12 @@ export default function contribute(server: PluginServerContext) {
   server.handle(openOmpMcpAuthorizationInPaseoBrowser, (input) =>
     resolveOpenOmpMcpAuthorizationInPaseoBrowser(input, browserAuthorizationRegistry),
   );
+  server.handle(cancelOmpSubagent, (input) =>
+    resolveCancelOmpSubagent(input, subagentControlRegistry),
+  );
+  server.handle(steerOmpSubagent, (input) =>
+    resolveSteerOmpSubagent(input, subagentControlRegistry),
+  );
   const removeSessionOpenHook = server.before("agent.session_open", ({ request }) => {
     if (request.provider !== "omp-plugin" && !request.provider.startsWith("omp-plugin-")) return;
     return withOmpSessionOpenEnv(request);
@@ -112,6 +126,7 @@ export default function contribute(server: PluginServerContext) {
     createOmpProvider({
       browserAuthorizationRegistry,
       sessionLimit,
+      subagentControlRegistry,
       reportProtocolViolation: protocolViolations.report,
       reportOperationalFailure: operationalFailures.report,
       resolveHostInheritEnv,
@@ -120,6 +135,7 @@ export default function contribute(server: PluginServerContext) {
   return () => {
     browserAuthorizationRegistry.clear();
     removeSessionLimitListener();
+    subagentControlRegistry.clear();
     removeSessionOpenHook();
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-omp",
-  "version": "5.1.1-next.336.1",
+  "version": "5.1.1-next.340.1",
   "type": "module",
   "description": "Paseo integration for OMP, including its direct provider and workspace tooling.",
   "license": "MIT",
@@ -64,8 +64,8 @@
     "@getpaseo/client": "0.14.0",
     "@getpaseo/plugin": "0.14.0",
     "@getpaseo/server": "0.14.0",
-    "@oh-my-pi/pi-agent-core": "18.12.6",
-    "@oh-my-pi/pi-coding-agent": "18.12.6",
+    "@oh-my-pi/pi-agent-core": "18.14.0",
+    "@oh-my-pi/pi-coding-agent": "18.14.0",
     "@tanstack/react-query": "^5.102.3",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.18",

package/server/package-version.ts

@@ -1,2 +1,2 @@
 /** Release Please keeps this bundle-safe constant aligned with package.json. */
-export const PASEO_OMP_PACKAGE_VERSION = "5.1.1-next.336.1"; // x-release-please-version
+export const PASEO_OMP_PACKAGE_VERSION = "5.1.1-next.340.1"; // x-release-please-version