dsh-config-manager 0.1.63 → 0.1.64

package/lib/adapters/json-section.js

@@ -0,0 +1,61 @@
+/**
+ * JSON 分区 adapter 的共享骨架（t31，批次 4）。
+ *
+ * 为什么存在：改动前 9 个「有 JSON 载荷」的分区的 `validate()` 都以**同一段样板**开头 ——
+ * 先是 object 守卫，再是 `data.version !== 1` 守卫，最后才是各分区自己的载荷形状检查；
+ * 这段样板在每个文件里逐字抄了一遍（审计 sync#F-08 / infra#C1）。本模块把它收敛为一份，
+ * 并让「期望版本」直接取自注册表 `dataVersion`（不再各写 `!== 1` 字面量）。
+ *
+ * 与注册表的分工：结构校验的**描述符**（zipPath / 载荷形态 / dataVersion）在
+ * `src/schema/section-registry.ts`；本模块只提供「按该描述符执行校验」的通用算法，
+ * 各 adapter 仍负责自己特有的形状检查（用 `shape` 回调注入）。
+ *
+ * 分层：只 import schema 与 core 的类型 —— 不 import node 内置模块（client bundle 自包含铁律）。
+ */
+import { sectionMeta } from '../schema/section-registry.js';
+/**
+ * JSON 分区通用结构校验骨架。
+ *
+ * 执行顺序（与改造前逐字一致，保证行为等价）：
+ *  1. object 守卫：非对象 → **直接返回**单条 `objectMessageKey` 错误（缺省 `adapter.validate.object`；后续检查不再执行）；
+ *  2. version 守卫：`version !== sectionMeta(sectionId).dataVersion` → push 一条 `version` 错误，
+ *     **不提前返回**（继续做形状检查，与历史实现一致）；
+ *  3. `shape` 回调：分区特有的载荷形状检查（可选）。
+ *
+ * @param sectionId 分区 id —— 同时是 object 错误的默认 subject 与 dataVersion 的查表键
+ * @param data 反序列化后的分区载荷（来自不可信备份 → 必须按 unknown 处理）
+ * @param msg 文案翻译器（adapter 的 `validate(data, msg = zhMsg)` 原样传入）
+ * @param shape 分区特有的形状检查（在 version 守卫之后调用）
+ * @param subject object 错误里的显示名；缺省 = sectionId。历史上 credentials 用的是
+ *   `'credentials'`（而非分区 id `credentialsStatus`），此参数为保留该原文案而存在 ——
+ *   改文案属独立的行为变更，不在本任务射程内。
+ * @param objectMessageKey object 错误的**消息键**（t11 新增，可选）；缺省 `adapter.validate.object`
+ *   （`'{subject} 数据必须是对象'`）。为什么需要它：文件类分区历史上用的是专用键
+ *   `adapter.validate.fileSection`（`'文件分区数据必须是对象'`，**不含** `{subject}` 占位符），
+ *   那是**键**级差异 —— `subject` 参数补不了它（把 subject 拼成"文件分区"后中文模板仍多一个空格），
+ *   而硬换键会让 skills / agentPresets / agentInstructions / sessions / self 五个分区的用户可见
+ *   报错文案一起变。有了这个可选键，那处也能并入骨架而文案逐字不变。
+ *   键必须存在于 `src/core/messages.ts` 目录（`MsgFunc` 形参是 string，编译器只能校验到键名集合）。
+ */
+export function validateJsonSection(sectionId, data, msg, shape, subject = sectionId, objectMessageKey = 'adapter.validate.object') {
+    if (data === null || typeof data !== 'object') {
+        return {
+            valid: false,
+            issues: [{ path: '$', message: msg(objectMessageKey, { subject }), severity: 'error' }],
+        };
+    }
+    const section = data;
+    const issues = [];
+    const expectedVersion = sectionMeta(sectionId).dataVersion;
+    if (section.version !== expectedVersion) {
+        issues.push({
+            path: 'version',
+            message: msg('adapter.validate.version', { value: String(section.version) }),
+            severity: 'error',
+        });
+    }
+    if (shape !== undefined)
+        shape(section, issues);
+    return { valid: issues.filter((i) => i.severity === 'error').length === 0, issues };
+}
+//# sourceMappingURL=json-section.js.map

package/lib/adapters/mcp.d.ts

