diff --git a/README.md b/README.md
index 61007f88b..4920e9190 100644
--- a/README.md
+++ b/README.md
@@ -58,7 +58,7 @@ agentcore                          # interactive TUI
 ├── runtime                        # inspect deployed AgentCore Runtimes
 │   ├── get                        # fetch a Runtime by id
 │   ├── list                       # list Runtimes (server-side paginated)
-│   ├── invoke                     # invoke a Runtime
+│   ├── invoke                     # invoke a Runtime headlessly or in a persistent console
 │   ├── version
 │   │   ├── get                    # get a specific Runtime version
 │   │   └── list                   # list a Runtime's versions
@@ -182,7 +182,7 @@ Source-aware values: any field flag documented as such accepts the value inline,
 
 ### Invoke a Runtime
 
-Runtime invocation accepts inline, file, or stdin payload bytes:
+Headless invocation accepts inline, file, or stdin payload bytes:
 
 ```bash
 # Inline
@@ -254,14 +254,35 @@ agentcore runtime invoke --id <runtimeId> --payload '{"action":"status"}' --json
 # {"statusCode":200,"contentType":"application/json","bodyEncoding":"utf8","body":"{\"ok\":true}","complete":true}
 ```
 
+Without `--payload`, Runtime Invoke opens a persistent JSON console for repeated
+requests. The console sends inline `application/json` payloads and renders each
+response according to its returned content type. Bare invoke opens the Runtime
+and endpoint pickers; `--id` skips the Runtime picker, and `--id` plus
+`--qualifier` opens the console directly. `--session-id` resumes that Runtime
+session in the console. `--user-id`, `--header`, and `--bearer-token` seed
+request context that persists across sends and endpoint changes within that
+Runtime. The console never displays their values, and switching Runtimes clears
+them. Interactive bearer tokens may be inline or `file://` sources, but not
+stdin.
+
+| Shortcut      | Action                                       |
+| ------------- | -------------------------------------------- |
+| `Enter`       | Send the JSON request                        |
+| `Shift+Enter` | Insert a newline                             |
+| `Ctrl+T`      | Change Runtime or endpoint                   |
+| `Ctrl+V`      | Toggle raw and pretty completed JSON         |
+| `Esc`         | Interrupt an active request or navigate back |
+| `↑`/`↓`       | Scroll response history                      |
+
 Runtime Invoke accepts Runtime IDs from the current account only. It does not
 accept ARNs, `--version`, `--interactive`, cross-account targets, or custom
 request paths. All requests use the Runtime `/invocations` route, including MCP
 Runtimes.
 
