dsh-conversation-recycle-bin 0.3.18 → 0.3.20

package/CHANGELOG.md

@@ -3,6 +3,66 @@
 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 上没有任何出口**；另有一条把瞬时读失败当永久不可恢复。
+
+### Fixed
+
+- **失败导出的残留变成可恢复**（架构 P2 / 验收 R-21-01）：`bundle.json` 过去只在整个搬移循环结束后才写，若在此之前失败且补偿搬回也失败，目录只剩 `files/` 与 `ORPHANED.json` —— `readExported` 只认 bundle，restore 无物可读、discard 拒绝文件、force 又要求"日志不可读"，条目永久留盘。现在补偿决定保留时**同时写一份 rescue bundle**（用仍留在 `files/` 的条目重建），让恢复重新有路。
+- **索引已有节点、内容仍在 bundle 时不再拒绝恢复**（同一根因的另一半）：失败导出会把索引还原成 pristine（节点还在），旧逻辑看到"节点已存在"就直接 `E_TRASH_CONFLICT`；现在若内容文件仍在 bundle 里，就把它搬回并视为已恢复。
+- **`restored` 残留条目有了 purge 入口**（架构 ARCH-02 / 验收 R-21-02）：恢复成功但 `memory/` 仍有文件时，条目落在"未完成条目"面板，Restore/Discard/Force 全不可用，而 API 的 purge 其实允许。`IncompleteEntries` 现在对 `canPurge === true` 渲染 purge（沿用 `DELETE` 短语确认）。
+- **瞬时读失败不再被当成永久不可恢复**（安全 S-01）：`recoverSessionLog`/`readSessionLogCwd` 过去把所有错误吞成 `null`，于是 EACCES/EBUSY（杀软、备份锁）也会让列表隐藏 Restore 并提供"强制清理（会丢弃记忆）"。现在只有 `ENOENT`/`ENOTDIR` 与解析失败算"确实读不出"，`EACCES`/`EPERM`/`EBUSY`/`EMFILE`/`ENFILE`/`EAGAIN` 一律按瞬时处理：能力位保持 `canRestore`、不给 force，恢复时提示"稍后重试"。
+- **stranded 记忆成为第三种 force 场景**（架构 ARCH-01 的出口）：`entryCapabilities` 新增 `strandedMemory`，与"日志不可读"同级允许 `canForceDiscard`（仍需 `DELETE` 短语）。
+
+### Changed
+
+- **内联确认框改为订阅 seat 状态**：`overlaySeatMounted` 布尔换成 `overlaySeatStore`（订阅式），`DialogHost` 挂载即发布，面板同帧让位；不再依赖 250ms 轮询，消除了双渲染窗口（架构 ARCH-06 / 安全 S-03）。
+- **`lastSweep` 显示相对时间**："Host 已在后台自动清理 N 条"补上 `{when}`（刚刚 / N 分钟前 / N 小时前 / N 天前），避免把 6 小时前的结果当成刚刚发生。
+- `audit.append` 的文档补上契约：**调用方必须已持有跨进程 mutation 锁**（`serialize()` 只排本进程的顺序，补换行读末字节与另一 Host 的追加会交错）。
+
+### Tests
+
+- `test/cascade.test.mjs`（30 → 32）：stranded 记忆开启 force 出口 / 无 stranded 时不开启；force 在 stranded 下被接受、无 stranded 时拒绝且 `forceable` 不置位；瞬时 `EBUSY` 时 restore 提示重试、discard 不把 force 打开。
+- `test/memory.test.mjs`（18 → 19）：导出失败 + 补偿搬回失败 → 留下可用的 rescue bundle，且 `restoreBundle` 能把内容搬回。
+- `test/client-module.test.mjs`（29 → 31）：`canPurge` 时渲染 purge（无该能力时不渲染任何破坏性动作）；`formatAgo` 的相对时间文案。
+- `test/api.test.mjs`（68 → 70）：Origin 栅栏矩阵（127/localhost 混用 403、缺 Host 403、`dsh-app://app` 豁免、跨站拒绝）；端到端验证 stranded 条目被列出为 `strandedMemory` 且 `force:true` 的 discard 被接受（不带 force 仍 409）。
+- 合计 213 → **221**。
+
 ## [0.3.18] — 2026-11-04
 
 一次针对「失败之后再失败」链路的修补，加上客户端与宿主队列预算的统一。0.3.17 的评审结论是正常路径可信、错误处理链路第二层未被同等对待；这一版把 4 条可能导致数据不可逆丢失的路径、8 条一致性/健壮性缺口和文档漂移全部闭合。

