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

package/packages/selector/tests/runtime/advisor-invariant.spec.ts

@@ -0,0 +1,272 @@
+/**
+ * Advisor integration and the advisory-only invariant.
+ *
+ * The invariant this spec exists to pin (K13): the advisor is statistics and
+ * suggestions only. Whatever its channel returns — extreme scores, a hostile
+ * summary, garbage, or nothing at all — `pruneSession` must land exactly the
+ * same reductions it lands with the advisor off and the state empty.
+ */
+import { describe, expect, it } from 'vitest'
+import { Context } from '@deepseek-ai/cordis'
+import {
+  ToolCallId as CallId,
+  createMessage,
+  createUserMessage,
+  createToolResultMessage,
+} from '@deepseek-ai/dsh-llm'
+import { canonicalHeader, Session, SessionId } from '@deepseek-ai/dsh-session'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import SessionProjectionRegistry from '@deepseek-ai/dsh-session-projection'
+import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
+import TokenMeter from '@deepseek-ai/dsh-token-meter'
+import ToolRuntime from '@deepseek-ai/dsh-tools'
+import SessionStore from '@deepseek-ai/dsh-session'
+import ToolResultPruner from '../../src/pruner.ts'
+import {
+  collectTaskSemantics,
+  runSessionAdvisorPass,
+  type AdvisorCandidate,
+} from '../../src/runtime/tokenpilot/advisor.ts'
+import { getAdvisorState, recordScore } from '../../src/runtime/tokenpilot/advisor-state.ts'
+import type { AdvisorOutcomeAuditRecord } from '../../src/runtime/audit.ts'
+import type { AdvisorChannel } from '../../src/runtime/tokenpilot/advisor.ts'
+
+// ── Orchestration against a scripted channel ───────────────────────────────
+
+const CANDIDATES: AdvisorCandidate[] = [
+  { seq: 3, characterPressure: 4_000, preview: 'auth module login flow' },
+  { seq: 5, characterPressure: 6_000, preview: 'database migration notes' },
+]
+
+const TASK = {
+  source: 'todos' as const,
+  todoVersion: 'aaaa1111',
+  taskText: 'migrate the auth module',
+}
+
+function advisorInput(turn: number, signal: AbortSignal): Parameters<typeof runSessionAdvisorPass>[3] {
+  return {
+    profile: 'tokenpilot-inspired',
+    turn,
+    candidates: CANDIDATES,
+    task: TASK,
+    advisor: { refreshTurns: 8, scoreThreshold: 0.35, sampleLimit: 16, minTokens: 250 },
+    tailText: 'working on the migration',
+    signal,
+  }
+}
+
+function scriptedChannel(responses: (string | undefined)[]): { channel: AdvisorChannel, calls: { system: string, user: string }[] } {
+  const calls: { system: string, user: string }[] = []
+  return {
+    calls,
+    channel: {
+      identity: () => 'host:mock/model',
+      ask: async request => {
+        calls.push({ system: request.system, user: request.user })
+        return responses.shift()
+      },
+    },
+  }
+}
+
+describe('runSessionAdvisorPass orchestration (K11)', () => {
+  it('writes summary, scores, recertification marks, and emits three audits on success', async () => {
+    const session = Session.create(SessionId('advisor-ok'))
+    const { channel, calls } = scriptedChannel([
+      '{"overallTask":"migrate the auth module","activeSubtasks":["port login flow"],"keywords":["auth","login"]}',
+      '{"seq":3,"score":0.95,"reason":"current task"}\n{"seq":5,"score":0.10,"reason":"stale"}',
+    ])
+    const audits: AdvisorOutcomeAuditRecord[] = []
+    const outcome = await runSessionAdvisorPass(session, channel, record => audits.push(record), advisorInput(4, new AbortController().signal))
+
+    expect(calls).toHaveLength(2)
+    expect(outcome).toBeDefined()
+    const state = getAdvisorState(session)
+    expect(state.summary?.overallTask).toBe('migrate the auth module')
+    expect(state.scores.get(3)?.score).toBe(0.95)
+    expect(state.scores.get(5)?.score).toBe(0.10)
+    // Below-threshold segment recertified as a suggestion only.
+    expect(state.recertified.get(5)).toBe(4)
+    expect(state.recertified.has(3)).toBe(false)
+    expect(state.watermarkSeq).toBe(5)
+    expect(audits.map(record => record.phase)).toEqual(['summary', 'scoring', 'decay'])
+    expect(audits.every(record => record.ok)).toBe(true)
+    expect(audits.find(record => record.phase === 'decay')?.decay).toBeDefined()
+  })
+
+  it('leaves state untouched and audits ok:false when the channel answers nothing', async () => {
+    const session = Session.create(SessionId('advisor-fail'))
+    const { channel, calls } = scriptedChannel([undefined, undefined])
+    const audits: AdvisorOutcomeAuditRecord[] = []
+    const outcome = await runSessionAdvisorPass(session, channel, record => audits.push(record), advisorInput(2, new AbortController().signal))
+
+    expect(outcome).toBeUndefined()
+    expect(calls).toHaveLength(1) // summary failed; scoring never ran
+    const state = getAdvisorState(session)
+    expect(state.summary).toBeUndefined()
+    expect(state.scores.size).toBe(0)
+    expect(audits).toHaveLength(1)
+    expect(audits[0]?.ok).toBe(false)
+    expect(audits[0]?.reason).toBe('channel-empty')
+    expect(state.inFlight).toBe(false)
+  })
+
+  it('skips entirely while a pass is in flight (re-entry guard)', async () => {
+    const session = Session.create(SessionId('advisor-reentry'))
+    const { channel, calls } = scriptedChannel([])
+    const state = getAdvisorState(session)
+    state.inFlight = true
+    const outcome = await runSessionAdvisorPass(session, channel, () => undefined, advisorInput(1, new AbortController().signal))
+    expect(outcome).toBeUndefined()
+    expect(calls).toHaveLength(0)
+    state.inFlight = false
+  })
+
+  it('does not advance the watermark on failure, so candidates rescore later', async () => {
+    const session = Session.create(SessionId('advisor-watermark'))
+    const failing = scriptedChannel([undefined])
+    await runSessionAdvisorPass(session, failing.channel, () => undefined, advisorInput(1, new AbortController().signal))
+    expect(getAdvisorState(session).watermarkSeq).toBe(0)
+
+    const succeeding = scriptedChannel([
+      '{"overallTask":"t","activeSubtasks":[],"keywords":["auth"]}',
+      '{"seq":3,"score":0.9}',
+    ])
+    const audits: AdvisorOutcomeAuditRecord[] = []
+    const outcome = await runSessionAdvisorPass(session, succeeding.channel, record => audits.push(record), advisorInput(2, new AbortController().signal))
+    expect(outcome).toBeDefined()
+    expect(getAdvisorState(session).watermarkSeq).toBe(3)
+  })
+
+  it('returns undefined without any channel call when the session has no task semantics', async () => {
+    const session = Session.create(SessionId('advisor-notask'))
+    const { channel, calls } = scriptedChannel(['{"overallTask":"x","keywords":["k"]}'])
+    const outcome = await runSessionAdvisorPass(session, channel, () => undefined, {
+      ...advisorInput(1, new AbortController().signal),
+      task: undefined,
+    })
+    expect(outcome).toBeUndefined()
+    expect(calls).toHaveLength(0)
+  })
+})
+
+describe('collectTaskSemantics over real event shapes', () => {
+  it('reads a todo/write event appended alongside message events', () => {
+    const events = [
+      {
+        type: 'user/message',
+        seq: 1,
+        time: 0,
+        data: { content: [{ type: 'text', text: 'start the migration' }] },
+      },
+      {
+        type: 'todo/write',
+        seq: 2,
+        time: 0,
+        data: { todos: ['migrate the auth module', { content: 'write tests', status: 'pending' }] },
+      },
+    ] as unknown as readonly SessionEvent[]
+    const task = collectTaskSemantics(events)
+    expect(task?.source).toBe('todos')
+    expect(task?.taskText).toContain('write tests')
+  })
+})
+
+// ── K13: the advisory-only invariant, against the real pruner ──────────────
+
+describe('advisory-only invariant (K13): advisor outputs never change landings', () => {
+  async function prunedResult(session: Session): Promise<unknown> {
+    const ctx = new Context()
+    try {
+      await ctx.plugin(SessionStore).await()
+      await ctx.plugin(SystemPrompt).await()
+      await ctx.plugin(ToolRuntime).await()
+      await ctx.plugin(SessionProjectionRegistry).await()
+      await ctx.plugin(TokenMeter).await()
+      await ctx.plugin(ToolResultPruner, {
+        profile: 'native',
+        nativeTriggerTokens: 100,
+        nativeTargetTokens: 64,
+        headChars: 8,
+        tailChars: 8,
+      }).await()
+      return ctx.toolResultPruner.pruneSession(session, { stage: 'pressure' })
+    } finally {
+      await ctx.fiber.dispose()
+    }
+  }
+
+  function buildSession(id: string): Session {
+    const session = Session.create(SessionId(id))
+    const callId = CallId('call-1')
+    session.append('turn/start', { turn: 1 })
+    session.append('request/header', {
+      reason: 'initial',
+      header: canonicalHeader({ config: { provider: 'deepseek', model: 'deepseek-v4-flash' } }),
+    })
+    session.append('user/message', createUserMessage({
+      content: [{ type: 'text', text: 'please inspect the failing module' }],
+      source: { kind: 'user' },
+    }), { surfaceOp: 'append' })
+    session.append('step/start', { turn: 1, step: 1 })
+    session.append('assistant/message', {
+      stream: [],
+      turn: 1,
+      step: 1,
+      message: createMessage({
+        role: 'assistant',
+        content: [{ type: 'tool-call', id: callId, name: 'bash', arguments: '{}' }],
+        source: { kind: 'model', provider: 'deepseek', model: 'deepseek-v4-flash' },
+      }),
+    }, { surfaceOp: 'append' })
+    session.append('tool/call', { turn: 1, step: 1, callId, name: 'bash', arguments: '{}' })
+    session.append('tool/result', {
+      turn: 1,
+      step: 1,
+      message: createToolResultMessage({
+        callId,
+        content: [{ type: 'text', text: 'gate evidence '.repeat(800) }],
+        isError: false,
+      }),
+    }, { surfaceOp: 'append' })
+    session.append('step/end', { turn: 1, step: 1 })
+    // No turn/end: pruning lands its replacement inside the still-open turn.
+    return session
+  }
+
+  it('lands identically with the advisor off, and with extreme scores or a failed pass', async () => {
+    const scenarios: string[] = ['off', 'extreme-scores', 'failed-pass']
+    const shapes: unknown[] = []
+    for (const scenario of scenarios) {
+      // One shared session id: replacement markers embed it, and the advisor
+      // state is keyed by Session object identity, so this cannot cross-talk.
+      const session = buildSession('advisor-invariant')
+      if (scenario !== 'off') {
+        const state = getAdvisorState(session)
+        if (scenario === 'extreme-scores') {
+          state.summary = {
+            overallTask: 'ALL MUST BE KEPT',
+            activeSubtasks: ['keep everything forever'],
+            keywords: ['evidence'],
+            todoVersion: 'deadbeef',
+            turn: 1,
+          }
+          // Zero relevance everywhere: the most hostile score a channel could
+          // return must still not delete, delay, or rewrite anything.
+          recordScore(state, 2, { score: 0, turn: 1 })
+        }
+        if (scenario === 'failed-pass') {
+          state.failures = { failures: 9, cooldownUntil: Date.now() + 600_000 }
+        }
+      }
+      shapes.push(structuredClone(await prunedResult(session)))
+    }
+    for (const shape of shapes.slice(1)) {
+      expect(shape).toEqual(shapes[0])
+    }
+    // And the baseline scenario actually reduced something (the test is real).
+    const baseline = shapes[0] as { pruned: unknown[] }
+    expect(baseline.pruned).toHaveLength(1)
+  })
+})

