@mingmaple/dsh-handover 0.9.13 → 0.9.22

package/src/lib/scaffold.mjs

@@ -20,6 +20,7 @@ const DEFAULT_ROOT_NAME = '_Workspace';
 const DIRS = [
   '_Control_Center/records',
   '_Control_Center/rules',
+  '_Control_Center/standards',
   '_Control_Center/templates',
   '_Control_Center/tools',
   '_Control_Center/user',
@@ -35,6 +36,8 @@ const FILES = [
   ['_Control_Center/records/Global_Changelog.md', 'Changelog.skeleton.md'],
   ['_Control_Center/rules/Workspace_Charter.md', 'Charter.skeleton.md'],
   ['_Control_Center/templates/Prompt_Templates.md', 'Prompt_Templates.md'],
+  // 通用规范：一条规范一个子目录，各角色会话都可读，只有全局写。这里先铺说明，规范正文由会话按需建立。
+  ['_Control_Center/standards/README.md', 'standards/README.md'],
   // 规则类：工作区没有这份时，ho_charter 会退回同名内置版本；这里先铺一份可改的默认口径。
   ['_Control_Center/rules/Handover_Rules.md', 'rules/Handover_Rules.md'],
   ['_Control_Center/rules/Migration_Rules.md', 'rules/Migration_Rules.md'],
@@ -62,6 +65,41 @@ function normalizeParent(input) {
   return { parent: abs, createdParent: !st };
 }
 
+/**
+ * 在既有的全局根上补齐缺失的目录与说明文件：只新建，不覆盖，不删任何东西。
+ * 用途：插件新增了目录（例如通用规范库）后，已部署的工作区靠它一次补齐。
+ */
+export function ensureScaffold(root) {
+  const abs = String(root || '');
+  let st = null;
+  try { st = fs.statSync(abs); } catch { st = null; }
+  if (!st || !st.isDirectory()) return { ok: false, error: '全局根不存在或不是目录：' + (abs || '（空）') };
+
+  const created = [];
+  const written = [];
+  const skipped = [];
+  for (const d of DIRS) {
+    const p = path.join(abs, d.split('/').join(path.sep));
+    if (!fs.existsSync(p)) created.push(d);
+    try {
+      fs.mkdirSync(p, { recursive: true });
+    } catch (e) {
+      return { ok: false, error: '建目录失败：' + d + '（' + String(e && e.message ? e.message : e) + '）', created, written, skipped };
+    }
+  }
+  for (const [rel, tpl] of FILES) {
+    const dst = path.join(abs, rel.split('/').join(path.sep));
+    if (fs.existsSync(dst)) { skipped.push(rel); continue; }
+    try {
+      fs.writeFileSync(dst, template(tpl), 'utf8');
+      written.push(rel);
+    } catch (e) {
+      return { ok: false, error: '写文件失败（' + rel + '）：' + (e && e.message ? e.message : e), created, written, skipped };
+    }
+  }
+  return { ok: true, created, written, skipped };
+}
+
 /**
  * 建全局根。
  * @param parentInput 用户在设置页粘贴的路径
@@ -89,30 +127,14 @@ export function createGlobalWorkspace(parentInput, opts) {
     existed = true;
   }
 
-  const created = [];
   try {
     fs.mkdirSync(root, { recursive: true });
-    for (const d of DIRS) {
-      const p = path.join(root, d.split('/').join(path.sep));
-      fs.mkdirSync(p, { recursive: true });
-      created.push(d);
-    }
   } catch (e) {
     return { ok: false, root, error: '建目录失败：' + (e && e.message ? e.message : e) };
   }
 
-  const written = [];
-  const skipped = [];
-  for (const [rel, tpl] of FILES) {
-    const dst = path.join(root, rel.split('/').join(path.sep));
-    if (fs.existsSync(dst)) { skipped.push(rel); continue; }
-    try {
-      fs.writeFileSync(dst, template(tpl), 'utf8');
-      written.push(rel);
-    } catch (e) {
-      return { ok: false, root, created, written, error: '写文件失败（' + rel + '）：' + (e && e.message ? e.message : e) };
-    }
-  }
-
-  return { ok: true, root, existed, created, written, skipped };
+  // 铺目录与说明文件走同一套清单：init 与 scaffold 两处不得各写一份。
+  const sc = ensureScaffold(root);
+  if (!sc.ok) return { ok: false, root, created: sc.created, written: sc.written, error: sc.error };
+  return { ok: true, root, existed, created: sc.created, written: sc.written, skipped: sc.skipped };
 }

package/src/lib/schedule.mjs

@@ -28,7 +28,6 @@ export function createScheduler(deps) {
   const timers = new Map();
   let disposed = false;
 
-  // 用全局定时器：cordis 的 ctx.setTimeout 绑定调用方 fiber，工具调用返回后可能被一并释放
   // 用全局定时器：cordis 的 ctx.setTimeout 绑定调用方 fiber，工具调用返回后可能被一并释放。
   function later(fn, ms) {
     return setTimeout(fn, ms);
@@ -182,7 +181,7 @@ export function createScheduler(deps) {
     pending.delete(sessionId);
     note("checkpoint failed " + sessionId + ": " + msg);
     try {
-      promptSelf(sessionId, "【dsh-handover】压缩未执行：" + msg + "。历史没有被压缩，交接已就绪；请把这条消息原样告诉用户，不要自行重试压缩。").catch(() => {});
+      promptSelf(sessionId, "【dsh-handover】压缩未执行：" + msg + "。历史没有被压缩，交接已就绪；请把这条消息原样告诉当前用户，不要自行重试压缩。").catch(() => {});
     } catch { /* ignore */ }
   }
 