package/README.md

@@ -2,7 +2,7 @@
 
 给 DeepSeek Harness (DSH) Web 增加「删除对话」：会话列表的「…」菜单与会话详情页头部各有一个删除入口；确认框内可勾选「同时删除关联记忆」（默认不勾选），并实时显示将被影响的记忆条数。删除默认进入插件回收站，可恢复；每次操作写入审计日志；批量删除有上限与限流，批量软删除需输入数量，彻底删除一键执行；事务任一步失败即回滚。
 
-> 状态：`0.3.18`，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/client.js

@@ -116,6 +116,11 @@ window.__ModuleLoader__.load({
         'trash.expiresIn': 'auto-purged in {days} d',
         'trash.expiresSoon': 'auto-purged on the next check',
         'trash.swept': 'The Host cleaned up {count} expired entries in the background.',
+        'trash.sweptAgo': 'The Host cleaned up {count} expired entries {when}.',
+        'time.justNow': 'just now',
+        'time.minutesAgo': '{count} min ago',
+        'time.hoursAgo': '{count} h ago',
+        'time.daysAgo': '{count} d ago',
         'trash.modeSoft': 'soft',
         'trash.modeHard': 'permanent',
         'trash.items': '{sessions} conversation(s) · {memories} memory entries',
@@ -125,6 +130,7 @@ window.__ModuleLoader__.load({
         'trash.incompleteTitle': 'Incomplete entries',
         'trash.incompleteHint': 'Entries that never committed. Discard them to free the space; an entry that still holds a conversation log must be restored or purged instead.',
         'trash.restoreIncompleteHint': 'Put the conversation log back and re-attach it to its workspace.',
+        'trash.purgeIncompleteHint': 'Delete this entry and everything still inside it. Type DELETE to confirm.',
         'trash.discard': 'Discard',
         'trash.discarded': 'Entry removed.',
         'trash.confirmDiscard': 'Type DELETE to discard this incomplete entry.',
@@ -282,6 +288,11 @@ window.__ModuleLoader__.load({
         'trash.expiresIn': '{days} 天后自动清理',
         'trash.expiresSoon': '下次检查时自动清理',
         'trash.swept': 'Host 已在后台自动清理 {count} 条过期条目。',
+        'trash.sweptAgo': 'Host 已在{when}自动清理 {count} 条过期条目。',
+        'time.justNow': '刚刚',
+        'time.minutesAgo': '{count} 分钟前',
+        'time.hoursAgo': '{count} 小时前',
+        'time.daysAgo': '{count} 天前',
         'trash.modeSoft': '软删除',
         'trash.modeHard': '彻底',
         'trash.items': '{sessions} 个对话 · {memories} 条记忆',
@@ -291,6 +302,7 @@ window.__ModuleLoader__.load({
         'trash.incompleteTitle': '未完成条目',
         'trash.incompleteHint': '这些条目没有提交成功，可直接清理以释放空间；仍保存着会话日志的条目请先恢复或彻底删除。',
         'trash.restoreIncompleteHint': '把会话日志放回原位，并重新挂回它所属的工作区。',
+        'trash.purgeIncompleteHint': '彻底删除该条目及其中残留的内容，需要输入 DELETE 确认。',
         'trash.discard': '清理',
         'trash.discarded': '条目已清理。',
         'trash.confirmDiscard': '输入 DELETE 清理该未完成条目。',
@@ -704,34 +716,28 @@ window.__ModuleLoader__.load({
      * only confirmation dialog the delete flow had. Settings still gets a page
      * island, so the panel can render that same dialog inline instead of
      * pretending the button did nothing.
+     *
+     * A store, not a poll: the panel and the host must flip in the same frame,
+     * otherwise both copies of the dialog render for a tick.
      */
-    let overlaySeatMounted = false
+    const overlaySeatStore = {
+      mounted: false,
+      listeners: new Set(),
+      subscribe(listener) {
+        this.listeners.add(listener)
+        return () => this.listeners.delete(listener)
+      },
+      set(mounted) {
+        const next = mounted === true
+        if (this.mounted === next) return
+        this.mounted = next
+        for (const listener of this.listeners) listener(next)
+      },
+    }
 
     function useOverlaySeatPresent() {
-      const [present, setPresent] = useState(overlaySeatMounted === true)
-      useEffect(() => {
-        if (overlaySeatMounted === true) {
-          setPresent(true)
-          return undefined
-        }
-        // The overlay host mounts with the shell, but nothing guarantees it is
-        // already there when this panel first renders: poll briefly so a late
-        // mount still wins over the inline copy instead of rendering both.
-        let timer = null
-        const tick = () => {
-          if (overlaySeatMounted !== true) return
-          if (timer !== null) clearInterval(timer)
-          setPresent(true)
-        }
-        timer = setInterval(tick, 250)
-        const stop = setTimeout(() => {
-          if (timer !== null) clearInterval(timer)
-        }, 10_000)
-        return () => {
-          if (timer !== null) clearInterval(timer)
-          clearTimeout(stop)
-        }
-      }, [])
+      const [present, setPresent] = useState(overlaySeatStore.mounted)
+      useEffect(() => overlaySeatStore.subscribe(setPresent), [])
       return present
     }
 
@@ -1028,6 +1034,25 @@ window.__ModuleLoader__.load({
       }
     }
 
+    /**
+     * "3 hours ago"-style label for the last background sweep.
+     *
+     * The sweep only runs on the Host's own timer, so the same result stays in
+     * `lastSweep` for up to six hours. Rendering it without a time made users
+     * think the entries had just been deleted on the refresh they had in front
+     * of them.
+     */
+    function formatAgo(value, nowMs = Date.now()) {
+      if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) return ''
+      const seconds = Math.max(0, Math.round((nowMs - value) / 1000))
+      if (seconds < 60) return t('time.justNow')
+      const minutes = Math.round(seconds / 60)
+      if (minutes < 60) return t('time.minutesAgo', { count: minutes })
+      const hours = Math.round(minutes / 60)
+      if (hours < 24) return t('time.hoursAgo', { count: hours })
+      return t('time.daysAgo', { count: Math.round(hours / 24) })
+    }
+
     /**
      * The recycle-bin retention window, read from the Host payload.
      *
@@ -1588,9 +1613,11 @@ window.__ModuleLoader__.load({
       const payload = useDialogState()
       const flash = useFlashMessage()
       useEffect(() => {
-        overlaySeatMounted = true
+        // Publishing synchronously on mount is what keeps the inline copy from
+        // rendering alongside this one: the panel is subscribed, not polling.
+        overlaySeatStore.set(true)
         return () => {
-          overlaySeatMounted = false
+          overlaySeatStore.set(false)
         }
       }, [])
       // `kind` is optional: every pre-0.2.2 caller opens a delete dialog, so a
@@ -1668,7 +1695,7 @@ window.__ModuleLoader__.load({
      * log) gets a Restore button: `performDiscard` refuses exactly those
      * entries, so without this the only way out was a manual API call.
      */
-    function IncompleteEntries({ entries, discardTarget, discardPhrase, discardForce = false, onPhrase, onStart, onForceStart, onCancel, onDiscard, onRestore, restoreBusyId, discardBusyId = null }) {
+    function IncompleteEntries({ entries, discardTarget, discardPhrase, discardForce = false, onPhrase, onStart, onForceStart, onCancel, onDiscard, onRestore, restoreBusyId, discardBusyId = null, purgeTarget = null, purgePhrase = '', onPurgePhrase, onPurgeStart, onPurgeCancel, onPurge, purgeBusyId = null }) {
       return h('div', { className: 'dc-panel dc-incomplete' },
         h('div', { className: 'dc-state-title' }, `${t('trash.incompleteTitle')} (${entries.length})`),
         h('p', { className: 'dc-hint' }, t('trash.incompleteHint')),
@@ -1706,6 +1733,34 @@ window.__ModuleLoader__.load({
                   title: t('trash.restoreIncompleteHint'),
                 }, t('action.restore'))
                 : null,
+              // A restored entry that still holds memory files is purgeable by
+              // the API but was not reachable from this panel: it rendered no
+              // action at all. Offer the same confirmed purge the trash rows use.
+              entry.capabilities?.canPurge === true && typeof onPurge === 'function'
+                ? purgeTarget === entry.trashId
+                  ? h('span', { className: 'dc-inline-confirm' },
+                    h('input', {
+                      type: 'text',
+                      value: purgePhrase,
+                      placeholder: 'DELETE',
+                      className: 'dc-input dc-input-small',
+                      onChange: (event) => onPurgePhrase(event.target.value),
+                      autoCapitalize: 'characters',
+                      autoCorrect: 'off',
+                      spellCheck: false,
+                    }),
+                    h(Button, {
+                      variant: 'danger',
+                      disabled: purgeBusyId === entry.trashId || phraseMatches(purgePhrase, 'DELETE') !== true,
+                      onClick: () => onPurge(entry.trashId),
+                    }, t('action.purge')),
+                    h(Button, { disabled: purgeBusyId === entry.trashId, onClick: onPurgeCancel }, t('action.cancel')))
+                  : h(Button, {
+                    variant: 'danger',
+                    onClick: () => onPurgeStart(entry.trashId),
+                    title: t('trash.purgeIncompleteHint'),
+                  }, t('action.purge'))
+                : null,
               typeof openDiscard !== 'function'
                 ? null
                 : discardTarget === entry.trashId
@@ -2093,7 +2148,9 @@ window.__ModuleLoader__.load({
         tab === 'trash' ? h('div', { id: 'dc-panel-trash', role: 'tabpanel', 'aria-labelledby': 'dc-tab-trash', className: 'dc-panel' },
           retentionDays > 0 ? h('div', { className: 'dc-hint dc-hint-block' }, t('trash.retention', { days: retentionDays })) : null,
           Number(lastSweep?.purged) > 0
-            ? h('div', { className: 'dc-hint dc-hint-block' }, t('trash.swept', { count: Number(lastSweep.purged) }))
+            ? h('div', { className: 'dc-hint dc-hint-block' }, typeof lastSweep?.at === 'number'
+              ? t('trash.sweptAgo', { count: Number(lastSweep.purged), when: formatAgo(lastSweep.at) })
+              : t('trash.swept', { count: Number(lastSweep.purged) }))
             : null,
           trash.length === 0 ? h('div', { className: 'dc-empty' }, t('trash.empty')) : null,
           ...trash.map((entry) => h('div', { key: entry.trashId, className: 'dc-row' },
@@ -2144,6 +2201,13 @@ window.__ModuleLoader__.load({
           onRestore: (trashId) => { void restoreIncomplete(trashId) },
           restoreBusyId,
           discardBusyId,
+          purgeTarget,
+          purgePhrase,
+          purgeBusyId: purgeBusy === true ? purgeTarget : null,
+          onPurgePhrase: setPurgePhrase,
+          onPurgeStart: (trashId) => { setPurgeTarget(trashId); setPurgePhrase('') },
+          onPurgeCancel: () => { setPurgeTarget(null); setPurgePhrase('') },
+          onPurge: (trashId) => { void purge(trashId, purgePhrase.trim()) },
         }) : null,
 
         tab === 'batch' ? h('div', { id: 'dc-panel-batch', role: 'tabpanel', 'aria-labelledby': 'dc-tab-batch', className: 'dc-panel' },
@@ -2404,7 +2468,8 @@ window.__ModuleLoader__.load({
     // guard changes the outcome.
     exports.__phraseMatches = phraseMatches
     exports.__httpFallbackError = httpFallbackError
-    exports.__overlaySeatState = () => ({ mounted: overlaySeatMounted })
+    exports.__overlaySeatState = () => ({ mounted: overlaySeatStore.mounted })
+    exports.__formatAgo = formatAgo
     return module.exports
   },
 })

package/lib/core/audit.js

@@ -93,6 +93,15 @@ export function createAuditLog({ filePath, maxBytes = 5 * 1024 * 1024, retention
      * deletion whose audit write fails must be reported as a failed operation,
      * because "traceable" is part of the contract. Callers run the audit write
      * inside the same transaction step so a failure rolls the deletion back.
+     *
+     * CONTRACT: every caller must already hold the cross-process mutation lock
+     * (`<dataDir>/mutation.lock`). `serialize()` only orders appends inside THIS
+     * process; the trailing-newline repair below reads the last byte and then
+     * appends, which interleaves with a second Host (desktop + `dsh web` share
+     * one DSH_HOME) unless that lock is held. Every current call site (delete,
+     * restore, purge, discard, retention sweep) is inside it — a new caller that
+     * is not must take the lock first, or its record can be glued to another
+     * process's torn tail line.
      */
     append(record) {
       return serialize(async () => {

package/lib/core/cascade.js

@@ -303,6 +303,10 @@ export function entryCapabilities(entry, disk = {}) {
   // Unreadable log ≠ restorable log. Offering restore here produced a button
   // that always failed with "discard it", while discard itself refused.
   const unrecoverable = disk.payloadRecoverable === false
+  // `memory/<adapter>/` holds files but no readable bundle: the export died
+  // before it could write one. Nothing can restore that adapter, so the entry
+  // needs the same explicit exit as an unreadable log.
+  const stranded = disk.strandedMemory === true
   const hasSessionLog = entry?.sessionLog !== null && entry?.sessionLog !== undefined
   const hasCatalog = entry?.catalog !== null && entry?.catalog !== undefined
   const memoryTotal = typeof entry?.memory?.total === 'number' ? entry.memory.total : 0
@@ -325,7 +329,9 @@ export function entryCapabilities(entry, disk = {}) {
     // entry out of all three actions: restore refused the log, discard refused
     // the memory, purge refused the status. This flag marks the one state where
     // a forced discard (explicit, phrase-confirmed) is the remaining exit.
-    canForceDiscard: status !== 'trashed' && hasMemoryFiles === true && unrecoverable === true,
+    canForceDiscard: status !== 'trashed' && hasMemoryFiles === true && (unrecoverable === true || stranded === true),
+    // Surfaced so the panel can explain WHY the forced exit is offered.
+    strandedMemory: stranded,
   }
 }
 
@@ -360,7 +366,17 @@ export async function performRestore({ entry, ops, trash, audit, now = Date.now,
   // "nothing left to restore" (the discard route refuses that folder too, so
   // without this the only copy was stranded).
   if (sessionLog === null && typeof ops.recoverSessionLog === 'function') {
-    sessionLog = await ops.recoverSessionLog(entry).catch(() => null)
+    try {
+      sessionLog = await ops.recoverSessionLog(entry)
+    } catch (error) {
+      // A locked or briefly unreadable log is not a missing one: the right
+      // answer is "try again", not "this can never be restored".
+      throw new DeleteError('E_TRASH_CONFLICT', 'The conversation log could not be read right now (another process may hold it); retry in a moment.', {
+        trashId: entry.trashId,
+        reason: 'log-read-transient',
+        cause: error instanceof Error ? error.message : String(error),
+      })
+    }
   }
   // If the log copy is on disk but its header cannot be read (truncated, wrong
   // codec, missing `cwd`), there is no path to put it back to and no state it
@@ -716,7 +732,13 @@ export async function performDiscard({ entry, ops, trash, audit, now = Date.now,
   // it left the entry stuck in `pending` forever.
   let logUnrecoverable = false
   if (holdsLog === true && (entry.sessionLog === null || entry.sessionLog === undefined) && typeof ops.recoverSessionLog === 'function') {
-    logUnrecoverable = (await ops.recoverSessionLog(entry).catch(() => null)) === null
+    try {
+      logUnrecoverable = (await ops.recoverSessionLog(entry)) === null
+    } catch {
+      // Transient read failure: the log may still be restorable, so this must
+      // not open the forced-discard exit (which deletes the memory bundle).
+      logUnrecoverable = false
+    }
   }
   if (holdsLog === true && !logUnrecoverable) {
     throw new DeleteError('E_TRASH_CONFLICT', 'This incomplete entry still holds the conversation log; restore or purge it instead of discarding it.', {
@@ -732,19 +754,26 @@ export async function performDiscard({ entry, ops, trash, audit, now = Date.now,
   } else {
     holdsMemory = entry.includeMemory === true && (entry.memory?.total ?? 0) > 0
   }
+  // Files without a readable bundle cannot be restored by anything: that is the
+  // second state where a forced, phrase-confirmed discard is the only exit.
+  let strandedMemory = false
+  if (holdsMemory === true && typeof ops.hasStrandedMemory === 'function') {
+    strandedMemory = await ops.hasStrandedMemory(entryDir).catch(() => false) === true
+  }
   // The status half of the decision is shared with the UI; the two refusals
   // below stay separate because their advice differs (purge vs restore).
   const capabilities = entryCapabilities(entry, {
     hasLogFiles: holdsLog === true && !logUnrecoverable,
     hasMemoryFiles: holdsMemory,
     payloadRecoverable: logUnrecoverable ? false : null,
+    strandedMemory,
   })
   if (holdsMemory || !capabilities.canDiscard) {
-    // The exit for the all-refused state: a log whose header cannot be read can
-    // never be restored, and its memory bundle therefore cannot be restored
-    // either. Refusing `force` outside exactly that combination keeps this from
-    // becoming a generic "skip the safety check" switch.
-    const forceAllowed = force === true && logUnrecoverable === true
+    // The exit for the all-refused states: a log whose header cannot be read,
+    // or memory files whose bundle was never written. Both can never be
+    // restored, so the only remaining action is a confirmed discard. Refusing
+    // `force` anywhere else keeps this from becoming a generic skip switch.
+    const forceAllowed = force === true && (logUnrecoverable === true || strandedMemory === true)
     if (!forceAllowed) {
       const which = holdsMemory ? 'memory files' : 'payload'
       throw new DeleteError('E_TRASH_CONFLICT', `This incomplete entry still holds ${which}; restore or purge it instead of discarding it.`, {

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/core/memory/json-index-adapter.js

@@ -477,6 +477,31 @@ export function createJsonIndexMemoryAdapter(options) {
             // copy of it, and the restored index no longer points at it.
             // Removing the bundle here would destroy memory content outright,
             // so keep it and leave a marker explaining the leftover.
+            // Keep the content AND its recoverability. `bundle.json` is written
+            // only after every file moved, so a failure inside the move loop
+            // used to leave `files/` with no manifest: `readExported` saw
+            // nothing, restore refused, discard refused the files it found, and
+            // the entry could never be cleaned up. Write a rescue bundle for the
+            // files that are still here.
+            const strandedEntries = []
+            for (const moved of failedMoves) {
+              const name = basename(moved.to)
+              const original = bundle.entries.find((item) => item.storedFile === name)
+              if (original !== undefined) strandedEntries.push(original)
+            }
+            if (strandedEntries.length > 0) {
+              const rescue = {
+                ...bundle,
+                bundlePath: join(bundleDir, bundleFileName),
+                count: strandedEntries.length,
+                entries: strandedEntries,
+                links: [],
+                rescuedAt: now(),
+              }
+              await fsApi
+                .writeFile(join(bundleDir, bundleFileName), `${JSON.stringify(rescue, null, 2)}\n`, 'utf8')
+                .catch(() => {})
+            }
             await fsApi
               .writeFile(
                 join(bundleDir, ORPHAN_MARKER),
@@ -534,6 +559,22 @@ export function createJsonIndexMemoryAdapter(options) {
               alreadyRestored.add(entry.nodeId)
               continue
             }
+            // The index still lists the node (a failed export restored the
+            // pristine snapshot) while its content file is only in the bundle.
+            // Putting the file back finishes the job; refusing here left the
+            // entry with no usable action at all.
+            if (destination !== null && isPlainFileName(entry.storedFile) && typeof bundle.bundlePath === 'string') {
+              const stored = join(dirname(bundle.bundlePath), 'files', entry.storedFile)
+              try {
+                await fsApi.mkdir(dirname(destination), { recursive: true })
+                await fsApi.rename(stored, destination)
+                alreadyRestored.add(entry.nodeId)
+                continue
+              } catch {
+                // Fall through to the refusal: the content is neither in place
+                // nor where the bundle says it is.
+              }
+            }
             throw new DeleteError('E_TRASH_CONFLICT', 'A memory entry with the same id already exists; restore aborted.', {
               adapter: id,
               nodeId: entry.nodeId,