dsh-session-manager 0.7.3 → 0.7.4

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.7.4 — 2026-10-20
+
+- **fix(workspace)**: Repair workspace session membership on DSH 0.2.x. New and forked sessions are now attributed to the workspace owning their `cwd` as soon as the session is announced (runtime repair, no restart needed), and historical sessions whose `cwd` matches a registered workspace are re-registered on startup — all through the official DSH workspace entity API (#41).
+- **fix(move)**: "Move to workspace" on a session whose `cwd` already equals the target workspace path now repairs the missing membership instead of returning a silent no-op. The response reports whether a membership was written (`attached`); the artifact's content, size and mtime are untouched and running sessions are never restarted (#41).
+- **fix(compat)**: Resolve the DSH home through the official `$DSH_HOME` → `~/.dsh` order (tilde-expanded, absolute) when the `dshHomePath` service is not visible to the plugin scope, so session scans and stores work with a custom DSH home (#41).
+- **fix(workspace)**: Read durable workspace membership from the registry record instead of the runtime-filtered projection when deleting sessions, so stale runtime indexes can no longer leave dead entries behind.
+- **test**: Add regression coverage for runtime new/forked session attribution, boot repair, same-path move repair (including artifact byte/size/mtime invariants), idempotence, cross-workspace moves, cwd mismatch safety, incomplete-scan safety, restart stability, archived-session preservation, and custom DSH home resolution (#41).
+- **compat**: Compatible with DSH Desktop v0.2.1-rc.2 (and v0.2.0-rc.2); workspace membership repair uses the official workspace registry entity API.
+- **fix(safety)**: Workspace membership repair never migrates a session that is already accounted by another workspace: such a conflict is refused with `409 workspace-membership-conflict` and both records stay untouched, because an account removed from a different workspace cannot be restored through the official API. Completing a missing membership still goes through the official `attachSession()` after its validation conditions (header readability, cwd resolution, canonical path equality) are pre-checked, so a predictable rejection fails before any write (#41).
+- **fix(api)**: "Move to workspace" no longer reports success when a repair cannot be completed: hosts without the official `attachSession` API answer `501 workspace-attach-unavailable`, an unconfirmable membership state is refused, a membership conflict answers `409 workspace-membership-conflict`, and unsafe or failed repairs answer `500` with `workspace-repair-unsafe` / `workspace-repair-failed`. Successful repairs report `membership` (`already-member` / `attached`) next to the existing `moved` / `attached` fields (#41).
+
 ## 0.7.3 — 2026-10-18
 
 - **fix(update)**: Fix built-in one-click update and resolve `cannot get property "remote" without inject` by routing update requests through the plugin's own Host API instead of client-side `remote.pluginManager`.

package/README.md

@@ -20,7 +20,7 @@ Verified with the official DSH Desktop client; see [5 Compatibility](#5-compatib
 
 - **Delete** is irreversible and always asks for confirmation. Subagent sessions and transient blank placeholders (no persisted artifact) cannot be deleted.
 - **Archive / Unarchive** moves a session in and out of the active list without touching its disk content.
-- **Move to workspace** keeps history, title, archive state and derived-session relationships intact, rewrites the session's `cwd` to the target workspace, and updates the live writer's header in place so any pending tool calls keep landing on the new path.
+- **Move to workspace** keeps history, title, archive state and derived-session relationships intact, rewrites the session's `cwd` to the target workspace, and updates the live writer's header in place so any pending tool calls keep landing on the new path. When the session's `cwd` already equals the target workspace path but its membership was never recorded, only the missing membership is repaired: no `cwd` rewrite, no artifact rewrite or move, and no session restart.
 - **Migrate Agent preset** rewrites the latest `agent-preset/selected` event (or the session header if no such event exists) so a session whose preset was renamed or removed can resume. Message history is never altered.
 
 ### 1.2 Session shortcuts
@@ -136,7 +136,7 @@ After changing plugin dependencies, `package.json`, bundle configuration, or oth
 - Cold rewrites preserve the artifact's stored format (V1 / V2 / V3 / V4 are all readable; the plugin never forces an upgrade). Moves and rewrites refuse corrupt / truncated Zstd logs or JSONL logs with incomplete final lines instead of publishing partial history.
 - Preset migration separates backup, publication and rollback. If rollback fails, recovery files are retained and their paths are included in the error; do not remove them.
 - **Workspace archiving rollback protection**: archiving is refused if active sessions are present, and batch session archiving automatically rolls back on partial failures to preserve state consistency.
-- Incomplete startup scans skip workspace reconciliation. Complete scans preserve live sessions and any membership added during the scan.
+- On startup, sessions whose `cwd` names a registered workspace but whose membership record is missing are re-registered through the official DSH API (idempotent). Incomplete scans skip pruning only: existing membership is never dropped, and live sessions or memberships added during the scan are always preserved.
 - Plugin mutations are serialized per session and request bodies are limited to 64 KiB. This queue supplements, rather than replaces, DSH's own persistence coordination.
 
 ## 5 Compatibility
@@ -147,7 +147,7 @@ The table below lists verified version combinations between DeepSeek Harness (DS
 
 | DeepSeek Harness (DSH) | dsh-session-manager | Verified Environment |
 | :--- | :--- | :--- |
-| **v0.2.1-rc.2** | `0.7.3`, `0.7.2` | Desktop |
+| **v0.2.1-rc.2** | `0.7.4`, `0.7.3`, `0.7.2` | Desktop |
 | **v0.2.0-rc.2** | `0.7.1`, `0.7.0`, `0.6.4`, `0.6.3`, `0.6.2`, `0.5.4` | Desktop |
 | **v0.1.7-rc.2** | `0.5.3` | Desktop / Web UI |
 | **v0.1.7-rc.1** | `0.5.2` | Desktop / Web UI |

package/README.zh.md

@@ -20,7 +20,7 @@ DSH 会话与工作区管理——工作区：归档与显示。会话：跨工
 
 - **删除**：不可逆操作，UI 始终要求二次确认。subagent 会话和尚未落盘的空白会话占位不能删除。
 - **归档 / 移出归档**：把会话移出或移回主列表，不删除磁盘内容。
-- **移动至工作区**：跨工作区移动时保留历史、标题、归档状态和派生会话关系，同时把 `cwd` 重写为目标工作区，并就地更新 live writer 的 header，使挂起的工具调用继续落到新路径。
+- **移动至工作区**：跨工作区移动时保留历史、标题、归档状态和派生会话关系，同时把 `cwd` 重写为目标工作区，并就地更新 live writer 的 header，使挂起的工具调用继续落到新路径。若会话的 `cwd` 本来就等于目标工作区、只是归属未登记，则只补全归属记录，不改写 `cwd`、不重写或移动工件、不重启会话。
 - **迁移 Agent 预设**：原预设被改名或删除导致会话无法恢复时，可修复该会话。迁移会就地重写最后一条 `agent-preset/selected` 事件（若从未记录则修改会话 header），不改动历史消息。
 
 ### 1.2 会话快捷管理
@@ -134,7 +134,7 @@ dsh plugin --profile web add <本仓库路径>
 - 冷会话重写保留原工件格式（V1 / V2 / V3 / V4 都可读，绝不强制升级）。损坏或截断的 Zstd 日志、缺少完整尾行的 JSONL 会拒绝移动 / 重写，不会把部分历史当作完整日志保存。
 - 迁移预设按"备份 → 发布 → 回滚"分阶段处理。如果回滚失败，会保留恢复文件并在错误中报告路径；不要删除这些文件。
 - **工作区归档事务保护**：若工作区内存在运行中会话则拒绝归档；批量归档会话若中途遇到异常会自动回滚已变更状态，避免部分成功导致状态不一致。
-- 启动扫描不完整时跳过工作区归属修复；完整扫描也不会清除仍在内存中或扫描期间新加入的会话。
+- 启动时若发现 `cwd` 对应已注册工作区但归属记录遗漏的会话，会通过 DSH 官方接口补全登记（幂等）；扫描不完整时只跳过清理，不会误删现有归属，也不会清除仍在内存中或扫描期间新加入的会话。
 - 同一会话的插件写操作按顺序执行；请求体限制为 64 KiB。该队列不替代 DSH 自身的持久化写入协调。
 
 ## 5 兼容性
@@ -145,7 +145,7 @@ dsh plugin --profile web add <本仓库路径>
 
 | DeepSeek Harness (DSH) | dsh-session-manager | 验证环境 |
 | :--- | :--- | :--- |
-| **v0.2.1-rc.2** | `0.7.3`, `0.7.2` | Desktop |
+| **v0.2.1-rc.2** | `0.7.4`, `0.7.3`, `0.7.2` | Desktop |
 | **v0.2.0-rc.2** | `0.7.1`, `0.7.0`, `0.6.4`, `0.6.3`, `0.6.2`, `0.5.4` | Desktop |
 | **v0.1.7-rc.2** | `0.5.3` | Desktop / Web UI |
 | **v0.1.7-rc.1** | `0.5.2` | Desktop / Web UI |

package/lib/client.js

@@ -3773,7 +3773,7 @@ function isTopmostDialog(z) {
       ));
     }
 
-    const CURRENT_VERSION = "0.7.3";
+    const CURRENT_VERSION = "0.7.4";
 
     function compareSemver(v1, v2) {
       if (typeof v1 !== "string" || typeof v2 !== "string") return 0;

package/lib/compat/dsh-adapter.js

@@ -9,10 +9,36 @@
  */
 import { createRequire } from "node:module";
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 
 const require = createRequire(import.meta.url);
 
+/** Expand a leading `~` / `~/` / `~\` against the OS home, matching
+ * `@deepseek-ai/dsh-home-paths` `expandHomePath`. */
+function expandHomePath(path) {
+  if (path === "~") return homedir();
+  if (path.startsWith("~/") || path.startsWith("~\\")) return join(homedir(), path.slice(2));
+  return path;
+}
+
+/**
+ * Resolve the DSH home without the `dshHomePath` service. DSH 0.2.x resolves
+ * the harness home exclusively through `resolveDshHome()`: `$DSH_HOME` when
+ * set and non-blank, otherwise `~/.dsh`; the value is tilde-expanded and
+ * resolved to an absolute path. Mirror that order so a plugin scope that
+ * cannot see the root-context service still lands on the same directory.
+ */
+function fallbackDshHome() {
+  const raw = typeof process.env.DSH_HOME === "string" ? process.env.DSH_HOME.trim() : "";
+  const selected = raw.length > 0 ? expandHomePath(raw) : join(homedir(), ".dsh");
+  return resolve(selected);
+}
+
+/** Same calling convention as the official `dshHomePath(...segments)`. */
+function fallbackHomePath(...segments) {
+  return join(fallbackDshHome(), ...segments);
+}
 /** Pull one service out of the Cordis ctx, tolerating direct property fallbacks. */
 export function getService(ctx, name) {
   try {
@@ -157,7 +183,15 @@ export function createDshAdapter(ctx) {
     get persistence() { return getService(ctx, "sessionPersistence"); },
     get agentPresets() { return getService(ctx, "agentPresets"); },
     get projectionCache() { return getService(ctx, "sessionProjectionCache"); },
-    get homePath() { return getService(ctx, "dshHomePath"); },
+    get homePath() {
+      // DSH 0.2.x provides `dshHomePath` on the root context (app-boot), but a
+      // plugin scope may not resolve it; without a fallback every disk-backed
+      // path (sessions scan, annotation store, workspace archive store) is
+      // lost. Fall back to the official home resolution instead.
+      const served = getService(ctx, "dshHomePath");
+      if (typeof served === "function") return served;
+      return fallbackHomePath;
+    },
     get pluginManager() { return getService(ctx, "pluginManager"); },
 
     getSession(id) {

package/lib/index.js

@@ -101,6 +101,12 @@ function rebindLiveWriter(persistence, sessionId, newHeader) {
  * disk fallback semantics are preserved -- the orphan is the whole
  * reason this loop exists.
  *
+ * The result carries two completeness flags: "persisted" reports whether the
+ * persistence index itself listed successfully (its rows are authoritative),
+ * while "complete" additionally requires the disk sweep to finish without
+ * errors. Callers that only add validated memberships may run on "persisted";
+ * callers that remove records must wait for "complete".
+ *
  * @param {object|undefined} persistence  DSH's sessionPersistence service
  * @param {((segment: string) => string)|undefined} dshHome  Resolver for
  *   DSH home sub-paths; only "sessions" is read.
@@ -110,6 +116,7 @@ const scanSessionHeaders = async (persistence, dshHome) => {
   const headers = [];
   const errors = [];
   let listed = false;
+  let persisted = false;
   if (typeof persistence?.list === "function") {
     try {
       const rows = await persistence.list();
@@ -122,9 +129,10 @@ const scanSessionHeaders = async (persistence, dshHome) => {
         if (!seen.has(header.id)) { seen.add(header.id); headers.push(header); }
       }
       listed = true;
+      persisted = true;
     } catch (error) { errors.push(error); }
   }
-  const result = () => ({ headers, complete: listed && errors.length === 0, errors });
+  const result = () => ({ headers, persisted, complete: listed && errors.length === 0, errors });
   // Skip known files before fopen; retain the orphan/raw-id compatibility path.
   // Only add canonical session directories that do not start and end with "--"
   // to avoid colliding with legacy projectKey candidates (e.g. "--s1--").
@@ -175,6 +183,16 @@ const scanSessionHeaders = async (persistence, dshHome) => {
 
 const listSessionHeaders = async (persistence, dshHome) => (await scanSessionHeaders(persistence, dshHome)).headers;
 
+/** Canonicalize a directory path the way DSH's workspace registry does
+ * (fs.realpath on a fully qualified path). Returns undefined when the path
+ * cannot be resolved so callers skip instead of guessing; DSH stores
+ * workspace paths canonicalized, so canonical equality is the only safe
+ * membership comparison on Windows (case, separators, 8.3 names, junctions). */
+const canonicalizeDirectory = async (path) => {
+  if (typeof path !== "string" || path === "") return undefined;
+  try { return await realpath(path); } catch { return undefined; }
+};
+
 const UPDATE_STATUS_FILE = ".dsh-session-manager-update.json";
 const STALE_EXTERNAL_TASK_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes fallback for dead external processes
 const HEARTBEAT_STALE_TIMEOUT_MS = 3 * 60 * 1000; // 3 minutes without heartbeat for external processes
@@ -367,7 +385,7 @@ function verifyInstalledPackage(profileDir, expectedVersion) {
 
 export function apply(ctx) {
   try {
-    const buildId = "dsh-session-manager v0.7.3 (workspace-archive)";
+    const buildId = "dsh-session-manager v0.7.4 (workspace-archive)";
     if (typeof ctx?.logger?.info === "function") ctx.logger.info(buildId);
     else if (typeof console !== "undefined" && console?.info) console.info(buildId);
   } catch (_) { /* ignore logging failures */ }
@@ -399,10 +417,26 @@ export function apply(ctx) {
   const safeGetAgent = (sessionId) => {
     try { return ctx.agents?.get?.(sessionId); } catch { return undefined; }
   };
+  /** Durable workspace membership for one entity. The record account is the
+   * authoritative persisted list on DSH 0.2.x (registry entities expose it as
+   * the private `record` field); the runtime `sessionIds` getter is filtered
+   * by the canonical-cwd index and may hide members whose index entry is
+   * stale, so it is only a fallback for hosts without a readable record. */
+  const workspaceMemberIds = (entity) => {
+    if (entity === null || entity === undefined) return [];
+    const record = entity.record;
+    if (record !== null && record !== undefined && Array.isArray(record.sessionIds)) return record.sessionIds;
+    const ids = entity.sessionIds;
+    if (Array.isArray(ids)) return ids;
+    if (typeof ids === "function") {
+      try { const value = ids(); if (Array.isArray(value)) return value; } catch { /* ignore */ }
+    }
+    return [];
+  };
   const assertAnnotatable = id => {
     const registry = adapter.workspaceRegistry;
     if (adapter.getSession(id) !== undefined || registry?.headers?.has?.(id)
-      || adapter.workspaceList().some(ws => (ws.record?.sessionIds ?? ws.sessionIds ?? []).includes(id))) return;
+      || adapter.workspaceList().some(ws => workspaceMemberIds(ws).includes(id))) return;
     throw Object.assign(new Error("会话不存在或尚未加载，请先打开该会话后重试"), { code: "session-not-found" });
   };
   const operations = new Map();
@@ -567,7 +601,9 @@ export function apply(ctx) {
   const detachFromWorkspaces = async (sessionId) => {
     const registry = ctx.get("workspaceRegistry") ?? ctx.workspaceRegistry ?? adapter.workspaceRegistry;
     for (const entity of registry.list()) {
-      if (entity.sessionIds.includes(sessionId)) {
+      // Durable record, not the runtime-filtered getter: deleting a session
+      // must purge its account even when the cwd index is stale.
+      if (workspaceMemberIds(entity).includes(sessionId)) {
         await entity.detachSession(sessionId);
       }
     }
@@ -576,9 +612,7 @@ export function apply(ctx) {
   /** Ordered workspace projection for the client. */
   const listWorkspaces = () => {
     return ctx.workspaceRegistry.list().map((entity) => {
-      const rawIds = Array.isArray(entity.record?.sessionIds)
-        ? [...entity.record.sessionIds]
-        : [...entity.sessionIds];
+      const rawIds = [...workspaceMemberIds(entity)];
       const selfUpdatedAt = entity.updatedAt ?? entity.record?.updatedAt ?? null;
       return {
         id: entity.id,
@@ -834,6 +868,182 @@ ${rest}`, "utf8");
       return false;
     };
 
+    /**
+     * Attach one session to the registered workspace that owns its cwd.
+     * Returns true only when a new durable membership was written.
+     *
+     * DSH's own create/fork flow attaches through workspaceRegistry, but a
+     * session created outside that flow (cwd-only create, an attach the host
+     * declined, or a session that predates this plugin load) stays
+     * unaccounted even though its cwd names a registered workspace. The
+     * official entity API re-validates the stored header cwd against the
+     * canonical workspace path and persists through the domain table, so a
+     * wrong match can never be written. Subagent sessions never join a
+     * workspace account, and a session any workspace already accounts for is
+     * left untouched (no session is ever registered twice).
+     */
+    const attachSessionToOwningWorkspace = async (header) => {
+      const registry = adapter.workspaceRegistry;
+      if (registry === void 0 || typeof registry.list !== "function") return false;
+      if (header === void 0 || typeof header.id !== "string") return false;
+      if (header.origin === "subagent") return false;
+      if (typeof header.cwd !== "string" || header.cwd === "") return false;
+      const run = async () => {
+        const entities = registry.list();
+        for (const entity of entities) {
+          if (workspaceMemberIds(entity).includes(header.id)) return false;
+        }
+        const byPath = new Map();
+        for (const entity of entities) {
+          if (typeof entity.path === "string" && !byPath.has(entity.path)) byPath.set(entity.path, entity);
+        }
+        let target = byPath.get(header.cwd);
+        if (target === void 0 && typeof registry.resolveByPath === "function") {
+          try { target = await registry.resolveByPath(header.cwd); } catch { target = void 0; }
+        }
+        if (target === void 0) {
+          const canonical = await canonicalizeDirectory(header.cwd);
+          if (canonical !== void 0) target = byPath.get(canonical);
+        }
+        if (target === void 0 || typeof target.attachSession !== "function") return false;
+        await target.attachSession(header.id);
+        return true;
+      };
+      if (typeof registry.enqueueOperation === "function") return await registry.enqueueOperation(run);
+      return await run();
+    };
+
+    /**
+     * Resolve the header the official attachSession() will validate against.
+     * WorkspaceEntity.readSessionHeader prefers the live session, then the
+     * registry's own header index, and only then a fresh persistence listing.
+     * Mirroring that order lets the repair predict a rejection instead of
+     * attempting an attach that cannot succeed.
+     */
+    const effectiveSessionHeader = (sessionId, storedHeader) => {
+      try {
+        const live = ctx.sessions?.get?.(sessionId);
+        if (live !== undefined && live !== null && live.header !== undefined) return live.header;
+      } catch { /* fall through to the index */ }
+      try {
+        const indexed = adapter.workspaceRegistry?.headers?.get?.(sessionId);
+        if (indexed !== undefined) return indexed;
+      } catch { /* fall through to the stored header */ }
+      return storedHeader;
+    };
+
+    /**
+     * Complete the durable workspace membership of a session whose artifact
+     * already lives under the target workspace path (same-path move). DSH 0.2.x
+     * keeps "cwd matches the workspace path" and "the workspace accounts for
+     * the session" as separate facts, so a matching cwd alone must not be
+     * reported as success.
+     *
+     * Conservative policy. The official domain offers no cross-record
+     * transaction (single-record updates on one serialized storage unit), and
+     * attachSession() validates the session cwd against the workspace path --
+     * so an account held by a DIFFERENT workspace can never be restored
+     * through the official API once it is removed. Automatic migration would
+     * therefore risk destroying the only remaining account if the target
+     * attach then failed. Hence:
+     *   - no workspace accounts for the session: complete the target
+     *     membership through attachSession(), after pre-checking every
+     *     condition it validates so a predictable rejection fails before any
+     *     write;
+     *   - already accounted by the target and by nobody else: idempotent
+     *     no-op, no write;
+     *   - accounted by another workspace: refuse with a membership-conflict
+     *     error; no automatic cross-record migration;
+     *   - membership state cannot be confirmed: refuse.
+     *
+     * No artifact is rewritten, no cwd is touched, and no live session is
+     * restarted. A true cross-workspace move re-homes the artifact first and
+     * is a separate, unchanged path.
+     *
+     * @returns {status: "already-member"|"attached", attached: boolean}
+     * @throws with code workspace-membership-unknown | workspace-membership-conflict |
+     *   workspace-attach-unavailable | workspace-repair-unsafe | workspace-repair-failed.
+     */
+    const repairWorkspaceMembership = async (target, sessionId, storedHeader) => {
+      const registry = ctx.get("workspaceRegistry") ?? ctx.workspaceRegistry ?? adapter.workspaceRegistry;
+      const run = async () => {
+        // Confirm the current accounting from a fresh, readable listing. An
+        // unreadable registry must never be guessed at.
+        let entities;
+        let inTarget;
+        let stale;
+        try {
+          if (typeof registry?.list !== "function") throw new Error("workspace registry 不可用");
+          const listed = registry.list();
+          if (!Array.isArray(listed)) throw new Error("workspace registry 返回了无效数据");
+          entities = listed;
+          inTarget = workspaceMemberIds(target).includes(sessionId);
+          stale = entities.filter((entity) =>
+            entity !== target && entity.id !== target.id && workspaceMemberIds(entity).includes(sessionId));
+        } catch (cause) {
+          const error = new Error("无法确认会话当前的工作区归属状态（" + safeErrorMessage(cause) + "），已拒绝修复操作");
+          error.code = "workspace-membership-unknown";
+          throw error;
+        }
+
+        if (stale.length > 0) {
+          // Membership conflict: the session is accounted by a workspace whose
+          // path differs from its cwd. That account cannot be restored through
+          // the official API once removed, so an automatic migration could
+          // destroy the only remaining account if the target attach failed.
+          // Refuse and let the operator resolve the conflict.
+          const names = stale.map((entity) => entity.title || entity.id).join("、");
+          const error = new Error(
+            "会话当前登记在其他工作区（" + names + "），与其 cwd 指向的目标工作区不一致。"
+            + "为避免修复失败造成数据损失，已拒绝自动迁移；请先处理该归属冲突，或使用真正的跨工作区移动"
+          );
+          error.code = "workspace-membership-conflict";
+          throw error;
+        }
+        if (inTarget) return { status: "already-member", attached: false };
+        if (typeof target.attachSession !== "function") {
+          const error = new Error("当前 DSH 宿主未提供官方工作区归属接口（attachSession），无法补全会话归属");
+          error.code = "workspace-attach-unavailable";
+          throw error;
+        }
+
+        // Pre-check every condition attachSession() validates so a predictable
+        // rejection fails before any write. The header it reads is the live
+        // session first, then the registry index, then a fresh persistence
+        // listing -- not necessarily the header this request was validated
+        // against.
+        const effective = effectiveSessionHeader(sessionId, storedHeader);
+        if (effective === void 0 || typeof effective.cwd !== "string" || effective.cwd === "") {
+          const error = new Error("拒绝补全归属：会话没有可校验的 cwd，官方接口无法登记");
+          error.code = "workspace-repair-unsafe";
+          throw error;
+        }
+        const canonical = await canonicalizeDirectory(effective.cwd);
+        if (canonical === void 0 || canonical !== target.path) {
+          const error = new Error(
+            "拒绝补全归属：会话当前 cwd（" + effective.cwd + "）解析后与目标工作区（" + target.path
+            + "）不一致，官方接口会拒绝登记；未做任何修改"
+          );
+          error.code = "workspace-repair-unsafe";
+          throw error;
+        }
+        try {
+          await target.attachSession(sessionId);
+        } catch (cause) {
+          // Nothing has been written yet, so the previous state (no account) is
+          // intact; surface the failure with its cause.
+          const error = new Error("补全归属失败：" + safeErrorMessage(cause));
+          error.code = "workspace-repair-failed";
+          throw error;
+        }
+        return { status: "attached", attached: true };
+      };
+      if (registry !== void 0 && typeof registry.enqueueOperation === "function") {
+        return await registry.enqueueOperation(run);
+      }
+      return await run();
+    };
+
     /**
      * TRUE cross-workspace move. See the module docstring for the full design:
      * re-home the stored cwd, migrate the artifact, then swap accounting.
@@ -896,7 +1106,25 @@ ${rest}`, "utf8");
         let currentCanonical;
         try { currentCanonical = await realpath(storedHeader.cwd); } catch { /* re-home below */ }
         if (currentCanonical === targetPath) {
-          return { ok: true, sessionId, moved: false, message: "会话已属于目标工作区" };
+          // The artifact already lives under the target workspace path, but on
+          // DSH 0.2.x "cwd matches" and "the workspace accounts for the
+          // session" are separate facts: a matching cwd with a missing
+          // registration used to return a silent no-op success. Repair the
+          // durable membership through the official entity API (idempotent,
+          // no artifact rewrite, no live-session restart) and report what
+          // actually happened. A repair that cannot be completed fails loudly
+          // instead of reporting success.
+          const repair = await repairWorkspaceMembership(target, sessionId, storedHeader);
+          return {
+            ok: true,
+            sessionId,
+            moved: false,
+            attached: repair.attached,
+            membership: repair.status,
+            message: repair.attached
+              ? "会话已归属目标工作区（已补全归属记录）"
+              : "会话已属于目标工作区"
+          };
         }
       }
 
@@ -1003,7 +1231,7 @@ ${rest}`, "utf8");
         const oldIndexedPath = registry.sessionPaths?.get?.(sessionId);
         const oldInvalidPath = registry.invalidSessionPaths?.get?.(sessionId);
         const fromWorkspaceIds = registry.list()
-          .filter((entity) => entity.id !== target.id && (entity.record?.sessionIds ?? entity.sessionIds).includes(sessionId))
+          .filter((entity) => entity.id !== target.id && workspaceMemberIds(entity).includes(sessionId))
           .map((entity) => entity.id);
         let targetAttached = false;
         const detachedFrom = [];
@@ -1168,8 +1396,7 @@ ${rest}`, "utf8");
             throw error;
           }
           allowedIds = new Set();
-          const ids = typeof ws.sessionIds === "function" ? ws.sessionIds() : ws.sessionIds;
-          if (Array.isArray(ids)) for (const id of ids) allowedIds.add(id);
+          for (const id of workspaceMemberIds(ws)) allowedIds.add(id);
         }
       }
       const requestedSessionId = filter !== void 0 && typeof filter === "object" && typeof filter.sessionId === "string"
@@ -1818,43 +2045,103 @@ ${rest}`, "utf8");
     if (typeof persistence?.list !== "function" || typeof registry?.list !== "function") return;
 
     try {
-      // Remember only ids that existed before the async scan. Concurrently
-      // attached ids must never be removed using this older disk snapshot.
-      const initialIds = new Map(registry.list().map(ws => [ws.id, new Set(ws.record?.sessionIds ?? [])]));
-      const scan = await scanSessionHeaders(persistence, adapter.homePath);
-      if (!scan.complete) {
-        ctx.logger.warn("session-manager: incomplete session scan; workspace reconciliation skipped: " + scan.errors.map(safeErrorMessage).join("; "));
+      // Snapshot durable membership BEFORE the async scan. Only ids that
+      // already existed here may ever be pruned later; ids attached
+      // concurrently must never be removed using an older disk snapshot.
+      let entities;
+      try { entities = registry.list(); }
+      catch (error) {
+        ctx.logger.warn("session-manager: workspace registry unavailable; workspace reconciliation skipped: " + safeErrorMessage(error));
         return;
       }
-      const headers = scan.headers;
-      const validIds = new Set(headers.map(header => header.id));
+      const initialIds = new Map(entities.map(ws => [ws.id, new Set(workspaceMemberIds(ws))]));
+      const scan = await scanSessionHeaders(persistence, adapter.homePath);
+      const headers = Array.isArray(scan.headers) ? scan.headers : [];
+
+      // Step 1a: attach sessions whose cwd names a registered workspace but
+      // that no workspace accounts for (issue #41). Every candidate is
+      // re-validated by the official entity API, which persists through the
+      // domain table and is idempotent for already-accounted ids -- so this
+      // pass can only add well-formed memberships, never corrupt records.
+      // It runs whenever the persistence index listed successfully
+      // (scan.persisted); a partial disk sweep cannot make a listed header
+      // invalid.
+      let added = 0;
+      if (scan.persisted) {
+        const assigned = new Set();
+        for (const ws of entities) for (const id of initialIds.get(ws.id)) assigned.add(id);
+        const candidates = headers.filter(header =>
+          typeof header.cwd === "string" && header.cwd !== ""
+          && header.origin !== "subagent"
+          && !assigned.has(header.id));
+        if (candidates.length > 0) {
+          const byPath = new Map();
+          for (const ws of entities) {
+            if (typeof ws.path === "string" && !byPath.has(ws.path)) byPath.set(ws.path, ws);
+          }
+          const attach = async () => {
+            // Re-read membership inside the registry write queue: a concurrent
+            // move may have accounted an id after the snapshot above.
+            const current = typeof registry.list === "function" ? registry.list() : entities;
+            const assignedNow = new Set();
+            for (const ws of current) for (const id of workspaceMemberIds(ws)) assignedNow.add(id);
+            for (const header of candidates) {
+              if (assignedNow.has(header.id)) continue;
+              let target = byPath.get(header.cwd);
+              if (target === void 0) {
+                const canonical = await canonicalizeDirectory(header.cwd);
+                if (canonical !== void 0) target = byPath.get(canonical);
+              }
+              if (target === void 0 || typeof target.attachSession !== "function") continue;
+              try {
+                await target.attachSession(header.id);
+                assignedNow.add(header.id);
+                added += 1;
+              } catch (error) {
+                ctx.logger.warn("session-manager: boot attach of session '" + header.id + "' to workspace '" + target.id + "' failed: " + safeErrorMessage(error));
+              }
+            }
+          };
+          if (typeof registry.enqueueOperation === "function") await registry.enqueueOperation(attach);
+          else await attach();
+        }
+      }
 
-      // Step 1: Immediate Workspace Member Reconciliation (isolated from projection rebuild)
+      // Step 1b: prune record entries whose session no longer exists. Only a
+      // fully complete scan (persistence index plus disk sweep, no errors)
+      // may remove anything; live sessions and ids attached after the
+      // snapshot are always kept. Durable records are read through
+      // workspaceMemberIds so a stale runtime index cannot hide a dead entry.
       let removed = 0;
-      let added = 0;
-      await registry.enqueueOperation(async () => {
-        const state = registry.requireState();
-        const pathById = new Map(registry.list().map(ws => [ws.id, ws.path]));
-        const assignedIds = new Set((state.workspaces ?? []).flatMap(ws => ws.sessionIds ?? []));
-        const workspaces = (state.workspaces ?? []).map(ws => {
-          const original = ws.sessionIds ?? [];
-          const sessionIds = original.filter(id => validIds.has(id)
-            || !initialIds.get(ws.id)?.has(id) || adapter.getSession(id) !== undefined);
-          const removedHere = original.length - sessionIds.length;
-          removed += removedHere;
-          for (const header of headers) {
-            if (header.cwd === undefined || header.cwd !== pathById.get(ws.id) || assignedIds.has(header.id)) continue;
-            sessionIds.unshift(header.id);
-            assignedIds.add(header.id);
-            added += 1;
+      if (scan.complete) {
+        const validIds = new Set(headers.map(header => header.id));
+        const prune = async () => {
+          for (const ws of (typeof registry.list === "function" ? registry.list() : entities)) {
+            const initial = initialIds.get(ws.id);
+            // Snapshot: detachSession replaces the record array while we walk it.
+            for (const id of [...workspaceMemberIds(ws)]) {
+              if (validIds.has(id)) continue;
+              if (initial === void 0 || !initial.has(id)) continue;
+              if (adapter.getSession(id) !== undefined) continue;
+              if (typeof ws.detachSession !== "function") continue;
+              await ws.detachSession(id);
+              removed += 1;
+            }
           }
-          if (sessionIds.length === original.length && sessionIds.every((id, i) => id === original[i])) return ws;
-          return { ...ws, sessionIds, updatedAt: new Date().toISOString() };
-        });
-        if (removed || added) await registry.setState({ ...state, workspaces });
-      });
-      if (removed || added) {
-        ctx.logger.info('session-manager: post-boot workspace reconcile removed ' + removed + ' orphans, attached ' + added + ' disk-only sessions');
+        };
+        if (typeof registry.enqueueOperation === "function") await registry.enqueueOperation(prune);
+        else await prune();
+      }
+      if (added || removed) {
+        ctx.logger.info('session-manager: post-boot workspace reconcile attached ' + added + ' unaccounted sessions, removed ' + removed + ' orphans');
+      }
+      if (!scan.persisted) {
+        ctx.logger.warn("session-manager: incomplete session scan; workspace reconciliation skipped: " + scan.errors.map(safeErrorMessage).join("; "));
+        return;
+      }
+      if (!scan.complete) {
+        ctx.logger.warn("session-manager: incomplete disk sweep; workspace membership pruning skipped: " + scan.errors.map(safeErrorMessage).join("; "));
+        return;
       }
 
       // Step 2: Budgeted Background Projection Cache Rebuild
@@ -1918,6 +2205,32 @@ ${rest}`, "utf8");
     }
   }, "session-manager: post-boot re-fold stale projection cache rows");
 
+  /**
+   * Runtime membership repair (issue #41): DSH's own create/fork flow attaches
+   * a session to its workspace, but a session created outside that flow -- or
+   * one whose host-side attach failed -- stays unaccounted even though its
+   * cwd names a registered workspace, and would otherwise only be repaired on
+   * the next DSH restart. Repair it as soon as the session is announced.
+   *
+   * The listener must never throw synchronously: a throwing session/created
+   * listener rolls back session creation in DSH. Everything is contained and
+   * fire-and-forget; failures are logged only.
+   */
+  if (typeof ctx.on === "function") ctx.on("session/created", (session) => {
+    void (async () => {
+      try {
+        const header = session?.header ?? session;
+        if (header === void 0 || typeof header.id !== "string") return;
+        const attached = await attachSessionToOwningWorkspace(header);
+        if (attached) {
+          ctx.logger.info("session-manager: attached new session '" + header.id + "' to its cwd workspace");
+        }
+      } catch (error) {
+        ctx.logger.warn("session-manager: session/created membership repair failed: " + safeErrorMessage(error));
+      }
+    })();
+  });
+
   /** Build a normalized annotation patch from one bulk action + payload.
    * Returns null when the payload is missing or malformed so the caller can
    * surface a 400 instead of letting the store throw on a bad value.
@@ -2215,7 +2528,7 @@ ${rest}`, "utf8");
           return send(res, 200, { ok: true, result });
         }
         if (req.method === "GET" && path === "/update/check") {
-          const currentVersion = adapter.pluginVersion() || "0.7.3";
+          const currentVersion = adapter.pluginVersion() || "0.7.4";
           const runningVersion = currentVersion;
           let installedVersion = runningVersion;
           const profileDir = resolveProfileDir(adapter, ctx);
@@ -2399,7 +2712,7 @@ ${rest}`, "utf8");
           };
           setActiveTask(taskRecord);
 
-          const currentVersion = adapter.pluginVersion() || "0.7.3";
+          const currentVersion = adapter.pluginVersion() || "0.7.4";
           let installedVersion = currentVersion;
           if (profileDir) {
             const pkgFile = join(profileDir, "node_modules", "dsh-session-manager", "package.json");
@@ -2929,7 +3242,7 @@ ${rest}`, "utf8");
         }
         if (req.method === "GET" && path === "/update/status") {
           const profileDir = resolveProfileDir(adapter, ctx);
-          const currentVersion = adapter.pluginVersion() || "0.7.3";
+          const currentVersion = adapter.pluginVersion() || "0.7.4";
           let installedVersion = currentVersion;
           if (profileDir) {
             const diskCheck = verifyInstalledPackage(profileDir);
@@ -3004,7 +3317,9 @@ ${rest}`, "utf8");
         ctx.logger.warn("session-manager: api error: " + safeErrorMessage(error) + "; json=" + safeJson(error));
         const status = error?.code === "bad-request" ? 400 : error?.code === "body-too-large" ? 413
           : error?.code === "annotation-conflict" || error?.code === "annotations-busy" ? 409
-          : error?.code === "session-not-found" ? 404 : error?.code?.startsWith("annotations-") ? 503 : 500;
+          : error?.code === "session-not-found" ? 404 : error?.code?.startsWith("annotations-") ? 503
+          : error?.code === "workspace-membership-conflict" ? 409
+          : error?.code === "workspace-attach-unavailable" ? 501 : 500;
         return send(res, status, {
           ok: false,
           error: safeErrorMessage(error),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-manager",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "DeepSeek Harness session and workspace manager —— Workspaces: archive and visibility. Sessions: move, migrate presets, delete, favorite, review later, prioritize, tag, and annotate. Batch operations. | DSH 会话与工作区管理——工作区：归档与显示。会话：跨工作区移动、预设迁移、删除；收藏、待回看、优先级、标签、备注。批量操作。",
   "license": "MIT",
   "keywords": [