@@ -18,9 +18,9 @@ export declare function extractMcpServers(lines: {
 export declare function buildMcpPatchLine(lineId: string, server: McpServerEntry): Record<string, unknown>;
 export declare class McpAdapter implements ConfigAdapter<McpExportSection> {
     readonly id: 'mcp';
-    readonly displayName = "MCP Servers";
-    readonly defaultIncluded = true;
-    readonly portability: 'platformSpecific';
+    readonly displayName: string;
+    readonly defaultIncluded: boolean;
+    readonly portability: import("../schema/section-registry.ts").SectionPortability;
     export(ctx: HostContext, _options: ExportOptions): Promise<ExportSection<McpExportSection>>;
     analyzeImport(data: McpExportSection, ctx: ImportContext): Promise<PlanItem[]>;
     applyItem(item: PlanItem, ctx: ImportContext): Promise<ApplyResult>;

package/lib/adapters/mcp.js

@@ -8,6 +8,8 @@
  */
 import { isDeepStrictEqual } from 'node:util';
 import { msgOf, zhMsg } from '../core/messages.js';
+import { sectionMeta } from '../schema/section-registry.js';
+import { validateJsonSection } from './json-section.js';
 import { USER_PATCH_FILE } from './plugins.js';
 /** 从 patch 行数组中提取 MCP server 条目（以 config.serverName 存在为判定） */
 export function extractMcpServers(lines) {
@@ -77,9 +79,10 @@ function newLineId(serverName) {
 }
 export class McpAdapter {
     id = 'mcp';
-    displayName = 'MCP Servers';
-    defaultIncluded = true;
-    portability = 'platformSpecific';
+    // 元数据唯一来源 = 注册表（t31）：不再与 ui/export-flow.ts 的导出目录各写一份
+    displayName = sectionMeta('mcp').displayName;
+    defaultIncluded = sectionMeta('mcp').defaultIncluded;
+    portability = sectionMeta('mcp').portability;
     async export(ctx, _options) {
         const warnings = [];
         let lines = [];
@@ -155,24 +158,18 @@ export class McpAdapter {
         return { ok: true, needsRestart: true, message: msg('adapter.mcpWritten', { serverName }) };
     }
     async validate(data, msg = zhMsg) {
-        const issues = [];
-        if (data === null || typeof data !== 'object') {
-            return { valid: false, issues: [{ path: '$', message: msg('adapter.validate.object', { subject: 'mcp' }), severity: 'error' }] };
-        }
-        if (data.version !== 1) {
-            issues.push({ path: 'version', message: msg('adapter.validate.version', { value: String(data.version) }), severity: 'error' });
-        }
-        if (!Array.isArray(data.servers)) {
-            issues.push({ path: 'servers', message: msg('adapter.validate.array', { subject: 'servers' }), severity: 'error' });
-        }
-        else {
-            for (const s of data.servers) {
-                if (s === null || typeof s !== 'object' || typeof s.serverName !== 'string' || s.serverName === '') {
-                    issues.push({ path: 'servers[]', message: msg('adapter.validate.serverName'), severity: 'error' });
+        return validateJsonSection('mcp', data, msg, (section, issues) => {
+            if (!Array.isArray(section.servers)) {
+                issues.push({ path: 'servers', message: msg('adapter.validate.array', { subject: 'servers' }), severity: 'error' });
+            }
+            else {
+                for (const s of section.servers) {
+                    if (s === null || typeof s !== 'object' || typeof s.serverName !== 'string' || s.serverName === '') {
+                        issues.push({ path: 'servers[]', message: msg('adapter.validate.serverName'), severity: 'error' });
+                    }
                 }
             }
-        }
-        return { valid: issues.filter((i) => i.severity === 'error').length === 0, issues };
+        });
     }
 }
 //# sourceMappingURL=mcp.js.map

package/lib/adapters/plugin-files.d.ts

@@ -4,9 +4,9 @@ import type { ApplyResult, ConfigAdapter, ExportOptions, ExportSection, ExportUn
 export declare const DEFAULT_PLUGIN_FILE_WHITELIST: readonly string[];
 export declare class PluginFilesAdapter implements ConfigAdapter<FilesSection> {
     readonly id: 'pluginFiles';
-    readonly displayName = "Plugin Files";
-    readonly defaultIncluded = false;
-    readonly portability: 'deviceSpecific';
+    readonly displayName: string;
+    readonly defaultIncluded: boolean;
+    readonly portability: import("../schema/section-registry.ts").SectionPortability;
     private readonly whitelist;
     /** 约定配置目录（相对 ~/.dsh 根，如 'plugin-config'）；递归收集其下所有文件。undefined = 不收集。 */
     private readonly collectDir?;

package/lib/adapters/plugin-files.js

@@ -11,12 +11,15 @@ import { msgOf, zhMsg } from '../core/messages.js';
 import { linkWarnings, listFilesDetailed } from './link-report.js';
 import { isPathSafe, isReservedInternalRel } from '../utils/paths.js';
 import { unitAllowed, unitsFromFiles } from './units.js';
+import { sectionMeta } from '../schema/section-registry.js';
+import { validateJsonSection } from './json-section.js';
 export const DEFAULT_PLUGIN_FILE_WHITELIST = ['dsh-ssh.json', 'pet.json'];
 export class PluginFilesAdapter {
     id = 'pluginFiles';
-    displayName = 'Plugin Files';
-    defaultIncluded = false;
-    portability = 'deviceSpecific';
+    // 元数据唯一来源 = 注册表（t31）：不再与 ui/export-flow.ts 的导出目录各写一份
+    displayName = sectionMeta('pluginFiles').displayName;
+    defaultIncluded = sectionMeta('pluginFiles').defaultIncluded;
+    portability = sectionMeta('pluginFiles').portability;
     whitelist;
     /** 约定配置目录（相对 ~/.dsh 根，如 'plugin-config'）；递归收集其下所有文件。undefined = 不收集。 */
     collectDir;
@@ -138,17 +141,11 @@ export class PluginFilesAdapter {
         return { ok: true };
     }
     async validate(data, msg = zhMsg) {
-        const issues = [];
-        if (data === null || typeof data !== 'object') {
-            return { valid: false, issues: [{ path: '$', message: msg('adapter.validate.object', { subject: 'pluginFiles' }), severity: 'error' }] };
-        }
-        if (data.version !== 1) {
-            issues.push({ path: 'version', message: msg('adapter.validate.version', { value: String(data.version) }), severity: 'error' });
-        }
-        if (!Array.isArray(data.files)) {
-            issues.push({ path: 'files', message: msg('adapter.validate.array', { subject: 'files' }), severity: 'error' });
-        }
-        return { valid: issues.filter((i) => i.severity === 'error').length === 0, issues };
+        return validateJsonSection('pluginFiles', data, msg, (section, issues) => {
+            if (!Array.isArray(section.files)) {
+                issues.push({ path: 'files', message: msg('adapter.validate.array', { subject: 'files' }), severity: 'error' });
+            }
+        });
     }
 }
 //# sourceMappingURL=plugin-files.js.map

package/lib/adapters/plugins.d.ts

@@ -20,9 +20,9 @@ export declare const PNPM_WORKSPACE_REL: (profile: string | undefined) => string
 export declare const MAX_PATCH_FILE_BYTES: number;
 export declare class PluginsAdapter implements ConfigAdapter<PluginsSection> {
     readonly id: 'plugins';
-    readonly displayName = "Plugins";
-    readonly defaultIncluded = true;
-    readonly portability: 'portable';
+    readonly displayName: string;
+    readonly defaultIncluded: boolean;
+    readonly portability: import("../schema/section-registry.ts").SectionPortability;
     /** 插件自身包名：导出 plugins 分区时不列自己（避免备份里出现「当前正在生成备份的插件」的自引用条目） */
     private readonly selfName;
     /** T1：本地源（link:/file:）插件打包钩子；未注入 = 不打包（保持改造前行为） */

package/lib/adapters/plugins.js

@@ -13,11 +13,13 @@
 import { isDeepStrictEqual } from 'node:util';
 import { sha256Hex } from '../utils/hashing.js';
 import { installSpecFor, resolveProfileNameFromArgv } from '../core/plugin-cli.js';
-import { isLocalPluginSpec, isPackedLocalSpec, LOCAL_PLUGIN_DIR } from '../core/local-plugin-pack.js';
+import { LOCAL_PLUGIN_DIR } from '../core/local-plugin-pack.js';
 import { msgOf, zhMsg } from '../core/messages.js';
 import { isPathSafe, normalizePath } from '../utils/paths.js';
 import { PLUGIN_PATCH_REF_PREFIX } from '../core/backup.js';
 import { parsePnpmPatchedDependencies, sanitizePnpmWorkspacePatches } from './pnpm-workspace.js';
+import { sectionMeta } from '../schema/section-registry.js';
+import { validateJsonSection } from './json-section.js';
 export const USER_PATCH_FILE = 'cordis.patch.yml';
 /** tarball 字节 → base64（零依赖，避免 Buffer 在浏览器侧类型问题） */
 function bytesToBase64(data) {
@@ -108,9 +110,10 @@ function entriesOfRaw(raw) {
 }
 export class PluginsAdapter {
     id = 'plugins';
-    displayName = 'Plugins';
-    defaultIncluded = true;
-    portability = 'portable';
+    // 元数据唯一来源 = 注册表（t31）：不再与 ui/export-flow.ts 的导出目录各写一份
+    displayName = sectionMeta('plugins').displayName;
+    defaultIncluded = sectionMeta('plugins').defaultIncluded;
+    portability = sectionMeta('plugins').portability;
     /** 插件自身包名：导出 plugins 分区时不列自己（避免备份里出现「当前正在生成备份的插件」的自引用条目） */
     selfName;
     /** T1：本地源（link:/file:）插件打包钩子；未注入 = 不打包（保持改造前行为） */
@@ -629,47 +632,41 @@ export class PluginsAdapter {
         return { ok: true, needsRestart: true, message: msg('adapter.patchWritten', { ref }) };
     }
     async validate(data, msg = zhMsg) {
-        const issues = [];
-        if (data === null || typeof data !== 'object') {
-            return { valid: false, issues: [{ path: '$', message: msg('adapter.validate.object', { subject: 'plugins' }), severity: 'error' }] };
-        }
-        if (data.version !== 1) {
-            issues.push({ path: 'version', message: msg('adapter.validate.version', { value: String(data.version) }), severity: 'error' });
-        }
-        if (!Array.isArray(data.plugins)) {
-            issues.push({ path: 'plugins', message: msg('adapter.validate.array', { subject: 'plugins' }), severity: 'error' });
-        }
-        if (data.patch !== undefined && !Array.isArray(data.patch)) {
-            issues.push({ path: 'patch', message: msg('adapter.validate.array', { subject: 'patch' }), severity: 'error' });
-        }
-        if (data.pnpmWorkspace !== undefined && data.pnpmWorkspace !== null && typeof data.pnpmWorkspace !== 'string') {
-            issues.push({ path: 'pnpmWorkspace', message: msg('adapter.validate.string', { subject: 'pnpmWorkspace' }), severity: 'error' });
-        }
-        // T1：本地插件 tarball 载荷（缺省合法；存在时逐条校验形状与路径安全）
-        if (data.localTarballs !== undefined) {
-            if (!Array.isArray(data.localTarballs)) {
-                issues.push({ path: 'localTarballs', message: msg('adapter.validate.array', { subject: 'localTarballs' }), severity: 'error' });
+        return validateJsonSection('plugins', data, msg, (section, issues) => {
+            if (!Array.isArray(section.plugins)) {
+                issues.push({ path: 'plugins', message: msg('adapter.validate.array', { subject: 'plugins' }), severity: 'error' });
             }
-            else {
-                data.localTarballs.forEach((t, i) => {
-                    if (t === null || typeof t !== 'object') {
-                        issues.push({ path: `localTarballs[${i}]`, message: msg('adapter.validate.object', { subject: 'localTarballs[]' }), severity: 'error' });
-                        return;
-                    }
-                    for (const field of ['packageName', 'version', 'relativePath', 'base64']) {
-                        if (typeof t[field] !== 'string' || t[field] === '') {
-                            issues.push({ path: `localTarballs[${i}].${field}`, message: msg('adapter.validate.string', { subject: field }), severity: 'error' });
+            if (section.patch !== undefined && !Array.isArray(section.patch)) {
+                issues.push({ path: 'patch', message: msg('adapter.validate.array', { subject: 'patch' }), severity: 'error' });
+            }
+            if (section.pnpmWorkspace !== undefined && section.pnpmWorkspace !== null && typeof section.pnpmWorkspace !== 'string') {
+                issues.push({ path: 'pnpmWorkspace', message: msg('adapter.validate.string', { subject: 'pnpmWorkspace' }), severity: 'error' });
+            }
+            // T1：本地插件 tarball 载荷（缺省合法；存在时逐条校验形状与路径安全）
+            if (section.localTarballs !== undefined) {
+                if (!Array.isArray(section.localTarballs)) {
+                    issues.push({ path: 'localTarballs', message: msg('adapter.validate.array', { subject: 'localTarballs' }), severity: 'error' });
+                }
+                else {
+                    section.localTarballs.forEach((t, i) => {
+                        if (t === null || typeof t !== 'object') {
+                            issues.push({ path: `localTarballs[${i}]`, message: msg('adapter.validate.object', { subject: 'localTarballs[]' }), severity: 'error' });
+                            return;
                         }
-                    }
-                    // 相对路径必须落在 LOCAL_PLUGIN_DIR 之下且不含穿越段（防写 homeDir 外）
-                    const rel = typeof t.relativePath === 'string' ? t.relativePath.replace(/\\/g, '/') : '';
-                    if (rel !== '' && (!rel.startsWith(`${LOCAL_PLUGIN_DIR}/`) || rel.includes('..'))) {
-                        issues.push({ path: `localTarballs[${i}].relativePath`, message: msg('adapter.validate.localTarballPath', { path: rel }), severity: 'error' });
-                    }
-                });
+                        for (const field of ['packageName', 'version', 'relativePath', 'base64']) {
+                            if (typeof t[field] !== 'string' || t[field] === '') {
+                                issues.push({ path: `localTarballs[${i}].${field}`, message: msg('adapter.validate.string', { subject: field }), severity: 'error' });
+                            }
+                        }
+                        // 相对路径必须落在 LOCAL_PLUGIN_DIR 之下且不含穿越段（防写 homeDir 外）
+                        const rel = typeof t.relativePath === 'string' ? t.relativePath.replace(/\\/g, '/') : '';
+                        if (rel !== '' && (!rel.startsWith(`${LOCAL_PLUGIN_DIR}/`) || rel.includes('..'))) {
+                            issues.push({ path: `localTarballs[${i}].relativePath`, message: msg('adapter.validate.localTarballPath', { path: rel }), severity: 'error' });
+                        }
+                    });
+                }
             }
-        }
-        return { valid: issues.filter((i) => i.severity === 'error').length === 0, issues };
+        });
     }
 }
 //# sourceMappingURL=plugins.js.map

package/lib/adapters/prompts.d.ts

@@ -20,9 +20,9 @@ export declare function mergePromptIntoLine(raw: unknown, prompt: PromptExportEn
 export declare function buildPromptLine(lineId: string, prompt: PromptExportEntry): Record<string, unknown>;
 export declare class PromptsAdapter implements ConfigAdapter<PromptsExportSection> {
     readonly id: 'prompts';
-    readonly displayName = "Prompts";
-    readonly defaultIncluded = true;
-    readonly portability: 'portable';
+    readonly displayName: string;
+    readonly defaultIncluded: boolean;
+    readonly portability: import("../schema/section-registry.ts").SectionPortability;
     export(ctx: HostContext, _options: ExportOptions): Promise<ExportSection<PromptsExportSection>>;
     analyzeImport(data: PromptsExportSection, ctx: ImportContext): Promise<PlanItem[]>;
     applyItem(item: PlanItem, ctx: ImportContext): Promise<ApplyResult>;

package/lib/adapters/prompts.js

@@ -9,9 +9,10 @@
  *  - 均不存在 → Warning（不编造行名自动创建，提示手动配置）。
  * rules/commands 无独立存储（研究报告 §2.2），不实现。
  */
-import { isDeepStrictEqual } from 'node:util';
 import { msgOf, zhMsg } from '../core/messages.js';
 import { USER_PATCH_FILE } from './plugins.js';
+import { sectionMeta } from '../schema/section-registry.js';
+import { validateJsonSection } from './json-section.js';
 /** 从 patch 行 config 中提取 prompt 条目（systemPrompt.persona / planMode.sections[].text） */
 export function extractPrompts(lines) {
     const prompts = [];
@@ -101,9 +102,10 @@ export function buildPromptLine(lineId, prompt) {
 }
 export class PromptsAdapter {
     id = 'prompts';
-    displayName = 'Prompts';
-    defaultIncluded = true;
-    portability = 'portable';
+    // 元数据唯一来源 = 注册表（t31）：不再与 ui/export-flow.ts 的导出目录各写一份
+    displayName = sectionMeta('prompts').displayName;
+    defaultIncluded = sectionMeta('prompts').defaultIncluded;
+    portability = sectionMeta('prompts').portability;
     async export(ctx, _options) {
         const warnings = [];
         let lines = [];
@@ -208,24 +210,18 @@ export class PromptsAdapter {
         return { ok: true, needsRestart: true, message: msg('adapter.promptWritten', { name: prompt.name, ref }) };
     }
     async validate(data, msg = zhMsg) {
-        const issues = [];
-        if (data === null || typeof data !== 'object') {
-            return { valid: false, issues: [{ path: '$', message: msg('adapter.validate.object', { subject: 'prompts' }), severity: 'error' }] };
-        }
-        if (data.version !== 1) {
-            issues.push({ path: 'version', message: msg('adapter.validate.version', { value: String(data.version) }), severity: 'error' });
-        }
-        if (!Array.isArray(data.prompts)) {
-            issues.push({ path: 'prompts', message: msg('adapter.validate.array', { subject: 'prompts' }), severity: 'error' });
-        }
-        else {
-            for (const p of data.prompts) {
-                if (p === null || typeof p !== 'object' || typeof p.name !== 'string' || typeof p.text !== 'string') {
-                    issues.push({ path: 'prompts[]', message: msg('adapter.validate.promptIdentity'), severity: 'error' });
+        return validateJsonSection('prompts', data, msg, (section, issues) => {
+            if (!Array.isArray(section.prompts)) {
+                issues.push({ path: 'prompts', message: msg('adapter.validate.array', { subject: 'prompts' }), severity: 'error' });
+            }
+            else {
+                for (const p of section.prompts) {
+                    if (p === null || typeof p !== 'object' || typeof p.name !== 'string' || typeof p.text !== 'string') {
+                        issues.push({ path: 'prompts[]', message: msg('adapter.validate.promptIdentity'), severity: 'error' });
+                    }
                 }
             }
-        }
-        return { valid: issues.filter((i) => i.severity === 'error').length === 0, issues };
+        });
     }
 }
 //# sourceMappingURL=prompts.js.map

package/lib/adapters/providers.d.ts

@@ -22,9 +22,9 @@ export interface ProviderExportSection {
 export declare const DEFAULT_PROVIDER_NAMESPACES: readonly string[];
 export declare class ProvidersAdapter implements ConfigAdapter<ProviderExportSection> {
     readonly id: 'providers';
-    readonly displayName = "Providers & Models";
-    readonly defaultIncluded = true;
-    readonly portability: 'portable';
+    readonly displayName: string;
+    readonly defaultIncluded: boolean;
+    readonly portability: import("../schema/section-registry.ts").SectionPortability;
     private readonly namespaces;
     constructor(namespaces?: string[] | NamespaceProvider);
     export(ctx: HostContext, _options: ExportOptions): Promise<ExportSection<ProviderExportSection>>;

package/lib/adapters/providers.js

@@ -8,6 +8,8 @@
 import { isDeepStrictEqual } from 'node:util';
 import { msgOf, zhMsg } from '../core/messages.js';
 import { resolveNamespaces, isEmptyValue } from './settings.js';
+import { sectionMeta } from '../schema/section-registry.js';
+import { validateJsonSection } from './json-section.js';
 export const DEFAULT_PROVIDER_NAMESPACES = ['llm-deepseek', 'llm-pi-ai'];
 /** 无 raw 时的兜底重建：只取 ProviderEntry 已知字段 */
 function stripEntry(entry) {
@@ -20,9 +22,10 @@ function stripEntry(entry) {
 }
 export class ProvidersAdapter {
     id = 'providers';
-    displayName = 'Providers & Models';
-    defaultIncluded = true;
-    portability = 'portable';
+    // 元数据唯一来源 = 注册表（t31）：不再与 ui/export-flow.ts 的导出目录各写一份
+    displayName = sectionMeta('providers').displayName;
+    defaultIncluded = sectionMeta('providers').defaultIncluded;
+    portability = sectionMeta('providers').portability;
     namespaces;
     constructor(namespaces = DEFAULT_PROVIDER_NAMESPACES) {
         this.namespaces = namespaces;
@@ -125,31 +128,25 @@ export class ProvidersAdapter {
         return { ok: true };
     }
     async validate(data, msg = zhMsg) {
-        const issues = [];
-        if (data === null || typeof data !== 'object') {
-            return { valid: false, issues: [{ path: '$', message: msg('adapter.validate.object', { subject: 'providers' }), severity: 'error' }] };
-        }
-        if (data.version !== 1) {
-            issues.push({ path: 'version', message: msg('adapter.validate.version', { value: String(data.version) }), severity: 'error' });
-        }
-        if (data.providers === null || typeof data.providers !== 'object') {
-            issues.push({ path: 'providers', message: msg('adapter.validate.missingObject', { subject: 'providers' }), severity: 'error' });
-        }
-        else {
-            for (const [route, entry] of Object.entries(data.providers)) {
-                if (entry === null || typeof entry !== 'object') {
-                    issues.push({ path: `providers.${route}`, message: msg('adapter.validate.recordObject', { subject: 'provider' }), severity: 'error' });
-                    continue;
-                }
-                if (typeof entry.namespace !== 'string' || entry.namespace === '') {
-                    issues.push({ path: `providers.${route}.namespace`, message: msg('adapter.validate.sourceNamespace'), severity: 'error' });
-                }
-                if (typeof entry.revision !== 'number') {
-                    issues.push({ path: `providers.${route}.revision`, message: msg('adapter.validate.number', { subject: 'revision' }), severity: 'error' });
+        return validateJsonSection('providers', data, msg, (section, issues) => {
+            if (section.providers === null || typeof section.providers !== 'object') {
+                issues.push({ path: 'providers', message: msg('adapter.validate.missingObject', { subject: 'providers' }), severity: 'error' });
+            }
+            else {
+                for (const [route, entry] of Object.entries(section.providers)) {
+                    if (entry === null || typeof entry !== 'object') {
+                        issues.push({ path: `providers.${route}`, message: msg('adapter.validate.recordObject', { subject: 'provider' }), severity: 'error' });
+                        continue;
+                    }
+                    if (typeof entry.namespace !== 'string' || entry.namespace === '') {
+                        issues.push({ path: `providers.${route}.namespace`, message: msg('adapter.validate.sourceNamespace'), severity: 'error' });
+                    }
+                    if (typeof entry.revision !== 'number') {
+                        issues.push({ path: `providers.${route}.revision`, message: msg('adapter.validate.number', { subject: 'revision' }), severity: 'error' });
+                    }
                 }
             }
-        }
-        return { valid: issues.filter((i) => i.severity === 'error').length === 0, issues };
+        });
     }
 }
 //# sourceMappingURL=providers.js.map

package/lib/adapters/sessions.d.ts

@@ -8,7 +8,8 @@
  * core/session-select.ts（单位 = 会话目录、文件名判据不写死、按日志最新 mtime 倒序）。
  */
 import { FileCollectionAdapter } from './file-collection.ts';
-import type { ExportOptions, HostContext } from '../core/types.ts';
+import type { ApplyResult, ExportOptions, ExportSection, HostContext, ImportContext } from '../core/types.ts';
+import type { FilesSection } from '../schema/types.ts';
 export declare class SessionsAdapter extends FileCollectionAdapter {
     readonly id: 'sessions';
     readonly displayName = "Sessions";
@@ -35,4 +36,99 @@ export declare class SessionsAdapter extends FileCollectionAdapter {
         keep: Set<string> | null;
         warnings: string[];
     } | null>;
+    /**
+     * 本机**全部**会话单元 id（P1-5 会话删除墓碑的「本机现存集合」）。
+     *
+     * 只做「列目录 + 按单元分组」，**不 stat 时间**（时间只用于排序，这里只要集合）——比
+     * restrictUnits 少一轮 stat，扫描千级会话库的代价可接受。目录不可读 → 空数组：调用方
+     * 据此**跳过**本轮删除检测（把「读不到」当成「全删了」会误标一大片墓碑）。
+     */
+    listAllUnitIds(ctx: HostContext): Promise<string[]>;
+    /**
+     * 会话日志文件 → mtime（毫秒；读不到 = null）。批量并发 stat，避免一次性开满 Promise 打爆 libuv 线程池。
+     *
+     * 两个调用方共用同一实现（口径不许漂移）：
+     *  - `restrictUnits`：「最新 N 个会话」预筛选（issue #39 Feature 1）；
+     *  - `unitActivityTimes`：导出选择器「历史对话按最新到最旧排序」的时间来源。
+     *
+     * @param rels 调用方的键（这里一律是 baseDir 相对路径）；@param homeRelOf 把它们映射到
+     *   FileSystemFacade 认的 homeDir 相对路径（缺省 = 键本身就是 homeDir 相对路径）。
+     */
+    private logMtimes;
+    /**
+     * 导出选择器的排序时间源（宿主 `/export-preview` 调用）：会话裸键 → 该会话**最新一份**日志的 mtime。
+     *
+     * 为什么需要它：会话标题与活跃时间来自 DSH 的 `storages/session_projcache.json`，而那份缓存只覆盖
+     * **一部分**会话（真机实测：同一项目 731 个会话目录里 347 个不在缓存内）。这些会话拿不到时间，
+     * 只能按 uuid 字典序排在组尾 —— 用户看到的就是「历史对话没有按最新到最旧排序」。会话日志 mtime
+     * 对每个会话都存在，且与「最新 N 个会话」预筛选（restrictUnits）**同一口径**（同一门面、同一批大小）。
+     *
+     * 返回键 = `sessionIdKey(目录名)`（`session-<uuid>` 与裸 `<uuid>` 归一化成同一个会话，取较大者）；
+     * 时间读不到的会话**不进 Map**（调用方按「时间未知」处理，绝不把未知当成 0 —— 那会把它排到最旧）。
+     * 宿主不提供 `mtimeMs` 门面 → 返回空 Map（调用方退回元数据缓存时间，行为与改造前一致）。
+     */
+    unitActivityTimes(ctx: HostContext, section: ExportSection<FilesSection>): Promise<Map<string, number>>;
+    /**
+     * 分区收尾（issue #45）：把用户填的路径映射**同时**作用到会话日志首帧 cwd 与目录位置。
+     *
+     * 为什么必须做：DSH 判定工作区成员要求 realpath(会话首帧 cwd) == workspace.path 且 id 在
+     * sessionIds 里；跨机恢复时 header 还是源机路径，attachSession 必然被拒 —— 这正是
+     * 「会话数据恢复了却显示不出来」。workspace.path 侧已由 analyzer 应用了同一份映射，
+     * 这里补上会话侧，两边共用同一个 applyPathMapping（口径不许漂移）。
+     *
+     * 顺序与一致性（DSH 启动时校验「日志位置 == projectKeyOf(header.cwd)/id」，不一致直接拒绝启动）：
+     *   ① 先改写首帧（全部 generation）→ ② 再按映射后的 cwd 归位目录 → ③ 目录搬不动就回滚首帧。
+     * 任何一步失败都如实报告，绝不留「header 与位置不一致」的半套状态；回滚也失败时按硬失败上报
+     * （宁可让 rollbackOnError 把这次导入整体回滚，也不要悄悄留下坏状态）。
+     *
+     * 没有命中映射时退回原有护栏：只校验「目录段 == projectKeyOf(首帧 cwd)」，不一致就归位。
+     * 读不出 cwd（非日志 / 非 zstd / 首帧不完整）→ 跳过该单元：不猜、不动、也不谎报通过。
+     */
+    /**
+     * 导出收尾：选中子代理会话时**连带它的父对话**（真机事故：导入全部成功，工作区里却看不见）。
+     *
+     * 为什么（DSH 客户端源码 dsh-client-ui-workspace 的 sessionVisible）：
+     *   session.origin !== "subagent" && ...
+     * —— 工作区列表**只显示** origin !== 'subagent' 的会话；子代理会话只在**父对话之下**出现。
+     * 于是「只导出子会话、不带父对话」的包在导入侧一切成功（文件落盘、workspace.json 也登记了），
+     * 用户在 DSH 工作区里却一条都看不到（真机：用户勾了 4 条子代理会话导出再导入，全无踪影）。
+     * 所以导出侧按父链补齐（父对话本身也可能是子代理会话 → 继续往上追），并在报告里如实说明；
+     * 追不到（本机没有 / 超出分区上限）也绝不静默。
+     */
+    export(ctx: HostContext, options: ExportOptions): Promise<ExportSection<FilesSection>>;
+    /** 一个会话单元的 header（取该单元第一份日志；读不出 → undefined，不猜）。 */
+    private firstUnitHeader;
+    /**
+     * 按「父会话 id」在本机找它的会话目录（两种命名形态 + 子会话所在项目键优先）。
+     * 只认「目录里真有会话日志」的候选：空目录 / 同名目录不算命中（不猜）。
+     */
+    private findSessionDir;
+    /**
+     * 目标机上是否已有该父对话。
+     *
+     * 探测面 = 两种目录命名形态（`session-<uuid>` / 裸 `<uuid>`）× 目录本身 + 三种已知日志文件名：
+     * 目录级探测在真实宿主上就够，文件级探测则让内存 fs（单测）与「日志名不按常见形态」的机器也能命中。
+     * 探针异常按「不知道」处理 —— 宁可多告警一条（可解释），也不静默放过。
+     */
+    private parentExistsLocally;
+    /**
+     * 导出侧会话族补齐：**只向上补父对话**（选中子代理会话 → 连带它的父对话，否则 DSH 工作区列表里
+     * 一条都看不见）。追不到（本机没有 / 超出分区上限）一律进报告，绝不静默。
+     *
+     * **引擎为什么不再向下展开**（历史上这里还有一条「勾父带子」）：条目级白名单是**用户意图的唯一事实**，
+     * 而引擎看不到「界面为什么没勾这条子会话」—— 一旦自己向下补，「用户在界面上单独取消某条子代理会话」
+     * 就会被无声地加回包里（真机事故：只勾 2 条，导出 41 个会话目录）。所以「勾父带子」改由**界面**在
+     * 勾选时联动完成（`src/ui/selection-model.ts` 的 `applySessionParentCoupling`：勾父自动勾上它的子代理
+     * 会话、勾子自动带上父、取消父连带取消子），引擎只保留这条「不让用户吃亏」的**向上**兜底
+     * （父对话缺席 = 导入后在工作区里完全看不见）。
+     */
+    private coupleSessionParents;
+    /**
+     * 导入侧：子代理会话的父对话**既不在本包内、本机也没有** → 一条 warning。
+     *
+     * 为什么要探测「本机有没有」：目标机本来就有该父对话时（例如把旧包导回同机），子会话会正常
+     * 挂在本地父对话之下 —— 无脑告警会把正常情况说成「看不到」，比不告警更糟。
+     */
+    private orphanSubagentWarnings;
+    finalizeApply(ctx: ImportContext): Promise<ApplyResult[]>;
 }