@opengeni/runtime 4.0.0 → 4.0.1-canary.35916963870001

package/src/interaction-tools.ts

@@ -183,6 +183,7 @@ const BrowserObserveInput = z
   .object({
     browserSessionId: z.string().uuid(),
     targetId: z.string().min(1).max(512),
+    includeScreenshot: z.boolean().optional(),
   })
   .strict();
 const BrowserActInput = z
@@ -381,7 +382,7 @@ const ComputerActInput = z
     computerSessionId: z.string().uuid(),
     targetId: z.string().min(1).max(512),
     expectedTargetGeneration: z.string().min(1).max(256).optional(),
-    expectedObservationId: z.string().uuid().nullable().optional(),
+    expectedObservationId: ComputerObservation.shape.observationId.nullable().optional(),
     expectedFrameId: z.string().min(1).max(256).nullable().optional(),
     action: ComputerAction,
   })
@@ -510,7 +511,7 @@ export function createInteractionAttemptToolDefinitions(
     codemodePath: ["interaction", "browser", "open"],
     title: "Open or reuse browser",
     description:
-      "Open a managed BrowserSession on the current agent placement, reuse a relevant compatible live session by default, attach to an explicit workspace BrowserSession, or open an attached Chrome profile by passing placement={kind:'attached_device',deviceId}. This does not infer or attach the user's existing Chrome: for requests about 'my browser', 'my tabs', or current Chrome, call interaction_discover first and select an actual attachedBrowsers device; if none exists, explain that the Chrome extension must be connected instead of silently creating a blank managed browser. Managed Chromium defaults to headed so OAuth and later human interaction use a supported browser; request headless=true only for agent-only work that will not require sign-in or human control. Returns exact session and tab state.",
+      "Open a managed BrowserSession on the current agent placement, reuse a relevant compatible live session by default, attach to an explicit workspace BrowserSession, or open an attached Chrome profile by passing placement={kind:'attached_device',deviceId}. This does not infer or attach the user's existing Chrome: for requests about 'my browser', 'my tabs', or current Chrome, call interaction_discover first and select an actual attachedBrowsers device; if none exists, explain that the Chrome extension must be connected instead of silently creating a blank managed browser. BrowserSessions persist across tool calls; shell-launched browser daemons do not survive remote-command cleanup. Never switch to the user's attached Chrome as a fallback for a failed managed browser unless the user requested that profile. A new attached session opens a dedicated tab. Managed Chromium defaults to headed so OAuth and later human interaction use a supported browser; request headless=true only for agent-only work that will not require sign-in or human control. Returns exact session and tab state.",
     input: BrowserOpenInput,
     output: BrowserOpenOutput,
     readOnly: false,
@@ -524,7 +525,7 @@ export function createInteractionAttemptToolDefinitions(
     codemodePath: ["interaction", "browser", "tabs"],
     title: "Manage browser tabs",
     description:
-      "List, open, select, or close tabs in one exact BrowserSession. Returns the authoritative complete tab list after the operation.",
+      "List, open, logically select, or close tabs in one exact BrowserSession. Selection changes the BrowserSession's default target, not the visible desktop tab. New attached-Chrome tabs open in the background. Use browser_act activate only when foregrounding the owned tab is explicitly intended. Returns the authoritative complete tab list after the operation.",
     input: BrowserTabsInput,
     output: BrowserTargetListResponse,
     readOnly: false,
@@ -556,17 +557,47 @@ export function createInteractionAttemptToolDefinitions(
     codemodePath: ["interaction", "browser", "observe"],
     title: "Observe browser tab",
     description:
-      "Read one tab's current URL/title, causal generations, compact semantic accessibility tree, dialog, and diagnostic counts without taking control.",
+      "Read one tab's current URL/title, measured page viewport, causal generations, compact semantic accessibility tree, dialog, and diagnostic counts without taking control. Set includeScreenshot=true to receive a current still image as tool image content; the structured screenshot field is only a retained-artifact reference and can remain null.",
     input: BrowserObserveInput,
     output: BrowserObservation,
     readOnly: true,
     idempotent: true,
-    execute: async (value) =>
-      await input.transport.observeBrowserTarget(
+    execute: async (value) => {
+      let observation = await input.transport.observeBrowserTarget(
         input.workspaceId,
         value.browserSessionId,
         value.targetId,
-      ),
+      );
+      if (!value.includeScreenshot) return observation;
+      const frame = await input.transport.captureBrowserTarget(
+        input.workspaceId,
+        value.browserSessionId,
+        value.targetId,
+      );
+      if (
+        observation.target.targetGeneration !== frame.targetGeneration ||
+        observation.target.documentGeneration !== frame.documentGeneration
+      ) {
+        observation = await input.transport.observeBrowserTarget(
+          input.workspaceId,
+          value.browserSessionId,
+          value.targetId,
+        );
+      }
+      if (
+        observation.target.targetGeneration !== frame.targetGeneration ||
+        observation.target.documentGeneration !== frame.documentGeneration
+      ) {
+        throw new Error("browser target changed while its visual observation was captured");
+      }
+      return new InteractionExecutionResult(observation, [
+        {
+          type: "image",
+          data: Buffer.from(frame.data).toString("base64"),
+          mimeType: frame.mediaType,
+        },
+      ]);
+    },
   });
 
   add({
@@ -574,7 +605,7 @@ export function createInteractionAttemptToolDefinitions(
     codemodePath: ["interaction", "browser", "act"],
     title: "Act in browser tab",
     description:
-      "Perform one semantic-first browser action or bounded batch, including setting a managed browser's web permission for this tab's exact current top-level origin. Omit generation fences to use a fresh observation automatically; provide them to require exact previously observed state. Returns the durable receipt and changed observation.",
+      "Perform one semantic-first browser action or bounded batch. Use viewport to set page width, height, desktop/mobile layout and touch emulation, then check the measured viewport in the returned observation; emulation does not prove physical mobile-browser behavior. Use history back/forward for tab navigation; keypress shortcuts are page input and may not navigate browser history. The explicit activate action foregrounds the target in the user's desktop browser; use only when that is intended. Permission actions set a managed browser's web permission for this tab's exact current top-level origin. Omit generation fences to use a fresh observation automatically; provide them to require exact previously observed state. Returns the durable receipt and changed observation.",
     input: BrowserActInput,
     output: BrowserActionReceipt,
     readOnly: false,
@@ -986,7 +1017,7 @@ export function createInteractionAttemptToolDefinitions(
     codemodePath: ["interaction", "computer", "act"],
     title: "Act in app or window",
     description:
-      "Perform one action in an exact ComputerSession target. Prefer semantic actions from computer_observe: on macOS they can invoke controls and set values without foregrounding the app. Pointer, keyboard, target focus, screen actions, and clipboard paste use the physical graphical seat and may change the user's foreground app; use them only when foreground control is explicitly intended. Omit fences to use a fresh observation automatically. Returns the durable causal receipt.",
+      "Perform one action in an exact ComputerSession target. Prefer semantic actions from computer_observe: on macOS they can invoke controls and set values without foregrounding the app. Pointer, keyboard, target focus, screen actions, and clipboard paste use the physical graphical seat and may change the user's foreground app; use them only when foreground control is explicitly intended. For pointer actions, set action.frameId from the observed frame and use coordinates in the returned screenshot's pixels; do not scale them to target.bounds. Omit fences to use a fresh observation automatically. Returns the durable causal receipt.",
     input: ComputerActInput,
     output: ComputerActionReceipt,
     readOnly: false,
@@ -1131,7 +1162,8 @@ async function openBrowser(
   if (value.browserSessionId) {
     session = await transport.getBrowserSession(workspaceId, value.browserSessionId);
   } else {
-    const listed = await transport.listBrowserSessions(workspaceId);
+    const listed =
+      value.mode === "new" ? { sessions: [] } : await transport.listBrowserSessions(workspaceId);
     // The agent-facing browser is human-capable by default. A headless session
     // is a deliberately narrower execution mode and must never be silently
     // reused for an omitted/default headed request: OAuth providers such as
@@ -1141,7 +1173,18 @@ async function openBrowser(
       value.mode === "new"
         ? null
         : newestRelevant(
-            listed.sessions.filter((candidate) => candidate.headless === requestedHeadless),
+            listed.sessions.filter(
+              (candidate) =>
+                candidate.headless === requestedHeadless &&
+                compatibleInteractionPlacement(candidate.placement, value.placement) &&
+                (value.identityId === undefined || candidate.identityId === value.identityId) &&
+                (value.baseRevisionId === undefined ||
+                  candidate.baseRevisionId === value.baseRevisionId) &&
+                (value.networkRouteId === undefined ||
+                  candidate.networkRouteId === value.networkRouteId) &&
+                (value.linkedComputerSessionId === undefined ||
+                  candidate.linkedComputerSessionId === value.linkedComputerSessionId),
+            ),
             sourceSessionId,
           );
     if (reusable) {
@@ -1205,8 +1248,14 @@ async function openComputer(
   if (value.computerSessionId) {
     session = await transport.getComputerSession(workspaceId, value.computerSessionId);
   } else {
-    const listed = await transport.listComputerSessions(workspaceId);
-    const reusable = value.mode === "new" ? null : newestRelevant(listed.sessions, sourceSessionId);
+    const listed =
+      value.mode === "new" ? { sessions: [] } : await transport.listComputerSessions(workspaceId);
+    const reusable = newestRelevant(
+      listed.sessions.filter((candidate) =>
+        compatibleInteractionPlacement(candidate.placement, value.placement),
+      ),
+      sourceSessionId,
+    );
     session = reusable
       ? reusable
       : (
@@ -1227,6 +1276,16 @@ async function openComputer(
   };
 }
 
+function compatibleInteractionPlacement(
+  candidate: z.infer<typeof InteractionPlacement>,
+  requested: z.infer<typeof InteractionPlacement> | undefined,
+): boolean {
+  if (!requested) return candidate.kind !== "attached_device";
+  return Object.entries(requested).every(
+    ([key, value]) => (candidate as Record<string, unknown>)[key] === value,
+  );
+}
+
 function newestRelevant<
   T extends {
     lifecycle: string;

package/src/operational-instructions.ts

@@ -83,6 +83,8 @@ Display images with ![descriptive alt text](artifact:<artifactId>). Use the exac
 
 Publish files you deliberately deliver so they are retained and discoverable in Artifacts; do not publish every temporary file. Reuse retained references for unchanged outputs. Source-code navigation may still use workspace file links. Inline HTML stays in chat unless explicitly saved as a Site.
 
+For published files, [Open file](artifact:<artifactId>) opens the retained file in Artifacts. ![Preview](artifact:<artifactId>) displays images, video, audio, or PDFs inline in the OpenGeni console, with an Artifact link for other formats. Replace <artifactId> with the exact artifact.artifactId from the publication receipt and use a descriptive label. Sites and native documents keep their tool-returned canonical links. Never substitute a storage URL or a sandbox path for a published artifact reference.
+
 # Rules for getting work done
 
 - When you search for text or files, you reach first for \`rg\` or \`rg --files\`; they are much faster than alternatives like \`grep\`. If \`rg\` is unavailable, you use the next best tool without fuss.
@@ -120,6 +122,8 @@ When presented with clarifying questions or objections from the user, lead with
 
 If completion requires new authority, external coordination, or a meaningful expansion beyond the user’s implied intent and task scope (e.g. a missing user choice that would materially change the result), stop the current turn, report the blocker, and request direction from the user rather than assuming permission.
 
+Decide the design before building it. First check whether OpenGeni already provides the capability natively (for example, a Site reaches the model and workspace tools through the host bridge and needs no server of its own). If a native path fits, use it. Follow the project's established architecture and choices the user has already authorized or delegated; the user need not name each host, provider, or credential. Ask before making a new external commitment or materially departing from the established architecture beyond the authorized scope: name the candidate designs, and do not start parallel work that assumes the unresolved choice. The absence of a native path alone does not require a question; continue with routine implementation choices within scope.
+
 # Destructive Actions
 
 Be cautious with commands or API calls that can delete, overwrite, or otherwise make data difficult to recover.
@@ -152,7 +156,7 @@ Skills are reusable instructions supplied dynamically for the current session. W
 
 # Integration setup
 
-Use available integration tools directly. If the task needs an integration you cannot access, discover it with \`capability_catalog_search\` before declaring a setup blocker. For a suitable match with \`setup.nextAction\`, call \`capability_authorization_request\` with the returned capability ID and a brief task-specific rationale to show its Connect card in chat. Requesting the card does not need integration-management permission; the authenticated human must authorize setup. After setup, rediscover the tools and continue the task, verifying the access it needs. If access remains blocked, explain the specific blocker from the returned facts. If either setup tool is unavailable, report the missing setup path.
+Use available integration tools directly. If the task needs an integration you cannot access, discover it with \`capability_catalog_search\` before declaring a setup blocker. For a suitable match with \`setup.nextAction\`, call \`capability_authorization_request\` with the returned capability ID and a brief task-specific rationale to show its Connect card in chat. Requesting the card does not need integration-management permission; the authenticated human must authorize setup. A card is for an integration required by the authorized design, including established or delegated choices. Resolve out-of-scope architecture choices before requesting setup. After setup, rediscover the tools and continue the task, verifying the access it needs. If access remains blocked, explain the specific blocker from the returned facts. If either setup tool is unavailable, report the missing setup path.
 
 # Session coordination
 

package/src/sandbox/browser-control-client.ts

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { posix as posixPath } from "node:path";
+import { parseBrowserFrameMetadata, type BrowserFrameMetadata } from "@opengeni/sdk";
 import {
   BROWSER_CONTROL_MAX_JSON_BYTES,
   BROWSER_CONTROL_PORT,
@@ -165,6 +166,29 @@ export type ComputerControlFrame = {
   metadata: ComputerControlFrameMetadata;
 };
 
+export type BrowserControlFrame = {
+  data: Uint8Array;
+  mediaType: "image/jpeg" | "image/png";
+  metadataHeader: string;
+  metadata: BrowserFrameMetadata;
+};
+
+type ExpectedBrowserFrameEvidence = {
+  browserSessionId: string;
+  controllerGeneration: string;
+  targetId: string;
+};
+
+type FrameRequest = {
+  method: "GET";
+  path: string;
+  token: string;
+  timeoutMs?: number;
+} & (
+  | { surface: "browser"; expectedFrameEvidence: ExpectedBrowserFrameEvidence }
+  | { surface: "computer"; expectedFrameEvidence: ExpectedComputerFrameEvidence }
+);
+
 export type ComputerControlFrameMetadata = {
   frameId: string;
   computerSessionId: string;
@@ -947,7 +971,17 @@ export class BrowserControlClient {
     expectedFrameEvidence: ExpectedComputerFrameEvidence;
     timeoutMs?: number;
   }): Promise<ComputerControlFrame> {
-    return await this.requestBytes(input);
+    return (await this.requestBytes({ ...input, surface: "computer" })) as ComputerControlFrame;
+  }
+
+  async requestBrowserBytesForSession(input: {
+    method: "GET";
+    path: string;
+    token: string;
+    expectedFrameEvidence: ExpectedBrowserFrameEvidence;
+    timeoutMs?: number;
+  }): Promise<BrowserControlFrame> {
+    return (await this.requestBytes({ ...input, surface: "browser" })) as BrowserControlFrame;
   }
 
   private async requestJson(
@@ -1124,15 +1158,9 @@ export class BrowserControlClient {
   }
 
   private async requestBytes(
-    input: {
-      method: "GET";
-      path: string;
-      token: string;
-      expectedFrameEvidence: ExpectedComputerFrameEvidence;
-      timeoutMs?: number;
-    },
+    input: FrameRequest,
     retryNativeEndpoint = true,
-  ): Promise<ComputerControlFrame> {
+  ): Promise<ComputerControlFrame | BrowserControlFrame> {
     const requireHostFetch = this.session.requireHostFetchController === true;
     if (this.session.resolveExposedPort && !this.session.ensureBrowserControl) {
       try {
@@ -1247,10 +1275,10 @@ export class BrowserControlClient {
       const data = await readBytes(
         this.session,
         responsePath,
-        COMPUTER_SCREENSHOT_MAX_BYTES,
+        input.surface === "browser" ? 24 * 1024 * 1024 : COMPUTER_SCREENSHOT_MAX_BYTES,
         timeoutMs,
       );
-      return computerControlFrame(data, headers, input.expectedFrameEvidence);
+      return controllerImageFrame(data, headers, input);
     } catch (error) {
       if (
         error instanceof BrowserControlRequestError ||
@@ -1432,6 +1460,19 @@ export class BrowserControlSessionClient {
     );
   }
 
+  async capture(targetId: string): Promise<BrowserControlFrame> {
+    return await this.parent.requestBrowserBytesForSession({
+      method: "GET",
+      path: this.targetPath(targetId, "screenshot?format=jpeg&quality=55"),
+      token: this.viewToken,
+      expectedFrameEvidence: {
+        browserSessionId: this.reference.browserSessionId,
+        controllerGeneration: this.reference.controllerGeneration,
+        targetId: requireOpaqueId(targetId, "browser target id"),
+      },
+    });
+  }
+
   async readClipboard(): Promise<BrowserClipboardValue> {
     return BrowserClipboard.parse(
       await this.parent.requestForSession({
@@ -1840,15 +1881,9 @@ async function requestExposedController(
 
 async function requestExposedControllerBytes(
   endpoint: ExposedPortEndpoint,
-  input: {
-    method: "GET";
-    path: string;
-    token: string;
-    expectedFrameEvidence: ExpectedComputerFrameEvidence;
-    timeoutMs?: number;
-  },
+  input: FrameRequest,
   defaultTimeoutMs: number,
-): Promise<ComputerControlFrame> {
+): Promise<ComputerControlFrame | BrowserControlFrame> {
   const token = requireToken(input.token, "browser controller token");
   const timeoutMs = boundedTimeout(input.timeoutMs ?? defaultTimeoutMs);
   const streamUrl = exposedControllerUrl(endpoint, input.path);
@@ -1872,12 +1907,63 @@ async function requestExposedControllerBytes(
     throw new BrowserControlProtocolError("browser controller image response is invalid");
   }
   const declaredLength = Number(response.headers.get("content-length"));
-  if (Number.isFinite(declaredLength) && declaredLength > COMPUTER_SCREENSHOT_MAX_BYTES) {
-    await response.body?.cancel("computer frame exceeds its byte bound").catch(() => undefined);
-    throw new RangeError("computer frame exceeds its byte bound");
+  const maxBytes = input.surface === "browser" ? 24 * 1024 * 1024 : COMPUTER_SCREENSHOT_MAX_BYTES;
+  if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+    await response.body?.cancel("frame exceeds its byte bound").catch(() => undefined);
+    throw new RangeError("frame exceeds its byte bound");
   }
   const data = new Uint8Array(await response.arrayBuffer());
-  return computerControlFrame(data, response.headers, input.expectedFrameEvidence);
+  return controllerImageFrame(data, response.headers, input);
+}
+
+function controllerImageFrame(
+  data: Uint8Array,
+  headers: { get(name: string): string | null | undefined },
+  input: FrameRequest,
+): ComputerControlFrame | BrowserControlFrame {
+  return input.surface === "browser"
+    ? browserControlFrame(data, headers, input.expectedFrameEvidence)
+    : computerControlFrame(data, headers, input.expectedFrameEvidence);
+}
+
+function browserControlFrame(
+  data: Uint8Array,
+  headers: { get(name: string): string | null | undefined },
+  expected: ExpectedBrowserFrameEvidence,
+): BrowserControlFrame {
+  if (data.byteLength < 1 || data.byteLength > 24 * 1024 * 1024) {
+    throw new RangeError("browser frame exceeds its byte bound");
+  }
+  const get = (name: string): string | null => headers.get(name.toLowerCase()) ?? null;
+  const mediaType = get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  if (mediaType !== "image/jpeg" && mediaType !== "image/png") {
+    throw new BrowserControlProtocolError("browser frame media type is invalid");
+  }
+  const metadataHeader = get("x-opengeni-browser-frame");
+  if (
+    !metadataHeader ||
+    metadataHeader.length > 64 * 1024 ||
+    !/^[A-Za-z0-9_-]+$/u.test(metadataHeader)
+  ) {
+    throw new BrowserControlProtocolError("browser frame metadata is invalid");
+  }
+  let metadata: BrowserFrameMetadata;
+  try {
+    metadata = parseBrowserFrameMetadata(
+      JSON.parse(Buffer.from(metadataHeader, "base64url").toString("utf8")),
+    );
+  } catch {
+    throw new BrowserControlProtocolError("browser frame metadata is invalid");
+  }
+  if (
+    metadata.browserSessionId !== expected.browserSessionId ||
+    metadata.controllerGeneration !== expected.controllerGeneration ||
+    metadata.targetId !== expected.targetId ||
+    metadata.mediaType !== mediaType
+  ) {
+    throw new BrowserControlProtocolError("browser frame evidence does not match its request");
+  }
+  return { data, mediaType, metadataHeader, metadata };
 }
 
 function computerControlFrame(

package/src/sandbox/routing/routing-session.ts

@@ -295,6 +295,7 @@ export interface RoutingSandboxSessionDeps {
   adoptProcessAsBackgroundCommand?: (input: {
     backend: ResolvedActiveBackend;
     process: RoutingRetainedProcess;
+    command?: string | undefined;
   }) => Promise<void>;
   /** Called only when an operation against the default/home backend throws a
    * non-fence error. Wiring may classify definitive provider disappearance and
@@ -2125,7 +2126,10 @@ export class RoutingSandboxSession implements RoutableBackendSession {
   /** Make a retained process session-owned before exposing its live locator.
    * Provider yield alone is not adoption: short commands can still finish and
    * return inline during the model-facing eager-wait window. */
-  async adoptRetainedProcessAsBackgroundCommand(providerSessionId: number): Promise<void> {
+  async adoptRetainedProcessAsBackgroundCommand(
+    providerSessionId: number,
+    command?: string,
+  ): Promise<void> {
     const record = this.retainedProcess(providerSessionId);
     if (!this.canAdoptRetainedProcessAsBackgroundCommand(providerSessionId)) {
       throw new RoutingUnsupportedError("backgroundCommandAdoption", record.backend.kind);
@@ -2142,6 +2146,7 @@ export class RoutingSandboxSession implements RoutableBackendSession {
     record.backgroundAdoption ??= this.deps.adoptProcessAsBackgroundCommand({
       backend: record.backend,
       process: record.process,
+      command,
     });
     try {
       await record.backgroundAdoption;

package/src/sandbox/turn-tool-cancellation.ts

@@ -67,6 +67,8 @@ type ShellProcessIdentity = {
 
 type ActiveShellSession = {
   sessionId: number;
+  /** Original model command, before adding process-control shell wrappers. */
+  command?: string;
   markerPath: string | null;
   token: string | null;
   interactive: boolean;
@@ -97,7 +99,10 @@ type CommandCancellationSession = {
   /** Whether the provider locator remains controllable from another worker
    * process after this turn returns. */
   canAdoptRetainedProcessAsBackgroundCommand?(providerSessionId: number): boolean;
-  adoptRetainedProcessAsBackgroundCommand?(providerSessionId: number): Promise<void>;
+  adoptRetainedProcessAsBackgroundCommand?(
+    providerSessionId: number,
+    command?: string,
+  ): Promise<void>;
   retainedProcessIdentity?(providerSessionId: number): { id: string } | null;
   cancelSupervisedCommand?(providerSessionId: number, reason: "explicit_stop"): Promise<boolean>;
   writeStdinForProcessRead?(args: {
@@ -1203,6 +1208,7 @@ class TurnToolCancellationControllerImpl implements TurnToolCancellationControll
                 // invoke a helper through the mutable current route.
                 this.shellSessions.set(retainedProcess.providerSessionId, {
                   sessionId: retainedProcess.providerSessionId,
+                  command: parsed.cmd,
                   markerPath,
                   token,
                   interactive,
@@ -1232,6 +1238,7 @@ class TurnToolCancellationControllerImpl implements TurnToolCancellationControll
             if (sessionId !== null) {
               const state: ActiveShellSession = {
                 sessionId,
+                command: parsed.cmd,
                 markerPath: useRemoteOpCancellation ? null : markerPath,
                 token: useRemoteOpCancellation ? null : token,
                 interactive,
@@ -1481,7 +1488,10 @@ class TurnToolCancellationControllerImpl implements TurnToolCancellationControll
       return `${runningCommandBanner(state.sessionId, output)}\nThis process is turn-scoped; it will stop when this turn ends or is interrupted.\n`;
     }
     if (state.processSession?.adoptRetainedProcessAsBackgroundCommand) {
-      await state.processSession.adoptRetainedProcessAsBackgroundCommand(state.sessionId);
+      await state.processSession.adoptRetainedProcessAsBackgroundCommand(
+        state.sessionId,
+        state.command,
+      );
       this.shellSessions.delete(state.sessionId);
     }
     return runningCommandBanner(