perf(terminal): eliminate adverse control and frame-gate cases (#11045)

* perf(terminal): eliminate dense control and frame gate regressions

* test(terminal): keep gate labels in valid expect shape

* test(terminal): expose the surviving sub-threshold control-density case

The only adverse strip fixture sat at 50% control density, which is exactly
where the fallback fires and wins. A shape at 31 controls per 64-unit block
evades the trigger and still loses to the per-character legacy (0.67x), so the
benchmark structurally could not show it.

Add that fixture, pin both density literals in the staleness guard so a retune
fails loudly instead of silently measuring a boundary that moved, and export
the probe constant the equivalence test was hardcoding.

src/shared/command-code-output-status.test.ts

@@ -1,5 +1,8 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
-import { createCommandCodeOutputStatusDetector } from './command-code-output-status'
+import {
+  createCommandCodeOutputStatusDetector,
+  stripTerminalControl
+} from './command-code-output-status'
 
 afterEach(() => {
   vi.restoreAllMocks()
@@ -317,6 +320,44 @@ function maxStringContextLength(contexts: unknown[]): number {
 }
 
 describe('terminal control stripping', () => {
+  const esc = String.fromCharCode(0x1b)
+  const bel = String.fromCharCode(0x07)
+  const ansiEscape = new RegExp(
+    `${esc}(?:[@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~]|\\][^${bel}]*(?:${bel}|${esc}\\\\))`,
+    'g'
+  )
+  const incompleteAnsiEscape = new RegExp(
+    `${esc}(?:\\[[0-?]*[ -/]*|\\][^${bel}${esc}]*|\\S?)?$`,
+    'g'
+  )
+
+  function legacyStripTerminalControl(data: string): string {
+    const withoutAnsi = data.replace(ansiEscape, '').replace(incompleteAnsiEscape, '')
+    let output = ''
+    for (let index = 0; index < withoutAnsi.length; index += 1) {
+      const code = withoutAnsi.charCodeAt(index)
+      if ((code <= 0x1f && code !== 0x0a && code !== 0x0d) || (code >= 0x7f && code <= 0x9f)) {
+        continue
+      }
+      output += withoutAnsi[index]
+    }
+    return output
+  }
+
+  function makeRandom(seed: number): () => number {
+    let state = seed >>> 0
+    return () => {
+      state ^= state << 13
+      state ^= state >>> 17
+      state ^= state << 5
+      return (state >>> 0) / 0x1_0000_0000
+    }
+  }
+
+  function expectLegacyEquivalent(data: string): void {
+    expect(stripTerminalControl(data)).toBe(legacyStripTerminalControl(data))
+  }
+
   function promptFrom(raw: string): string | null {
     let captured: string | null = null
     const detector = createCommandCodeOutputStatusDetector({
@@ -347,4 +388,78 @@ describe('terminal control stripping', () => {
       '日本語 \u{1f389} prompt'
     )
   })
+
+  it('matches the legacy filter across ANSI, C0/C1, line breaks, and Unicode', () => {
+    for (const data of [
+      '',
+      'plain text',
+      '\x1b[35mstyled\x1b[0m',
+      '\x1b[unterminated',
+      '\x00leading',
+      'trailing\x9f',
+      '\x01\x02adjacent\x7f\x80',
+      'keep\r\nline breaks',
+      '日本語 \u{1f389} \ud83d \ude00',
+      '\x1b]0;title\x07prompt',
+      '\x1b]0;title\x1b\\prompt'
+    ]) {
+      expectLegacyEquivalent(data)
+    }
+  })
+
+  it('matches legacy output at density thresholds and block resets', () => {
+    const control = '\x01'
+    const fixtures = [
+      `${control.repeat(31)}${'a'.repeat(33)}`,
+      `${control.repeat(32)}${'a'.repeat(32)}`,
+      `${'a'.repeat(32)}${control.repeat(31)}a`,
+      `${control.repeat(31)}${'a'.repeat(33)}${control.repeat(31)}z`,
+      `${control.repeat(31)}${'a'.repeat(33)}${control.repeat(32)}z`,
+      `${'a'.repeat(64 * 3)}${control.repeat(32)}tail`,
+      `${'a\x01'.repeat(2048)}tail`
+    ]
+    for (const data of fixtures) {
+      expectLegacyEquivalent(data)
+    }
+  })
+
+  it('exhaustively matches short strings over control and Unicode code units', () => {
+    const alphabet = ['a', '\r', '\n', '\x01', '\x7f', '\x80', '\u20ac', '\ud83d']
+    for (let encoded = 0; encoded < alphabet.length ** 4; encoded += 1) {
+      let cursor = encoded
+      let data = ''
+      for (let position = 0; position < 4; position += 1) {
+        data += alphabet[cursor % alphabet.length]
+        cursor = Math.floor(cursor / alphabet.length)
+      }
+      expectLegacyEquivalent(data)
+    }
+  })
+
+  it('matches seeded random terminal text', () => {
+    const random = makeRandom(0xc0de_0727)
+    const alphabet = [
+      'a',
+      'Z',
+      '\r',
+      '\n',
+      '\x00',
+      '\x1f',
+      '\x7f',
+      '\x9f',
+      '\u00e9',
+      '\u20ac',
+      '\u{1f389}',
+      '\x1b[35m',
+      '\x1b[0m'
+    ]
+    for (let trial = 0; trial < 2_000; trial += 1) {
+      let data = ''
+      const parts = Math.floor(random() * 256)
+      for (let index = 0; index < parts; index += 1) {
+        data += alphabet[Math.floor(random() * alphabet.length)]
+      }
+      expectLegacyEquivalent(data)
+    }
+  })
 })