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

package/packages/selector/tests/runtime/public/public-runtime.spec.ts

@@ -45,6 +45,7 @@ import ToolResultPruner, {
   resolvePolicy,
 } from '../../../src/pruner.ts'
 import type { CustomCompressionPolicy } from '../../../src/pruner.ts'
+import { CHARS_PER_TOKEN } from '../../../src/runtime/config.ts'
 import { DEEPSEEK_V4_TOKENIZER_ARTIFACT, deepSeekV4TokenizerForModel } from '../../../src/deepseek-v4-tokenizer.ts'
 import {
   DEEPSEEK_VISION_DEFAULT_IMAGE_TOKENS,
@@ -165,6 +166,7 @@ function appendToolTurn(
   userText?: string,
   provider = 'deepseek',
   model: string = MODEL,
+  toolName = 'bash',
 ): { readonly assistantSeq: number; readonly resultSeq: number } {
   const callId = CallId(`call-${String(turn)}`)
   session.append('turn/start', { turn })
@@ -187,11 +189,11 @@ function appendToolTurn(
     step: 1,
     message: createMessage({
       role: 'assistant',
-      content: [{ type: 'tool-call', id: callId, name: 'bash', arguments: '{}' }],
+      content: [{ type: 'tool-call', id: callId, name: toolName, arguments: '{}' }],
       source: { kind: 'model', provider, model },
     }),
   }, { surfaceOp: 'append' })
-  session.append('tool/call', { turn, step: 1, callId, name: 'bash', arguments: '{}' })
+  session.append('tool/call', { turn, step: 1, callId, name: toolName, arguments: '{}' })
   const result = session.append('tool/result', {
     turn,
     step: 1,
@@ -416,6 +418,58 @@ describe('standalone runtime on published Harness APIs', () => {
     expect(record?.tokensRemoved).toBe((record?.tokensBefore ?? 0) - (record?.tokensAfter ?? 0))
   })
 
+  it('threads the reducer elided-line count from a fresh plan into the rewrite audit', async () => {
+    // The skeleton reducer counts the lines it hid behind elision markers; that
+    // count must survive the whole planning middle (plan options → planned
+    // replacement → audit record) without ever touching the replacement text.
+    const ctx = await runtimeContext()
+    await ctx.plugin(TestSettings).await()
+    await ctx.plugin(SelectorHost).await()
+    await ctx.settings.update(nsBrand(CONTEXT_COMPRESSION_SETTINGS_NAMESPACE), {
+      profile: 'balanced',
+      codeSkeleton: { enabled: true },
+    })
+    const audit = captureAudit(ctx)
+    await ctx.plugin(ToolResultPruner, {
+      profile: 'balanced',
+      freshTriggerTokens: 1_000,
+      freshTargetTokens: 800,
+      aggregateTriggerTokens: 500_000,
+      aggregateTargetTokens: 450_000,
+      historyTriggerTokens: 500_000,
+    }).await()
+    const session = Session.create(SessionId('public-fresh-elided-lines'))
+    const fixture = [
+      "import { readFile } from 'node:fs/promises'",
+      '',
+      ...Array.from({ length: 40 }, (_, index) => [
+        `export function handler${String(index)}(input: string): string {`,
+        `  const normalized = input.trim().toLowerCase()`,
+        `  if (normalized.length === 0) return 'empty-${String(index)}'`,
+        `  return normalized.split('-').join('+')`,
+        '}',
+        '',
+      ]).flat(),
+    ].join('\n')
+    appendToolTurn(session, 1, fixture, false, undefined, 'deepseek-official', MODEL, 'read')
+
+    const result = ctx.toolResultPruner.pruneSession(session, {
+      stage: 'fresh',
+      freshTurn: 1,
+      freshStep: 1,
+    })
+
+    expect(result.pruned).toHaveLength(1)
+    expect(result.pruned[0]?.reducer).toBe('hypa-code-skeleton')
+    const record = rewrites(audit.records()).find(entry => entry.component === 'fresh')
+    expect(record?.reducer).toBe('hypa-code-skeleton')
+    expect(record?.elidedLines).toEqual(expect.any(Number))
+    expect(record?.elidedLines).toBeGreaterThan(0)
+    expect(Number.isInteger(record?.elidedLines)).toBe(true)
+    expect(record?.tokensBefore).toBeGreaterThan(1_000)
+    expect(record?.tokensAfter).toBeLessThanOrEqual(800)
+  })
+
   it('proves isolated Aggregate while Fresh and History remain below their gates', async () => {
     const ctx = await runtimeContext()
     const audit = captureAudit(ctx)
@@ -460,13 +514,16 @@ describe('standalone runtime on published Harness APIs', () => {
     )
     session.append('turn/start', { turn: 2 })
     const view = measureForCompaction(ctx, session)
+    // Decision gates run on the character basis, so the thresholds below are
+    // derived from per-result character pressure and expressed in the
+    // token-named settings keys via CHARS_PER_TOKEN.
     const counts = batch.resultSeqs.map((seq) => {
-      const entry = view.measuredNodes.find(node => node.seq === seq)?.count
-      if (entry?.kind !== 'exact-tokenizer') throw new Error('working-set test needs exact result counts')
-      return entry.tokens
+      const entry = view.measuredNodes.find(node => node.seq === seq)
+      if (entry === undefined) throw new Error('working-set test needs measured results')
+      return entry.characterPressure
     })
-    const recentTailTokens = counts.slice(-3).reduce((sum, tokens) => sum + tokens, 0) - 1
-    const totalToolTokens = counts.reduce((sum, tokens) => sum + tokens, 0)
+    const recentTailChars = counts.slice(-3).reduce((sum, chars) => sum + chars, 0) - 1
+    const totalToolChars = counts.reduce((sum, chars) => sum + chars, 0)
 
     await ctx.plugin(ToolResultPruner, {
       profile: 'balanced',
@@ -474,12 +531,15 @@ describe('standalone runtime on published Harness APIs', () => {
       freshTargetTokens: 90_000,
       aggregateTriggerTokens: 100_000,
       aggregateTargetTokens: 90_000,
-      // The strict required-reclaim gate demands one batch pull tool tokens
+      // The strict required-reclaim gate demands one batch pull tool chars
       // back below the trigger; 72% leaves exactly the two oldest results as
       // the reclaimable margin above the placeholder residue.
-      historyTriggerTokens: Math.floor(totalToolTokens * 0.72),
+      historyTriggerTokens: Math.floor(totalToolChars * 0.72 / CHARS_PER_TOKEN),
       historyKeepRecentToolCalls: 2,
-      historyKeepRecentTokens: recentTailTokens,
+      // 4 x floor(recentTailChars / 4) sits above the two-newest char total
+      // and at or below the three-newest total, so the tail protects exactly
+      // the three newest results.
+      historyKeepRecentTokens: Math.floor(recentTailChars / CHARS_PER_TOKEN),
       historyMinReclaimTokens: 1,
     }).await()
 
@@ -1327,7 +1387,7 @@ describe('standalone runtime on published Harness APIs', () => {
     }))
   })
 
-  it('preserves exact-tokenizer-unavailable before Adaptive cost authority', async () => {
+  it('audits adaptive-cost-rejected on the character basis when the authority lacks request telemetry', async () => {
     const ctx = await runtimeContext()
     const audit = captureAudit(ctx)
     await ctx.plugin(ToolResultPruner, {
@@ -1338,7 +1398,9 @@ describe('standalone runtime on published Harness APIs', () => {
       aggregateTargetTokens: 90_000,
       historyTriggerTokens: 100,
       historyKeepRecentToolCalls: 0,
-      historyKeepRecentTokens: 1,
+      // A zero tail budget keeps nothing in the char-basis protection loop
+      // (0 < 0 is false), so the batch can actually form.
+      historyKeepRecentTokens: 0,
       historyMinReclaimTokens: 1,
     }).await()
     const session = Session.create(SessionId('public-history-adaptive-exact-unavailable'))
@@ -1353,18 +1415,21 @@ describe('standalone runtime on published Harness APIs', () => {
     )
     session.append('turn/start', { turn: 2 })
     ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
+    // Planning now succeeds on the character basis; the batch is refused by
+    // the adaptive cost authority (no adjacent request telemetry), not by a
+    // missing exact count.
     expect(audit.records()).toContainEqual(expect.objectContaining({
       kind: 'component-evaluation',
       sessionId: String(session.id),
       component: 'history',
       status: 'skipped',
-      reason: 'exact-tokenizer-unavailable',
+      reason: 'adaptive-cost-rejected',
       historyMode: 'adaptive',
-      measurementKind: 'unavailable',
+      measurementKind: 'characters',
     }))
   })
 
-  it('audits exact-tokenizer-unavailable for History when counts are not exact', async () => {
+  it('plans and lands History on the character basis when counts are not exact', async () => {
     const ctx = await runtimeContext()
     const audit = captureAudit(ctx)
     await ctx.plugin(ToolResultPruner, {
@@ -1375,21 +1440,28 @@ describe('standalone runtime on published Harness APIs', () => {
       aggregateTargetTokens: 90_000,
       historyTriggerTokens: 100,
       historyKeepRecentToolCalls: 0,
-      historyKeepRecentTokens: 1,
+      historyKeepRecentTokens: 0,
       historyMinReclaimTokens: 1,
     }).await()
     const session = Session.create(SessionId('public-history-exact-unavailable'))
     appendToolTurn(session, 1, 'unknown model history evidence '.repeat(300), true, undefined, 'deepseek', 'unsupported-public-model')
     session.append('turn/start', { turn: 2 })
     ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
+    // A committed batch forms from character pressure alone and lands, because
+    // this pruner registers its own recovery tool. The sibling case below drops
+    // the tool registry to exercise the recovery-tool-unavailable path.
     expect(audit.records()).toContainEqual(expect.objectContaining({
-      kind: 'component-evaluation',
+      kind: 'rewrite',
       sessionId: String(session.id),
       component: 'history',
-      status: 'skipped',
-      reason: 'exact-tokenizer-unavailable',
-      measurementKind: 'unavailable',
+      reducer: 'historical-tool-result-aging',
+      measurementBasis: 'characters',
+      tokenizerId: 'characters',
+      tokenizerRevision: 'chars-per-token-4.0',
     }))
+    // The character basis never claims an exact tokenizer it does not have.
+    expect(audit.records().some(record =>
+      record.kind === 'rewrite' && record.measurementBasis === 'exact-tokenizer')).toBe(false)
   })
 
   it('audits recovery-tool-unavailable when a committed batch cannot land without the recovery tool', async () => {
@@ -1763,14 +1835,15 @@ describe('standalone runtime on published Harness APIs', () => {
     expect(replayRecovered).toEqual(recovered)
   })
 
-  it('audits TailTrim threshold, tokenizer, safety-group, and min-reclaim skip paths', async () => {
+  it('audits TailTrim threshold, safety-group, and min-reclaim skip paths and lands on the character basis for an unknown model', async () => {
     async function runScenario(options: {
       readonly id: string
-      readonly expectedReason: string
+      readonly expectedReason?: string
       readonly trigger: number
       readonly minReclaim: number
       readonly candidateTurns: number
       readonly model?: string
+      readonly expectLanding?: boolean
     }): Promise<void> {
       const ctx = new Context()
       activeContexts.push(ctx)
@@ -1813,7 +1886,17 @@ describe('standalone runtime on published Harness APIs', () => {
 
       ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
 
-      expect(rewrites(audit.records()).filter(record => record.component === 'tail-trim')).toHaveLength(0)
+      const tailTrimRewrites = rewrites(audit.records()).filter(record => record.component === 'tail-trim')
+      if (options.expectLanding === true) {
+        // An unknown model id no longer skips: the group lands and the record
+        // must honestly report the character basis.
+        expect(tailTrimRewrites).toHaveLength(1)
+        expect(tailTrimRewrites[0]?.measurementBasis).toBe('characters')
+        expect(tailTrimRewrites[0]?.tokenizerId).toBe('characters')
+        expect(tailTrimRewrites[0]?.tokenizerRevision).toBe('chars-per-token-4.0')
+        return
+      }
+      expect(tailTrimRewrites).toHaveLength(0)
       expect(audit.records()).toContainEqual(expect.objectContaining({
         kind: 'component-evaluation',
         sessionId: String(session.id),
@@ -1831,12 +1914,12 @@ describe('standalone runtime on published Harness APIs', () => {
       candidateTurns: 2,
     })
     await runScenario({
-      id: 'public-tailtrim-tokenizer-unavailable',
-      expectedReason: 'exact-tokenizer-unavailable',
+      id: 'public-tailtrim-character-basis-landing',
       trigger: 1,
       minReclaim: 1,
       candidateTurns: 2,
       model: 'unsupported-public-model',
+      expectLanding: true,
     })
     await runScenario({
       id: 'public-tailtrim-first-group-protected',
@@ -2276,19 +2359,25 @@ describe('standalone runtime on published Harness APIs', () => {
     // The original image-bearing result stays on the surface untouched.
     const original = sessionEvents(session)[imageResult.seq]
     expect(original?.type).toBe('tool/result')
+    // Character basis: the text-only guard rejects a rich node, so the fresh and
+    // aggregate passes report no reducible candidate and the single candidate
+    // stays inside the protected History tail. The image itself is never
+    // rewritten, which is the behaviour this case exists to protect.
     expect(audit.records()).toContainEqual(expect.objectContaining({
       kind: 'component-evaluation',
       sessionId: String(session.id),
       component: 'fresh',
       status: 'skipped',
-      reason: 'exact-tokenizer-unavailable',
+      reason: 'no-valid-reduction',
+      measurementKind: 'characters',
     }))
     expect(audit.records()).toContainEqual(expect.objectContaining({
       kind: 'component-evaluation',
       sessionId: String(session.id),
       component: 'history',
       status: 'skipped',
-      reason: 'exact-tokenizer-unavailable',
+      reason: 'protected-working-set',
+      measurementKind: 'characters',
     }))
   })
 
@@ -2551,3 +2640,85 @@ describe('standalone runtime on published Harness APIs', () => {
       || record.reason === 'exact-tokenizer-unavailable')).toBe(true)
   })
 })
+
+describe('character basis / model-id independence', () => {
+  // ~57,688 characters of read-type output on the decision surface, in the
+  // code shape the hypa-code-skeleton reducer collapses.
+  const readFixture = [
+    "import { readFile } from 'node:fs/promises'",
+    '',
+    ...Array.from({ length: 300 }, (_, index) => [
+      `export function handler${String(index)}(input: string): string {`,
+      `  const normalized = input.trim().toLowerCase()`,
+      `  if (normalized.length === 0) return 'empty-${String(index)}'`,
+      `  return normalized.split('-').join('+')`,
+      '}',
+      '',
+    ]).flat(),
+  ].join('\n')
+
+  async function characterBasisContext(): Promise<Context> {
+    const ctx = await runtimeContext()
+    await ctx.plugin(TestSettings).await()
+    await ctx.plugin(SelectorHost).await()
+    await ctx.settings.update(nsBrand(CONTEXT_COMPRESSION_SETTINGS_NAMESPACE), {
+      profile: 'balanced',
+      codeSkeleton: { enabled: true },
+    })
+    await ctx.plugin(ToolResultPruner, {
+      profile: 'balanced',
+      freshTriggerTokens: 1_000,
+      freshTargetTokens: 800,
+      aggregateTriggerTokens: 500_000,
+      aggregateTargetTokens: 450_000,
+      historyTriggerTokens: 500_000,
+    }).await()
+    return ctx
+  }
+
+  for (const routedModel of ['deepseek-nonexistent-9', 'deepseek-flash']) {
+    it(`lands a fresh reduction on the character basis for routed model ${routedModel}`, async () => {
+      const ctx = await characterBasisContext()
+      const audit = captureAudit(ctx)
+      const session = Session.create(SessionId(`public-char-basis-${routedModel}`))
+      appendToolTurn(session, 1, readFixture, false, undefined, 'deepseek-official', routedModel, 'read')
+
+      const result = ctx.toolResultPruner.pruneSession(session, {
+        stage: 'fresh',
+        freshTurn: 1,
+        freshStep: 1,
+      })
+
+      expect(result.pruned.length).toBe(1)
+      expect(result.pruned[0]?.reducer).toBe('hypa-code-skeleton')
+      // The decision ran on characters: the record must not claim an exact
+      // tokenizer it never used.
+      const record = rewrites(audit.records()).find(entry => entry.component === 'fresh')
+      expect(record?.measurementBasis).toBe('characters')
+      expect(record?.tokenizerId).toBe('characters')
+      expect(record?.tokenizerRevision).toBe('chars-per-token-4.0')
+    })
+  }
+
+  it('keeps the exact-tokenizer basis and the same reducer for a whitelisted model', async () => {
+    const ctx = await characterBasisContext()
+    const audit = captureAudit(ctx)
+    const session = Session.create(SessionId('public-char-basis-whitelisted'))
+    appendToolTurn(session, 1, readFixture, false, undefined, 'deepseek-official', MODEL, 'read')
+
+    const result = ctx.toolResultPruner.pruneSession(session, {
+      stage: 'fresh',
+      freshTurn: 1,
+      freshStep: 1,
+    })
+
+    expect(result.pruned.length).toBe(1)
+    expect(result.pruned[0]?.reducer).toBe('hypa-code-skeleton')
+    const record = rewrites(audit.records()).find(entry => entry.component === 'fresh')
+    expect(record?.measurementBasis).toBe('exact-tokenizer')
+    expect(record?.tokenizerId).toEqual(expect.stringContaining('deepseek'))
+    expect(record?.tokenizerRevision).toEqual(expect.any(String))
+    expect(record?.tokensBefore).toBeGreaterThan(0)
+    expect(record?.tokensAfter).toBeGreaterThan(0)
+  })
+})

package/packages/selector/tests/runtime/read-input-cap.spec.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest'
+import { resolveConfig, resolvePolicy } from '../../src/pruner.ts'
+
+/** task_4 (G2): the read input cap is in CHARACTERS while the fresh trigger is
+ *  in TOKENS. At the conservative 4.0 chars/token upper bound, a cap at or
+ *  below `freshTriggerTokens × 4.0` truncates every read result below the
+ *  trigger and silently silences the fresh path — so `resolvePolicy` must
+ *  reject that combination at startup. 32k fails (32,000 < 8192×4.0 = 32,768);
+ *  the deployed 50k cap passes; unset stays untouched. */
+describe('readInputCapChars invariant', () => {
+  it('throws when the cap would sit below the fresh trigger (32k vs 8192×4.0)', () => {
+    const config = resolveConfig({ readInputCapChars: 32_000 })
+    expect(() => resolvePolicy(config, 'balanced')).toThrow(
+      'context compression policy: read input cap would silence the fresh path',
+    )
+  })
+
+  it('accepts the deployed 50k cap', () => {
+    const config = resolveConfig({ readInputCapChars: 50_000 })
+    const policy = resolvePolicy(config, 'balanced')
+    expect(policy.readInputCapChars).toBe(50_000)
+  })
+
+  it('leaves the policy untouched when the cap is not set', () => {
+    const policy = resolvePolicy(resolveConfig({}), 'balanced')
+    expect(policy.readInputCapChars).toBeUndefined()
+  })
+
+  it('keeps profiles without a configured cap byte-identical (no field on the resolved object)', () => {
+    const policy = resolvePolicy(resolveConfig({}), 'balanced')
+    expect(Object.hasOwn(policy, 'readInputCapChars')).toBe(false)
+  })
+})

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

@@ -0,0 +1,110 @@
+import { describe, expect, it } from 'vitest'
+import { reduceFreshToolResult } from '../../src/runtime/reducers.ts'
+
+const SOURCE_REF = 'session://s1/event/7'
+
+function searchInput(text: string, budgetChars = 16_000): Parameters<typeof reduceFreshToolResult>[0] {
+  return {
+    toolName: 'grep_search',
+    argumentsText: '{"pattern":"config"}',
+    text,
+    budgetChars,
+    sourceRef: SOURCE_REF,
+    isError: false,
+  }
+}
+
+describe('search L1 locator (R10)', () => {
+  it('reports the complete line-number set for a 592-hit file (count == hits)', () => {
+    // 实测 upper bound: one real session had a 592-hit file; the old reducer
+    // reported only "(592 matches)" and dropped every line number (21.2% of
+    // all hits across sessions were silently unlocatable).
+    const lines = Array.from({ length: 592 }, (_, i) =>
+      `src/deep/module.ts:${String(i + 1)}: export const config${String(i)} = configure(${String(i)})`)
+    const output = reduceFreshToolResult(searchInput(lines.join('\n')))
+    expect(output).not.toBeNull()
+    const locator = output!.text.split('\n').find(line => line.startsWith('## src/deep/module.ts'))
+    expect(locator).toBeDefined()
+    const numbers = [...locator!.matchAll(/L(\d+)/g)].map(match => Number(match[1]))
+    expect(numbers).toHaveLength(592)
+    expect(numbers[0]).toBe(1)
+    expect(numbers[591]).toBe(592)
+  })
+
+  it('keeps L1 free of content rows (pure locator)', () => {
+    const lines = Array.from({ length: 40 }, (_, i) => `a.ts:${String(i + 1)}: content row ${String(i)}`)
+    const output = reduceFreshToolResult(searchInput(lines.join('\n'), 700))
+    expect(output).not.toBeNull()
+    const locatorLine = output!.text.split('\n').find(line => line.startsWith('## a.ts'))
+    expect(locatorLine).toBeDefined()
+    expect(locatorLine).not.toContain('content row')
+  })
+
+  it('announces withheld locators visibly instead of silently truncating', () => {
+    // Budget too small for the full L1 set: the header must state how much
+    // was withheld rather than quietly shrinking the list.
+    const lines = [
+      ...Array.from({ length: 300 }, (_, i) => `big.ts:${String(i + 1)}: hit ${String(i)}`),
+      ...Array.from({ length: 5 }, (_, i) => `small.ts:${String(i + 1)}: hit ${String(i)}`),
+    ].join('\n')
+    const output = reduceFreshToolResult(searchInput(lines, 900))
+    expect(output).not.toBeNull()
+    expect(output!.text).toMatch(/withheld|more (?:files|matches)/i)
+  })
+})
+
+describe('search L2 water-filling (R10)', () => {
+  it('serves every file one round before any file takes a second row', () => {
+    const fat = Array.from({ length: 500 }, (_, i) => `fat.ts:${String(i + 1)}: fat file row ${String(i)}`)
+    const mid = Array.from({ length: 10 }, (_, i) => `mid.ts:${String(i + 1)}: mid file row ${String(i)}`)
+    const thin = Array.from({ length: 5 }, (_, i) => `thin.ts:${String(i + 1)}: thin file row ${String(i)}`)
+    // Tight content quota: only ~15 rows fit after L1. Round-robin must give
+    // each file a row per round — the old "fill from index 0" let the first
+    // file eat the whole quota.
+    const output = reduceFreshToolResult(searchInput([...fat, ...mid, ...thin].join('\n'), 1_600))
+    expect(output).not.toBeNull()
+    const counts = new Map<string, number>()
+    for (const line of output!.text.split('\n')) {
+      const match = /^(fat|mid|thin)\.ts:\d+:/.exec(line)
+      if (match !== null) counts.set(match[1]!, (counts.get(match[1]!) ?? 0) + 1)
+    }
+    expect(counts.get('fat')!).toBeGreaterThan(0)
+    expect(counts.get('mid')!).toBeGreaterThan(0)
+    expect(counts.get('thin')!).toBeGreaterThan(0)
+  })
+
+  it('exhausts small files before the big file takes the remaining quota', () => {
+    const fat = Array.from({ length: 500 }, (_, i) => `fat.ts:${String(i + 1)}: fat file row ${String(i)}`)
+    const mid = Array.from({ length: 10 }, (_, i) => `mid.ts:${String(i + 1)}: mid file row ${String(i)}`)
+    const thin = Array.from({ length: 5 }, (_, i) => `thin.ts:${String(i + 1)}: thin file row ${String(i)}`)
+    // Generous quota after L1: mid and thin end up FULLY covered (100% of
+    // their rows) while fat takes only what is left.
+    const output = reduceFreshToolResult(searchInput([...fat, ...mid, ...thin].join('\n'), 6_000))
+    const counts = new Map<string, number>()
+    for (const line of output!.text.split('\n')) {
+      const match = /^(fat|mid|thin)\.ts:\d+:/.exec(line)
+      if (match !== null) counts.set(match[1]!, (counts.get(match[1]!) ?? 0) + 1)
+    }
+    expect(counts.get('thin')).toBe(5)
+    expect(counts.get('mid')).toBe(10)
+    expect(counts.get('fat')!).toBeGreaterThan(0)
+  })
+
+  it('keeps error rows available to the quota', () => {
+    const rows = Array.from({ length: 40 }, (_, i) => `app.ts:${String(i + 1)}: ordinary row ${String(i)}`)
+    rows.push('app.ts:99: FATAL: unhandled rejection in loader')
+    // Tight quota: round 0 must reach the important row (offered first within
+    // the file) even though 40 ordinary rows outrank it by line number.
+    const output = reduceFreshToolResult(searchInput(rows.join('\n'), 900))
+    expect(output).not.toBeNull()
+    expect(output!.text).toContain('FATAL: unhandled rejection in loader')
+  })
+
+  it('falls back to salience when no path:line form exists', () => {
+    const output = reduceFreshToolResult(searchInput([
+      ...Array.from({ length: 60 }, (_, i) => `ordinary output line ${String(i)} without any locators at all`),
+      'FATAL: something exploded without a path prefix',
+    ].join('\n'), 1_200))
+    expect(output?.reducer).toBe('search-salience')
+  })
+})