dsh-context-compression-improved 0.4.0 → 0.5.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

@@ -213,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/tokenpilot/profile-baseline.spec.ts

@@ -66,6 +66,18 @@ describe('tokenpilot-inspired preset', () => {
       reviewTimeoutTurns: 6,
       cacheHitDiscountAlpha: 0.1,
       reviewHighImpactTokens: 4000,
+      // Advisory advisor ships off with its documented defaults. The
+      // resolved matrix intentionally gains this group so it follows the
+      // estimator's resolved-consumption pattern; see
+      // .agents/plans/ctx-relevance-advisor/spec.md decision record.
+      advisor: {
+        mode: '',
+        timeoutMs: 8000,
+        refreshTurns: 8,
+        scoreThreshold: 0.35,
+        sampleLimit: 16,
+        minTokens: 250,
+      },
     })
     // Other profiles never carry the capability matrix.
     expect(resolvePolicy(config, 'balanced').presetOptions).toBeUndefined()

package/packages/selector/tests/standing-generation.host.spec.ts

@@ -101,6 +101,37 @@ async function overlayFiles(sourceMarker: string): Promise<{ path: string, rende
   return files
 }
 
+/**
+ * The mtime this platform actually persists for one given stamp.
+ *
+ * `node:fs` `utimes` writes the seconds component through a 32-bit field on
+ * Windows: on node v22 win32, `utimes(file, 4677832452 s)` reads back as
+ * `382865156 s` — exactly `seconds >>> 0` — while sub-second precision
+ * survives. The standing stamp deliberately parks identities around year 2162
+ * (`STANDING_MTIME_EPOCH_SECONDS + 0xffffffff`, src/preset-overlay.ts), so its
+ * seconds component sits past that 2^32-second horizon (max year 2106) and the
+ * persisted literal differs on that platform. Deterministically so: the wrap is
+ * a pure function of the identity stamp, which is why identity → mtime stays
+ * stable and the collision escalation still absorbs any merge.
+ *
+ * Instead of hardcoding the platform or weakening the assertion, calibrate:
+ * ask the filesystem what it stores for exactly this stamp, then require the
+ * overlay to persist that same value. On a platform with a full-width seconds
+ * field this collapses to the stamp itself, so the assertion stays strict.
+ */
+async function platformPersistedMs(stampMs: number): Promise<number> {
+  const directory = await mkdtemp(join(tmpdir(), 'dsh-selector-mtime-probe-'))
+  const probe = join(directory, 'probe')
+  try {
+    await writeFile(probe, 'probe')
+    const stamp = new Date(stampMs)
+    await utimes(probe, stamp, stamp)
+    return (await stat(probe)).mtimeMs
+  } finally {
+    await rm(directory, { recursive: true, force: true })
+  }
+}
+
 let sourceRoot: string | undefined
 
 /** Rewrite the source preset to an equal-length marker module. */
@@ -329,8 +360,17 @@ describe('real AgentPresets standing generations with the overlay threshold', ()
     expect(firstStat.size).toBe(secondStat.size)
     expect(firstStat.mtimeMs % 1000).toBe(0)
     expect(secondStat.mtimeMs % 1000).toBe(0)
-    expect(firstStat.mtimeMs).toBe(Math.floor(standingStampMsAtWindow(collision.firstIdentity, 0) / 1000) * 1000)
-    expect(secondStat.mtimeMs).toBe(Math.floor(standingStampMsAtWindow(collision.secondIdentity, 1) / 1000) * 1000)
+    // The coarse metadata surface floors both stamps to a whole second, and the
+    // platform may additionally wrap the seconds field (platformPersistedMs),
+    // so require exactly what the filesystem stores for those identity stamps.
+    const firstStamp = await platformPersistedMs(
+      Math.floor(standingStampMsAtWindow(collision.firstIdentity, 0) / 1000) * 1000,
+    )
+    const secondStamp = await platformPersistedMs(
+      Math.floor(standingStampMsAtWindow(collision.secondIdentity, 1) / 1000) * 1000,
+    )
+    expect(Math.floor(firstStat.mtimeMs / 1000)).toBe(Math.floor(firstStamp / 1000))
+    expect(Math.floor(secondStat.mtimeMs / 1000)).toBe(Math.floor(secondStamp / 1000))
 
     await installation.dispose()
   })