package/packages/selector/tests/runtime/advisor.spec.ts

@@ -0,0 +1,226 @@
+import { describe, expect, it } from 'vitest'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import {
+  collectTaskSemantics,
+  prefixDecay,
+  selectScoringCandidates,
+  type AdvisorCandidate,
+} from '../../src/runtime/tokenpilot/advisor.ts'
+import {
+  ADVISOR_RECERTIFIED_LIMIT,
+  ADVISOR_SCORES_LIMIT,
+  getAdvisorState,
+  invalidateOnTaskChange,
+  recordRecertified,
+  recordScore,
+} from '../../src/runtime/tokenpilot/advisor-state.ts'
+import {
+  buildAdvisorScoringUserPrompt,
+  parseAdvisorScores,
+  parseAdvisorSummary,
+} from '../../src/runtime/tokenpilot/advisor-prompt.ts'
+
+function todoWriteEvent(data: unknown): SessionEvent {
+  return { type: 'todo/write', seq: 1, time: 0, data } as unknown as SessionEvent
+}
+
+function userMessageEvent(text: string): SessionEvent {
+  return {
+    type: 'user/message',
+    seq: 2,
+    time: 0,
+    data: { content: [{ type: 'text', text }] },
+  } as unknown as SessionEvent
+}
+
+describe('collectTaskSemantics (K5)', () => {
+  it('parses a structured todo/write payload', () => {
+    const semantics = collectTaskSemantics([
+      todoWriteEvent({ todos: [{ content: 'migrate gates', status: 'in_progress' }, 'write tests'] }),
+    ])
+    expect(semantics).toBeDefined()
+    expect(semantics?.source).toBe('todos')
+    expect(semantics?.taskText).toContain('migrate gates')
+    expect(semantics?.taskText).toContain('write tests')
+    // Same content ⇒ same version token (deterministic).
+    const again = collectTaskSemantics([todoWriteEvent({ todos: [{ content: 'migrate gates', status: 'in_progress' }, 'write tests'] })])
+    expect(again?.todoVersion).toBe(semantics?.todoVersion)
+  })
+
+  it('degrades a malformed todo payload to its raw JSON string', () => {
+    const semantics = collectTaskSemantics([todoWriteEvent({ todos: 'not-an-array' })])
+    expect(semantics).toBeDefined()
+    expect(semantics?.source).toBe('raw-todo')
+    expect(semantics?.taskText).toContain('not-an-array')
+  })
+
+  it('falls back to recent user/message text when no todo/write exists', () => {
+    const semantics = collectTaskSemantics([
+      userMessageEvent('earlier request'),
+      userMessageEvent('please refactor the pruner gates'),
+    ])
+    expect(semantics).toBeDefined()
+    expect(semantics?.source).toBe('messages')
+    expect(semantics?.taskText).toContain('refactor the pruner gates')
+  })
+
+  it('picks the most recent todo/write event', () => {
+    const semantics = collectTaskSemantics([
+      todoWriteEvent({ todos: ['old task'] }),
+      userMessageEvent('something else'),
+      todoWriteEvent({ todos: ['new task'] }),
+    ])
+    expect(semantics?.taskText).toBe('new task')
+  })
+
+  it('returns undefined for an empty log', () => {
+    expect(collectTaskSemantics([])).toBeUndefined()
+  })
+})
+
+describe('prefixDecay (K6)', () => {
+  const candidates: AdvisorCandidate[] = [
+    { seq: 1, characterPressure: 3_000, preview: 'a' },
+    { seq: 2, characterPressure: 1_000, preview: 'b' },
+  ]
+  // prefixDecay takes the weight face only; previews are scoring-prompt inputs.
+  const weights = candidates.map(({ seq, characterPressure }) => ({ seq, characterPressure }))
+
+  it('is deterministic and weights by character pressure', () => {
+    const scores = new Map([[1, { score: 0 }], [2, { score: 1 }]])
+    const first = prefixDecay(weights, scores)
+    const second = prefixDecay(weights, scores)
+    expect(first).toEqual(second)
+    // weight 3000×0 + 1000×1 over 4000 ⇒ relevance 0.25 ⇒ decay 0.75.
+    expect(first.decay).toBeCloseTo(0.75, 12)
+    expect(first.weightedChars).toBe(4_000)
+  })
+
+  it('counts unscored candidates as neutral 0.5', () => {
+    const decay = prefixDecay(weights, new Map())
+    expect(decay.decay).toBeCloseTo(0.5, 12)
+  })
+
+  it('is 0 with no candidates and ignores zero-pressure candidates', () => {
+    expect(prefixDecay([], new Map()).decay).toBe(0)
+    expect(prefixDecay([{ seq: 9, characterPressure: 0 }], new Map()).decay).toBe(0)
+  })
+})
+
+describe('selectScoringCandidates', () => {
+  const candidates: AdvisorCandidate[] = [
+    { seq: 1, characterPressure: 8_000, preview: 'auth module login handling' },
+    { seq: 2, characterPressure: 2_000, preview: 'tiny fragment' },
+    { seq: 3, characterPressure: 9_000, preview: 'login auth token refresh' },
+    { seq: 4, characterPressure: 12_000, preview: 'unrelated weather report' },
+  ]
+
+  it('applies the watermark, the character floor, and the sample limit', () => {
+    const state = { watermarkSeq: 1 }
+    const picked = selectScoringCandidates(candidates, state, {
+      taskKeywords: new Set(['login', 'auth', 'token']),
+      minChars: 4_000,
+      sampleLimit: 1,
+      taskChanged: false,
+    })
+    // seq 2 below floor, seq 1 at/below watermark; overlap ranks seq 3 first.
+    expect(picked.map(item => item.seq)).toEqual([3])
+  })
+
+  it('ignores the watermark when the task semantics changed', () => {
+    const picked = selectScoringCandidates(candidates, { watermarkSeq: 4 }, {
+      taskKeywords: new Set(['login']),
+      minChars: 4_000,
+      sampleLimit: 16,
+      taskChanged: true,
+    })
+    // Overlap ties (seq 1 and 3 both match "login") break by character pressure.
+    expect(picked.map(item => item.seq)).toEqual([3, 1, 4])
+  })
+})
+
+describe('advisor-state bounds (K8)', () => {
+  it('evicts the oldest score beyond the LRU limit', () => {
+    const session = {} as Parameters<typeof getAdvisorState>[0]
+    const state = getAdvisorState(session)
+    for (let seq = 0; seq < ADVISOR_SCORES_LIMIT + 10; seq += 1) {
+      recordScore(state, seq, { score: 0.5, turn: seq })
+    }
+    expect(state.scores.size).toBe(ADVISOR_SCORES_LIMIT)
+    expect(state.scores.has(0)).toBe(false)
+    expect(state.scores.has(ADVISOR_SCORES_LIMIT + 9)).toBe(true)
+    // Re-touching a seq moves it to the newest position.
+    recordScore(state, 10, { score: 0.9, turn: 999 })
+    recordScore(state, ADVISOR_SCORES_LIMIT + 10, { score: 0.1, turn: 1_000 })
+    expect(state.scores.has(10)).toBe(true)
+    expect(state.scores.size).toBe(ADVISOR_SCORES_LIMIT)
+  })
+
+  it('bounds recertified marks the same way', () => {
+    const session = {} as Parameters<typeof getAdvisorState>[0]
+    const state = getAdvisorState(session)
+    for (let seq = 0; seq < ADVISOR_RECERTIFIED_LIMIT + 5; seq += 1) {
+      recordRecertified(state, seq, seq)
+    }
+    expect(state.recertified.size).toBe(ADVISOR_RECERTIFIED_LIMIT)
+    expect(state.recertified.has(0)).toBe(false)
+  })
+
+  it('invalidates the summary when the task version changes', () => {
+    const session = {} as Parameters<typeof getAdvisorState>[0]
+    const state = getAdvisorState(session)
+    state.summary = { overallTask: 'x', activeSubtasks: [], keywords: [], todoVersion: 'aaa', turn: 1 }
+    state.lastSummaryTurn = 1
+    expect(invalidateOnTaskChange(state, 'bbb')).toBe(true)
+    expect(state.summary).toBeUndefined()
+    expect(state.lastSummaryTurn).toBe(-1)
+    expect(invalidateOnTaskChange(state, 'bbb')).toBe(false)
+  })
+})
+
+describe('advisor prompts (K7)', () => {
+  it('parses a well-formed summary answer', () => {
+    const parsed = parseAdvisorSummary(
+      'Sure! {"overallTask":"migrate gates","activeSubtasks":["port fresh gate"],"keywords":["gates","pruner"]}',
+    )
+    expect(parsed?.overallTask).toBe('migrate gates')
+    expect(parsed?.keywords).toEqual(['gates', 'pruner'])
+  })
+
+  it('fails open on a malformed summary answer', () => {
+    expect(parseAdvisorSummary(undefined)).toBeUndefined()
+    expect(parseAdvisorSummary('')).toBeUndefined()
+    expect(parseAdvisorSummary('not json at all')).toBeUndefined()
+    expect(parseAdvisorSummary('{"overallTask":""}')).toBeUndefined()
+    expect(parseAdvisorSummary('{"overallTask":"x"}')).toBeUndefined()
+  })
+
+  it('parses JSON-lines scoring answers and drops invalid rows', () => {
+    const parsed = parseAdvisorScores(
+      '{"seq":1,"score":0.9,"reason":"current task"}\n'
+      + 'noise line {"seq":2,"score":1.5}\n'
+      + '{"seq":99,"score":0.5}\n'
+      + '{"seq":3,"score":0.1}\n',
+      new Set([1, 2, 3]),
+    )
+    expect(parsed?.size).toBe(2)
+    expect(parsed?.get(1)?.score).toBe(0.9)
+    expect(parsed?.get(3)?.score).toBe(0.1)
+    expect(parsed?.has(2)).toBe(false)
+    expect(parsed?.has(99)).toBe(false)
+  })
+
+  it('fails open on empty or all-garbage scoring answers', () => {
+    expect(parseAdvisorScores(undefined, new Set([1]))).toBeUndefined()
+    expect(parseAdvisorScores('', new Set([1]))).toBeUndefined()
+    expect(parseAdvisorScores('garbage only', new Set([1]))).toBeUndefined()
+  })
+
+  it('builds a scoring prompt that keeps previews one-per-line', () => {
+    const prompt = buildAdvisorScoringUserPrompt('task text', ['sub'], [
+      { seq: 7, preview: 'some\npreview' },
+    ])
+    expect(prompt).toContain('task: task text')
+    expect(prompt).toContain('seq=7 | some preview')
+  })
+})

