@omercnet/paseo-omp 5.1.1-next.339.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.339.1",
+  "version": "5.1.1-next.340.1",
   "type": "module",
   "description": "Paseo integration for OMP, including its direct provider and workspace tooling.",
   "license": "MIT",

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.339.1"; // x-release-please-version
+export const PASEO_OMP_PACKAGE_VERSION = "5.1.1-next.340.1"; // x-release-please-version

package/server/provider/connection.ts

@@ -13,6 +13,7 @@ import type {
   OmpOperationalFailure,
   OmpOperationalFailureReporter,
 } from "../operational-failure-diagnostics";
+import type { OmpSubagentControlRegistry } from "../subagents";
 import { discoverOmpCatalog } from "./catalog";
 import { normalizeOmpCatalogOptions } from "./config-normalization";
 import type { OmpMcpConnector } from "./host-tools";
@@ -724,6 +725,7 @@ export function createOmpConnection(
   reportOperationalFailure: OmpOperationalFailureReporter = () => {},
   resolveHostInheritEnv?: () => Promise<readonly string[]>,
   sessionLimit = new OmpSessionLimit(),
+  subagentControlRegistry?: OmpSubagentControlRegistry,
 ): ProviderConnection {
   const errorDetails = (error: unknown, fallback: string): { message: string } => {
     if (isOmpPublicError(error)) return { message: error.message };
@@ -758,6 +760,7 @@ export function createOmpConnection(
       session: OmpOpenedSession;
       nativeSessionId?: string;
       removeBrowserAuthorization?: () => void;
+      removeSubagentControls?: () => void;
     }
   >();
   const opening = new Map<
@@ -791,6 +794,7 @@ export function createOmpConnection(
     if (slot?.token !== token) return false;
     sessions.delete(sessionId);
     slot.removeBrowserAuthorization?.();
+    slot.removeSubagentControls?.();
     return true;
   };
 
@@ -1033,12 +1037,12 @@ export function createOmpConnection(
             nativeReservations.release(nativeSessionId, token);
             return;
           }
-          const browserAgentId = input.config.env.PASEO_AGENT_ID?.trim() || input.sessionId;
+          const agentId = input.config.env.PASEO_AGENT_ID?.trim() || input.sessionId;
           // A history session has no live Paseo browser tools to authorize.
           const browserAuthorization = historyOnly
             ? undefined
             : browserAuthorizationRegistry?.register(
-                browserAgentId,
+                agentId,
                 session.openPaseoBrowser.bind(session),
               );
           session.setBrowserAuthorizationIssuer(browserAuthorization?.issue ?? null);
@@ -1048,11 +1052,17 @@ export function createOmpConnection(
                 browserAuthorization.remove();
               }
             : undefined;
+          // A history session has no runtime, so it has no subagents to control.
+          const removeSubagentControls =
+            session instanceof OmpProviderSession
+              ? subagentControlRegistry?.register(agentId, session)
+              : undefined;
           sessions.set(input.sessionId, {
             token,
             session,
             nativeSessionId,
             ...(removeBrowserAuthorization ? { removeBrowserAuthorization } : {}),
+            ...(removeSubagentControls ? { removeSubagentControls } : {}),
           });
           await session.publishOpened(input.requestId);
           if (
@@ -1204,7 +1214,10 @@ export function createOmpConnection(
     shutdown.abort(shutdownReason);
     for (const { controller } of opening.values()) controller.abort(shutdownReason);
     for (const { session } of sessions.values()) session.beginConnectionShutdown();
-    for (const slot of sessions.values()) slot.removeBrowserAuthorization?.();
+    for (const slot of sessions.values()) {
+      slot.removeBrowserAuthorization?.();
+      slot.removeSubagentControls?.();
+    }
     const failures: unknown[] = [];
     const operationBatch = [...activeOperations];
     const operationResults = await Promise.allSettled(operationBatch);

package/server/provider/omp-rpc-protocol.ts

@@ -144,7 +144,7 @@ export const OMP_RPC_COMMAND_POLICIES = {
   abort_and_restore_queue: "unsupported",
   btw: "unsupported",
   btw_cancel: "unsupported",
-  cancel_subagent: "unsupported",
+  cancel_subagent: "implemented",
   fork: "unsupported",
   get_btw_history: "unsupported",
   get_logout_accounts: "unsupported",
@@ -166,7 +166,7 @@ export const OMP_RPC_COMMAND_POLICIES = {
   set_ask_dialog: "implemented",
   set_cache_warming: "unsupported",
   set_slow_mode: "unsupported",
-  steer_subagent: "unsupported",
+  steer_subagent: "implemented",
 } as const;
 export const OMP_RPC_RESPONSE_POLICIES = OMP_RPC_COMMAND_POLICIES;
 export const OMP_PROTOCOL_VIOLATION_CATEGORIES = [
@@ -2001,6 +2001,8 @@ export const OmpSubagentsResultSchema = z.object({
     )
     .max(1_024),
 });
+export const OmpCancelSubagentResultSchema = z.object({ cancelled: z.boolean() });
+export const OmpSteerSubagentResultSchema = z.object({}).strict().optional();
 export const OmpSubagentMessagesResultSchema = z.object({
   sessionFile: boundedString(MAX_PATH_LENGTH),
   fromByte: z.number().int().nonnegative(),

package/server/provider/omp-rpc.ts

@@ -16,6 +16,7 @@ import {
   OmpBranchMessagesResultSchema,
   type OmpBranchResult,
   OmpBranchResultSchema,
+  OmpCancelSubagentResultSchema,
   type OmpCompactionResult,
   OmpCompactionResultSchema,
   type OmpExtensionUiResponse,
@@ -41,6 +42,7 @@ import {
   OmpSessionStateSchema,
   type OmpSessionStats,
   OmpSessionStatsSchema,
+  OmpSteerSubagentResultSchema,
   type OmpSubagentMessagesResult,
   OmpSubagentMessagesResultSchema,
   type OmpSubagentSnapshot,
@@ -105,6 +107,9 @@ export interface OmpRuntimeSession {
     subagentId?: string;
     sessionFile?: string;
   }): Promise<OmpSubagentMessagesResult>;
+  /** Resolves `false` when OMP no longer lists the subagent as running for this session. */
+  cancelSubagent(subagentId: string): Promise<boolean>;
+  steerSubagent(subagentId: string, message: string): Promise<void>;
   prompt(
     message: string,
     images?: readonly OmpImage[],
@@ -466,6 +471,26 @@ class OmpRpcSession implements OmpRuntimeSession {
     );
   }
 
+  async cancelSubagent(subagentId: string): Promise<boolean> {
+    const safeId = validateBoundedText(subagentId, "subagent identifier", MAX_ID_LENGTH);
+    return OmpCancelSubagentResultSchema.parse(
+      await this.process.request({ type: "cancel_subagent", subagentId: safeId }),
+    ).cancelled;
+  }
+
+  async steerSubagent(subagentId: string, message: string): Promise<void> {
+    const safeId = validateBoundedText(subagentId, "subagent identifier", MAX_ID_LENGTH);
+    const safeMessage = validateBoundedText(message, "subagent steering message", MAX_TEXT_LENGTH);
+    if (!safeMessage.trim()) throw new Error("Invalid OMP subagent steering message");
+    OmpSteerSubagentResultSchema.parse(
+      await this.process.request({
+        type: "steer_subagent",
+        subagentId: safeId,
+        message: safeMessage,
+      }),
+    );
+  }
+
   async getBranchMessages(): Promise<Array<{ entryId: string; text: string }>> {
     const result = OmpBranchMessagesResultSchema.parse(
       await this.process.request({ type: "get_branch_messages" }),

package/server/provider/registration.ts

@@ -5,6 +5,7 @@ import { z } from "zod";
 import type { OmpBrowserAuthorizationRegistry } from "../mcp-browser";
 import type { OmpOperationalFailureReporter } from "../operational-failure-diagnostics";
 import { probeOmpAvailability } from "../provider-diagnostics";
+import type { OmpSubagentControlRegistry } from "../subagents";
 import { mergeOmpInheritedEnvironmentNames } from "./config-normalization";
 import { createOmpConnection, OmpNativeSessionReservations } from "./connection";
 import type { OmpMcpConnector } from "./host-tools";
@@ -131,6 +132,7 @@ export interface OmpProviderOptions {
     timeoutMs: number | undefined,
   ) => Promise<ProviderAvailabilityCompat>;
   resolveHostInheritEnv?: () => Promise<readonly string[]>;
+  subagentControlRegistry?: OmpSubagentControlRegistry;
 }
 
 function stableJson(value: unknown): string {
@@ -235,6 +237,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
         options.reportOperationalFailure,
         options.resolveHostInheritEnv,
         sessionLimit,
+        options.subagentControlRegistry,
       );
     },
   };

package/server/provider/session.ts

@@ -6,10 +6,12 @@ import type {
   ProviderInput,
   ProviderSessionConfig,
 } from "@getpaseo/plugin/server/provider";
+import { isLiveOmpSubagentStatus } from "../../shared/subagents";
 import type {
   OmpOperationalFailure,
   OmpOperationalFailureReporter,
 } from "../operational-failure-diagnostics";
+import { type OmpSubagentControls, OmpSubagentNotRunningError } from "../subagents";
 import {
   mapOmpModels,
   nativeOmpModelId,
@@ -84,7 +86,7 @@ import {
   unknownTerminalOutcomeError,
 } from "./session-terminal";
 import { OmpSessionUsage } from "./session-usage";
-import { OmpSubsessionProjector } from "./subsessions";
+import { OmpSubsessionProjector, ompSubagentHandle } from "./subsessions";
 import {
   defaultOmpTimelineScheduler,
   OmpTimelineProjector,
@@ -298,7 +300,7 @@ async function settleSessionCleanup(promises: readonly Promise<void>[]): Promise
     throw new AggregateError(failures, "OMP session initialization cleanup failed");
   }
 }
-export class OmpProviderSession implements OmpOpenedSession {
+export class OmpProviderSession implements OmpOpenedSession, OmpSubagentControls {
   readonly id: string;
   readonly cwd: string;
 
@@ -465,6 +467,36 @@ export class OmpProviderSession implements OmpOpenedSession {
     this.projector.setBrowserAuthorizationIssuer(issue);
   }
 
+  async cancelSubagent(handle: string): Promise<boolean> {
+    const target = await this.liveSubagent(handle);
+    return target ? await target.runtime.cancelSubagent(target.nativeId) : false;
+  }
+
+  async steerSubagent(handle: string, message: string): Promise<void> {
+    const target = await this.liveSubagent(handle);
+    if (!target) throw new OmpSubagentNotRunningError();
+    await target.runtime.steerSubagent(target.nativeId, message);
+  }
+
+  /**
+   * The native ID and runtime of a subagent this session's current runtime lists as running, or
+   * `null`. OMP repeats the check; this scopes the request to this session and answers exactly.
+   */
+  private async liveSubagent(
+    handle: string,
+  ): Promise<{ runtime: OmpRuntimeSession; nativeId: string } | null> {
+    if (this.closed || this.runtimeDead) return null;
+    const runtime = this.runtime;
+    const snapshots = await runtime.getSubagents();
+    if (runtime !== this.runtime || this.closed || this.runtimeDead) return null;
+    const live = snapshots.find(
+      (snapshot) =>
+        ompSubagentHandle(this.id, snapshot.id) === handle &&
+        isLiveOmpSubagentStatus(snapshot.status),
+    );
+    return live ? { runtime, nativeId: live.id } : null;
+  }
+
   private readonly imageMaterializer = new OmpImageMaterializer();
   static async open(
     input: SessionOpenInput,
@@ -2658,6 +2690,9 @@ export class OmpProviderSession implements OmpOpenedSession {
       });
       throw error;
     }
+    if (event.type === "tool_execution_start" && event.toolName === "task") {
+      this.subsessions?.anchorRootTask(event.toolCallId);
+    }
     if (event.type === "tool_execution_end") this.resumeDeferredAgentEnd();
   }
 

package/server/provider/subsessions.ts

@@ -2,6 +2,12 @@ import { createHash } from "node:crypto";
 import { basename, extname, isAbsolute } from "node:path";
 import type { ProviderEvent } from "@getpaseo/plugin/server/provider";
 import { z } from "zod";
+import {
+  MAX_OMP_SUBAGENT_STRIP_ENTRIES,
+  OMP_SUBAGENT_DESCRIPTION_MAX_LENGTH,
+  OMP_SUBAGENT_STRIP_KIND,
+  type OmpSubagentStrip,
+} from "../../shared/subagents";
 import type { OmpRuntime, OmpRuntimeSession } from "./omp-rpc";
 import type {
   OmpAgentSessionEvent,
@@ -56,6 +62,7 @@ type ChildState = {
   sessionClosed: boolean;
   replayUnavailable?: boolean;
   seenInSnapshot: boolean;
+  runningSince: number;
   seenAssistantIdentities: BoundedStringSet;
   projector: OmpTimelineProjector;
 };
@@ -305,6 +312,19 @@ function terminalStatus(status: string): ChildTerminalStatus | undefined {
   return;
 }
 
+/**
+ * OMP derives subagent IDs from model-chosen task names, so clients only see this opaque handle,
+ * scoped to the provider session that owns the subagent.
+ */
+export function ompSubagentHandle(sessionId: string, nativeId: string): string {
+  return createHash("sha256")
+    .update(sessionId)
+    .update("\0")
+    .update(nativeId)
+    .digest("base64url")
+    .slice(0, 32);
+}
+
 function bufferedNativeId(event: OmpSubagentEvent): string {
   return event.type === "subagent_progress" ? event.payload.progress.id : event.payload.id;
 }
@@ -314,6 +334,10 @@ export class OmpSubsessionProjector {
   private readonly sessionIdByNativeId = new Map<string, string>();
   private readonly toolOwners = new Map<string, string>();
   private readonly dispatches = new Map<string, TaskDispatch>();
+  /** Last published payload of each non-empty subagent control strip, by timeline item ID. */
+  private readonly controlStrips = new Map<string, string>();
+  /** Root `task` calls whose tool card the root timeline has published, oldest first. */
+  private readonly anchoredRootTasks = new Set<string>();
   private readonly bufferedEvents: BufferedSubagentEvent[] = [];
   // null means every child observed during this replay is omitted after tombstone saturation.
   private omittedBufferedChildren: Set<string> | null = new Set();
@@ -368,7 +392,7 @@ export class OmpSubsessionProjector {
     if (event.isError) {
       this.dispatches.delete(event.toolCallId);
       this.toolOwners.delete(event.toolCallId);
-      this.onActivityChange();
+      this.activityChanged();
       return;
     }
     dispatch.acknowledged = true;
@@ -462,6 +486,82 @@ export class OmpSubsessionProjector {
     this.reconcileSnapshots(await runtime.getSubagents());
   }
 
+  private activityChanged(): void {
+    this.publishControlStrips();
+    this.onActivityChange();
+  }
+
+  /**
+   * Marks a root `task` call whose tool card is now in the root timeline. Its control strip is
+   * published only after this, so the strip lands below the card even when subagent frames
+   * arrive while the turn's own events are still buffered.
+   */
+  anchorRootTask(toolCallId: string): void {
+    if (this.anchoredRootTasks.size >= MAX_TASK_DISPATCHES) {
+      const oldest = this.anchoredRootTasks.values().next().value;
+      if (oldest !== undefined) this.anchoredRootTasks.delete(oldest);
+    }
+    this.anchoredRootTasks.add(toolCallId);
+    this.publishControlStrips();
+  }
+
+  /**
+   * Publishes one plugin timeline row per root `task` call, below its tool card, listing the
+   * call's running subagents so the client can steer or cancel them in place. A row is emptied
+   * rather than removed when its subagents finish.
+   */
+  private publishControlStrips(): void {
+    if (!this.pluginTimelineEnabled || this.closed) return;
+    const strips = new Map<string, OmpSubagentStrip["subagents"]>();
+    for (const child of this.children.values()) {
+      if (child.status !== "running") continue;
+      const taskCallId = this.rootTaskCallId(child);
+      if (!taskCallId || !this.anchoredRootTasks.has(taskCallId)) continue;
+      const id = `omp:subagents:${taskCallId}`;
+      const entries = strips.get(id) ?? [];
+      if (entries.length >= MAX_OMP_SUBAGENT_STRIP_ENTRIES) continue;
+      entries.push({
+        id: ompSubagentHandle(this.rootSessionId, child.nativeId),
+        agent: child.title,
+        description: child.description
+          ? this.dataFilter.text(child.description, OMP_SUBAGENT_DESCRIPTION_MAX_LENGTH)
+          : null,
+        runningSince: child.runningSince,
+      });
+      strips.set(id, entries);
+    }
+    for (const id of new Set([...this.controlStrips.keys(), ...strips.keys()])) {
+      const data: OmpSubagentStrip = { subagents: strips.get(id) ?? [] };
+      const payload = JSON.stringify(data);
+      if (this.controlStrips.get(id) === payload) continue;
+      if (data.subagents.length > 0) this.controlStrips.set(id, payload);
+      else this.controlStrips.delete(id);
+      this.emit({
+        type: "timeline.item",
+        sessionId: this.rootSessionId,
+        item: {
+          type: "plugin",
+          id,
+          pluginId: "paseo-omp",
+          kind: OMP_SUBAGENT_STRIP_KIND,
+          version: 1,
+          data,
+        },
+      });
+    }
+  }
+
+  /** The root timeline's `task` call that a subagent descends from, when it is known. */
+  private rootTaskCallId(child: ChildState): string | undefined {
+    let current = child;
+    for (let depth = 0; current.parentSessionId !== this.rootSessionId; depth += 1) {
+      const parent = this.children.get(current.parentSessionId);
+      if (!parent || depth >= MAX_CHILDREN) return;
+      current = parent;
+    }
+    return current.parentToolCallId;
+  }
+
   hasActiveChildren(): boolean {
     for (const child of this.children.values()) if (child.status === "running") return true;
     for (const dispatch of this.dispatches.values()) if (dispatch.acknowledged) return true;
@@ -474,7 +574,7 @@ export class OmpSubsessionProjector {
     }
     this.dispatches.clear();
     this.toolOwners.clear();
-    this.onActivityChange();
+    this.activityChanged();
   }
 
   close(): void {
@@ -626,7 +726,7 @@ export class OmpSubsessionProjector {
       const terminal = terminalStatus(event.payload.status);
       if (terminal) this.requestTerminal(child, terminal);
       else if (event.payload.status === "started") this.restartChild(child);
-      this.onActivityChange();
+      this.activityChanged();
       return;
     }
     if (event.type === "subagent_progress") {
@@ -643,7 +743,7 @@ export class OmpSubsessionProjector {
       const terminal = terminalStatus(event.payload.progress.status);
       if (terminal) this.requestTerminal(child, terminal);
       else this.restartChild(child);
-      this.onActivityChange();
+      this.activityChanged();
       return;
     }
     const sessionId = this.sessionIdByNativeId.get(event.payload.id);
@@ -701,6 +801,7 @@ export class OmpSubsessionProjector {
       ...(ref.sessionFile ? { sessionFile: ref.sessionFile } : {}),
       ...(ref.parentToolCallId ? { parentToolCallId: ref.parentToolCallId } : {}),
       status: "running",
+      runningSince: Date.now(),
       sessionClosed: false,
       seenAssistantIdentities: new BoundedStringSet(MAX_CHILD_MESSAGE_IDENTITIES),
       seenInSnapshot: false,
@@ -739,6 +840,7 @@ export class OmpSubsessionProjector {
     child.replayUnavailable = false;
     if (child.status === "running") return;
     child.status = "running";
+    child.runningSince = Date.now();
     child.terminalRequested = undefined;
     child.seenInSnapshot = false;
     child.turnSequence += 1;
@@ -784,7 +886,7 @@ export class OmpSubsessionProjector {
     if (parent?.terminalRequested && !this.hasDirectActivity(parent.sessionId)) {
       this.finishChild(parent, parent.terminalRequested);
     }
-    this.onActivityChange();
+    this.activityChanged();
   }
   private failReplayChild(child: ChildState): void {
     child.replayUnavailable = true;
@@ -812,7 +914,7 @@ export class OmpSubsessionProjector {
     if (owner?.terminalRequested && !this.hasDirectActivity(owner.sessionId)) {
       this.finishChild(owner, owner.terminalRequested);
     }
-    this.onActivityChange();
+    this.activityChanged();
   }
 
   private resolveParent(parentToolCallId?: string, sessionFile?: string): string {
@@ -864,7 +966,7 @@ export class OmpSubsessionProjector {
         this.requestTerminal(child, "completed");
       }
     }
-    this.onActivityChange();
+    this.activityChanged();
   }
 
   private async replaySnapshots(

package/server/subagents.ts

@@ -0,0 +1,97 @@
+import type { RpcInput, RpcOutput } from "@getpaseo/plugin";
+import type { cancelOmpSubagent, steerOmpSubagent } from "../shared/subagents";
+import { OmpRpcRequestRejectedError } from "./provider/omp-rpc-transport";
+import { isOmpPublicError, OmpPublicError } from "./provider/security";
+
+/** Subagent controls of one live OMP session; history-only sessions never register. */
+export interface OmpSubagentControls {
+  /** Resolves `false` when the subagent is no longer running. */
+  cancelSubagent(handle: string): Promise<boolean>;
+  steerSubagent(handle: string, message: string): Promise<void>;
+}
+
+export class OmpSubagentNotRunningError extends OmpPublicError {
+  constructor() {
+    super("This subagent is no longer running");
+  }
+}
+
+type SubagentOperation = "cancel" | "steer";
+
+const OPERATION_FAILURES: Record<SubagentOperation, string> = {
+  cancel: "OMP could not cancel the subagent",
+  steer: "OMP did not accept the message. The subagent may have finished or refused it",
+};
+
+// A timed-out request is not withdrawn from OMP, so its outcome is unknown rather than failed.
+const OPERATION_TIMEOUTS: Record<SubagentOperation, string> = {
+  cancel: "OMP did not confirm the cancellation in time. Check the subagent before retrying",
+  steer: "OMP did not confirm delivery in time. The subagent may still receive the message",
+};
+
+/**
+ * Routes subagent controls to the OMP session that owns a Paseo agent. Keys are the agent ID the
+ * plugin's own `agent.session_open` hook injects, so a request can only reach that agent's
+ * runtime, and OMP then resolves the subagent only within that runtime's roster.
+ */
+export class OmpSubagentControlRegistry {
+  private readonly agents = new Map<string, { controls: OmpSubagentControls }>();
+
+  /** A newer session for the same agent replaces the older one; its removal is then a no-op. */
+  register(agentId: string, controls: OmpSubagentControls): () => void {
+    const entry = { controls };
+    this.agents.set(agentId, entry);
+    return () => {
+      if (this.agents.get(agentId) === entry) this.agents.delete(agentId);
+    };
+  }
+
+  get(agentId: string): OmpSubagentControls | undefined {
+    return this.agents.get(agentId)?.controls;
+  }
+
+  clear(): void {
+    this.agents.clear();
+  }
+}
+
+async function withPublicFailure<T>(operation: SubagentOperation, run: () => Promise<T>) {
+  try {
+    return await run();
+  } catch (error) {
+    if (isOmpPublicError(error)) throw error;
+    if (error instanceof OmpRpcRequestRejectedError && error.code === "unsupported_command") {
+      throw new OmpPublicError("Update OMP to 18.4.9 or newer to control subagents from Paseo");
+    }
+    if (error instanceof Error && error.message === "OMP RPC request timed out") {
+      throw new OmpPublicError(OPERATION_TIMEOUTS[operation]);
+    }
+    // Native OMP error text is never forwarded; it can echo arbitrary subagent output.
+    throw new OmpPublicError(OPERATION_FAILURES[operation]);
+  }
+}
+
+function controlsFor(registry: OmpSubagentControlRegistry, agentId: string): OmpSubagentControls {
+  const controls = registry.get(agentId);
+  if (!controls) throw new OmpPublicError("This agent has no running OMP Plugin session");
+  return controls;
+}
+
+export async function resolveCancelOmpSubagent(
+  input: RpcInput<typeof cancelOmpSubagent>,
+  registry: OmpSubagentControlRegistry,
+): Promise<RpcOutput<typeof cancelOmpSubagent>> {
+  const controls = controlsFor(registry, input.agentId);
+  return {
+    cancelled: await withPublicFailure("cancel", () => controls.cancelSubagent(input.subagentId)),
+  };
+}
+
+export async function resolveSteerOmpSubagent(
+  input: RpcInput<typeof steerOmpSubagent>,
+  registry: OmpSubagentControlRegistry,
+): Promise<RpcOutput<typeof steerOmpSubagent>> {
+  const controls = controlsFor(registry, input.agentId);
+  await withPublicFailure("steer", () => controls.steerSubagent(input.subagentId, input.message));
+  return { accepted: true };
+}

package/shared/subagents.ts

@@ -0,0 +1,60 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const OMP_SUBAGENT_STEER_MAX_LENGTH = 16_384;
+export const OMP_SUBAGENT_DESCRIPTION_MAX_LENGTH = 512;
+
+const AgentIdSchema = z.string().min(1).max(256);
+const SubagentIdSchema = z.string().min(1).max(256);
+
+export const OmpSubagentStatusSchema = z.enum([
+  "pending",
+  "running",
+  "started",
+  "completed",
+  "failed",
+  "aborted",
+]);
+export type OmpSubagentStatus = z.infer<typeof OmpSubagentStatusSchema>;
+
+export const cancelOmpSubagent = defineRpc({
+  name: "paseo-omp.cancel-subagent",
+  input: z.object({ agentId: AgentIdSchema, subagentId: SubagentIdSchema }),
+  /** `false` when the subagent had already finished; cancelling is idempotent. */
+  output: z.object({ cancelled: z.boolean() }),
+});
+
+export const steerOmpSubagent = defineRpc({
+  name: "paseo-omp.steer-subagent",
+  input: z.object({
+    agentId: AgentIdSchema,
+    subagentId: SubagentIdSchema,
+    message: z.string().trim().min(1).max(OMP_SUBAGENT_STEER_MAX_LENGTH),
+  }),
+  output: z.object({ accepted: z.literal(true) }),
+});
+
+export const OMP_SUBAGENT_STRIP_KIND = "omp-subagents";
+export const MAX_OMP_SUBAGENT_STRIP_ENTRIES = 64;
+
+/** The running subagents of one `task` call, rendered below its tool card. */
+export const ompSubagentStripSchema = z.object({
+  subagents: z
+    .array(
+      z.object({
+        /** Opaque handle scoped to the agent's current OMP session, never the native OMP ID. */
+        id: SubagentIdSchema,
+        agent: z.string().min(1).max(256),
+        description: z.string().max(OMP_SUBAGENT_DESCRIPTION_MAX_LENGTH).nullable(),
+        /** Epoch milliseconds when the plugin last saw the subagent start running. */
+        runningSince: z.number().int().nonnegative(),
+      }),
+    )
+    .max(MAX_OMP_SUBAGENT_STRIP_ENTRIES),
+});
+export type OmpSubagentStrip = z.infer<typeof ompSubagentStripSchema>;
+
+/** OMP reaches a subagent only while its roster lists it as running or pending. */
+export function isLiveOmpSubagentStatus(status: OmpSubagentStatus): boolean {
+  return status === "pending" || status === "running";
+}