@@ -382,11 +422,19 @@ describe('real AgentPresets standing generations with the overlay threshold', ()
     expect(files.length).toBeGreaterThanOrEqual(3)
     const buckets = await Promise.all(files.map(async file => Math.floor((await stat(file.path)).mtimeMs / 1000)))
     expect(new Set(buckets).size).toBe(buckets.length)
-    // No staging leftovers survive a publish.
+    // No staging leftovers survive a publish. A spec file running in parallel
+    // disposes its own store while this scan runs, so a vanished directory means
+    // "no leftovers to find" rather than a failure (mirrors overlayFiles).
     const storeDirs = await Promise.all(
       (await readdir(tmpdir(), { withFileTypes: true }))
         .filter(entry => entry.isDirectory() && entry.name.startsWith('dsh-context-compression-presets-'))
-        .map(async entry => readdir(join(tmpdir(), entry.name))),
+        .map(async entry => {
+          try {
+            return await readdir(join(tmpdir(), entry.name))
+          } catch {
+            return []
+          }
+        }),
     )
     expect(storeDirs.flat().some(name => name.endsWith('.tmp'))).toBe(false)
 
@@ -451,8 +499,9 @@ describe('real AgentPresets standing generations with the overlay threshold', ()
       ? /standard-([0-9a-f]+)\.agent\.cordis\.yml$/u.exec(files[0]!.path)?.[1]
       : undefined
     expect(identity).toBeDefined()
+    const persistedStamp = await platformPersistedMs(standingStampMs(identity as string))
     expect(Math.floor(details.mtimeMs / 1000))
-      .toBe(Math.floor(standingStampMs(identity as string) / 1000))
+      .toBe(Math.floor(persistedStamp / 1000))
     const observedSubSecond = details.mtimeMs % 1000
     const expectedSubSecond = standingStampMs(identity as string) % 1000
     expect(observedSubSecond === 0 || Math.abs(observedSubSecond - expectedSubSecond) < 1).toBe(true)

package/scripts/packed-components-smoke.mjs

@@ -561,13 +561,25 @@ try {
       && JSON.stringify(originalImage).includes('packed-image-800x600')
       && JSON.stringify(originalImage).includes('"type":"image"'),
     'packed vision image-bearing result is no longer intact on the surface')
+    // The character basis retired the `exact-tokenizer-unavailable` skip: a
+    // History planning skip can no longer refuse for a missing exact count (see
+    // the HistoryPlanOutcome note in src/pruner/types.ts). A vision session
+    // without the exact tokenizer is therefore judged on characters and its
+    // skip carries a real reason (observed: fresh/aggregate `at-or-below-
+    // trigger`, history `below-profile-trigger`) — assert that observable
+    // contract instead of the removed literal.
     for (const component of ['fresh', 'history']) {
-      assert(visionAudit.some(record => record.kind === 'component-evaluation'
-        && record.sessionId === String(visionImage.id)
-        && record.component === component
-        && record.status === 'skipped'
-        && record.reason === 'exact-tokenizer-unavailable'),
-      `packed vision image session lacks the ${component} exact-tokenizer-unavailable audit`)
+      const record = visionAudit.find(entry => entry.kind === 'component-evaluation'
+        && entry.sessionId === String(visionImage.id)
+        && entry.component === component)
+      assert(record !== undefined,
+        `packed vision image session lacks the ${component} component-evaluation audit`)
+      assert(record.status === 'skipped',
+        `packed vision ${component} status is ${String(record.status)}, expected skipped`)
+      assert(record.measurementKind === 'characters',
+        `packed vision ${component} was decided on ${String(record.measurementKind)}, expected characters`)
+      assert(typeof record.reason === 'string' && record.reason.length > 0,
+        `packed vision ${component} skip carries no diagnostic reason`)
     }
 
     console.info(`PACKED_VISION_E2E ${JSON.stringify({
@@ -651,9 +663,19 @@ try {
     && firstIndex('history') < firstIndex('tail-trim'),
   'installed component rewrite order is wrong')
   const pipelineRewrites = rewrites.filter(record => record.sessionId === String(session.id))
+  // The character basis decides on Unicode code points, so a committed rewrite
+  // may report an unchanged token figure while still reclaiming characters
+  // (observed once here: history `historical-tool-result-aging` landed at
+  // 129 -> 129 with tokensRemoved 0). The rewrite audit carries no character
+  // field yet, so assert what the basis can actually guarantee: integer
+  // accounting, a consistent removal figure, and never an increase. A strict
+  // token decrease would re-encode the retired exact-token authority — see the
+  // measurementBasis note in src/runtime/audit.ts.
   assert(pipelineRewrites.every(record => Number.isSafeInteger(record.tokensBefore)
-    && Number.isSafeInteger(record.tokensAfter) && record.tokensBefore > record.tokensAfter),
-  'installed rewrite lacks exact decreasing token evidence')
+    && Number.isSafeInteger(record.tokensAfter)
+    && record.tokensBefore >= record.tokensAfter
+    && record.tokensRemoved === record.tokensBefore - record.tokensAfter),
+  'installed rewrite token accounting is inconsistent or increasing')
   assert(audit.some(record => record.kind === 'native-auto-compact'
     && record.sessionId === String(session.id)),
   'installed Runtime did not audit official Native summary')

package/scripts/packed-install-e2e.mjs

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto'
 import { spawn } from 'node:child_process'
 import { createReadStream } from 'node:fs'
 import { copyFile, mkdir, mkdtemp, readFile, readdir, realpath, rm, stat, writeFile } from 'node:fs/promises'
-import { readFileSync } from 'node:fs'
+import { readFileSync, readdirSync } from 'node:fs'
 import { createServer } from 'node:http'
 import { createRequire } from 'node:module'
 import { tmpdir } from 'node:os'
@@ -27,8 +27,17 @@ const officialHostPackages = Object.entries(rootManifest.devDependencies)
   .filter(([name]) => name.startsWith('@deepseek-ai/'))
   .map(([name, version]) => `${name}@${version}`)
 
+// Only the package-manager shims need a shell on Windows; every real executable
+// must be spawned directly, because cmd.exe re-parses arguments: `^` is its
+// escape character, so `HEAD^{tree}` reached git as `HEAD{tree}`, and a
+// multi-line `node -e` settings script was cut at its first newline into
+// `[eval]:1 const` / `SyntaxError: Unexpected end of input`. Both killed the
+// official-clone leg for reasons unrelated to what it asserts.
+const SHELL_COMMANDS = new Set(['npm', 'npm.cmd', 'pnpm', 'pnpm.cmd'])
+const usesShell = (command) => process.platform === 'win32' && SHELL_COMMANDS.has(command)
+
 const run = (command, args, options = {}) => new Promise((resolve, reject) => {
-  const child = spawn(command, args, { stdio: 'inherit', shell: process.platform === 'win32', ...options })
+  const child = spawn(command, args, { stdio: 'inherit', shell: usesShell(command), ...options })
   child.once('error', reject)
   child.once('exit', (code, signal) => {
     if (code === 0) resolve()
@@ -37,7 +46,7 @@ const run = (command, args, options = {}) => new Promise((resolve, reject) => {
 })
 
 const capture = (command, args, options = {}) => new Promise((resolve, reject) => {
-  const child = spawn(command, args, { shell: process.platform === 'win32', ...options, stdio: ['ignore', 'pipe', 'pipe'] })
+  const child = spawn(command, args, { shell: usesShell(command), ...options, stdio: ['ignore', 'pipe', 'pipe'] })
   let stdout = ''
   let stderr = ''
   child.stdout.setEncoding('utf8')
@@ -56,7 +65,7 @@ const capture = (command, args, options = {}) => new Promise((resolve, reject) =
 })
 
 const captureOutcome = (command, args, options = {}) => new Promise((resolve, reject) => {
-  const child = spawn(command, args, { shell: process.platform === 'win32', ...options, stdio: ['ignore', 'pipe', 'pipe'] })
+  const child = spawn(command, args, { shell: usesShell(command), ...options, stdio: ['ignore', 'pipe', 'pipe'] })
   let stdout = ''
   let stderr = ''
   child.stdout.setEncoding('utf8')
@@ -306,7 +315,23 @@ async function runOfficialCloneCliSmoke(referenceRoot, registry, upgradeFrom, ca
   const dshHome = join(temporaryRoot, 'dsh-home')
   let added = false
   const environment = { ...process.env, DSH_HOME: dshHome }
-  const dsh = (...args) => run('pnpm', ['dsh', ...args], { cwd: worktree, env: environment })
+  let lastLifecycle = { command: '(none)', code: 0, stdout: '', stderr: '' }
+  const dsh = async (...args) => {
+    const outcome = await captureOutcome('pnpm', ['dsh', ...args], { cwd: worktree, env: environment })
+    lastLifecycle = {
+      command: `pnpm dsh ${args.join(' ')}`,
+      code: outcome.code ?? -1,
+      stdout: outcome.stdout,
+      stderr: outcome.stderr,
+    }
+    if (outcome.code !== 0) {
+      throw new Error([
+        `${lastLifecycle.command} exited ${String(lastLifecycle.code)}`,
+        outcome.stdout.trim(),
+        outcome.stderr.trim(),
+      ].filter(Boolean).join('\n'))
+    }
+  }
   const dumpConfig = () => capture('pnpm', ['dsh', '--profile', 'web', '--dump-config'], {
     cwd: worktree,
     env: environment,
@@ -316,7 +341,36 @@ async function runOfficialCloneCliSmoke(referenceRoot, registry, upgradeFrom, ca
   const profilePackages = () => {
     const profileRoot = join(dshHome, 'profiles/web')
     const profileRequire = createRequire(join(profileRoot, 'package.json'))
-    const selectorPath = profileRequire.resolve('dsh-context-compression-improved/package.json')
+    let selectorPath
+    try {
+      selectorPath = profileRequire.resolve('dsh-context-compression-improved/package.json')
+    } catch (error) {
+      // A silent no-op lifecycle command is the difference between "the package
+      // manager refused" and "the CLI exited 0 without installing anything";
+      // carry that evidence instead of a bare MODULE_NOT_FOUND.
+      const declared = (() => {
+        try {
+          return JSON.stringify(JSON.parse(readFileSync(join(profileRoot, 'package.json'), 'utf8')).dependencies ?? {})
+        } catch {
+          return '(profile package.json unreadable)'
+        }
+      })()
+      const installed = (() => {
+        try {
+          return JSON.stringify(readdirSync(join(profileRoot, 'node_modules')).slice(0, 40))
+        } catch {
+          return '(profiles/web/node_modules unreadable)'
+        }
+      })()
+      throw new Error([
+        `official profile ${profileRoot} does not resolve dsh-context-compression-improved`,
+        `last lifecycle: ${lastLifecycle.command} (exit ${String(lastLifecycle.code)})`,
+        `lifecycle stdout: ${lastLifecycle.stdout.trim()}`,
+        `lifecycle stderr: ${lastLifecycle.stderr.trim()}`,
+        `profile dependencies: ${declared}`,
+        `profiles/web/node_modules: ${installed}`,
+      ].join('\n'), { cause: error })
+    }
     return {
       profileRoot,
       selectorPath,
@@ -623,8 +677,8 @@ async function runOfficialCloneCliSmoke(referenceRoot, registry, upgradeFrom, ca
     // $DSH_HOME/profiles/node_modules — the shared-module fallback the
     // plugin's harness peers resolve through in every later raw-node proof.
     const addedDump = await dumpConfig()
-    assert(addedDump.includes('context-compression-selector-bundle'),
-      'official post-add dump lacks the selector Bundle layer')
+    assert(addedDump.includes('context-compression-improved-bundle'),
+      'official post-add dump lacks the context-compression Bundle layer')
 
     // Real profile start on the previous release, BEFORE seeding: the
     // previous-release schema predates the autoCompact section, so this probe
@@ -646,11 +700,11 @@ async function runOfficialCloneCliSmoke(referenceRoot, registry, upgradeFrom, ca
     const loadProof = await provePluginLoads()
     const postUpBoot = await runProfileBootProbe('post-up', true)
     const upDump = await dumpConfig()
-    for (const marker of ['context-compression-selector-bundle', 'presetOverlay: true']) {
+    for (const marker of ['context-compression-improved-bundle', 'presetOverlay: true']) {
       assert(upDump.includes(marker), `official post-up dump lacks ${marker}`)
     }
-    assert(upDump.match(/context-compression-selector-bundle/gu)?.length === 1,
-      'official post-up dump contains more than one selector Bundle layer')
+    assert(upDump.match(/context-compression-improved-bundle/gu)?.length === 1,
+      'official post-up dump contains more than one context-compression Bundle layer')
 
     // pnpm's peers check is informational: plugin peers resolve through the
     // healed profiles/node_modules fallback, which pnpm cannot see by design.
@@ -661,14 +715,14 @@ async function runOfficialCloneCliSmoke(referenceRoot, registry, upgradeFrom, ca
 
     await dsh('plugin', '--profile', 'web', 'remove', 'dsh-context-compression-improved')
     const removedDump = await dumpConfig()
-    assert(!removedDump.includes('context-compression-selector-bundle'),
-      'official CLI remove left the selector Bundle layer active')
+    assert(!removedDump.includes('context-compression-improved-bundle'),
+      'official CLI remove left the context-compression Bundle layer active')
 
     await dsh('plugin', '--profile', 'web', 'add',
       'dsh-context-compression-improved@latest', '--registry', registry)
     const secondDump = await dumpConfig()
-    assert(secondDump.includes('context-compression-selector-bundle'),
-      'official CLI reinstall did not restore the selector Bundle layer')
+    assert(secondDump.includes('context-compression-improved-bundle'),
+      'official CLI reinstall did not restore the context-compression Bundle layer')
 
     return {
       tag: before.tag,