dsh-config-manager 0.1.78 → 0.1.80

package/src/schema/types.ts

@@ -32,6 +32,42 @@ export interface EncryptionInfo {
   version: number;
 }
 
+/**
+ * **外部来源包**的溯源块（manifest.foreign，2026-10-18 新增，纯 additive）。
+ *
+ * 为什么需要它：外部来源（Claude Code / Hermes / …）合成的包是**标准 bundle v1**，
+ * 落盘后与 DSH 自产备份**逐字同构** —— 事后无法复核「这包从哪来」。本块把来源标识、
+ * 读取位置、项目根、插件元数据与跳过聚合写进 manifest，供用户与界面核对。
+ *
+ * 三条纪律（与 src/foreign/types.ts 的 ForeignOrigin 同口径）：
+ *  ① **只放标识与计数，绝不放值**（凭据只有引用名，诊断只有机器码，无一字配置内容）；
+ *  ② 向后兼容：旧包没有该字段 ⇒ 缺省即合法；本字段的存在**绝不能**让旧/新包被拒；
+ *  ③ 缺字段即「不知道」，绝不填默认值假装知道。
+ */
+export interface ManifestForeignOrigin {
+  /** 来源 agent id（稳定机器标识，如 claude-code / hermes；不随文案变化） */
+  agent: string;
+  /** 实际读取的位置（相对 home 的 POSIX 路径；不含任何值） */
+  locations?: string[];
+  /** 来源侧版本标记（读不到即省略） */
+  sourceVersion?: string;
+  /** 被扫描的项目根绝对路径（仅溯源，供用户核对；绝不进任何分区载荷） */
+  projects?: string[];
+  /** 插件清单（名称 / 版本 / 市场 / 来源仓库 / ref / 组件种类；**不含凭据**） */
+  plugins?: {
+    name: string;
+    version?: string;
+    marketplace?: string;
+    repo?: string;
+    ref?: string;
+    components?: string[];
+  }[];
+  /** 跳过与诊断汇总（机器码 + 条数，**不含任何值**） */
+  skipped?: { code: string; count: number }[];
+  /** 需要用户在目标机补录的凭据引用名（只有名字，**没有任何值**） */
+  credentialRefs?: string[];
+}
+
 /** 每个导出 ZIP 根部的 manifest.json */
 export interface Manifest {
   schemaVersion: number;
@@ -48,6 +84,12 @@ export interface Manifest {
    * 宽容读取：非字符串/缺失一律按「未知」处理（不重定基，不报错）。
    */
   sourceHome?: string;
+  /**
+   * **外部来源包的溯源块**（见 ManifestForeignOrigin）；DSH 自产备份没有该字段。
+   *
+   * 宽容读取：缺省 = 旧包（合法）；存在但形状/字段类型不对 = 仅 warning（绝不因此拒绝导入）。
+   */
+  foreign?: ManifestForeignOrigin;
   sections: Record<SectionId, boolean>;
   security: {
     containsSecrets: boolean;
@@ -109,8 +151,9 @@ export interface PluginEntry {
   /**
    * 声明依赖 spec（profile package.json dependencies 原样），如 ^0.3.6、
    * github:csyangwen/dsh-memory-evolve、file:/link: 等。
-   * 导入时非 registry 来源（github:/git+/file:/link:/workspace: 等）按此 spec 安装，
-   * 否则按裸包名走 npm 最新版（官方机制）。
+   * 导入时的安装目标由 `core/plugin-cli.ts` 的 `pluginInstallTarget()` 统一推导（issue #101）：
+   * 非 registry 来源按此 spec 原样安装；`version` 是具体 semver 时按 `<name>@<version>` 精确安装；
+   * 其余 spec 按 `<name>@<spec>`；都没有才退回裸包名（npm 最新版）。
    */
   spec?: string;
   /**

package/src/sync/ancestor.ts

@@ -8,7 +8,9 @@ import { engineMsg } from './messages.ts';
 import type { SnapshotFs } from './fs.ts';
 import { readSnapshotFromDir, writeSnapshotToDir } from './layout.ts';
 import { SNAPSHOT_MANIFEST_FILE } from './layout.ts';
+import { isEncryptedSections } from './transport.ts';
 import type { SyncSnapshot } from './transport.ts';
+import { parseJsonSafe, stringifyJsonSafe } from '../utils/json.ts';
 
 /** 默认保留的祖先快照数量（最旧超出则被裁剪）。 */
 export const DEFAULT_ANCESTOR_KEEP = 10;
@@ -23,7 +25,7 @@ export async function loadAncestor(
     throw new Error(engineMsg('sync.ancestorSnapshotIdRequired'));
   }
   const dir = joinFs(localSnapshotsDir, snapshotId);
-  return await readSnapshotFromDir(dir, fsx);
+  return await readAncestorSnapshot(dir, fsx);
 }
 
 /**
@@ -43,12 +45,84 @@ export async function tryLoadAncestor(
 ): Promise<SyncSnapshot | undefined> {
   if (typeof snapshotId !== 'string' || snapshotId === '') return undefined;
   try {
-    return await readSnapshotFromDir(joinFs(localSnapshotsDir, snapshotId), fsx);
+    return await readAncestorSnapshot(joinFs(localSnapshotsDir, snapshotId), fsx);
   } catch {
     return undefined;
   }
 }
 
+/**
+ * 加密祖先副本的密文载荷文件名（issue #107）。
+ * 加密快照无法平铺成明文 JSON 分区，因此加密祖先目录 = manifest.json + 这一个密文载荷文件。
+ */
+export const ENCRYPTED_ANCESTOR_FILE = 'sections.encrypted.json';
+
+/**
+ * 读祖先副本目录：manifest.encrypted=true → 读密文单载荷；否则按散文件布局读回明文。
+ *
+ * 为什么要在这里分派（而不是改 layout.readSnapshotFromDir）：散文件布局对加密快照是**结构性拒绝**
+ * （layoutEncryptedDirUnsupported，git 通道的密文单文件布局依赖它）；祖先副本是本地缓存目录，
+ * 允许有自己的加密形态，且不该让「本地缓存」把明文布局的契约搞松。
+ * 读不出 / 形态不符一律抛错 —— 是否降级为 undefined 由 tryLoadAncestor 决定。
+ */
+export async function readAncestorSnapshot(
+  dir: string,
+  fsx: SnapshotFs = createSnapshotFs(),
+): Promise<SyncSnapshot> {
+  const manifestAbs = joinFs(dir, SNAPSHOT_MANIFEST_FILE);
+  if (!(await fsx.exists(manifestAbs))) {
+    throw new Error(engineMsg('sync.layoutManifestMissing', { file: SNAPSHOT_MANIFEST_FILE, dir }));
+  }
+  const parsed = parseJsonSafe(Buffer.from(await fsx.readFile(manifestAbs)).toString('utf8'));
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(engineMsg('sync.layoutManifestNotObject'));
+  }
+  const m = parsed as Record<string, unknown>;
+  const manifest = m['manifest'];
+  if (manifest !== null && typeof manifest === 'object' && !Array.isArray(manifest)
+    && (manifest as Record<string, unknown>)['encrypted'] === true) {
+    const payloadAbs = joinFs(dir, ENCRYPTED_ANCESTOR_FILE);
+    if (!(await fsx.exists(payloadAbs))) {
+      throw new Error(engineMsg('sync.layoutManifestMissing', { file: ENCRYPTED_ANCESTOR_FILE, dir }));
+    }
+    const payload = parseJsonSafe(Buffer.from(await fsx.readFile(payloadAbs)).toString('utf8'));
+    if (!isEncryptedSections(payload)) {
+      throw new Error(engineMsg('sync.layoutManifestMissingFields'));
+    }
+    return {
+      id: typeof m['id'] === 'string' ? m['id'] : '',
+      createdAt: typeof m['createdAt'] === 'string' ? m['createdAt'] : '',
+      manifest: manifest as SyncSnapshot['manifest'],
+      sections: payload,
+    };
+  }
+  return await readSnapshotFromDir(dir, fsx);
+}
+
+/**
+ * 把**加密**祖先副本写入本地目录（issue #107）。
+ *
+ * 磁盘上只有 manifest.json（manifest.encrypted=true，sectionHashes 为空）+ 单个 AES-GCM 密文载荷；
+ * 密码绝不落盘（载荷里只有 salt/iv/authTag 与密文，与远端加密快照同口径）。
+ * 目录里有 manifest.json ⇒ 仍被 listAncestors / pruneAncestors 当成普通祖先副本，保留策略不变。
+ */
+export async function writeEncryptedAncestor(
+  localSnapshotsDir: string,
+  snapshot: SyncSnapshot,
+  fsx: SnapshotFs = createSnapshotFs(),
+): Promise<void> {
+  if (!isEncryptedSections(snapshot.sections)) {
+    // 结构性断言：明文快照必须走 writeAncestor（散文件布局），不得落进密文单载荷形态
+    throw new Error(engineMsg('sync.layoutEncryptedDirUnsupported'));
+  }
+  const dir = joinFs(localSnapshotsDir, snapshot.id);
+  await fsx.mkdir(dir);
+  const manifest = { id: snapshot.id, createdAt: snapshot.createdAt, manifest: snapshot.manifest, sectionHashes: {} };
+  const enc = new TextEncoder();
+  await fsx.writeFile(joinFs(dir, SNAPSHOT_MANIFEST_FILE), enc.encode(stringifyJsonSafe(manifest, { space: 2 })));
+  await fsx.writeFile(joinFs(dir, ENCRYPTED_ANCESTOR_FILE), enc.encode(stringifyJsonSafe(snapshot.sections, { space: 2 })));
+}
+
 /** 把合并后的快照写入本地祖先副本目录（覆盖同名 id）。 */
 export async function writeAncestor(
   localSnapshotsDir: string,

package/src/sync/autosync-config.test.ts

@@ -11,7 +11,7 @@ import path from 'node:path';
 import {
   readAutosyncConfig, writeAutosyncConfig, readAllAutosyncConfigs, AUTOSYNC_CONFIG_FILE,
   AUTOSYNC_CONFIG_SCHEMA_VERSION, DEFAULT_AUTOSYNC_INTERVAL,
-  DEFAULT_STARTUP_MIN_INTERVAL_MS,
+  DEFAULT_STARTUP_MIN_INTERVAL_MS, lastRunFailureMessage, clearLastRunResult, shouldRunOnEnable,
 } from './autosync-config.ts';
 
 test('writeAutosyncConfig + readAutosyncConfig：写入 → 读回字段一致（git 通道）', async () => {
@@ -145,3 +145,75 @@ test('v1 迁移：顶层单通道字段 → git 通道（webdav 缺省）', asyn
     assert.equal(git2.interval, '12h');
   } finally { await fs.rm(dir, { recursive: true, force: true }); }
 });
+/* ------------------------------------------------- issue #105：旧运行结果不得被当成结论 */
+
+test('lastRunFailureMessage：只有 failed 才回传错误原文（issue #105）', () => {
+  // failed + 有原文 → 原样回传
+  assert.equal(
+    lastRunFailureMessage({ lastRunStatus: 'failed', lastRunMessage: 'git pull 失败: 认证失败' }),
+    'git pull 失败: 认证失败',
+  );
+  // 其余状态一律 undefined —— 这正是「卡片挂着十天前旧错误」的根因
+  for (const status of ['success', 'skipped', 'partial'] as const) {
+    assert.equal(
+      lastRunFailureMessage({ lastRunStatus: status, lastRunMessage: '上一轮认证失败' }),
+      undefined,
+      `${status} 不得回传上一轮的旧错误`,
+    );
+  }
+  // 空串 / 缺字段 / 从未运行 → 都不得渲染
+  assert.equal(lastRunFailureMessage({ lastRunStatus: 'failed', lastRunMessage: '' }), undefined);
+  assert.equal(lastRunFailureMessage({ lastRunStatus: 'failed' }), undefined);
+  assert.equal(lastRunFailureMessage({}), undefined);
+});
+
+test('clearLastRunResult：配置变更清空上一轮结论，但保留「上次跑过什么」（issue #105）', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-autosync-clear-'));
+  try {
+    await writeAutosyncConfig(dir, 'git', {
+      enabled: true,
+      interval: '15m',
+      startupMinIntervalMs: 300000,
+      consecutiveFailures: 4,
+      lastRunAt: '2026-08-17T10:00:00.000Z',
+      lastRunStatus: 'failed',
+      lastRunMessage: '认证失败',
+      lastRunSkipReason: 'conflict',
+      lastRunSkipCount: 2,
+      lastRunHistoryId: 'hist-9',
+    });
+    const cleared = clearLastRunResult(await readAutosyncConfig(dir, 'git'));
+    assert.equal(cleared.lastRunMessage, undefined);
+    assert.equal(cleared.lastRunSkipReason, undefined);
+    assert.equal(cleared.lastRunSkipCount, undefined);
+    // 配置与「上次运行事实」必须保留：改间隔不等于抹掉历史
+    assert.equal(cleared.enabled, true);
+    assert.equal(cleared.interval, '15m');
+    assert.equal(cleared.lastRunAt, '2026-08-17T10:00:00.000Z');
+    assert.equal(cleared.lastRunStatus, 'failed');
+    assert.equal(cleared.consecutiveFailures, 4);
+    // 落盘后旧结论真的不在文件里（不是只在内存里清掉）
+    await writeAutosyncConfig(dir, 'git', cleared);
+    const raw = JSON.parse(await fs.readFile(path.join(dir, AUTOSYNC_CONFIG_FILE), 'utf8'));
+    assert.equal(raw.channels.git.lastRunMessage, undefined);
+    assert.equal(raw.channels.git.lastRunSkipReason, undefined);
+    assert.equal(raw.channels.git.lastRunSkipCount, undefined);
+    assert.equal(raw.channels.git.lastRunStatus, 'failed');
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('issue #105 建议 4：shouldRunOnEnable —— 只有「关→开」且已过启动冷却才立刻跑一轮', () => {
+  const now = Date.parse('2026-10-21T21:00:00.000Z');
+  const base = { enabled: true, lastRunAt: '2026-10-01T10:00:00.000Z', startupMinIntervalMs: 300_000 };
+  // 关 → 开，上次运行是十天前：立刻跑
+  assert.equal(shouldRunOnEnable({ enabled: false }, base, now), true);
+  // 本来就开着（只是改间隔/阈值）：不跑
+  assert.equal(shouldRunOnEnable({ enabled: true }, base, now), false);
+  // 这次是关掉：不跑
+  assert.equal(shouldRunOnEnable({ enabled: false }, { ...base, enabled: false }, now), false);
+  // 刚跑过（冷却窗口内）：不跑，避免连点把通道打爆
+  assert.equal(shouldRunOnEnable({ enabled: false }, { ...base, lastRunAt: '2026-10-21T20:58:00.000Z' }, now), false);
+  // 从未跑过 / 时间读不出：当作「很久没跑」→ 跑
+  assert.equal(shouldRunOnEnable({ enabled: false }, { ...base, lastRunAt: undefined }, now), true);
+  assert.equal(shouldRunOnEnable({ enabled: false }, { ...base, lastRunAt: 'garbage' }, now), true);
+});

package/src/sync/autosync-config.ts

@@ -34,6 +34,38 @@ export const DEFAULT_AUTOSYNC_INTERVAL: AutosyncInterval = '30m';
 /** 缺省启动触发最小间隔阈值（5 分钟，防频繁重启反复同步） */
 export const DEFAULT_STARTUP_MIN_INTERVAL_MS = 5 * 60 * 1000;
 
+/** 缺省开启「本地改动即时触发」（真·自动同步；关闭后退回纯定时器） */
+export const DEFAULT_AUTOSYNC_REALTIME = true;
+
+/** 缺省远端轮询间隔（realtime 开启时与本地监听并行：本地改动即时上行，远端改动最迟 1 分钟内下行） */
+export const DEFAULT_AUTOSYNC_REMOTE_CHECK_MS = 60 * 1000;
+
+/** 远端轮询间隔下限（15 s）：再短只是空转 fetch，收益为零 */
+export const MIN_AUTOSYNC_REMOTE_CHECK_MS = 15 * 1000;
+
+/** 远端轮询间隔上限（60 min）：比这更慢就不该叫「实时」了 */
+export const MAX_AUTOSYNC_REMOTE_CHECK_MS = 60 * 60 * 1000;
+
+/** 自动应用的最高风险等级（low = 只有低风险分区自动落盘；medium = 中风险 plugins/mcp 也自动落盘） */
+export type AutosyncAutoApplyTier = 'low' | 'medium';
+
+/** 缺省自动应用等级：medium（用户拍板：plugins/mcp 的中风险改动也要真自动，否则「同步所有改动」是假的） */
+export const DEFAULT_AUTOSYNC_AUTO_APPLY_TIER: AutosyncAutoApplyTier = 'medium';
+
+/**
+ * 双侧都改（真冲突）时的自动裁决策略：
+ *  - 'ask'   ：保留冲突待人工裁决（改造前的唯一行为）；
+ *  - 'local' ：缺省 —— **保留本机并推上去**（VS Code 风格）：本机版本成为新的远端最新，
+ *              被覆盖的远端版本仍留在远端历史快照里，随时可回滚。
+ *
+ * 刻意**不提供** 'remote'：采用远端需要走 applyMergeResolutions，那条路径会整体应用所有
+ * 可决断分区、绕过 risk.ts 的风险分级（audit-sync sync-F5），与「分区逐档放行」冲突。
+ */
+export type AutosyncConflictPolicy = 'ask' | 'local';
+
+/** 缺省冲突策略：local（保留本机并推上去） */
+export const DEFAULT_AUTOSYNC_CONFLICT_POLICY: AutosyncConflictPolicy = 'local';
+
 /** 最近一次自动同步执行状态 */
 export type AutosyncRunStatus = 'success' | 'skipped' | 'failed' | 'partial';
 
@@ -45,6 +77,21 @@ export interface AutosyncConfig {
   interval: AutosyncInterval;
   /** 重启触发的「自动下载合并」最小间隔阈值（ms） */
   startupMinIntervalMs: number;
+  /**
+   * 真·自动同步：本地文件改动后即时触发一次（缺省 true）。
+   *
+   * false = 退回改造前的纯定时器语义（等 interval 到点）；保留这个开关是因为
+   * 「监听整棵配置目录」在某些环境（网络盘、超大 skills 树）可能带来额外 I/O。
+   *
+   * 可选：**读取层（parseV1Channel）恒补缺省值**，旧文件/旧夹具不需要带这个字段。
+   */
+  realtime?: boolean;
+  /** realtime 开启时的远端轮询间隔（ms；下限 15 s、上限 60 min，缺省 60 s） */
+  remoteCheckMs?: number;
+  /** 自动应用的最高风险等级（缺省 medium） */
+  autoApplyTier?: AutosyncAutoApplyTier;
+  /** 双侧都改时的自动裁决策略（缺省 local：保留本机并推上去） */
+  conflictPolicy?: AutosyncConflictPolicy;
   /** 连续失败计数（用于通知判定） */
   consecutiveFailures: number;
   /** 最近一次自动同步执行时间（ISO-8601 UTC）；''/undefined = 从未执行 */
@@ -77,9 +124,19 @@ export function defaultAutosyncConfig(): AutosyncConfig {
     interval: DEFAULT_AUTOSYNC_INTERVAL,
     startupMinIntervalMs: DEFAULT_STARTUP_MIN_INTERVAL_MS,
     consecutiveFailures: 0,
+    realtime: DEFAULT_AUTOSYNC_REALTIME,
+    remoteCheckMs: DEFAULT_AUTOSYNC_REMOTE_CHECK_MS,
+    autoApplyTier: DEFAULT_AUTOSYNC_AUTO_APPLY_TIER,
+    conflictPolicy: DEFAULT_AUTOSYNC_CONFLICT_POLICY,
   };
 }
 
+/** 远端轮询间隔夹取（非数字 / 越界一律回落到边界值，绝不写入 NaN）。 */
+export function clampRemoteCheckMs(value: number): number {
+  if (!Number.isFinite(value)) return DEFAULT_AUTOSYNC_REMOTE_CHECK_MS;
+  return Math.min(MAX_AUTOSYNC_REMOTE_CHECK_MS, Math.max(MIN_AUTOSYNC_REMOTE_CHECK_MS, Math.round(value)));
+}
+
 /** 从 v1 顶层字段（缺 schemaVersion 或 schemaVersion=1）解析单通道配置；非法字段回退缺省。 */
 function parseV1Channel(obj: Record<string, unknown>): AutosyncConfig {
   const cfg = defaultAutosyncConfig();
@@ -91,6 +148,13 @@ function parseV1Channel(obj: Record<string, unknown>): AutosyncConfig {
   if (typeof obj['consecutiveFailures'] === 'number' && Number.isFinite(obj['consecutiveFailures']) && obj['consecutiveFailures'] >= 0) {
     cfg.consecutiveFailures = obj['consecutiveFailures'];
   }
+  // 真·自动同步的三个新字段：缺失（旧文件）→ 缺省值，等于升级后立刻自动生效（用户已拍板）
+  if (typeof obj['realtime'] === 'boolean') cfg.realtime = obj['realtime'];
+  if (typeof obj['remoteCheckMs'] === 'number') cfg.remoteCheckMs = clampRemoteCheckMs(obj['remoteCheckMs']);
+  if (obj['autoApplyTier'] === 'low' || obj['autoApplyTier'] === 'medium') cfg.autoApplyTier = obj['autoApplyTier'];
+  if (obj['conflictPolicy'] === 'ask' || obj['conflictPolicy'] === 'local') {
+    cfg.conflictPolicy = obj['conflictPolicy'];
+  }
   if (typeof obj['lastRunAt'] === 'string' && obj['lastRunAt'] !== '') cfg.lastRunAt = obj['lastRunAt'];
   if (typeof obj['lastRunStatus'] === 'string' && (obj['lastRunStatus'] === 'success' || obj['lastRunStatus'] === 'skipped' || obj['lastRunStatus'] === 'failed' || obj['lastRunStatus'] === 'partial')) {
     cfg.lastRunStatus = obj['lastRunStatus'];
@@ -168,6 +232,62 @@ export async function writeAutosyncConfig(dir: string, channel: SyncTransportTyp
   await atomicWriteFile(target, data, { mode: 0o600 });
 }
 
+/**
+ * 可展示的「本轮失败原因」（issue #105）。
+ *
+ * 判据只有一条：**本轮状态真的是 failed**，才允许把 lastRunMessage 当成错误文案回传。
+ * 此前状态路由无条件回传 lastRunMessage，而 POST /sync/autosync 又会把读到的旧配置原样
+ * 写回 —— 于是「十天前那次失败的错误原文」会被一次纯粹改间隔的保存坐实，卡片上继续挂着
+ * 早已不成立的错误，用户据此去查一个不存在的故障（真机现场：认证已修好，界面仍报认证失败）。
+ *
+ * 返回 undefined = 界面不得渲染任何 lastRunMessage 单元格。
+ */
+export function lastRunFailureMessage(cfg: Pick<AutosyncConfig, 'lastRunStatus' | 'lastRunMessage'>): string | undefined {
+  if (cfg.lastRunStatus !== 'failed') return undefined;
+  const message = cfg.lastRunMessage;
+  return message === undefined || message === '' ? undefined : message;
+}
+
+/**
+ * 清空「上一轮运行结果」三字段（issue #105：配置变更 ≠ 一轮运行结果）。
+ *
+ * POST /sync/autosync 是**配置**写入而不是运行，写完必须把上一轮的结论清掉，否则旧结论
+ * 会被当成当前结论继续展示。保留 lastRunAt/lastRunStatus 与连续失败计数：它们描述的是
+ * 「上一次真的跑过什么」，不会因为改了间隔就变成假话。
+ */
+export function clearLastRunResult(cfg: AutosyncConfig): AutosyncConfig {
+  const next: AutosyncConfig = { ...cfg };
+  delete next.lastRunMessage;
+  delete next.lastRunSkipReason;
+  delete next.lastRunSkipCount;
+  return next;
+}
+
+/**
+ * 勾选「自动同步」后是否该立刻跑一轮（issue #105 建议 4）。
+ *
+ * 三种情况返回 false：
+ *  - 本来就已经开着：这次 POST 只是改间隔 / 调阈值，不是「打开」动作；
+ *  - 打开后仍在 startupMinIntervalMs 冷却窗口内：刚跑过，别连点把通道打爆；
+ *  - 这次是把开关关掉：关掉当然不跑。
+ * `lastRunAt` 缺失或读不出（NaN）→ 当作「很久没跑过」，该跑。
+ *
+ * 判据与 `autosync-scheduler.ts` 的 `shouldTriggerStartupRun` 一致；这里不能直接 import 它
+ * —— 调度器依赖本模块，反向引用会成环。
+ */
+export function shouldRunOnEnable(
+  prev: Pick<AutosyncConfig, 'enabled'>,
+  next: Pick<AutosyncConfig, 'enabled' | 'lastRunAt' | 'startupMinIntervalMs'>,
+  nowMs: number = Date.now(),
+): boolean {
+  if (!next.enabled || prev.enabled) return false
+  const lastRunAt = next.lastRunAt
+  if (lastRunAt === undefined || lastRunAt === '') return true
+  const lastMs = Date.parse(lastRunAt)
+  if (Number.isNaN(lastMs)) return true
+  return nowMs - lastMs >= next.startupMinIntervalMs
+}
+
 /** AutosyncConfig → 文件载荷（可选运行字段仅在非空时写入，保持文件干净）。 */
 function toChannelPayload(cfg: AutosyncConfig): Record<string, unknown> {
   const payload: Record<string, unknown> = {
@@ -175,6 +295,10 @@ function toChannelPayload(cfg: AutosyncConfig): Record<string, unknown> {
     interval: cfg.interval,
     startupMinIntervalMs: cfg.startupMinIntervalMs,
     consecutiveFailures: cfg.consecutiveFailures,
+    realtime: cfg.realtime ?? DEFAULT_AUTOSYNC_REALTIME,
+    remoteCheckMs: clampRemoteCheckMs(cfg.remoteCheckMs ?? DEFAULT_AUTOSYNC_REMOTE_CHECK_MS),
+    autoApplyTier: cfg.autoApplyTier ?? DEFAULT_AUTOSYNC_AUTO_APPLY_TIER,
+    conflictPolicy: cfg.conflictPolicy ?? DEFAULT_AUTOSYNC_CONFLICT_POLICY,
   };
   if (cfg.lastRunAt !== undefined && cfg.lastRunAt !== '') payload['lastRunAt'] = cfg.lastRunAt;
   if (cfg.lastRunStatus !== undefined) payload['lastRunStatus'] = cfg.lastRunStatus;

package/src/sync/autosync-risk-tier.test.ts

@@ -24,7 +24,7 @@ function section(id: string, decision: MergeSectionResult['decision']): MergeSec
 
 const GIT_CFG: SyncConfig = { schemaVersion: 2, transport: 'git', git: { repoUrl: 'git@github.com:foo/bar.git' } };
 
-test('sync-F5：自动同步不得应用 medium 风险分区（plugins），且必须把它记进历史 conflictedSections', async () => {
+test('sync-F5：缺省 autoApplyTier=medium → plugins（中风险）自动落盘，不再挂起等人工', async () => {
   const cfg: AutosyncConfig = { enabled: true, interval: '30m', startupMinIntervalMs: 300000, consecutiveFailures: 0 };
   const entries: AutosyncHistoryEntry[] = [];
   const appliedPlans: string[][] = [];
@@ -53,7 +53,43 @@ test('sync-F5：自动同步不得应用 medium 风险分区（plugins），且
 
   const result = await scheduler.runOnce('git');
 
-  assert.deepEqual(appliedPlans, [['settings']], 'medium 风险分区（plugins）绝不能被自动应用');
+  assert.deepEqual(appliedPlans, [['settings', 'plugins']], '缺省 medium 档：settings(low) 与 plugins(medium) 都可自动应用');
+  assert.ok(!entries.some((e) => (e.conflictedSections ?? []).length > 0), '没有分区被扣下 → 不该产生待确认记录');
+  assert.equal(result.status, 'success', '自动落盘中风险分区仍是一轮成功');
+});
+
+test('sync-F5：autoApplyTier=low → medium 风险分区（plugins）仍必须留给人工确认并进历史 conflictedSections', async () => {
+  const cfg: AutosyncConfig = {
+    enabled: true, interval: '30m', startupMinIntervalMs: 300000, consecutiveFailures: 0,
+    autoApplyTier: 'low',
+  };
+  const entries: AutosyncHistoryEntry[] = [];
+  const appliedPlans: string[][] = [];
+  const engine = {
+    merge: async (): Promise<MergePlan> => ({ sections: [section('settings', 'useRemote'), section('plugins', 'useRemote')] }),
+    applyMergePlan: async (plan: { autoApply: MergeSectionResult[] }) => {
+      appliedPlans.push(plan.autoApply.map((s) => String(s.id)));
+      return { ok: true, applied: plan.autoApply.map((s) => s.id), restoreId: 'r1', rolledBack: false, review: [], warnings: [] };
+    },
+    push: async () => ({ ok: true, snapshotId: 'snap-1', sections: [] as never, warnings: [] }),
+  };
+  const scheduler = new AutoSyncScheduler({
+    syncDir: '/tmp',
+    host: { log: nullLogger() },
+    makeSyncEngine: () => engine as unknown as SyncEngine,
+    msg: (k: string) => k,
+    runs: new RunRegistry(),
+    now: () => new Date(1_000_000_000_000),
+    readConfig: async () => cfg,
+    writeConfig: async () => undefined,
+    readSyncConfigFn: async () => GIT_CFG,
+    readHistoryFn: async () => ({ schemaVersion: 1, autosyncEntries: entries, updatedAt: '' }),
+    appendHistoryFn: async (e) => { entries.push(e); },
+  });
+
+  const result = await scheduler.runOnce('git');
+
+  assert.deepEqual(appliedPlans, [['settings']], 'low 档下 medium 风险分区（plugins）绝不能被自动应用');
   const withSections = entries.find((e) => (e.conflictedSections ?? []).length > 0);
   assert.ok(withSections !== undefined, '被扣下的分区必须写进历史（可见，不静默）');
   assert.deepEqual(withSections!.conflictedSections, ['plugins']);