@@ -7338,8 +7338,13 @@ Text is its own member of that normalized union, not a key with a payload: a
 named key — submit, dismiss, traverse, move, erase — is a command whoever
 handles it recognizes, and text is content that goes wherever content goes.
 Text carries what the terminal decoded, so shifted, accented and multi-byte
-characters arrive already assembled, and a newline inside a paste arrives as
-one. A chord carries a letter in its physical key code, and reading that code
+characters arrive already assembled. The screen owns bracketed-paste mode with
+its other terminal settings. The decoder consumes framing across reads and
+publishes a completed paste as text, normalizing CR, LF and CRLF to LF. Payload
+bytes never become submission keys; deliberate keys outside the frame retain
+their meaning. Incomplete paste state belongs to that decoder's scope.
+
+A chord carries a letter in its physical key code, and reading that code
 would type the letter somebody held Control with, so a chord is dropped whole —
 payload included. Arrows, Home, End, the Page keys and Alt+Up/Down are named as
 pressed rather than dropped: they carry no text.
 
@@ -1,7 +1,11 @@
 /**
  * Turning terminal bytes into the events the tree already understands.
  *
- * The tty scanner does the decoding; this decides which decoded events the
+ * Framed paste is text, including bytes that otherwise name keyboard commands.
+ * Its payload waits for the closing marker so UTF-8 and line separators can
+ * cross reads without becoming partial text or submission keys.
+ *
+ * The tty scanner decodes ordinary input; this decides which decoded events the
  * composition layer has a meaning for and hands them over in its own closed
  * shape. Nothing here knows an action name: a normalized event says what
  * happened and where, and what it means is decided by whichever mounted node
@@ -103,9 +107,9 @@ const ALT_KEYS: ReadonlyMap<string, ReplKey> = new Map([
 ]);
 
 /**
- * The physical key a pasted newline arrives as.
+ * The physical key an unframed LF arrives as.
  *
- * A terminal sends `LF` inside a paste, and the decoder reports `LF` as
+ * An unframed newline arrives as `LF`, and the decoder reports `LF` as
  * Control-J with no text of its own. Pasting a multi-line document is the whole
  * point of an XMD draft, so this one chord is text — and it is the only chord
  * that is.
@@ -278,27 +282,96 @@ export interface ReplDecoder {
 export function useReplDecoder(
   options: { readonly escLatency?: number } = {},
 ): Operation<ReplDecoder> {
-  const settings = options.escLatency === undefined ? {} : { escLatency: options.escLatency };
+  const settings = { escLatency: options.escLatency ?? 25 };
   return resource<ReplDecoder>(function* (provide) {
     let input: Input = yield* until(createInput(settings));
+    let prefix: number[] = [];
+    let paste: number[] | undefined;
+    const opening = new TextEncoder().encode("\x1b[200~");
+    const closing = new TextEncoder().encode("\x1b[201~");
+
+    function* keys(bytes?: Uint8Array): Operation<ReplInputScan> {
+      const drained = drain(input, bytes);
+      const settling =
+        bytes === undefined && drained.pendingFor !== undefined && drained.ordered.length === 0;
+      if (!settling) {
+        return drained;
+      }
+      // The spent ESC otherwise joins the next keystroke as an Alt modifier.
+      input = yield* until(createInput(settings));
+      return Object.freeze({
+        ordered: Object.freeze([{ kind: "input", event: ESCAPE } satisfies ReplPhysicalInput]),
+        events: Object.freeze([ESCAPE]),
+        pointers: Object.freeze([]),
+        resized: drained.resized,
+        pendingFor: undefined,
+      });
+    }
+
     yield* provide({
       *scan(bytes?: Uint8Array): Operation<ReplInputScan> {
-        const drained = drain(input, bytes);
-        const settling =
-          bytes === undefined && drained.pendingFor !== undefined && drained.ordered.length === 0;
-        if (!settling) {
-          return drained;
+        const passes: ReplInputScan[] = [];
+        let ordinary: number[] = [];
+        if (bytes === undefined) {
+          if (paste === undefined && prefix.length > 0) {
+            passes.push(yield* keys(Uint8Array.from(prefix)));
+            prefix = [];
+          }
+          passes.push(yield* keys());
+        } else {
+          for (const byte of bytes) {
+            if (paste !== undefined) {
+              paste.push(byte);
+              if (
+                paste.length >= closing.length &&
+                closing.every(
+                  (one, index) => paste?.[paste.length - closing.length + index] === one,
+                )
+              ) {
+                const text = new TextDecoder()
+                  .decode(Uint8Array.from(paste.slice(0, -closing.length)))
+                  .replace(/\r\n|\r/g, "\n");
+                const event: ReplInputEvent = Object.freeze({ kind: "text", text });
+                passes.push({
+                  ordered: [{ kind: "input", event }],
+                  events: [event],
+                  pointers: [],
+                  resized: false,
+                  pendingFor: undefined,
+                });
+                paste = undefined;
+              }
+              continue;
+            }
+            if (prefix.length > 0 && byte !== opening[prefix.length]) {
+              ordinary.push(...prefix);
+              prefix = [];
+            }
+            if (byte === opening[prefix.length]) {
+              prefix.push(byte);
+              if (prefix.length === opening.length) {
+                passes.push(yield* keys(Uint8Array.from(ordinary)));
+                ordinary = [];
+                prefix = [];
+                paste = [];
+              }
+            } else {
+              ordinary.push(byte);
+            }
+          }
+          passes.push(yield* keys(Uint8Array.from(ordinary)));
         }
-        // Nothing followed the held ESC, so it was the key. A fresh scanner,
-        // because the spent byte is still in this one's buffer and would
-        // otherwise become the first byte of whatever is typed next.
-        input = yield* until(createInput(settings));
         return Object.freeze({
-          ordered: Object.freeze([{ kind: "input", event: ESCAPE } satisfies ReplPhysicalInput]),
-          events: Object.freeze([ESCAPE]),
-          pointers: Object.freeze([]),
-          resized: drained.resized,
-          pendingFor: undefined,
+          ordered: Object.freeze(passes.flatMap((pass) => pass.ordered)),
+          events: Object.freeze(passes.flatMap((pass) => pass.events)),
+          pointers: Object.freeze(passes.flatMap((pass) => pass.pointers)),
+          resized: passes.some((pass) => pass.resized),
+          pendingFor:
+            prefix.length === 1
+              ? settings.escLatency
+              : prefix.length > 1 || paste !== undefined
+                ? undefined
+                : passes.at(-1)?.pendingFor,
         });
       },
     });
 
@@ -81,6 +81,10 @@ export function replModes(): Setting {
     alternateBuffer({ clear: true }),
     cursor(false),
     mouseTracking(),
+    {
+      apply: new TextEncoder().encode("\x1b[?2004h"),
+      revert: new TextEncoder().encode("\x1b[?2004l"),
+    },
     // Level 1: disambiguated escape codes, which is what makes a lone Escape
     // decidable at all on terminals that support it.
     progressiveInput(1),
 
@@ -14,6 +14,7 @@ import { records, useHarness } from "./fixtures/repl/issue-883/sidekick-harness.
 import type { Harness } from "./fixtures/repl/issue-883/sidekick-harness.ts";
 import { awaitedFact } from "./support/mounted-repl.ts";
 import { settledReading } from "./support/mounted-history.ts";
+import { useReplDecoder } from "../src/repl/input.ts";
 import { useReplPage } from "./support/repl-page.ts";
 import {
   asked,
@@ -24,6 +25,7 @@ import {
   COMPOSER_VALUE,
   draftText,
   DRAFT_VALUE,
+  sidekickIdle,
 } from "./support/screen-journeys.ts";
 
 function service(
@@ -84,6 +86,66 @@ function fills(source: string): string {
 }
 
 describe("shared Sidekick dispatch", () => {
+  for (const busy of [false, true]) {
+    it(`keeps one pasted Message at its caret while ${busy ? "busy" : "idle"}`, function* () {
+      const page = yield* useReplPage();
+      if (busy) {
+        page.repl.fake.script({ reply: "<Output>original joined</Output>", held: true });
+        yield* sendMessage(page, "original request");
+        yield* page.repl.fake.startedTurns(1);
+      }
+      yield* intoComposer(page);
+      yield* typed(page, "beforeafter");
+      for (let at = 0; at < "after".length; at += 1) {
+        const before = page.screen().index;
+        yield* page.key("ArrowLeft");
+        yield* page.until("middle caret", (one) => one.index > before);
+      }
+      const payload = "first\n\n\t  é界🙂\nlast";
+      const raw = new TextEncoder().encode(`\x1b[200~${payload.replaceAll("\n", "\r\n")}\x1b[201~`);
+      const decoder = yield* useReplDecoder();
+      expect((yield* decoder.scan(raw)).events).toEqual([{ kind: "text", text: payload }]);
+      const initial = yield* settledReading(page.repl);
+      page.repl.terminal.bytes(raw);
+      yield* page.until(
+        "pasted tail at the middle caret",
+        (one) => one.found("lastafter", COMPOSER_VALUE) > 0,
+      );
+      expect(page.screen().shows("QUEUE 0/16")).toBe(true);
+      expect(page.repl.fake.prompts).toHaveLength(busy ? 1 : 0);
+      const pasted = yield* settledReading(page.repl);
+      expect(pasted.chat.filter((one) => one.kind === "message")).toEqual(
+        initial.chat.filter((one) => one.kind === "message"),
+      );
+      expect(pasted.model.entries).toEqual(initial.model.entries);
+      if (busy) {
+        page.repl.fake.releaseTurn();
+        yield* page.until(
+          "joined idle without queued paste",
+          (one) => sidekickIdle(one) && one.shows("original joined"),
+        );
+        expect(page.screen().found("lastafter", COMPOSER_VALUE)).toBe(1);
+        expect(page.screen().shows("QUEUE 0/16")).toBe(true);
+        expect(page.repl.fake.prompts).toHaveLength(1);
+        expect(
+          (yield* settledReading(page.repl)).chat.filter((one) => one.kind === "message"),
+        ).toHaveLength(1);
+      }
+      page.repl.fake.script({ reply: "<Output>paste submitted once</Output>" });
+      yield* page.key("Enter");
+      yield* page.until(
+        "one deliberate full submission",
+        (one) => sidekickIdle(one) && one.shows("paste submitted once"),
+      );
+      const after = yield* settledReading(page.repl);
+      const messages = after.chat.filter((one) => one.kind === "message");
+      expect(messages).toHaveLength(busy ? 2 : 1);
+      expect(messages.at(-1)?.text).toBe(`before${payload}after`);
+      expect(page.repl.fake.prompts).toHaveLength(busy ? 2 : 1);
+      expect(after.model.entries).toEqual(initial.model.entries);
+    });
+  }
+
   it("keeps the mounted UI's real controls, generated entry and final answer", function* () {
     const page = yield* useReplPage();
     const repl = page.repl;