dsh-context-compression-improved 0.5.0 → 0.5.1

package/CHANGELOG.ja.md

@@ -2,6 +2,21 @@
 
 > 完全な履歴（アップストリーム 0.1.0 以前を含む）は [CHANGELOG.md](CHANGELOG.md) を参照。このファイルはフォークの追加エントリーのみを翻訳したものです。 · [English](CHANGELOG.md) · [中文](CHANGELOG.zh.md) · [한국어](CHANGELOG.ko.md)
 
+## 0.5.1 - 2026-09-20
+
+### Fixed（修正）
+
+- 同一 identity を並行して compose する preset-overlay が Windows で失敗しなくなりました。
+  公開は宛先パスごとに直列化し、それでも原子的 rename が競合に敗れた場合は、宛先が
+  このステージングファイルと同じ `{mtimeMs, size}` standing key を既に持っていることを
+  確認してから成功と見なします。Windows の `MoveFileEx` はこの競合を `EPERM`/`EBUSY` と
+  して報告しますが、POSIX の `rename` は単に置き換えます——これが並行セッション開始時に
+  `standingKeyFor()` を投げさせていました。一致しない宛先はこれまで通り明確に失敗し、
+  静かな世代の再利用は禁止されたままです。
+- この問題と他の既存レッドゲートを覆い隠していたリリースゲート／テストの修正
+  （packed smoke の陳旧な識別子と廃止済み audit reason、古い client inject 期待値、
+  Windows 限定の spawn トラップ）。
+
 ## 0.5.0 - 2026-09-20
 
 ### Added（追加）

package/CHANGELOG.ko.md

@@ -2,6 +2,21 @@
 
 > 전체 히스토리(업스트림 0.1.0 이전 포함)는 [CHANGELOG.md](CHANGELOG.md)를 참고하세요. 이 파일은 포크의 추가 항목만 번역한 것입니다. · [English](CHANGELOG.md) · [中文](CHANGELOG.zh.md) · [日本語](CHANGELOG.ja.md)
 
+## 0.5.1 - 2026-09-20
+
+### Fixed(수정)
+
+- 동일 identity를 동시에 compose하는 preset-overlay가 Windows에서 더 이상 실패하지
+  않습니다. 게시는 대상 경로별로 직렬화되며, 그래도 원자적 rename이 경쟁에서 지면 대상이
+  이미 이 스테이징 파일과 같은 `{mtimeMs, size}` standing key를 가지고 있는지 확인한 뒤에만
+  성공으로 간주합니다. Windows의 `MoveFileEx`는 이 경쟁을 `EPERM`/`EBUSY`로 보고하지만
+  POSIX `rename`은 대상을 그대로 교체합니다——이 때문에 동시 세션 시작 시
+  `standingKeyFor()`가 예외를 던졌습니다. 일치하지 않는 대상은 여전히 명확히 실패하며,
+  조용한 세대 재사용은 계속 금지됩니다.
+- 이 문제와 다른 기존 레드 게이트를 가리던 릴리스 게이트/테스트 수정
+  (packed smoke의 오래된 식별자와 폐기된 audit reason, 낡은 client inject 기대값,
+  Windows 전용 spawn 함정).
+
 ## 0.5.0 - 2026-09-20
 
 ### Added(추가)

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes use this file. The project follows semantic versioning after `0.1.0`.
 
+## 0.5.1 - 2026-09-20
+
+### Fixed
+
+- Concurrent preset-overlay composition of one identity no longer fails on Windows.
+  Publication is now serialized per destination path, and when the atomic rename still
+  loses the race the destination is confirmed to already carry this staging file's
+  `{mtimeMs, size}` standing key before the publish reports success. Windows `MoveFileEx`
+  reports that lost race as `EPERM`/`EBUSY` where POSIX `rename` simply replaces the
+  destination, which made `standingKeyFor()` throw during concurrent session start. A
+  destination that does not match still fails loudly, so a silently reused generation
+  stays forbidden.
+- Release-gate and test repairs that had been hiding this and other pre-existing red
+  gates: stale identifiers and a retired audit reason in the packed smokes, a stale
+  client-inject expectation, and Windows-only spawn traps (`git` and multi-line
+  `node -e` scripts were routed through `cmd.exe`, which rewrote their arguments).
+
 ## 0.5.0 - 2026-09-20
 
 ### Added

package/CHANGELOG.zh.md

@@ -2,6 +2,19 @@
 
 > 完整历史（含上游 0.1.0 及更早版本）见 [CHANGELOG.md](CHANGELOG.md)。本文件只翻译本 fork 的新增条目。 · [English](CHANGELOG.md) · [日本語](CHANGELOG.ja.md) · [한국어](CHANGELOG.ko.md)
 
