dsh-session-manager 0.7.4 → 0.7.6

package/lib/compat/projection-cache-delete.js

@@ -0,0 +1,110 @@
+import * as fs from "node:fs/promises";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+import { assertSessionId, replaceSessionFile } from "../session-files.js";
+
+// rc.1 cache.write() may await sessions.flush() before reaching table.put().
+// A queue barrier alone cannot drain such a delayed writer. Keep a lifecycle
+// tombstone at the table entry point: queued puts precede delete(), later puts
+// of the deleted lifecycle are ignored. A recreated id with a new identity is
+// independent. The guard lives with the table (including across plugin reloads).
+const guards = new WeakMap();
+const lifecycleKey = identity => Number.isSafeInteger(identity?.createdAt)
+  ? JSON.stringify([identity.createdAt, identity.cwd ?? null, identity.isSeeded ?? false])
+  : undefined;
+export function beginProjectionCacheDeletion(cache, id, header) {
+  assertSessionId(id);
+  const table = typeof cache?.requireTable === "function" ? cache.requireTable() : cache?.table;
+  if (!table || !["get", "put", "delete"].every(key => typeof table[key] === "function")) return undefined;
+  let guard = guards.get(table);
+  if (!guard) {
+    const removed = new Map();
+    const put = table.put;
+    table.put = function(key, record) {
+      if (removed.get(key)?.has(lifecycleKey(record?.identity))) return Promise.resolve();
+      return put.call(this, key, record);
+    };
+    guard = { removed };
+    guards.set(table, guard);
+  }
+  const identity = table.get(id)?.identity;
+  const stamps = [header, identity].map(lifecycleKey).filter(key => key !== undefined);
+  if (!stamps.length && (header || identity)) throw new Error("无法确认投影缓存的会话生命周期");
+  const previous = guard.removed.get(id);
+  const blocked = new Set([...(previous ?? []), ...stamps]);
+  guard.removed.set(id, blocked);
+  return {
+    remove: () => table.delete(id),
+    legacyRetained: table.host?.unit?.descriptor?.layout === "per-record",
+    legacyManaged: Boolean(table.host?.unit?.descriptor) && table.host.unit.descriptor.layout !== "per-record",
+    rollback() {
+      if (guard.removed.get(id) !== blocked) return;
+      if (previous) guard.removed.set(id, previous); else guard.removed.delete(id);
+    }
+  };
+}
+
+async function regular(path, directory = false) {
+  const info = await fs.lstat(path);
+  if (info.isSymbolicLink() || !(directory ? info.isDirectory() : info.isFile())) {
+    throw new Error("投影缓存路径不是安全的普通" + (directory ? "目录" : "文件") + ": " + path);
+  }
+}
+
+export async function assertProjectionCachePath(home, id) {
+  assertSessionId(id);
+  const paths = [home, join(home, "storages"), join(home, "storages", "session_projcache"),
+    join(home, "storages", "session_projcache", "sessions"), join(home, "storages", "session_projcache", "sessions", `${id}.json`)];
+  for (let i = 0; i < paths.length; i++) {
+    try { await regular(paths[i], i < paths.length - 1); }
+    catch (error) { if (error.code === "ENOENT") return; throw error; }
+  }
+}
+
+/** rc.1 bootstraps but never writes its retained legacy unit. Serialize our
+ * read/modify/publish across deletes and processes; preserve its stamp/schema
+ * and every unrelated table/record. Unknown shapes fail without publication.
+ */
+export async function removeLegacyProjectionCache(home, id) {
+  assertSessionId(id);
+  const root = join(home, "storages");
+  const path = join(root, "session_projcache.json");
+  try {
+    await regular(home, true);
+    await regular(root, true);
+    await regular(path);
+  } catch (error) { if (error.code === "ENOENT") return; throw error; }
+  const lockPath = join(root, "session_projcache.session-manager.lock");
+  const token = randomBytes(16).toString("hex");
+  const deadline = Date.now() + 3000;
+  let lock;
+  while (!lock) {
+    try { lock = await fs.open(lockPath, "wx", 0o600); }
+    catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      if (Date.now() >= deadline) throw new Error("投影缓存清理锁正被占用: " + lockPath);
+      await delay(25);
+    }
+  }
+  let stamped = false;
+  try {
+    await lock.writeFile(token);
+    stamped = true;
+    await regular(root, true);
+    await regular(path);
+    const document = JSON.parse(await fs.readFile(path, "utf8"));
+    const records = document?.tables?.sessions;
+    if (document?.unit?.name !== "session_projcache" || ![3, 4, 5, 6, 7].includes(document.unit.version)
+      || !records || typeof records !== "object" || Array.isArray(records)) {
+      throw new Error("未知的旧版投影缓存格式，未修改文件");
+    }
+    if (!Object.hasOwn(records, id)) return;
+    delete records[id];
+    const result = await replaceSessionFile(path, JSON.stringify(document) + "\n");
+    if (result.backupPath) throw new Error("旧版投影缓存已更新，但备份清理失败: " + result.backupPath);
+  } finally {
+    await lock.close();
+    if (!stamped || await fs.readFile(lockPath, "utf8").catch(() => undefined) === token) await fs.rm(lockPath, { force: true });
+  }
+}

