dsh-conversation-recycle-bin 0.3.19 → 0.3.20

package/CHANGELOG.md

@@ -3,6 +3,40 @@
 All notable changes to `dsh-conversation-recycle-bin` are documented here.
 The format follows Keep a Changelog; the project uses Semantic Versioning.
 
+## [0.3.20] — 2026-11-09
+
+一次只改工程效率、不改删除语义的整理：把测试墙钟从 **60.5s 压到 4.6s**，堵住「跑过测试再打包」会把本机测试残留塞进 npm 包的路径，删掉三处零引用导出，并把两个确认前的**读**循环改成有界并发。生产路径的锁预算、超时与策略判定全部不变。
+
+### Changed
+
+- **`/delete` 的锁预算改为可注入、且与 `preview` 共用一份计算**（`PLAN_LOCK_BUDGET` + `planLockBudgetMs()`）：这两处过去是同一算式抄了两份（`preview` 发布 `limits.planTimeoutMs`，`/delete` 用它当跨进程锁超时），一处调参另一处很容易漏。生产默认值不变（15s 基数 + 每会话 16s + 每个 live 会话一个 drain 窗口，上限 900s）；测试可传 `planBudget` 把预算降到毫秒级。
+- **`preview` / `deletePlan` 的预检改为有界并发（8）**：`inspect()` 只读（persistence stat + 投影 + 缓存列表），50 项批量过去要串行付 50 次往返。**执行**循环仍是严格串行——只有读并发。
+- **`gateway.loadList()` 加单飞 + 代际号**：预检并发后，冷启动时多个 `inspect()` 会同时触发列表构建；现在只有第一个真正构建，其余复用同一个 Promise。`invalidate()` 会递增代际并丢弃在飞的构建结果，保证「1.5s 缓存窗口内 pin 后删除」的既有修复不因并发回退。
+- **`/sessions` 去掉第二趟投影读**：`enrichTitles()` 会对「标题仍为空」的行再读一遍 `buildList()` 刚读过的同一批投影文件，且只补前 80 行。`createdAt` 现在由 `buildList()` 在唯一那次读里补齐，`enrichTitles()` 整个删除。
+- **`files` 收紧为 `test/*.mjs`**：过去是整个 `test/` 目录，而 npm 的 `files` 白名单优先于 `.gitignore`，于是 `npm test` 之后 `npm pack` 会把 `test/.tmp/` 里的会话日志、记忆索引和 `mutation-busy-*.lock` 打进包——同一个 commit 打两次包 shasum 不同。新增 `scripts/clean-tmp.mjs`（`prepack` 钩子）作为第二道防线，失败只告警不阻断发布。
+- **`config.schema.json` / 语义不变**：本版没有新增或改动任何配置键。
+
+### Removed
+
+| 符号 | 位置 | 状态 |
+|---|---|---|
+| `ok()` | `lib/core/errors.js` | 零引用（`toWireError` 才是失败态唯一出口） |
+| `defaultConfig()` | `lib/core/config.js` | 零引用；连带删除只被它使用的 `clone()` |
+| `writeJsonAtomic()` | `lib/host/paths.js` | 零引用；连带从 import 里去掉 `writeFile` |
+| `enrichTitles()` | `lib/host/gateway.js` | 功能已并入 `buildList()`，见上 |
+
+### Added
+
+- **`.github/workflows/ci.yml`**：此前仓库没有任何 CI，所有审计都是手工 `npm test`。现在 push/PR 会在 ubuntu + windows × Node 22.15/24 上跑 `npm run check`、`npm test`，并额外断言打包产物不含 `test/.tmp`。包无任何依赖，因此没有安装步骤。
+
+### Tests
+
+- 用例总数不变（**221**，10 个文件），`api.test.mjs` 70/70 全过。
+- **全量墙钟 60.5s → 4.6s；`api.test.mjs` 59.3s → 3.5s**，来自两处固定等待被消除：
+  - 「busy cross-process lock」用例过去被 `/delete` 的 33s 预算卡住（用例自己注入的 60ms `timeoutMs` 被路由参数覆盖）→ 现在注入 `planBudget` + `liveDrainMs: 0`，压到毫秒级；
+  - fixture 默认 `foreignWriterGraceMs: 0`，9 个 hard-delete 用例不再各付 1.5s 固定宽限。真正验证该窗口的两条用例仍直接构造 `createSessionLogOps({ foreignWriterGraceMs: 120/40, delay })`，语义未被稀释。
+- README 的三处用例数（188 / 200 / 200）统一为实际的 **221**。
+
 ## [0.3.19] — 2026-11-05
 
 平台审计（架构 / 安全 / 验收三方独立复审 v0.3.18）之后的修复。三方从不同角度撞到同一处：**记忆残留的条目在 UI/API 上没有任何出口**；另有一条把瞬时读失败当永久不可恢复。

