dsh-archived-chats 0.3.0 → 0.4.0

package/README.md

@@ -18,13 +18,15 @@ Restart DSH once after installing, then open **Settings → Archived Chats**.
 - **Search** by title, plus two filters: type (all / regular / subagent) and project.
 - **Unarchive** a single chat or a whole project group from the group's `⋯` menu — restored chats reappear in the sidebar immediately.
 - **Delete** one chat, a project group, or everything (**Delete All**), each behind a confirmation dialog. Deletion is thorough: the session log is removed from disk, the session is detached from its workspace record, and the registry's in-memory header index is purged, so the sidebar drops the rows live.
-- Sessions that are still resident in the background are **parked permanently** and physically removed on the next DSH start — nothing is left half-deleted, and parked sessions stay hidden meanwhile.
+- Sessions still resident in the background are **deleted in place too**: the plugin disposes the session through the official lifecycle teardown order (cancel → quiesce → flush → fiber teardown → registry detach), the persistence layer releases the write path, and the physical delete completes within the same request — no restart. If the running DSH build does not expose the required internal seams, the plugin falls back to "park permanently + delete on the next start", with parked sessions staying hidden meanwhile.
 - Works in light and dark schemes; localized in English and 中文.
 
 ## How it works
 
 - **Host half** (`lib/index.js`) registers the `/plugins/dsh-archived-chats/*` routes on the DSH web server: `GET /state`, `POST /unarchive`, `POST /unarchive-all`, `POST /delete`, `POST /delete-all`. Unarchiving writes through the workspace registry's own state path, so every connected client receives the `host/archived-sessions-changed` push. Mutating routes require a custom `x-dsh-archived-chats: 1` header as CSRF hardening.
-- **Pending-deletion store**: deleting a live session takes a "park and defer" path — the agent is cancelled permanently (`cancel({ kind: 'disposed' })`), the session stays archived and hidden, and the id is recorded in `$DSH_HOME/plugin-data/archived-chats/pending-deletions.json`. On the next boot the plugin sweeps the queue and completes the deletion through the ordinary delete path. Parked sessions are excluded from the listing; unarchiving one before the restart cancels its pending deletion.
+- **In-place live deletion**: deleting a resident session replays the agent factory's own disposer sequence — `cancel({ kind: 'disposed' })` → `whenIdle` → `flush` → `agent.scope.dispose()` → detach of the `agents` and `sessions` store entries. The session detach emits `session/disposed`, the persistence coordinator retires (drains and releases) the write path, and the ordinary cold delete completes in the same request. The store entries are internal surfaces, so every step is feature-detected; anything missing falls back to park-and-defer.
+- **Pending-deletion store** (fallback path and crash bracket): the id is recorded in `$DSH_HOME/plugin-data/archived-chats/pending-deletions.json` while the session stays archived and hidden; the next boot sweeps the queue through the ordinary delete path. In-place deletes are bracketed by the same store (recorded before disposal, cleared once the files are gone), so a crash mid-delete is completed on the next start. Parked sessions are excluded from the listing; unarchiving cancels a pending deletion.
+- **Title cache**: resolved titles are memoized per id across list refreshes instead of re-reading every archived log; delete and unarchive invalidate their entries.
 - **Browser half** (`lib/client.js`) registers a `settings.section` slot entry (order 30) and renders the page with React and DSH design tokens.
 
 ## Uninstall

package/README.zh.md

@@ -18,13 +18,15 @@ dsh plugin --profile web add dsh-archived-chats
 - **搜索**标题，外加两个筛选器：类型（全部 / 普通会话 / 子代理会话）和项目。
 - **取消归档**单个聊天，或从分组的 `⋯` 菜单整组取消——恢复的聊天会立刻回到侧边栏。
 - **删除**单个聊天、某个项目分组或全部（**全部删除**），均有确认弹窗。删除是彻底的：会话日志从磁盘移除、从工作区记录中摘除、注册表内存索引同步清理，主侧边栏的条目也会立即消失。