package/lib/compat/zstd-frames.js

@@ -12,8 +12,10 @@
  *
  * @module dsh-session-manager/compat/zstd-frames
  */
-import { zstdDecompress } from "node:zlib";
+import { zstdDecompress, createZstdDecompress } from "node:zlib";
 import { promisify } from "node:util";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 
 const zstdDecompressAsync = promisify(zstdDecompress);
 const ZSTD_MAGIC = 0xfd2fb528;
@@ -76,6 +78,81 @@ export async function decompressZstdFrame(frame, options) {
   return zstdDecompressAsync(frame, options);
 }
 
+export function decompressZstdFirstLine(frame, limit) {
+  return new Promise((resolve, reject) => {
+    const stream = createZstdDecompress();
+    const chunks = [];
+    let size = 0;
+    let settled = false;
+    let lineFound = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      stream.destroy();
+      if (error) reject(error); else resolve(value);
+    };
+    stream.on("error", error => finish(error));
+    stream.on("end", () => lineFound
+      ? finish(null, Buffer.concat(chunks, size))
+      : finish(new Error("会话头行不完整或超过大小限制")));
+    stream.on("data", chunk => {
+      if (lineFound) return;
+      const newline = chunk.indexOf(10);
+      const part = newline < 0 ? chunk : chunk.subarray(0, newline + 1);
+      size += part.length;
+      if (size > limit) return finish(new Error("会话头行不完整或超过大小限制"));
+      chunks.push(part);
+      if (newline >= 0) lineFound = true;
+    });
+    if (Buffer.isBuffer(frame)) stream.end(frame);
+    else pipeline(Readable.from(frame), stream).catch(error => finish(error));
+  });
+}
+
+/** Feed exactly the first complete frame, with bounded reads even for huge batches.
+ * Keep consuming after the first line to validate the frame/checksum before discovery.
+ */
+export async function* firstZstdFrameChunks(handle) {
+  let position = 0;
+  const exact = async size => {
+    const bytes = Buffer.alloc(size);
+    let offset = 0;
+    while (offset < size) {
+      const { bytesRead } = await handle.read(bytes, offset, size - offset, position);
+      if (!bytesRead) throw new Error("会话日志存在截断的 Zstd 帧");
+      offset += bytesRead;
+      position += bytesRead;
+    }
+    return bytes;
+  };
+  const prefix = await exact(5);
+  if (prefix.readUInt32LE(0) !== ZSTD_MAGIC) throw new Error("corrupt Zstandard session log: invalid frame magic");
+  const descriptor = prefix[4];
+  if (descriptor & 0x18) throw new Error("corrupt Zstandard session log: reserved frame-header bit");
+  yield prefix;
+  const sizeFlag = descriptor >>> 6;
+  const singleSegment = Boolean(descriptor & 0x20);
+  const dictionaryFlag = descriptor & 3;
+  const headerSize = (singleSegment ? 0 : 1) + (dictionaryFlag === 3 ? 4 : dictionaryFlag)
+    + (sizeFlag === 0 ? (singleSegment ? 1 : 0) : 1 << sizeFlag);
+  if (headerSize) yield await exact(headerSize);
+  for (;;) {
+    const header = await exact(3);
+    const block = header.readUIntLE(0, 3);
+    const type = (block >>> 1) & 3;
+    if (type === 3) throw new Error("corrupt Zstandard session log: reserved block type");
+    yield header;
+    let remaining = type === 1 ? 1 : block >>> 3;
+    while (remaining) {
+      const count = Math.min(remaining, 64 * 1024);
+      yield await exact(count);
+      remaining -= count;
+    }
+    if (block & 1) break;
+  }
+  if (descriptor & 4) yield await exact(4);
+}
+
 export async function decompressAllZstdFrames(buffer) {
   const scan = scanZstdFrames(buffer);
   if (scan.frames.length === 0) {

package/lib/index.js

@@ -28,7 +28,8 @@ import { basename, dirname, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { createAnnotationStore } from "./annotation-store.js";
 import { createWorkspaceArchiveStore, assertWorkspaceId } from "./workspace-archive-store.js";
-import { createDshAdapter, normalizeSessionHeader, compareSemver, detectPluginSource, isHmrActive, resolveProfileDir } from "./compat/dsh-adapter.js";
+import { createDshAdapter, getService, normalizeSessionHeader, compareSemver, detectPluginSource, isHmrActive, resolveProfileDir } from "./compat/dsh-adapter.js";
+import { assertProjectionCachePath, beginProjectionCacheDeletion, removeLegacyProjectionCache } from "./compat/projection-cache-delete.js";
 import { ARTIFACT_NAMES, assertSessionId, assertSessionDirectory, candidateSessionDirs, encodeFsSessionSegment, decodeFsSessionSegment, encodeProjectSegment, encodeSessionSegment, parseSessionGenerationFromFilename, readSessionHeader, readSessionFile, writeTempFile, replaceSessionFile } from "./session-files.js";
 
 export const name = "dsh-session-manager";
@@ -39,7 +40,8 @@ export const inject = [
   "sessions",
   "agents",
   "sessionPersistence",
-  "agentPresets"
+  "agentPresets",
+  "connection"
 ];
 
 /** Like JSON.stringify but swallows circular-reference/BigInt errors so the
@@ -385,7 +387,7 @@ function verifyInstalledPackage(profileDir, expectedVersion) {
 
 export function apply(ctx) {
   try {
-    const buildId = "dsh-session-manager v0.7.4 (workspace-archive)";
+    const buildId = "dsh-session-manager v0.7.6 (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 */ }
@@ -1044,6 +1046,115 @@ ${rest}`, "utf8");
       return await run();
     };
 
+    /**
+     * Issue #42: record the working-directory change a move implies.
+     *
+     * A cross-workspace move rewrites the artifact header's `cwd`, but DSH
+     * folds the `workingDirectory` projection from the session log: the unit
+     * initializes from `header.cwd` only while it has no checkpoint, and both
+     * the projection cache and every `working-directory/change` event
+     * supersede that initial value. A live session therefore keeps reporting
+     * its pre-move directory -- the projection state is never re-initialized --
+     * and the cache checkpoints that stale state under the NEW header identity,
+     * so a rebuild cannot recover the target either. Route the change through
+     * the host's own path (the `workingDirectory` service is what a user `cd`
+     * uses) so the log gains the event the projection folds from; without that
+     * service, append the equivalent event directly, which is the same shape
+     * the host's `commit()` writes.
+     *
+     * @param agent - the live Agent owning the moved session, when one exists.
+     * @param session - the live Session owning the moved log.
+     * @param targetPath - the destination workspace directory.
+     * @returns `{status}`: "synced" (host service committed the change),
+     *   "recorded" (event appended directly) or "restart-required" (the host
+     *   rejected the change; the move itself has already succeeded).
+     */
+    const rehomeLiveWorkingDirectory = async ({ agent, session, targetPath }) => {
+      const service = getService(ctx, "workingDirectory");
+      if (service !== undefined && typeof service.set === "function" && agent !== undefined) {
+        try {
+          const cwd = await service.set(agent, targetPath);
+          return { status: "synced", cwd: typeof cwd === "string" && cwd !== "" ? cwd : targetPath };
+        } catch (error) {
+          const isFiberError = error?.code === "INACTIVE_EFFECT" ||
+            String(error?.message || error).toLowerCase().includes("inactive") ||
+            String(error?.message || error).toLowerCase().includes("fiber");
+          if (!isFiberError) {
+            ctx.logger.warn(`session-manager: moved "${safeJson(session?.id)}" but the host rejected the working-directory change: ${safeErrorMessage(error)}`);
+            return { status: "restart-required", reason: safeErrorMessage(error) };
+          }
+        }
+      }
+      if (session === undefined || session === null || typeof session.append !== "function") {
+        return { status: "restart-required", reason: "no live session to record the working-directory change" };
+      }
+      try {
+        session.append("working-directory/change", { cwd: targetPath });
+        return { status: "recorded", cwd: targetPath };
+      } catch (error) {
+        ctx.logger.warn(`session-manager: moved "${safeJson(session.id)}" but could not record the working-directory change: ${safeErrorMessage(error)}`);
+        return { status: "restart-required", reason: safeErrorMessage(error) };
+      }
+    };
+
+    /**
+     * Issue #42 (cold sessions): append the `working-directory/change` event a
+     * live move records, but only when the stored log already carries one --
+     * otherwise the rewritten `header.cwd` alone initializes the projection on
+     * the next resume and touching the log would be gratuitous. A stale change
+     * event would otherwise fold the pre-move directory back in. Rows whose
+     * `seq` does not match their position (packed physical rows) cannot be
+     * extended without the persistence codec, so the body is left untouched and
+     * the caller reports that a restart is required.
+     *
+     * @param rest - the artifact body (everything after the header line).
+     * @param targetPath - the destination workspace directory.
+     * @returns `{rest, status}` with the body to publish.
+     */
+    const rehomeColdWorkingDirectory = (rest, targetPath) => {
+      const nl = String.fromCharCode(10);
+      const terminated = rest.endsWith(nl);
+      const body = terminated ? rest.slice(0, -1) : rest;
+      if (body === "") return { rest, status: "header-only" };
+      const lines = body.split(nl);
+      let lastChange;
+      let hasPackedOrUnparseableRows = false;
+      let hasNonSequentialSeq = false;
+      for (let index = 0; index < lines.length; index += 1) {
+        let event;
+        try {
+          event = JSON.parse(lines[index]);
+        } catch {
+          hasPackedOrUnparseableRows = true;
+          continue;
+        }
+        if (event === null || typeof event !== "object") {
+          hasPackedOrUnparseableRows = true;
+          continue;
+        }
+        if (event.seq !== index) {
+          hasNonSequentialSeq = true;
+        }
+        if (event.type === "working-directory/change") {
+          lastChange = event.data?.cwd;
+        }
+      }
+      if (lastChange === undefined) return { rest, status: "header-only" };
+      if (lastChange === targetPath) return { rest, status: "already-target" };
+      if (hasPackedOrUnparseableRows || hasNonSequentialSeq) {
+        const error = new Error("无法安全同步会话工作目录（会话日志包含压缩行且已有工作目录变更历史），为防止工作目录不一致，已取消移动。原始会话保持原状");
+        error.code = "working-directory-sync-unsafe";
+        throw error;
+      }
+      const appended = JSON.stringify({
+        type: "working-directory/change",
+        seq: lines.length,
+        time: Date.now(),
+        data: { cwd: targetPath }
+      });
+      return { rest: `${body}${nl}${appended}${nl}`, status: "recorded" };
+    };
+
     /**
      * TRUE cross-workspace move. See the module docstring for the full design:
      * re-home the stored cwd, migrate the artifact, then swap accounting.
@@ -1196,7 +1307,14 @@ ${rest}`, "utf8");
           throw new Error("目标位置已有会话工件，拒绝覆盖");
         } catch (error) { if (error.code !== "ENOENT") throw error; }
         if (oldPath === newPath) throw new Error("会话源路径与目标路径相同，但 cwd 不一致，拒绝覆盖");