package/README.md

@@ -2,7 +2,7 @@
 
 给 DeepSeek Harness (DSH) Web 增加「删除对话」：会话列表的「…」菜单与会话详情页头部各有一个删除入口；确认框内可勾选「同时删除关联记忆」（默认不勾选），并实时显示将被影响的记忆条数。删除默认进入插件回收站，可恢复；每次操作写入审计日志；批量删除有上限与限流，批量软删除需输入数量，彻底删除一键执行；事务任一步失败即回滚。
 
-> 状态：`0.3.19`，Host + Web Client 双半，零构建（plain JS ESM），只依赖宿主已发布的公开扩展点。
+> 状态：`0.3.20`，Host + Web Client 双半，零构建（plain JS ESM），只依赖宿主已发布的公开扩展点。
 > 运行要求：**Node.js ≥ 22.15**（Host 侧用到 `readdir(..., { recursive: true })`、`AbortSignal` 等 22.x 行为），DSH `>=0.2.1-rc.2 <0.3.0-0`（`package.json` 的 `engines.dsh` 已如实声明，DSH 安装校验会据此拒绝范围外版本；上界是刻意的：0.2.2 与 0.3.x 之间没有承诺兼容）。
 > 包名：`dsh-conversation-recycle-bin`（原 `dsh-delete-conversation` 因 npm 被他人占用而改名，见 CHANGELOG 0.2.0）。
 > 本 README 同时是设计说明与验收依据；安装/回滚步骤见 [INSTALL.md](INSTALL.md)；变更见 [CHANGELOG.md](CHANGELOG.md)。
@@ -236,7 +236,7 @@ dsh-conversation-recycle-bin/
 │     ├─ memory.js               # 适配器装配
 │     ├─ feedback.js             # 反馈校验/渲染/投递（http 或 smtp，凭证只读环境变量）
 │     └─ api.js                 # 同源 HTTP API、确认 token、限流
-└─ test/                        # 188 个用例，覆盖用户要求的 5 类场景 + live 删除 + 记忆锁 + 原地刷新 + 部分失败/跨进程/未完成条目 + 反馈通道 + Client 半渲染冒烟
+└─ test/                        # 221 个用例，覆盖用户要求的 5 类场景 + live 删除 + 记忆锁 + 原地刷新 + 部分失败/跨进程/未完成条目 + 反馈通道 + Client 半渲染冒烟
 ```
 
 ---
@@ -245,7 +245,7 @@ dsh-conversation-recycle-bin/
 
 ```powershell
 cd D:\Users\34332\AI\dsh-conversation-recycle-bin