-Bare Runtime and Memory branches and leaves require a TTY on stdin and stdout. Supplying
-operation flags runs the command headlessly, and `--json` always suppresses TUI
-rendering.
+Bare Runtime and Memory branches and leaves require a TTY on stdin and stdout.
+For Runtime Invoke, supplying a payload or headless-only request or output flags
+runs headlessly; `--session-id` can instead seed the persistent console.
+`--json` always suppresses TUI rendering.
 
 ```bash
 agentcore runtime
diff --git a/src/components/Layout.tsx b/src/components/Layout.tsx
index a2cda1b9f..149f88ac9 100644
--- a/src/components/Layout.tsx
+++ b/src/components/Layout.tsx
@@ -22,12 +22,9 @@ export const Layout: React.FC<LayoutProps> = ({ breadcrumb, description, keyHint
   const { columns, rows } = useWindowSize();
 
   return (
-    <Box width={columns} height={rows} flexDirection="column" justifyContent="space-between">
+    <Box width={columns} height={rows} flexDirection="column">
       <Header breadcrumb={breadcrumb} description={description} />
-      {/* The header and footer each occupy 2 rows (breadcrumb/divider and
-          divider/key-hints), so the content area gets the remaining rows - 4.
-          ScrollView children need a concrete height to measure their viewport. */}
-      <Box height={rows - 4} flexDirection="column">
+      <Box flexGrow={1} flexShrink={1} minHeight={0} flexDirection="column">
         {children}
       </Box>
       <Footer keys={keyHints} />
diff --git a/src/components/Root.tsx b/src/components/Root.tsx
index 5899233ac..352cb88a8 100644
--- a/src/components/Root.tsx
+++ b/src/components/Root.tsx
@@ -31,6 +31,7 @@ import { RuntimeListVersionsScreen } from "../handlers/runtime/version/list/scre
 import { MemoryScreen } from "../handlers/memory/screen.tsx";
 import { MemoryGetJsonScreen, MemoryGetScreen } from "../handlers/memory/get/screen.tsx";
 import { MemoryListScreen } from "../handlers/memory/list/screen.tsx";
+import { RuntimeInvokeScreen } from "../handlers/runtime/invoke/screen.tsx";
 import { RootScreen, HelpScreen } from "../handlers/screen.tsx";
 import type { Context } from "../router";
 
@@ -275,6 +276,18 @@ export function Root({ path, ctx, core, queryClient }: RootProps) {
             path="agentcore/memory/get/:memoryId/json"
             element={<MemoryGetJsonScreen ctx={ctx} core={core} />}
           />
+          <Route
+            path="agentcore/runtime/invoke"
+            element={<RuntimeInvokeScreen ctx={ctx} core={core} />}
+          />
+          <Route
+            path="agentcore/runtime/invoke/:runtimeId"
+            element={<RuntimeInvokeScreen ctx={ctx} core={core} />}
+          />
+          <Route
+            path="agentcore/runtime/invoke/:runtimeId/:qualifier"
+            element={<RuntimeInvokeScreen ctx={ctx} core={core} />}
+          />
           <Route path="*" element={<HelpScreen ctx={ctx} core={core} />} />
         </Routes>
       </MemoryRouter>
diff --git a/src/components/RuntimeEndpointPicker.tsx b/src/components/RuntimeEndpointPicker.tsx
index 8485b46d3..fc46edcc3 100644
--- a/src/components/RuntimeEndpointPicker.tsx
+++ b/src/components/RuntimeEndpointPicker.tsx
@@ -42,6 +42,7 @@ export interface RuntimeEndpointPickerProps extends ScreenProps {
   breadcrumb: string[];
   description?: string;
   onSelect: (qualifier: string) => void;
+  onEscape?: () => void;
 }
 
 export function RuntimeEndpointPicker({
@@ -51,10 +52,11 @@ export function RuntimeEndpointPicker({
   breadcrumb,
   description,
   onSelect,
+  onEscape,
 }: RuntimeEndpointPickerProps) {
   const opts = coreOptsFromCtx(ctx);
   const navigate = useNavigate();
-  const goBack = () => navigate(-1);
+  const goBack = onEscape ?? (() => navigate(-1));
 
   return (
     <PaginatedTablePicker
diff --git a/src/components/RuntimePicker.tsx b/src/components/RuntimePicker.tsx
index 22ef489a0..cc46466b7 100644
--- a/src/components/RuntimePicker.tsx
+++ b/src/components/RuntimePicker.tsx
@@ -52,6 +52,7 @@ export interface RuntimePickerProps extends ScreenProps {
   breadcrumb: string[];
   description?: string;
   onSelect: (runtimeId: string) => void;
+  onEscape?: () => void;
 }
 
 export function RuntimePicker({
@@ -60,10 +61,11 @@ export function RuntimePicker({
   breadcrumb,
   description,
   onSelect,
+  onEscape,
 }: RuntimePickerProps) {
   const opts = coreOptsFromCtx(ctx);
   const navigate = useNavigate();
-  const goBack = () => navigate("/" + breadcrumb.slice(0, -1).join("/"));
+  const goBack = onEscape ?? (() => navigate("/" + breadcrumb.slice(0, -1).join("/")));
 
   return (
     <PaginatedTablePicker
diff --git a/src/components/ui/key-hint/KeyHint.test.tsx b/src/components/ui/key-hint/KeyHint.test.tsx
new file mode 100644
index 000000000..a111ded3c
--- /dev/null
+++ b/src/components/ui/key-hint/KeyHint.test.tsx
@@ -0,0 +1,35 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import React from "react";
+import { cleanup, render } from "ink-testing-library";
+import { KeyHint, type KeyHintItem } from "./KeyHint";
+
+afterEach(cleanup);
+
+function renderAtWidth(keys: KeyHintItem[], columns: number): string {
+  const instance = render(<></>);
+  Object.defineProperty(instance.stdout, "columns", {
+    configurable: true,
+    value: columns,
+  });
+  instance.stdout.emit("resize");
+  instance.rerender(<KeyHint keys={keys} />);
+  return instance.lastFrame() ?? "";
+}
+
+describe("KeyHint", () => {
+  test("shows only complete high-priority hints that fit one row", () => {
+    const frame = renderAtWidth(
+      [
+        { key: "enter", label: "send" },
+        { key: "⇧↵", label: "newline" },
+        { key: "ctl+t", label: "target" },
+        { key: "↑↓", label: "scroll" },
+        { key: "esc", label: "back" },
+        { key: "ctl+c", label: "quit" },
+      ],
+      60,
+    );
+
+    expect(frame).toBe("[enter] send  [⇧↵] newline  [↑↓] scroll  [esc] back");
+  });
+});
diff --git a/src/components/ui/key-hint/KeyHint.tsx b/src/components/ui/key-hint/KeyHint.tsx
index 6f0e80086..552c0be05 100644
--- a/src/components/ui/key-hint/KeyHint.tsx
+++ b/src/components/ui/key-hint/KeyHint.tsx
@@ -1,8 +1,11 @@
 import React from "react";
-import { Text, Box } from "ink";
+import { Text, Box, useWindowSize } from "ink";
+import stringWidth from "string-width";
 import { darkTheme } from "../_core.js";
 import type { InkUITheme } from "../_core.js";
 
+const ITEM_GAP = 2;
+
 export interface KeyHintItem {
   /** Displayed in brackets, e.g. "Enter", "↑↓", "Space" */
   key: string;
@@ -15,15 +18,48 @@ export interface KeyHintProps {
   theme?: InkUITheme;
 }
 
-export const KeyHint: React.FC<KeyHintProps> = ({ keys, theme = darkTheme }) => (
-  <Box gap={2}>
-    {keys.map(({ key, label }) => (
-      <Box key={key} gap={1}>
-        <Text bold dimColor>
-          [{key}]
-        </Text>
-        <Text color={theme.colors.muted}>{label}</Text>
-      </Box>
-    ))}
-  </Box>
-);
+function priority({ key, label }: KeyHintItem): number {
+  if (key === "esc" || label === "back") return 0;
+  if (key === "enter" || key.includes("↵") || label === "select") return 1;
+  if (key.includes("↑") || key.includes("↓")) return 2;
+  if (key.includes("←") || key.includes("→") || key === "/" || key === "ctl+c") return 4;
+  return 3;
+}
+
+function itemWidth({ key, label }: KeyHintItem): number {
+  return stringWidth(`[${key}] ${label}`);
+}
+
+function fitKeys(keys: KeyHintItem[], columns: number): KeyHintItem[] {
+  const candidates = keys
+    .map((item, index) => ({ item, index }))
+    .sort((a, b) => priority(a.item) - priority(b.item) || a.index - b.index);
+  const selected = new Set<number>();
+  let width = 0;
+
+  for (const candidate of candidates) {
+    const nextWidth = itemWidth(candidate.item) + (selected.size === 0 ? 0 : ITEM_GAP);
+    if (width + nextWidth > columns) continue;
+    selected.add(candidate.index);
+    width += nextWidth;
+  }
+
+  return keys.filter((_, index) => selected.has(index));
+}
+
+export const KeyHint: React.FC<KeyHintProps> = ({ keys, theme = darkTheme }) => {
+  const { columns } = useWindowSize();
+
+  return (
+    <Box width={columns} height={1} overflow="hidden" gap={ITEM_GAP}>
+      {fitKeys(keys, columns).map(({ key, label }) => (
+        <Box key={key} flexShrink={0} gap={1}>
+          <Text bold dimColor>
+            [{key}]
+          </Text>
+          <Text color={theme.colors.muted}>{label}</Text>
+        </Box>
+      ))}
+    </Box>
+  );
+};
diff --git a/src/handlers/runtime/invoke/RuntimePayloadInput.tsx b/src/handlers/runtime/invoke/RuntimePayloadInput.tsx
new file mode 100644
index 000000000..e9c66e251
--- /dev/null
+++ b/src/handlers/runtime/invoke/RuntimePayloadInput.tsx
@@ -0,0 +1,116 @@
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { darkTheme } from "../../../components/ui/_core.js";
+
+const theme = darkTheme;
+const PREVIEW_LINES = 4;
+const PLACEHOLDER = "Enter JSON payload";
+
+interface RuntimePayloadInputProps {
+  value: string;
+  onChange: (value: string) => void;
+  onSubmit: () => void;
+  submitDisabled?: boolean;
+}
+
+function Cursor({ character }: { character: string }) {
+  return (
+    <Text color={theme.colors.focus} inverse>
+      {character}
+    </Text>
+  );
+}
+
+export function RuntimePayloadInput({
+  value,
+  onChange,
+  onSubmit,
+  submitDisabled = false,
+}: RuntimePayloadInputProps) {
+  const [rawCursor, setRawCursor] = useState(value.length);
+  const cursor = Math.min(rawCursor, value.length);
+
+  useInput((input, key) => {
+    if (key.leftArrow) {
+      setRawCursor(Math.max(0, cursor - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setRawCursor(Math.min(value.length, cursor + 1));
+      return;
+    }
+    if (key.upArrow || key.downArrow) return;
+
+    if (key.backspace || key.delete) {
+      if (cursor === 0) return;
+      onChange(value.slice(0, cursor - 1) + value.slice(cursor));
+      setRawCursor(cursor - 1);
+      return;
+    }
+
+    if (key.return) {
+      if (key.shift || key.meta) {
+        onChange(value.slice(0, cursor) + "\n" + value.slice(cursor));
+        setRawCursor(cursor + 1);
+      } else if (!submitDisabled) {
+        onSubmit();
+      }
+      return;
+    }
+    if (key.ctrl || key.meta || key.escape || input === "") return;
+
+    const next = input.replace(/\r/g, "\n");
+    onChange(value.slice(0, cursor) + next + value.slice(cursor));
+    setRawCursor(cursor + next.length);
+  });
+
+  if (value === "") {
+    return (
+      <Box flexDirection="column">
+        <Text color={theme.colors.muted}>JSON payload</Text>
+        <Box>
+          <Cursor character={PLACEHOLDER[0]!} />
+          <Text color={theme.colors.muted}>{PLACEHOLDER.slice(1)}</Text>
+        </Box>
+      </Box>
+    );
+  }
+
+  const lines = value.split("\n");
+  const beforeCursor = value.slice(0, cursor);
+  const cursorLine = beforeCursor.split("\n").length - 1;
+  const lastNewline = beforeCursor.lastIndexOf("\n");
+  const cursorColumn = cursor - lastNewline - 1;
+  const start = Math.max(0, cursorLine - PREVIEW_LINES + 1);
+  const visible = lines.slice(start, start + PREVIEW_LINES);
+
+  return (
+    <Box flexDirection="column">
+      <Text color={theme.colors.muted}>JSON payload</Text>
+      {visible.map((line, index) => {
+        const lineIndex = start + index;
+        const prefix = index === 0 && start > 0 ? "… " : "";
+        if (lineIndex !== cursorLine) {
+          return (
+            <Box key={lineIndex}>
+              <Text color={theme.colors.border}>{prefix}</Text>
+              <Text>{line || " "}</Text>
+            </Box>
+          );
+        }
+
+        const before = line.slice(0, cursorColumn);
+        const at = line[cursorColumn] ?? " ";
+        const after = line.slice(cursorColumn + 1);
+        return (
+          <Box key={lineIndex}>
+            <Text color={theme.colors.border}>{prefix}</Text>
+            {before ? <Text>{before}</Text> : null}
+            <Cursor character={at} />
+            {after ? <Text>{after}</Text> : null}
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}
diff --git a/src/handlers/runtime/invoke/index.tsx b/src/handlers/runtime/invoke/index.tsx
index 67dc5f132..0110273a3 100644
--- a/src/handlers/runtime/invoke/index.tsx
+++ b/src/handlers/runtime/invoke/index.tsx
@@ -1,18 +1,25 @@
 import z from "zod";
-import { InputValidationError, RuntimeInvokeInterruptedError } from "../../../errors";
-import { createHandler, flag } from "../../../router";
+import {
+  InputValidationError,
+  InvalidEnvironmentError,
+  RuntimeInvokeInterruptedError,
+} from "../../../errors";
+import { createHandler, flag, PathKey } from "../../../router";
 import type { AppIO } from "../../../io";
 import type { Core } from "../../types";
 import { coreOptsFromCtx } from "../../utils";
 import { JsonKey } from "../../keys";
 import { ExitCode } from "../../../runnable";
+import { renderTuiAt } from "../../../tui";
 import {
   normalizeRuntimeInvokeRequest,
   parseRuntimeInvokeHeaders,
   resolveRuntimeInvokeSources,
+  resolveRuntimeInvokeTuiBearerToken,
   runtimeIdSchema,
 } from "./request";
 import { writeRuntimeInvokeResponse } from "./response";
+import { RuntimeInvokeLaunchContextKey } from "./launchContext";
 
 export const createInvokeRuntimeHandler = (core: Core, io: AppIO) =>
   createHandler({
@@ -55,9 +62,56 @@ export const createInvokeRuntimeHandler = (core: Core, io: AppIO) =>
         });
       }
       if (flags.payload === undefined) {
-        throw new InputValidationError("required option '--payload <payload>' not specified", {
-          exitCode: ExitCode.USAGE,
-        });
+        const hasHeadlessOnlyFlag = Object.entries(flags).some(
+          ([name, value]) =>
+            ![
+              "id",
+              "qualifier",
+              "payload",
+              "session-id",
+              "user-id",
+              "header",
+              "bearer-token",
+            ].includes(name) && value !== undefined,
+        );
+        if (ctx.require(JsonKey) || hasHeadlessOnlyFlag) {
+          throw new InputValidationError("required option '--payload <payload>' not specified", {
+            exitCode: ExitCode.USAGE,
+          });
+        }
+        let path = `${ctx.require(PathKey)}/${encodeURIComponent(flags.id)}`;
+        if (flags.qualifier !== undefined) {
+          path += `/${encodeURIComponent(flags.qualifier)}`;
+        }
+        const applicationHeaders = parseRuntimeInvokeHeaders(flags.header);
+        const bearerToken = await resolveRuntimeInvokeTuiBearerToken(
+          flags["bearer-token"],
+          io.stdin,
+        );
+        const launchContext = {
+          runtimeId: flags.id,
+          runtimeSessionId: flags["session-id"],
+          runtimeUserId: flags["user-id"],
+          applicationHeaders,
+          bearerToken,
+        };
+        try {
+          await renderTuiAt(
+            path,
+            ctx.withValue(RuntimeInvokeLaunchContextKey, launchContext),
+            core,
+            io,
+          );
+        } catch (error) {
+          if (error instanceof InvalidEnvironmentError) {
+            throw new InputValidationError(error.message, {
+              cause: error,
+              exitCode: ExitCode.USAGE,
+            });
+          }
+          throw error;
+        }
+        return;
       }
 
       const jsonOutput = ctx.require(JsonKey);
diff --git a/src/handlers/runtime/invoke/invoke.screen.test.tsx b/src/handlers/runtime/invoke/invoke.screen.test.tsx
new file mode 100644
index 000000000..019f946ab
--- /dev/null
+++ b/src/handlers/runtime/invoke/invoke.screen.test.tsx
@@ -0,0 +1,835 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type {
+  AgentRuntime,
+  AgentRuntimeEndpoint,
+  GetAgentRuntimeResponse,
+} from "@aws-sdk/client-bedrock-agentcore-control";
+import type { RuntimeInvokeRequest } from "../types";
+import {
+  cleanupScreens,
+  renderScreen,
+  TestCoreClient,
+  waitFor,
+  waitForText,
+} from "../../../testing";
+import { RuntimeInvokeLaunchContextKey } from "./launchContext";
+
+const REGION = "us-east-1";
+const RUNTIME_ID = "runtime-123";
+const QUALIFIER = "prod";
+const RUNTIME_ARN = `arn:aws:bedrock-agentcore:${REGION}:123456789012:runtime/${RUNTIME_ID}`;
+const CONSOLE_PATH = `/agentcore/runtime/invoke/${RUNTIME_ID}/${QUALIFIER}`;
+
+afterEach(cleanupScreens);
+
+function runtime(overrides: Partial<AgentRuntime> = {}): AgentRuntime {
+  return {
+    agentRuntimeArn: RUNTIME_ARN,
+    agentRuntimeId: RUNTIME_ID,
+    agentRuntimeVersion: "3",
+    agentRuntimeName: "checkout",
+    description: "Checkout Runtime",
+    lastUpdatedAt: new Date("2026-07-20T12:34:56.000Z"),
+    status: "READY",
+    ...overrides,
+  };
+}
+
+function endpoint(overrides: Partial<AgentRuntimeEndpoint> = {}): AgentRuntimeEndpoint {
+  return {
+    name: QUALIFIER,
+    id: QUALIFIER,
+    liveVersion: "3",
+    targetVersion: "3",
+    status: "READY",
+    agentRuntimeEndpointArn: `${RUNTIME_ARN}/endpoint/${QUALIFIER}`,
+    agentRuntimeArn: RUNTIME_ARN,
+    description: "Production endpoint",
+    createdAt: new Date("2026-07-19T01:02:03.000Z"),
+    lastUpdatedAt: new Date("2026-07-20T12:34:56.000Z"),
+    ...overrides,
+  };
+}
+
+function responseBody(...chunks: Uint8Array[]): AsyncIterable<Uint8Array> {
+  return (async function* () {
+    yield* chunks;
+  })();
+}
+
+function invokeRequests(core: TestCoreClient): RuntimeInvokeRequest[] {
+  return core.runtime.calls
+    .filter((call) => call.method === "invokeRuntime")
+    .map((call) => call.args[0] as RuntimeInvokeRequest);
+}
+
+describe("Runtime invoke routing", () => {
+  test("selects a Runtime and endpoint before opening one console", async () => {
+    const runtimeId = "runtime/blue one";
+    const qualifier = "prod/green one";
+    const core = new TestCoreClient();
+    core.runtime
+      .setListResponse({
+        agentRuntimes: [
+          runtime({
+            agentRuntimeId: runtimeId,
+            agentRuntimeName: "pick-runtime",
+            agentRuntimeArn: `arn:aws:bedrock-agentcore:${REGION}:123456789012:runtime/${runtimeId}`,
+          }),
+        ],
+      })
+      .setListEndpointsResponse({
+        runtimeEndpoints: [endpoint({ name: qualifier, id: qualifier })],
+      })
+      .setGetResponse({
+        agentRuntimeArn: `arn:aws:bedrock-agentcore:${REGION}:123456789012:runtime/${runtimeId}`,
+      } as GetAgentRuntimeResponse);
+    const screen = renderScreen("/agentcore/runtime/invoke", { core });
+
+    await waitForText(screen.lastFrame, "pick-runtime");
+    await screen.press("return");
+    await waitForText(screen.lastFrame, qualifier);
+    await screen.press("return");
+
+    await waitForText(
+      screen.lastFrame,
+      `agentcore → runtime → invoke → ${runtimeId} → ${qualifier}`,
+    );
+    await waitForText(screen.lastFrame, "Enter JSON payload");
+  });
+
+  test("esc from an initial endpoint picker returns to the Runtime picker", async () => {
+    const core = new TestCoreClient();
+    core.runtime.setListEndpointsResponse({ runtimeEndpoints: [endpoint()] }).setListResponse({
+      agentRuntimes: [runtime({ agentRuntimeName: "back-to-runtime-picker" })],
+    });
+    const screen = renderScreen(`/agentcore/runtime/invoke/${RUNTIME_ID}`, { core });
+
+    await waitForText(screen.lastFrame, QUALIFIER);
+    await screen.press("escape");
+
+    await waitForText(screen.lastFrame, "back-to-runtime-picker");
+    expect(screen.lastFrame()).toContain("agentcore → runtime → invoke");
+  });
+
+  test("keeps a CLI-selected session while choosing an endpoint", async () => {
+    const sessionId = "cli-selected-session";
+    const core = new TestCoreClient();
+    core.runtime
+      .setListEndpointsResponse({ runtimeEndpoints: [endpoint()] })
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse);
+    const screen = renderScreen(`/agentcore/runtime/invoke/${RUNTIME_ID}`, {
+      core,
+      withContext: (ctx) =>
+        ctx.withValue(RuntimeInvokeLaunchContextKey, {
+          runtimeId: RUNTIME_ID,
+          runtimeSessionId: sessionId,
+        }),
+    });
+
+    await waitForText(screen.lastFrame, QUALIFIER);
+    await screen.press("return");
+
+    await waitForText(screen.lastFrame, `Ready · Session ID: ${sessionId}`);
+    expect(screen.lastFrame()).not.toContain("MCP session ID");
+  });
+
+  test("escape switches endpoints without restoring the launch session", async () => {
+    const nextQualifier = "back-endpoint";
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse)
+      .setListEndpointsResponse({
+        runtimeEndpoints: [endpoint({ name: nextQualifier, id: nextQualifier })],
+      })
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "text/plain",
+        body: responseBody(Buffer.from("ok")),
+      });
+    const screen = renderScreen(CONSOLE_PATH, {
+      core,
+      withContext: (ctx) =>
+        ctx.withValue(RuntimeInvokeLaunchContextKey, {
+          runtimeId: RUNTIME_ID,
+          runtimeSessionId: "cli-selected-session",
+        }),
+    });
+
+    await waitForText(screen.lastFrame, "Session ID: cli-selected-session");
+    await screen.press("escape");
+    await waitForText(screen.lastFrame, nextQualifier);
+    await screen.press("return");
+    await waitForText(
+      screen.lastFrame,
+      `agentcore → runtime → invoke → ${RUNTIME_ID} → ${nextQualifier}`,
+    );
+    expect(screen.lastFrame()).toContain("Ready · Session ID: Not set");
+
+    await screen.write("{}");
+    await screen.press("return");
+    await waitFor(() => invokeRequests(core).length === 1);
+    expect(invokeRequests(core)[0]!.runtimeSessionId).toBeUndefined();
+  });
+
+  test("unmount cancels the Runtime detail lookup", async () => {
+    let lookupSignal: AbortSignal | undefined;
+    const core = new TestCoreClient();
+    core.runtime.getRuntime = async (_id, _options, signal) => {
+      lookupSignal = signal;
+      return new Promise(() => {});
+    };
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitFor(() => lookupSignal !== undefined);
+    screen.unmount();
+
+    await waitFor(() => lookupSignal!.aborted);
+  });
+});
+
+describe("Runtime invoke JSON console", () => {
+  test("sends inline JSON with the fixed content type", async () => {
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse)
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "text/plain",
+        body: responseBody(Buffer.from("ok")),
+      });
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "JSON payload");
+    await screen.write('{"prompt":"hello"}');
+    await screen.press("return");
+    await waitFor(() => invokeRequests(core).length === 1);
+
+    expect(invokeRequests(core)[0]).toMatchObject({
+      runtimeId: RUNTIME_ID,
+      qualifier: QUALIFIER,
+      contentType: "application/json",
+    });
+    expect(new TextDecoder().decode(invokeRequests(core)[0]!.payload)).toBe('{"prompt":"hello"}');
+    await waitForText(screen.lastFrame, "complete · 2 bytes");
+  });
+
+  test("rejects invalid JSON locally without clearing the editor or invoking", async () => {
+    const core = new TestCoreClient();
+    core.runtime.setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse);
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write('{"prompt":');
+    await screen.press("return");
+
+    await waitForText(screen.lastFrame, "Enter a valid JSON payload");
+    expect(screen.lastFrame()).toContain('{"prompt":');
+    expect(invokeRequests(core)).toHaveLength(0);
+  });
+
+  test("Shift+Enter inserts JSON newlines without sending", async () => {
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse)
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "text/plain",
+        body: responseBody(Buffer.from("ok")),
+      });
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write("{");
+    await screen.write("\x1b[13;2u");
+    await screen.write('"prompt":"hello"');
+    await screen.write("\x1b[13;2u");
+    await screen.write("}");
+
+    await waitForText(screen.lastFrame, '{\n"prompt":"hello"\n}');
+    expect(invokeRequests(core)).toHaveLength(0);
+    await screen.press("return");
+    await waitFor(() => invokeRequests(core).length === 1);
+    expect(new TextDecoder().decode(invokeRequests(core)[0]!.payload)).toBe(
+      '{\n"prompt":"hello"\n}',
+    );
+  });
+
+  test("edits JSON with cursor movement and backspace", async () => {
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse)
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "text/plain",
+        body: responseBody(Buffer.from("ok")),
+      });
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write('{"a":1}');
+    await screen.press("left");
+    await screen.press("left");
+    await screen.write("2");
+    await screen.press("right");
+    await screen.write("\x7f");
+    await screen.press("return");
+
+    await waitFor(() => invokeRequests(core).length === 1);
+    expect(new TextDecoder().decode(invokeRequests(core)[0]!.payload)).toBe('{"a":2}');
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write("\x7f");
+    expect(screen.lastFrame()).toContain("Enter JSON payload");
+  });
+
+  test("keeps blank multiline rows inside the four-line editor", async () => {
+    const core = new TestCoreClient();
+    core.runtime.setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse);
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    const initialStatusLine = screen
+      .lastFrame()!
+      .split("\n")
+      .findIndex((line) => line.includes("Ready · Session ID"));
+
+    for (let index = 0; index < 3; index++) await screen.write("\x1b[13;2u");
+
+    const expandedLines = screen.lastFrame()!.split("\n");
+    const labelLine = expandedLines.findIndex((line) => line.includes("JSON payload"));
+    const lowerDivider = expandedLines.findIndex(
+      (line, index) => index > labelLine && /^─+$/.test(line),
+    );
+    expect(lowerDivider - labelLine).toBe(5);
+    expect(expandedLines.findIndex((line) => line.includes("Ready · Session ID"))).toBe(
+      initialStatusLine,
+    );
+    expect(screen.lastFrame()).not.toContain("…");
+
+    await screen.write("\x1b[13;2u");
+    expect(screen.lastFrame()).toContain("…");
+  });
+
+  test("keeps status and shortcut rows intact with a long target at narrow widths", async () => {
+    const runtimeId = "RuntimeTuiMatrix_MatrixRuntime-vKVMPm4r8j";
+    const core = new TestCoreClient();
+    core.runtime.setGetResponse({
+      agentRuntimeArn: `arn:aws:bedrock-agentcore:${REGION}:123456789012:runtime/${runtimeId}`,
+    } as GetAgentRuntimeResponse);
+    const screen = renderScreen(`/agentcore/runtime/invoke/${runtimeId}/${QUALIFIER}`, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.resize(80, 24);
+    expect(screen.lastFrame()).toContain("Ready · Session ID: Not set");
+    expect(screen.lastFrame()).toContain(
+      "[enter] send  [⇧↵] newline  [ctl+t] target  [↑↓] scroll  [esc] back",
+    );
+
+    await screen.resize(60, 24);
+    expect(screen.lastFrame()).toContain("Ready · Session ID: Not set");
+    expect(screen.lastFrame()).toContain("[enter] send  [⇧↵] newline  [↑↓] scroll  [esc] back");
+  });
+
+  test("keeps the next JSON draft while the current response streams", async () => {
+    const release = Promise.withResolvers<void>();
+    const requests: RuntimeInvokeRequest[] = [];
+    const core = new TestCoreClient();
+    core.runtime.setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse);
+    core.runtime.invokeRuntime = async (request) => {
+      requests.push(request);
+      return {
+        statusCode: 200,
+        contentType: "text/plain",
+        body:
+          requests.length === 1
+            ? (async function* () {
+                yield Buffer.from("partial");
+                await release.promise;
+              })()
+            : responseBody(Buffer.from("done")),
+      };
+    };
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write('{"turn":1}');
+    await screen.press("return");
+    await waitForText(screen.lastFrame, "partial");
+    await screen.write('{"turn":2}');
+    await screen.press("return");
+    expect(requests).toHaveLength(1);
+
+    release.resolve();
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.press("return");
+    await waitFor(() => requests.length === 2);
+    expect(new TextDecoder().decode(requests[1]!.payload)).toBe('{"turn":2}');
+  });
+
+  test("keeps settled response details out of streaming frames", async () => {
+    const release = Promise.withResolvers<void>();
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse)
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "text/plain",
+        runtimeSessionId: "returned-runtime",
+        body: (async function* () {
+          yield Buffer.from("partial");
+          await release.promise;
+          yield Buffer.from(" response");
+        })(),
+      });
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write("{}");
+    const frameCount = screen.frames.length;
+    await screen.press("return");
+    await waitForText(screen.lastFrame, "partial");
+
+    const streamingFrames = screen.frames
+      .slice(frameCount)
+      .filter((frame) => frame.includes("streaming…"));
+    expect(streamingFrames.length).toBeGreaterThan(0);
+    for (const frame of streamingFrames) {
+      expect(frame).not.toContain("Session ID: returned-runtime");
+      expect(frame).not.toContain("streaming ·");
+    }
+
+    release.resolve();
+    await waitForText(screen.lastFrame, "complete · 16 bytes");
+    expect(screen.lastFrame()).toContain("Session ID: returned-runtime");
+  });
+
+  test.each([
+    [
+      "invalid UTF-8 text",
+      "text/plain",
+      Buffer.from([0xff]),
+      "Invalid UTF-8 response; showing raw text.",
+    ],
+    [
+      "invalid JSON",
+      "application/json",
+      Buffer.from("not-json"),
+      "Invalid JSON response; showing raw text.",
+    ],
+  ])("explains %s responses", async (_case, contentType, body, note) => {
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse)
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType,
+        body: responseBody(body),
+      });
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write("{}");
+    await screen.press("return");
+
+    await waitForText(screen.lastFrame, note);
+    expect(screen.lastFrame()).toContain(`complete · ${body.byteLength} bytes`);
+  });
+
+  test("shows failures that occur before a response starts", async () => {
+    const core = new TestCoreClient();
+    core.runtime.setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse);
+    core.runtime.invokeRuntime = async () => {
+      throw new Error("connection failed");
+    };
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write("{}");
+    await screen.press("return");
+
+    await waitForText(screen.lastFrame, "connection failed");
+    expect(screen.lastFrame()).toContain("failed · 0 bytes");
+  });
+
+  test("shows failures that occur while reading a response", async () => {
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse)
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "text/plain",
+        body: (async function* () {
+          yield Buffer.from("partial");
+          throw new Error("stream failed");
+        })(),
+      });
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write("{}");
+    await screen.press("return");
+
+    await waitForText(screen.lastFrame, "response stream failed");
+    expect(screen.lastFrame()).toContain("partial");
+    expect(screen.lastFrame()).toContain("failed · 7 bytes");
+  });
+
+  test("scrolls completed response history with the arrow keys", async () => {
+    const response = Array.from({ length: 12 }, (_, index) => `response-line-${index}`).join("\n");
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse)
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "text/plain",
+        body: responseBody(Buffer.from(response)),
+      });
+    const screen = renderScreen(CONSOLE_PATH, { core });
+    await screen.resize(80, 16);
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write("{}");
+    await screen.press("return");
+    await waitForText(screen.lastFrame, "response-line-11");
+
+    for (let index = 0; index < 8; index++) await screen.press("up");
+    expect(screen.lastFrame()).toContain("response-line-3");
+    for (let index = 0; index < 8; index++) await screen.press("down");
+    expect(screen.lastFrame()).toContain("response-line-11");
+  });
+
+  test("starts from --session-id and adopts returned Runtime and MCP context", async () => {
+    const requests: RuntimeInvokeRequest[] = [];
+    const core = new TestCoreClient();
+    core.runtime.setGetResponse({
+      agentRuntimeArn: RUNTIME_ARN,
+      protocolConfiguration: { serverProtocol: "MCP" },
+    } as GetAgentRuntimeResponse);
+    core.runtime.invokeRuntime = async (request) => {
+      requests.push(request);
+      return {
+        statusCode: 200,
+        contentType: "text/event-stream",
+        runtimeSessionId: "returned-runtime",
+        mcpSessionId: "returned-mcp",
+        mcpProtocolVersion: "2025-06-18",
+        body: responseBody(Buffer.from("data: done\n\n")),
+      };
+    };
+    const initialSession = "cli-selected-session";
+    const screen = renderScreen(CONSOLE_PATH, {
+      core,
+      withContext: (ctx) =>
+        ctx.withValue(RuntimeInvokeLaunchContextKey, {
+          runtimeId: RUNTIME_ID,
+          runtimeSessionId: initialSession,
+        }),
+    });
+
+    await waitForText(screen.lastFrame, `Session ID: ${initialSession}`);
+    await screen.write('{"turn":1}');
+    await screen.press("return");
+    await waitForText(
+      screen.lastFrame,
+      "Ready · Session ID: returned-runtime · MCP session ID: returned-mcp",
+    );
+    await screen.write('{"turn":2}');
+    await screen.press("return");
+    await waitFor(() => requests.length === 2);
+
+    expect(requests[0]!.runtimeSessionId).toBe(initialSession);
+    expect(requests[0]!.mcpSessionId).toBeUndefined();
+    expect(requests[0]!.mcpProtocolVersion).toBeUndefined();
+    expect(requests[1]!.runtimeSessionId).toBe("returned-runtime");
+    expect(requests[1]!.mcpSessionId).toBe("returned-mcp");
+    expect(requests[1]!.mcpProtocolVersion).toBe("2025-06-18");
+  });
+
+  test("persists launch identity, authentication, and headers without exposing values", async () => {
+    const token = "secret-bearer-token";
+    const userId = "user-123";
+    const requests: RuntimeInvokeRequest[] = [];
+    const core = new TestCoreClient();
+    core.runtime.setGetResponse({
+      agentRuntimeArn: RUNTIME_ARN,
+      authorizerConfiguration: { customJWTAuthorizer: {} },
+      requestHeaderConfiguration: { requestHeaderAllowlist: ["X-Tenant"] },
+    } as GetAgentRuntimeResponse);
+    core.runtime.invokeRuntime = async (request) => {
+      requests.push(request);
+      return {
+        statusCode: 200,
+        contentType: "application/json",
+        body: responseBody(Buffer.from('{"ok":true}')),
+      };
+    };
+    const screen = renderScreen(CONSOLE_PATH, {
+      core,
+      withContext: (ctx) =>
+        ctx.withValue(RuntimeInvokeLaunchContextKey, {
+          runtimeId: RUNTIME_ID,
+          runtimeUserId: userId,
+          applicationHeaders: [["X-Tenant", "retail"]],
+          bearerToken: token,
+        }),
+    });
+
+    await waitForText(screen.lastFrame, "Context user/JWT/1h");
+    expect(screen.lastFrame()).not.toContain(userId);
+    expect(screen.lastFrame()).not.toContain(token);
+    expect(screen.lastFrame()).not.toContain("retail");
+
+    await screen.write('{"turn":1}');
+    await screen.press("return");
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write('{"turn":2}');
+    await screen.press("return");
+    await waitFor(() => requests.length === 2);
+
+    for (const request of requests) {
+      expect(request).toMatchObject({
+        runtimeUserId: userId,
+        applicationHeaders: [["X-Tenant", "retail"]],
+        bearerToken: token,
+      });
+    }
+  });
+
+  test("target switching clears transcript and target-specific sessions", async () => {
+    const nextQualifier = "canary";
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({
+        agentRuntimeArn: RUNTIME_ARN,
+        protocolConfiguration: { serverProtocol: "MCP" },
+        requestHeaderConfiguration: { requestHeaderAllowlist: ["X-Tenant"] },
+      } as GetAgentRuntimeResponse)
+      .setListResponse({ agentRuntimes: [runtime()] })
+      .setListEndpointsResponse({
+        runtimeEndpoints: [endpoint({ name: nextQualifier, id: nextQualifier })],
+      })
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "text/plain",
+        runtimeSessionId: "returned-runtime",
+        mcpSessionId: "returned-mcp",
+        mcpProtocolVersion: "2025-06-18",
+        body: responseBody(Buffer.from("old response")),
+      });
+    const screen = renderScreen(CONSOLE_PATH, {
+      core,
+      withContext: (ctx) =>
+        ctx.withValue(RuntimeInvokeLaunchContextKey, {
+          runtimeId: RUNTIME_ID,
+          runtimeUserId: "user-123",
+          applicationHeaders: [["X-Tenant", "retail"]],
+        }),
+    });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write('{"turn":1}');
+    await screen.press("return");
+    await waitForText(screen.lastFrame, "Ready · Session ID: returned-runtime");
+
+    await screen.write("\x14");
+    await waitForText(screen.lastFrame, "choose another Runtime");
+    await screen.press("return");
+    await waitForText(screen.lastFrame, nextQualifier);
+    await screen.press("return");
+    await waitForText(
+      screen.lastFrame,
+      `agentcore → runtime → invoke → ${RUNTIME_ID} → ${nextQualifier}`,
+    );
+    expect(screen.lastFrame()).not.toContain("old response");
+    expect(screen.lastFrame()).toContain("Ready · Session ID: Not set");
+    expect(screen.lastFrame()).toContain("MCP session ID: Not set");
+
+    core.runtime.setInvokeResponse({
+      statusCode: 200,
+      contentType: "text/plain",
+      body: responseBody(Buffer.from("new response")),
+    });
+    await screen.write('{"turn":2}');
+    await screen.press("return");
+    await waitFor(() => invokeRequests(core).length === 2);
+    expect(invokeRequests(core)[1]!.runtimeSessionId).toBeUndefined();
+    expect(invokeRequests(core)[1]!.mcpSessionId).toBeUndefined();
+    expect(invokeRequests(core)[1]!.mcpProtocolVersion).toBeUndefined();
+    expect(invokeRequests(core)[1]).toMatchObject({
+      runtimeUserId: "user-123",
+      applicationHeaders: [["X-Tenant", "retail"]],
+    });
+  });
+
+  test("switching Runtimes clears launch identity, authentication, and headers", async () => {
+    const nextRuntimeId = "runtime-next";
+    const nextQualifier = "canary";
+    const nextArn = RUNTIME_ARN.replace(RUNTIME_ID, nextRuntimeId);
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({
+        agentRuntimeArn: RUNTIME_ARN,
+        authorizerConfiguration: { customJWTAuthorizer: {} },
+        requestHeaderConfiguration: { requestHeaderAllowlist: ["X-Tenant"] },
+      } as GetAgentRuntimeResponse)
+      .setListResponse({
+        agentRuntimes: [
+          runtime(),
+          runtime({
+            agentRuntimeId: nextRuntimeId,
+            agentRuntimeName: "next-runtime",
+            agentRuntimeArn: nextArn,
+          }),
+        ],
+      })
+      .setListEndpointsResponse({
+        runtimeEndpoints: [endpoint({ name: nextQualifier, id: nextQualifier })],
+      })
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "text/plain",
+        body: responseBody(Buffer.from("ok")),
+      });
+    const screen = renderScreen(CONSOLE_PATH, {
+      core,
+      withContext: (ctx) =>
+        ctx.withValue(RuntimeInvokeLaunchContextKey, {
+          runtimeId: RUNTIME_ID,
+          runtimeUserId: "user-123",
+          applicationHeaders: [["X-Tenant", "retail"]],
+          bearerToken: "secret-token",
+        }),
+    });
+
+    await waitForText(screen.lastFrame, "Context user/JWT/1h");
+    core.runtime.setGetResponse({ agentRuntimeArn: nextArn } as GetAgentRuntimeResponse);
+    await screen.write("\x14");
+    await waitForText(screen.lastFrame, "next-runtime");
+    await screen.press("down");
+    await screen.press("return");
+    await waitForText(screen.lastFrame, nextQualifier);
+    await screen.press("return");
+    await waitForText(
+      screen.lastFrame,
+      `agentcore → runtime → invoke → ${nextRuntimeId} → ${nextQualifier}`,
+    );
+    expect(screen.lastFrame()).not.toContain("Context");
+
+    await screen.write("{}");
+    await screen.press("return");
+    await waitFor(() => invokeRequests(core).length === 1);
+    expect(invokeRequests(core)[0]!.runtimeUserId).toBeUndefined();
+    expect(invokeRequests(core)[0]!.applicationHeaders).toBeUndefined();
+    expect(invokeRequests(core)[0]!.bearerToken).toBeUndefined();
+  });
+
+  test("toggles a completed JSON response between raw and pretty text", async () => {
+    const raw = '{"z":1,"nested":{"ok":true}}';
+    const pretty = JSON.stringify(JSON.parse(raw), null, 2);
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse)
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "application/json",
+        body: responseBody(Buffer.from(raw)),
+      });
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write("{}");
+    await screen.press("return");
+    await waitForText(screen.lastFrame, raw);
+    await waitForText(screen.lastFrame, "Ready");
+
+    await screen.write("\x16");
+    await waitForText(screen.lastFrame, pretty);
+    await screen.write("\x16");
+    await waitForText(screen.lastFrame, raw);
+  });
+
+  test("rejects binary console responses before consuming their bodies", async () => {
+    let iterations = 0;
+    const core = new TestCoreClient();
+    core.runtime
+      .setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse)
+      .setInvokeResponse({
+        statusCode: 200,
+        contentType: "application/octet-stream",
+        body: (async function* () {
+          iterations++;
+          yield Buffer.from([0, 255]);
+        })(),
+      });
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write("{}");
+    await screen.press("return");
+
+    await waitForText(
+      screen.lastFrame,
+      "Binary or unknown responses require headless invoke with --output-file.",
+    );
+    expect(iterations).toBe(0);
+  });
+
+  test("reports a missing bearer token for CUSTOM_JWT Runtimes", async () => {
+    const core = new TestCoreClient();
+    core.runtime.setGetResponse({
+      agentRuntimeArn: RUNTIME_ARN,
+      authorizerConfiguration: { customJWTAuthorizer: {} },
+    } as GetAgentRuntimeResponse);
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    await waitForText(screen.lastFrame, "Ready");
+    await screen.write("{}");
+    await screen.press("return");
+
+    await waitForText(screen.lastFrame, "CUSTOM_JWT Runtime requires --bearer-token");
+    expect(invokeRequests(core)).toHaveLength(0);
+  });
+
+  test("Esc interrupts a response stream, preserves partial text, and rejects its sessions", async () => {
+    const stop = Promise.withResolvers<void>();
+    let signal: AbortSignal | undefined;
+    const core = new TestCoreClient();
+    core.runtime.setGetResponse({ agentRuntimeArn: RUNTIME_ARN } as GetAgentRuntimeResponse);
+    core.runtime.invokeRuntime = async (_request, _options, nextSignal) => {
+      signal = nextSignal;
+      return {
+        statusCode: 200,
+        contentType: "text/event-stream",
+        runtimeSessionId: "interrupted-runtime",
+        mcpSessionId: "interrupted-mcp",
+        body: (async function* () {
+          yield Buffer.from("data: partial\n");
+          await stop.promise;
+        })(),
+      };
+    };
+    const screen = renderScreen(CONSOLE_PATH, { core });
+
+    try {
+      await waitForText(screen.lastFrame, "Ready");
+      await screen.write("{}");
+      await screen.press("return");
+      await waitForText(screen.lastFrame, "data: partial");
+
+      await screen.press("escape");
+      expect(signal?.aborted).toBe(true);
+      stop.reject(Object.assign(new Error("The operation was aborted"), { name: "AbortError" }));
+      await waitForText(screen.lastFrame, "interrupted · 14 bytes");
+      expect(screen.lastFrame()).toContain("data: partial");
+      expect(screen.lastFrame()).toContain("Ready · Session ID: Not set");
+      expect(
+        screen
+          .lastFrame()!
+          .split("\n")
+          .find((line) => line.includes("Ready · Session ID")),
+      ).not.toContain("MCP session ID");
+    } finally {
+      stop.resolve();
+    }
+  });
+});
diff --git a/src/handlers/runtime/invoke/invoke.test.tsx b/src/handlers/runtime/invoke/invoke.test.tsx
index af17facd8..fa4d4859d 100644
--- a/src/handlers/runtime/invoke/invoke.test.tsx
+++ b/src/handlers/runtime/invoke/invoke.test.tsx
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { PassThrough, Writable } from "node:stream";
@@ -12,7 +12,10 @@ import {
   waitFor,
 } from "../../../testing";
 import { ExitCode, runWithExitCode } from "../../../runnable";
+import { InvalidEnvironmentError } from "../../../errors";
 import { createRootHandler } from "../../index";
+import * as tui from "../../../tui";
+import { RuntimeInvokeLaunchContextKey } from "./launchContext";
 
 const REGION = "us-west-2";
 const RUNTIME_ID = "runtime-123";
@@ -153,17 +156,14 @@ describe("runtime invoke", () => {
     });
   });
 
-  test.each<[string, string[]]>([
-    ["no request options", []],
-    ["--content-type", ["--content-type", "text/plain"]],
-    ["--header", ["--header", "X-Test: value"]],
-    ["--output-file", ["--output-file", "response.bin"]],
-    ["--json", ["--json"]],
-  ])("requires a payload with %s before Core calls", async (_name, extraArgs) => {
+  test.each([
+    ["--content-type", "text/plain"],
+    ["--output-file", "response.bin"],
+  ])("rejects request option %s without a payload before Core calls", async (flagName, value) => {
     const core = new TestCoreClient();
     const output = captureIO();
     await expect(
-      runCommand(core, output.io, ["runtime", "invoke", "--id", RUNTIME_ID, ...extraArgs]),
+      runCommand(core, output.io, ["runtime", "invoke", "--id", RUNTIME_ID, flagName, value]),
     ).rejects.toThrow(/--payload/);
     expect(core.runtime.calls).toEqual([]);
   });
@@ -340,15 +340,12 @@ describe("runtime invoke", () => {
     expect(core.runtime.calls).toEqual([]);
   });
 
-  test.each<[string, string[]]>([
-    ["--id", ["--payload", "{}"]],
-    ["--payload", ["--id", RUNTIME_ID]],
-  ])("classifies a missing %s as usage before Core calls", async (_flag, args) => {
+  test("classifies a missing --id as usage before Core calls", async () => {
     const core = new TestCoreClient();
     const output = captureIO();
 
     const code = await runWithExitCode(async () =>
-      runCommand(core, output.io, ["runtime", "invoke", ...args]),
+      runCommand(core, output.io, ["runtime", "invoke", "--payload", "{}"]),
     );
 
     expect(code).toBe(ExitCode.USAGE);
@@ -394,7 +391,7 @@ describe("runtime invoke", () => {
     expect(core.runtime.calls.map((call) => call.method)).toEqual(["getRuntime"]);
   });
 
-  test("a bare command reaches the Runtime TUI middleware without Core calls", async () => {
+  test("a bare command enters existing TUI middleware without Runtime Core calls", async () => {
     const core = new TestCoreClient();
     const output = captureIO();
 
@@ -404,6 +401,147 @@ describe("runtime invoke", () => {
     expect(core.runtime.calls).toEqual([]);
   });
 
+  test("classifies the TUI requirement as usage at the handler boundary", async () => {
+    const core = new TestCoreClient();
+    const output = captureIO();
+    const render = spyOn(tui, "renderTuiAt").mockRejectedValue(
+      new InvalidEnvironmentError("interactive mode requires a TTY on stdin and stdout"),
+    );
+
+    try {
+      const code = await runWithExitCode(async () =>
+        runCommand(core, output.io, ["runtime", "invoke", "--id", RUNTIME_ID]),
+      );
+
+      expect(code).toBe(ExitCode.USAGE);
+      expect(core.runtime.calls).toEqual([]);
+    } finally {
+      render.mockRestore();
+    }
+  });
+
+  test("preserves unexpected TUI rendering failures", async () => {
+    const core = new TestCoreClient();
+    const output = captureIO();
+    const failure = new TypeError("render failed");
+    const render = spyOn(tui, "renderTuiAt").mockRejectedValue(failure);
+
+    try {
+      await expect(
+        runCommand(core, output.io, ["runtime", "invoke", "--id", RUNTIME_ID]),
+      ).rejects.toBe(failure);
+      expect(core.runtime.calls).toEqual([]);
+    } finally {
+      render.mockRestore();
+    }
+  });
+
+  test("handler deep-links id-only and qualified invokes with encoded path segments", async () => {
+    const core = new TestCoreClient();
+    const output = captureIO();
+    const render = spyOn(tui, "renderTuiAt").mockResolvedValue(undefined);
+
+    try {
+      await runCommand(core, output.io, ["runtime", "invoke", "--id", "runtime/blue one"]);
+      await runCommand(core, output.io, [
+        "runtime",
+        "invoke",
+        "--id",
+        "runtime/blue one",
+        "--session-id",
+        "session/one two",
+      ]);
+      await runCommand(core, output.io, [
+        "runtime",
+        "invoke",
+        "--id",
+        "runtime/blue one",
+        "--qualifier",
+        "prod/green one",
+      ]);
+      await runCommand(core, output.io, [
+        "runtime",
+        "invoke",
+        "--id",
+        "runtime/blue one",
+        "--qualifier",
+        "prod/green one",
+        "--session-id",
+        "session/one two",
+      ]);
+
+      expect(render.mock.calls.map(([path]) => path)).toEqual([
+        "/agentcore/runtime/invoke/runtime%2Fblue%20one",
+        "/agentcore/runtime/invoke/runtime%2Fblue%20one",
+        "/agentcore/runtime/invoke/runtime%2Fblue%20one/prod%2Fgreen%20one",
+        "/agentcore/runtime/invoke/runtime%2Fblue%20one/prod%2Fgreen%20one",
+      ]);
+      expect(render.mock.calls[1]![1].value(RuntimeInvokeLaunchContextKey)).toMatchObject({
+        runtimeId: "runtime/blue one",
+        runtimeSessionId: "session/one two",
+      });
+      expect(render.mock.calls[3]![1].value(RuntimeInvokeLaunchContextKey)).toMatchObject({
+        runtimeId: "runtime/blue one",
+        runtimeSessionId: "session/one two",
+      });
+    } finally {
+      render.mockRestore();
+    }
+  });
+
+  test("passes launch identity, authentication, and headers to the TUI without a payload", async () => {
+    const core = new TestCoreClient();
+    const output = captureIO();
+    const render = spyOn(tui, "renderTuiAt").mockResolvedValue(undefined);
+
+    try {
+      await runCommand(core, output.io, [
+        "runtime",
+        "invoke",
+        "--id",
+        RUNTIME_ID,
+        "--user-id",
+        "user-123",
+        "--header",
+        "X-Tenant: retail",
+        "--bearer-token",
+        "secret-token",
+      ]);
+
+      expect(render).toHaveBeenCalledTimes(1);
+      expect(render.mock.calls[0]![1].value(RuntimeInvokeLaunchContextKey)).toEqual({
+        runtimeId: RUNTIME_ID,
+        runtimeSessionId: undefined,
+        runtimeUserId: "user-123",
+        applicationHeaders: [["X-Tenant", "retail"]],
+        bearerToken: "secret-token",
+      });
+      expect(core.runtime.calls).toEqual([]);
+    } finally {
+      render.mockRestore();
+    }
+  });
+
+  test("rejects a stdin bearer token when launching the TUI", async () => {
+    const core = new TestCoreClient();
+    const output = captureIO();
+
+    await expect(
+      runCommand(core, output.io, ["runtime", "invoke", "--id", RUNTIME_ID, "--bearer-token", "-"]),
+    ).rejects.toThrow("stdin bearer tokens are not available");
+    expect(core.runtime.calls).toEqual([]);
+  });
+
+  test("handler keeps JSON mode without a payload as a usage error", async () => {
+    const core = new TestCoreClient();
+    const output = captureIO();
+
+    await expect(
+      runCommand(core, output.io, ["runtime", "invoke", "--id", RUNTIME_ID, "--json"]),
+    ).rejects.toThrow(/--payload/);
+    expect(core.runtime.calls).toEqual([]);
+  });
+
   test.each<[string, ...string[]]>([
     ["malformed", "missing separator"],
     ["duplicate", "X-Test: one", "x-test: two"],
diff --git a/src/handlers/runtime/invoke/launchContext.ts b/src/handlers/runtime/invoke/launchContext.ts
new file mode 100644
index 000000000..bcee87f31
--- /dev/null
+++ b/src/handlers/runtime/invoke/launchContext.ts
@@ -0,0 +1,12 @@
+import { contextKey } from "../../../router";
+
+export type RuntimeInvokeLaunchContext = {
+  runtimeId: string;
+  runtimeSessionId?: string;
+  runtimeUserId?: string;
+  applicationHeaders?: [string, string][];
+  bearerToken?: string;
+};
+
+export const RuntimeInvokeLaunchContextKey =
+  contextKey<RuntimeInvokeLaunchContext>("runtime.invoke.launch");
diff --git a/src/handlers/runtime/invoke/request.test.ts b/src/handlers/runtime/invoke/request.test.ts
index 995c69882..4b6625a7c 100644
--- a/src/handlers/runtime/invoke/request.test.ts
+++ b/src/handlers/runtime/invoke/request.test.ts
@@ -1,11 +1,13 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
 import { Readable } from "node:stream";
 import type { GetAgentRuntimeResponse } from "@aws-sdk/client-bedrock-agentcore-control";
 import { InputValidationError, SourceResolutionError } from "../../../errors";
+import { SourceResolver } from "../../../io";
 import {
   normalizeRuntimeInvokeRequest,
   parseRuntimeInvokeHeaders,
   resolveRuntimeInvokeSources,
+  resolveRuntimeInvokeTuiBearerToken,
 } from "./request";
 
 const REGION = "us-west-2";
@@ -86,6 +88,30 @@ describe("resolveRuntimeInvokeSources", () => {
   });
 });
 
+test("brands TUI bearer-token file failures as input errors", async () => {
+  const missing = `file:///tmp/missing-runtime-token-${process.pid}`;
+  const error = await resolveRuntimeInvokeTuiBearerToken(missing, stdin(new Uint8Array())).catch(
+    (error) => error,
+  );
+
+  expect(error).toBeInstanceOf(InputValidationError);
+  expect(error.message).toContain("could not read '--bearer-token' from file");
+  expect(error.cause).toBeInstanceOf(SourceResolutionError);
+});
+
+test("preserves unexpected TUI bearer-token source failures", async () => {
+  const failure = new TypeError("source failed");
+  const resolve = spyOn(SourceResolver.prototype, "resolveText").mockRejectedValue(failure);
+
+  try {
+    await expect(resolveRuntimeInvokeTuiBearerToken("token", stdin(new Uint8Array()))).rejects.toBe(
+      failure,
+    );
+  } finally {
+    resolve.mockRestore();
+  }
+});
+
 describe("parseRuntimeInvokeHeaders", () => {
   test("brands validation failures as input errors", () => {
     expect(() => parseRuntimeInvokeHeaders(["missing separator"])).toThrow(InputValidationError);
diff --git a/src/handlers/runtime/invoke/request.ts b/src/handlers/runtime/invoke/request.ts
index 5f53c21f3..4da78c5ac 100644
--- a/src/handlers/runtime/invoke/request.ts
+++ b/src/handlers/runtime/invoke/request.ts
@@ -56,6 +56,25 @@ export async function resolveRuntimeInvokeSources(
   }
 }
 
+export async function resolveRuntimeInvokeTuiBearerToken(
+  source: string | undefined,
+  stdin: NodeJS.ReadStream,
+): Promise<string | undefined> {
+  if (source === "-") {
+    throw new InputValidationError(
+      "stdin bearer tokens are not available when launching the interactive console",
+    );
+  }
+  try {
+    return await new SourceResolver({ stdin }).resolveText("bearer-token", source);
+  } catch (error) {
+    if (error instanceof SourceResolutionError) {
+      throw new InputValidationError(error.message, { cause: error });
+    }
+    throw error;
+  }
+}
+
 export function parseRuntimeInvokeHeaders(values: string[] = []): [string, string][] {
   const seen = new Set<string>();
 
diff --git a/src/handlers/runtime/invoke/screen.tsx b/src/handlers/runtime/invoke/screen.tsx
new file mode 100644
index 000000000..19e80904b
--- /dev/null
+++ b/src/handlers/runtime/invoke/screen.tsx
@@ -0,0 +1,418 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Box, Text, useInput, useWindowSize } from "ink";
+import { useQuery } from "@tanstack/react-query";
+import { useNavigate, useParams } from "react-router";
+import { ScrollView, type ScrollViewRef } from "ink-scroll-view";
+import cliTruncate from "cli-truncate";
+import { InputValidationError } from "../../../errors";
+import type { ScreenProps } from "../../types";
+import { coreOptsFromCtx } from "../../utils";
+import { Layout } from "../../../components/Layout";
+import { RuntimeEndpointPicker } from "../../../components/RuntimeEndpointPicker";
+import { RuntimePicker } from "../../../components/RuntimePicker";
+import { darkTheme } from "../../../components/ui/_core.js";
+import { Divider } from "../../../components/ui/divider";
+import { Spinner } from "../../../components/ui/spinner";
+import type { RuntimeInvokeResponse } from "../types";
+import { normalizeRuntimeInvokeRequest } from "./request";
+import { RuntimePayloadInput } from "./RuntimePayloadInput";
+import { classifyRuntimeResponse } from "./response";
+import { RuntimeInvokeLaunchContextKey, type RuntimeInvokeLaunchContext } from "./launchContext";
+
+const theme = darkTheme;
+
+type ExchangeState = "connecting" | "streaming" | "complete" | "interrupted" | "failed";
+
+type TargetPickerState = { stage: "runtime" } | { stage: "endpoint"; runtimeId: string };
+
+interface Exchange {
+  payload: string;
+  response: string;
+  pretty?: string;
+  note?: string;
+  heading?: string;
+  metadata?: string;
+  byteCount: number;
+  state: ExchangeState;
+}
+
+const invokePath = (...parts: string[]) =>
+  ["/agentcore/runtime/invoke", ...parts.map(encodeURIComponent)].join("/");
+
+const metadata = (response: RuntimeInvokeResponse) =>
+  [
+    ["Session ID:", response.runtimeSessionId],
+    ["MCP session ID:", response.mcpSessionId],
+    ["MCP protocol version:", response.mcpProtocolVersion],
+    ["trace", response.traceId],
+    ["traceparent", response.traceParent],
+    ["tracestate", response.traceState],
+    ["baggage", response.baggage],
+  ]
+    .filter((entry) => entry[1])
+    .map((entry) => entry.join(" "))
+    .join(" · ");
+
+export function RuntimeInvokeScreen(props: ScreenProps) {
+  const { runtimeId, qualifier } = useParams();
+  const navigate = useNavigate();
+  const launchContext = props.ctx.value(RuntimeInvokeLaunchContextKey);
+  const initialContext = launchContext?.runtimeId === runtimeId ? launchContext : undefined;
+
+  if (!runtimeId) {
+    return (
+      <RuntimePicker
+        {...props}
+        breadcrumb={["agentcore", "runtime", "invoke"]}
+        description="choose a Runtime to invoke"
+        onSelect={(id) => navigate(invokePath(id))}
+      />
+    );
+  }
+
+  if (!qualifier) {
+    return (
+      <RuntimeEndpointPicker
+        {...props}
+        runtimeId={runtimeId}
+        breadcrumb={["agentcore", "runtime", "invoke", runtimeId]}
+        description="choose an endpoint to invoke"
+        onSelect={(selected) => navigate(invokePath(runtimeId, selected))}
+        onEscape={() => navigate(invokePath())}
+      />
+    );
+  }
+
+  return (
+    <RuntimeInvokeConsole
+      {...props}
+      runtimeId={runtimeId}
+      qualifier={qualifier}
+      initialContext={initialContext}
+    />
+  );
+}
+
+type RuntimeInvokeConsoleProps = ScreenProps & {
+  runtimeId: string;
+  qualifier: string;
+  initialContext?: RuntimeInvokeLaunchContext;
+};
+
+function RuntimeInvokeConsole({
+  ctx,
+  core,
+  runtimeId,
+  qualifier,
+  initialContext,
+}: RuntimeInvokeConsoleProps) {
+  const opts = coreOptsFromCtx(ctx);
+  const { columns, rows } = useWindowSize();
+  const [target, setTarget] = useState({ runtimeId, qualifier });
+  const [targetPicker, setTargetPicker] = useState<TargetPickerState | null>(null);
+  const detail = useQuery({
+    queryKey: ["runtime", opts.region, target.runtimeId],
+    queryFn: ({ signal }) => core.runtime.getRuntime(target.runtimeId, opts, signal),
+  });
+  const mcp = detail.data?.protocolConfiguration?.serverProtocol === "MCP";
+  const [payload, setPayload] = useState("");
+  const [inputError, setInputError] = useState<string>();
+  const [requestContext, setRequestContext] = useState(initialContext);
+  const [runtimeSessionId, setRuntimeSessionId] = useState(initialContext?.runtimeSessionId);
+  const [mcpSessionId, setMcpSessionId] = useState<string>();
+  const [mcpProtocolVersion, setMcpProtocolVersion] = useState<string>();
+  const [history, setHistory] = useState<Exchange[]>([]);
+  const [prettyJson, setPrettyJson] = useState(false);
+  const abortRef = useRef<AbortController | null>(null);
+  const scrollRef = useRef<ScrollViewRef>(null);
+  const stickRef = useRef(true);
+  const keepScrolledToBottom = useCallback(() => {
+    if (stickRef.current) scrollRef.current?.scrollToBottom();
+  }, []);
+
+  useEffect(() => () => abortRef.current?.abort(), []);
+
+  const updateExchange = (patch: Partial<Exchange>) => {
+    setHistory((current) => current.slice(0, -1).concat({ ...current.at(-1)!, ...patch }));
+  };
+
+  const send = async () => {
+    if (abortRef.current || !detail.data) return;
+    const requestPayload = payload;
+    try {
+      JSON.parse(requestPayload);
+    } catch {
+      setInputError("Enter a valid JSON payload");
+      return;
+    }
+
+    setInputError(undefined);
+    stickRef.current = true;
+    const appendExchange = (response: string, state: ExchangeState) =>
+      setHistory((current) => [
+        ...current,
+        { payload: requestPayload, response, byteCount: 0, state },
+      ]);
+    setPayload("");
+    appendExchange("", "connecting");
+    setPrettyJson(false);
+    const controller = new AbortController();
+    abortRef.current = controller;
+    let responseStarted = false;
+
+    try {
+      const request = normalizeRuntimeInvokeRequest(detail.data, {
+        runtimeId: target.runtimeId,
+        qualifier: target.qualifier,
+        payload: new TextEncoder().encode(requestPayload),
+        contentType: "application/json",
+        runtimeSessionId,
+        runtimeUserId: requestContext?.runtimeUserId,
+        applicationHeaders: requestContext?.applicationHeaders,
+        bearerToken: requestContext?.bearerToken,
+        ...(mcp && { mcpSessionId, mcpProtocolVersion }),
+      });
+      const response = await core.runtime.invokeRuntime(request, opts, controller.signal);
+      responseStarted = true;
+      updateExchange({
+        heading: `Response · ${response.statusCode} · ${response.contentType || "-"}`,
+        metadata: metadata(response),
+        state: "streaming",
+      });
+      let byteCount = 0;
+      const kind = classifyRuntimeResponse(response.contentType);
+      if (kind === "binary") {
+        controller.abort();
+        updateExchange({
+          response: "Binary or unknown responses require headless invoke with --output-file.",
+          state: "failed",
+        });
+        return;
+      }
+      const decoder = new TextDecoder();
+      const chunks: Uint8Array[] = [];
+      let responseText = "";
+      for await (const chunk of response.body) {
+        const snapshot = Uint8Array.from(chunk);
+        chunks.push(snapshot);
+        byteCount += snapshot.byteLength;
+        responseText += decoder.decode(snapshot, { stream: true });
+        updateExchange({
+          response: responseText,
+          byteCount,
+        });
+      }
+      responseText += decoder.decode();
+      updateExchange({ response: responseText });
+      let text: string | undefined;
+      try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks));
+      } catch {
+        updateExchange({ note: "Invalid UTF-8 response; showing raw text." });
+      }
+      if (kind === "json" && text !== undefined) {
+        try {
+          const pretty = JSON.stringify(JSON.parse(text), null, 2);
+          updateExchange({ pretty });
+        } catch {
+          updateExchange({ note: "Invalid JSON response; showing raw text." });
+        }
+      }
+      if (response.runtimeSessionId) setRuntimeSessionId(response.runtimeSessionId);
+      if (response.mcpSessionId) setMcpSessionId(response.mcpSessionId);
+      if (response.mcpProtocolVersion) setMcpProtocolVersion(response.mcpProtocolVersion);
+      updateExchange({ state: "complete" });
+    } catch (error) {
+      if (controller.signal.aborted || (error as Error)?.name === "AbortError") {
+        updateExchange({ note: "interrupted", state: "interrupted" });
+      } else if (error instanceof InputValidationError) {
+        updateExchange({ response: `Error: ${error.message}`, state: "failed" });
+      } else if (!responseStarted && error instanceof Error) {
+        updateExchange({ note: error.message, state: "failed" });
+      } else {
+        updateExchange({ note: "response stream failed", state: "failed" });
+      }
+    } finally {
+      abortRef.current = null;
+    }
+  };
+
+  const liveState = history.at(-1)?.state;
+  const busy = liveState === "connecting" || liveState === "streaming";
+  const inputRows = Math.min(4, Math.max(1, payload.split("\n").length));
+  const transcriptHeight = Math.max(1, rows - 8 - inputRows);
+  const canPrettyJson = history.some((exchange) => exchange.pretty !== undefined);
+  const requestContextSummary = [
+    requestContext?.runtimeUserId ? "user" : undefined,
+    requestContext?.bearerToken ? "JWT" : undefined,
+    requestContext?.applicationHeaders?.length
+      ? `${requestContext.applicationHeaders.length}h`
+      : undefined,
+  ]
+    .filter(Boolean)
+    .join("/");
+
+  useInput(
+    (input, key) => {
+      if (key.ctrl) {
+        if (input === "v" && !abortRef.current) setPrettyJson((current) => !current);
+        else if (input === "t" && !abortRef.current) setTargetPicker({ stage: "runtime" });
+        return;
+      }
+      if (key.escape) {
+        if (abortRef.current) abortRef.current.abort();
+        else setTargetPicker({ stage: "endpoint", runtimeId: target.runtimeId });
+        return;
+      }
+      const view = scrollRef.current;
+      if (!view) return;
+      if (key.upArrow) {
+        const offset = view.getScrollOffset();
+        const next = Math.max(0, offset - 1);
+        view.scrollTo(next);
+        if (next < view.getBottomOffset()) stickRef.current = false;
+      }
+      if (key.downArrow) {
+        const offset = view.getScrollOffset();
+        const bottom = view.getBottomOffset();
+        const next = Math.min(bottom, offset + 1);
+        view.scrollTo(next);
+        if (next >= bottom) stickRef.current = true;
+      }
+    },
+    { isActive: targetPicker === null },
+  );
+
+  if (targetPicker?.stage === "runtime") {
+    return (
+      <RuntimePicker
+        ctx={ctx}
+        core={core}
+        breadcrumb={["agentcore", "runtime", "invoke"]}
+        description="choose another Runtime"
+        onSelect={(selectedRuntimeId) =>
+          setTargetPicker({ stage: "endpoint", runtimeId: selectedRuntimeId })
+        }
+        onEscape={() => setTargetPicker(null)}
+      />
+    );
+  }
+
+  if (targetPicker?.stage === "endpoint") {
+    const nextRuntimeId = targetPicker.runtimeId;
+    return (
+      <RuntimeEndpointPicker
+        ctx={ctx}
+        core={core}
+        runtimeId={nextRuntimeId}
+        breadcrumb={["agentcore", "runtime", "invoke", nextRuntimeId]}
+        description="choose another endpoint"
+        onSelect={(selected) => {
+          if (nextRuntimeId !== target.runtimeId || selected !== target.qualifier) {
+            const runtimeChanged = nextRuntimeId !== target.runtimeId;
+            setTarget({ runtimeId: nextRuntimeId, qualifier: selected });
+            setRuntimeSessionId(undefined);
+            setMcpSessionId(undefined);
+            setMcpProtocolVersion(undefined);
+            if (runtimeChanged) setRequestContext(undefined);
+            setHistory([]);
+            setPrettyJson(false);
+            setInputError(undefined);
+          }
+          setTargetPicker(null);
+        }}
+        onEscape={() => setTargetPicker({ stage: "runtime" })}
+      />
+    );
+  }
+
+  return (
+    <Layout
+      breadcrumb={["agentcore", "runtime", "invoke", target.runtimeId, target.qualifier]}
+      keyHints={
+        busy
+          ? [
+              { key: "esc", label: "interrupt" },
+              { key: "↑↓", label: "scroll" },
+              { key: "ctl+c", label: "quit" },
+            ]
+          : [
+              { key: "enter", label: "send" },
+              ...(canPrettyJson
+                ? [
+                    {
+                      key: "ctl+v",
+                      label: prettyJson ? "raw JSON" : "pretty JSON",
+                    },
+                  ]
+                : [{ key: "⇧↵", label: "newline" }]),
+              { key: "ctl+t", label: "target" },
+              { key: "↑↓", label: "scroll" },
+              { key: "esc", label: "back" },
+              { key: "ctl+c", label: "quit" },
+            ]
+      }
+    >
+      <Box height="100%" flexDirection="column">
+        {detail.isPending ? (
+          <Spinner label="Loading Runtime…" />
+        ) : detail.isError ? (
+          <Text color="red">Error: {(detail.error as Error).message}</Text>
+        ) : (
+          <Box flexDirection="column">
+            <Box height={transcriptHeight} flexDirection="column">
+              <ScrollView ref={scrollRef} onContentHeightChange={keepScrolledToBottom}>
+                {history.map((exchange, index) => (
+                  <Box key={index} flexDirection="column" paddingBottom={1}>
+                    <Text bold>Request</Text>
+                    <Text>{exchange.payload}</Text>
+                    <Text bold>{exchange.heading ?? "Response"}</Text>
+                    <Text>
+                      {prettyJson && exchange.pretty ? exchange.pretty : exchange.response}
+                    </Text>
+                    {exchange.state !== "connecting" && exchange.state !== "streaming" ? (
+                      <>
+                        {exchange.metadata ? <Text color="gray">{exchange.metadata}</Text> : null}
+                        {exchange.note ? <Text color="yellow">{exchange.note}</Text> : null}
+                        <Text color={exchange.state === "failed" ? "red" : "gray"}>
+                          {exchange.state} · {exchange.byteCount} bytes
+                        </Text>
+                      </>
+                    ) : null}
+                  </Box>
+                ))}
+              </ScrollView>
+            </Box>
+            <Divider />
+            <RuntimePayloadInput
+              value={payload}
+              onChange={(value) => {
+                setPayload(value);
+                setInputError(undefined);
+              }}
+              onSubmit={() => void send()}
+              submitDisabled={busy}
+            />
+            <Divider />
+            <Box height={1}>
+              {inputError ? (
+                <Text color="red">{inputError}</Text>
+              ) : busy ? (
+                <Spinner label={`${liveState}… (esc to interrupt)`} />
+              ) : (
+                <Text color={theme.colors.muted}>
+                  {cliTruncate(
+                    `Ready · Session ID: ${runtimeSessionId ?? "Not set"}${
+                      mcp ? ` · MCP session ID: ${mcpSessionId ?? "Not set"}` : ""
+                    }${requestContextSummary ? ` · Context ${requestContextSummary}` : ""}`,
+                    columns,
+                  )}
+                </Text>
+              )}
+            </Box>
+          </Box>
+        )}
+      </Box>
+    </Layout>
+  );
+}
diff --git a/src/testing/renderScreen.tsx b/src/testing/renderScreen.tsx
index 9e10ac754..f638bb6cb 100644
--- a/src/testing/renderScreen.tsx
+++ b/src/testing/renderScreen.tsx
@@ -61,6 +61,8 @@ export interface RenderScreenOptions {
   core?: TestCoreClient;
   // ctx overrides the base context (rarely needed).
   ctx?: Context;
+  // withContext adds screen-specific launch values to the otherwise real base context.
+  withContext?: (ctx: Context) => Context;
   // queryClient overrides the deterministic default when a test needs to
   // exercise cache behavior.
   queryClient?: QueryClient;
@@ -122,7 +124,8 @@ export function cleanupScreens(): void {
 // and returns handles to read frames and send input.
 export function renderScreen(path: string, options: RenderScreenOptions = {}): RenderScreenResult {
   const core = options.core ?? new TestCoreClient();
-  const ctx = options.ctx ?? baseContext(core, options.endpointUrl);
+  const base = options.ctx ?? baseContext(core, options.endpointUrl);
+  const ctx = options.withContext?.(base) ?? base;
   const queryClient = options.queryClient ?? testQueryClient();
 
   const instance = render(<></>);