-        const bytes = await encodeArtifact(JSON.stringify(newHeader), rest, newPath.endsWith(".zstd"));
+        // Issue #42: a cold log is the only authority its working-directory
+        // projection folds from on the next resume, so re-home it together
+        // with the artifact header. Live sessions get the equivalent event
+        // through the host path once the artifact has been published.
+        const bodyRehome = liveSession === void 0
+          ? rehomeColdWorkingDirectory(rest, targetPath)
+          : { rest, status: "live" };
+        const bytes = await encodeArtifact(JSON.stringify(newHeader), bodyRehome.rest, newPath.endsWith(".zstd"));
         await mkdir(dirname(newPath), { recursive: true });
         const tempNew = await writeTempFile(newPath, bytes);
         const oldHidden = `${oldPath}.${randomBytes(6).toString("hex")}.tmp`;
@@ -1297,7 +1415,7 @@ ${rest}`, "utf8");
           await rm(dirname(oldPath), { recursive: true, force: true });
         } catch (error) { ctx.logger.warn(`session-manager: old directory retained: ${String(error)}`); }
 
-        movedArtifact = { header: newHeader, rest };
+        movedArtifact = { header: newHeader, rest: bodyRehome.rest, workingDirectory: bodyRehome.status };
 
         return {
           ok: true,
@@ -1329,7 +1447,34 @@ ${rest}`, "utf8");
           ctx.logger.warn(`session-manager: post-move cache refresh failed for "${sessionId}": ${String(error)}`);
         }
       }
