dsh-sessions-manager 3.6.1 → 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,9 +1142,9 @@ 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";
-var TITLE_INDEX_SCHEMA_VERSION = 1;
+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) {
   if (!raw || typeof raw !== "object") return null;
@@ -711,9 +1153,13 @@ function normalizeEntry(raw) {
   const createdAt = typeof raw.createdAt === "number" ? raw.createdAt : null;
   const fingerprint = typeof raw.fingerprint === "string" && raw.fingerprint ? raw.fingerprint : null;
   const updatedAt = typeof raw.updatedAt === "number" ? raw.updatedAt : 0;
+  const resolved = raw.resolved === true || raw.resolved === 1;
   if (!fingerprint || fingerprint.startsWith("rev:")) return null;
   if (!title && !cwd) return null;
-  return { title, cwd, createdAt, fingerprint, updatedAt };
+  if (!title && !resolved) return null;
+  const entry = { title, cwd, createdAt, fingerprint, updatedAt };
+  if (resolved) entry.resolved = 1;
+  return entry;
 }
 function normalizeTitleIndex(raw) {
   const entries = {};
@@ -739,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")));
@@ -774,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;
@@ -794,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;
     }
@@ -806,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) {
@@ -879,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);
@@ -907,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,
@@ -1121,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)-/;
@@ -1145,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 {
@@ -1260,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);
@@ -1270,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 }) {
@@ -1325,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 {
@@ -1362,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;
@@ -1383,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",
@@ -1403,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.1+f0814a9e" : "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;
@@ -1467,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;
@@ -1499,20 +2041,6 @@ function getActiveSessionId(context) {
   }
   return null;
 }
-function foldTitle(events) {
-  let found = null;
-  let firstUser = null;
-  for (const ev of events) {
-    if (ev.type === "session/title" && ev.data && typeof ev.data.title === "string" && ev.data.title.length) {
-      found = ev.data.title;
-    }
-    if (firstUser === null && ev.type === "user/message" && ev.data && Array.isArray(ev.data.content)) {
-      const txt = ev.data.content.filter((b) => b && b.type === "text").map((b) => b.text).filter(Boolean).join(" ").trim();
-      if (txt) firstUser = txt;
-    }
-  }
-  return found || firstUser || null;
-}
 function apply(ctx) {
   const w = ctx.workspaceRegistry;
   const sp = ctx.sessionPersistence;
@@ -1522,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;
@@ -1538,7 +2068,7 @@ function apply(ctx) {
       if (!stat5 || !entry) continue;
       const fp = persistFingerprintOf(stat5);
       if (!fp) continue;
-      if (fp && entry.fingerprint === fp) {
+      if (entry.fingerprint === fp && (entry.title || entry.resolved)) {
         hits.set(id, { title: entry.title, cwd: entry.cwd, createdAt: entry.createdAt });
       }
     }
@@ -1548,10 +2078,12 @@ function apply(ctx) {
     if (!decoded || !decoded.size) return;
     const batch = {};
     const now = Date.now();
-    for (const [id, meta] of decoded) {
+    for (const [id, pack] of decoded) {
+      if (!pack || !pack.resolved) continue;
+      const meta = pack.meta;
       const fp = persistFingerprintOf(statsById.get(id));
       if (!fp) continue;
-      batch[id] = { title: meta.title, cwd: meta.cwd, createdAt: meta.createdAt, fingerprint: fp, updatedAt: now };
+      batch[id] = { title: meta.title, cwd: meta.cwd, createdAt: meta.createdAt, fingerprint: fp, updatedAt: now, resolved: 1 };
     }
     if (!Object.keys(batch).length) return;
     try {
@@ -1634,6 +2166,60 @@ function apply(ctx) {
   const warmQueue = /* @__PURE__ */ new Map();
   let warmRunning = false;
   let warmKickTimer = null;
+  const WARM_MAX_ATTEMPTS = 5;
+  const warmFail = /* @__PURE__ */ new Map();
+  function warmFpOf(stat5) {
+    return fingerprintOf(stat5) || persistFingerprintOf(stat5);
+  }
+  function warmBlocked(id, fp) {
+    const rec = warmFail.get(id);
+    if (!rec) return 0;
+    if (fp && rec.fp && rec.fp !== fp) {
+      warmFail.delete(id);
+      return 0;
+    }
+    const now = Date.now();
+    return rec.nextAt > now ? rec.nextAt - now : 0;
+  }
+  function warmMarkFailure(id, stat5, header) {
+    const rec = warmFail.get(id) || { count: 0, fp: null, nextAt: 0 };
+    rec.count += 1;
+    rec.fp = warmFpOf(stat5) || rec.fp;
+    if (stat5) rec.stat = stat5;
+    if (header) rec.header = header;
+    const backoff = rec.count >= WARM_MAX_ATTEMPTS ? 60 * 60 * 1e3 : Math.min(5 * 60 * 1e3, 15 * 1e3 * Math.pow(2, rec.count));
+    rec.nextAt = Date.now() + backoff;
+    warmFail.set(id, rec);
+  }
+  function warmPendingNow() {
+    if (!warmHasApi) return false;
+    if (warmRunning || warmQueue.size) return true;
+    for (const rec of warmFail.values()) if (rec.nextAt > Date.now()) return true;
+    return false;
+  }
+  let warmRetryTimer = null;
+  function scheduleWarmRetry() {
+    if (warmRetryTimer) return;
+    let soonest = 0;
+    for (const rec of warmFail.values()) {
+      const wait = rec.nextAt - Date.now();
+      if (wait <= 0) {
+        soonest = 1;
+        break;
+      }
+      if (!soonest || wait < soonest) soonest = wait;
+    }
+    if (!soonest) return;
+    warmRetryTimer = setTimeout(() => {
+      warmRetryTimer = null;
+      const now = Date.now();
+      for (const [id, rec] of warmFail) {
+        if (rec.nextAt <= now && !warmQueue.has(id)) warmQueue.set(id, { stat: rec.stat || null, header: rec.header || null });
+      }
+      if (warmQueue.size) scheduleWarm();
+    }, soonest);
+    if (typeof warmRetryTimer.unref === "function") warmRetryTimer.unref();
+  }
   function scheduleWarm() {
     if (warmKickTimer || warmRunning) return;
     warmKickTimer = setTimeout(() => {
@@ -1644,15 +2230,44 @@ function apply(ctx) {
   }
   function enqueueWarm(ids, statsById, entryById) {
     if (!ids || !ids.length) return;
+    if (!warmHasApi) return;
     for (const id of ids) {
       const key = String(id);
+      const stat5 = statsById ? statsById.get(key) || null : null;
+      const fp = warmFpOf(stat5);
+      if (!fp) continue;
+      const blockedMs = warmBlocked(key, fp);
       const entry = entryById ? entryById.get(key) : null;
+      const rec = warmFail.get(key);
+      if (rec) {
+        rec.stat = stat5 || rec.stat;
+        if (entry) rec.header = entry.header || rec.header;
+      }
+      if (blockedMs > 0) continue;
       warmQueue.set(key, {
-        stat: statsById ? statsById.get(key) || null : null,
+        stat: stat5,
         header: entry && entry.header || null
       });
     }
-    scheduleWarm();
+    if (warmQueue.size) scheduleWarm();
+    scheduleWarmRetry();
+  }
+  async function backfillTrashTitles(decoded) {
+    if (!decoded || !decoded.size) return;
+    try {
+      const items = await readTrash();
+      const worth = items.some((t) => !t.title && decoded.get(String(t.sessionId)) && decoded.get(String(t.sessionId)).meta && decoded.get(String(t.sessionId)).meta.title);
+      if (!worth) return;
+      await mutateTrash((store) => {
+        for (const item of store.items) {
+          if (item.title) continue;
+          const pack = decoded.get(String(item.sessionId));
+          const t = pack && pack.meta && pack.meta.title;
+          if (t) item.title = String(t);
+        }
+      });
+    } catch (e) {
+    }
   }
   async function runWarm() {
     if (warmRunning) return;
@@ -1663,21 +2278,27 @@ function apply(ctx) {
         for (const [id] of batch) warmQueue.delete(id);
         try {
           const ids = batch.map(([id]) => id);
-          const snapshotById = await projectTitles(ids);
+          const resultById = await projectTitlesStatus(ids);
           const decoded = /* @__PURE__ */ new Map();
           const statsById = /* @__PURE__ */ new Map();
           for (const [id, desc] of batch) {
-            const snapshot = snapshotById.has(id) ? snapshotById.get(id) : null;
-            const meta = metaFromSnapshot(snapshot);
+            const r = resultById.get(id);
+            if (!r || !r.resolved) {
+              warmMarkFailure(id, desc.stat, desc.header);
+              continue;
+            }
+            warmFail.delete(id);
+            const meta = metaFromSnapshot(r.snapshot || null);
             if (desc.header) {
               if (typeof desc.header.cwd === "string") meta.cwd = desc.header.cwd;
               if (desc.header.createdAt != null) meta.createdAt = desc.header.createdAt;
             }
             metaCache.set(id, desc.stat, meta);
             statsById.set(id, desc.stat);
-            if (desc.stat) decoded.set(id, meta);
+            decoded.set(id, { meta, resolved: true });
           }
           await persistDecoded(decoded, statsById);
+          await backfillTrashTitles(decoded);
         } catch (e) {
         }
         await new Promise((resolve) => setImmediate(resolve));
@@ -1685,6 +2306,7 @@ function apply(ctx) {
     } finally {
       warmRunning = false;
       if (warmQueue.size) scheduleWarm();
+      scheduleWarmRetry();
     }
   }
   async function collectUsage(preloadedEntries) {
@@ -1742,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);
     }
@@ -1756,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 () => {
@@ -1773,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(() => {
   });
@@ -1786,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;
@@ -1804,30 +2438,19 @@ function apply(ctx) {
         cwd = header.cwd || null;
         title = header.title || header.meta && header.meta.title || null;
       }
-      if (!title) {
-        if (typeof sq.readTitleSnapshot === "function") {
-          try {
-            const snap = unwrapSnapshot(await sq.readTitleSnapshot(sid));
-            if (snap && snap.title && snap.title.title) title = String(snap.title.title);
-            if (snap && snap.session) {
-              if (!cwd) cwd = snap.session.cwd || null;
-            }
-          } catch (e) {
-          }
-        }
-      }
       if (!title) {
         try {
-          let folded = null;
-          const summary = await persistence.inspectSession(sid, {
-            onEvents: (events) => {
-              if (!folded) folded = foldTitle(events);
-            }
-          });
-          if (summary && summary.meta && !cwd) cwd = summary.meta.cwd || null;
-          title = folded;
+          const delStat = persistenceEntry && typeof persistenceEntry.revision === "string" && persistenceEntry.revision ? { revision: persistenceEntry.revision, sizeBytes: Number.isFinite(persistenceEntry.sizeBytes) ? Number(persistenceEntry.sizeBytes) : void 0 } : removedPath ? await stat4(removedPath).then((st) => ({ mtimeMs: st.mtimeMs, size: st.size })) : null;
+          if (delStat) {
+            const m = metaCache.get(sid, delStat) || (await hydrateFromPersist([sid], /* @__PURE__ */ new Map([[sid, delStat]]))).get(sid);
+            if (m && m.title) title = String(m.title);
+          }
         } catch (e) {
         }
+        if (!title) {
+          const at = authorityTitleCache.get(sid);
+          if (at) title = String(at);
+        }
       }
     } catch (e) {
     }
@@ -1839,8 +2462,10 @@ function apply(ctx) {
     const archived = await mutateArchived((list) => ({ next: null, value: list.includes(sid) })).catch(() => false);
     await mutateTrash((store) => {
       const entry = {
+        // v3.6.2 #7：不再把 cwd/裸 id 冒充标题永久定格——存 null，预热解出后
+        // backfillTrashTitles 补写；渲染端（t.title || t.sessionId）自然降级。
         sessionId: sid,
-        title: title || cwd || sid,
+        title: title || null,
         cwd: cwd || null,
         header: header || null,
         originalPath: removedPath || null,
@@ -2047,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) {
@@ -2082,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);
@@ -2091,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") };
@@ -2136,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);
@@ -2153,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 {
@@ -2171,7 +2800,7 @@ function apply(ctx) {
           }
         }
         try {
-          await rename6(backupPath, oldPath);
+          await rename9(backupPath, oldPath);
         } catch (_) {
         }
         if (e && e.code !== "ENOENT") throw e;
@@ -2251,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");
           }
@@ -2259,7 +2888,7 @@ function apply(ctx) {
         const restore = async () => {
           if (backupPath) {
             try {
-              await rename6(backupPath, oldPath);
+              await rename9(backupPath, oldPath);
             } catch (_) {
             }
           }
@@ -2278,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) {
@@ -2361,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) {
@@ -2455,19 +3094,50 @@ function apply(ctx) {
       return { next: null, value: { ok: true, archived: true } };
     });
   }
-  async function projectTitles(ids) {
+  const warmHasApi = typeof sq.readTitleSnapshots === "function" || typeof sq.readTitleSnapshot === "function";
+  async function projectTitlesStatus(ids) {
     const out = /* @__PURE__ */ new Map();
+    const markAll = (resolved) => {
+      for (const id of ids) out.set(String(id), { resolved, snapshot: null });
+    };
     if (!ids || !ids.length) return out;
-    if (typeof sq.readTitleSnapshots !== "function") return out;
-    try {
-      const results = await sq.readTitleSnapshots(ids);
-      if (!Array.isArray(results)) return out;
-      results.forEach((result, index) => {
-        const id = String(ids[index]);
-        out.set(id, unwrapSnapshot(result));
-      });
-    } catch (e) {
+    if (!warmHasApi) {
+      markAll(false);
+      return out;
+    }
+    if (typeof sq.readTitleSnapshots === "function") {
+      let results = null;
+      try {
+        results = await sq.readTitleSnapshots(ids);
+      } catch (e) {
+        results = null;
+      }
+      if (Array.isArray(results)) {
+        results.forEach((result, index) => {
+          const id = String(ids[index]);
+          if (result && result.status === "fulfilled") out.set(id, { resolved: true, snapshot: unwrapSnapshot(result) });
+          else if (result && result.status === "rejected") out.set(id, { resolved: false, snapshot: null });
+          else if (result) out.set(id, { resolved: true, snapshot: unwrapSnapshot(result) });
+          else out.set(id, { resolved: false, snapshot: null });
+        });
+        for (const id of ids) if (!out.has(String(id))) out.set(String(id), { resolved: false, snapshot: null });
+        return out;
+      }
     }
+    if (typeof sq.readTitleSnapshot === "function") {
+      for (const raw of ids) {
+        const id = String(raw);
+        try {
+          const r = await sq.readTitleSnapshot(id);
+          if (r && r.status === "rejected") out.set(id, { resolved: false, snapshot: null });
+          else out.set(id, { resolved: true, snapshot: unwrapSnapshot(r) });
+        } catch (e) {
+          out.set(id, { resolved: false, snapshot: null });
+        }
+      }
+      return out;
+    }
+    markAll(false);
     return out;
   }
   async function allSessionItemsDetailed(opts = {}) {
@@ -2553,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 = {}) {
@@ -2653,56 +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
+      lineage,
+      // v3.6.2：还有预热/退避重试在途 → client 缩短轮询节拍，预热一完成就把
+      // 补齐的标题送回（含面板自动刷新）。无预热 API 时恒 false，绝不假忙。
+      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();
-  async function refineEmptyLineage(lineage, entries) {
-    if (!persistence || typeof persistence.inspectSession !== "function") return;
-    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);
-      let scanned = emptyScanCache.get(id);
-      if (!scanned || scanned.sizeBytes !== size) {
-        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;
+  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 });
+    }
+    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 });
+          }
         }
-        scanned = { sizeBytes: size, empty: isEmpty };
-        emptyScanCache.set(id, scanned);
-      }
-      if (scanned.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];
+        if (Object.keys(persistBatch).length) {
+          try {
+            await emptyIndex.merge(persistBatch);
+          } catch (e) {
+          }
+        }
+        await new Promise((resolve) => setImmediate(resolve));
       }
-    }
-    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) {
@@ -3058,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));
@@ -3079,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) });
             }