-- 仍驻留后台的会话会被**永久停用**，待下次启动 DSH 时完成物理删除——不会留下半删除状态，停用期间会话保持隐藏。
+- 仍驻留后台的会话也**当场删除**：插件按官方生命周期的拆除顺序原地停用并注销会话（取消 → 静默 → 落盘 → 拆纤程 → 摘出注册表），持久层随之释放写入通道，同一次请求内即完成物理删除——无需重启。若当前 DSH 版本不提供所需内部接口，则自动回退为「永久停用 + 下次启动完成删除」，停用期间会话保持隐藏。
 - 适配浅色/深色主题，支持中文和英文界面。
 
 ## 实现原理
 
 - **Host 半**（`lib/index.js`）在 DSH Web 服务器上注册 `/plugins/dsh-archived-chats/*` 路由：`GET /state`、`POST /unarchive`、`POST /unarchive-all`、`POST /delete`、`POST /delete-all`。取消归档走 workspace registry 自身的状态写入通道，所有已连接的客户端都会收到 `host/archived-sessions-changed` 推送。写操作路由要求自定义请求头 `x-dsh-archived-chats: 1` 作为 CSRF 加固。
-- **待删队列**：删除仍在后台运行的会话时采用「停用并延后」策略——agent 被永久取消（`cancel({ kind: 'disposed' })`），会话保持归档与隐藏，id 记入 `$DSH_HOME/plugin-data/archived-chats/pending-deletions.json`；下次启动时插件会清扫该队列，通过常规删除路径完成物理删除。已入队的会话不会出现在列表中；若在重启前取消归档，待删标记会被撤销。
+- **活会话原地删除**：删除仍驻留后台的会话时，插件复刻 agent 工厂自身 disposer 的顺序——`cancel({ kind: 'disposed' })` → `whenIdle` → `flush` → `agent.scope.dispose()` → 依次 detach `agents` 与 `sessions` 两个 store 条目；session detach 发出 `session/disposed`，持久化协调器随之 retire（排空并释放）该会话的写入通道，之后冷删除路径在同一请求内完成。所涉 store 条目属于内部接口，每一步都做特性探测，探测失败即回退为停用+延后。
+- **待删队列**（回退路径与崩溃兜底）：id 记入 `$DSH_HOME/plugin-data/archived-chats/pending-deletions.json`，会话保持归档与隐藏；下次启动时插件清扫该队列，通过常规删除路径完成物理删除。原地删除也用该队列包裹（删除前登记、文件移除后清除），中途崩溃由下次启动补完。已入队的会话不会出现在列表中；取消归档会撤销待删标记。
+- **标题缓存**：列表刷新时按 id 记忆已解析的标题，不再每次全量读日志；删除与取消归档会使对应缓存失效。
 - **浏览器半**（`lib/client.js`）注册 `settings.section` 插槽项（order 30），用 React 和 DSH 设计令牌渲染页面。
 
 ## 卸载

package/lib/client.js