-            // The agent is still live (no teardown). The session's in-memory
+      // Issue #42: the artifact header was rewritten, but the folded
+      // `workingDirectory` projection was not. Align it now -- after the
+      // artifact has been published (a live session's change event must land in
+      // the moved log) and after the registry swap.
+      let workingDirectory = movedArtifact?.workingDirectory ?? "not-needed";
+      let restartRequired = false;
+      if (liveSession !== void 0) {
+        const rehomed = await rehomeLiveWorkingDirectory({ agent: liveAgent, session: liveSession, targetPath });
+        workingDirectory = rehomed.status;
+        if (rehomed.status === "restart-required") restartRequired = true;
+        if (rehomed.status === "synced" || rehomed.status === "recorded") {
+          // The refold above seeds from the projection cache, so it cannot see
+          // a change committed after the move: checkpoint what the live
+          // session now actually folds (this flushes the new event first).
+          if (cache !== void 0 && typeof cache.write === "function") {
+            try {
+              await cache.write(liveSession);
+            } catch (error) {
+              ctx.logger.warn(`session-manager: post-move working-directory checkpoint failed for "${sessionId}": ${safeErrorMessage(error)}`);
+            }
+          }
+        }
+      } else if (workingDirectory === "restart-required") {
+        restartRequired = true;
+      }
+      result.workingDirectory = workingDirectory;
+      result.restartRequired = restartRequired;
+      // The agent is still live (no teardown). The session's in-memory
       // header was rewritten above and the workspace registry updated;
       // future writes go through persistence.locate() against the new
       // cwd, so the file at the new location accumulates new events.