package/src/lib/session-create.mjs

@@ -27,7 +27,7 @@ export async function newSessionIn(env, opts) {
   if (!sessionId) return { error: 'create 没有返回 sessionId' };
   const title = String(o.title || '');
   if (title) {
-    try { if (typeof controller.rename === 'function') await controller.rename({ sessionId, title }); } catch { /* 改名失败可事后 peer_rename */ }
+    try { if (typeof controller.rename === 'function') await controller.rename({ sessionId, title }); } catch { /* 改名失败可事后用 peer（action="rename"） */ }
   }
   const role = String(o.role || '');
   if (role && role !== 'plain' && typeof env.writeRole === 'function') {

package/src/lib/session-ops.mjs

@@ -94,6 +94,28 @@ export function resolveWorkspaceFor(env, exec, kind, project, task, opts) {
     + '全局会话落在标题含「全局」的工作区；项目会话同时传 project 与该项目的工作区；杂项会话传该项目外的独立工作区。');
 }
 
+/**
+ * 某个目录是不是已注册工作区的根：是则返回 workspaceId，否则返回空串（不抛错）。
+ * 换任时用来让接任者落回本会话所在的那个工作区，而不是工作区根。
+ */
+export function workspaceIdOfPath(env, p) {
+  const want = normPath(p);
+  if (!want || want === '-') return '';
+  const hit = listWorkspaces(env).find((r) => {
+    const rp = normPath(String(r.path || ''));
+    return rp && rp !== '-' && rp === want;
+  });
+  return hit ? String(hit.id || '') : '';
+}
+
+/** workspaceId 对应的根路径；查不到返回空串（登记表的工作区一栏用它写成实际落点）。 */
+export function workspacePathOf(env, id) {
+  const key = String(id || '');
+  if (!key) return '';
+  const hit = listWorkspaces(env).find((r) => String(r.id || '') === key);
+  return hit && hit.path ? String(hit.path) : '';
+}
+
 /** 已注册工作区清单（插件服务优先，退化读 workspace.json）：新建会话时用来列出可选项。 */
 function listWorkspaces(env) {
   try {
@@ -154,14 +176,14 @@ function reuseBlocker(env, ws, kind, key) {
   if (pct === null || pct === undefined || !(Number(pct) < watermark(env.cfg).warnValue)) return '';
   const label = kind === 'global' ? '全局类别' : kind === 'project' ? '项目「' + key + '」' : '杂项任务「' + key + '」';
   return '拒绝新建：' + label + '已有在任会话 ' + (cur.name || '（未命名）') + '（' + cur.sessionId + '）水位 '
-    + Number(pct).toFixed(1) + '%，低于 ' + watermark(env.cfg).warn + '；建议用 peer_send 复用，确需另建请传 force=true。';
+    + Number(pct).toFixed(1) + '%，低于 ' + watermark(env.cfg).warn + '；建议用 peer（action="send"）复用，确需另建请传 force=true。';
 }
 
 export async function sessionNew(env, args, exec) {
   const ws = env.resolveWs(exec);
   const controller = env.controller();
   // 换任（新建接班会话）先问用户。
-  if (args.confirm !== true) throw new Error('新建会话（换任）需要用户确认：先向用户说明要建接班会话并得到同意，再传 confirm=true');
+  if (args.confirm !== true) throw new Error('新建会话（换任）需要当前用户确认：先向当前用户说明要建接班会话并得到同意，再传 confirm=true');
   if (!controller) throw new Error('ctx.sessionController 不可用');
   // 名字要落成目录：先校验，别等会话建完、写角色表时才失败（那样会留下一个没有角色的会话）。
   if (args.project) assertProjectName(String(args.project));
@@ -197,22 +219,29 @@ export async function sessionNew(env, args, exec) {
   // 建会话即登记在任：全局手工建/换会话与自服务换任共用一张登记表，不让注册表漏记或与实况分叉。
   try {
     if (officeKind) {
-      const reg = registerHolder(ws, { kind: officeKind, project, task, name: title, sessionId, workspace: ws });
+      // 工作区一栏写**实际落点**（用户指定的那个工作区），不是调用者自己所在的工作区根。
+      const reg = registerHolder(ws, {
+        kind: officeKind, project, task, name: title, sessionId,
+        workspace: workspacePathOf(env, workspaceId) || ws,
+      });
       out.push('在任登记：' + reg.key + ' → ' + title + (reg.previous ? '（原 ' + reg.previous.name + ' 进历史）' : ''));
     }
   } catch (e) {
     out.push('在任登记失败：' + String(e && e.message ? e.message : e) + '（不影响会话本身）');
   }
   const meId = env.selfId(exec) || '（未知）';
-  // 交接路径按**接任者自身的角色**取用：项目换任读取项目交接，不再退回全局交接。
-  const hp = handoverPathFor(ws, finalRole === 'project' && project ? { role: 'project', project } : { role: 'global' });
-  const handover = env.cfg.handoverPath || (hp.path || '');
+  // 交接路径按**新会话自身的角色**取用：项目读项目交接、杂项读任务交接，都不退回全局交接。
+  // cfg.handoverPath 是「强制全局交接路径」的演练开关，只对全局角色生效。
+  const hp = handoverPathFor(ws, finalRole === 'project' && project ? { role: 'project', project }
+    : finalRole === 'misc' && task ? { role: 'misc', task } : { role: 'global' });
+  const handover = (finalRole === 'global' ? env.cfg.handoverPath : '') || hp.path
+    || (finalRole === 'misc' ? path.join(ws, '_Control_Center', 'rules', 'Misc_Task_Standard.md') : '');
   const text = args.message || [
     '先读交接：' + handover + '。',
-    '读毕先向用户报告，不得自行开展作业：一、当前停在哪一步；二、交接列有哪些待办；三、建议先做哪一条。待用户指派后再动手。交接无待办时如实说明，不得编造任务。',
+    '读毕先向当前用户报告，不得自行开展作业：一、当前停在哪一步；二、交接列有哪些待办；三、建议先做哪一条。待当前用户指派后再动手。交接无待办时如实说明，不得编造任务。',
     '本会话 id：' + sessionId,
     (finalRole === 'project' ? '全局会话 id：' : '创建者会话 id：') + meId,
-    '默认沉默：仅在三种时机各发一条 peer_send 给全局：水位不低于 ' + watermark(env.cfg).warn + ' 且已写交接、需用户决定、全局口径有误。任务完成不报全局，任务属本会话内部事务。会话间可直接 peer_send，不必经全局转述；不得每轮回执，不得发送「收到」「已完成」一类确认，全局以文件末态为准。',
+    '默认沉默：仅在三种时机各发一条 peer（action="send"）给全局：水位不低于 ' + watermark(env.cfg).warn + ' 且已写交接、需当前用户决定、全局口径有误。任务完成不报全局，任务属本会话内部事务。会话间可直接 peer（action="send"），不必经全局转述；不得每轮回执，不得发送「收到」「已完成」一类确认，全局以文件末态为准。',
   ].join(NL);
   const r = await sendPrompt(env.controller(), sessionId, text, 'queue');
   out.push('已投启动提示词 accepted=' + String(r && r.accepted) + '（' + text.length + ' 字）');
@@ -263,7 +292,7 @@ export function promptFor(env, opts) {
   const roleText = kind === 'global'
     ? '第 ' + ordinal + ' 任全局（管理会话）'
     : kind === 'project'
-      ? '「' + project + '」项目的执行对话'
+      ? '「' + project + '」项目的执行会话'
       : kind === 'misc' ? '杂项任务会话' : '新机器接手会话';
   const scopeText = kind === 'project'
     ? '库根 Projects/' + project + ' 与 _Project_Meta/' + project
@@ -288,9 +317,9 @@ export function promptFor(env, opts) {
   if (kind === 'project' && project) {
     extraLines.push('库根：Projects/' + project + '/；元数据：_Project_Meta/' + project + '/；快照：_Temp/' + project + '/Snapshots/');
     extraLines.push('作业前读库根 SKILL.md；修改文档时另读 _Control_Center/rules/ 对应规范。');
-    extraLines.push('进入预警区后写交接；请用户在聊天框发送 /allow-succeed 授权，再由本会话调用 ho_succeed 完成换任，不向全局请求。');
+    extraLines.push('进入预警区后写交接；请当前用户在聊天框发送 /allow-succeed 授权，再由本会话调用 ho_succeed 完成换任，不向全局请求。');
   }
-  if (kind === 'misc') extraLines.push('标准见 rules/Misc_Task_Standard.md；换任须用户授权，再由本会话调用 ho_succeed。');
+  if (kind === 'misc') extraLines.push('标准见 rules/Misc_Task_Standard.md；换任须当前用户授权，再由本会话调用 ho_succeed。');
   if (kind === 'migration') extraLines.push('迁移口径见 rules/Migration_Rules.md；通过顶层闸门后再开始作业。');
   if (o.extra) extraLines.push(String(o.extra));
   return [body].concat(extraLines.length ? ['', ...extraLines] : []).join(NL);
@@ -315,7 +344,7 @@ export function sessionPrompt(env, args, exec) {
 export async function sessionArchive(env, args, exec) {
   const reg = env.registry();
   if (!reg || typeof reg.archiveSession !== 'function') {
-    throw new Error('workspaceRegistry.archiveSession 不可用（先跑 ho_diag 看服务可见性）');
+    throw new Error('workspaceRegistry.archiveSession 不可用（先跑 ho_status（view=diag） 看服务可见性）');
   }
   const sid = String(args.session_id || '').trim();
   if (!sid) throw new Error('必须给 session_id');
@@ -341,7 +370,7 @@ export async function sessionArchive(env, args, exec) {
 export async function sessionUnarchive(env, args) {
   const reg = env.registry();
   if (!reg || typeof reg.unarchiveSession !== 'function') {
-    throw new Error('workspaceRegistry.unarchiveSession 不可用（先跑 ho_diag 看服务可见性）');
+    throw new Error('workspaceRegistry.unarchiveSession 不可用（先跑 ho_status（view=diag） 看服务可见性）');
   }
   const sid = String(args.session_id || '').trim();
   if (!sid) throw new Error('必须给 session_id');
@@ -364,7 +393,7 @@ function orderHandoverText(env, sid, extra) {
   lines.push("   直接调用 ho_handover(action=\"write\", text=...)，不要传 path：路径已按你的角色（" + (info && info.role ? info.role : "unknown") + "）解析。");
   lines.push("2) 必写：① 当前进度（版本、产物、是否通过）② 环境与路径（版本号、安装位置、下载源）③ 下一步清单，按顺序列出，每条可直接执行 ④ 已完成待验收、要求未实现的部分 ⑤ 已知问题与已踩的错。");
   lines.push("3) 机密只写位置，不写值：密码、token、密钥均写明所在文件。");
-  lines.push("4) 写完只回一条 peer_send 给全局：`交接已写 <绝对路径>`，附一句状态，不复述全文。");
+  lines.push("4) 写完只回一条 peer（action=\"send\"）给全局：`交接已写 <绝对路径>`，附一句状态，不复述全文。");
   lines.push("5) 不要压缩上下文，不要新建会话（新建会话属全局权限）。");
   if (extra) lines.push("6) 全局附加：" + extra);
   return lines.join(NL);
@@ -376,7 +405,7 @@ export async function sessionOrder(env, args) {
   if (!sid) throw new Error("order 需要 session_id");
   if (order !== "handover" && order !== "compact") throw new Error("order 只能是 handover 或 compact");
   // 给别的会话下「交接、压缩」指令，也要先问用户。
-  if (args.confirm !== true) throw new Error("下交接、压缩指令需要用户确认：先说明会唤醒目标会话并让它交接或压缩，得到同意后传 confirm=true");
+  if (args.confirm !== true) throw new Error("下交接、压缩指令需要当前用户确认：先说明会唤醒目标会话并让它交接或压缩，得到同意后传 confirm=true");
   const extra = typeof args.extra === "string" ? args.extra.trim() : "";
   const hp = env.handoverForSid(sid);
   const info = env.infoOfSid(sid);
@@ -413,7 +442,7 @@ export async function sessionOrder(env, args) {
   const max = (env.cfg && env.cfg.maxCompactions) || 3;
   const n = used + 1;
   if (n > max) {
-    out.push("已压满 " + used + "/" + max + "：不再压缩。应执行 ho_succeed 自行换任（先请用户发送 /allow-succeed 授权）；全局会话自身也可用 ho_sessions(action=\"new\")。新会话读毕交接会先向你报告，等待指派。");
+    out.push("已压满 " + used + "/" + max + "：不再压缩。应执行 ho_succeed 自行换任（先请当前用户发送 /allow-succeed 授权）；全局会话自身也可用 ho_sessions(action=\"new\")。新会话读毕交接会先向你报告，等待指派。");
     return out.join(NL);
   }
   const recentSec = st && st.lastSummaryMs ? (Date.now() - st.lastSummaryMs) / 1000 : null;
@@ -425,15 +454,15 @@ export async function sessionOrder(env, args) {
   const cs = checkConsent(sid);
   if (!cs.ok) {
     out.push("拒绝排压缩：" + cs.reason + "。");
-    out.push("请用户到设置页的 dsh-handover 中，点「压缩授权」的「允许该会话压缩一次」（5 分钟内有效），再重下这条指令。");
+    out.push("请当前用户到设置页的 dsh-handover 中，点击「授权」里的「授权压缩」（5 分钟内有效），再重下这条指令。");
     return out.join(NL);
   }
   const resume = args.resume === "continue" ? "continue" : "wait";
   env.schedule(sid, n, { resume });
-  out.push("用户已授权（" + (cs.atText || '') + " 点击，剩 " + Math.round((cs.leftMs || 0) / 1000) + " 秒）。");
+  out.push("当前用户已授权（" + (cs.atText || '') + " 点击，剩 " + Math.round((cs.leftMs || 0) / 1000) + " 秒）。");
   out.push("已登记压缩（它自己第 " + n + "/" + max + " 次）：等它空闲后执行。");
   if (resume === "wait") {
-    out.push("去向：wait（缺省）—— 压缩后不再唤醒它，等用户派新任务，或由新会话接手。");
+    out.push("去向：wait（缺省）—— 压缩后不再唤醒它，等当前用户派新任务，或由新会话接手。");
   } else {
     out.push("去向：continue —— 压缩后它会自动收到**它自己的**续跑消息（带它自己的交接路径）。");
   }
@@ -453,7 +482,7 @@ export async function sessionPlace(env, args) {
   if (!sid) throw new Error("place 需要 session_id");
   if (!key) throw new Error("place 需要 workspace（id、标题、路径都行）");
   const reg = env.registry();
-  if (!reg || typeof reg.get !== "function") throw new Error("workspaceRegistry 不可用（先跑 ho_diag）");
+  if (!reg || typeof reg.get !== "function") throw new Error("workspaceRegistry 不可用（先跑 ho_status（view=diag））");
   const wid = findWorkspaceId(key);
   if (!wid) throw new Error("找不到工作区：" + key);
   const w = reg.get(wid);

package/src/lib/sessions.mjs

@@ -37,7 +37,7 @@ function isPlausible(name) {
 
 /** 返回 { project, real }：优先看 cwd 里的 Projects/<名>/，退回首条提示里的 Projects/<名>/ 或 「<名>」项目。 */
 export function projectOf(data) {
-  // 先认路径：首条提示是自然语言的会话解析不出项目名，会被整行过滤，在任判定就可能落到前任身上。
+  // 先认路径：首条提示是自然语言的会话解析不出项目名，会被整行过滤，在任判定就可能落到已交出的旧会话身上。
   // cwd 由宿主写入，最可靠。
   const raw = String(cwdOf(data) || '').replace(/\\/g, '/');
   const ci = raw.toLowerCase().indexOf('/projects/');

package/src/lib/status.mjs

@@ -1,11 +1,11 @@
-/**
+/**
  * 设置页用的状态快照（只读）：插件自身状态 ＋ 闸门 ＋ 交接体检 ＋ 会话水位 ＋ 最近一次守卫判定。
  * 全部读本地文件，不唤醒任何会话、不花任何会话的 token。
  * 任何一段出错都只让该段带 error 字段，不让整页 500。
  */
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
-import { isDir } from './text.mjs';
 import { syncCheck } from './gates.mjs';
 import { lintGlobal, lintProject } from './lint.mjs';
 import { scanSessions } from './sessions.mjs';
@@ -15,20 +15,125 @@ import { buildGuide, SETUP_STEPS } from './guide.mjs';
 import { readRoles, resolveRole, ROLE_LABEL, sessionMeta } from './role.mjs';
 import { listConsent } from './consent.mjs';
 import { listProfiles } from './profile.mjs';
+import { loadOffice, readRegistryProjects, KIND_LABEL } from './office.mjs';
 
 function guard(fn, fallback) {
   try { return fn(); } catch (e) { return { ...fallback, error: String(e && e.message ? e.message : e) }; }
 }
 
-/** 项目交接体检：_Project_Meta/<项目>/Handover.md。 */
+/**
+ * DSH 工作区索引：读 `~/.dsh/storages/workspace.json`（只读）。
+ * 返回 { list, bySession, archived }：
+ * - list：按登记顺序的工作区（key、title、path）；
+ * - bySession：sessionId → 工作区；
+ * - archived：已归档会话 id，设置页不再罗列。
+ * 读不到时全部为空，调用方据此退化为「按会话目录分组、只按归档表过滤」。
+ */
+function loadWorkspaceIndex() {
+  const out = { list: [], bySession: new Map(), archived: new Set() };
+  let v = null;
+  try {
+    const file = path.join(os.homedir(), '.dsh', 'storages', 'workspace.json');
+    v = JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
+  } catch { return out; }
+  if (!v || typeof v !== 'object') return out;
+  const tables = v.tables && v.tables.workspaces ? v.tables.workspaces : {};
+  const order = v.global && Array.isArray(v.global.workspaceIds) && v.global.workspaceIds.length
+    ? v.global.workspaceIds : Object.keys(tables);
+  for (const key of order) {
+    const w = tables[key];
+    if (!w) continue;
+    const item = { key: String(key), title: String(w.title || ''), path: String(w.path || '') };
+    out.list.push(item);
+    for (const sid of (Array.isArray(w.sessionIds) ? w.sessionIds : [])) out.bySession.set(String(sid), item);
+  }
+  for (const sid of (v.global && Array.isArray(v.global.archivedSessionIds) ? v.global.archivedSessionIds : [])) {
+    out.archived.add(String(sid));
+  }
+  return out;
+}
+
+/** 仍然存在的会话目录：`~/.dsh/sessions` 下以 session- 开头的目录名（含已归档里恢复不了的会话就自然不在）。 */
+function liveSessionDirs() {
+  const set = new Set();
+  try {
+    const walk = (dir, depth) => {
+      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (!e.isDirectory()) continue;
+        if (e.name.indexOf('session-') === 0) set.add(e.name);
+        else if (depth < 4) walk(path.join(dir, e.name), depth + 1);
+      }
+    };
+    walk(path.join(os.homedir(), '.dsh', 'sessions'), 0);
+  } catch { /* 读不到就返回空集 */ }
+  return set;
+}
+
+/** 在任登记：Office.json 中每条登记（全局、各项目、各杂项任务）的现任。
+ * 返回 sessionId → { key, kind, kindLabel, name }；读不到登记表时为空表，调用方据此退化为「不过滤」。
+ * 普通会话不登记，因此不会被当成在任会话。
+ */
+function loadDuty(ws) {
+  const map = new Map();
+  let office = null;
+  try { office = loadOffice(ws); } catch { office = null; }
+  const lineages = (office && office.lineages) || {};
+  for (const key of Object.keys(lineages)) {
+    const lin = lineages[key] || {};
+    const cur = lin.current;
+    if (!cur || !cur.sessionId) continue;
+    map.set(String(cur.sessionId), {
+      key,
+      kind: String(lin.kind || ''),
+      kindLabel: KIND_LABEL[lin.kind] || '',
+      project: String(lin.project || ''),
+      task: String(lin.task || ''),
+      name: String(cur.name || key),
+    });
+  }
+  return { map, office };
+}
+
+/** 项目交接体检：只查 Registry.md 已登记的项目，未登记的旧目录不在此列。 */
 function lintProjects(ws) {
   const out = [];
-  let dirs = [];
-  try { dirs = fs.readdirSync(path.join(ws, '_Project_Meta')).sort(); } catch { return out; }
-  for (const name of dirs) {
-    const dir = path.join(ws, '_Project_Meta', name);
-    try { if (!isDir(dir)) continue; } catch { continue; }
-    const r = lintProject(path.join(dir, 'Handover.md'));
+  let names = [];
+  try { names = readRegistryProjects(ws); } catch { return out; }
+  for (const name of names) {
+    const r = lintProject(path.join(ws, '_Project_Meta', name, 'Handover.md'));
+    out.push({ name, verdict: r.verdict, reasons: Array.isArray(r.reasons) ? r.reasons.slice(0, 5) : [] });
+  }
+  return out;
+}
+
+/** 杂项目录：规范位置 `_Misc/tasks/<任务>/`，兼容旧布局 `_Misc/<任务>/`；两处都没有就返回空串。 */
+function miscDir(ws, task) {
+  const name = String(task || '').trim();
+  if (!name) return '';
+  const cands = [path.join(ws, '_Misc', 'tasks', name), path.join(ws, '_Misc', name)];
+  for (const dir of cands) {
+    try { if (fs.statSync(dir).isDirectory()) return dir; } catch { /* 继续看下一个 */ }
+  }
+  return '';
+}
+
+/**
+ * 杂项交接体检：按 Office.json 里已登记的杂项条目找任务目录。
+ * 登记名与目录名不一致（例如登记「示例任务」、目录名不同）时报「未找到」，
+ * 不猜近似目录：猜错会把别人的交接算到这条任务头上。
+ */
+function lintMisc(ws, office) {
+  const out = [];
+  const lineages = (office && office.lineages) || {};
+  for (const key of Object.keys(lineages)) {
+    const lin = lineages[key] || {};
+    if (String(lin.kind || '') !== 'misc') continue;
+    const name = String(lin.task || key).trim();
+    if (!name) continue;
+    const dir = miscDir(ws, name);
+    const r = dir
+      ? lintProject(path.join(dir, 'Handover.md'))
+      : { verdict: '未找到', reasons: ['按登记名找不到任务目录：_Misc/tasks/' + name + ' 或 _Misc/' + name] };
     out.push({ name, verdict: r.verdict, reasons: Array.isArray(r.reasons) ? r.reasons.slice(0, 5) : [] });
   }
   return out;
@@ -39,6 +144,9 @@ export function buildStatus(env, extra) {
   const ws = routeWorkspace(env);
   const found = hasCenter(ws);
   const warn = Math.round((env.cfg.warnRatio || 0.32) * 100);
+  const duty = loadDuty(ws);
+  const onDuty = (sid) => (duty.map.size ? duty.map.has(String(sid || '')) : true);
+  const dutyOf = (sid) => duty.map.get(String(sid || '')) || null;
   const out = {
     generatedAt: stampTz(Date.now()),
     plugin: {
@@ -68,7 +176,7 @@ export function buildStatus(env, extra) {
       }
       return map;
     }, {}),
-    consent: guard(() => listConsent(), []),
+    consent: guard(() => listConsent().map((r) => ({ ...r, onduty: onDuty(r.sessionId) })), []),
     profiles: guard(() => listProfiles(ws), []),
     guide: guard(() => buildGuide(env.cfg), { intro: [], situations: [], groups: [], rules: [] }),
     gate: null,
@@ -102,66 +210,120 @@ export function buildStatus(env, extra) {
   out.handover = guard(() => {
     const g = lintGlobal(path.join(ws, '_Control_Center', 'records', 'Global_Handover.md'));
     const projects = lintProjects(ws);
+    const misc = lintMisc(ws, duty.office);
+    const bad = projects.concat(misc).filter((p) => p.verdict === '不合格');
     return {
       global: { verdict: g.verdict, reasons: Array.isArray(g.reasons) ? g.reasons.slice(0, 5) : [] },
       projects,
-      fail: projects.filter((p) => p.verdict === '不合格').length,
+      misc,
+      fail: bad.length,
     };
-  }, { global: { verdict: '读不到', reasons: [] }, projects: [], fail: 0 });
+  }, { global: { verdict: '读不到', reasons: [] }, projects: [], misc: [], fail: 0 });
 
   out.sessions = guard(() => {
-    const scan = scanSessions({
-      dir: env.cacheDir(),
-      meId: null,
-      meCwd: null,
-      warn,
-      silentHours: env.cfg.sessionScanHours,
-      projectsOnly: true,
+    const wide = scanSessions({
+      dir: env.cacheDir(), meId: null, meCwd: null, warn,
+      silentHours: env.cfg.sessionScanHours, projectsOnly: false,
     });
     const store = readRoles(env.cfg);
     const roleOf = (sid, cwd, firstPrompt, title) => {
       const meta = sessionMeta(sid);
       return resolveRole({ cfg: env.cfg, roles: store, sessionId: sid, cwd, firstPrompt, subagent: meta.subagent, title });
     };
-    const wide = scanSessions({
-      dir: env.cacheDir(), meId: null, meCwd: null, warn, silentHours: env.cfg.sessionScanHours, projectsOnly: false,
-    });
-    const all = wide.rows.filter((r) => r.kind === '平级').map((r) => {
+    // 工作区与归档：设置页按工作区分组罗列，已归档与目录已不存在的会话不再出现。
+    const wsIndex = loadWorkspaceIndex();
+    const live = liveSessionDirs();
+    // 会话 id 在缓存里有带与不带 session- 前缀两种写法，统一成带前缀再比。
+    const sidKey = (sid) => (/^session-/.test(String(sid)) ? String(sid) : 'session-' + String(sid));
+    const archived = (sid) => wsIndex.archived.has(sidKey(sid));
+    const stillThere = (sid) => live.size === 0 || live.has(sidKey(sid));
+    // 真实路径：旧根现为链接，靠 realpath 才能把老会话归到当前工作区。
+    const realCache = new Map();
+    const realOf = (p) => {
+      const key = String(p || '').toLowerCase();
+      if (realCache.has(key)) return realCache.get(key);
+      let v = '';
+      try { v = fs.realpathSync(String(p || '')); } catch { v = ''; }
+      realCache.set(key, v);
+      return v;
+    };
+    const wsReal = wsIndex.list.map((w) => ({
+      w,
+      real: String(realOf(w.path) || w.path || '').replace(/\\/g, '/').toLowerCase(),
+    }));
+    const wsOf = (sid, cwd) => {
+      const direct = wsIndex.bySession.get(sidKey(sid));
+      if (direct) return direct;
+      // 未登记到工作区的会话：按 cwd（先取真实路径）最长前缀归到工作区。
+      const c = String(realOf(cwd) || cwd || '').replace(/\\/g, '/').toLowerCase();
+      if (!c) return null;
+      let best = null;
+      for (const item of wsReal) {
+        const wp = item.real;
+        if (!wp) continue;
+        if ((c === wp || c.indexOf(wp + '/') === 0) && (!best || wp.length > best.real.length)) best = item;
+      }
+      return best ? best.w : null;
+    };
+    const mapRow = (r) => {
       const meta = sessionMeta(r.sid);
       const info = roleOf(r.sid, meta.cwd, meta.firstPrompt, r.project);
+      const d = dutyOf(r.sid);
+      const w = wsOf(r.sid, meta.cwd);
+      // 目录已不存在的老会话（旧树里删掉的项目库等）不再罗列。
+      const cwdOk = !meta.cwd || !!realOf(meta.cwd);
       return {
         sid: r.sid,
         title: r.project === '-' ? '' : r.project,
+        project: r.project,
         role: info.role,
         roleLabel: ROLE_LABEL[info.role] || info.role,
         source: info.source,
-        project: info.project,
+        projectName: info.project,
         task: info.task,
+        cwdOk,
+        // 工作区分组：没有登记归属时留空，客户端归入「未归属工作区」。
+        wsKey: w ? w.key : '',
+        wsTitle: w ? w.title : '',
+        wsPath: w ? w.path : String(meta.cwd || ''),
+        // 类别与名称以在任登记为准：登记过的会话才能说清自己是全局、项目还是杂项。
+        dutyKind: d ? d.kindLabel : '',
+        dutyKey: d ? d.key : '',
+        dutyName: d ? d.name : '',
         pct: r.pct,
         state: r.state,
-        active: r.mtime >= scan.cutoffMs,
+        active: r.mtime >= wide.cutoffMs,
+        onduty: !!d,
+        mtime: r.mtime,
         seen: stampTz(r.mtime),
       };
-    });
+    };
+    const all = wide.rows
+      .filter((r) => r.kind === '平级' && !archived(r.sid) && stillThere(r.sid))
+      .map(mapRow)
+      .filter((r) => r.wsKey || r.cwdOk);
+    // 在任集合：全局、各项目、各杂项任务的现任各一行；普通会话不在登记表里，因此不出现。
+    const rows = all.filter((r) => r.onduty).slice(0, 60);
+    // 通知：每条登记的在任会话，若本轮仍活跃；已交出的会话即使更活跃也不通知。
+    const notify = [];
+    for (const sid of duty.map.keys()) {
+      const hit = rows.find((r) => r.sid === sid);
+      if (hit && hit.mtime >= wide.cutoffMs) notify.push({ sid: hit.sid, key: hit.dutyKey, name: hit.dutyName });
+    }
+    const hot = rows.filter((r) => r.pct !== null && r.pct >= warn).length;
     return {
-      rows: scan.rows.slice(0, 60).map((r) => {
-        const meta = sessionMeta(r.sid);
-        const info = roleOf(r.sid, meta.cwd, meta.firstPrompt, r.project);
-        return {
-          sid: r.sid, project: r.project, pct: r.pct, state: r.state,
-          role: info.role, roleLabel: ROLE_LABEL[info.role] || info.role,
-          active: r.mtime >= scan.cutoffMs, seen: stampTz(r.mtime),
-        };
-      }),
+      rows,
       all,
-      notify: scan.notify.map((r) => ({ sid: r.sid, project: r.project })),
-      hot: scan.hot.length,
-      unknown: scan.unknown.length,
-      cutoff: stampTz(scan.cutoffMs),
-      silentHours: scan.silentHours,
-      verdict: scan.hot.length
-        ? scan.hot.length + ' 个会话已进预警区（不低于 ' + warn + '%），应先收齐交接，再换会话'
-        : '没有会话进入预警区。',
+      workspaces: wsIndex.list.map((w) => ({ key: w.key, title: w.title || w.path, path: w.path })),
+      notify,
+      onduty: duty.map.size,
+      hot,
+      unknown: wide.unknown.length,
+      cutoff: stampTz(wide.cutoffMs),
+      silentHours: wide.silentHours,
+      verdict: hot
+        ? hot + ' 个在任会话已进预警区（不低于 ' + warn + '%），应先收齐交接，再换会话'
+        : '没有在任会话进入预警区。',
     };
   }, { rows: [], notify: [], hot: 0, unknown: 0 });
 
@@ -171,7 +333,5 @@ export function buildStatus(env, extra) {
     return all.filter((r) => r && r.role === 'global').length;
   }, 0);
 
-  if (out.gate && !out.gate.ok && !out.gate.error) out.notes.push('通用约束条闸门未过：向对应项目会话派发，全局不代写项目库内文件。');
-  if (out.handover && out.handover.fail) out.notes.push(out.handover.fail + ' 个项目交接体检不合格，交接前必须先补。');
   return out;
 }