@@ -3094,7 +3846,7 @@ function apply(ctx) {
       path: "/archived-sessions/sessions",
       handler: async (req, res) => {
         try {
-          json(res, { items: await allSessionItems() });
+          json(res, { items: await allSessionItems({ usage: true }), warmPending: warmPendingNow() });
         } catch (e) {
           json(res, { error: String(e && e.message || e) }, 500);
         }
@@ -3109,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));
         }
       }
     }));
@@ -3174,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();
@@ -3198,9 +4070,18 @@ function apply(ctx) {
             });
             if (Number.isFinite(sizeBytes)) sizeById.set(id, sizeBytes);
           };
+          const lineageStats = /* @__PURE__ */ new Map();
+          const lineageHeaders = /* @__PURE__ */ new Map();
           try {
             for (const entry of await persistence.listEntries()) {
               addHeader(entry.header, entry.sizeBytes);
+              const eid = entry && entry.id != null ? String(entry.id) : null;
+              if (eid) {
+                lineageHeaders.set(eid, { header: entry && entry.header || null });
+                if (entry && typeof entry.revision === "string" && entry.revision) {
+                  lineageStats.set(eid, Number.isFinite(entry.sizeBytes) ? { revision: entry.revision, sizeBytes: Number(entry.sizeBytes) } : { revision: entry.revision });
+                }
+              }
               if (entry && entry.id != null) persistedIds.add(String(entry.id));
             }
           } catch (e) {
@@ -3252,11 +4133,17 @@ function apply(ctx) {
             n.children.forEach(walk);
           };
           nodes.forEach(walk);
-          const titles = await projectTitles(allIds);
+          const lineageIds = allIds.map(String);
+          const { cached: lineageCached, missing: lineageMissing } = metaCache.partition(lineageIds, lineageStats);
+          const lineagePersisted = await hydrateFromPersist(lineageMissing, lineageStats);
+          for (const [id, meta] of lineagePersisted) metaCache.set(id, lineageStats.get(id), meta);
+          const lineageRest = lineageMissing.filter((id) => !lineagePersisted.has(id));
+          if (lineageRest.length) enqueueWarm(lineageRest, lineageStats, lineageHeaders);
+          const truncateTitle = (t) => t ? t.length > MAX_TITLE ? t.slice(0, MAX_TITLE) + "\u2026" : t : null;
           const titleOf = (id) => {
-            const snap = titles.get(id);
-            const m = snap ? metaFromSnapshot(snap) : null;
-            return m && m.title || null;
+            const key = String(id);
+            const m = lineageCached.get(key) || lineagePersisted.get(key);
+            return truncateTitle(m && m.title || authorityTitleCache.get(key) || null);
           };
           const fill = (n) => {
             n.title = titleOf(n.sessionId);
@@ -3371,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",