@@ -1914,11 +2059,20 @@ ${rest}`, "utf8");
       await assertAndStopActiveSession(sessionId, true);
     }
 
+    let projectionDeletion;
+    let artifactsDeleted = false;
     try {
       // Resolve/validate before cancelling the agent or changing registry state.
       let dir = await sessionDirOf(sessionId);
       const session = ctx.sessions?.get?.(sessionId);
       let agent = safeGetAgent(sessionId);
+      try {
+        await assertProjectionCachePath(dirname(adapter.homePath("storages")), sessionId);
+        const artifact = await readSessionArtifact(sessionId, undefined, { headerOnly: true });
+        projectionDeletion = beginProjectionCacheDeletion(adapter.projectionCache, sessionId, session?.header ?? artifact?.meta);
+      } catch (error) {
+        cleanupWarnings.push("投影缓存回写防护不可用: " + safeErrorMessage(error));
+      }
 
       if (agent !== void 0) {
         // Stop any running turn (disposed-kind suppresses re-wake).
@@ -1979,6 +2133,29 @@ ${rest}`, "utf8");
         await assertSessionDirectory(adapter.homePath("sessions"), dir, sessionId);
         await rm(dir, { recursive: true, force: true });
       }
+      artifactsDeleted = true;
+
+      // Use the host queue to remove both its in-memory row and durable record.
+      // Tombstones installed before disposal also stop writes still awaiting flush.
+      try {
+        await assertProjectionCachePath(dirname(adapter.homePath("storages")), sessionId);
+        if (projectionDeletion) await projectionDeletion.remove();
+        else {
+          const file = adapter.homePath("storages", "session_projcache", "sessions", `${sessionId}.json`);
+          if (existsSync(file)) throw new Error("宿主投影缓存删除接口不可用，缓存尚未清理");
+        }
+      } catch (error) {
+        cleanupWarnings.push("会话已删除，但投影缓存清理失败: " + safeErrorMessage(error));
+      }
+      try {
+        if (projectionDeletion?.legacyRetained) await removeLegacyProjectionCache(dirname(adapter.homePath("storages")), sessionId);
+        else if (!projectionDeletion?.legacyManaged && existsSync(adapter.homePath("storages", "session_projcache.json"))) {
+          throw new Error("无法确认旧版缓存已停止写入，未修改文件");
+        }
+      }
+      catch (error) {
+        cleanupWarnings.push("会话已删除，但旧版投影缓存清理失败: " + safeErrorMessage(error));
+      }
 
       try {
         await annotations().remove(sessionId);
@@ -2008,6 +2185,7 @@ ${rest}`, "utf8");
         subagentCount: deletedSubagentIds.length
       };
     } catch (parentErr) {
+      if (!artifactsDeleted) projectionDeletion?.rollback();
       const err = deletedSubagentIds.length > 0
         ? new Error(`删除主会话 '${sessionId}' 失败: ${safeErrorMessage(parentErr)}`)
         : parentErr;
@@ -2295,9 +2473,80 @@ ${rest}`, "utf8");
     if (isBlank) { const e = new Error("blank"); e.code = "blank-skip"; throw e; }
   };
 
