@murchey/dsh-session-manager 0.1.1 → 0.1.2

package/README.md

@@ -41,11 +41,11 @@ dsh plugin --profile <profile> add link:<此目录绝对路径>
 
 - 顶部显示总会话数与磁盘占用；
 - 每个会话显示标题、ID、项目目录、创建日期、占用空间和比例条；
-- 运行中的会话标记为 `运行中`，不能选择（先结束会话再删除）；已归档会话显示 `已归档` 徽标；页面打开期间每 5 秒自动同步一次状态，切回后台页面时会立即同步，因此结束会话后无需重启 DSH；
+- 只有**正在生成**的会话标记为 `运行中` 并禁止选择；“已归档”会话显示 `已归档` 徽标，只要没有正在运行的一轮，就可以直接删除，不再需要重启 DSH；页面打开期间每 5 秒自动同步一次状态，切回后台页面时会立即同步；
 - 支持按标题 / ID / 项目目录搜索，按大小或时间排序；
 - 行尾“删除”按钮删除单个会话，“删除所选”批量删除；
 - 删除前弹出确认对话框，明确显示数量、总字节数和“不可撤销”警告，并默认勾选“同时删除不再被其他会话引用的附件”；
-- 删除成功后主动刷新 Client 会话目录，左侧会话列表同步移除条目；
+- 删除成功后会同时把会话从 DSH 的归档 / 置顶集合中移除，避免侧边栏残留“已归档”空条目，并主动刷新 Client 会话目录；
 - 顶部“清理失效栏目”按钮用于历史遗留：先向 Host 重新拉取权威会话目录，再把侧边栏中数据已不存在的条目从本地目录移除（不会删除任何仍然存在的会话）；删除成功后也会顺带执行同样的清理。
 
 页面通过 Connection 的已认证 `/api/session-shredder/*` 路由读写；UI 的确认对话框就是人工闸门，Host 路由仍要求 `confirm:true` 并只接受 owner 浏览器会话。
@@ -70,7 +70,9 @@ dsh plugin --profile <profile> add link:<此目录绝对路径>
 ## 安全规则
 
 - 插件在 Host 进程内运行，**不受**会话 workspace 文件沙箱限制；它只按配置的数据根删除，并校验每个目标确实位于根内。
-- 当前会话、本进程内仍存活的会话（含子代理）**拒绝删除**。
+- 当前会话、正在运行的一轮（`agent.status === 'running'`）**拒绝删除**。
+- “驻留内存但空闲”的 Agent 不再等同于“运行中”：DSH 归档只是把会话移入归档集合，并不会销毁 Agent，因此旧逻辑会把归档会话永久锁死，只能靠重启释放。现在这类会话可以删除，`plan` 会给出提示而不是阻止。
+- 归档 / 置顶只是 `workspace.json` 里的元数据；插件在删除成功后会把对应 id 从这两个集合中移除，避免留下删不掉的空条目。
 - 会话 id 只接受安全字符（顶层会话 `session-<token>`、子代理裸 UUID）；路径编码与 DSH 的 JSONL 后端完全一致，避免路径穿越。
 - 只删除 `sessionsRoot` / `projectionCacheRoot` / `attachmentsRoot` 内部的真实目录，不跟随符号链接。
 - 子代理会话不能调用该工具，只有顶层会话可以。
@@ -108,7 +110,7 @@ dsh plugin --profile <profile> add link:<此目录绝对路径>
 
 ## 不会处理的内容
 
-- `workspace.json` 里的会话排序 / 归档 id：只是元数据，DSH 在下次 workspace 变更时会自动剪除；它们不包含会话内容。
+- `workspace.json` 里的会话排序 id：只是元数据，DSH 在下次 workspace 变更时会自动剪除；归档 / 置顶 id 会在删除成功后由插件主动移除（它们不包含会话内容）。
 - 会话搜索索引（若启用 SQLite 后端）：DSH 启动时会按持久化列表对账删除，重启后消失。
 - `llm-deepseek/files-v3.json` 中的远端 `fileId` 映射：只有引用，不含内容，且远端文件会过期。
 - 系统临时目录中由子进程产生的日志/溢出文件，以及 Web 端浏览器缓存。

