dsh-sessions-manager 3.6.2 → 3.7.0

package/lib/index.js

@@ -1,8 +1,8 @@
 // src/index.js
-import { mkdir as mkdir6, readFile as readFile3, readdir as readdir4, realpath, rename as rename6, rm as rm3, stat as stat4, unlink, writeFile as writeFile6 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname3, isAbsolute, join as join8 } from "node:path";
-import { readFileSync as readFileSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
+import { mkdir as mkdir10, readFile as readFile4, readdir as readdir4, realpath, rename as rename9, rm as rm3, stat as stat4, unlink, writeFile as writeFile10 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname4, isAbsolute, join as join12 } from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
 
 // src/zstd-frame.js
 import zlib from "node:zlib";
@@ -303,13 +303,358 @@ function createStarIndex(options = {}) {
   return { read, write, mutate, setStarred, removeIds, indexPath, dir };
 }
 
-// src/pending-moves.js
+// src/tag-index.js
+import { mkdir as mkdir2, rename as fsRename, writeFile as writeFile2 } from "node:fs/promises";
 import { readFileSync as readFileSync2 } from "node:fs";
-import { mkdir as mkdir2, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
+var TAG_SCHEMA_VERSION = 4;
+var MAX_TAGS = 200;
+var MAX_TAGS_PER_SESSION = 10;
+var MAX_TAG_NAME = 24;
+var DEFAULT_TAG_DIR = join2(homedir2(), ".dsh", "sessions-manager");
+var TAG_ID_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+function randomSuffix() {
+  const bytes = randomBytes(8);
+  let out = "";
+  for (const b of bytes) out += TAG_ID_ALPHABET[b % TAG_ID_ALPHABET.length];
+  return out;
+}
+function isSafeSessionId2(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 200 && !/[\\/\0]/.test(value) && value !== "." && value !== "..";
+}
+function isSafeTagId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 64 && !/[\\/\0]/.test(value);
+}
+function tagError(message, status, code) {
+  const error = new Error(message);
+  error.status = status;
+  if (code) error.code = code;
+  throw error;
+}
+function normalizeTagName(value) {
+  if (typeof value !== "string") return null;
+  const name2 = value.trim();
+  if (!name2 || /[\\/\0]/.test(name2)) return null;
+  if (Array.from(name2).length > MAX_TAG_NAME) return null;
+  return name2;
+}
+function nameKey(name2) {
+  return name2.toLocaleLowerCase();
+}
+function normalizeTagStore(raw) {
+  const source = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
+  const tags = [];
+  const ids = /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Set();
+  for (const item of source && Array.isArray(source.tags) ? source.tags : []) {
+    if (!item || typeof item !== "object") continue;
+    if (!isSafeTagId(item.id) || ids.has(item.id)) continue;
+    const name2 = normalizeTagName(item.name);
+    if (name2 === null) continue;
+    const key = nameKey(name2);
+    if (names.has(key)) continue;
+    ids.add(item.id);
+    names.add(key);
+    const createdAt = Number.isFinite(Number(item.createdAt)) ? Number(item.createdAt) : 0;
+    tags.push({ id: item.id, name: name2, createdAt });
+    if (tags.length >= MAX_TAGS) break;
+  }
+  const assignments = {};
+  const rawAssignments = source && source.assignments && typeof source.assignments === "object" && !Array.isArray(source.assignments) ? source.assignments : null;
+  if (rawAssignments) {
+    for (const [sid, value] of Object.entries(rawAssignments)) {
+      if (!isSafeSessionId2(sid) || !Array.isArray(value)) continue;
+      const kept = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const tagId of value) {
+        if (!ids.has(tagId) || seen.has(tagId)) continue;
+        seen.add(tagId);
+        kept.push(tagId);
+        if (kept.length >= MAX_TAGS_PER_SESSION) break;
+      }
+      if (kept.length) assignments[sid] = kept;
+    }
+  }
+  return { schemaVersion: TAG_SCHEMA_VERSION, tags, assignments };
+}
+function createTagIndex(options = {}) {
+  const dir = options.dir || process.env.DSH_SESSIONS_MANAGER_STAR_DIR || DEFAULT_TAG_DIR;
+  const indexPath = options.indexPath || join2(dir, "tags.json");
+  let mutation = Promise.resolve();
+  async function read() {
+    try {
+      return normalizeTagStore(JSON.parse(readFileSync2(indexPath, "utf8")));
+    } catch {
+      return normalizeTagStore(null);
+    }
+  }
+  async function write(store) {
+    await mkdir2(dir, { recursive: true });
+    const tmp = join2(dir, `.tags-${process.pid}-${Date.now()}.tmp`);
+    await writeFile2(tmp, JSON.stringify(normalizeTagStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await fsRename(tmp, indexPath);
+  }
+  function mutate(mutator) {
+    const operation = mutation.then(async () => {
+      const store = await read();
+      const result = await mutator(store);
+      await write(store);
+      return result;
+    });
+    mutation = operation.catch(() => {
+    });
+    return operation;
+  }
+  function newTagId(store) {
+    for (let i = 0; i < 16; i++) {
+      const id = `t_${randomSuffix()}`;
+      if (!store.tags.some((t) => t.id === id)) return id;
+    }
+    return tagError("\u65E0\u6CD5\u751F\u6210\u6807\u7B7E id\uFF08\u968F\u673A\u78B0\u649E\u5F02\u5E38\uFF09", 500, "DSM_TAG_ID_COLLISION");
+  }
+  async function create(rawName) {
+    const name2 = normalizeTagName(rawName);
+    if (name2 === null) tagError(`\u6807\u7B7E\u540D\u65E0\u6548\uFF08\u975E\u7A7A\u3001\u4E0D\u542B\u659C\u6760\u3001\u4E0D\u8D85\u8FC7 ${MAX_TAG_NAME} \u4E2A\u5B57\u7B26\uFF09`, 400, "DSM_TAG_NAME_INVALID");
+    const key = nameKey(name2);
+    return mutate((store) => {
+      if (store.tags.some((t) => nameKey(t.name) === key)) tagError("\u540C\u540D\u6807\u7B7E\u5DF2\u5B58\u5728", 409, "DSM_TAG_EXISTS");
+      if (store.tags.length >= MAX_TAGS) tagError(`\u6807\u7B7E\u603B\u6570\u5DF2\u8FBE\u4E0A\u9650\uFF08${MAX_TAGS}\uFF09`, 409, "DSM_TAG_LIMIT");
+      const tag = { id: newTagId(store), name: name2, createdAt: Date.now() };
+      store.tags.push(tag);
+      return tag;
+    });
+  }
+  async function rename10(id, rawName) {
+    const name2 = normalizeTagName(rawName);
+    if (name2 === null) tagError(`\u6807\u7B7E\u540D\u65E0\u6548\uFF08\u975E\u7A7A\u3001\u4E0D\u542B\u659C\u6760\u3001\u4E0D\u8D85\u8FC7 ${MAX_TAG_NAME} \u4E2A\u5B57\u7B26\uFF09`, 400, "DSM_TAG_NAME_INVALID");
+    const key = nameKey(name2);
+    return mutate((store) => {
+      const tag = store.tags.find((t) => t.id === id);
+      if (!tag) tagError("\u6807\u7B7E\u4E0D\u5B58\u5728", 404, "DSM_TAG_NOT_FOUND");
+      if (store.tags.some((t) => t.id !== tag.id && nameKey(t.name) === key)) tagError("\u540C\u540D\u6807\u7B7E\u5DF2\u5B58\u5728", 409, "DSM_TAG_EXISTS");
+      tag.name = name2;
+      return tag;
+    });
+  }
+  async function merge(fromId, toId) {
+    if (!isSafeTagId(fromId) || !isSafeTagId(toId) || fromId === toId) {
+      tagError("\u5408\u5E76\u7684\u6E90/\u76EE\u6807\u6807\u7B7E\u65E0\u6548\u6216\u76F8\u540C", 400, "DSM_TAG_INVALID");
+    }
+    return mutate((store) => {
+      if (!store.tags.some((t) => t.id === fromId) || !store.tags.some((t) => t.id === toId)) {
+        tagError("\u6807\u7B7E\u4E0D\u5B58\u5728", 404, "DSM_TAG_NOT_FOUND");
+      }
+      for (const [sid, list2] of Object.entries(store.assignments)) {
+        if (!list2.includes(fromId)) continue;
+        const merged = [...new Set(list2.filter((x) => x !== fromId).concat(toId))];
+        store.assignments[sid] = merged.slice(0, MAX_TAGS_PER_SESSION);
+      }
+      store.tags = store.tags.filter((t) => t.id !== fromId);
+      return { merged: true };
+    });
+  }
+  function removeTag(id) {
+    return mutate((store) => {
+      if (isSafeTagId(id)) {
+        store.tags = store.tags.filter((t) => t.id !== id);
+        for (const [sid, list2] of Object.entries(store.assignments)) {
+          const kept = list2.filter((x) => x !== id);
+          if (kept.length) store.assignments[sid] = kept;
+          else delete store.assignments[sid];
+        }
+      }
+      return { removed: true };
+    });
+  }
+  async function setTags(sessionId, tagIds) {
+    if (!isSafeSessionId2(sessionId)) tagError("\u65E0\u6548\u7684 sessionId", 400, "DSM_TAG_SESSION_INVALID");
+    if (!Array.isArray(tagIds)) tagError("tagIds \u5FC5\u987B\u662F\u6570\u7EC4", 400, "DSM_TAG_IDS_INVALID");
+    const seen = /* @__PURE__ */ new Set();
+    const wanted = [];
+    for (const v of tagIds) {
+      if (!isSafeTagId(v)) tagError("\u65E0\u6548\u7684\u6807\u7B7E id", 400, "DSM_TAG_UNKNOWN");
+      if (seen.has(v)) continue;
+      seen.add(v);
+      wanted.push(v);
+    }
+    if (wanted.length > MAX_TAGS_PER_SESSION) tagError(`\u5355\u4E2A\u4F1A\u8BDD\u6700\u591A ${MAX_TAGS_PER_SESSION} \u4E2A\u6807\u7B7E`, 409, "DSM_TAG_LIMIT");
+    return mutate((store) => {
+      const known = new Set(store.tags.map((t) => t.id));
+      const unknown = wanted.filter((id) => !known.has(id));
+      if (unknown.length) tagError(`\u672A\u77E5\u7684\u6807\u7B7E id\uFF1A${unknown.join("\u3001")}`, 400, "DSM_TAG_UNKNOWN");
+      if (wanted.length) store.assignments[sessionId] = [...wanted];
+      else delete store.assignments[sessionId];
+      return store.assignments;
+    });
+  }
+  function removeIds(ids) {
+    const wanted = (Array.isArray(ids) ? ids : []).filter(isSafeSessionId2);
+    return mutate((store) => {
+      for (const sid of wanted) delete store.assignments[sid];
+      return store.assignments;
+    });
+  }
+  async function list() {
+    const store = await read();
+    return { tags: store.tags, assignments: store.assignments };
+  }
+  return { read, write, mutate, list, create, rename: rename10, merge, removeTag, setTags, removeIds, indexPath, dir };
+}
+
+// src/saved-filters.js
+import { mkdir as mkdir3, rename as rename2, writeFile as writeFile3 } from "node:fs/promises";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+var FILTER_SCHEMA_VERSION = 1;
+var MAX_FILTERS = 20;
+var MAX_FILTER_NAME = 40;
+var MAX_FILTER_JSON = 2048;
+var DEFAULT_FILTER_DIR = join3(homedir3(), ".dsh", "sessions-manager");
+var FILTER_ID_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+function randomSuffix2() {
+  const bytes = randomBytes2(8);
+  let out = "";
+  for (const b of bytes) out += FILTER_ID_ALPHABET[b % FILTER_ID_ALPHABET.length];
+  return out;
+}
+function isSafeFilterId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 64 && !/[\\/\0]/.test(value);
+}
+function filterError(message, status, code) {
+  const error = new Error(message);
+  error.status = status;
+  if (code) error.code = code;
+  throw error;
+}
+function normalizeFilterName(value) {
+  if (typeof value !== "string") return null;
+  const name2 = value.trim();
+  if (!name2 || /[\\/\0]/.test(name2)) return null;
+  if (Array.from(name2).length > MAX_FILTER_NAME) return null;
+  return name2;
+}
+function nameKey2(name2) {
+  return name2.toLocaleLowerCase();
+}
+function normalizeFiltersPayload(value) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch {
+    return null;
+  }
+  if (typeof serialized !== "string" || serialized.length > MAX_FILTER_JSON) return null;
+  try {
+    return JSON.parse(serialized);
+  } catch {
+    return null;
+  }
+}
+function normalizeFilterStore(raw) {
+  const source = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
+  const items = [];
+  const ids = /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Set();
+  for (const item of source && Array.isArray(source.items) ? source.items : []) {
+    if (!item || typeof item !== "object") continue;
+    if (!isSafeFilterId(item.id) || ids.has(item.id)) continue;
+    const name2 = normalizeFilterName(item.name);
+    if (name2 === null) continue;
+    const key = nameKey2(name2);
+    if (names.has(key)) continue;
+    const filters = normalizeFiltersPayload(item.filters);
+    if (filters === null) continue;
+    ids.add(item.id);
+    names.add(key);
+    const createdAt = Number.isFinite(Number(item.createdAt)) ? Number(item.createdAt) : 0;
+    items.push({ id: item.id, name: name2, filters, createdAt });
+    if (items.length >= MAX_FILTERS) break;
+  }
+  return { schemaVersion: FILTER_SCHEMA_VERSION, items };
+}
+function createSavedFilters(options = {}) {
+  const dir = options.dir || process.env.DSH_SESSIONS_MANAGER_STAR_DIR || DEFAULT_FILTER_DIR;
+  const indexPath = options.indexPath || join3(dir, "saved-filters.json");
+  let mutation = Promise.resolve();
+  async function read() {
+    try {
+      return normalizeFilterStore(JSON.parse(readFileSync3(indexPath, "utf8")));
+    } catch {
+      return normalizeFilterStore(null);
+    }
+  }
+  async function write(store) {
+    await mkdir3(dir, { recursive: true });
+    const tmp = join3(dir, `.saved-filters-${process.pid}-${Date.now()}.tmp`);
+    await writeFile3(tmp, JSON.stringify(normalizeFilterStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename2(tmp, indexPath);
+  }
+  function mutate(mutator) {
+    const operation = mutation.then(async () => {
+      const store = await read();
+      const result = await mutator(store);
+      await write(store);
+      return result;
+    });
+    mutation = operation.catch(() => {
+    });
+    return operation;
+  }
+  function newFilterId(store) {
+    for (let i = 0; i < 16; i++) {
+      const id = `f_${randomSuffix2()}`;
+      if (!store.items.some((t) => t.id === id)) return id;
+    }
+    return filterError("\u65E0\u6CD5\u751F\u6210\u7B5B\u9009 id\uFF08\u968F\u673A\u78B0\u649E\u5F02\u5E38\uFF09", 500, "DSM_FILTER_ID_COLLISION");
+  }
+  async function save(rawName, filters) {
+    const name2 = normalizeFilterName(rawName);
+    if (name2 === null) filterError(`\u7B5B\u9009\u540D\u65E0\u6548\uFF08\u975E\u7A7A\u3001\u4E0D\u542B\u659C\u6760\u3001\u4E0D\u8D85\u8FC7 ${MAX_FILTER_NAME} \u4E2A\u5B57\u7B26\uFF09`, 400, "DSM_FILTER_NAME_INVALID");
+    let serialized;
+    try {
+      serialized = JSON.stringify(filters);
+    } catch {
+      serialized = void 0;
+    }
+    if (typeof serialized !== "string") filterError("\u7B5B\u9009\u6761\u4EF6\u5FC5\u987B\u662F\u53EF JSON \u5E8F\u5217\u5316\u7684\u6570\u636E", 400, "DSM_FILTER_INVALID");
+    if (serialized === "null") filterError("\u7B5B\u9009\u6761\u4EF6\u4E0D\u80FD\u4E3A null", 400, "DSM_FILTER_INVALID");
+    if (serialized.length > MAX_FILTER_JSON) filterError(`\u7B5B\u9009\u6761\u4EF6\u8FC7\u5927\uFF08\u5E8F\u5217\u5316\u540E\u6700\u591A ${MAX_FILTER_JSON} \u5B57\u7B26\uFF09`, 400, "DSM_FILTER_TOO_LARGE");
+    const payload = JSON.parse(serialized);
+    const key = nameKey2(name2);
+    return mutate((store) => {
+      if (store.items.some((t) => nameKey2(t.name) === key)) filterError("\u540C\u540D\u7B5B\u9009\u5DF2\u5B58\u5728", 409, "DSM_FILTER_EXISTS");
+      if (store.items.length >= MAX_FILTERS) filterError(`\u4FDD\u5B58\u7684\u7B5B\u9009\u5DF2\u8FBE\u4E0A\u9650\uFF08${MAX_FILTERS}\uFF09`, 409, "DSM_FILTER_LIMIT");
+      const item = { id: newFilterId(store), name: name2, filters: payload, createdAt: Date.now() };
+      store.items.push(item);
+      return item;
+    });
+  }
+  function remove(ids) {
+    const wanted = new Set((Array.isArray(ids) ? ids : []).filter(isSafeFilterId).map(String));
+    return mutate((store) => {
+      const before = store.items.length;
+      store.items = store.items.filter((t) => !wanted.has(t.id));
+      return before - store.items.length;
+    });
+  }
+  async function list() {
+    const store = await read();
+    return store.items;
+  }
+  return { read, write, mutate, list, save, remove, indexPath, dir };
+}
+
+// src/pending-moves.js
+import { readFileSync as readFileSync4 } from "node:fs";
+import { mkdir as mkdir4, rename as rename3, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
 var SCHEMA_VERSION = 1;
-var DEFAULT_DIR = process.env.DSH_SESSIONS_MANAGER_PENDING_DIR || process.env.DSH_SESSIONS_MANAGER_STAR_DIR || join2(homedir2(), ".dsh", "sessions-manager");
+var DEFAULT_DIR = process.env.DSH_SESSIONS_MANAGER_PENDING_DIR || process.env.DSH_SESSIONS_MANAGER_STAR_DIR || join4(homedir4(), ".dsh", "sessions-manager");
 var MAX_ITEMS = 50;
 var MAX_ATTEMPTS = 5;
 function isSafeId(value) {
@@ -335,20 +680,20 @@ function normalizeStore(raw) {
 }
 function createPendingMoveStore(options = {}) {
   const dir = options.dir || DEFAULT_DIR;
-  const indexPath = options.indexPath || join2(dir, "pending-moves.json");
+  const indexPath = options.indexPath || join4(dir, "pending-moves.json");
   let mutation = Promise.resolve();
   async function read() {
     try {
-      return normalizeStore(JSON.parse(readFileSync2(indexPath, "utf8")));
+      return normalizeStore(JSON.parse(readFileSync4(indexPath, "utf8")));
     } catch (e) {
       return normalizeStore(null);
     }
   }
   async function write(store) {
-    await mkdir2(dir, { recursive: true });
-    const tmp = join2(dir, `.pending-moves-${process.pid}-${Date.now()}.tmp`);
-    await writeFile2(tmp, JSON.stringify(normalizeStore(store), null, 2), { encoding: "utf8", mode: 384 });
-    await rename2(tmp, indexPath);
+    await mkdir4(dir, { recursive: true });
+    const tmp = join4(dir, `.pending-moves-${process.pid}-${Date.now()}.tmp`);
+    await writeFile4(tmp, JSON.stringify(normalizeStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename3(tmp, indexPath);
   }
   function mutate(mutator) {
     const operation = mutation.then(async () => {
@@ -398,9 +743,106 @@ function createPendingMoveStore(options = {}) {
   };
 }
 
+// src/move-notices.js
+import { readFileSync as readFileSync5 } from "node:fs";
+import { mkdir as mkdir5, rename as rename4, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
+var SCHEMA_VERSION2 = 1;
+var MAX_NOTICES = 20;
+var NOTICE_MAX_AGE_MS = 7 * 24 * 3600 * 1e3;
+var KINDS = /* @__PURE__ */ new Set(["moved", "abandoned"]);
+function isSafeId2(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 200;
+}
+function str(v, max) {
+  return typeof v === "string" && v ? v.slice(0, max) : null;
+}
+function normalizeNotice(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  if (!KINDS.has(raw.kind) || !isSafeId2(raw.sessionId)) return null;
+  const at = Number.isFinite(raw.at) && raw.at > 0 ? Math.floor(raw.at) : 0;
+  if (!at) return null;
+  const sessionId = String(raw.sessionId);
+  return {
+    id: str(raw.id, 400) || `${sessionId}:${raw.kind}:${at}`,
+    kind: raw.kind,
+    sessionId,
+    targetPath: str(raw.targetPath, 500),
+    attempts: Number.isSafeInteger(raw.attempts) && raw.attempts >= 0 ? raw.attempts : null,
+    reason: str(raw.reason, 300),
+    at
+  };
+}
+function normalizeStore2(raw) {
+  const source = raw && Array.isArray(raw.items) ? raw.items : [];
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const entry of source) {
+    const n = normalizeNotice(entry);
+    if (!n || seen.has(n.id)) continue;
+    seen.add(n.id);
+    items.push(n);
+  }
+  items.sort((a, b) => a.at - b.at);
+  const trimmed = items.length > MAX_NOTICES ? items.slice(items.length - MAX_NOTICES) : items;
+  return { schemaVersion: SCHEMA_VERSION2, items: trimmed };
+}
+function createMoveNoticeStore(options = {}) {
+  const dir = options.dir || process.env.DSH_SESSIONS_MANAGER_PENDING_DIR || process.env.DSH_SESSIONS_MANAGER_STAR_DIR || join5(homedir5(), ".dsh", "sessions-manager");
+  const indexPath = options.indexPath || join5(dir, "move-notices.json");
+  let mutation = Promise.resolve();
+  function read() {
+    try {
+      return normalizeStore2(JSON.parse(readFileSync5(indexPath, "utf8")));
+    } catch (e) {
+      return normalizeStore2(null);
+    }
+  }
+  async function write(store) {
+    await mkdir5(dir, { recursive: true });
+    const tmp = join5(dir, `.move-notices-${process.pid}-${Date.now()}.tmp`);
+    await writeFile5(tmp, JSON.stringify(normalizeStore2(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename4(tmp, indexPath);
+  }
+  function mutate(mutator) {
+    const operation = mutation.then(async () => {
+      const store = read();
+      const result = await mutator(store);
+      await write(store);
+      return result;
+    });
+    mutation = operation.catch(() => {
+    });
+    return operation;
+  }
+  return {
+    indexPath,
+    // 终局落一条通知；同 id（会话+类型+时刻）幂等去重。
+    append: (notice) => mutate((store) => {
+      const n = normalizeNotice(notice);
+      if (!n) return null;
+      if (store.items.some((x) => x.id === n.id)) return n;
+      store.items.push(n);
+      return n;
+    }),
+    // 只读列出未过期、未 ack 的通知（按时间升序）。过期项在下次写入时随归一化清掉。
+    async list() {
+      const now = Date.now();
+      return read().items.filter((n) => now - n.at <= NOTICE_MAX_AGE_MS);
+    },
+    ack: (ids) => mutate((store) => {
+      const drop = new Set((Array.isArray(ids) ? ids : []).filter((v) => typeof v === "string" && v.length <= 400).map(String));
+      const before = store.items.length;
+      store.items = store.items.filter((n) => !drop.has(n.id));
+      return before - store.items.length;
+    })
+  };
+}
+
 // src/state-temp-sweep.js
 import { readdir, rm, stat } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join6 } from "node:path";
 var TEMP_NAME_RE = /^\..+-\d+-\d+\.tmp$/;
 async function sweepStaleStateTemps(dirs, options = {}) {
   const maxAgeMs = Number.isSafeInteger(options.maxAgeMs) && options.maxAgeMs >= 0 ? options.maxAgeMs : 36e5;
@@ -416,7 +858,7 @@ async function sweepStaleStateTemps(dirs, options = {}) {
     }
     for (const name2 of entries) {
       if (!TEMP_NAME_RE.test(name2)) continue;
-      const path = join3(dir, name2);
+      const path = join6(dir, name2);
       let info;
       try {
         info = await stat(path);
@@ -487,15 +929,15 @@ function aggregateStorage(items, options = {}) {
 }
 
 // src/auto-archive.js
-import { mkdir as mkdir3, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
-import { readFileSync as readFileSync3 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
+import { mkdir as mkdir6, rename as rename5, writeFile as writeFile6 } from "node:fs/promises";
+import { readFileSync as readFileSync6 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join7 } from "node:path";
 var AUTO_ARCHIVE_SCHEMA_VERSION = 4;
 var INACTIVE_DAY_OPTIONS = Object.freeze([0, 30, 60, 90]);
 var DAY_MS = 864e5;
 var RUN_INTERVAL_MS = DAY_MS;
-var DEFAULT_DIR2 = join4(homedir3(), ".dsh", "sessions-manager");
+var DEFAULT_DIR2 = join7(homedir6(), ".dsh", "sessions-manager");
 function normalizeAutoArchiveStore(raw) {
   const source = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   const settings = source.settings && typeof source.settings === "object" ? source.settings : {};
@@ -540,20 +982,20 @@ function pickInactiveCandidates(items, options = {}) {
 }
 function createAutoArchiveStore(options = {}) {
   const dir = options.dir || process.env.DSH_SESSIONS_MANAGER_AUTO_ARCHIVE_DIR || DEFAULT_DIR2;
-  const indexPath = options.indexPath || join4(dir, "auto-archive.json");
+  const indexPath = options.indexPath || join7(dir, "auto-archive.json");
   let mutation = Promise.resolve();
   async function read() {
     try {
-      return normalizeAutoArchiveStore(JSON.parse(readFileSync3(indexPath, "utf8")));
+      return normalizeAutoArchiveStore(JSON.parse(readFileSync6(indexPath, "utf8")));
     } catch {
       return normalizeAutoArchiveStore(null);
     }
   }
   async function write(store) {
-    await mkdir3(dir, { recursive: true });
-    const tmp = join4(dir, `.auto-archive-${process.pid}-${Date.now()}.tmp`);
-    await writeFile3(tmp, JSON.stringify(normalizeAutoArchiveStore(store), null, 2), { encoding: "utf8", mode: 384 });
-    await rename3(tmp, indexPath);
+    await mkdir6(dir, { recursive: true });
+    const tmp = join7(dir, `.auto-archive-${process.pid}-${Date.now()}.tmp`);
+    await writeFile6(tmp, JSON.stringify(normalizeAutoArchiveStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename5(tmp, indexPath);
   }
   function mutate(mutator) {
     const operation = mutation.then(async () => {
@@ -700,8 +1142,8 @@ function createSessionMetaCache(opts = {}) {
 }
 
 // src/title-persist-index.js
-import { mkdir as mkdir4, readFile, rename as rename4, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname, join as join5 } from "node:path";
+import { mkdir as mkdir7, readFile, rename as rename6, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname, join as join8 } from "node:path";
 var TITLE_INDEX_SCHEMA_VERSION = 2;
 var MAX_ENTRIES = 2e4;
 function normalizeEntry(raw) {
@@ -743,7 +1185,7 @@ function mergeEntries(left, right) {
 function createTitleIndexStore({ dir, file }) {
   let cache = null;
   let chain = Promise.resolve();
-  const path = file || join5(dir, "title-index.json");
+  const path = file || join8(dir, "title-index.json");
   async function readRaw() {
     try {
       return normalizeTitleIndex(JSON.parse(await readFile(path, "utf8")));
@@ -778,10 +1220,10 @@ function createTitleIndexStore({ dir, file }) {
       if (!Object.keys(right).length) return false;
       await enqueue(async (store) => {
         const next = mergeEntries(store, right);
-        await mkdir4(dirname(path), { recursive: true });
-        const tmp = join5(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`);
-        await writeFile4(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: next }), { encoding: "utf8", mode: 384 });
-        await rename4(tmp, path);
+        await mkdir7(dirname(path), { recursive: true });
+        const tmp = join8(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`);
+        await writeFile7(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: next }), { encoding: "utf8", mode: 384 });
+        await rename6(tmp, path);
         cache = next;
       });
       return true;
@@ -798,10 +1240,110 @@ function createTitleIndexStore({ dir, file }) {
           }
         }
         if (!changed) return;
-        await mkdir4(dirname(path), { recursive: true });
-        const tmp = join5(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`);
-        await writeFile4(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: store }), { encoding: "utf8", mode: 384 });
-        await rename4(tmp, path);
+        await mkdir7(dirname(path), { recursive: true });
+        const tmp = join8(dirname(path), `.title-index-${process.pid}-${Date.now()}.tmp`);
+        await writeFile7(tmp, JSON.stringify({ schemaVersion: TITLE_INDEX_SCHEMA_VERSION, entries: store }), { encoding: "utf8", mode: 384 });
+        await rename6(tmp, path);
+      });
+      return true;
+    }
+  };
+}
+
+// src/empty-scan-index.js
+import { mkdir as mkdir8, readFile as readFile2, rename as rename7, writeFile as writeFile8 } from "node:fs/promises";
+import { dirname as dirname2, join as join9 } from "node:path";
+var EMPTY_SCAN_SCHEMA_VERSION = 1;
+var MAX_ENTRIES2 = 2e4;
+function normalizeEntry2(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const empty = raw.empty === 1 || raw.empty === true ? 1 : raw.empty === 0 || raw.empty === false ? 0 : null;
+  const fingerprint = typeof raw.fingerprint === "string" && raw.fingerprint ? raw.fingerprint : null;
+  const updatedAt = typeof raw.updatedAt === "number" ? raw.updatedAt : 0;
+  if (empty === null || !fingerprint || fingerprint.startsWith("rev:")) return null;
+  return { empty, fingerprint, updatedAt };
+}
+function normalizeEmptyScanIndex(raw) {
+  const entries = {};
+  if (raw && typeof raw === "object" && raw.entries && typeof raw.entries === "object") {
+    for (const [id, entry] of Object.entries(raw.entries)) {
+      if (typeof id !== "string" || !id || id.length > 200) continue;
+      const normalized = normalizeEntry2(entry);
+      if (normalized) entries[id] = normalized;
+    }
+  }
+  return { schemaVersion: EMPTY_SCAN_SCHEMA_VERSION, entries };
+}
+function mergeEntries2(left, right) {
+  const merged = { ...left };
+  for (const [id, entry] of Object.entries(right)) merged[id] = entry;
+  const ids = Object.keys(merged);
+  if (ids.length > MAX_ENTRIES2) {
+    ids.sort((a, b) => (merged[a].updatedAt || 0) - (merged[b].updatedAt || 0));
+    for (const id of ids.slice(0, ids.length - MAX_ENTRIES2)) delete merged[id];
+  }
+  return merged;
+}
+function createEmptyScanStore({ dir, file }) {
+  let cache = null;
+  let chain = Promise.resolve();
+  const path = file || join9(dir, "empty-scan.json");
+  async function readRaw() {
+    try {
+      return normalizeEmptyScanIndex(JSON.parse(await readFile2(path, "utf8")));
+    } catch (e) {
+      return normalizeEmptyScanIndex(null);
+    }
+  }
+  function enqueue(mutator) {
+    const operation = chain.then(async () => {
+      const store = cache || (cache = (await readRaw()).entries);
+      await mutator(store);
+      return store;
+    });
+    chain = operation.catch(() => {
+    });
+    return operation;
+  }
+  return {
+    async entries() {
+      if (cache) return cache;
+      cache = (await readRaw()).entries;
+      return cache;
+    },
+    async merge(batch) {
+      const right = {};
+      for (const [id, entry] of Object.entries(batch || {})) {
+        const normalized = normalizeEntry2(entry);
+        if (normalized) right[String(id)] = normalized;
+      }
+      if (!Object.keys(right).length) return false;
+      await enqueue(async (store) => {
+        const next = mergeEntries2(store, right);
+        await mkdir8(dirname2(path), { recursive: true });
+        const tmp = join9(dirname2(path), `.empty-scan-${process.pid}-${Date.now()}.tmp`);
+        await writeFile8(tmp, JSON.stringify({ schemaVersion: EMPTY_SCAN_SCHEMA_VERSION, entries: next }), { encoding: "utf8", mode: 384 });
+        await rename7(tmp, path);
+        cache = next;
+      });
+      return true;
+    },
+    async remove(ids) {
+      const wanted = new Set((ids || []).map(String));
+      if (!wanted.size) return false;
+      await enqueue(async (store) => {
+        let changed = false;
+        for (const id of wanted) {
+          if (id in store) {
+            delete store[id];
+            changed = true;
+          }
+        }
+        if (!changed) return;
+        await mkdir8(dirname2(path), { recursive: true });
+        const tmp = join9(dirname2(path), `.empty-scan-${process.pid}-${Date.now()}.tmp`);
+        await writeFile8(tmp, JSON.stringify({ schemaVersion: EMPTY_SCAN_SCHEMA_VERSION, entries: store }), { encoding: "utf8", mode: 384 });
+        await rename7(tmp, path);
       });
       return true;
     }
@@ -810,7 +1352,7 @@ function createTitleIndexStore({ dir, file }) {
 
 // src/handle-era-paths.js
 import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
-import { basename, join as join6 } from "node:path";
+import { basename, join as join10 } from "node:path";
 
 // src/path-guard.js
 function splitSegments(target) {
@@ -883,8 +1425,8 @@ function resolveSessionRoot(sp) {
   return typeof root === "string" && root.length > 0 ? root : null;
 }
 function deriveSessionDir(root, cwd, id) {
-  const project = cwd === void 0 || cwd === null || cwd === "" ? join6(root, "_no-cwd") : join6(root, projectKeyFor(cwd));
-  return join6(project, encodeSegmentFor(id));
+  const project = cwd === void 0 || cwd === null || cwd === "" ? join10(root, "_no-cwd") : join10(root, projectKeyFor(cwd));
+  return join10(project, encodeSegmentFor(id));
 }
 function generationVersionOf(name2) {
   return Number((String(name2).match(/^session\.v(\d+)\./) || [])[1] || 0);
@@ -911,11 +1453,11 @@ async function locateSessionArtifacts(sp, header) {
   const generationFiles = entries.filter((name2) => GENERATION_LOG_RE.test(name2));
   if (generationFiles.length === 0) return null;
   generationFiles.sort((a, b) => generationVersionOf(b) - generationVersionOf(a));
-  const logPath = join6(sessionDir, generationFiles[0]);
+  const logPath = join10(sessionDir, generationFiles[0]);
   if (!pathOwnsSession(logPath, sid)) return null;
   return {
     root,
-    projectDir: join6(root, header.cwd === void 0 || header.cwd === null || header.cwd === "" ? "_no-cwd" : projectKeyFor(header.cwd)),
+    projectDir: join10(root, header.cwd === void 0 || header.cwd === null || header.cwd === "" ? "_no-cwd" : projectKeyFor(header.cwd)),
     sessionDir,
     logPath,
     generationFiles,
@@ -1125,8 +1667,8 @@ function requireCapability(capabilities, name2) {
 }
 
 // src/handle-era-ops.js
-import { mkdir as mkdir5, readFile as readFile2, readdir as readdir3, rename as rename5, rm as rm2, stat as stat3, writeFile as writeFile5 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname2, join as join7 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile3, readdir as readdir3, rename as rename8, rm as rm2, stat as stat3, writeFile as writeFile9 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname3, join as join11 } from "node:path";
 var MOVE_BATCH = 400;
 var REAL_LOG_RE = /^session.*\.jsonl(\.zst(d)?)?$/;
 var MOVE_TEMP_RE = /\.move-(backup|stage)-/;
@@ -1149,7 +1691,7 @@ async function cleanSiblingCopies(root, sid, keepDir, keepVersion) {
   const real = [];
   for (const ent of projects) {
     if (!ent.isDirectory()) continue;
-    const candidate = join7(root, ent.name, segment);
+    const candidate = join11(root, ent.name, segment);
     if (keepDir && candidate === keepDir) continue;
     let entries;
     try {
@@ -1264,7 +1806,7 @@ async function purgeSessionArtifacts(sp, sid, header) {
   return artifacts;
 }
 async function relocateRewrittenBackup({ sid, canonical, backupLogPath, artifacts }) {
-  const original = await readFile2(backupLogPath);
+  const original = await readFile3(backupLogPath);
   const frames = scanZstdFrames(original).frames;
   if (frames.length === 0) throw new Error("\u79FB\u52A8\u524D\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u65E5\u5FD7\u6CA1\u6709\u5B8C\u6574 zstd \u5E27");
   const rewritten = rewriteFrame0CwdInMemory(original, canonical);
@@ -1274,10 +1816,10 @@ async function relocateRewrittenBackup({ sid, canonical, backupLogPath, artifact
     throw new Error("\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u4E8B\u4EF6\u5185\u5BB9\u53D1\u751F\u53D8\u5316");
   }
   const targetDir = deriveSessionDir(artifacts.root, canonical, sid);
-  await mkdir5(targetDir, { recursive: true });
-  const staged = join7(targetDir, `.move-stage-${process.pid}-${Date.now()}`);
-  await writeFile5(staged, rewritten, { mode: 384 });
-  await rename5(staged, join7(targetDir, artifacts.generationFiles[0]));
+  await mkdir9(targetDir, { recursive: true });
+  const staged = join11(targetDir, `.move-stage-${process.pid}-${Date.now()}`);
+  await writeFile9(staged, rewritten, { mode: 384 });
+  await rename8(staged, join11(targetDir, artifacts.generationFiles[0]));
   return targetDir;
 }
 async function moveSessionToCwd({ sp, sid, header, canonical, events = [], inheritedEventCount = 0 }) {
@@ -1329,11 +1871,11 @@ async function moveSessionToCwd({ sp, sid, header, canonical, events = [], inher
   const firstSeq = events.length ? Number(events[0].seq) : 0;
   const replay = firstSeq !== 0 ? events.map((event, index) => ({ ...event, seq: index })) : events;
   const createOptions = header.isSeeded && Number.isSafeInteger(inheritedEventCount) && inheritedEventCount > 0 ? { inheritedEventCount } : void 0;
-  const backupRoot = join7(dirname2(artifacts.root), "sessions-manager-move-backup");
-  const backupDir = join7(backupRoot, `${encodeSegmentFor(sid)}-${process.pid}-${Date.now()}`);
-  await mkdir5(backupRoot, { recursive: true });
-  const backupLogPath = join7(backupDir, basename2(artifacts.logPath));
-  await rename5(artifacts.sessionDir, backupDir);
+  const backupRoot = join11(dirname3(artifacts.root), "sessions-manager-move-backup");
+  const backupDir = join11(backupRoot, `${encodeSegmentFor(sid)}-${process.pid}-${Date.now()}`);
+  await mkdir9(backupRoot, { recursive: true });
+  const backupLogPath = join11(backupDir, basename2(artifacts.logPath));
+  await rename8(artifacts.sessionDir, backupDir);
   let writer = null;
   try {
     try {
@@ -1366,11 +1908,11 @@ async function moveSessionToCwd({ sp, sid, header, canonical, events = [], inher
     } catch (_) {
     }
     try {
-      await mkdir5(dirname2(artifacts.sessionDir), { recursive: true });
+      await mkdir9(dirname3(artifacts.sessionDir), { recursive: true });
     } catch (_) {
     }
     try {
-      await rename5(backupDir, artifacts.sessionDir);
+      await rename8(backupDir, artifacts.sessionDir);
     } catch (_) {
     }
     if (e && e.status) throw e;
@@ -1387,12 +1929,6 @@ async function moveSessionToCwd({ sp, sid, header, canonical, events = [], inher
 }
 
 // src/lineage.js
-var EMPTY_BASE = 190;
-function isEmptyLogSize(sizeBytes, cwd) {
-  if (!Number.isFinite(sizeBytes) || sizeBytes < 0) return false;
-  const cwdLen = typeof cwd === "string" ? cwd.length : 0;
-  return sizeBytes <= EMPTY_BASE + cwdLen;
-}
 var EMPTY_DECODE_LIMIT = 8192;
 var LIFECYCLE_EVENT_TYPES = /* @__PURE__ */ new Set([
   "session",
@@ -1407,24 +1943,26 @@ function isEmptyEventTypes(types) {
   }
   return true;
 }
-function classifyLineage(header, sizeBytes) {
+function classifyLineage(header) {
   if (!header || typeof header !== "object") return null;
   const origin = header.origin === "subagent" ? "subagent" : null;
   const parentSession = typeof header.parentSession === "string" && header.parentSession ? header.parentSession : null;
   const delegationDepth = Number.isSafeInteger(header.delegationDepth) && header.delegationDepth > 0 ? header.delegationDepth : 0;
-  const empty = isEmptyLogSize(sizeBytes, header.cwd);
-  if (!origin && !parentSession && !empty) return null;
-  return { origin, parentSession, delegationDepth, empty };
+  if (!origin && !parentSession) return null;
+  return { origin, parentSession, delegationDepth, empty: null };
+}
+function emptyScanCandidate(sizeBytes) {
+  return Number.isFinite(sizeBytes) && sizeBytes <= EMPTY_DECODE_LIMIT;
 }
 
 // src/index.js
-var BUILD_STAMP = true ? "3.6.2+e36dc3fc" : "dev";
+var BUILD_STAMP = true ? "3.7.0+95376789" : "dev";
 var name = "dsh-sessions-manager";
 var inject = ["webServer", "workspaceRegistry", "sessionPersistence", "sessionQuery", "storageDomain"];
 var MAX_TITLE = 80;
-var STATE_DIR = process.env.DSH_SESSIONS_MANAGER_STAR_DIR || join8(homedir4(), ".dsh", "sessions-manager");
-var TRASH_DIR = process.env.DSH_SESSIONS_MANAGER_TRASH_DIR || join8(homedir4(), ".dsh", "sessions-manager-trash");
-var TRASH_INDEX = join8(TRASH_DIR, "index.json");
+var STATE_DIR = process.env.DSH_SESSIONS_MANAGER_STAR_DIR || join12(homedir7(), ".dsh", "sessions-manager");
+var TRASH_DIR = process.env.DSH_SESSIONS_MANAGER_TRASH_DIR || join12(homedir7(), ".dsh", "sessions-manager-trash");
+var TRASH_INDEX = join12(TRASH_DIR, "index.json");
 var TRASH_SCHEMA_VERSION = 2;
 var DEFAULT_TRASH_SETTINGS = Object.freeze({ retentionDays: 0 });
 var FETCH_TOOL_RE = /search|fetch|download|browse/i;
@@ -1471,14 +2009,14 @@ function parseIds(body) {
   const raw = body && body.sessionIds;
   if (!Array.isArray(raw)) return null;
   const ids = [];
-  for (const v of raw) if (typeof v === "string" && isSafeSessionId2(v)) ids.push(v);
+  for (const v of raw) if (typeof v === "string" && isSafeSessionId3(v)) ids.push(v);
   return ids;
 }
-function isSafeSessionId2(value) {
+function isSafeSessionId3(value) {
   return typeof value === "string" && value.length > 0 && value.length <= 200 && !/[\\/\0]/.test(value) && value !== "." && value !== "..";
 }
 function requireSessionId(value) {
-  if (!isSafeSessionId2(value)) {
+  if (!isSafeSessionId3(value)) {
     const error = new Error("\u65E0\u6548\u7684 sessionId");
     error.status = 400;
     throw error;
@@ -1512,7 +2050,9 @@ function apply(ctx) {
   const dom = () => ctx.storageDomain.get("workspace");
   const authorityTitleCache = /* @__PURE__ */ new Map();
   const metaCache = createSessionMetaCache();
-  const titleIndex = createTitleIndexStore({ dir: TRASH_DIR, file: join8(TRASH_DIR, "title-index.json") });
+  const titleIndex = createTitleIndexStore({ dir: TRASH_DIR, file: join12(TRASH_DIR, "title-index.json") });
+  const emptyIndex = createEmptyScanStore({ dir: TRASH_DIR });
+  const EMPTY_VERDICT_TTL_MS = 14 * 24 * 3600 * 1e3;
   async function hydrateFromPersist(ids, statsById) {
     const hits = /* @__PURE__ */ new Map();
     if (!ids || !ids.length) return hits;
@@ -1824,12 +2364,12 @@ function apply(ctx) {
       schemaVersion: TRASH_SCHEMA_VERSION,
       settings: { retentionDays },
       items: raw && Array.isArray(raw.items) ? raw.items : [],
-      purgedSessionIds: raw && Array.isArray(raw.purgedSessionIds) ? [...new Set(raw.purgedSessionIds.filter(isSafeSessionId2).map(String))] : []
+      purgedSessionIds: raw && Array.isArray(raw.purgedSessionIds) ? [...new Set(raw.purgedSessionIds.filter(isSafeSessionId3).map(String))] : []
     };
   }
   async function readTrashStore() {
     try {
-      return normalizeTrashStore(JSON.parse(readFileSync4(TRASH_INDEX, "utf8")));
+      return normalizeTrashStore(JSON.parse(readFileSync7(TRASH_INDEX, "utf8")));
     } catch (e) {
       return normalizeTrashStore(null);
     }
@@ -1838,10 +2378,10 @@ function apply(ctx) {
     return (await readTrashStore()).items;
   }
   async function writeTrashStore(store) {
-    await mkdir6(TRASH_DIR, { recursive: true });
-    const tmp = join8(TRASH_DIR, `.index-${process.pid}-${Date.now()}.tmp`);
-    await writeFile6(tmp, JSON.stringify(normalizeTrashStore(store), null, 2), { encoding: "utf8", mode: 384 });
-    await rename6(tmp, TRASH_INDEX);
+    await mkdir10(TRASH_DIR, { recursive: true });
+    const tmp = join12(TRASH_DIR, `.index-${process.pid}-${Date.now()}.tmp`);
+    await writeFile10(tmp, JSON.stringify(normalizeTrashStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename9(tmp, TRASH_INDEX);
   }
   function mutateTrash(mutator) {
     const operation = trashMutation.then(async () => {
@@ -1855,7 +2395,10 @@ function apply(ctx) {
     return operation;
   }
   const stars = createStarIndex();
+  const tags = createTagIndex();
+  const savedFilters = createSavedFilters();
   const pendingMoves = createPendingMoveStore();
+  const moveNotices = createMoveNoticeStore();
   const autoArchive = createAutoArchiveStore();
   sweepStaleStateTemps([STATE_DIR, TRASH_DIR], {}).catch(() => {
   });
@@ -1868,6 +2411,15 @@ function apply(ctx) {
     } catch (e) {
     }
   }
+  async function gcTags(validIds) {
+    try {
+      const store = await tags.read();
+      const valid = new Set(validIds.map(String));
+      const gone = Object.keys(store.assignments).filter((id) => !valid.has(id));
+      if (gone.length) await tags.removeIds(gone);
+    } catch (e) {
+    }
+  }
   async function deleteOne(sid) {
     requireSessionId(sid);
     let header = null;
@@ -2120,6 +2672,10 @@ function apply(ctx) {
       await stars.removeIds([sid]);
     } catch (e) {
     }
+    try {
+      await tags.removeIds([sid]);
+    } catch (e) {
+    }
     return { ok: true, purged: true };
   }
   async function trashSettings(next) {
@@ -2155,8 +2711,8 @@ function apply(ctx) {
   async function moveTargetWorkspace(rawPath) {
     if (typeof rawPath !== "string" || !rawPath.trim()) throw new Error("\u7F3A\u5C11\u76EE\u6807\u5DE5\u4F5C\u533A\u8DEF\u5F84");
     let p = String(rawPath).trim();
-    if (p.startsWith("~/")) p = join8(homedir4(), p.slice(2));
-    if (!isAbsolute(p)) p = join8(homedir4(), p);
+    if (p.startsWith("~/")) p = join12(homedir7(), p.slice(2));
+    if (!isAbsolute(p)) p = join12(homedir7(), p);
     let canonical = null;
     try {
       canonical = await realpath(p);
@@ -2164,7 +2720,7 @@ function apply(ctx) {
       canonical = null;
     }
     if (canonical === null) {
-      await mkdir6(p, { recursive: true });
+      await mkdir10(p, { recursive: true });
       canonical = await realpath(p);
     }
     return { canonical, entity: await w.create(canonical, basename3(canonical) || "workspace") };
@@ -2209,15 +2765,15 @@ function apply(ctx) {
       const stagedPath = `${newPath}.move-stage-${process.pid}-${Date.now()}`;
       let destinationInstalled = false;
       try {
-        await mkdir6(dirname3(newPath), { recursive: true });
+        await mkdir10(dirname4(newPath), { recursive: true });
         try {
           await stat4(newPath);
           throw new Error("\u79FB\u52A8\u5931\u8D25\uFF1A\u76EE\u6807\u4F4D\u7F6E\u5DF2\u5B58\u5728\u540C\u540D\u4F1A\u8BDD\u65E5\u5FD7");
         } catch (e) {
           if (e && e.code !== "ENOENT") throw e;
         }
-        await rename6(oldPath, backupPath);
-        const original = await readFile3(backupPath);
+        await rename9(oldPath, backupPath);
+        const original = await readFile4(backupPath);
         const originalFrames = scanZstdFrames(original).frames;
         if (originalFrames.length === 0) throw new Error("\u79FB\u52A8\u524D\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u65E5\u5FD7\u6CA1\u6709\u5B8C\u6574 zstd \u5E27");
         const rewritten = rewriteFrame0CwdInMemory(original, canonical);
@@ -2226,11 +2782,11 @@ function apply(ctx) {
         const originalTail = original.subarray(originalFrames[0].end);
         const rewrittenTail = rewritten.subarray(rewrittenFrames[0].end);
         if (!originalTail.equals(rewrittenTail)) throw new Error("\u79FB\u52A8\u540E\u6821\u9A8C\u5931\u8D25\uFF1A\u4F1A\u8BDD\u4E8B\u4EF6\u5185\u5BB9\u53D1\u751F\u53D8\u5316");
-        await writeFile6(stagedPath, rewritten, { mode: 384 });
-        await rename6(stagedPath, newPath);
+        await writeFile10(stagedPath, rewritten, { mode: 384 });
+        await rename9(stagedPath, newPath);
         destinationInstalled = true;
         await unlink(backupPath);
-        const keptInSource = await cleanupMovedSourceDir(dirname3(oldPath));
+        const keptInSource = await cleanupMovedSourceDir(dirname4(oldPath));
         if (keptInSource.length > 0) moveNotes.push(`\u6E90\u76EE\u5F55\u672A\u80FD\u6E05\u7406\u5E72\u51C0\uFF08\u6B8B\u7559 ${keptInSource.join("\u3001")}\uFF09\uFF0C\u82E5\u540E\u7EED\u79FB\u52A8\u62A5\u201Cduplicate\u201D\u8BF7\u624B\u52A8\u6E05\u7A7A\u8BE5\u76EE\u5F55\u3002`);
       } catch (e) {
         try {
@@ -2244,7 +2800,7 @@ function apply(ctx) {
           }
         }
         try {
-          await rename6(backupPath, oldPath);
+          await rename9(backupPath, oldPath);
         } catch (_) {
         }
         if (e && e.code !== "ENOENT") throw e;
@@ -2324,7 +2880,7 @@ function apply(ctx) {
         const backupPath = oldPath ? `${oldPath}.move-backup-${Date.now()}` : null;
         if (backupPath) {
           try {
-            await rename6(oldPath, backupPath);
+            await rename9(oldPath, backupPath);
           } catch (e) {
             if (e && e.code !== "ENOENT") throw new Error("\u79FB\u52A8\u5931\u8D25\uFF1A\u65E0\u6CD5\u5907\u4EFD\u65E7\u7684\u4F1A\u8BDD\u65E5\u5FD7");
           }
@@ -2332,7 +2888,7 @@ function apply(ctx) {
         const restore = async () => {
           if (backupPath) {
             try {
-              await rename6(backupPath, oldPath);
+              await rename9(backupPath, oldPath);
             } catch (_) {
             }
           }
@@ -2351,7 +2907,7 @@ function apply(ctx) {
             }
           }
           if (oldPath) {
-            const keptInSource = await cleanupMovedSourceDir(dirname3(oldPath));
+            const keptInSource = await cleanupMovedSourceDir(dirname4(oldPath));
             if (keptInSource.length > 0) moveNotes.push(`\u6E90\u76EE\u5F55\u672A\u80FD\u6E05\u7406\u5E72\u51C0\uFF08\u6B8B\u7559 ${keptInSource.join("\u3001")}\uFF09\uFF0C\u82E5\u540E\u7EED\u79FB\u52A8\u62A5\u201Cduplicate\u201D\u8BF7\u624B\u52A8\u6E05\u7A7A\u8BE5\u76EE\u5F55\u3002`);
           }
         } catch (e) {
@@ -2434,11 +2990,21 @@ function apply(ctx) {
           metaCache.invalidate(item.sessionId);
           moved++;
           notes.push(`\u6392\u961F\u4E2D\u7684\u79FB\u52A8\u5DF2\u5B8C\u6210\uFF1A${String(item.sessionId).slice(0, 18)}\u2026`);
+          try {
+            await moveNotices.append({ kind: "moved", sessionId: item.sessionId, targetPath: item.targetPath, at: Date.now() });
+          } catch (e) {
+          }
         } catch (e) {
           if (isBusyError(e)) continue;
           if (Date.now() - bootedAt < BOOT_WARMUP_MS) continue;
           const bumped = await pendingMoves.bumpAttempts(item.sessionId);
-          if (bumped && bumped.dropped) notes.push(`\u6392\u961F\u4E2D\u7684\u79FB\u52A8\u591A\u6B21\u5931\u8D25\u5DF2\u653E\u5F03\uFF1A${String(item.sessionId).slice(0, 18)}\u2026\uFF08${String(e && e.message || e)}\uFF09`);
+          if (bumped && bumped.dropped) {
+            notes.push(`\u6392\u961F\u4E2D\u7684\u79FB\u52A8\u591A\u6B21\u5931\u8D25\u5DF2\u653E\u5F03\uFF1A${String(item.sessionId).slice(0, 18)}\u2026\uFF08${String(e && e.message || e)}\uFF09`);
+            try {
+              await moveNotices.append({ kind: "abandoned", sessionId: item.sessionId, targetPath: item.targetPath, at: Date.now(), attempts: bumped.attempts, reason: String(e && e.message || e).split("\n")[0] });
+            } catch (err) {
+            }
+          }
         }
       }
       if (moved > 0) {
@@ -2657,12 +3223,23 @@ function apply(ctx) {
       return { items: archivedItems, usage };
     }
     let starredSet = /* @__PURE__ */ new Set();
+    let tagIdsBySession = /* @__PURE__ */ new Map();
     try {
       starredSet = new Set((await stars.read()).starredSessionIds);
+      const tagStore = await tags.read();
+      const knownTagIds = new Set(tagStore.tags.map((t) => t.id));
+      for (const [sid, list] of Object.entries(tagStore.assignments)) {
+        const kept = list.filter((id) => knownTagIds.has(id));
+        if (kept.length) tagIdsBySession.set(sid, kept);
+      }
     } catch (e) {
     }
-    for (const it of items) it.starred = starredSet.has(String(it.sessionId));
+    for (const it of items) {
+      it.starred = starredSet.has(String(it.sessionId));
+      it.tags = tagIdsBySession.get(String(it.sessionId)) || [];
+    }
     if (headersOk) await gcStars(ids);
+    if (headersOk) await gcTags(ids);
     return { items, usage };
   }
   async function allSessionItems(opts = {}) {
@@ -2757,69 +3334,121 @@ function apply(ctx) {
       }
     }
     const lineage = {};
+    const refineWanted = [];
+    let emptyStore = null;
+    try {
+      emptyStore = await emptyIndex.entries();
+    } catch (e) {
+      emptyStore = null;
+    }
+    const nowTs = Date.now();
     for (const entry of entries) {
-      const info = classifyLineage(entry.header, entry.sizeBytes);
-      if (info) lineage[entry.id] = info;
+      const id = String(entry.id);
+      const size = entry && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null;
+      const candidate = emptyScanCandidate(size);
+      let verdict = null;
+      if (!candidate) {
+        if (size !== null) verdict = false;
+      } else {
+        const mem = emptyScanCache.get(id);
+        if (mem && mem.sizeBytes === size) {
+          verdict = !!mem.empty;
+        } else {
+          const rec = emptyStore && emptyStore[id];
+          if (rec && rec.fingerprint === `sz:${size}` && nowTs - (rec.updatedAt || 0) <= EMPTY_VERDICT_TTL_MS) {
+            verdict = rec.empty === 1;
+            emptyScanCache.set(id, { sizeBytes: size, empty: verdict });
+          }
+        }
+        if (verdict === null && refineCapable() && !refineQueue.has(id)) refineWanted.push({ id, sizeBytes: size });
+      }
+      const info = classifyLineage(entry.header);
+      if (info) lineage[id] = { origin: info.origin, parentSession: info.parentSession, delegationDepth: info.delegationDepth, empty: verdict };
+      else if (verdict === true) lineage[id] = { origin: null, parentSession: null, delegationDepth: 0, empty: true };
     }
-    await refineEmptyLineage(lineage, entries);
-    return {
+    enqueueRefine(refineWanted);
+    for (const key of emptyScanCache.keys()) {
+      const rec = emptyScanCache.get(key);
+      if (!rec || !emptyScanCandidate(rec.sizeBytes)) emptyScanCache.delete(key);
+    }
+    const payload = {
       titles: Object.fromEntries(authorityTitleCache),
       trashedSessionIds: store.items.map((item) => String(item.sessionId)),
       purgedSessionIds: activeTombstones,
       lineage,
       // v3.6.2：还有预热/退避重试在途 → client 缩短轮询节拍，预热一完成就把
       // 补齐的标题送回（含面板自动刷新）。无预热 API 时恒 false，绝不假忙。
-      warmPending: warmPendingNow()
+      warmPending: warmPendingNow(),
+      // T1：空白精判后台队列是否还有活。无精判能力（旧 runtime 无 inspect 通道）
+      // 时恒 false——永久 busy 会让 client 疯轮询，这是唯一现实的假忙陷阱。
+      refinePending: refinePendingNow()
     };
+    try {
+      const noticeRows = await moveNotices.list();
+      if (noticeRows.length) payload.moveNotices = noticeRows;
+    } catch (e) {
+    }
+    return payload;
   }
   const emptyScanCache = /* @__PURE__ */ new Map();
-  const REFINE_BUDGET = 40;
-  function applyEmptyScan(lineage, id, empty) {
-    if (empty) {
-      const info = lineage[id] || (lineage[id] = { origin: null, parentSession: null, delegationDepth: 0, empty: false });
-      info.empty = true;
-    } else if (lineage[id]) {
-      const info = lineage[id];
-      info.empty = false;
-      if (!info.origin && !info.parentSession) delete lineage[id];
-    }
-  }
-  async function refineEmptyLineage(lineage, entries) {
-    if (!persistence || typeof persistence.inspectSession !== "function") return;
-    const limiter = createLimiter(4);
-    const todo = [];
-    for (const entry of entries) {
-      const size = entry && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null;
-      if (size === null || size > EMPTY_DECODE_LIMIT) continue;
-      const id = String(entry.id);
-      const scanned = emptyScanCache.get(id);
-      if (scanned && scanned.sizeBytes === size) {
-        applyEmptyScan(lineage, id, scanned.empty);
-        continue;
-      }
-      if (todo.length < REFINE_BUDGET) todo.push({ id, size });
+  const REFINE_CHUNK = 2;
+  const refineQueue = /* @__PURE__ */ new Map();
+  let refineRunning = false;
+  let refineKickTimer = null;
+  function refineCapable() {
+    return !!persistence && typeof persistence.inspectSession === "function";
+  }
+  function refinePendingNow() {
+    return !!(refineRunning || refineQueue.size);
+  }
+  function scheduleRefine() {
+    if (refineKickTimer || refineRunning || !refineQueue.size) return;
+    refineKickTimer = setTimeout(() => {
+      refineKickTimer = null;
+      runRefine();
+    }, 25);
+    if (typeof refineKickTimer.unref === "function") refineKickTimer.unref();
+  }
+  function enqueueRefine(items) {
+    if (!items || !items.length || !refineCapable()) return;
+    for (const { id, sizeBytes } of items) {
+      if (emptyScanCache.has(id) && emptyScanCache.get(id).sizeBytes === sizeBytes) continue;
+      refineQueue.set(id, { sizeBytes });
     }
-    await Promise.all(todo.map(({ id, size }) => limiter(async () => {
-      let isEmpty = false;
-      try {
-        const types = [];
-        await persistence.inspectSession(id, { onEvents: (batch) => {
-          for (const ev of batch || []) if (types.length < 64) types.push(ev && ev.type);
-        } });
-        isEmpty = isEmptyEventTypes(types);
-      } catch (e) {
-        isEmpty = false;
+    scheduleRefine();
+  }
+  async function runRefine() {
+    if (refineRunning) return;
+    refineRunning = true;
+    try {
+      while (refineQueue.size) {
+        const batch = [...refineQueue.entries()].slice(0, REFINE_CHUNK);
+        for (const [id] of batch) refineQueue.delete(id);
+        const persistBatch = {};
+        for (const [id, desc] of batch) {
+          try {
+            const types = [];
+            await persistence.inspectSession(id, { onEvents: (b) => {
+              for (const ev of b || []) if (types.length < 64) types.push(ev && ev.type);
+            } });
+            const isEmpty = isEmptyEventTypes(types);
+            emptyScanCache.set(id, { sizeBytes: desc.sizeBytes, empty: isEmpty });
+            persistBatch[id] = { empty: isEmpty ? 1 : 0, fingerprint: `sz:${desc.sizeBytes}`, updatedAt: Date.now() };
+          } catch (e) {
+            emptyScanCache.set(id, { sizeBytes: desc.sizeBytes, empty: false });
+          }
+        }
+        if (Object.keys(persistBatch).length) {
+          try {
+            await emptyIndex.merge(persistBatch);
+          } catch (e) {
+          }
+        }
+        await new Promise((resolve) => setImmediate(resolve));
       }
-      emptyScanCache.set(id, { sizeBytes: size, empty: isEmpty });
-      applyEmptyScan(lineage, id, isEmpty);
-    })));
-    const live = /* @__PURE__ */ new Set();
-    for (const entry of entries) {
-      const size = entry && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null;
-      if (size !== null && size <= EMPTY_DECODE_LIMIT) live.add(String(entry.id));
-    }
-    for (const key of emptyScanCache.keys()) {
-      if (!live.has(key)) emptyScanCache.delete(key);
+    } finally {
+      refineRunning = false;
+      if (refineQueue.size) scheduleRefine();
     }
   }
   async function buildDetails(sid, signal) {
@@ -3175,6 +3804,10 @@ function apply(ctx) {
             await titleIndex.remove([sid]);
           } catch (e) {
           }
+          try {
+            await emptyIndex.remove([sid]);
+          } catch (e) {
+          }
           json(res, out);
         } catch (e) {
           json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
@@ -3196,6 +3829,8 @@ function apply(ctx) {
               metaCache.invalidate(sid);
               await titleIndex.remove([sid]).catch(() => {
               });
+              await emptyIndex.remove([sid]).catch(() => {
+              });
             } catch (e) {
               results.push({ sessionId: sid, ok: false, error: String(e && e.message || e) });
             }
@@ -3211,7 +3846,7 @@ function apply(ctx) {
       path: "/archived-sessions/sessions",
       handler: async (req, res) => {
         try {
-          json(res, { items: await allSessionItems(), warmPending: warmPendingNow() });
+          json(res, { items: await allSessionItems({ usage: true }), warmPending: warmPendingNow() });
         } catch (e) {
           json(res, { error: String(e && e.message || e) }, 500);
         }
@@ -3226,13 +3861,133 @@ function apply(ctx) {
           const starred = !!(body && body.starred);
           let ids = parseIds(body);
           if ((!ids || ids.length === 0) && body && typeof body.sessionId === "string") {
-            ids = isSafeSessionId2(body.sessionId) ? [body.sessionId] : null;
+            ids = isSafeSessionId3(body.sessionId) ? [body.sessionId] : null;
           }
-          if (!ids || ids.length === 0) return json(res, { ok: false, error: "missing sessionId" }, 400);
+          if (!ids || ids.length === 0) return json(res, { ok: false, code: "DSM_STAR_SESSION_INVALID", error: "missing sessionId" }, 400);
           const starredSessionIds = await stars.setStarred(ids, starred);
           json(res, { ok: true, starredSessionIds });
         } catch (e) {
-          json(res, { ok: false, error: String(e && e.message || e) }, errorStatus(e));
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/tags/list",
+      handler: async (req, res) => {
+        try {
+          const { tags: tagList, assignments } = await tags.list();
+          json(res, { ok: true, tags: tagList, assignments });
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/tags/create",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          const tag = await tags.create(body && body.name);
+          json(res, { ok: true, tag });
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/tags/rename",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          await tags.rename(body && body.id, body && body.name);
+          json(res, { ok: true });
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/tags/merge",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          await tags.merge(body && body.fromId, body && body.toId);
+          json(res, { ok: true });
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/tags/delete",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          await tags.removeTag(body && body.id);
+          json(res, { ok: true });
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/tags/set",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          const sid = body && body.sessionId;
+          if (!isSafeSessionId3(sid)) {
+            return json(res, { ok: false, code: "DSM_TAG_SESSION_INVALID", error: "missing/invalid sessionId" }, 400);
+          }
+          const assignments = await tags.setTags(sid, body && body.tagIds);
+          json(res, { ok: true, assignments });
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/filters/list",
+      handler: async (req, res) => {
+        try {
+          json(res, { ok: true, items: await savedFilters.list() });
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/filters/save",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          const item = await savedFilters.save(body && body.name, body && body.filters);
+          json(res, { ok: true, item });
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/filters/delete",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          const ids = body && Array.isArray(body.ids) ? body.ids : null;
+          if (!ids || ids.length === 0) return json(res, { ok: false, code: "DSM_FILTER_IDS_INVALID", error: "missing ids" }, 400);
+          const removed = await savedFilters.remove(ids);
+          json(res, { ok: true, removed });
+        } catch (e) {
+          json(res, { ok: false, code: e && e.code, error: String(e && e.message || e) }, errorStatus(e));
         }
       }
     }));
@@ -3291,7 +4046,7 @@ function apply(ctx) {
         try {
           const body = await readJsonBody(req);
           const rootId = body && typeof body.sessionId === "string" ? body.sessionId : "";
-          if (!rootId || !isSafeSessionId2(rootId)) return json(res, { error: "missing sessionId" }, 400);
+          if (!rootId || !isSafeSessionId3(rootId)) return json(res, { error: "missing sessionId" }, 400);
           const headerById = /* @__PURE__ */ new Map();
           const sizeById = /* @__PURE__ */ new Map();
           const trashedIds = /* @__PURE__ */ new Set();
@@ -3503,6 +4258,21 @@ function apply(ctx) {
         }
       }
     }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/pending-moves/notices/ack",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          const ids = body && Array.isArray(body.ids) ? body.ids : null;
+          if (!ids || !ids.length) return json(res, { ok: false, error: "missing ids" }, 400);
+          const removed = await moveNotices.ack(ids);
+          json(res, { ok: true, removed });
+        } catch (e) {
+          json(res, { ok: false, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
     disposers.push(ctx.webServer.register({
       kind: "exact",
       path: "/archived-sessions/archive",