@@ -124,6 +124,19 @@ window.__ModuleLoader__.load({
 			: n === 1
 				? "1 chat is parked and will be permanently deleted after DSH restarts"
 				: `${n} chats are parked and will be permanently deleted after DSH restarts`;
+		// Success confirmation after a completed delete — same copy as CodeX.
+		const deletedText = (t, n) => isZh(t)
+			? "已删除归档聊天"
+			: n === 1 ? "Archived chat deleted" : `${n} archived chats deleted`;
+		// Pin the success toast just inside the settings dialog's top edge: the
+		// toast is fixed-positioned (viewport coordinates), so measure where the
+		// dialog actually starts instead of hardcoding an offset.
+		const toastTop = () => {
+			try {
+				const top = document.querySelector('[role="dialog"]')?.getBoundingClientRect().top;
+				return typeof top === "number" && top >= 0 ? Math.round(top) + 16 : 24;
+			} catch { return 24; }
+		};
 		function formatDate(t, ms) {
 			if (typeof ms !== "number" || !Number.isFinite(ms)) return "";
 			try {
@@ -139,7 +152,7 @@ window.__ModuleLoader__.load({
 
 		//#region styles
 		const CSS = `
-.dac-page{display:flex;flex-direction:column;gap:14px;padding:4px 0 28px;font-family:inherit}
+.dac-page{position:relative;display:flex;flex-direction:column;gap:14px;padding:4px 0 28px;font-family:inherit}
 .dac-head{display:flex;align-items:center;justify-content:space-between;gap:12px}
 .dac-title{color:var(--dsw-alias-label-primary);font-size:18px;font-weight:500;line-height:28px}
 .dac-deleteall{display:inline-flex;align-items:center;gap:6px;border:none;border-radius:999px;padding:6px 14px;background:rgba(229,72,77,.1);color:#e5484d;font:inherit;font-size:13px;line-height:20px;cursor:pointer;transition:background .15s}
@@ -187,6 +200,12 @@ window.__ModuleLoader__.load({
 .dac-retry{border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:transparent;color:var(--dsw-alias-label-primary);font:inherit;font-size:12px;padding:4px 12px;cursor:pointer}
 .dac-notice{display:flex;align-items:center;justify-content:space-between;gap:10px;border:1px solid rgba(229,72,77,.45);border-radius:10px;background:rgba(229,72,77,.08);color:#e5484d;font-size:12px;line-height:18px;padding:8px 12px}
 .dac-notice button{border:none;background:transparent;color:inherit;cursor:pointer;font:inherit;padding:0;display:inline-flex}
+.dac-toast{position:fixed;top:20px;left:50%;transform:translateX(-50%);z-index:1200;display:flex;align-items:center;gap:8px;border:1px solid rgba(48,164,108,.4);border-radius:999px;background:color-mix(in srgb,#30a46c 9%,var(--dsw-alias-bg-primary,#fff));color:#2f9e68;font-size:13px;font-weight:500;line-height:20px;padding:7px 12px 7px 14px;box-shadow:0 6px 20px rgba(0,0,0,.10),0 1px 3px rgba(0,0,0,.06);animation:dac-toast-in .28s cubic-bezier(.21,1.02,.55,1) both}
+.dac-toast svg{flex:none}
+.dac-toast button{border:none;background:transparent;color:inherit;opacity:.55;cursor:pointer;font:inherit;padding:2px;margin-left:2px;display:inline-flex;border-radius:999px}
+.dac-toast button:hover{opacity:1;background:rgba(48,164,108,.12)}
+@keyframes dac-toast-in{from{opacity:0;transform:translateX(-50%) translateY(-10px) scale(.96)}to{opacity:1;transform:translateX(-50%) translateY(0) scale(1)}}
+@media (prefers-reduced-motion:reduce){.dac-toast{animation:none}}
 .dac-confirm-overlay{position:fixed;inset:0;z-index:1400;display:flex;align-items:center;justify-content:center;background:rgba(0,0,0,.4)}
 .dac-confirm{width:min(400px,calc(100vw - 64px));display:flex;flex-direction:column;gap:12px;border-radius:16px;background:var(--dsw-alias-bg-layer-2);box-shadow:0 16px 64px rgba(0,0,0,.3);padding:20px}
 .dac-confirm-title{color:var(--dsw-alias-label-primary);font-size:15px;font-weight:500;line-height:24px}
@@ -310,6 +329,9 @@ window.__ModuleLoader__.load({
 		function IconClose({ size = 12 }) {
 			return (0, jsx.jsx)("svg", { ...svgProps(size), children: (0, jsx.jsx)("path", { d: "M6 6l12 12M18 6 6 18" }) });
 		}
+		function IconCheckCircle({ size = 15 }) {
+			return (0, jsx.jsxs)("svg", { ...svgProps(size), children: [(0, jsx.jsx)("circle", { cx: 12, cy: 12, r: 9 }), (0, jsx.jsx)("path", { d: "m8.5 12.2 2.4 2.4 4.6-5" })] });
+		}
 		//#endregion
 
 		//#region components
@@ -473,6 +495,16 @@ window.__ModuleLoader__.load({
 			const [notice, setNotice] = _react.useState(null);
 			const [collapsed, setCollapsed] = _react.useState(readCollapsed);
 
+			// Success confirmations are transient toasts (CodeX behavior);
+			// errors stay until dismissed.
+			_react.useEffect(() => {
+				if (notice?.kind !== "ok") return undefined;
+				const timer = setTimeout(() => {
+					setNotice((current) => (current === notice ? null : current));
+				}, 4000);
+				return () => clearTimeout(timer);
+			}, [notice]);
+
 			const toggleCollapsed = (key) => {
 				setCollapsed((prev) => {
 					const next = { ...prev };
@@ -512,7 +544,7 @@ window.__ModuleLoader__.load({
 					await post("/unarchive-all", { sessionIds: ids });
 					setSessions((prev) => (prev ?? []).filter((s) => !ids.includes(s.id)));
 				} catch (error) {
-					setNotice(String(error.message ?? error));
+					setNotice({ kind: "error", text: String(error.message ?? error) });
 				} finally {
 					markBusy(ids, false);
 				}
@@ -535,8 +567,9 @@ window.__ModuleLoader__.load({
 						// next-boot sweep physically removes it.
 						setSessions((prev) => (prev ?? []).filter((s) => !deleted.includes(s.id) && !pending.includes(s.id)));
 					}
-					if (failed.length > 0) setNotice(failureText(t, failed));
-					else if (pending.length > 0) setNotice(pendingText(t, pending.length));
+					if (failed.length > 0) setNotice({ kind: "error", text: failureText(t, failed) });
+					else if (pending.length > 0) setNotice({ kind: "error", text: pendingText(t, pending.length) });
+					else if (deleted.length > 0) setNotice({ kind: "ok", text: deletedText(t, deleted.length) });
 				} catch (error) {
 					const deleted = error.body?.deleted ?? [];
 					const pending = error.body?.pending ?? [];
@@ -545,7 +578,7 @@ window.__ModuleLoader__.load({
 						changed = true;
 						setSessions((prev) => (prev ?? []).filter((s) => !deleted.includes(s.id) && !pending.includes(s.id)));
 					}
-					setNotice(failed.length > 0 ? failureText(t, failed) : String(error.message ?? error));
+					setNotice({ kind: "error", text: failed.length > 0 ? failureText(t, failed) : String(error.message ?? error) });
 				} finally {
 					markBusy(ids, false);
 					setConfirm(null);
@@ -669,10 +702,20 @@ window.__ModuleLoader__.load({
 							})
 						]
 					}),
-					notice !== null && (0, jsx.jsxs)("div", {
+					notice !== null && notice.kind === "ok" && (0, jsx.jsxs)("div", {
+						className: "dac-toast",
+						role: "status",
+						style: { top: `${toastTop()}px` },
+						children: [
+							(0, jsx.jsx)(IconCheckCircle, {}),
+							(0, jsx.jsx)("span", { children: notice.text }),
+							(0, jsx.jsx)("button", { type: "button", "aria-label": t("notice.dismiss"), onClick: () => setNotice(null), children: (0, jsx.jsx)(IconClose, {}) })
+						]
+					}),
+					notice !== null && notice.kind !== "ok" && (0, jsx.jsxs)("div", {
 						className: "dac-notice",
 						children: [
-							(0, jsx.jsx)("span", { children: notice }),
+							(0, jsx.jsx)("span", { children: notice.text }),
 							(0, jsx.jsx)("button", { type: "button", "aria-label": t("notice.dismiss"), onClick: () => setNotice(null), children: (0, jsx.jsx)(IconClose, {}) })
 						]
 					}),

package/lib/index.js

@@ -14,8 +14,10 @@
  *   POST /plugins/dsh-archived-chats/delete-all     → { sessionIds: [...] }
  *
  *   Mutating responses carry { ok, deleted, pending, failed }: `deleted` is
- *   complete cold deletes, `pending` is live sessions accepted for deferred
- *   deletion (parked now, physically removed on the next boot).
+ *   complete deletes (cold sessions, and live sessions this build lets us
+ *   dispose in place), `pending` is live sessions accepted for deferred
+ *   deletion (parked now, physically removed on the next boot — the fallback
+ *   when in-place disposal is unavailable).
  *
  * The stock workspace registry only exposes `archiveSession` — unarchiving and
  * deleting live here, behind one HTTP surface the browser half can drive.
@@ -25,20 +27,32 @@
  * updates live). Delete additionally detaches the session from its workspace
  * record and removes the session-log directory from disk.
  *
- * Deleting a COLD session is immediate. A session that is still LIVE (opened
- * at least once this boot — web agents stay resident until shutdown and the
- * stock composition exposes no dispose) cannot have its log ripped out from
- * under it: the persistence coordinator would hit ENOENT on its next append.
- * Instead the live path parks the agent permanently (`cancel({kind:
- * 'disposed'})` — parked input never wakes the driver again), waits for
- * quiescence, flushes durability, then records the id in a small
- * pending-deletions store while KEEPING it archived so it stays invisible.
- * The boot sweep (`sweepPendingDeletions`, launched once when the plugin's
- * three services have all bound) completes the removal through the ordinary
- * cold delete path on the next boot — when every session is cold. Unarchiving
- * a parked session drops it from the pending store, and the sweep skips ids
- * that are no longer archived, so an unarchive always wins over a parked
- * deletion.
+ * Deleting a COLD session is immediate. A LIVE session (opened at least once
+ * this boot — web agents stay resident until shutdown) cannot have its log
+ * ripped out from under it: the persistence coordinator would hit ENOENT on
+ * its next append. The live path therefore disposes the session first, the
+ * same sequence the agent factory's own lifecycle disposer runs: cancel the
+ * agent with the `disposed` cause, wait for quiescence, flush durability,
+ * tear down the agent's fiber (`agent.scope.dispose()`), then detach the
+ * `agents` and `sessions` store entries — the session-store detach emits
+ * `session/disposed`, which the persistence coordinator answers by retiring
+ * (draining and releasing) the session's write path. Once retired the session
+ * is cold and the ordinary delete completes in the same request — no restart.
+ *
+ * The store entries and their `detach` are internal surfaces of this dsh
+ * build (plain properties, not exported API), so every step is feature-
+ * detected. When any piece is missing the live path falls back to the
+ * original conservative behavior: the agent is left parked (cancelled,
+ * flushed) and the id is recorded in a small pending-deletions store while
+ * KEEPING it archived so it stays invisible. The boot sweep
+ * (`sweepPendingDeletions`, launched once when the plugin's three services
+ * have all bound) completes the removal through the ordinary cold delete path
+ * on the next boot — when every session is cold. The pending store also
+ * brackets the successful live path (recorded before disposal, cleared after
+ * the files are gone), so a crash mid-delete is swept on the next boot
+ * instead of leaving a half-deleted ghost. Unarchiving a parked session drops
+ * it from the pending store, and the sweep skips ids that are no longer
+ * archived, so an unarchive always wins over a parked deletion.
  *
  * Routes bind lazily (same posture as dsh-agent-teams): the web server, the
  * workspace registry, and session persistence may mount after this plugin
@@ -166,9 +180,13 @@ function extractTitle(events) {
 /**
  * Build the archived-session listing: one row per archived id with the
  * resolved title, creation time, and owning workspace (accounting slot first,
- * canonical cwd second, ungrouped last).
+ * canonical cwd second, ungrouped last). Resolved titles are memoized in
+ * `titleCache` (id → title) so refreshes stop re-reading every archived log:
+ * only non-null titles are cached — a title-less session stays cheap to
+ * re-inspect and picks up a late `session/title` event on the next refresh.
+ * Delete and unarchive invalidate their ids.
  */
-async function listArchived(ctx, registry, persistence) {
+async function listArchived(ctx, registry, persistence, titleCache) {
     const archivedIds = registry.archivedSessionIds.map(String);
     if (archivedIds.length === 0) return [];
     const headerById = new Map();
@@ -182,12 +200,15 @@ async function listArchived(ctx, registry, persistence) {
     const rows = [];
     for (const id of archivedIds) {
         const header = headerById.get(id) ?? live?.get(id)?.header;
-        let title;
-        try {
-            const inspection = await persistence.inspect(id);
-            title = extractTitle(inspection.events);
-        } catch {
-            // A torn/unreadable log still lists — the row is manageable without a title.
+        let title = titleCache?.get(id);
+        if (title === undefined) {
+            try {
+                const inspection = await persistence.inspect(id);
+                title = extractTitle(inspection.events);
+                if (title !== undefined) titleCache?.set(id, title);
+            } catch {
+                // A torn/unreadable log still lists — the row is manageable without a title.
+            }
         }
         const workspace = workspaces.find((w) => w.sessionIds.map(String).includes(id));
         rows.push({
@@ -227,14 +248,29 @@ async function unarchiveIds(registry, ids) {
 }
 
 /**
- * Park a live session for deletion: cancel its agent with the `disposed`
- * cause (parked input never wakes the driver again), wait for quiescence so
- * in-flight closing events land, then flush durability. Afterwards the log is
- * frozen and the id joins the pending-deletions store; the session STAYS
- * archived so it keeps hidden until the next-boot sweep completes the delete.
+ * Dispose a live session in place so its deletion can complete without a
+ * restart. Mirrors the agent factory's own lifecycle disposer: cancel the
+ * agent with the `disposed` cause (parked input never wakes the driver
+ * again), wait for quiescence so in-flight closing events land, flush
+ * durability, tear down the agent's fiber, then detach the `agents` and
+ * `sessions` store entries. The session-store detach emits `session/disposed`
+ * — the persistence coordinator answers by retiring (draining and releasing)
+ * the session's write path, after which the log directory is free to remove.
+ *
+ * The store maps and their entries' `detach` are internal surfaces of this
+ * dsh build, so every step is feature-detected. Returns true when the session
+ * ends up fully detached (cold); false when disposal is unavailable or did
+ * not converge — the session is then left in the parked state (cancelled and
+ * flushed) and the caller falls back to the deferred next-boot deletion.
  */
-async function parkLiveSession(ctx, id) {
-    const agent = ctx.get('agents')?.get(id);
+async function disposeLiveSession(ctx, id) {
+    const sessions = ctx.get('sessions');
+    const agents = ctx.get('agents');
+    const session = sessions?.get(id);
+    if (session === undefined) return true;
+    // Park first — this is also the complete fallback outcome: the loop can
+    // never run again and the log's buffered tail is durable.
+    const agent = agents?.get(id);
     if (agent !== undefined) {
         try {
             agent.cancel({ kind: 'disposed' });
@@ -246,27 +282,60 @@ async function parkLiveSession(ctx, id) {
             ctx.logger.warn(`archived-chats: parking ${id} did not fully converge: ${String(error)}`);
         }
     }
-    const sessions = ctx.get('sessions');
-    const live = sessions?.get(id);
-    if (live !== undefined && typeof sessions.flush === 'function') {
-        try { await sessions.flush(live); }
-        catch (error) { ctx.logger.warn(`archived-chats: flush before parking ${id} failed: ${String(error)}`); }
+    if (typeof sessions.flush === 'function') {
+        try { await sessions.flush(session); }
+        catch (error) { ctx.logger.warn(`archived-chats: flush before disposing ${id} failed: ${String(error)}`); }
+    }
+    // Feature-detect the internal store entries before touching anything else:
+    // without BOTH detach capabilities the session must stay parked. The
+    // session-store entry carries its own `detach`; the agent-registry entry
+    // does not (its detach closure lives with the creator), so the agent side
+    // goes through the registry's `detachEntered(entry)` — the same method
+    // that closure calls.
+    const sessionEntry = sessions.store instanceof Map ? sessions.store.get(id) : undefined;
+    const agentEntry = agents?.store instanceof Map ? agents.store.get(id) : undefined;
+    if (typeof sessionEntry?.detach !== 'function') return false;
+    if (agent !== undefined && (agentEntry === undefined
+        || typeof agents.detachEntered !== 'function'
+        || agentEntry.announcing === true)) return false;
+    // Factory disposer order: agent fiber first, then unregister the agent,
+    // then detach the session (emitting `session/disposed`).
+    try { await agent?.scope?.dispose?.(); }
+    catch (error) { ctx.logger.warn(`archived-chats: agent fiber teardown for ${id} failed: ${String(error)}`); }
+    try { if (agentEntry !== undefined) agents.detachEntered(agentEntry); }
+    catch (error) { ctx.logger.warn(`archived-chats: agent detach for ${id} failed: ${String(error)}`); }
+    try { sessionEntry.detach(); }
+    catch (error) {
+        ctx.logger.warn(`archived-chats: session detach for ${id} failed: ${String(error)}`);
+        return false;
     }
-    await addPending(id);
+    // Detach can defer while a creation announce or append is unwinding — if
+    // the session is still in the store, treat it as parked, not disposed.
+    if (sessions.get(id) !== undefined) return false;
+    // The retirement triggered by `session/disposed` drains asynchronously.
+    // The pre-detach flush left nothing buffered, so a short settle keeps the
+    // log-directory removal below clear of the drain's final serialize.
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    return true;
 }
 
 /**
  * Delete one archived session. A COLD session is removed end to end right
  * away: unarchive, detach from the owning workspace record, remove the
  * session-log directory from disk, and purge the registry's stale header
- * index. A LIVE session is parked and deferred instead (see
- * {@link parkLiveSession}) and reported as `pending`.
+ * index. A LIVE session is first disposed in place (see
+ * {@link disposeLiveSession}) and then follows the same cold path in this
+ * request; when in-place disposal is unavailable on this build it stays
+ * parked and is reported as `pending` for the next-boot sweep. Either way the
+ * id sits in the pending-deletions store from before disposal until the files
+ * are gone, so a crash mid-delete is completed by the sweep instead of
+ * leaving a half-deleted ghost.
  */
-async function deleteSession(ctx, registry, persistence, id) {
-    const live = ctx.get('sessions');
-    if (live?.get(id) !== undefined) {
-        await parkLiveSession(ctx, id);
-        return 'pending';
+async function deleteSession(ctx, registry, persistence, id, titleCache) {
+    if (ctx.get('sessions')?.get(id) !== undefined) {
+        await addPending(id);
+        const disposed = await disposeLiveSession(ctx, id);
+        if (!disposed) return 'pending';
     }
     await unarchiveIds(registry, [id]);
     for (const workspace of registry.list()) {
@@ -295,6 +364,10 @@ async function deleteSession(ctx, registry, persistence, id) {
         const map = registry[key];
         if (map instanceof Map) map.delete(id);
     }
+    titleCache?.delete(id);
+    // Clear the crash bracket (and any pre-existing parked mark) now that the
+    // files are gone. A no-op for ids that were never pending.
+    await removePending([id]);
     return 'deleted';
 }
 
@@ -335,13 +408,13 @@ async function sweepPendingDeletions(ctx, registry, persistence) {
 //#endregion
 
 //#region routes
-function registerRoutes(ctx, webServer, registry, persistence) {
+function registerRoutes(ctx, webServer, registry, persistence, titleCache) {
     ctx.effect(() => webServer.register({
         kind: 'exact',
         path: `${ROUTE_PREFIX}/state`,
         handler: async (req, res) => {
             try {
-                const sessions = await listArchived(ctx, registry, persistence);
+                const sessions = await listArchived(ctx, registry, persistence, titleCache);
                 send(res, 200, { sessions });
             } catch (error) {
                 ctx.logger.warn(`archived-chats: state failed: ${String(error)}`);
@@ -362,6 +435,7 @@ function registerRoutes(ctx, webServer, registry, persistence) {
                     return;
                 }
                 const archivedSessionIds = await unarchiveIds(registry, [body.sessionId]);
+                titleCache.delete(body.sessionId);
                 await removePending([body.sessionId]);
                 send(res, 200, { ok: true, archivedSessionIds });
             } catch (error) {
@@ -383,6 +457,7 @@ function registerRoutes(ctx, webServer, registry, persistence) {
                     return;
                 }
                 const archivedSessionIds = await unarchiveIds(registry, ids);
+                for (const id of ids) titleCache.delete(id);
                 await removePending(ids);
                 send(res, 200, { ok: true, archivedSessionIds });
             } catch (error) {
@@ -407,7 +482,7 @@ function registerRoutes(ctx, webServer, registry, persistence) {
             const failed = [];
             for (const id of ids) {
                 try {
-                    const outcome = await deleteSession(ctx, registry, persistence, id);
+                    const outcome = await deleteSession(ctx, registry, persistence, id, titleCache);
                     if (outcome === 'pending') pending.push(id);
                     else deleted.push(id);
                 } catch (error) {
@@ -439,6 +514,8 @@ function registerRoutes(ctx, webServer, registry, persistence) {
  */
 export function apply(ctx) {
     let registered = false;
+    /** Memoized session titles for {@link listArchived} (id → title). */
+    const titleCache = new Map();
     const registerWebSurface = () => {
         if (registered) return;
         const webServer = ctx.get(WEB_SERVER_KEYS[0]) ?? ctx.get(WEB_SERVER_KEYS[1]);
@@ -446,7 +523,7 @@ export function apply(ctx) {
         const persistence = ctx.get(PERSISTENCE_KEYS[0]);
         if (webServer === undefined || registry === undefined || persistence === undefined) return;
         registered = true;
-        registerRoutes(ctx, webServer, registry, persistence);
+        registerRoutes(ctx, webServer, registry, persistence, titleCache);
         // Boot sweep: every pending-deletion id is cold now (plugin activation
         // precedes any client resume), so complete each deferred deletion.
         void sweepPendingDeletions(ctx, registry, persistence)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-archived-chats",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "DeepSeek Harness 已归档会话管理页：在设置里查看、搜索、取消归档、删除已归档的聊天，按项目分组。An Archived Chats settings page for DeepSeek Harness: browse, search, unarchive, and delete archived sessions, grouped by workspace.",
   "license": "MIT",
   "author": "Ultronen",