dsh-subagent-profile 0.5.0 → 0.5.1

package/lib/core/data-maintenance.mjs

@@ -0,0 +1,139 @@
+// lib/core/data-maintenance.mjs — 设置页数据维护（四区清理 + 快照管理路由）。
+// 一个入口四区（避免多按钮）：① 候选/建议清理（进化资产域全清）② 快照清理
+// （snapshots/ 一键清理）③ 提醒中心已处理归档（只移出活动列表，存储与
+// governance-audit 保留——提醒=审计记录，绝不物理删除）④ 重置统计（dispatch.jsonl
+// 封存为 dispatch-archive-<ts>.jsonl，历史台账归档保留、统计从零开始；summaries.json
+// 置空重建）。每次清理记一条治理审计（kind: data-cleared / reminder-archived /
+// stats-reset，字段 target/count/ts）。快照列表/开关/单条查看路由同驻本模块
+// （快照域装配与清除口径单一来源）。CSRF 与 loopback 守卫由 createHttpRoutes
+// 入口统一完成，本模块只做解析与执行。
+
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { json, readBody, persistOk } from './http-helpers.mjs';
+import { writeSummaries } from './evolution-summary.mjs';
+import { SNAPSHOT_CAP } from './snapshots.mjs';
+
+// ④ 重置统计执行：活动台账封存（rename，内容字节不变）+ 空台账重建 + summaries
+// 置空。归档名有意不匹配轮转封存件模式（dispatch-<seq>-<ts>.jsonl）：金丝雀基线
+// 不再读入（统计从零开始），后续自动轮转也不会淘汰（决策留痕保留）。
+function resetStats(deps) {
+  const dir = dirname(deps.dispatchFile);
+  let count = 0;
+  let archivedFile = null;
+  if (existsSync(deps.dispatchFile)) {
+    try {
+      count = readFileSync(deps.dispatchFile, 'utf8').split('\n').filter((line) => line.trim() !== '').length;
+    } catch { count = 0; }
+    if (count > 0) {
+      const stamp = Date.now();
+      let archive = join(dir, `dispatch-archive-${stamp}.jsonl`);
+      let attempt = 0;
+      while (existsSync(archive)) {
+        attempt += 1;
+        archive = join(dir, `dispatch-archive-${stamp}-${attempt}.jsonl`);
+      }
+      try {
+        mkdirSync(dir, { recursive: true });
+        renameSync(deps.dispatchFile, archive);
+        archivedFile = basename(archive);
+      } catch (error) {
+        deps.logger.warn(`[dsh-subagent-profile] 台账封存失败（${error instanceof Error ? error.message : String(error)}），统计未重置`);
+        return { count: 0, error: '台账封存失败，统计未重置' };
+      }
+    }
+  }
+  try {
+    writeFileSync(deps.dispatchFile, '', 'utf8');
+    writeSummaries(deps.summariesFile, { l1: {}, l2: {} });
+  } catch (error) {
+    deps.logger.warn(`[dsh-subagent-profile] 统计重建失败（${error instanceof Error ? error.message : String(error)}）`);
+    return { count, archivedFile, error: '统计重建失败' };
+  }
+  deps.recordAudit({ kind: 'stats-reset', target: 'stats', count, ts: Date.now(), ...(archivedFile !== null ? { archivedFile } : {}) });
+  return { count, archivedFile };
+}
+
+export function createDataMaintenance({ dispatchFile, summariesFile, snapshots, reminderStore, evolution, logger, store, recordAudit = () => {} } = {}) {
+  const deps = { dispatchFile, summariesFile, snapshots, reminderStore, evolution, logger, store, recordAudit };
+  return {
+    // 四区清理：非法 zone 返回 null（调用方 400）；成功返回 { count, ... }。
+    // 审计一次清理一条（target/count/ts），快照清理沿用 B8 口径 kind=data-cleared。
+    clean(zone) {
+      if (zone === 'candidates') {
+        const count = deps.evolution !== undefined && typeof deps.evolution.purgeCandidates === 'function' ? deps.evolution.purgeCandidates() : 0;
+        deps.recordAudit({ kind: 'data-cleared', target: 'candidates', count, ts: Date.now() });
+        return { count };
+      }
+      if (zone === 'snapshots') {
+        const count = deps.snapshots !== undefined && typeof deps.snapshots.clear === 'function' ? deps.snapshots.clear() : 0;
+        deps.recordAudit({ kind: 'data-cleared', target: 'snapshots', count, ts: Date.now() });
+        return { count };
+      }
+      if (zone === 'reminders') {
+        const count = deps.reminderStore !== undefined && typeof deps.reminderStore.archiveActed === 'function' ? deps.reminderStore.archiveActed() : 0;
+        deps.recordAudit({ kind: 'reminder-archived', target: 'reminders', count, ts: Date.now() });
+        return { count };
+      }
+      if (zone === 'stats') return resetStats(deps);
+      return null;
+    },
+  };
+}
+
+// ── 路由处理（快照管理 + 数据维护 + 提醒归档视图）─────────────────────────────
+
+function handleSnapshotsList(deps, res) {
+  if (deps.snapshots === undefined) return json(res, 404, { ok: false, error: '配置快照域未装配' });
+  return json(res, 200, {
+    ok: true,
+    snapshotEnabled: typeof deps.store.loadSnapshotEnabled === 'function' ? deps.store.loadSnapshotEnabled() : false,
+    count: deps.snapshots.count(),
+    cap: SNAPSHOT_CAP,
+    entries: deps.snapshots.list(),
+  });
+}
+
+async function handleSnapshotsSetEnabled(deps, req, res) {
+  const body = await readBody(req);
+  const next = !!(body && body.snapshotEnabled === true);
+  const persist = deps.store.persistSnapshotEnabled(next);
+  return persistOk(res, { snapshotEnabled: deps.store.loadSnapshotEnabled() }, persist);
+}
+
+function handleSnapshotView(deps, url, res) {
+  const id = url.searchParams.get('id') ?? '';
+  const snapshot = deps.snapshots !== undefined ? deps.snapshots.view(id) : null;
+  if (snapshot === null) return json(res, 404, { ok: false, error: '快照不存在或已损坏' });
+  return json(res, 200, { ok: true, snapshot });
+}
+
+async function handleMaintenanceClean(deps, req, res) {
+  const body = await readBody(req);
+  const zone = typeof body.zone === 'string' ? body.zone : '';
+  if (zone === '') return json(res, 400, { ok: false, error: 'zone 不能为空' });
+  if (deps.maintenance === undefined) return json(res, 404, { ok: false, error: '数据维护入口未装配' });
+  const result = deps.maintenance.clean(zone);
+  if (result === null) return json(res, 400, { ok: false, error: 'zone 无效（candidates/snapshots/reminders/stats）' });
+  if (result.error !== undefined) return json(res, 500, { ok: false, error: result.error });
+  return json(res, 200, { ok: true, zone, count: result.count, ...(result.archivedFile !== undefined ? { archivedFile: result.archivedFile } : {}) });
+}
+
+function handleRemindersArchived(deps, url, res) {
+  const offset = Number.parseInt(url.searchParams.get('offset') ?? '0', 10);
+  const limit = Number.parseInt(url.searchParams.get('limit') ?? '20', 10);
+  const page = deps.reminderStore !== undefined && typeof deps.reminderStore.listArchived === 'function'
+    ? deps.reminderStore.listArchived({ offset, limit })
+    : { reminders: [], total: 0, offset: 0, limit: 20 };
+  return json(res, 200, { ok: true, ...page });
+}
+
+// 数据维护域路由分发：只处理本域路径，未知交给统一 404。
+export async function routeDataMaintenance(deps, req, res, url, sub) {
+  if (req.method === 'GET' && sub === '/snapshots') return handleSnapshotsList(deps, res);
+  if (req.method === 'POST' && sub === '/snapshots/set-enabled') return handleSnapshotsSetEnabled(deps, req, res);
+  if (req.method === 'GET' && sub === '/snapshot') return handleSnapshotView(deps, url, res);
+  if (req.method === 'POST' && sub === '/maintenance/clean') return handleMaintenanceClean(deps, req, res);
+  if (req.method === 'GET' && sub === '/reminders/archived') return handleRemindersArchived(deps, url, res);
+  return json(res, 404, { ok: false, error: `未知路由 ${sub}` });
+}