+## 0.5.1 - 2026-09-20
+
+### Fixed
+
+- 同一 identity 的并发 preset-overlay 组装在 Windows 上不再失败：发布改为按目标路径串行，
+  且当原子 rename 仍然竞争失败时，会先确认目标文件已带有本 staging 文件的
+  `{mtimeMs, size}` standing key 才判定发布成功。Windows 的 `MoveFileEx` 会把这种竞争
+  失败报成 `EPERM`/`EBUSY`，而 POSIX `rename` 只是覆盖目标——这曾导致并发启动会话时
+  `standingKeyFor()` 抛错。目标不匹配时仍会明确失败，静默复用世代依旧被禁止。
+- 一并修复了长期掩盖该问题及其它预存红灯的发布门禁与测试：packed smoke 中陈旧的标识符与
+  已退役的审计 reason、过期的客户端 inject 断言，以及仅 Windows 触发的 spawn 陷阱
+  （`git` 与多行 `node -e` 脚本经 `cmd.exe` 转发会被改写参数）。
+
 ## 0.5.0 - 2026-09-20
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context-compression-improved",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",

package/packages/selector/lib/index.js

@@ -118,6 +118,15 @@ function standingStampMsAtWindow(identity, windowIndex) {
 	const subSecond = parseInt(identity.slice(start + 8, start + STANDING_MTIME_WINDOW_HEX).padEnd(3, "0"), 16) % 1e3;
 	return seconds * 1e3 + subSecond;
 }