-npm test        # 依次跑 test/*.test.mjs（10 个文件、200 个用例）；任一失败仍会跑完全部再汇总
+npm test        # 依次跑 test/*.test.mjs（10 个文件、221 个用例）；任一失败仍会跑完全部再汇总
 npm run check   # 语法 + manifest
 node scripts/verify-host-contract.mjs http://127.0.0.1:3082 --token=<token>   # 宿主已启动时的运行时探针（boot 图 + /api/state）
 ```
@@ -362,7 +362,7 @@ node -e "console.log('b64:' + Buffer.from('your-feedback@example.com','utf8').to
 cd D:\Users\34332\AI\dsh-conversation-recycle-bin
 npm run check                      # 语法 + manifest（含 feedback.js）
 node test/feedback.test.mjs        # 20 个反馈用例
-npm test                           # 全量 200 个用例
+npm test                           # 全量 221 个用例
 
 # 端到端：用本机收件桩观察真实投递路径，不外发邮件
 $env:DSH_CRB_MAIL_API_URL   = 'http://127.0.0.1:9099/emails'

package/lib/core/config.js

@@ -100,10 +100,6 @@ function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value)
 }
 
-function clone(value) {
-  return JSON.parse(JSON.stringify(value))
-}
-
 function clampInt(raw, fallback, min, max, field, warnings) {
   if (raw === undefined) return fallback
   const number = typeof raw === 'number' ? raw : Number.NaN
@@ -345,8 +341,3 @@ export function resolveJsonPointer(document, pointer) {
   }
   return cursor
 }
-
-/** Deep clone of the defaults; exported for tests and documentation. */
-export function defaultConfig() {
-  return clone(DEFAULTS)
-}

package/lib/core/errors.js

@@ -91,8 +91,3 @@ export function toWireError(error) {
   const normalized = asDeleteError(error)
   return { ok: false, error: redactDetails(normalized.toJSON()) }
 }
-
-/** Wire shape for a successful call. */
-export function ok(value) {
-  return { ok: true, ...value }
-}

package/lib/host/api.js

@@ -73,6 +73,13 @@ import { SESSION_ID_PATTERN } from '../core/ids.js'
 export const ROUTE_PREFIX = '/conversation-recycle-bin/api'
 export const REQUIRED_HEADER = 'x-conversation-recycle-bin'
 const MAX_BODY_BYTES = 256 * 1024
+/**
+ * How many sessions a plan preflight may inspect at once. `inspect()` is a
+ * short read (persistence stat + one projection file), so this bounds open
+ * descriptors and CPU while still collapsing a 50-item batch's serial latency.
+ * The mutation loop itself stays strictly serial — only reads fan out.
+ */
+const PREFLIGHT_CONCURRENCY = 8
 /**
  * Lock wait budget for the single-entry trash mutations.
  *
@@ -104,6 +111,36 @@ export function queueBudgetFor(lockBudgetMs) {
   return (Number.isFinite(budget) && budget > 0 ? budget : 30_000) + QUEUE_GRACE_MS
 }
 
+/**
+ * Shape of the lock wait a delete plan is allowed, per unit of work.
+ *
+ * The number has two consumers that MUST agree: `preview` publishes it as
+ * `limits.planTimeoutMs` (so the Client waits long enough) and `/delete` uses
+ * the very same computation as its cross-process lock timeout. They used to be
+ * two copies of the same expression, which is exactly the kind of pair that
+ * drifts when one side is tuned.
+ *
+ * `createDeleteApi` accepts an override so a test can shrink the budget without
+ * waiting the production 31 s to observe `E_LOCK_BUSY`. Production defaults are
+ * unchanged: 15 s base + 16 s per session + one drain window per live session.
+ */
+export const PLAN_LOCK_BUDGET = Object.freeze({ baseMs: 15_000, perItemMs: 16_000, capMs: 900_000 })
+
+/**
+ * Lock budget for a plan of `itemCount` sessions, `liveCount` of them live.
+ * @param {number} itemCount sessions in the plan
+ * @param {number} liveCount how many of them must be drained first
+ * @param {number} liveDrainMs configured `liveDrainMs`
+ * @param {{ baseMs: number, perItemMs: number, capMs: number }} [budget]
+ */
+export function planLockBudgetMs(itemCount, liveCount, liveDrainMs, budget = PLAN_LOCK_BUDGET) {
+  const items = Number.isFinite(itemCount) && itemCount > 0 ? itemCount : 0
+  const live = Number.isFinite(liveCount) && liveCount > 0 ? liveCount : 0
+  const drain = Number.isFinite(liveDrainMs) && liveDrainMs > 0 ? liveDrainMs : 0
+  const cap = Number.isFinite(budget?.capMs) && budget.capMs > 0 ? budget.capMs : PLAN_LOCK_BUDGET.capMs
+  return Math.min(cap, budget.baseMs + items * budget.perItemMs + live * drain)
+}
+
 function isLoopbackHostname(hostname) {
   const value = String(hostname ?? '').trim().toLowerCase().replace(/^\[|\]$/g, '')
   return value === 'localhost' || value === '::1' || value === '0:0:0:0:0:0:0:1' || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(value)
@@ -370,7 +407,7 @@ function sendJson(res, status, payload) {
  *   E_LOCK_BUSY path with a short wait budget; production uses 30s because a
  *   deletion transaction legitimately takes a while and waiting beats failing.
  */
-export function createDeleteApi({ ctx, config, paths, now = Date.now, logger = console, mutationLock = null }) {
+export function createDeleteApi({ ctx, config, paths, now = Date.now, logger = console, mutationLock = null, planBudget = PLAN_LOCK_BUDGET }) {
   const gateway = createSessionGateway({ ctx, paths, now, logger })
   const memoryService = createMemoryService({
     adapters: createMemoryAdapters({ config, dshHome: paths.dshHome, now }),
@@ -731,8 +768,13 @@ export function createDeleteApi({ ctx, config, paths, now = Date.now, logger = c
     }
     const sessions = []
     const blocked = []
-    for (const id of sessionIds) {
-      const session = await gateway.inspect(id)
+    // `inspect()` only reads (persistence stat + projection + cached list), so
+    // the per-session preflight fans out. A 50-item batch used to pay 50 serial
+    // round trips before the dialog could render the plan.
+    const inspected = await mapLimit(sessionIds, PREFLIGHT_CONCURRENCY, (id) => gateway.inspect(id))
+    for (let index = 0; index < sessionIds.length; index += 1) {
+      const id = sessionIds[index]
+      const session = inspected[index]
       if (session === null) {
         blocked.push({ sessionId: id, policy: { ok: false, code: 'E_NOT_FOUND', message: 'The conversation was not found.' } })
         continue
@@ -770,7 +812,7 @@ export function createDeleteApi({ ctx, config, paths, now = Date.now, logger = c
     // instead of its own estimate, otherwise it aborts while the Host is still
     // deleting and retries into an in-flight transaction.
     const liveCount = sessions.filter((item) => item.live === true).length
-    const planTimeoutMs = Math.min(900_000, 15_000 + sessionIds.length * 16_000 + liveCount * config.liveDrainMs)
+    const planTimeoutMs = planLockBudgetMs(sessionIds.length, liveCount, config.liveDrainMs, planBudget)
 
     return {
       sessions,
@@ -849,8 +891,13 @@ export function createDeleteApi({ ctx, config, paths, now = Date.now, logger = c
     // of reasons, never half-executed because the last id was forbidden.
     const sessions = []
     const refusals = []
-    for (const id of sessionIds) {
-      const session = await gateway.inspect(id)
+    // Read-only preflight, same bounded fan-out as `preview`: nothing mutates
+    // here, so the order of the reads is irrelevant — only the order of the
+    // resulting `sessions`/`refusals` lists is, and that is rebuilt below.
+    const preflighted = await mapLimit(sessionIds, PREFLIGHT_CONCURRENCY, (id) => gateway.inspect(id))
+    for (let index = 0; index < sessionIds.length; index += 1) {
+      const id = sessionIds[index]
+      const session = preflighted[index]
       if (session === null) {
         refusals.push({ sessionId: id, code: 'E_NOT_FOUND', message: 'The conversation was not found.' })
         continue
@@ -1061,8 +1108,9 @@ export function createDeleteApi({ ctx, config, paths, now = Date.now, logger = c
   }
 
   async function sessionsForUi() {
+    // `gateway.list()` fills titles and `createdAt` from the per-session
+    // projections for every row, so there is no second enrichment pass here.
     const sessions = await gateway.list()
-    await gateway.enrichTitles(sessions)
     // Every row carries its own policy verdict: "select all" used to include
     // subagent/orphan/out-of-root conversations that `/preview` then refuses
     // as a whole batch, leaving the user with a disabled button and no hint
@@ -1494,7 +1542,9 @@ export function createDeleteApi({ ctx, config, paths, now = Date.now, logger = c
             ? [body.sessionId]
             : []
         const batchCount = Math.max(1, rawIds.length)
-        const lockBudget = Math.min(900_000, 15_000 + batchCount * 16_000 + batchCount * config.liveDrainMs)
+        // Same computation `preview` publishes, assuming the worst case (every
+        // item live) so the lock wait can never be shorter than the work.
+        const lockBudget = planLockBudgetMs(batchCount, batchCount, config.liveDrainMs, planBudget)
         const result = await serialize(() => deletePlan(body), {
           lockTimeoutMs: lockBudget,
           shouldAbort: () => clientGone(req, res),

package/lib/host/gateway.js

@@ -24,6 +24,13 @@ const STATE_TTL_MS = 1_500
 export function createSessionGateway({ ctx, paths, now = Date.now, logger = console }) {
   let listCache = null
   let listCachedAt = -Infinity
+  // Single-flight for the list build. `inspect()` calls `loadList()` and a plan
+  // preflight now inspects several sessions concurrently, so without this every
+  // worker that arrives before the first build finishes would start its own.
+  let listInFlight = null
+  // Bumped by `invalidate()`. A build that started before an invalidation must
+  // not write its (possibly pre-mutation) snapshot into the cache afterwards.
+  let listGeneration = 0
   let stateCache = null
   let stateCachedAt = -Infinity
 
@@ -115,6 +122,18 @@ export function createSessionGateway({ ctx, paths, now = Date.now, logger = cons
 
   async function loadList() {
     if (listCache !== null && now() - listCachedAt < LIST_TTL_MS) return listCache
+    if (listInFlight !== null) return listInFlight
+    const generation = listGeneration
+    const pending = buildList(generation)
+    listInFlight = pending
+    try {
+      return await pending
+    } finally {
+      if (listInFlight === pending) listInFlight = null
+    }
+  }
+
+  async function buildList(generation) {
     const controller = service('sessionController')
     const persistence = service('sessionPersistence')
     let items = []
@@ -160,7 +179,7 @@ export function createSessionGateway({ ctx, paths, now = Date.now, logger = cons
     }
     const titles = await readTitles()
     const state = await readWorkspaceState()
-    listCache = items.map((item) => {
+    const rows = items.map((item) => {
       const member = workspaceBySession.get(item.sessionId) ?? null
       const byCwd = member === null ? workspaceByCwd(item.cwd) : null
       const owned = member ?? (byCwd === null ? null : { workspace: byCwd, index: -1 })
@@ -189,17 +208,29 @@ export function createSessionGateway({ ctx, paths, now = Date.now, logger = cons
     // above is usually empty and every row would render untitled. Fill the gaps
     // from the authoritative per-session projection, in small batches so a long
     // history does not open hundreds of descriptors at once.
-    const untitled = listCache.filter((row) => row.title === '')
+    //
+    // This is also the only place `createdAt` can come from: the legacy bulk
+    // table does not carry it. `enrichTitles()` used to run a second pass over
+    // exactly these rows (re-reading the same projection files) purely to fill
+    // that field, and was capped at the first 80 rows; doing it here makes the
+    // pass complete and removes the duplicate reads.
+    const untitled = rows.filter((row) => row.title === '')
     for (let index = 0; index < untitled.length; index += 16) {
       await Promise.all(untitled.slice(index, index + 16).map(async (row) => {
         const projection = await readSessionProjection(row.id)
         if (projection === null) return
         if (projection.title !== '') row.title = projection.title
         row.blank = row.blank || projection.blank
+        if (row.createdAt === null) row.createdAt = projection.createdAt ?? null
       }))
     }
-    listCachedAt = now()
-    return listCache
+    // A build that started before an `invalidate()` describes state the caller
+    // deliberately discarded, so it must not install itself as the cache.
+    if (generation === listGeneration) {
+      listCache = rows
+      listCachedAt = now()
+    }
+    return rows
   }
 
   function isLive(sessionId) {
@@ -374,25 +405,23 @@ export function createSessionGateway({ ctx, paths, now = Date.now, logger = cons
     },
 
     /**
-     * Fill missing titles from the per-session projection checkpoints for the
-     * first `limit` rows. The bulk list is read-only UI data, so this is done
-     * lazily here rather than on every inspect; a missing checkpoint simply
-     * leaves the id/cwd fallback the Client renders.
+     * NOTE: `enrichTitles()` used to live here. It re-read the same projection
+     * files `buildList()` had just read — but only for rows still untitled, and
+     * only for the first 80 rows — purely to fill a title/`createdAt` that
+     * `buildList()` now fills for every row. `/sessions` paid for that second,
+     * partial pass on every call. Titles and `createdAt` are complete after
+     * `list()`; see `buildList()`.
      */
-    async enrichTitles(sessions, limit = 80) {
-      const slice = sessions.slice(0, Math.max(1, limit))
-      await Promise.all(slice.map(async (session) => {
-        if (typeof session.title === 'string' && session.title !== '') return
-        const projection = await readSessionProjection(session.id)
-        if (projection === null) return
-        if (typeof projection.title === 'string' && projection.title !== '') session.title = projection.title
-        if (projection.blank === true) session.blank = true
-        if (session.createdAt === null) session.createdAt = projection.createdAt ?? null
-      }))
-      return sessions
-    },
 
+    /**
+     * Drop every cached read. Also retires an in-flight list build: it started
+     * from state the caller has just been told is stale (a pin or archive made
+     * inside the 1.5 s window), so its result must neither be installed nor be
+     * what the next `inspect()` awaits.
+     */
     invalidate() {
+      listGeneration += 1
+      listInFlight = null
       listCache = null
       listCachedAt = -Infinity
       stateCache = null

package/lib/host/paths.js

@@ -14,7 +14,7 @@
  * its original cwd and there is no directory left to scan.
  */
 import { createReadStream } from 'node:fs'
-import { cp, mkdir, open, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises'
+import { cp, mkdir, open, readdir, readFile, rename, rm, stat } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
 
@@ -297,17 +297,3 @@ export async function readJsonFile(filePath) {
     throw new Error(`malformed JSON at ${filePath}: ${error instanceof Error ? error.message : String(error)}`)
   }
 }
-
-/** Write JSON through a sibling temp file + rename (never a torn target). */
-export async function writeJsonAtomic(filePath, value) {
-  await mkdir(dirname(filePath), { recursive: true })
-  const temporary = `${filePath}.tmp-${process.pid}-${Date.now()}`
-  const payload = `${JSON.stringify(value, null, 2)}\n`
-  await writeFile(temporary, payload, 'utf8')
-  try {
-    await rename(temporary, filePath)
-  } catch (error) {
-    await rm(temporary, { force: true }).catch(() => {})
-    throw error
-  }
-}

package/lib/version.js

@@ -5,4 +5,4 @@
  * asserted against it by `test/manifest.test.mjs` so the two can never drift
  * (they did: the constant stayed at 0.1.0 while the package reached 0.1.4).
  */
-export const PLUGIN_VERSION = '0.3.19'
+export const PLUGIN_VERSION = '0.3.20'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-conversation-recycle-bin",
-  "version": "0.3.19",
+  "version": "0.3.20",
   "description": "DSH conversation deletion with an optional, previewed cascade into conversation-associated memory: soft delete + recycle bin, audit trail, batch rate limits and per-session rollback. 删除对话（可选一并删除关联记忆）：软删除与回收站、审计留痕、批量限流、失败回滚。",
   "repository": {
     "type": "git",
@@ -32,7 +32,7 @@
     "LICENSE",
     "AUDIT-*.md",
     "scripts/",
-    "test/"
+    "test/*.mjs"
   ],
   "engines": {
     "node": ">=22.15",
@@ -60,7 +60,8 @@
   },
   "scripts": {
     "test": "node scripts/run-tests.mjs",
-    "check": "node scripts/check-syntax.mjs && node test/manifest.test.mjs"
+    "check": "node scripts/check-syntax.mjs && node test/manifest.test.mjs",
+    "prepack": "node scripts/clean-tmp.mjs"
   },
   "dsh": {
     "manifestVersion": 1,

package/scripts/clean-tmp.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/**
+ * Remove `test/.tmp` before a tarball is built.
+ *
+ * The suites create their fixtures under `test/.tmp/<random>` and clean up
+ * afterwards, but on Windows a lingering handle (antivirus, a still-open log
+ * file, a lock file whose owner process is slow to exit) makes `rm` fail
+ * silently. `files` in package.json used to whitelist the whole `test/`
+ * directory, and npm's `files` whitelist wins over `.gitignore`, so a
+ * `npm pack` after `npm test` shipped those leftovers: a real session log, a
+ * memory index and a `mutation-busy-*.lock`. The tarball then differed between
+ * two runs of the same commit.
+ *
+ * `files` now names `test/*.mjs` explicitly, which already excludes the
+ * directory; this script is the second line of defence (and keeps `npm pack`
+ * output identical whether or not the tests ran in the same checkout).
+ *
+ * Best effort on purpose: a leftover fixture must never block a release. The
+ * failure is printed so it is visible instead of silent.
+ */
+import { readdirSync, rmSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const tmpDir = resolve(here, '..', 'test', '.tmp')
+
+try {
+  readdirSync(tmpDir)
+} catch (error) {
+  if (error?.code === 'ENOENT') process.exit(0)
+  console.warn(`[pack] could not read ${tmpDir}: ${error?.code ?? error}`)
+  process.exit(0)
+}
+
+try {
+  rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 })
+  console.log(`[pack] removed leftover test fixtures at ${tmpDir}`)
+} catch (error) {
+  console.warn(`[pack] could not remove ${tmpDir} (${error?.code ?? error}); check "files" in package.json`)
+}
+process.exit(0)