package/lib/core/delegation.mjs

@@ -91,6 +91,22 @@ export function collectChildCalls(session, maxCalls = 6) {
   return { calls, truncated: totalCalls > maxCalls, totalCalls };
 }
 
+// childTotalTokens：宿主 tokenMeter 启发式估算（surface 口径，非计费 usage）；仅
+// completed 结算时测量，服务缺失/非函数/抛错均返回 undefined（fail-soft）。
+export function measureChildTokens(getService, session) {
+  if (session === undefined || session === null) return undefined;
+  const meter = getService('tokenMeter');
+  if (meter === undefined || typeof meter.measure !== 'function') return undefined;
+  try {
+    const measured = meter.measure(session);
+    return measured !== null && typeof measured === 'object' && typeof measured.totalTokens === 'number'
+      ? measured.totalTokens
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 // 把一个后台 one-shot run 结算为带前台同等可观测元数据的任务结果。非 completed
 // 停因转 failed（aborted => killed，官方词汇表）并附部分输出；硬失败绝不 reject
 // 任务。

package/lib/core/dispatch-tool.mjs

@@ -10,7 +10,7 @@ import { defineTool } from './shims.mjs';
 import { textFrom, stopReasonError, withPartialText, pruneBlocks, assertResultSchemaConsistency, trustLabel, trustAudit, dispatchLabel } from './pure.mjs';
 import { resolveWhitelist } from './whitelist.mjs';
 import { recordEscapeAllow } from './escape.mjs';
-import { settleStart, collectChildUsage, collectChildCalls } from './delegation.mjs';
+import { settleStart, collectChildUsage, collectChildCalls, measureChildTokens } from './delegation.mjs';
 import { DISPATCH_OUTPUT_SCHEMA, DISPATCH_PARAMETERS, DISPATCH_RENDER, imageTextOf, normalizeReasoningEffort } from './dispatch-schema.mjs';
 import { createDecisionTrace, finalizeTrace, assertTraceSize, parentContextOf, requestedOf, effectiveMeta, recordApprovalGate, recordFailure, profileSnapshotOf } from './decision-trace.mjs';
 import { profileDirectoryRows } from './profile-directory.mjs';
@@ -207,22 +207,6 @@ async function runBackground(args, merged, meta, request, parent, deps, pruneRes
   return out;
 }
 
-// childTotalTokens：宿主 tokenMeter 启发式估算（surface 口径，非计费 usage）；仅
-// completed 结算时测量，服务缺失/非函数/抛错均返回 undefined（fail-soft）。
-function measureChildTokens(getService, session) {
-  if (session === undefined || session === null) return undefined;
-  const meter = getService('tokenMeter');
-  if (meter === undefined || typeof meter.measure !== 'function') return undefined;
-  try {
-    const measured = meter.measure(session);
-    return measured !== null && typeof measured === 'object' && typeof measured.totalTokens === 'number'
-      ? measured.totalTokens
-      : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
 // 仅 completed 结算时测量一次（tokenMeter 估算 + usage 分解 + 调用明细），dispose
 // 前读子 session 保证事件流完整；全 fail-soft（缺失/抛错 → undefined）绝不阻断结算。
 function measureForegroundRun(deps, run) {
@@ -345,8 +329,7 @@ async function runDispatch(args, exec, deps) {
     const meta = buildMeta(args, merged, parent);
     const request = buildRequest(args, merged, parent, exec.signal);
     const adoptionBase = { promptExcerpt: promptExcerptOf(args?.prompt), requestedModel: merged.model, parentModel: parent.options?.model };
-    // 结果回收默认剪枝：在 textFrom 前复用宿主 toolResultPruner.pruneContent 预剪；
-    // pruner 缺失时 pruneBlocks 回退为不剪（剪枝是增强、非硬依赖）。
+    // 结果回收默认剪枝：textFrom 前复用宿主 toolResultPruner.pruneContent 预剪；pruner 缺失时 pruneBlocks 回退为不剪（增强、非硬依赖）。
     const pruneResultOutput = (blocks) => pruneBlocks(blocks, deps.getService('toolResultPruner'));
     logDispatchDecision(deps.logger, args, merged, parent);
     // 总预算守卫：前/后台在 execute 入口占并发额度（continuable 不占），结算处 release
@@ -354,6 +337,8 @@ async function runDispatch(args, exec, deps) {
     guardHandle = applyBudgetGate(deps, parent, args, merged, trace);
     // 派发台账静态元数据（双栏 cfg/task 指纹），分支结算处补 child_id+outcome 写盘。
     const base = deps.evoLedger.baseEntry({ parent, args, merged, mode, effectiveModelSource: trace.requested.source });
+    // 配置快照（开关关恒跳过；失败绝不阻断派发）：记录完整 config 供「保存为方案」复现。
+    if (deps.snapshots !== undefined && typeof deps.snapshots.capture === 'function') { try { deps.snapshots.capture({ profileKey: profileKeyOf(base.effective), config: merged, mode }); } catch { /* fail-soft */ } }
     recordEscapeAllow(deps, parent, merged, trace);
     if (args.continuable === true) return await runContinuable(args, merged, meta, parent, exec, deps, trace, effectiveAllow, base);
     if (args.run_in_background === true) return await runBackground(args, merged, meta, request, parent, deps, pruneResultOutput, t0, trace, guardHandle, base, exec);
@@ -365,8 +350,8 @@ async function runDispatch(args, exec, deps) {
   }
 }
 
-export function createDispatchTool({ register, store, getEnabled, getService, logger, subagents, catalog, ledger, guard, evoLedger, backgroundLedger, adoptionTracker, getEscapeSet, getEvolutionAdvice }) {
-  const deps = { store, getEnabled, getService, logger, subagents, catalog, ledger, guard, evoLedger, backgroundLedger, adoptionTracker, getEscapeSet, getEvolutionAdvice };
+export function createDispatchTool({ register, store, getEnabled, getService, logger, subagents, catalog, ledger, guard, evoLedger, backgroundLedger, adoptionTracker, getEscapeSet, getEvolutionAdvice, snapshots }) {
+  const deps = { store, getEnabled, getService, logger, subagents, catalog, ledger, guard, evoLedger, backgroundLedger, adoptionTracker, getEscapeSet, getEvolutionAdvice, snapshots };
   const dispatchTool = defineTool({
     name: 'dispatch',
     description: '派发子任务给派生子 Agent，可逐个覆盖其 preset、model、provider、推理档位、persona、工具白名单、token 预算或递归深度。优先使用已保存的 profile，仅少数字段需要临时覆盖时才传 per-call 参数；未指定 model 时子代理继承父模型，查资料/汇总/读文件等轻任务请优先考虑 cheap 方案或显式 model=flash。细粒度路由/授权发现请用官方 subagent 工具 + list_subagent_models（provider/model 成对、受本会话官方模型选择白名单）；dispatch 只管方案（profile）及方案内覆盖。前台等待结果；run_in_background: true 启动后台任务（单轮即弃）；continuable: true 启动持久子 Agent，后续轮次经 send_message 工具延续对话；失败经结算通知回报；超时可 send_message 追问。失败动作映射：stopReason=max-tokens→用 profiles_query 降档或 profile 加 maxTokens；error→换 profile/preset；refusal→重述任务；连续失败→告知用户。前瞻：continuable 模式忽略 preset 换用与 reasoningEffort（结果以 ignored 提示）。',

package/lib/core/evolution-assets.mjs

@@ -81,6 +81,18 @@ function sweepExpiredAssets() {
   return 0;
 }
 
+// 数据维护清理：删除全部资产文件 + 索引置空（审计由调用方记）。返回删除条数；
+// 单个文件删除失败不阻断其余（best effort）。
+function purgeAllAssets(state) {
+  const count = state.index.assets.length;
+  for (const entry of state.index.assets) {
+    try { rmSync(join(state.dir, `${entry.id}.json`), { force: true }); } catch { /* best effort */ }
+  }
+  state.index.assets = [];
+  state.persistIndex();
+  return count;
+}
+
 // 状态流转：资产文件先行（合并 patch + 状态 + updatedAt），成功后同步索引。
 function transitionAsset(state, id, nextState, patch) {
   const safe = safeAssetId(id);
@@ -161,6 +173,7 @@ export function createEvolutionAssets({ dshHome, logger, onGovernanceFailure = (
       .filter((e) => e.profileKey === profileKey && UNRESOLVED_STATES.has(e.state))
       .map((e) => ({ ...e })),
     countBySource: (source) => state.index.assets.filter((e) => e.source === source).length,
+    purgeAll: () => purgeAllAssets(state),
     ids: () => state.index.assets.map((e) => e.id),
     sweepExpired: (now) => sweepExpiredAssets(state, now),
   };

package/lib/core/evolution-engine.mjs

@@ -409,5 +409,6 @@ export function createEvolutionEngine({
     evaluateCanaries: (now = Date.now()) => evaluateCanaries(deps, now),
     evolutionStatus: () => evolutionStatusOf({ getApplyEnabled: deps.getApplyEnabled, summaries: deps.getSummaries() }),
     backtest: (records, candidateConfig, opts) => deps.getHoldoutBacktest()(records, candidateConfig, opts),
+    purgeCandidates: () => assets.purgeAll(),
   };
 }

package/lib/core/evolution-routes.mjs

@@ -198,17 +198,27 @@ async function handleEvolutionRegenerate(deps, req, res) {
   return json(res, 200, { ok: true, ...result });
 }
 
-// 保存为方案：把建议来源的当前派发配置（身份键可还原的预设/提供方/模型段）存成
-// 新方案，便于复用与对比。自定义人格与工具过滤原文未留存（台账只存存在性），
-// 不在新方案内。身份键无可还原字段时 400。
+// 保存为方案：优先从配置快照取（同 profileKey 最近一条快照 → 完整 config，含
+// persona 原文与 toolFilter 全量，可完整复现该笔派发并记 snapshot-used 审计）；
+// 未命中回退「可还原段」逻辑（仅预设/提供方/模型，副注说明隐私取舍）。
+// 身份键无可保存字段时 400。
 async function handleAdviceSaveProfile(deps, req, res) {
   const body = await readBody(req);
   const profileKey = body && typeof body.profileKey === 'string' ? body.profileKey : '';
   if (profileKey === '') return json(res, 400, { ok: false, error: 'profileKey 不能为空' });
-  const from = sourceConfigFromKey(profileKey, {});
+  const snapshot = deps.snapshots !== undefined && typeof deps.snapshots.latestByProfileKey === 'function'
+    ? deps.snapshots.latestByProfileKey(profileKey)
+    : null;
   const config = {};
-  for (const field of ['preset', 'provider', 'model']) {
-    if (typeof from[field] === 'string' && from[field] !== '') config[field] = from[field];
+  if (snapshot !== null && snapshot.config !== null && typeof snapshot.config === 'object') {
+    for (const field of ['preset', 'provider', 'model', 'reasoningEffort', 'maxTokens', 'maxDepth', 'persona', 'toolFilter']) {
+      if (snapshot.config[field] !== undefined) config[field] = snapshot.config[field];
+    }
+  } else {
+    const from = sourceConfigFromKey(profileKey, {});
+    for (const field of ['preset', 'provider', 'model']) {
+      if (typeof from[field] === 'string' && from[field] !== '') config[field] = from[field];
+    }
   }
   if (Object.keys(config).length === 0) {
     return json(res, 400, { ok: false, error: '该配置无可保存字段（未指定预设/提供方/模型）' });
@@ -222,13 +232,19 @@ async function handleAdviceSaveProfile(deps, req, res) {
   }
   if (taken.has(id)) return json(res, 400, { ok: false, error: '方案编号冲突，无法保存' });
   const name = slug.length > 0 ? `建议配置-${slug.slice(0, 16)}` : '建议配置';
-  const { clean, warnings } = sanitizeProfile({ ...config, id, name, description: '来自建议面板的配置快照（仅预设/模型/提供方；人格与工具过滤不落盘，按隐私设计）。便于复用与对比分析。' }, { strict: true });
+  const description = snapshot !== null
+    ? '来自建议面板的配置快照（含自定义人格与工具过滤，取自本机快照）。便于复用与对比分析。'
+    : '来自建议面板的配置快照（仅预设/模型/提供方；人格与工具过滤不落盘，按隐私设计）。便于复用与对比分析。';
+  const { clean, warnings } = sanitizeProfile({ ...config, id, name, description }, { strict: true });
   if (warnings.length > 0) {
     const detail = warnings.map((w) => `${w.field}：${w.reason}`).join('；');
     return json(res, 400, { ok: false, error: `保存被拒绝：${detail}` });
   }
   deps.store.profiles.set(clean.id, { ...clean, persisted: true });
-  return persistOk(res, { id: clean.id, name: clean.name }, deps.store.persistProfiles());
+  if (snapshot !== null && typeof deps.recordAudit === 'function') {
+    deps.recordAudit({ kind: 'snapshot-used', profile_key: profileKey, file: typeof snapshot.file === 'string' ? snapshot.file : '' });
+  }
+  return persistOk(res, { id: clean.id, name: clean.name, fromSnapshot: snapshot !== null }, deps.store.persistProfiles());
 }
 
 export { handleEvolutionAssets, handleEvolutionApply, handleEvolutionRollback, handleEvolutionRegenerate, handleAdviceSaveProfile, handleSettingsCandidate };

package/lib/core/http-routes.mjs

@@ -10,6 +10,7 @@ import { profileStatsFromSummaries } from './profile-directory.mjs';
 import { costSummaryFromSummaries } from './cost-evidence.mjs';
 import { json, readBody, persistOk } from './http-helpers.mjs';
 import { handleEvolutionAssets, handleEvolutionApply, handleEvolutionRollback, handleEvolutionRegenerate, handleAdviceSaveProfile, handleSettingsCandidate } from './evolution-routes.mjs';
+import { createDataMaintenance, routeDataMaintenance } from './data-maintenance.mjs';
 
 // 只有 loopback 接口可以驱动设置 HTTP 路由。
 const LOOPBACKS = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
@@ -381,6 +382,7 @@ async function routeRequest(deps, req, res, url, sub) {
   if (req.method === 'POST' && sub === '/advice/save-profile') return handleAdviceSaveProfile(deps, req, res);
   if (req.method === 'POST' && sub === '/settings/candidate') return handleSettingsCandidate(deps, req, res);
   if (req.method === 'POST' && sub === '/options/refresh') return handleRefresh(deps, res);
+  if ((req.method === 'GET' && (sub === '/snapshots' || sub === '/snapshot' || sub === '/reminders/archived')) || (req.method === 'POST' && (sub === '/snapshots/set-enabled' || sub === '/maintenance/clean'))) return routeDataMaintenance(deps, req, res, url, sub);
   if (req.method === 'POST' && sub === '/set-enabled') return handleSetEnabled(deps, req, res);
   if (req.method === 'POST' && sub === '/set-evolution-advice') return handleSetEvolutionAdvice(deps, req, res);
   if (req.method === 'POST' && sub === '/set-escape') return handleSetEscape(deps, req, res);
@@ -394,8 +396,10 @@ async function routeRequest(deps, req, res, url, sub) {
   json(res, 404, { ok: false, error: `未知路由 ${sub}` });
 }
 
-export function createHttpRoutes({ webServer, store, getEnabled, setEnabled, syncTool, catalog, ledger, backgroundLedger, draftsStore, applyDraft, getAudit, getEvolutionAdvice, setEvolutionAdvice, getEscapeEnabled, setEscapeEnabled, escape, refreshAdvice, summariesFile, dispatchFile, adviceWhitelist, previewDraft, reminderStore, adviceSource, evolution, logger }) {
-  const deps = { store, getEnabled, setEnabled, syncTool, catalog, ledger, backgroundLedger, draftsStore, applyDraft, getAudit, getEvolutionAdvice, setEvolutionAdvice, getEscapeEnabled, setEscapeEnabled, escape, refreshAdvice, summariesFile, dispatchFile, adviceWhitelist, previewDraft, reminderStore, adviceSource, evolution, logger };
+export function createHttpRoutes({ webServer, store, getEnabled, setEnabled, syncTool, catalog, ledger, backgroundLedger, draftsStore, applyDraft, getAudit, getEvolutionAdvice, setEvolutionAdvice, getEscapeEnabled, setEscapeEnabled, escape, refreshAdvice, summariesFile, dispatchFile, adviceWhitelist, previewDraft, reminderStore, adviceSource, evolution, logger, snapshots, recordAudit }) {
+  const deps = { store, getEnabled, setEnabled, syncTool, catalog, ledger, backgroundLedger, draftsStore, applyDraft, getAudit, getEvolutionAdvice, setEvolutionAdvice, getEscapeEnabled, setEscapeEnabled, escape, refreshAdvice, summariesFile, dispatchFile, adviceWhitelist, previewDraft, reminderStore, adviceSource, evolution, logger, snapshots, recordAudit };
+  // 数据维护域装配（快照清理/候选清理/提醒归档/统计重置 + 快照管理路由依赖）。
+  deps.maintenance = createDataMaintenance({ dispatchFile, summariesFile, snapshots, reminderStore, evolution, logger, store, recordAudit });
   const handler = async (req, res) => {
     const remote = req.socket?.remoteAddress;
     if (!LOOPBACKS.has(remote)) return json(res, 403, { ok: false, error: '仅限本机访问' });

package/lib/core/model-policy.mjs

@@ -75,3 +75,30 @@ export function assertOfficialModelRoute(policy, provider, model) {
   const allowed = policy.allowedModels.some((route) => route.provider === provider && route.model === model);
   if (!allowed) throw new Error(officialModelRejectMessage(provider, model, policy.allowedModels));
 }
+
+// 官方模型选择可见性行（dispatch:profiles 静态段 note 追加）：投影存在（已启用）
+// 时列出官方允许清单；投影缺失（未启用）给「无官方发现工具」与 profiles_query
+// 授权路由引导。读取异常（形状校验 throw）fail-soft：debug 日志后按未启用展示，
+// 绝不影响 profiles 目录段本身。
+export function officialModelSelectionLine(ctx, context, logger) {
+  try {
+    const session = context?.agent?.session;
+    const policy = readModelSelectionPolicy(ctx, session);
+    if (policy.configured === true) {
+      const allowed = policy.allowedModels.map((route) => `${route.provider}/${route.model}`).join('、');
+      return `官方子代理模型选择：已启用（允许：${allowed}）`;
+    }
+  } catch (error) {
+    if (logger !== undefined && typeof logger.debug === 'function') {
+      logger.debug('[dsh-subagent-profile] 官方模型选择投影读取失败，按未启用提示：' + (error instanceof Error ? error.message : String(error)));
+    }
+  }
+  return '官方子代理模型选择：未启用（无官方发现工具；授权路由请用 profiles_query 查看在册状态）';
+}
+
+// dispatch:profiles 段包装：目录文本非空时追加官方模型选择可见性行。静态段辅助
+// 驻留 lib/core，index.mjs 装配不承载新增文案（行门）。
+export function appendOfficialVisibilityLine(baseText, ctx, context, logger) {
+  if (typeof baseText !== 'string' || baseText === '') return '';
+  return baseText + '\n' + officialModelSelectionLine(ctx, context, logger);
+}

package/lib/core/profiles-store.mjs

@@ -184,11 +184,12 @@ function persistProfiles(state, logger) {
 // （派发优化建议注入，默认关，需显式开）+ escapeEnabled（逃生舱放行，默认关——信任
 // 底板，仅设置页显式 opt-in 可放开）+ applyEnabled（进化候选生成与应用写路径，默认
 // 关——应用能力只由人显式开启）+ candidateMode/candidateTtlH（候选方案更新策略与
-// 有效期，用户可配置）。开关共用同一 state.json，读写整份对象以互不覆盖；
+// 有效期，用户可配置）+ snapshotEnabled（派发配置快照，默认关——本机私有域，仅
+// 设置页显式 opt-in 开启）。开关共用同一 state.json，读写整份对象以互不覆盖；
 // 缺失文件回退默认值（全新部署），损坏文件 fail-closed（全关，绝不静默回退
 // enabled:true —— 安全禁用会被撤销），内存态仍驱动本进程。
-const STATE_DEFAULTS = { enabled: true, evolutionAdvice: false, escapeEnabled: false, applyEnabled: false, candidateMode: 'auto', candidateTtlH: 24 };
-const STATE_FAIL_CLOSED = { enabled: false, evolutionAdvice: false, escapeEnabled: false, applyEnabled: false, candidateMode: 'auto', candidateTtlH: 24 };
+const STATE_DEFAULTS = { enabled: true, evolutionAdvice: false, escapeEnabled: false, applyEnabled: false, candidateMode: 'auto', candidateTtlH: 24, snapshotEnabled: false };
+const STATE_FAIL_CLOSED = { enabled: false, evolutionAdvice: false, escapeEnabled: false, applyEnabled: false, candidateMode: 'auto', candidateTtlH: 24, snapshotEnabled: false };
 
 // 候选有效期小时数归一：0（不自动过期）或 1~8760（一年内）的整数原样保留，
 // 其余值回退默认 24 小时（读取与写入共用同一口径，防坏值落盘）。
@@ -208,6 +209,7 @@ function loadState(state) {
       applyEnabled: parsed.applyEnabled === true,
       candidateMode: parsed.candidateMode === 'manual' ? 'manual' : 'auto',
       candidateTtlH: validCandidateTtlH(parsed.candidateTtlH),
+      snapshotEnabled: parsed.snapshotEnabled === true,
     };
   } catch (error) {
     // fail-closed（S2）：损坏的 state.json 若回退 enabled:true，会把「安全禁用」静默撤销。
@@ -294,6 +296,8 @@ export function createProfileStore({ dshHome, logger, onGovernanceFailure = () =
     persistCandidateMode: (value) => persistState(state, { candidateMode: value === 'manual' ? 'manual' : 'auto' }, onGovernanceFailure),
     loadCandidateTtlH: () => loadState(state).candidateTtlH,
     persistCandidateTtlH: (value) => persistState(state, { candidateTtlH: validCandidateTtlH(value) }, onGovernanceFailure),
+    loadSnapshotEnabled: () => loadState(state).snapshotEnabled,
+    persistSnapshotEnabled: (value) => persistState(state, { snapshotEnabled: value === true }, onGovernanceFailure),
     // getAllowFailOpen：cost guard 必须在派发时读取迁移标志；
     // loadProfiles/persistProfiles 持有该写入。
     getAllowFailOpen: () => state.allowFailOpen,

package/lib/core/reminder-store.mjs

@@ -65,6 +65,10 @@ function loadState(stateFile, state, warn) {
         createdAt: Number.isFinite(raw.createdAt) ? raw.createdAt : 0,
         action: typeof raw.action === 'string' ? raw.action : null,
         actedAt: Number.isFinite(raw.actedAt) ? raw.actedAt : null,
+        // 归档标记：数据维护「归档已处理提醒」置位；归档只移出活动列表、绝不物理删除
+        // （提醒=审计记录，存储与 governance-audit 保留）。
+        archived: raw.archived === true,
+        archivedAt: Number.isFinite(raw.archivedAt) ? raw.archivedAt : null,
       });
     }
   } catch (error) {
@@ -117,6 +121,8 @@ function recordReminder(state, persist, audit, { severity, kind, title, detail,
     createdAt: Date.now(),
     action: null,
     actedAt: null,
+    archived: false,
+    archivedAt: null,
   };
   state.reminders.push(reminder);
   if (state.reminders.length > state.maxReminders) state.reminders.shift();
@@ -153,8 +159,34 @@ function actOnReminder(state, persist, audit, id, action) {
 }
 
 function listReminders(state, unreadOnly) {
-  const all = [...state.reminders].reverse();
-  return unreadOnly ? all.filter((r) => r.unread === true) : all;
+  const active = state.reminders.filter((r) => r.archived !== true).reverse();
+  return unreadOnly ? active.filter((r) => r.unread === true) : active;
+}
+
+// 归档视图：只读、按处理时间倒序、分页（防大量已处理条目一次性渲染卡 UI）。
+// 返回 { reminders, total, offset, limit }；坏参数归一安全值。
+function listArchivedReminders(state, offset, limit) {
+  const off = Number.isInteger(offset) && offset >= 0 ? offset : 0;
+  const lim = Number.isInteger(limit) && limit > 0 ? Math.min(limit, 100) : 20;
+  const archived = state.reminders
+    .filter((r) => r.archived === true)
+    .sort((a, b) => (b.archivedAt ?? b.actedAt ?? 0) - (a.archivedAt ?? a.actedAt ?? 0));
+  return { reminders: archived.slice(off, off + lim), total: archived.length, offset: off, limit: lim };
+}
+
+// 归档已处理条目：action 非空且未归档的一并置 archived（只移出活动列表、保留存储）。
+// 返回本次归档条数；审计由调用方按一次清理记一条（数据维护口径）。
+function archiveActedReminders(state, persist) {
+  const now = Date.now();
+  let count = 0;
+  for (const reminder of state.reminders) {
+    if (typeof reminder.action !== 'string' || reminder.action === '' || reminder.archived === true) continue;
+    reminder.archived = true;
+    reminder.archivedAt = now;
+    count += 1;
+  }
+  if (count > 0) persist();
+  return count;
 }
 
 export function createReminderStore({ dshHome, audit = () => {}, warn = () => {}, maxReminders = MAX_REMINDERS } = {}) {
@@ -167,6 +199,8 @@ export function createReminderStore({ dshHome, audit = () => {}, warn = () => {}
     ack: (ids) => ackReminders(state, persist, audit, ids),
     actOn: (id, action) => actOnReminder(state, persist, audit, id, action),
     list: ({ unreadOnly = false } = {}) => listReminders(state, unreadOnly),
-    unreadCount: () => state.reminders.filter((r) => r.unread === true).length,
+    listArchived: ({ offset = 0, limit = 20 } = {}) => listArchivedReminders(state, offset, limit),
+    archiveActed: () => archiveActedReminders(state, persist),
+    unreadCount: () => state.reminders.filter((r) => r.unread === true && r.archived !== true).length,
   };
 }

package/lib/core/snapshots.mjs

@@ -0,0 +1,148 @@
+// lib/core/snapshots.mjs — 派发配置快照域（subagent-evolution/snapshots/）。
+// 开关开启后每次 dispatch effective 形成后写一条完整 config 快照（含 persona 原文
+// 与 toolFilter 全量），供「保存为方案」事后完整复现该笔派发；快照是用户显式
+// opt-in 的本机私有域（不是台账，dispatch.jsonl 不落原文——隐私红线保持）。
+// 原子写（tmp+rename）；索引 snapshots.index.json 记录元数据（无原文），按 ts
+// 倒序读取；损坏文件/索引 fail-soft 跳过；总量护栏：快照 ≤200 条，到上限停止
+// 新写并提示清理（不自动删旧）。import-free（仅 node 内置），可被裸 CI 单测。
+// 审计：snapshot-written（写）/ snapshot-used（保存为方案命中，由调用方记）。
+
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+// 快照总量护栏（B7 定稿值）：到上限停止新写（不自动删旧，提示清理）。
+export const SNAPSHOT_CAP = 200;
+
+// 完整 config 字段集：与 dispatch merged 同源（persona 原文、toolFilter 完整对象）。
+const CONFIG_FIELDS = ['preset', 'provider', 'model', 'reasoningEffort', 'maxTokens', 'maxDepth', 'persona', 'toolFilter'];
+
+// profileKey 摘要（文件名安全前缀，非可逆）。
+function digestOf(profileKey) {
+  return createHash('sha256').update(String(profileKey)).digest('hex').slice(0, 12);
+}
+
+// 原子写（tmp+rename）：崩溃不产生截断文件；失败清理 tmp + warn + 治理审计钩子。
+function atomicWrite(file, payload, logger, onGovernanceFailure) {
+  const tmp = `${file}.tmp`;
+  try {
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
+    renameSync(tmp, file);
+    return { persisted: true };
+  } catch (error) {
+    try { rmSync(tmp, { force: true }); } catch { /* best effort */ }
+    if (logger !== undefined && typeof logger.warn === 'function') {
+      logger.warn(`[dsh-subagent-profile] 配置快照写入失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof onGovernanceFailure === 'function') onGovernanceFailure();
+    return { persisted: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// 读索引；缺失回退空表，损坏/形状不符 fail-soft 从空起步（快照文件仍在，索引可重建）。
+function readIndex(indexFile, logger) {
+  if (!existsSync(indexFile)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(indexFile, 'utf8'));
+    if (parsed !== null && typeof parsed === 'object' && parsed.v === 1 && Array.isArray(parsed.entries)) {
+      return parsed.entries.filter((e) => e !== null && typeof e === 'object' && typeof e.id === 'string');
+    }
+  } catch { /* fail-soft */ }
+  if (logger !== undefined && typeof logger.warn === 'function') {
+    logger.warn('[dsh-subagent-profile] 配置快照索引损坏，按空索引处理（快照文件保留）');
+  }
+  return [];
+}
+
+// 读单个快照文件；缺失/损坏/形状不符返回 null（fail-soft，调用方跳过）。
+function readSnapshotFile(file, logger) {
+  if (!existsSync(file)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'));
+    if (parsed !== null && typeof parsed === 'object' && parsed.v === 1 && typeof parsed.id === 'string' && parsed.config !== null && typeof parsed.config === 'object') {
+      return parsed;
+    }
+  } catch { /* fail-soft */ }
+  if (logger !== undefined && typeof logger.warn === 'function') {
+    logger.warn(`[dsh-subagent-profile] 配置快照文件损坏，跳过：${file}`);
+  }
+  return null;
+}
+
+// dispatch effective 形成后调用：开关关恒跳过；到护栏上限停止新写（不自动删旧）。
+// 幂等键 = 摘要+ts；同键碰撞跳过。审计只记元数据（无 persona/prompt 原文）。
+function captureSnapshot(deps, { profileKey, config, mode }) {
+  if (!deps.getEnabled()) return null;
+  if (deps.state.index.length >= SNAPSHOT_CAP) {
+    if (deps.logger !== undefined && typeof deps.logger.warn === 'function') {
+      deps.logger.warn(`[dsh-subagent-profile] 配置快照已达 ${SNAPSHOT_CAP} 条护栏上限，停止新快照（可在设置页数据维护区清理）`);
+    }
+    return null;
+  }
+  const key = typeof profileKey === 'string' ? profileKey : '(inline)';
+  const ts = Date.now();
+  const id = `${digestOf(key)}-${ts}`;
+  if (deps.state.index.some((e) => e.id === id)) return null;
+  const payload = { v: 1, id, ts, profileKey: key, from: typeof mode === 'string' && mode !== '' ? mode : 'dispatch', config: {} };
+  for (const field of CONFIG_FIELDS) {
+    if (config !== null && typeof config === 'object' && config[field] !== undefined) payload.config[field] = config[field];
+  }
+  const size = Buffer.byteLength(JSON.stringify(payload));
+  const file = join(deps.dir, `${id}.json`);
+  const written = atomicWrite(file, payload, deps.logger, deps.onGovernanceFailure);
+  if (!written.persisted) return null;
+  deps.state.index.push({ key, ts, size, id, from: payload.from });
+  deps.persistIndex();
+  deps.recordAudit({ kind: 'snapshot-written', profile_key: key, file: `${id}.json`, size });
+  return { id, ts, profileKey: key };
+}
+
+// 索引元数据列表（ts 倒序；无 config 原文）。
+function listSnapshots(state) {
+  return [...state.index].sort((a, b) => b.ts - a.ts);
+}
+
+// 单条完整快照（只读查看用；含 persona 原文，UI 默认折叠）。
+function viewSnapshot(deps, id) {
+  if (typeof id !== 'string' || id === '' || !deps.state.index.some((e) => e.id === id)) return null;
+  return readSnapshotFile(join(deps.dir, `${id}.json`), deps.logger);
+}
+
+// 「保存为方案」数据源：按 profileKey 匹配最近一条快照（ts 倒序首条命中）。
+function latestSnapshot(deps, profileKey) {
+  for (const entry of listSnapshots(deps.state)) {
+    if (entry.key !== profileKey) continue;
+    const snapshot = readSnapshotFile(join(deps.dir, `${entry.id}.json`), deps.logger);
+    if (snapshot !== null) return { ...snapshot, file: `${entry.id}.json` };
+  }
+  return null;
+}
+
+// 一键清理：删除全部快照文件 + 索引置空。返回删除条数（审计由调用方记）。
+function clearSnapshots(deps) {
+  const count = deps.state.index.length;
+  for (const entry of deps.state.index) {
+    try { rmSync(join(deps.dir, `${entry.id}.json`), { force: true }); } catch { /* 单个删除失败不阻断其余 */ }
+  }
+  deps.state.index = [];
+  try { rmSync(deps.indexFile, { force: true }); } catch { /* best effort */ }
+  return count;
+}
+
+export function createSnapshotStore({ dshHome, logger, getEnabled = () => false, recordAudit = () => {}, onGovernanceFailure = () => {} } = {}) {
+  const dir = join(dshHome, 'subagent-evolution', 'snapshots');
+  const indexFile = join(dir, 'snapshots.index.json');
+  const state = { index: readIndex(indexFile, logger) };
+  const deps = { dir, indexFile, state, logger, getEnabled, recordAudit, onGovernanceFailure, persistIndex: () => atomicWrite(indexFile, { v: 1, entries: state.index }, logger, onGovernanceFailure) };
+  return {
+    dir,
+    indexFile,
+    capture: (input) => captureSnapshot(deps, input),
+    list: () => listSnapshots(state),
+    view: (id) => viewSnapshot(deps, id),
+    latestByProfileKey: (profileKey) => latestSnapshot(deps, profileKey),
+    count: () => state.index.length,
+    clear: () => clearSnapshots(deps),
+  };
+}