+/**
+* True for the filesystem errors a concurrent publish can raise on Windows:
+* `MoveFileEx` reports a lost race — or a reader holding the destination open —
+* as EPERM/EBUSY/EACCES, where POSIX `rename` simply replaces the destination.
+*/
+function isPublishRace(error) {
+	const code = error?.code;
+	return code === "EPERM" || code === "EBUSY" || code === "EACCES" || code === "EEXIST";
+}
 const COMPRESSION_IDS = /* @__PURE__ */ new Set([
 	"compaction",
 	"compaction-basic",
@@ -191,7 +200,7 @@ var PresetOverlayStore = class {
 			});
 			await chmod(staging, 384);
 			await this.disambiguateStamp(staging, identity);
-			await rename(staging, path);
+			await this.publish(staging, path);
 		} catch (error) {
 			try {
 				await rm(staging, { force: true });
@@ -203,6 +212,45 @@ var PresetOverlayStore = class {
 			path
 		};
 	}
+	/** In-flight publish chains, one per destination path. */
+	publishChains = /* @__PURE__ */ new Map();
+	/**
+	* Publish one stamped staging file to its final path, serialized per path.
+	*
+	* POSIX `rename` replaces an existing destination atomically, so concurrent
+	* composers of one identity are naturally idempotent there. Windows
+	* `MoveFileEx` instead fails the loser of that race with EPERM/EBUSY, which
+	* surfaced as `standingKeyFor()` throwing during concurrent composition.
+	* Every composer of one identity writes identical bytes and re-derives the
+	* same deterministic identity stamp, so a destination that already observes
+	* this staging file's {mtimeMs, size} key IS the intended end state: confirm
+	* it and treat the lost race as success. Every other outcome still throws, so
+	* a silently reused generation stays forbidden, and the caller still removes
+	* the staging file when this rejects.
+	*/
+	publish(staging, path) {
+		const tracked = (this.publishChains.get(path) ?? Promise.resolve()).catch(() => void 0).then(async () => {
+			try {
+				await rename(staging, path);
+				return;
+			} catch (error) {
+				if (!isPublishRace(error)) throw error;
+				try {
+					const intended = await this.metadataIo.read(staging);
+					const published = await this.metadataIo.read(path);
+					if (published.size === intended.size && Math.abs(published.mtimeMs - intended.mtimeMs) < 2) {
+						await rm(staging, { force: true });
+						return;
+					}
+				} catch {}
+				throw error;
+			}
+		}).finally(() => {
+			if (this.publishChains.get(path) === tracked) this.publishChains.delete(path);
+		});
+		this.publishChains.set(path, tracked);
+		return tracked;
+	}
 	/** Observed {mtimeMs,size} keys published by this store, per identity. */
 	standingKeys = /* @__PURE__ */ new Map();
 	/**

package/packages/selector/src/preset-overlay.ts

@@ -116,6 +116,16 @@ export function standingStampMs(identity: string): number {
   return standingStampMsAtWindow(identity, 0)
 }
 
+/**
+ * True for the filesystem errors a concurrent publish can raise on Windows:
+ * `MoveFileEx` reports a lost race — or a reader holding the destination open —
+ * as EPERM/EBUSY/EACCES, where POSIX `rename` simply replaces the destination.
+ */
+function isPublishRace(error: unknown): boolean {
+  const code = (error as { code?: unknown } | null)?.code
+  return code === 'EPERM' || code === 'EBUSY' || code === 'EACCES' || code === 'EEXIST'
+}
+
 const COMPRESSION_IDS = new Set([
   'compaction',
   'compaction-basic',
@@ -224,7 +234,7 @@ class PresetOverlayStore {
       // still private. No reader can observe a colliding {mtimeMs,size}
       // between rename and a later corrective utimes call.
       await this.disambiguateStamp(staging, identity)
-      await rename(staging, path)
+      await this.publish(staging, path)
     } catch (error) {
       // A failed publish must not leak its staging file into the store; the
       // cleanup must never mask the original failure either.
@@ -238,6 +248,55 @@ class PresetOverlayStore {
     return { ...preset, path }
   }
 
+  /** In-flight publish chains, one per destination path. */
+  private readonly publishChains = new Map<string, Promise<void>>()
+
+  /**
+   * Publish one stamped staging file to its final path, serialized per path.
+   *
+   * POSIX `rename` replaces an existing destination atomically, so concurrent
+   * composers of one identity are naturally idempotent there. Windows
+   * `MoveFileEx` instead fails the loser of that race with EPERM/EBUSY, which
+   * surfaced as `standingKeyFor()` throwing during concurrent composition.
+   * Every composer of one identity writes identical bytes and re-derives the
+   * same deterministic identity stamp, so a destination that already observes
+   * this staging file's {mtimeMs, size} key IS the intended end state: confirm
+   * it and treat the lost race as success. Every other outcome still throws, so
+   * a silently reused generation stays forbidden, and the caller still removes
+   * the staging file when this rejects.
+   */
+  private publish(staging: string, path: string): Promise<void> {
+    const previous = this.publishChains.get(path) ?? Promise.resolve()
+    const queued = previous.catch(() => undefined).then(async () => {
+      try {
+        await rename(staging, path)
+        return
+      } catch (error) {
+        if (!isPublishRace(error)) throw error
+        try {
+          const intended = await this.metadataIo.read(staging)
+          const published = await this.metadataIo.read(path)
+          // Sub-second precision survives a wrapped seconds field, but NTFS
+          // rounds it to 100ns, so compare the standing key within that
+          // rounding rather than by exact float equality.
+          if (published.size === intended.size
+            && Math.abs(published.mtimeMs - intended.mtimeMs) < 2) {
+            await rm(staging, { force: true })
+            return
+          }
+        } catch {
+          // The destination is unreadable: report the original publish failure.
+        }
+        throw error
+      }
+    })
+    const tracked = queued.finally(() => {
+      if (this.publishChains.get(path) === tracked) this.publishChains.delete(path)
+    })
+    this.publishChains.set(path, tracked)
+    return tracked
+  }
+
   /** Observed {mtimeMs,size} keys published by this store, per identity. */
   private readonly standingKeys = new Map<string, string>()
 

package/packages/selector/tests/built/client-artifact.spec.ts

@@ -34,11 +34,15 @@ describe('built Harness client artifact', () => {
     }) as { apply?: unknown, inject?: unknown }
 
     expect(exported.apply).toBeTypeOf('function')
-    // 0.1.5 declares only the always-present `slots` service: `locale` and
-    // `settingsScope` are resolved lazily inside apply, because a declarative
-    // inject of an absent or late service suspends apply forever and the whole
-    // UI disappears without a trace.
-    expect(exported.inject).toEqual(['slots'])
+    // Declare every consumed service: cordis holds apply until each one is
+    // provided, which is the official client-plugin pattern on this 0.1.5 host
+    // line (dsh-thinking-levels does the same). The earlier lazy alternative —
+    // resolving `locale` / `settingsScope` through ctx.get() inside apply —
+    // raced the settings client's activation; on a loss the apply
+    // early-returned and EVERY settings entry (the standalone section, the
+    // plugins-tab card, the item card) silently vanished. See the rationale
+    // recorded in src/client/index.ts.
+    expect(exported.inject).toEqual(['slots', 'locale', 'settingsScope'])
     const style = document.querySelector<HTMLStyleElement>(
       'style[data-plugin-css="dsh-context-compression-improved/CompressionProfileSelector.module.css"]',
     )

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,