package/test/api.test.mjs

@@ -49,6 +49,7 @@ async function makeFixture({
   mutationLock = null,
   connection = null,
   clock = null,
+  planBudget = null,
 } = {}) {
   const home = await makeTempHome()
   const workspaceRegistry = makeWorkspaceRegistry([
@@ -135,6 +136,12 @@ async function makeFixture({
     // is covered by `connection: a Host without a connection service refuses
     // by default`.
     requireConnection: connection !== null,
+    // The foreign-writer grace window is a fixed sleep inside every hard
+    // delete, so paying the production 1.5 s in ~10 unrelated tests bought
+    // nothing but wall time. The two tests that actually exercise the window
+    // build `createSessionLogOps` directly with their own value (and a stub
+    // `delay`), so they are unaffected by this default.
+    foreignWriterGraceMs: 0,
     ...configOverrides,
   }).value
   const paths = resolveDataPaths(home.root)
@@ -146,6 +153,7 @@ async function makeFixture({
     ...(clock === null ? {} : { now: clock }),
     logger: { error: (...args) => logs.push(args.join(' ')), warn() {}, info() {} },
     mutationLock,
+    ...(planBudget === null ? {} : { planBudget }),
   })
   return { home, api, config, paths, services, workspaceRegistry, seeded, memoryRoot, logs, items }
 }
@@ -927,9 +935,15 @@ test('mutation lock: a busy cross-process lock is E_LOCK_BUSY, not a corrupted m
   const lockPath = join(process.cwd(), 'test', '.tmp', `mutation-busy-${randomBytes(6).toString('hex')}.lock`)
   const holder = createFileLock({ lockPath, timeoutMs: 2_000, staleMs: 60_000, retryMs: 10 })
   const fixture = await makeFixture({
-    // A short wait budget keeps the test fast; production waits 30s because a
+    // A short wait budget keeps the test fast; production waits 31s because a
     // deletion transaction legitimately takes a while.
     mutationLock: createFileLock({ lockPath, timeoutMs: 60, staleMs: 60_000, retryMs: 10 }),
+    // `/delete` used to derive its own lock budget (15s + 16s/item + drain) and
+    // hand it to `serialize()`, overriding the lock's own timeout — so this
+    // test sat on the whole 33s budget just to observe E_LOCK_BUSY. The budget
+    // is now injectable, and `liveDrainMs: 0` removes the last fixed slice.
+    planBudget: { baseMs: 40, perItemMs: 20, capMs: 200 },
+    configOverrides: { liveDrainMs: 0 },
   })
   const release = await holder.acquire()
   try {