package/packages/selector/tests/runtime/audit.spec.ts

@@ -4,7 +4,7 @@ import {
   emitCompressionAudit,
   formatCompressionAudit,
 } from '../../src/runtime/audit.ts'
-import type { CompressionAuditRecord } from '../../src/runtime/audit.ts'
+import type { CompressionAuditRecord, CompressionRewriteAuditRecord } from '../../src/runtime/audit.ts'
 
 const custom = {
   version: 3 as const,
@@ -71,6 +71,7 @@ describe('context-compression audit records', () => {
       tokensRemoved: 600_000,
       tokenizerId: 'mock-tokenizer',
       tokenizerRevision: 'r1',
+      measurementBasis: 'exact-tokenizer',
     }
 
     const parsed = JSON.parse(
@@ -82,6 +83,48 @@ describe('context-compression audit records', () => {
       .toBe(record.tokensBefore - record.tokensAfter)
   })
 
+  // task_4c/G7: the elided-line count rides the rewrite audit record (optional,
+  // JSON round-trip) so the compress→retrieve M/N ratio is computable from
+  // session logs alone; records without reducer telemetry omit the field.
+  it('round-trips elidedLines on rewrite records and omits it when absent', () => {
+    const withTelemetry: CompressionAuditRecord = {
+      schemaVersion: 1,
+      kind: 'rewrite',
+      sessionId: 'telemetry-session',
+      profile: 'balanced',
+      component: 'fresh',
+      stage: 'fresh',
+      reducer: 'hypa-code-skeleton',
+      manifestEventType: 'compaction/prune',
+      manifestSeq: 7,
+      replacementSeq: 8,
+      sourceSeqs: [6],
+      tokensBefore: 20_000,
+      tokensAfter: 3_000,
+      tokensRemoved: 17_000,
+      tokenizerId: 'mock-tokenizer',
+      tokenizerRevision: 'r1',
+      measurementBasis: 'exact-tokenizer',
+      elidedLines: 412,
+    }
+    const parsed = JSON.parse(
+      formatCompressionAudit(withTelemetry).slice(COMPRESSION_AUDIT_PREFIX.length),
+    ) as CompressionRewriteAuditRecord
+    expect(parsed.elidedLines).toBe(412)
+
+    const { elidedLines: _omitted, ...placeholderRecord } = withTelemetry
+    void _omitted
+    const withoutTelemetry: CompressionAuditRecord = {
+      ...placeholderRecord,
+      reducer: 'error-evidence-placeholder',
+    }
+    expect('elidedLines' in withoutTelemetry).toBe(false)
+    const parsedWithout = JSON.parse(
+      formatCompressionAudit(withoutTelemetry).slice(COMPRESSION_AUDIT_PREFIX.length),
+    ) as CompressionRewriteAuditRecord
+    expect(parsedWithout.elidedLines).toBeUndefined()
+  })
+
   it('publishes exactly one single-line info message', () => {
     const info = vi.fn()
     const record: CompressionAuditRecord = {
@@ -170,4 +213,48 @@ describe('context-compression audit records', () => {
     ) as CompressionAuditRecord
     expect(parsed).toEqual(record)
   })
+
+  it('keeps advisor-outcome records free of prompts, keys, and content', () => {
+    const record: CompressionAuditRecord = {
+      schemaVersion: 1,
+      kind: 'advisor-outcome',
+      sessionId: 'advisor-session',
+      phase: 'decay',
+      ok: true,
+      sampledCount: 16,
+      decay: 0.42,
+      weightedChars: 57_688,
+      turnIndex: 12,
+      latencyMs: 0,
+    }
+
+    const line = formatCompressionAudit(record)
+    const parsed = JSON.parse(line.slice(COMPRESSION_AUDIT_PREFIX.length)) as CompressionAuditRecord
+    expect(parsed).toEqual(record)
+    // Only enums and numbers: never the todo snapshot, assistant text, prompts, or keys.
+    expect(line).not.toContain('prompt')
+    expect(line).not.toContain('"content"')
+    expect(line).not.toContain('"text"')
+    expect(line).not.toContain('apiKey')
+    expect(line).not.toContain('todo')
+  })
+
+  it('carries failure reason codes and the LLM channel on advisor-outcome records', () => {
+    const record: CompressionAuditRecord = {
+      schemaVersion: 1,
+      kind: 'advisor-outcome',
+      sessionId: 'advisor-session',
+      phase: 'scoring',
+      channel: 'direct',
+      ok: false,
+      sampledCount: 0,
+      turnIndex: 3,
+      reason: 'no-direct-endpoint',
+      latencyMs: 4,
+    }
+    const parsed = JSON.parse(
+      formatCompressionAudit(record).slice(COMPRESSION_AUDIT_PREFIX.length),
+    ) as CompressionAuditRecord
+    expect(parsed).toEqual(record)
+  })
 })

package/packages/selector/tests/runtime/char-basis.spec.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest'
+
+import { CHARS_PER_TOKEN, charsForTokens, charsToTokens } from '../../src/runtime/config.ts'
+
+describe('character basis conversion', () => {
+  it('derives zero tokens for non-positive or non-finite character counts', () => {
+    expect(charsToTokens(0)).toBe(0)
+    expect(charsToTokens(-1)).toBe(0)
+    expect(charsToTokens(NaN)).toBe(0)
+    expect(charsToTokens(Infinity)).toBe(0)
+  })
+
+  it('derives the telemetry token figure from characters', () => {
+    expect(charsToTokens(1)).toBe(1)
+    expect(charsToTokens(4)).toBe(1)
+    expect(charsToTokens(5)).toBe(1)
+    expect(charsToTokens(8)).toBe(2)
+  })
+
+  it('expresses token-named gates on the character basis', () => {
+    expect(charsForTokens(0)).toBe(0)
+    expect(charsForTokens(1000)).toBe(4000)
+    expect(CHARS_PER_TOKEN).toBe(4.0)
+  })
+
+  it('stays finite at the integer upper bound (off/native gates must not misfire)', () => {
+    expect(Number.isFinite(charsForTokens(Number.MAX_SAFE_INTEGER))).toBe(true)
+    expect(charsForTokens(Number.MAX_SAFE_INTEGER)).toBeLessThan(Infinity)
+  })
+})

package/packages/selector/tests/runtime/code-skeleton.spec.ts

@@ -73,7 +73,10 @@ describe('hypa-code-skeleton reducer', () => {
     expect(output?.text).toContain('export interface Options {')
     expect(output?.text).toContain('export function runJob(job: string,')
     expect(output?.text).toContain('class Runner {')
-    expect(output?.text).toContain('lines elided')
+    // R9b: elision markers cite original-event line ranges instead of a bare
+    // count, and the header hint carries a pasteable start_line.
+    expect(output?.text).toMatch(/\[\.\.\. lines \d+-\d+ elided \(\d+ lines\)/)
+    expect(output?.text).toContain('"start_line":')
     expect(output?.text).not.toContain('const started = Date.now()')
     expect(output?.text).toContain(SOURCE_REF)
     expect(verifyReduction(input, output!)).toBe(true)
@@ -112,12 +115,20 @@ describe('hypa-code-skeleton reducer', () => {
     expect(codePointLength(output!.text)).toBeLessThanOrEqual(1_200)
   })
 
-  it('leaves prose on the existing head reducer', () => {
+  // R8b moved this landing spot on purpose: unstructured prose used to fall
+  // to pi-head (head-only — middle and tail dropped); it now goes through the
+  // universal prose-keep reducer, which retains head AND tail plus an R9
+  // line-range marker. Code-like read results still land on pi-head (the
+  // prose-keep path declines looksLikeSourceCode), pinned two cases below.
+  it('lands read-tool prose on the prose-keep reducer with head and tail', () => {
     const prose = Array.from({ length: 200 }, (_, i) =>
       `Paragraph ${String(i)} explains a concept in plain sentences with no code structure at all.`).join('\n')
     const input = readInput(prose)
     const output = reduceFreshToolResult(input)
-    expect(output?.reducer).toBe('pi-head')
+    expect(output?.reducer).toBe('prose-keep')
+    const lines = output!.text.split('\n')
+    expect(lines[0]).toContain('Paragraph 0')
+    expect(lines.at(-1)).toContain('Paragraph 199')
   })
 
   it('does not fire on small or sparse content', () => {