@@ -13,6 +13,8 @@ import {
   ProviderDriverKind,
   ProviderInstanceId,
   retainedTerminalHistory,
+  terminalSequenceEnd,
+  terminalSequenceStateAfter,
   TerminalProviderInstanceNotFoundError,
 } from "@t3tools/contracts";
 import * as HostProcess from "@t3tools/shared/HostProcess";
@@ -337,7 +339,6 @@ function retainedHistory(text: string, maxLines: number, maxBytes = Infinity): s
   if (terminated) lines.pop();
   const retained = lines.slice(Math.max(0, lines.length - maxLines)).join("\n");
   const capped = terminated ? `${retained}\n` : retained;
-  if (Buffer.byteLength(capped) <= maxBytes) return capped;
   const points = Array.from(capped);
   let start = points.length;
   let bytes = 0;
@@ -347,7 +348,11 @@ function retainedHistory(text: string, maxLines: number, maxBytes = Infinity): s
     bytes += next;
     start -= 1;
   }
-  return points.slice(start).join("");
+  const kept = points.slice(start).join("");
+  if (maxLines <= 0 || maxBytes <= 0) return kept;
+  // A cut inside a control sequence drops the rest of that sequence too.
+  const state = terminalSequenceStateAfter(0, text, 0, text.length - kept.length);
+  return kept.slice(terminalSequenceEnd(state, kept));
 }
 
 it("preserves line and byte limits across arbitrary chunks, Unicode, ANSI sequences, and clear", () => {
@@ -365,6 +370,10 @@ it("preserves line and byte limits across arbitrary chunks, Unicode, ANSI sequen
     "\u001b[31m",
     "\u001b[0m",
     "\u001b]8;;url\u0007",
+    "\u001b]0;",
+    "\u001bP",
+    "\u0007",
+    "\u001b\\",
     "\ud83d",
     "\ude80",
   ];
@@ -375,7 +384,8 @@ it("preserves line and byte limits across arbitrary chunks, Unicode, ANSI sequen
 
   for (const maxBytes of [0, 3, 8, 64, Infinity]) {
     for (const maxLines of [0, 1, 3, 5, 5_000]) {
-      let expected = retainedHistory("before\ninitial\n", maxLines, maxBytes);
+      let full = "before\ninitial\n";
+      let expected = retainedHistory(full, maxLines, maxBytes);
       const history = new TerminalManager.BoundedTerminalHistory(
         maxLines,
         "before\ninitial\n",
@@ -386,24 +396,30 @@ it("preserves line and byte limits across arbitrary chunks, Unicode, ANSI sequen
       for (let step = 0; step < 300; step += 1) {
         if (step % 73 === 0) {
           history.clear();
-          expected = "";
-          expect(history.value()).toBe(expected);
+          full = "";
+          expect(history.value()).toBe("");
         }
         const chunk = nextFragment() + nextFragment();
         history.append(chunk);
-        expected = retainedHistory(expected + chunk, maxLines, maxBytes);
+        full += chunk;
+        expected = retainedHistory(full, maxLines, maxBytes);
         expect(history.value()).toBe(expected);
       }
     }
   }
 });
 
 it("does not retain the tail of a control sequence whose introducer was trimmed", () => {
-  for (const [text, maxBytes] of [
-    ["prefix\u001b[31mOK", 6],
-    ["prefix\u001b]0;HIDDEN\u0007OK", 10],
+  for (const [text, maxBytes, retained] of [
+    ["prefix\u001b[31mOK", 6, "OK"],
+    ["prefix\u001b]0;HIDDEN\u0007OK", 10, "OK"],
+    ["prefix\u001b]0;🙂HIDDEN\u0007OK", 9, "OK"],
+    // libghostty leaves every string but OSC at the emoji's second byte, so HELLO was visible.
+    ["prefix\u001bP🙂HELLO\u001b\\OK", 9, "HELLO\u001b\\OK"],
   ] as const) {
-    expect(new TerminalManager.BoundedTerminalHistory(5_000, text, maxBytes).value()).toBe("OK");
+    expect(new TerminalManager.BoundedTerminalHistory(5_000, text, maxBytes).value()).toBe(
+      retained,
+    );
   }
 });
 
 
@@ -6,6 +6,9 @@ import {
   DEFAULT_TERMINAL_ID,
   DEFAULT_MAX_TERMINAL_BUFFER_BYTES,
   retainedTerminalHistory,
+  TERMINAL_SEQUENCE_GROUND,
+  terminalSequenceEnd,
+  terminalSequenceStateAfter,
   TerminalCwdError,
   TerminalCwdNotDirectoryError,
   TerminalCwdNotFoundError,
@@ -888,6 +891,14 @@ interface TerminalHistoryPersistenceCursor {
   readonly fileBytes: number;
 }
 
+function countLineBreaks(data: string): number {
+  let lineBreaks = 0;
+  for (let index = data.indexOf("\n"); index !== -1; index = data.indexOf("\n", index + 1)) {
+    lineBreaks += 1;
+  }
+  return lineBreaks;
+}
+
 export class BoundedTerminalHistory {
   private readonly maxLines: number;
   private readonly maxBytes: number;
@@ -897,6 +908,8 @@ export class BoundedTerminalHistory {
   private lineBreaks = 0;
   // Reading the old string's tail on each append can force chunk concatenation.
   private lastCodeUnit: number | undefined;
+  // The terminal parser's state at the first retained code unit, which is where a replay starts.
+  private sequenceState = TERMINAL_SEQUENCE_GROUND;
   private cachedValue: string | null = "";
   private generation = 0;
   private appendedLength = 0;
@@ -961,10 +974,7 @@ export class BoundedTerminalHistory {
 
   private appendChunk(data: string): void {
     const byteLength = Buffer.byteLength(data);
-    let lineBreaks = 0;
-    for (let index = data.indexOf("\n"); index !== -1; index = data.indexOf("\n", index + 1)) {
-      lineBreaks += 1;
-    }
+    const lineBreaks = countLineBreaks(data);
     const previous = this.chunks.at(-1);
     if (previous && previous.data.length + data.length <= MAX_HISTORY_CHUNK_LENGTH) {
       previous.data += data;
@@ -981,6 +991,7 @@ export class BoundedTerminalHistory {
 
   private discardChunk(): void {
     const first = this.chunks[this.start]!;
+    this.sequenceState = terminalSequenceStateAfter(this.sequenceState, first.data);
     this.byteLength -= first.byteLength;
     this.lineBreaks -= first.lineBreaks;
     this.chunks[this.start++] = undefined;
@@ -992,6 +1003,7 @@ export class BoundedTerminalHistory {
       this.discardChunk();
       return;
     }
+    this.sequenceState = terminalSequenceStateAfter(this.sequenceState, first.data, 0, offset);
     first.data = first.data.slice(offset);
     first.byteLength -= byteLength;
     first.lineBreaks -= lineBreaks;
@@ -1039,6 +1051,12 @@ export class BoundedTerminalHistory {
       }
       this.trimChunk(offset, bytes, lineBreaks);
     }
+    // A cut inside a control sequence would replay the rest of it as text.
+    while (this.sequenceState !== TERMINAL_SEQUENCE_GROUND && this.start < this.chunks.length) {
+      const first = this.chunks[this.start]!;
+      const dropped = first.data.slice(0, terminalSequenceEnd(this.sequenceState, first.data));
+      this.trimChunk(dropped.length, Buffer.byteLength(dropped), countLineBreaks(dropped));
+    }
     if (
       this.start === this.chunks.length ||
       (this.start > 2_048 && this.start * 2 >= this.chunks.length)
@@ -1057,6 +1075,7 @@ export class BoundedTerminalHistory {
     this.byteLength = 0;
     this.lineBreaks = 0;
     this.lastCodeUnit = undefined;
+    this.sequenceState = TERMINAL_SEQUENCE_GROUND;
     this.cachedValue = "";
   }
 
 
@@ -1,4 +1,9 @@
-import { retainedTerminalHistory } from "@t3tools/contracts";
+import {
+  retainedTerminalHistory,
+  TERMINAL_SEQUENCE_GROUND,
+  terminalSequenceEnd,
+  terminalSequenceStateAfter,
+} from "@t3tools/contracts";
 
 export interface TerminalOutputChunk {
   readonly startOffset: number;
@@ -12,18 +17,24 @@ export interface TerminalOutputState {
   readonly retainedBytes: number;
   readonly resetVersion: number;
   readonly nextOffset: number;
+  // The terminal parser's state at the first retained code unit. Trimming can cut a control
+  // sequence, and a replay has to skip the rest of it instead of printing it.
+  readonly sequenceState: number;
 }
 
 export interface TerminalOutputCursor {
   readonly generation: number;
   readonly resetVersion: number;
   readonly offset: number;
+  // The cut control sequence still open at `offset`, which the reader's terminal never entered.
+  readonly sequenceState: number;
 }
 
 export const INITIAL_TERMINAL_OUTPUT_CURSOR = Object.freeze<TerminalOutputCursor>({
   generation: -1,
   resetVersion: -1,
   offset: 0,
+  sequenceState: TERMINAL_SEQUENCE_GROUND,
 });
 
 export type TerminalOutputUpdate =
@@ -54,6 +65,7 @@ export const EMPTY_TERMINAL_OUTPUT_STATE = Object.freeze<TerminalOutputState>({
   retainedBytes: 0,
   resetVersion: 0,
   nextOffset: 0,
+  sequenceState: TERMINAL_SEQUENCE_GROUND,
 });
 
 interface Utf8Chunk {
@@ -175,6 +187,7 @@ function appendOutput(
       retainedBytes: 0,
       resetVersion: current.resetVersion + 1,
       nextOffset: current.nextOffset + data.length,
+      sequenceState: TERMINAL_SEQUENCE_GROUND,
     };
   }
   const appended = splitOutputChunks(
@@ -185,12 +198,19 @@ function appendOutput(
 
   const chunks = [...current.chunks, ...appended.chunks];
   let retainedBytes = current.retainedBytes + appended.byteLength;
+  let sequenceState = current.sequenceState;
   let firstRetainedIndex = 0;
   while (retainedBytes > maxBufferBytes && firstRetainedIndex < chunks.length) {
     const first = chunks[firstRetainedIndex]!;
     const bytesToDrop = retainedBytes - maxBufferBytes;
     if (bytesToDrop < first.byteLength) {
       const trimmed = trimOutputChunkStart(first, bytesToDrop);
+      sequenceState = terminalSequenceStateAfter(
+        sequenceState,
+        first.data,
+        0,
+        first.data.length - trimmed.data.length,
+      );
       retainedBytes -= first.byteLength - trimmed.byteLength;
       if (trimmed.byteLength > 0) {
         chunks[firstRetainedIndex] = trimmed;
@@ -199,6 +219,7 @@ function appendOutput(
       }
       break;
     }
+    sequenceState = terminalSequenceStateAfter(sequenceState, first.data);
     retainedBytes -= first.byteLength;
     firstRetainedIndex += 1;
   }
@@ -209,6 +230,7 @@ function appendOutput(
     const excessChunks = retainedChunks.length - MAX_TERMINAL_OUTPUT_CHUNKS;
     if (excessChunks > 0) {
       for (const chunk of retainedChunks.slice(0, excessChunks)) {
+        sequenceState = terminalSequenceStateAfter(sequenceState, chunk.data);
         retainedBytes -= chunk.byteLength;
       }
       retainedChunks = retainedChunks.slice(excessChunks);
@@ -221,6 +243,7 @@ function appendOutput(
     retainedBytes,
     resetVersion: current.resetVersion,
     nextOffset: appended.nextOffset,
+    sequenceState,
   };
 }
 
@@ -241,18 +264,21 @@ function resetOutput(
     retainedBytes: reset.byteLength,
     resetVersion: current.resetVersion + 1,
     nextOffset: reset.nextOffset,
+    sequenceState: TERMINAL_SEQUENCE_GROUND,
   };
 }
 
+/** The retained output a fresh terminal can replay: it starts outside any control sequence. */
 export function terminalOutputText(output: TerminalOutputState): string {
-  return output.chunks.map((chunk) => chunk.data).join("");
+  const text = output.chunks.map((chunk) => chunk.data).join("");
+  return text.slice(terminalSequenceEnd(output.sequenceState, text));
 }
 
 export function readTerminalOutputUpdate(
   output: TerminalOutputState,
   cursor: TerminalOutputCursor,
 ): TerminalOutputUpdate {
-  const nextCursor = {
+  const position = {
     generation: output.generation,
     resetVersion: output.resetVersion,
     offset: output.nextOffset,
@@ -263,7 +289,16 @@ export function readTerminalOutputUpdate(
     cursor.resetVersion !== output.resetVersion ||
     cursor.offset < (firstChunk?.startOffset ?? output.nextOffset)
   ) {
-    return { type: "reset", data: terminalOutputText(output), cursor: nextCursor };
+    const text = output.chunks.map((chunk) => chunk.data).join("");
+    const start = terminalSequenceEnd(output.sequenceState, text);
+    return {
+      type: "reset",
+      data: text.slice(start),
+      cursor: {
+        ...position,
+        sequenceState: terminalSequenceStateAfter(output.sequenceState, text, 0, start),
+      },
+    };
   }
 
   // Appends and compaction preserve offset order, so unread chunks form a suffix.
@@ -273,17 +308,19 @@ export function readTerminalOutputUpdate(
     if (!(chunk.startOffset + chunk.data.length > cursor.offset)) break;
     firstUnread -= 1;
   }
-  const appended = output.chunks.slice(firstUnread);
-  if (appended.length === 0) {
+  const text = output.chunks
+    .slice(firstUnread)
+    .map((chunk) => chunk.data.slice(Math.max(0, cursor.offset - chunk.startOffset)))
+    .join("");
+  const start = terminalSequenceEnd(cursor.sequenceState, text);
+  const nextCursor = {
+    ...position,
+    sequenceState: terminalSequenceStateAfter(cursor.sequenceState, text, 0, start),
+  };
+  if (start === text.length) {
     return { type: "none", cursor: nextCursor };
   }
-  return {
-    type: "append",
-    data: appended
-      .map((chunk) => chunk.data.slice(Math.max(0, cursor.offset - chunk.startOffset)))
-      .join(""),
-    cursor: nextCursor,
-  };
+  return { type: "append", data: text.slice(start), cursor: nextCursor };
 }
 
 export { appendOutput, resetOutput };
@@ -160,16 +160,43 @@ describe("terminal session reducers", () => {
   });
 
   it("does not retain the tail of a control sequence whose introducer was trimmed", () => {
-    for (const [history, maxBytes] of [
-      ["prefix\u001b[31mOK", 6],
-      ["prefix\u001b]0;HIDDEN\u0007OK", 10],
+    for (const [history, maxBytes, replayable] of [
+      ["prefix\u001b[31mOK", 6, /^(?:[a-z]*\u001b\[31mOK|O?K?)$/],
+      ["prefix\u001b]0;HIDDEN\u0007OK", 10, /^(?:[a-z]*\u001b\]0;HIDDEN\u0007OK|O?K?)$/],
+      ["prefix\u001b]0;HIDDEN\u0007OK", 4, /^(?:[a-z]*\u001b\]0;HIDDEN\u0007OK|O?K?)$/],
     ] as const) {
       const state = applyTerminalAttachStreamEvent(
         EMPTY_TERMINAL_BUFFER_STATE,
         { type: "snapshot", snapshot: { ...BASE_SNAPSHOT, history } },
         maxBytes,
       );
       expect(terminalOutputText(state.output)).toBe("OK");
+
+      // The same text as live output: a mounted terminal still receives every byte, while one
+      // that mounts later, even inside the sequence, never prints the rest of it.
+      let live = applyTerminalAttachStreamEvent(
+        EMPTY_TERMINAL_BUFFER_STATE,
+        { type: "snapshot", snapshot: { ...BASE_SNAPSHOT, history: "" } },
+        maxBytes,
+      );
+      const readers = [{ cursor: INITIAL_TERMINAL_OUTPUT_CURSOR, written: "" }];
+      for (const data of history) {
+        live = applyTerminalAttachStreamEvent(
+          live,
+          { type: "output", threadId: TARGET.threadId, terminalId: TARGET.terminalId, data },
+          maxBytes,
+        );
+        readers.push({ cursor: INITIAL_TERMINAL_OUTPUT_CURSOR, written: "" });
+        for (const reader of readers) {
+          const update = readTerminalOutputUpdate(live.output, reader.cursor);
+          if (update.type === "reset") reader.written = update.data;
+          if (update.type === "append") reader.written += update.data;
+          reader.cursor = update.cursor;
+        }
+      }
+      expect(readers[0]!.written).toBe(history);
+      for (const reader of readers) expect(reader.written).toMatch(replayable);
+      expect(terminalOutputText(live.output)).toBe("OK");
     }
   });