@mingmaple/dsh-handover 0.9.22 → 1.0.0

package/src/lib/succession.mjs

@@ -100,7 +100,7 @@ function appendSuccessionBlock(file, lines) {
 export async function runSuccession(env, exec, opts) {
   const o = opts || {};
   const note = typeof o.note === 'string' ? o.note.trim() : '';
-  const reject = (reason) => '换任未执行，未做任何写入。' + NL + reason;
+  const reject = (reason) => '换任未执行，未写入任何内容。' + NL + reason;
 
   // 1. 自身角色与类别：只认已登记的角色。
   const info = env.roleOf(exec) || {};
@@ -120,8 +120,8 @@ export async function runSuccession(env, exec, opts) {
     return reject([
       cs.reason + '。',
       '授权方式（任选其一）：',
-      '  ① 在聊天框发送 /allow-succeed（最快，仅授权本会话）；',
-      '  ② 在设置页的 dsh-handover 中，点击「授权」里的「授权换任」。',
+      '  ① 在聊天框发送 /allow-succeed（仅授权本会话，最为快捷）；',
+      '  ② 在设置页的 dsh-handover 中，点击「授权」内的「授权换任」。',
       '授权有效期 5 分钟，用后失效。',
     ].join(NL));
   }
@@ -129,7 +129,7 @@ export async function runSuccession(env, exec, opts) {
   // 3. 交接结构检查（只判结构，不判质量）。
   const hp = env.handoverFor(exec) || {};
   const handoverFile = hp.path ? String(hp.path) : '';
-  if (!handoverFile) return reject('没有交接路径：' + (hp.reason || '本会话角色未确定'));
+  if (!handoverFile) return reject('没有可用的交接路径：' + (hp.reason || '本会话角色未确定'));
   const problems = auditHandover(handoverFile);
   if (problems.length) {
     return reject(['交接结构未通过：' + handoverFile]
@@ -145,10 +145,10 @@ export async function runSuccession(env, exec, opts) {
   const lin = store.lineages[key];
   // 只有本类别的在任者本人可换任：既防旧会话复活，也防同项目的旁支会话抢先。
   if (!lin || !lin.current || !lin.current.sessionId) {
-    return reject('本类别（' + key + '）在在任登记表里还没有现任记录：先由全局建会话并登记，再换任。');
+    return reject('本类别（' + key + '）在在任登记表中尚无在任记录：先由全局建立会话并登记，再换任。');
   }
   if (String(lin.current.sessionId) !== String(selfId)) {
-    return reject('本会话不是在任者：本类别现任为 ' + String(lin.current.name || '（未命名）')
+    return reject('本会话不是在任者：本类别在任为 ' + String(lin.current.name || '（未命名）')
       + '（' + String(lin.current.sessionId) + '），不得换任。');
   }
   {
@@ -156,17 +156,17 @@ export async function runSuccession(env, exec, opts) {
     const closed = history.find((h) => h && String(h.sessionId || '') === String(selfId) && h.to);
     if (closed) {
       const curName = lin.current && lin.current.name ? lin.current.name : '（空缺）';
-      return reject('本类别已为本会话记过一次换任（' + String(closed.to || '') + '，现任 ' + curName + '），旧会话不得再次换任。');
+      return reject('本类别已为本会话记过一次换任（' + String(closed.to || '') + '，在任 ' + curName + '），旧会话不得再次换任。');
     }
   }
 
-  // 4.1 水位未到线：本会话就是在任者且水位低于提醒线时，换任通常是多余的。
+  // 4.1 水位未到线：本会话就是在任者且水位低于提醒线时，换任通常多余。
   // 放在授权与交接校验之后、任何写入之前；取不到水位就跳过。
   if (o.force !== true) {
     let pct = null;
     try { pct = typeof env.selfPct === 'function' ? env.selfPct(selfId) : null; } catch { pct = null; }
-    if (pct !== null && pct !== undefined && Number(pct) < watermark(env.cfg).warnValue) {
-      return reject('本会话水位 ' + Number(pct).toFixed(1) + '%，尚未到线，通常无需换任；确需换任请传 force=true。');
+    if (pct !== null && pct !== undefined && Number(pct) < watermark(env.cfg).remindValue) {
+      return reject('本会话水位 ' + Number(pct).toFixed(1) + '%，未到提醒线，通常无需换任；确需换任请传 force=true。');
     }
   }
 
@@ -195,7 +195,7 @@ export async function runSuccession(env, exec, opts) {
     const base = promptFor(env, { ws, kind, project, task, title: name, sessionId: '', globalSessionId: globalId, extra: '' });
     prompt = base + NL + NL + [
       '接任交接：' + handoverFile,
-      '先读这份交接再动手；读毕向当前用户报告当前停在哪一步、交接列有哪些待办，然后等待当前用户指派任务。',
+      '先读这份交接，再开始作业。读毕向当前用户报告：当前停在哪一步；交接列有哪些待办。随后等待当前用户指派任务。',
     ].join(NL);
   } catch (e) {
     return reject('启动提示词生成失败：' + msgOf(e));
@@ -215,7 +215,7 @@ export async function runSuccession(env, exec, opts) {
   } catch (e) {
     return [
       '会话已建 ' + sessionId + '（' + name + '），但登记在任失败：' + msgOf(e),
-      '启动提示词尚未投递；先修好登记表，再用 peer（action="send"）通知它。',
+      '启动提示词尚未投递。先修好登记表，再用 peer（action="send"）通知该会话。',
     ].join(NL);
   }
 
@@ -253,8 +253,8 @@ export async function runSuccession(env, exec, opts) {
   out.push('换任完成：' + name + '（' + sessionId + '）');
   out.push('在任登记：' + key + (reg && reg.registry && reg.registry.changed && reg.registry.changed.length
     ? '，Registry.md 已同步在役列' : ''));
-  out.push('启动提示词：' + (delivered ? '已投递' : '未送达：' + deliveryError + '。会话已建，可用 peer（action="send"）补投'));
+  out.push('启动提示词：' + (delivered ? '已投递' : '未送达：' + deliveryError + '。会话已建，可用 peer（action="send"）补投。'));
   out.push('交接登记：' + appendNote);
-  out.push('本会话到此停止，等待当前用户在新会话中派任务。');
+  out.push('本会话到此停止，等待当前用户在新会话中指派任务。');
   return out.join(NL);
 }

package/src/lib/system.mjs

@@ -0,0 +1,364 @@
+/**
+ * 体系注册与文档定位（1.0）：每个任务一份注册文件，写目录结构、规范文件与计划；
+ * 全局总注册只列各任务体系文件的路径，不承载正文。
+ *
+ * 路径约定：
+ * - 全局总注册：_Control_Center/records/systems.md
+ * - 项目：_Project_Meta/<项目>/System.md
+ * - 杂项：_Misc/tasks/<任务>/System.md
+ * - 全局任务：_Control_Center/tasks/<任务>/System.md
+ *
+ * 定位：注册只给路径与用途，是否读正文由会话判断；空注册不注入正文，只注入一句提示。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { NL, readUtf8, isFile, isDir } from './text.mjs';
+import { projectNameOk, taskNameOk } from './role.mjs';
+import { readProfile } from './profile.mjs';
+
+export const GLOBAL_REGISTRY_REL = path.join('_Control_Center', 'records', 'systems.md');
+export const REGISTRY_NAME = 'System.md';
+
+const TICK = String.fromCharCode(96);
+
+export function lineageOf(info) {
+  const role = info && info.role ? info.role : '';
+  if (role === 'global') return { kind: 'global', project: '', task: '', key: '全局' };
+  if (role === 'project' && info.project) return { kind: 'project', project: String(info.project), task: '', key: String(info.project) };
+  if (role === 'misc' && info.task) return { kind: 'misc', project: '', task: String(info.task), key: String(info.task) };
+  if (role === 'global-task' && info.task) return { kind: 'global-task', project: '', task: String(info.task), key: String(info.task) };
+  return null;
+}
+
+export function lineageLabel(info) {
+  const lin = lineageOf(info);
+  if (!lin) return '';
+  if (lin.kind === 'project') return '项目「' + lin.project + '」';
+  if (lin.kind === 'misc') return '杂项任务「' + lin.task + '」';
+  if (lin.kind === 'global-task') return '全局任务「' + lin.task + '」';
+  return '全局';
+}
+
+/** 任务库根（相对工作区）。项目优先取骨架档案登记的根，其次 `<项目>库`，最后项目目录。 */
+export function taskRoot(ws, info) {
+  const lin = lineageOf(info);
+  if (!lin) return '';
+  if (lin.kind === 'project') {
+    const p = lin.project;
+    try {
+      const pf = readProfile(ws, { role: 'project', project: p });
+      if (pf && pf.exists && pf.profile && pf.profile.root) return String(pf.profile.root);
+    } catch { /* 骨架读不到时按目录规则推断 */ }
+    const lib = path.join('Projects', p, p + '库');
+    return isDir(path.join(String(ws || ''), lib)) ? lib : path.join('Projects', p);
+  }
+  if (lin.kind === 'misc') return path.join('_Misc', 'tasks', lin.task);
+  if (lin.kind === 'global-task') return path.join('_Control_Center', 'tasks', lin.task);
+  return '_Control_Center';
+}
+
+/** 注册文件相对路径。 */
+export function registryRelPath(info) {
+  const lin = lineageOf(info);
+  if (!lin) return null;
+  if (lin.kind === 'global') return GLOBAL_REGISTRY_REL;
+  if (lin.kind === 'project') return path.join('_Project_Meta', lin.project, REGISTRY_NAME);
+  if (lin.kind === 'misc') return path.join('_Misc', 'tasks', lin.task, REGISTRY_NAME);
+  if (lin.kind === 'global-task') return path.join('_Control_Center', 'tasks', lin.task, REGISTRY_NAME);
+  return null;
+}
+
+export function registryAbsPath(ws, info) {
+  const rel = registryRelPath(info);
+  return rel ? path.join(String(ws || ''), rel) : null;
+}
+
+export function planRelPath(ws, info) {
+  const root = taskRoot(ws, info);
+  return root ? path.join(root, 'PLAN.md') : '';
+}
+
+function normRel(p) {
+  return String(p || '').replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function cellsOf(line) {
+  return line.replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.replace(new RegExp(TICK, 'g'), '').trim());
+}
+
+/** 解析任务级注册：返回 { title, structure: [{path, about}], files: [{path, about, when}], plan }。 */
+export function parseRegistry(text) {
+  const out = { title: '', structure: [], files: [], plan: '' };
+  let section = '';
+  for (const raw of String(text || '').split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.startsWith('# ')) { out.title = line.slice(2).trim(); continue; }
+    if (line.startsWith('## ')) { section = line.slice(3).trim(); continue; }
+    if (section.indexOf('计划') !== -1) {
+      const m = /^[-*]\s*`?([^`：:]+\.md)`?/.exec(line);
+      if (m) out.plan = m[1].trim();
+      continue;
+    }
+    if (!line.startsWith('|')) continue;
+    const cells = cellsOf(line);
+    if (cells.length < 2) continue;
+    if (cells[0] === '路径') continue;
+    if (cells.every((c) => /^[-:\s]*$/.test(c))) continue;
+    if (section.indexOf('目录') !== -1) out.structure.push({ path: cells[0], about: cells[1] || '' });
+    else if (section.indexOf('规范') !== -1 || section.indexOf('文件') !== -1) {
+      out.files.push({ path: cells[0], about: cells[1] || '', when: cells[2] || '' });
+    }
+  }
+  return out;
+}
+
+/** 渲染任务级注册文件。 */
+export function renderRegistry(info, data) {
+  const label = lineageLabel(info);
+  const lines = ['# 体系注册（' + label + '）', '', '## 目录结构', '', '| 路径 | 用途 |', '|---|---|'];
+  for (const e of data.structure || []) lines.push('| ' + wrap(e.path) + ' | ' + e.about + ' |');
+  lines.push('', '## 规范文件', '', '| 路径 | 用途 | 何时读 |', '|---|---|---|');
+  for (const e of data.files || []) lines.push('| ' + wrap(e.path) + ' | ' + e.about + ' | ' + (e.when || '') + ' |');
+  lines.push('', '## 计划', '');
+  if (data.plan) lines.push('- ' + wrap(data.plan) + '：当前行动计划');
+  lines.push('');
+  lines.push('只给路径与用途：是否读正文由会话判断，不得无目的通读。');
+  return lines.join(NL) + NL;
+}
+
+function wrap(p) {
+  return TICK + normRel(p) + TICK;
+}
+
+/** 读取任务级注册；不存在返回 exists=false。 */
+export function readRegistry(ws, info) {
+  const file = registryAbsPath(ws, info);
+  if (!file) return { file: null, exists: false, data: { structure: [], files: [], plan: '' } };
+  if (!isFile(file)) return { file, exists: false, data: { structure: [], files: [], plan: '' } };
+  let text = '';
+  try { text = readUtf8(file); } catch { return { file, exists: true, error: '读取失败', data: { structure: [], files: [], plan: '' } }; }
+  return { file, exists: true, data: parseRegistry(text), text };
+}
+
+/** 路径合法且存在：只收工作区相对路径。 */
+export function pathProblem(ws, p) {
+  const raw = normRel(p);
+  if (!raw) return '路径为空';
+  if (/^[a-zA-Z]:/.test(raw) || raw.startsWith('/') || raw.startsWith('\\')) return '须写工作区相对路径，不得写绝对路径';
+  const norm = path.normalize(raw).replace(/\\/g, '/');
+  if (norm === '..' || norm.startsWith('../')) return '不得指向工作区之外';
+  const abs = path.join(String(ws || ''), norm);
+  if (!isFile(abs) && !isDir(abs)) return '不存在：' + norm;
+  return '';
+}
+
+export function validateEntries(ws, entries) {
+  const bad = [];
+  for (const e of entries) {
+    const problem = pathProblem(ws, e.path);
+    if (problem) bad.push({ path: e.path, problem });
+  }
+  return bad;
+}
+
+/** 解析全局总注册：返回 [{ task, kind, path }]。 */
+export function parseGlobalRegistry(text) {
+  const rows = [];
+  for (const raw of String(text || '').split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line.startsWith('|')) continue;
+    const cells = cellsOf(line);
+    if (cells.length < 3) continue;
+    if (cells[0] === '任务') continue;
+    if (cells.every((c) => /^[-:\s]*$/.test(c))) continue;
+    rows.push({ task: cells[0], kind: cells[1] || '', path: cells[2] });
+  }
+  return rows;
+}
+
+const KIND_LABEL = { project: '项目', misc: '杂项', 'global-task': '全局任务' };
+
+/** 扫描磁盘上的任务注册，重建全局总注册。返回 { rows, file, changed }。 */
+export function syncGlobalRefs(ws) {
+  const root = String(ws || '');
+  const rows = [];
+  const pushFrom = (base, kind, nameOf) => {
+    let names = [];
+    try { names = fs.readdirSync(base); } catch { return; }
+    for (const name of names) {
+      const dir = path.join(base, name);
+      if (fs.existsSync(path.join(dir, '.deregistered.json'))) continue;
+      const file = path.join(dir, REGISTRY_NAME);
+      if (!isFile(file)) continue;
+      rows.push({ task: nameOf(name), kind: KIND_LABEL[kind] || kind, path: path.join(base, name, REGISTRY_NAME), mtime: 0 });
+    }
+  };
+  pushFrom(path.join(root, '_Project_Meta'), 'project', (n) => n);
+  pushFrom(path.join(root, '_Misc', 'tasks'), 'misc', (n) => n);
+  pushFrom(path.join(root, '_Control_Center', 'tasks'), 'global-task', (n) => n);
+  rows.sort((a, b) => (a.kind === b.kind ? a.task.localeCompare(b.task, 'zh') : a.kind.localeCompare(b.kind)));
+  const file = path.join(root, GLOBAL_REGISTRY_REL);
+  const lines = ['# 体系注册（全局）', '', '| 任务 | 类别 | 体系文件 |', '|---|---|---|'];
+  for (const r of rows) lines.push('| ' + r.task + ' | ' + r.kind + ' | ' + wrap(r.path) + ' |');
+  lines.push('');
+  lines.push('本文件只列各任务体系文件的路径；各任务体系正文不注入全局提示段。');
+  const body = lines.join(NL) + NL;
+  let changed = true;
+  try { changed = readUtf8(file) !== body; } catch { changed = true; }
+  if (changed) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = file + '.tmp-' + process.pid;
+    fs.writeFileSync(tmp, body, 'utf8');
+    fs.renameSync(tmp, file);
+  }
+  return { rows, file, changed, body };
+}
+
+/** 全局总注册正文；不存在时按磁盘重建。 */
+export function readGlobalRegistry(ws) {
+  const synced = syncGlobalRefs(ws);
+  return { file: synced.file, exists: true, text: synced.body, rows: synced.rows };
+}
+
+/** 注册内容注入块：全局只注入引用清单；项目与杂项注入本任务注册全文（压缩为一行一条）。 */
+export function systemBlock(ws, info) {
+  const lin = lineageOf(info);
+  if (!lin) return '';
+  if (lin.kind === 'global') {
+    const g = readGlobalRegistry(ws);
+    if (!g.rows.length) return '体系注册（全局）：暂无任务体系；新建任务后由插件登记路径。';
+    const lines = ['体系注册（全局；只列路径，不注入各任务正文）'];
+    for (const r of g.rows) lines.push('- ' + normRel(r.path) + ' —— ' + r.kind + '「' + r.task + '」');
+    return lines.join(NL);
+  }
+  const reg = readRegistry(ws, info);
+  if (!reg.exists) return '体系注册：未设置（首轮讨论体系后用 ho_docmap(action="write") 注册）';
+  const d = reg.data;
+  const lines = ['体系注册（' + lineageLabel(info) + '）'];
+  for (const e of d.structure) lines.push('- 目录 ' + normRel(e.path) + '：' + (e.about || ''));
+  for (const e of d.files) lines.push('- 规范 ' + normRel(e.path) + '：' + (e.about || '') + (e.when ? '（' + e.when + '）' : ''));
+  if (d.plan) lines.push('- 计划 ' + normRel(d.plan));
+  return lines.join(NL);
+}
+
+/** 注册文件签名：文件不存在为 'none'；用于热更新判断。 */
+export function registrySignature(ws, info) {
+  const lin = lineageOf(info);
+  if (!lin) return '';
+  if (lin.kind === 'global') {
+    try {
+      const st = fs.statSync(path.join(String(ws || ''), GLOBAL_REGISTRY_REL));
+      return 'g:' + st.size + ':' + Math.round(st.mtimeMs);
+    } catch { return 'g:none'; }
+  }
+  const file = registryAbsPath(ws, info);
+  if (!file) return '';
+  try {
+    const st = fs.statSync(file);
+    return 'r:' + st.size + ':' + Math.round(st.mtimeMs);
+  } catch { return 'r:none'; }
+}
+
+/** 体检：校验某类别的注册路径；不传 info 时检查全部。返回 { rows, missing }。 */
+export function checkRegistries(ws, info) {
+  const targets = [];
+  if (info) targets.push(info);
+  else {
+    try {
+      for (const name of fs.readdirSync(path.join(String(ws || ''), '_Project_Meta'))) {
+        if (isFile(path.join(ws, '_Project_Meta', name, REGISTRY_NAME))) targets.push({ role: 'project', project: name });
+      }
+    } catch { /* 无项目元数据 */ }
+    try {
+      for (const name of fs.readdirSync(path.join(String(ws || ''), '_Misc', 'tasks'))) {
+        if (isFile(path.join(ws, '_Misc', 'tasks', name, REGISTRY_NAME))) targets.push({ role: 'misc', task: name });
+      }
+    } catch { /* 无杂项任务 */ }
+    try {
+      for (const name of fs.readdirSync(path.join(String(ws || ''), '_Control_Center', 'tasks'))) {
+        if (isFile(path.join(ws, '_Control_Center', 'tasks', name, REGISTRY_NAME))) targets.push({ role: 'global-task', task: name });
+      }
+    } catch { /* 无全局任务 */ }
+  }
+  const rows = [];
+  let missing = 0;
+  for (const t of targets) {
+    const reg = readRegistry(ws, t);
+    const entries = reg.data.structure.concat(reg.data.files);
+    const bad = validateEntries(ws, entries);
+    const planBad = reg.data.plan && pathProblem(ws, reg.data.plan) ? [{ path: reg.data.plan, problem: pathProblem(ws, reg.data.plan) }] : [];
+    missing += bad.length + planBad.length;
+    rows.push({ label: lineageLabel(t), rel: normRel(registryRelPath(t) || ''), exists: reg.exists, entries: entries.length, bad: bad.concat(planBad) });
+  }
+  return { rows, missing };
+}
+
+/** 写任务级注册：原子写，写前备份。 */
+export function writeRegistry(ws, info, data) {
+  const file = registryAbsPath(ws, info);
+  if (!file) throw new Error('没有可写的注册路径：角色未定');
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  let backup = '';
+  if (isFile(file)) {
+    backup = file + '.bak';
+    try { fs.copyFileSync(file, backup); } catch { backup = ''; }
+  }
+  const body = renderRegistry(info, data);
+  const tmp = file + '.tmp-' + process.pid;
+  fs.writeFileSync(tmp, body, 'utf8');
+  fs.renameSync(tmp, file);
+  return { file, backup, bytes: Buffer.byteLength(body, 'utf8') };
+}
+
+// ---------------------------------------------------------------- 计划
+
+function stamp() {
+  const d = new Date();
+  const p = (n) => String(n).padStart(2, '0');
+  return d.getFullYear() + p(d.getMonth() + 1) + p(d.getDate()) + '_' + p(d.getHours()) + p(d.getMinutes()) + p(d.getSeconds());
+}
+
+/** 归档旧计划到任务根 _archive/，返回归档路径；没有旧计划返回空串。 */
+export function archivePlan(ws, info) {
+  const rel = planRelPath(ws, info);
+  if (!rel) return '';
+  const abs = path.join(String(ws || ''), rel);
+  if (!isFile(abs)) return '';
+  const dir = path.join(path.dirname(abs), '_archive');
+  fs.mkdirSync(dir, { recursive: true });
+  const dst = path.join(dir, 'PLAN_' + stamp() + '.md');
+  fs.renameSync(abs, dst);
+  return dst;
+}
+
+export function readPlan(ws, info) {
+  const rel = planRelPath(ws, info);
+  const abs = rel ? path.join(String(ws || ''), rel) : '';
+  if (!abs || !isFile(abs)) return { rel, exists: false, text: '' };
+  try { return { rel, exists: true, text: readUtf8(abs) }; }
+  catch { return { rel, exists: true, text: '', error: '读取失败' }; }
+}
+
+/** 写计划：先归档旧计划，再原子写入。返回 { rel, archived, bytes }。 */
+export function writePlan(ws, info, text) {
+  const rel = planRelPath(ws, info);
+  if (!rel) throw new Error('没有可写的计划路径：角色未定');
+  const archived = archivePlan(ws, info);
+  const abs = path.join(String(ws || ''), rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  const body = String(text || '');
+  const tmp = abs + '.tmp-' + process.pid;
+  fs.writeFileSync(tmp, body, 'utf8');
+  fs.renameSync(tmp, abs);
+  return { rel, archived, bytes: Buffer.byteLength(body, 'utf8') };
+}
+
+/** 把计划写入本任务注册的「计划」一节；注册不存在时返回 false。 */
+export function pointRegistryToPlan(ws, info) {
+  const reg = readRegistry(ws, info);
+  if (!reg.exists) return false;
+  const rel = planRelPath(ws, info);
+  const data = { structure: reg.data.structure, files: reg.data.files, plan: rel };
+  writeRegistry(ws, info, data);
+  return true;
+}

package/src/templates/Changelog.skeleton.md

@@ -1,7 +1,7 @@
-# Global Handover Changelog（全局交接变更日志）
+# 全局交接台账
 
-> 追加式历史日志。每次改动 _Control_Center 的全局规则、结构或 Global_Handover.md 本身时，追加一行。
-> 由插件 ho_changelog 按格式追加（新行插在最新一行之前）。
+> 追加式历史记录。每次修改 `_Control_Center` 的全局规则、结构或 `Global_Handover.md` 本身时，追加一行。
+> 由插件 `ho_changelog` 按格式追加（新行插在最新一行之前）。
 
 ## 变更记录
 

package/src/templates/Charter.skeleton.md

@@ -1,13 +1,13 @@
 # Workspace Charter（骨架）
 
-> 本文件由 dsh-handover 首次安装向导生成，只含可运行所需的最小内容；按需继续写。
-> 铁律：§8.1.1.4 那 24 行是唯一正文来源，任何项目库的 RULES.md 都要逐字复制它（外加一行「上下文水位自查」）。改这里就必须同步改所有库。
+> 本文件由 dsh-handover 首次安装向导生成，只含可运行所需的最小内容；其余内容按需补充。
+> 铁律：§8.1.1.4 的 24 行是唯一正文来源，任何项目库的 RULES.md 都须逐字复制该节（外加一行「上下文水位自查」）。修改本节须同步修改全部库。
 
 ## 8. 工程约束
 
-### 8.1.1.4 项目侧通用约束条（可直接粘贴；改这里就要重新同步所有项目）
+### 8.1.1.4 项目侧通用约束条（可直接粘贴；修改本节须重新同步全部项目）
 
-> 同步方式＝把下面代码块的内容逐行复制进 `Projects/<项目名>/<库名>/RULES.md`，再加一行「上下文水位自查」。
+> 同步方式：将下列代码块内容逐行复制进 `Projects/<项目名>/<库名>/RULES.md`，并追加一行「上下文水位自查」。
 
 ```markdown
 **运行期省 token（通用约束；项目无关，全部在役项目共用这一份正文；数值按 27 个退役会话跨项目实测定）**
@@ -41,13 +41,17 @@
 
 ## 9. 上下文水位自查
 
-每个项目库的 `RULES.md` 必须含一行「上下文水位自查」（说明该库会话在多少水位时写交接、多少时换任）。
-闸门（ho_gate）会逐库检查：标题行在、24 行正文一行不缺、水位自查在。缺任何一项，该库判红。
+每个项目库的 `RULES.md` 应含一行「上下文水位自查」。水位 35% 写毕交接，水位 50% 不再新开任务，水位 85% 为硬顶；压缩至多 3 次，第 4 次换任。
+`ho_gate` 会逐库检查：标题行存在、24 行正文一行不缺、水位自查存在。缺任何一项，该库判定为未通过。
 
 ## 10. 工作区约定
 
-- 全局交接：`_Control_Center/records/Global_Handover.md`（ho_handover 读写，写前自动备份）
-- 台账：`_Control_Center/records/Global_Changelog.md`（ho_changelog 按格式追加）
-- 会话提示词模板：`_Control_Center/templates/Prompt_Templates.md`（ho_sessions 的 action=prompt 渲染）
+- 全局交接：`_Control_Center/records/Global_Handover.md`（由 `ho_handover` 读写，整篇重写前先归档）
+- 台账：`_Control_Center/records/Global_Changelog.md`（由 `ho_changelog` 按格式追加）
+- 会话提示词模板：`_Control_Center/templates/Prompt_Templates.md`（由 `ho_sessions` 的 `action=prompt` 渲染）
+- 体系注册：全局总注册 `_Control_Center/records/systems.md`（只列各任务体系文件路径），各任务一份 `System.md`（全局任务 `_Control_Center/tasks/<任务名>/System.md`、项目 `_Project_Meta/<项目名>/System.md`、杂项 `_Misc/tasks/<任务名>/System.md`）
+- 行动计划：任务根 `PLAN.md`；新建计划前归档旧计划到任务根 `_archive/`
+- 暂任提示词：任务根 `Delegation_Prompt.md`；规则见 `_Control_Center/rules/Delegation_Rules.md`
+- 写作规范：`_Control_Center/standards/写作规范/README.md`（W-01 至 W-42）
 - 项目库：`Projects/<项目名>/<库名>/`，每库一份 `RULES.md`；项目交接在 `_Project_Meta/<项目名>/Handover.md`
 - 杂项：`_Misc/tasks/<任务短名>/`；归档 `_Archives/`；临时与快照 `_Temp/`

package/src/templates/Handover.global.skeleton.md

@@ -1,6 +1,6 @@
-# 全局 交接文档
+# 全局交接文档
 
-> 本文件由 **dsh-handover 首次安装向导**生成。§7 里那行 session id 是**占位**——第一个全局会话接手时把它换成本机真实的 id。
+> 本文件由 dsh-handover 首次安装向导生成。§7 中带 session id 的行是占位，第一个全局会话接手时将其换成本机真实的 id。
 
 ## 0. 身份与寻址
 
@@ -12,21 +12,23 @@
 | 接任 | 无（首任） |
 | 上级、报告对象 | 用户 |
 | 本文件 | _Control_Center/records/Global_Handover.md |
-| 冲突以谁为准 | rules/Workspace_Charter.md |
+| 冲突以谁为准 | _Control_Center/rules/Workspace_Charter.md |
 | 修订 | 首次安装向导生成 |
 
 ## 1. 正在做的事
 
 | 项 | 现状 |
 |---|---|
-| 初始化 | 工作区骨架已生成；等第一个标题含「全局」的会话接手 |
+| 初始化 | 工作区骨架已生成；等待第一个标题含「全局」的会话接手 |
+| 体系注册 | 全局总注册已建立路径清单，尚无任务入口；任务建立后由全局增行 |
 
 ## 2. 下一步
 
 | # | 动作 | 落点 | 完成判据 |
 |---|---|---|---|
-| 1 | 全局会话接手：核闸门、把 §0 身份信息填实 | 本文件 §0 | ho_gate 三项全绿 |
-| 2 | 按需新建项目库 | Projects/ | 各库 RULES.md 24/24 ＋ 上下文水位自查 |
+| 1 | 全局会话接手：核对闸门、补全 §0 身份信息 | 本文件 §0 | `ho_gate` 3 项全部通过 |
+| 2 | 按需新建项目库 | Projects/ | 各库 RULES.md 24/24 且含上下文水位自查 |
+| 3 | 建立任务体系注册并登记全局总注册 | `_Control_Center/records/systems.md` | `ho_docmap` 检查路径全部有效 |
 
 ## 3. 待用户决定
 
@@ -36,18 +38,23 @@
 
 | # | 用户原话要点 | 状态 | 落在哪 |
 |---|---|---|---|
-| 1 | 安装插件并在指定目录建好全局根 | 已落地 | 本文件 |
+| 1 | 安装插件并在指定目录建立全局根 | 已落地 | 本文件 |
 
-## 5. 坑点与禁区
+## 5. 风险与禁区
 
-- 禁区：改 §8.1.1.4 那 24 行正文会让所有项目库对不上——要改就同步改全部库。
+- 禁区：修改 §8.1.1.4 的 24 行正文后，各项目库的 `RULES.md` 会与本章程不一致；确需修改须同步全部库。
+- 风险：项目库内文件由该项目会话自行修改；全局代写会使交接与库内事实分离。
 
 ## 6. 关键路径
 
-- 交接：_Control_Center/records/Global_Handover.md
-- 规则：_Control_Center/rules/Workspace_Charter.md
-- 台账：_Control_Center/records/Global_Changelog.md
-- 提示词模板：_Control_Center/templates/Prompt_Templates.md
+- 交接：`_Control_Center/records/Global_Handover.md`
+- 规则：`_Control_Center/rules/Workspace_Charter.md`
+- 体系注册：`_Control_Center/records/systems.md`（全局总注册）、`_Control_Center/tasks/` 下各全局任务的 `System.md`
+- 计划：各全局任务根 `PLAN.md`
+- 暂任规则：`_Control_Center/rules/Delegation_Rules.md`
+- 写作规范：`_Control_Center/standards/写作规范/README.md`
+- 台账：`_Control_Center/records/Global_Changelog.md`
+- 提示词模板：`_Control_Center/templates/Prompt_Templates.md`
 
 ## 7. 会话 id 对照