package/index.js

@@ -30,7 +30,7 @@ const TOOL_DESCRIPTION = [
   'Permanently delete DSH session data from disk: the append-only session log plus every historical format generation, the projection-cache record, the legacy cache-seed entry, and attachments that no surviving session references.',
   'This is irreversible. Use it only when the user explicitly asks to permanently delete sessions. Never use it for "archive", "hide", cleanup suggestions, or the current session.',
   'Workflow: call action:"list" to discover ids, call action:"plan" for the exact footprint and blockers, show that plan to the user, and call action:"purge" with confirm:true only after the user agrees.',
-  'A purge refuses the current session and any live session, and asks the user for approval before deleting.',
+  'A purge refuses the current session and any session with a running turn, and asks the user for approval before deleting. Archived sessions are deletable once idle, and their archive/pin entries are dropped with the data.',
 ].join(' ');
 
 /**
@@ -136,6 +136,7 @@ function registerHttpRoutes(ctx, options) {
               bytes: session.bytes,
               eventCount: session.eventCount ?? null,
               live: session.live,
+              resident: session.resident === true,
               archived: session.archived === true,
               orphan: session.orphan,
               subagent: !session.id.startsWith('session-'),
@@ -187,6 +188,7 @@ function registerHttpRoutes(ctx, options) {
             deletedBytes: result.deletedBytes,
             attachments: result.attachments,
             requestImageCache: result.requestImageCache,
+            metadata: result.metadata,
             targets: result.targets.map((target) => ({
               id: target.id,
               bytes: target.bytes,
@@ -283,8 +285,12 @@ async function planAction(ctx, options, sessionIds, currentSessionId) {
     `Purge plan (dry run) — ${plan.targets.length} session${plan.targets.length === 1 ? '' : 's'}, ${formatBytes(plan.totalBytes)} on disk.`,
   ];
   for (const target of plan.targets) {
+    const flags = [target.archived ? 'ARCHIVED' : '', target.resident ? 'RESIDENT' : '', target.live ? 'RUNNING' : '']
+      .filter(Boolean)
+      .join(', ');
     lines.push(
-      `- ${target.id}${target.title !== undefined ? `  "${target.title}"` : ''}  ${formatBytes(target.bytes)}`,
+      `- ${target.id}${target.title !== undefined ? `  "${target.title}"` : ''}  ${formatBytes(target.bytes)}` +
+        `${flags === '' ? '' : `  [${flags}]`}`,
     );
     if (target.dirs.length > 0) {
       for (const dir of target.dirs) lines.push(`    log: ${dir}`);
@@ -345,6 +351,9 @@ async function purgeAction(ctx, options, args, exec, currentSessionId) {
       `Request-image cache: cleared (${formatBytes(result.requestImageCache.bytes)}, ${result.requestImageCache.files} file(s)).`,
     );
   }
+  if (Array.isArray(result.metadata?.pruned) && result.metadata.pruned.length > 0) {
+    lines.push(`Archive/pin entries removed: ${result.metadata.pruned.join(', ')}.`);
+  }
   for (const target of result.targets) {
     lines.push(
       `- ${target.id}: ${formatBytes(target.bytes)}, ${target.files} file${target.files === 1 ? '' : 's'}` +

package/lib/core.js

@@ -321,14 +321,42 @@ async function safeTitle(ctx, id) {
   }
 }
 
-function liveAgentIds(ctx) {
+/**
+ * Snapshot the live agent registry as `session id -> running?`.
+ *
+ * `agents.list()` returns every Agent resident in this process, including idle
+ * ones that merely have an open session. Archiving a session does not dispose
+ * its Agent, so residency must never be reported as "running": a resident but
+ * idle agent is `status === 'idle'` and can be purged once its turn is over.
+ *
+ * @param {any} ctx
+ * @returns {Map<string, boolean>} session id -> true when a turn is running
+ */
+function agentRunningStates(ctx) {
+  const states = new Map();
   const agents = ctx.get?.('agents');
-  if (agents === undefined || typeof agents.list !== 'function') return new Set();
+  if (agents === undefined || typeof agents.list !== 'function') return states;
+  let list;
   try {
-    return new Set(agents.list().map((agent) => agent.id));
+    list = agents.list();
   } catch {
-    return new Set();
+    return states;
   }
+  for (const agent of Array.isArray(list) ? list : []) {
+    const id = agent?.id ?? agent?.session?.id;
+    if (typeof id !== 'string') continue;
+    // An agent without a readable status is treated as running: refusing is
+    // recoverable, deleting a live session is not.
+    let running = true;
+    try {
+      const status = agent?.status;
+      if (typeof status === 'string') running = status === 'running';
+    } catch {
+      running = true;
+    }
+    states.set(id, running);
+  }
+  return states;
 }
 
 /**
@@ -366,7 +394,7 @@ export async function listSessions(ctx, options, request = {}) {
   const snapshots = await listSnapshots(persistence, request.signal);
   const byId = new Map(snapshots.map((snapshot) => [snapshot.header.id, snapshot]));
   const dirIndex = await indexSessionDirs(options.sessionsRoot);
-  const live = liveAgentIds(ctx);
+  const agents = agentRunningStates(ctx);
   const archived = archivedSessionIds(ctx);
   const currentSessionId = request.currentSessionId;
   const limit = Number.isInteger(request.limit)
@@ -401,7 +429,8 @@ export async function listSessions(ctx, options, request = {}) {
       logDirs: dirs,
       stored: snapshot !== undefined,
       orphan: snapshot === undefined,
-      live: live.has(id),
+      live: agents.get(id) === true,
+      resident: agents.has(id),
       archived: archived.has(id),
       current: id === currentSessionId,
       latestMtime: latestMtime || undefined,
@@ -440,7 +469,8 @@ export async function planPurge(ctx, options, ids, request = {}) {
   const snapshots = await listSnapshots(persistence, request.signal);
   const byId = new Map(snapshots.map((snapshot) => [snapshot.header.id, snapshot]));
   const dirIndex = await indexSessionDirs(options.sessionsRoot);
-  const live = liveAgentIds(ctx);
+  const agents = agentRunningStates(ctx);
+  const archived = archivedSessionIds(ctx);
   const now = Date.now();
   const targets = [];
   const blockers = [];
@@ -489,7 +519,12 @@ export async function planPurge(ctx, options, ids, request = {}) {
     if (request.currentSessionId !== undefined && id === request.currentSessionId) {
       reasons.push('this is the current session; switch to another session to delete it');
     }
-    if (live.has(id)) reasons.push('a live agent still owns this session in this process');
+    if (agents.get(id) === true) reasons.push('a running turn still owns this session in this process');
+    else if (agents.has(id)) {
+      warnings.push(
+        `${id}: the session is still resident in this DSH process but no turn is running; deletion is allowed`,
+      );
+    }
     if (dirs.length === 0 && cacheFiles.length === 0 && snapshot === undefined) {
       reasons.push('no session data found on disk or in persistence for this id');
     }
@@ -508,7 +543,9 @@ export async function planPurge(ctx, options, ids, request = {}) {
       createdAt: snapshot?.header?.createdAt,
       cwd: snapshot?.header?.cwd,
       stored: snapshot !== undefined,
-      live: live.has(id),
+      live: agents.get(id) === true,
+      resident: agents.has(id),
+      archived: archived.has(id),
       current: request.currentSessionId !== undefined && id === request.currentSessionId,
       blockers: reasons,
     };
@@ -565,13 +602,14 @@ export async function purgeSessions(ctx, options, ids, request = {}) {
     });
   }
 
-  // The reference scan can take minutes; a target may have become live since
-  // the first plan. Re-refuse before deleting anything.
-  const liveNow = liveAgentIds(ctx);
-  const becameLive = plan.targets.filter((target) => liveNow.has(target.id));
+  // The reference scan can take minutes; a target may have started a turn
+  // since the first plan. Re-refuse before deleting anything. A resident but
+  // idle agent is fine: only a running turn keeps its log writer alive.
+  const runningNow = agentRunningStates(ctx);
+  const becameLive = plan.targets.filter((target) => runningNow.get(target.id) === true);
   if (becameLive.length > 0) {
     throw new PurgeError(
-      `purge refused: session(s) became live during planning: ${becameLive.map((target) => target.id).join(', ')}`,
+      `purge refused: session(s) started running during planning: ${becameLive.map((target) => target.id).join(', ')}`,
       'BLOCKED',
     );
   }
@@ -696,9 +734,75 @@ export async function purgeSessions(ctx, options, ids, request = {}) {
     report.verified = false;
     warnings.push(`request-image cache still present after purge: ${options.requestImageCacheRoot}`);
   }
+
+  // A fully removed session must also leave the registry's archive and pin
+  // sets. Otherwise the sidebar keeps an "archived" row whose data is gone:
+  // it can never be opened again and every later delete attempt refuses with
+  // "no session data found", which looks like an archived session that cannot
+  // be deleted.
+  report.metadata = { pruned: [], skipped: true };
+  const removable = plan.targets.filter((target, index) => report.targets[index].errors.length === 0);
+  if (removable.length > 0) {
+    report.metadata = await pruneSessionMetadata(ctx, removable.map((target) => target.id), warnings);
+  }
   return { ...report, plan };
 }
 
+/**
+ * Drop purged ids from the workspace registry's global archive and pin sets.
+ * Best effort: the filesystem removal already succeeded, so an unavailable
+ * registry must not turn a real purge into a reported failure.
+ *
+ * @param {any} ctx
+ * @param {string[]} ids
+ * @param {string[]} warnings
+ * @returns {Promise<{ pruned: string[], skipped: boolean }>}
+ */
+async function pruneSessionMetadata(ctx, ids, warnings) {
+  let registry;
+  try {
+    registry = ctx.get?.('workspaceRegistry');
+  } catch {
+    registry = undefined;
+  }
+  if (registry === undefined || registry === null) return { pruned: [], skipped: true };
+  const archived = archivedSessionIds(ctx);
+  const pinned = pinnedSessionIds(ctx);
+  const pruned = [];
+  for (const id of ids) {
+    let changed = false;
+    if (archived.has(id) && typeof registry.unarchiveSession === 'function') {
+      try {
+        await registry.unarchiveSession(id);
+        changed = true;
+      } catch (error) {
+        warnings.push(`${id}: could not remove the archived entry (${error?.message ?? String(error)})`);
+      }
+    }
+    if (pinned.has(id) && typeof registry.unpinSession === 'function') {
+      try {
+        await registry.unpinSession(id);
+        changed = true;
+      } catch (error) {
+        warnings.push(`${id}: could not remove the pinned entry (${error?.message ?? String(error)})`);
+      }
+    }
+    if (changed) pruned.push(id);
+  }
+  return { pruned, skipped: false };
+}
+
+/** Read the registry-global pin set without requiring the service. */
+function pinnedSessionIds(ctx) {
+  try {
+    const registry = ctx.get?.('workspaceRegistry');
+    const ids = registry?.pinnedSessionIds;
+    return new Set(Array.isArray(ids) ? ids : []);
+  } catch {
+    return new Set();
+  }
+}
+
 /**
  * Decision support for the approval gate: a short human sentence with count,
  * byte total, and a bounded title list.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@murchey/dsh-session-manager",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "基于 DeepSeek Harness 的会话存储管理插件：查看会话磁盘占用、永久删除会话，并清理侧边栏失效条目。",
   "type": "module",
   "exports": {