dsh-context-compression-improved 0.4.0-beta.1 → 0.5.0

package/packages/selector/tests/runtime/frequency-longstrings.spec.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest'
+import { normalizeTerminalLines, normalizeTerminalText } from '../../src/runtime/reducers.ts'
+
+describe('non-adjacent frequency folding (R11)', () => {
+  it('folds a line repeated 400 times but separated into first + one counted marker', () => {
+    // The adjacent fold only collapses CONSECUTIVE runs (0.03-0.32% of real
+    // duplicate content); separated repeats grew to 8.37% in large results.
+    const lines: string[] = ['start']
+    for (let index = 0; index < 400; index++) {
+      lines.push('same polling line', `interleaved ${String(index)}`)
+    }
+    lines.push('end')
+    const folded = normalizeTerminalLines(lines.join('\n')).folded
+    const texts = folded.map(line => line.text)
+    const sameCount = texts.filter(text => text === 'same polling line').length
+    expect(sameCount).toBe(1)
+    const marker = texts.find(text => text.startsWith('[×') && text.includes('same as line 2'))
+    expect(marker).toBeDefined()
+    expect(marker).toMatch(/\[× 400 total/)
+    // The marker cites the original-event lines it covers.
+    expect(marker).toMatch(/original lines? \d+/)
+    expect(texts[0]).toBe('start')
+    expect(texts.at(-1)).toBe('end')
+  })
+
+  it('leaves pairs alone (below the fold threshold)', () => {
+    const folded = normalizeTerminalLines(['a', 'b', 'a', 'c'].join('\n')).folded
+    expect(folded.map(line => line.text)).toEqual(['a', 'b', 'a', 'c'])
+  })
+
+  it('counter-proof: pure consecutive repeats stay byte-identical with adjacent-only folding', () => {
+    // Adjacent folding runs first; the frequency pass must not re-fold its
+    // output (double folding would corrupt the counts).
+    const input = ['run', 'run', 'run', 'run', 'other'].join('\n')
+    const folded = normalizeTerminalLines(input).folded
+    expect(folded.map(line => line.text)).toEqual([
+      'run',
+      '[previous line repeated 3 more times]',
+      'other',
+    ])
+    expect(normalizeTerminalText(input)).toBe('run\n[previous line repeated 3 more times]\nother')
+  })
+})
+
+describe('long-string placeholder (R12)', () => {
+  it('replaces long base64, long hex, and UUIDs with length summaries', () => {
+    const base64 = 'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpabcdeg'.repeat(9).slice(0, 300)
+    const hex = 'deadbeefcafebabe0123456789abcdef'.repeat(2)
+    const uuid = '123e4567-e89b-12d3-a456-426614174000'
+    const text = `token: ${base64}\nhash: ${hex}\nid: ${uuid}`
+    const folded = normalizeTerminalLines(text).folded
+    expect(folded[0]!.text).toContain(`[base64 300 chars: ${base64.slice(0, 16)}`)
+    expect(folded[1]!.text).toContain('[hex 64 chars: deadbeefcafebabe')
+    expect(folded[2]!.text).toContain('[uuid]')
+  })
+
+  it('counter-proof: short strings are never replaced', () => {
+    const shortishBase64 = 'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo='.repeat(5).slice(0, 150)
+    const shortHex = 'deadbeefcafebabe0123456789abcdef'
+    const text = `${shortishBase64}\n${shortHex}`
+    const joined = normalizeTerminalLines(text).folded.map(line => line.text).join('\n')
+    expect(joined).toContain(shortishBase64)
+    expect(joined).toContain(shortHex)
+  })
+
+  it('keeps the line count and original line numbers intact', () => {
+    const base64 = 'x'.repeat(260)
+    const text = `before ${base64} after\nnext line`
+    const folded = normalizeTerminalLines(text).folded
+    expect(folded).toHaveLength(2)
+    expect(folded[0]!.originalLine).toBe(1)
+    expect(folded[1]!.originalLine).toBe(2)
+  })
+})

package/packages/selector/tests/runtime/html-reducer.spec.ts

@@ -0,0 +1,212 @@
+import { describe, expect, it } from 'vitest'
+import { foldRepeatedHtmlBlocks, reduceFreshToolResult, type ReducerInput } from '../../src/runtime/reducers.ts'
+
+const SOURCE_REF = 'session://s1/event/3'
+
+function htmlInput(text: string, budgetChars = 2_000): ReducerInput {
+  return {
+    toolName: 'web_fetch',
+    argumentsText: '{"url":"https://example.com"}',
+    text,
+    budgetChars,
+    sourceRef: SOURCE_REF,
+    isError: false,
+  }
+}
+
+function samplePage(): string {
+  return [
+    '<!DOCTYPE html>',
+    '<html>',
+    '<head>',
+    '<meta charset="utf-8">',
+    '<script>window.tracking = "analytics payload ".repeat(200);</script>',
+    '<style>body { color: red; }</style>',
+    '</head>',
+    '<body>',
+    '<!-- navigation comment that must disappear -->',
+    '<div id="main" class="wrapper" style="color: blue" onclick="track()">',
+    '<h1>Pricing Overview</h1>',
+    '<p>The pricing page explains tiers, quotas, and the billing cycle for every plan we offer.</p>',
+    '<img src="data:image/png;base64,AAAA BillingBlob" alt="chart">',
+    '<a href="https://example.com/faq" title="FAQ">Read the <strong>FAQ</strong></a>',
+    '<table>',
+    '<tr><th>Plan</th><th>Quota</th></tr>',
+    '<tr><td>Free</td><td>5k/day</td></tr>',
+    '</table>',
+    '<h2>Enterprise Terms</h2>',
+    '<p>Enterprise customers sign a dedicated agreement with custom data-retention guarantees.</p>',
+    '</div>',
+    '</body>',
+    '</html>',
+  ].join('\n')
+}
+
+describe('html slimming (R13)', () => {
+  it('keeps body paragraphs and headings; never lands on pi-head', () => {
+    const output = reduceFreshToolResult(htmlInput(samplePage()))
+    expect(output).not.toBeNull()
+    expect(output!.reducer).not.toBe('pi-head')
+    expect(output!.reducer).toMatch(/^html-/)
+    expect(output!.text).toContain('Pricing Overview')
+    expect(output!.text).toContain('billing cycle for every plan')
+    expect(output!.text).toContain('Enterprise Terms')
+    expect(output!.text).toContain('Enterprise customers sign a dedicated agreement')
+  })
+
+  it('drops script bodies, style bodies, comments, and data URIs', () => {
+    const output = reduceFreshToolResult(htmlInput(samplePage()))
+    expect(output!.text).not.toContain('analytics payload')
+    expect(output!.text).not.toContain('color: red')
+    expect(output!.text).not.toContain('navigation comment')
+    expect(output!.text).not.toContain('data:image/png')
+    // Non-whitelisted attributes are stripped; href/alt/id survive (the R13
+    // whitelist is href/src/alt/title/id).
+    expect(output!.text).not.toContain('class="wrapper"')
+    expect(output!.text).not.toContain('style="color: blue"')
+    expect(output!.text).not.toContain('onclick=')
+    expect(output!.text).toContain('href="https://example.com/faq"')
+    expect(output!.text).toContain('alt="chart"')
+  })
+
+  it('falls back to a tag-aware skeleton when slim output exceeds the budget', () => {
+    const big = samplePage().replace(
+      '<h2>Enterprise Terms</h2>',
+      ['<h2>Enterprise Terms</h2>', ...Array.from({ length: 120 }, (_, i) => `<p>Section sentence ${String(i)} about contracts and retention windows.</p>`)].join('\n'),
+    )
+    const output = reduceFreshToolResult(htmlInput(big, 1_200))
+    expect(output).not.toBeNull()
+    expect(output!.reducer).toBe('html-skeleton')
+    expect(output!.text).toContain('<h1>Pricing Overview</h1>')
+    expect(output!.text).toContain('<h2>Enterprise Terms</h2>')
+    expect(output!.text).toMatch(/\[\.\.\. lines \d+-\d+ elided \(\d+ lines\)/)
+  })
+
+  it('misjudgment guard: TS generics and comparisons are not HTML', () => {
+    const code = [
+      'const map = new Map<string, number>()',
+      'if (a < b) {',
+      '  return new Array<Array<string>>()',
+      '}',
+      'const cmp = x < table.length ? 1 : 0',
+      'export function f<T extends object>(arg: T): T {',
+      '  return arg',
+      '}',
+    ].join('\n')
+    const output = reduceFreshToolResult(htmlInput(code))
+    expect(output?.reducer ?? 'none').not.toMatch(/^html-/)
+  })
+  // R4 third level (C23–C25, S4): deterministic repeated-block folding.
+  // NOTE: byte-identical repeated blocks are ALREADY folded by the R11
+  // normalizer before the reducers run — so these cases use counter-variant
+  // blocks (byte-different, digit-normalized-identical), which only the HTML
+  // third level can catch.
+  describe('repeated-block folding (R4)', () => {
+    const section = (word: string): string => [
+      `<h2>Section ${word}</h2>`,
+      `<p>Section ${word} carries unique body copy for the reader.</p>`,
+    ].join('\n')
+
+    it('folds a counter-variant repeated non-table block to a counted marker (C24)', () => {
+      // Counter-variant navs: byte-different lines (so the R11 normalizer fold
+      // leaves them alone) whose digit-normalized signature the HTML third
+      // level must catch.
+      const navBlock = (badge: number): readonly string[] => [
+        '<div class="nav">',
+        '<a href="/home">Home</a>',
+        `<span class="badge">${String(badge)}</span>`,
+        '</div>',
+      ]
+      const slim = [
+        ...navBlock(1).map((text, offset) => ({ text, index: offset })),
+        { text: '<h2>Section Alpha</h2>', index: 4 },
+        { text: '<p>Alpha body copy.</p>', index: 5 },
+        ...navBlock(2).map((text, offset) => ({ text, index: 6 + offset })),
+        { text: '<h2>Section Beta</h2>', index: 10 },
+        { text: '<p>Beta body copy.</p>', index: 11 },
+        ...navBlock(3).map((text, offset) => ({ text, index: 12 + offset })),
+        { text: '<h2>Section Gamma</h2>', index: 16 },
+        { text: '<p>Gamma body copy.</p>', index: 17 },
+      ]
+      const folded = foldRepeatedHtmlBlocks(slim, index => index + 1)
+      const markers = folded.filter(entry => entry.marker === true)
+      expect(markers).toHaveLength(2)
+      expect(markers[0]!.text).toBe('[×3 repeated block, first at line 1]')
+      expect(markers[0]!.index).toBe(6)
+    })
+
+    it('never folds table blocks (C25)', () => {
+      // Data-different tables: neither the R11 normalizer nor the HTML third
+      // level may fold them.
+      const tableBlock = (plan: string, quota: string, index: number): readonly { text: string, index: number }[] =>
+        [
+          '<table>',
+          '<tr><th>Plan</th><th>Quota</th></tr>',
+          `<tr><td>${plan}</td><td>${quota}</td></tr>`,
+          '</table>',
+        ].map((text, offset) => ({ text, index: index + offset }))
+      const slim = [
+        ...tableBlock('Free', '5k/day', 0),
+        { text: '<h2>Alpha</h2>', index: 4 },
+        ...tableBlock('Pro', '50k/day', 5),
+        { text: '<h2>Beta</h2>', index: 9 },
+        ...tableBlock('Max', '500k/day', 10),
+        { text: '<h2>Gamma</h2>', index: 14 },
+      ]
+      const folded = foldRepeatedHtmlBlocks(slim, currentIndex => currentIndex + 1)
+      expect(folded.filter(entry => entry.marker === true)).toHaveLength(0)
+      // Every table line survives the pass untouched.
+      expect(folded.filter(entry => entry.text === '<table>')).toHaveLength(3)
+    })
+
+    it('does not fold blocks whose copy differs beyond digits (S4)', () => {
+      const block = (word: string, index: number): readonly { text: string, index: number }[] =>
+        ['<div class="note">', `<span>${word}</span>`, '</div>']
+          .map((text, offset) => ({ text, index: index + offset }))
+      const same = [
+        ...block('Alpha', 0), { text: '<hr>', index: 3 },
+        ...block('Alpha', 4), { text: '<hr>', index: 7 },
+        ...block('Alpha', 8),
+      ]
+      expect(foldRepeatedHtmlBlocks(same, currentIndex => currentIndex + 1)
+        .filter(entry => entry.marker === true)).toHaveLength(2)
+      const different = [
+        ...block('Alpha', 0), { text: '<hr>', index: 3 },
+        ...block('Beta', 4), { text: '<hr>', index: 7 },
+        ...block('Gamma', 8),
+      ]
+      expect(foldRepeatedHtmlBlocks(different, currentIndex => currentIndex + 1)
+        .filter(entry => entry.marker === true)).toHaveLength(0)
+    })
+
+    it('keeps header + separator row of a table in the skeleton stage (C23)', () => {
+      const rows = ['<table>', '<tr><th>Plan</th><th>Quota</th></tr>', '<tr><td>Free</td><td>5k/day</td></tr>',
+        '<tr><td>Pro</td><td>50k/day</td></tr>', '<tr><td>Max</td><td>500k/day</td></tr>', '</table>']
+      const page = ['<h1>Plans</h1>', rows.join('\n'), '<h2>Details</h2>',
+        ...Array.from({ length: 60 }, (_, index) => `<p>Detail line ${String(index)} with distinct copy ${String(index * 7)}.</p>`)].join('\n')
+      const output = reduceFreshToolResult(htmlInput(page, 900))
+      expect(output).not.toBeNull()
+      expect(output!.reducer).toBe('html-skeleton')
+      expect(output!.text).toContain('<tr><th>Plan</th><th>Quota</th></tr>')
+      expect(output!.text).toContain('<tr><td>Free</td><td>5k/day</td></tr>')
+    })
+
+    it('digit-normalized signature folds counter-only variants (S4, end-to-end)', () => {
+      const counterBlock = (step: number): string => [
+        '<div class="page">',
+        `<span>Item ${String(step * 3 + 1)}</span>`,
+        `<span>Item ${String(step * 3 + 2)}</span>`,
+        '</div>',
+      ].join('\n')
+      const page = [
+        counterBlock(0), section('Alpha'),
+        counterBlock(1), section('Beta'),
+        counterBlock(2), section('Gamma'),
+        counterBlock(3),
+      ].join('\n')
+      const output = reduceFreshToolResult(htmlInput(page, 400))
+      expect(output).not.toBeNull()
+      expect(output!.text).toContain('repeated block')
+    })
+  })
+})

package/packages/selector/tests/runtime/line-mapping.spec.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest'
+import {
+  normalizeTerminalLines,
+  normalizeTerminalText,
+} from '../../src/runtime/reducers.ts'
+
+/** R9a drift harness: `retrieve` reads the ORIGINAL event, so every line
+ *  number a reducer prints must point back into the original event, not into
+ *  the normalized text. The assertions below pin EXACT original line numbers —
+ *  removing the mapping (or off-by-oneing it) fails these cases, which is the
+ *  reverse-proof the R9a acceptance asks for. */
+
+describe('normalizeTerminalLines', () => {
+  it('keeps folded lines 1:1 with the original event through ANSI + \\r redraw + adjacent dups', () => {
+    // Original event, 1-based:
+    //   1  staging files...            (ANSI-decorated)
+    //   2  progress 10%
+    //   3  progress 10%                (adjacent dup)
+    //   4  progress 10%                (adjacent dup)
+    //   5  Downloaded 100%             (\r redraw of one physical line)
+    //   6  done                        (ANSI-decorated)
+    const original = [
+      '\u001B[32mstaging files...\u001B[0m',
+      'progress 10%',
+      'progress 10%',
+      'progress 10%',
+      'Downloaded 50%\rDownloaded 100%',
+      '\u001B[1mdone\u001B[0m',
+    ].join('\n')
+
+    const { folded, text } = normalizeTerminalLines(original)
+
+    expect(folded).toEqual([
+      { text: 'staging files...', content: 'staging files...', originalLine: 1 },
+      { text: 'progress 10%', content: 'progress 10%', originalLine: 2 },
+      {
+        text: '[previous line repeated 2 more times]',
+        content: '[previous line repeated 2 more times]',
+        originalLine: 3,
+        originalLineEnd: 4,
+      },
+      { text: 'Downloaded 100%', content: 'Downloaded 100%', originalLine: 5 },
+      { text: 'done', content: 'done', originalLine: 6 },
+    ])
+    // The folded text is byte-identical with the string API.
+    expect(text).toBe(normalizeTerminalText(original))
+    expect(text).toBe([
+      'staging files...',
+      'progress 10%',
+      '[previous line repeated 2 more times]',
+      'Downloaded 100%',
+      'done',
+    ].join('\n'))
+  })
+
+  it('maps every kept line back to the same original line through ANSI stripping alone', () => {
+    const original = ['\u001B[1malpha\u001B[0m', 'beta', '\u001B[31mgamma\u001B[0m'].join('\n')
+    const { folded } = normalizeTerminalLines(original)
+    expect(folded.map(line => [line.text, line.originalLine])).toEqual([
+      ['alpha', 1],
+      ['beta', 2],
+      ['gamma', 3],
+    ])
+  })
+
+  it('never changes the line count before folding (logical 1:1 original)', () => {
+    // \r redraws and ANSI escapes consume no newlines, so even a line that
+    // redraws many times stays one logical line. A trailing newline keeps its
+    // empty logical line (byte-compatibility with the string API).
+    const original = 'a\rb\rc\rd\nx\n\u001B[2Ky\n'
+    const { folded } = normalizeTerminalLines(original)
+    expect(folded.map(line => line.text)).toEqual(['d', 'x', 'y', ''])
+    expect(folded.map(line => line.originalLine)).toEqual([1, 2, 3, 4])
+  })
+
+  it('pins the repeat-marker range to the occurrences it replaces', () => {
+    const original = ['head', 'same', 'same', 'same', 'same', 'tail'].join('\n')
+    const { folded } = normalizeTerminalLines(original)
+    expect(folded).toEqual([
+      { text: 'head', content: 'head', originalLine: 1 },
+      { text: 'same', content: 'same', originalLine: 2 },
+      {
+        text: '[previous line repeated 3 more times]',
+        content: '[previous line repeated 3 more times]',
+        originalLine: 3,
+        originalLineEnd: 5,
+      },
+      { text: 'tail', content: 'tail', originalLine: 6 },
+    ])
+  })
+
+  // GF-1 dual view (spec.md 「行号修复补丁 GF-1」): a block-detected read
+  // gutter is stripped on the CONTENT view only — the output view keeps the
+  // host's `N: ` prefixes byte-for-byte because they are the model's only
+  // inline locator into the original file, while form detection and the fold
+  // keys must not see them.
+  it('strips a detected read gutter on the content view and keeps it on the output view', () => {
+    const original = [
+      '1: export function alpha() {',
+      '2:   return 1',
+      '3: }',
+      '4: ',
+      '5: export function beta() {',
+      '6: }',
+    ].join('\n')
+    const { folded, text, contentText } = normalizeTerminalLines(original)
+    // Output view: the gutter is preserved verbatim.
+    expect(text).toBe(original)
+    // Content view: the gutter is gone.
+    expect(contentText).toBe([
+      'export function alpha() {',
+      '  return 1',
+      '}',
+      '',
+      'export function beta() {',
+      '}',
+    ].join('\n'))
+    // Every folded line still maps 1:1 into the original event.
+    expect(folded.map(line => line.originalLine)).toEqual([1, 2, 3, 4, 5, 6])
+    expect(folded.map(line => line.content)).toEqual([
+      'export function alpha() {',
+      '  return 1',
+      '}',
+      '',
+      'export function beta() {',
+      '}',
+    ])
+  })
+
+  it('does not strip a stray time-of-day colon as a read gutter (block-level guard)', () => {
+    // Only 1 of 5 non-empty lines is gutter-shaped, and the "numbers" are not
+    // strictly increasing — the block guard must keep both views intact.
+    const original = ['meeting at 12:30 pm', 'standup at 9:15 am', 'retro at 4:45 pm', 'done'].join('\n')
+    const { text, contentText } = normalizeTerminalLines(original)
+    expect(text).toBe(original)
+    expect(contentText).toBe(original)
+  })
+})
+
+/** 口径对拍 (task_2.3): `splitLines` (reducers.ts) and `splitScannedLines`
+ *  (retrieve.ts) must count lines identically — both split on '\n' and drop
+ *  only the trailing empty element when the text ends with a newline. retrieve
+ *  scans the raw event, reducers see normalized text; the R9a mapping above is
+ *  what keeps the two line spaces reconcilable. The behavioral proof lives in
+ *  the drift cases; this suite pins the reducer-side convention. */
+describe('line-splitting conventions', () => {
+  it('reducer-side folded lines join back to the text splitLines would produce', () => {
+    const original = 'one\ntwo\nthree'
+    const { folded, text } = normalizeTerminalLines(original)
+    expect(text.split('\n')).toEqual(folded.map(line => line.text))
+    expect(folded).toHaveLength(3)
+  })
+})

package/packages/selector/tests/runtime/prose-reducers.spec.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'vitest'
+import { codePointLength } from '../../src/runtime/config.ts'
+import { reduceFreshToolResult, type ReducerInput } from '../../src/runtime/reducers.ts'
+
+function input(overrides: Partial<ReducerInput> = {}): ReducerInput {
+  return {
+    toolName: 'mcp_remote_fetch',
+    argumentsText: '{}',
+    text: '',
+    budgetChars: 4_000,
+    sourceRef: 'session://s/event/1',
+    isError: false,
+    ...overrides,
+  }
+}
+
+function markdownDoc(sections: number): string {
+  const parts: string[] = ['# User Guide', 'Intro paragraph with orientation prose.']
+  for (let index = 1; index <= sections; index++) {
+    parts.push(`## Section ${String(index)}: Installation`)
+    for (let line = 0; line < 12; line++) {
+      parts.push(`Section ${String(index)} line ${String(line)} with ordinary documentation prose content.`)
+    }
+  }
+  return parts.join('\n')
+}
+
+describe('document skeleton (R8)', () => {
+  it('keeps every H1-H3 heading and at least one sentence per section', () => {
+    const output = reduceFreshToolResult(input({ text: markdownDoc(8) }))
+    expect(output).not.toBeNull()
+    expect(output!.reducer).toBe('doc-skeleton')
+    for (let index = 1; index <= 8; index++) {
+      expect(output!.text).toContain(`## Section ${String(index)}: Installation`)
+      // 每节 ≥1 句：the section's first line survives.
+      expect(output!.text).toContain(`Section ${String(index)} line 0`)
+    }
+    expect(output!.text).toContain('# User Guide')
+  })
+
+    it('keeps the first two rows of every table block', () => {
+    const doc = [
+      '# Report',
+      'Intro.',
+      '## Usage',
+      'Usage intro.',
+      '## Tables',
+      'Tables intro.',
+      ...Array.from({ length: 30 }, (_, i) => `Intro filler sentence ${String(i)} to make the section elidable.`),
+      '| Name | Quota |',
+      '| --- | --- |',
+      '| Free | 5k |',
+      '| Pro | 50k |',
+      ...Array.from({ length: 30 }, (_, i) => `Closing filler sentence ${String(i)} to make the section elidable.`),
+      'Trailing prose line.',
+    ].join('\n')
+    const output = reduceFreshToolResult(input({ text: doc, toolName: 'mcp_fetch' }))
+    expect(output!.reducer).toBe('doc-skeleton')
+    expect(output!.text).toContain('| Name | Quota |')
+    expect(output!.text).toContain('| --- | --- |')
+  })
+
+it('cites original-event line ranges in elision markers (R9 spec)', () => {
+    const output = reduceFreshToolResult(input({ text: markdownDoc(6) }))
+    expect(output).not.toBeNull()
+    // Every elision marker carries an original line range and a line count.
+    const markers = output!.text.match(/\[\.\.\. lines \d+-\d+ elided \(\d+ lines\)[^\]]*\]/g) ?? []
+    expect(markers.length).toBeGreaterThan(0)
+    for (const marker of markers) {
+      const [, start, end, count] = /\[\.\.\. lines (\d+)-(\d+) elided \((\d+) lines\)/.exec(marker) ?? []
+      expect(Number(end) - Number(start) + 1).toBe(Number(count))
+    }
+  })
+
+  it('misjudgment guard: logs and build output are not documents', () => {
+    // Realistic build/log output carries no Markdown heading lines at all —
+    // timestamps, INFO frames, and stack locations never match `^#\\s`.
+    const log = [
+      'INFO 2026-01-01 starting build',
+      'WARN 2026-01-01 deprecated flag --legacy',
+      'INFO compiling modules',
+      'ERROR TS2345: cannot find name elsewhere',
+      ...Array.from({ length: 40 }, (_, i) => `at /pkg/src/module${String(i)}.ts:12:5`),
+    ].join('\n')
+    const output = reduceFreshToolResult(input({ text: log, toolName: 'bash', argumentsText: '{"command":"pnpm build"}' }))
+    expect(output?.reducer).not.toBe('doc-skeleton')
+  })
+})
+
+describe('prose head+tail keep (R8b)', () => {
+  const prose = [
+    ...Array.from({ length: 60 }, (_, i) => `Early paragraph ${String(i)} with orientation prose for the reader.`),
+    ...Array.from({ length: 60 }, (_, i) => `Middle paragraph ${String(i)} carries ordinary filler content.`),
+    ...Array.from({ length: 60 }, (_, i) => `Final paragraph ${String(i)} holds the decisive conclusion about quotas.`),
+  ].join('\n')
+
+  it('keeps head AND tail non-empty with an elision marker in between', () => {
+    const output = reduceFreshToolResult(input({ text: prose }))
+    expect(output).not.toBeNull()
+    expect(output!.reducer).toBe('prose-keep')
+    const lines = output!.text.split('\n')
+    expect(lines[0]).toContain('Early paragraph 0')
+    expect(lines.at(-1)).toContain('Final paragraph 59')
+    expect(output!.text).toMatch(/\[\.\.\. lines \d+-\d+ elided \(\d+ lines\)/)
+    // The tail keeps conclusions the old head-only reducer dropped.
+    expect(output!.text).toContain('decisive conclusion')
+  })
+
+  it('counter-proof: head-only retention provably loses the tail keyword', () => {
+    // The old landing spots for prose were head-only (pi-head) or a salience
+    // pass whose middle list is empty for prose. A head-only slice of B chars
+    // can never contain a keyword that starts after char B: the prose is
+    // ~11k chars and the decisive sentence sits in the last third, so any
+    // head-only output within a 4k budget drops it by construction.
+    const keywordIndex = prose.indexOf('decisive conclusion')
+    expect(codePointLength(prose)).toBeGreaterThan(2 * 4_000)
+    expect(keywordIndex).toBeGreaterThan(4_000)
+    // The R8b output keeps it anyway (also asserted above).
+  })
+
+  it('misjudgment guard: source code still stays off the prose path', () => {
+    const code = [
+      'import { createHash } from \'node:crypto\'',
+      '',
+      ...Array.from({ length: 40 }, (_, i) => `export function handler${String(i)}(input: string): string {`),
+      ...Array.from({ length: 40 }, (_, i) => `  return hash(input, ${String(i)})`),
+      '}',
+    ].join('\n')
+    const output = reduceFreshToolResult(input({ text: code }))
+    expect(output?.reducer).not.toBe('prose-keep')
+    expect(output?.reducer).not.toBe('doc-skeleton')
+  })
+})