-  ctx.effect(() => ctx.webServer.register({    kind: "prefix",
+  /**
+   * Issue #43: Validate incoming request with DSH connection authentication.
+   * Reuses DSH official Connection/Gateway authentication and authorization mechanisms.
+   * Strict fail-closed: requires connection.admit() to succeed with a valid Owner peer.
+   * Must execute before request body reading, JSON parsing, or business operations.
+   */
+  const authenticateApiRequest = (req) => {
+    const connection = getService(ctx, "connection");
+    if (!connection || typeof connection.admit !== "function") {
+      return {
+        ok: false,
+        status: 503,
+        code: "auth-unavailable",
+        error: "DSH 认证服务未就绪或不可用，为保护数据安全已拒绝请求"
+      };
+    }
+    try {
+      const admission = connection.admit(req);
+      if (!admission || typeof admission !== "object") {
+        return {
+          ok: false,
+          status: 401,
+          code: "unauthorized",
+          error: "未授权：需要有效的 DSH 会话凭证"
+        };
+      }
+      if ("rejection" in admission) {
+        const status = typeof admission.rejection === "number" ? admission.rejection : 401;
+        const error = status === 403
+          ? "禁止访问：请求未通过 DSH 信任检查或跨站防护"
+          : "未授权：需要有效的 DSH 会话凭证";
+        return { ok: false, status, code: status === 403 ? "forbidden" : "unauthorized", error };
+      }
+      const peer = admission.peer;
+      if (!peer || typeof peer !== "object") {
+        return {
+          ok: false,
+          status: 401,
+          code: "unauthorized",
+          error: "未授权：缺少有效 Peer 凭证"
+        };
+      }
+      const principalKind = peer.principal?.kind;
+      if (principalKind !== "owner") {
+        return {
+          ok: false,
+          status: 403,
+          code: "forbidden",
+          error: "禁止访问：会话管理属于特权操作，需要 owner 权限"
+        };
+      }
+      return { ok: true, peer };
+    } catch (err) {
+      return {
+        ok: false,
+        status: 403,
+        code: "auth-error",
+        error: "认证检查失败: " + safeErrorMessage(err)
+      };
+    }
+  };
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: "prefix",
     path: API_PREFIX,
     handler: async (req, res) => {
+      const auth = authenticateApiRequest(req);
+      if (!auth.ok) {
+        return send(res, auth.status, {
+          ok: false,
+          code: auth.code,
+          error: auth.error
+        });
+      }
       try {
         const url = new URL(req.url ?? "/", "http://localhost");
         const path = url.pathname.startsWith(API_PREFIX) ? url.pathname.slice(API_PREFIX.length) || "/" : "/";
@@ -2528,7 +2777,7 @@ ${rest}`, "utf8");
           return send(res, 200, { ok: true, result });
         }
         if (req.method === "GET" && path === "/update/check") {
-          const currentVersion = adapter.pluginVersion() || "0.7.4";
+          const currentVersion = adapter.pluginVersion() || "0.7.6";
           const runningVersion = currentVersion;
           let installedVersion = runningVersion;
           const profileDir = resolveProfileDir(adapter, ctx);
@@ -2712,7 +2961,7 @@ ${rest}`, "utf8");
           };
           setActiveTask(taskRecord);
 
-          const currentVersion = adapter.pluginVersion() || "0.7.4";
+          const currentVersion = adapter.pluginVersion() || "0.7.6";
           let installedVersion = currentVersion;
           if (profileDir) {
             const pkgFile = join(profileDir, "node_modules", "dsh-session-manager", "package.json");
@@ -3242,7 +3491,7 @@ ${rest}`, "utf8");
         }
         if (req.method === "GET" && path === "/update/status") {
           const profileDir = resolveProfileDir(adapter, ctx);
-          const currentVersion = adapter.pluginVersion() || "0.7.4";
+          const currentVersion = adapter.pluginVersion() || "0.7.6";
           let installedVersion = currentVersion;
           if (profileDir) {
             const diskCheck = verifyInstalledPackage(profileDir);
@@ -3317,6 +3566,7 @@ ${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 === "working-directory-sync-unsafe" ? 409
           : error?.code === "session-not-found" ? 404 : error?.code?.startsWith("annotations-") ? 503
           : error?.code === "workspace-membership-conflict" ? 409
           : error?.code === "workspace-attach-unavailable" ? 501 : 500;

package/lib/session-files.js

@@ -1,7 +1,7 @@
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs/promises";
 import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { decompressAllZstdFrames, decompressZstdFrame, scanZstdFrames } from "./compat/zstd-frames.js";
+import { decompressAllZstdFrames, decompressZstdFirstLine, firstZstdFrameChunks } from "./compat/zstd-frames.js";
 
 /**
  * Filenames tried in this order to locate a session's durable artifact.
@@ -190,20 +190,17 @@ export async function readSessionHeader(path) {
   await assertRegularFile(path);
   const handle = await fs.open(path, "r");
   try {
+    if (path.endsWith(".zstd")) {
+      const decoded = await decompressZstdFirstLine(firstZstdFrameChunks(handle), MAX_HEADER_BYTES);
+      return parseHeader(decoded.toString("utf8"));
+    }
     let buffer = Buffer.alloc(0);
     while (buffer.length < MAX_HEADER_BYTES) {
       const chunk = Buffer.alloc(Math.min(64 * 1024, MAX_HEADER_BYTES - buffer.length));
       const { bytesRead } = await handle.read(chunk, 0, chunk.length, buffer.length);
       if (bytesRead === 0) break;
       buffer = Buffer.concat([buffer, chunk.subarray(0, bytesRead)]);
-      if (path.endsWith(".zstd")) {
-        const { frames } = scanZstdFrames(buffer, 1);
-        if (frames.length) {
-          const frame = frames[0];
-          const decoded = await decompressZstdFrame(buffer.subarray(frame.start, frame.end), { maxOutputLength: MAX_HEADER_BYTES });
-          return parseHeader(decoded.toString("utf8"));
-        }
-      } else if (buffer.includes(10)) {
+      if (buffer.includes(10)) {
         return parseHeader(buffer.toString("utf8"));
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-manager",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "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": [