ygc-dsh-sync 1.0.2 → 1.2.0

package/lib/api.js

@@ -23,7 +23,17 @@ import {
   scanLocalSessions,
 } from './backup.js';
 import { attachMany, attachedIds, findPulledUnattached, findUnattached } from './attach.js';
-import { ensureOwnFolder, joinMachineId, repairAll, scanFolders, splitMachineId } from './patrol.js';
+import { joinMachineId, repairAll, scanFolders, splitMachineId } from './patrol.js';
+import {
+  adoptFeature,
+  decisionOf,
+  dropFeature,
+  featurePath,
+  hasFeature,
+  inactiveReason,
+  planFeatures,
+  rememberDecision,
+} from './features.js';
 import {
   LINEAGE_FILE,
   LOCAL_SKILLS_ROOT,
@@ -218,7 +228,21 @@ export function createApi(deps) {
       const matched = pickWorkspaces(all, state.folders);
       const localIndex = scanLocalSessions();
 
-      const workspaces = matched.map((ws) => {
+      // 1.2.0：匹配的工作区里只把「有本机特征文件夹」的算作参与同步的；
+      // 其余的单独列一份「未参与」清单，面板上给原因和采纳按钮。
+      const active = matched.filter((ws) => hasFeature(ws.path, machineId));
+      const inactive = matched
+        .filter((ws) => !hasFeature(ws.path, machineId))
+        .map((ws) => ({
+          id: ws.id,
+          path: ws.path,
+          title: ws.title || ws.path,
+          featurePath: featurePath(ws.path, machineId),
+          declined: decisionOf(state, ws.path) === 'decline',
+          reason: inactiveReason(ws.path, machineId, state),
+        }));
+
+      const workspaces = active.map((ws) => {
         const machines = listMachines(ws.path);
         const own = machines.find((m) => m.machineId === machineId);
         const others = machines.filter((m) => m.machineId !== machineId);
@@ -227,6 +251,7 @@ export function createApi(deps) {
           path: ws.path,
           title: ws.title || ws.path,
           matchedPrefix: ws.matchedPrefix,
+          featurePath: featurePath(ws.path, machineId),
           own: own ? { sessions: own.sessions, bytes: own.bytes, newest: own.newest } : { sessions: 0, bytes: 0, newest: 0 },
           others: others.map((o) => ({
             machineId: o.machineId,
@@ -237,6 +262,20 @@ export function createApi(deps) {
         };
       });
 
+      // 待人工确认的采纳候选：未注册的匹配目录 + 升级时检出的存量工作区
+      const scan = scanFolders({
+        folders: state.folders,
+        workspaces: all,
+        machineId,
+      });
+      const plan = planFeatures({
+        folders: state.folders,
+        workspaces: all,
+        discover: scan.discover,
+        state,
+        machineId,
+      });
+
       json(res, 200, {
         ok: true,
         machineId,
@@ -247,6 +286,14 @@ export function createApi(deps) {
         lastBackupAt: state.lastBackupAt,
         lastPullAt: state.lastPullAt,
         patrol: state.patrol,
+        // 特征文件夹采纳：待人工确认清单 + 已有格子的工作区数
+        features: {
+          initialized: state.features.initialized === true,
+          pending: plan.pending,
+          pendingCount: plan.pending.length,
+          activeCount: active.length,
+          inactiveCount: inactive.length,
+        },
         skills: { ...state.skills, localRoot: LOCAL_SKILLS_ROOT },
         // 插件清单共享（1.0.0 从自动更新器迁来）：配置 + 运行态 + 口径声明
         plugins: {
@@ -258,6 +305,8 @@ export function createApi(deps) {
         history: state.history.slice(0, 20),
         workspaceCount: all.length,
         matchedCount: workspaces.length,
+        matchedTotal: matched.length,
+        inactive,
         workspaces,
         totals: {
           ownSessions: workspaces.reduce((n, w) => n + w.own.sessions, 0),
@@ -309,13 +358,23 @@ export function createApi(deps) {
       });
     },
 
-    /** 立即备份：全部匹配工作区，或指定 id 列表。 */
+    /** 立即备份：只备份「有本机特征文件夹」的工作区。 */
     'POST /backup': async (req, res) => {
       const body = await readJson(req);
       const state = loadState();
       const machineId = deps.machineId() || state.machineId;
       const all = listWorkspaces();
-      const matched = pickWorkspaces(all, state.folders);
+      // 1.2.0：只对「特征文件夹存在」的工作区干活；没建格子的跳过并报原因
+      const matchedAll = pickWorkspaces(all, state.folders);
+      const matched = matchedAll.filter((w) => hasFeature(w.path, machineId));
+      const skipped = matchedAll
+        .filter((w) => !hasFeature(w.path, machineId))
+        .map((w) => ({
+          id: w.id,
+          path: w.path,
+          title: w.title || w.path,
+          reason: '没有本机特征文件夹（未参与备份）',
+        }));
       const chosen =
         Array.isArray(body.workspaceIds) && body.workspaceIds.length
           ? matched.filter((w) => body.workspaceIds.includes(w.id))
@@ -336,24 +395,41 @@ export function createApi(deps) {
       pushHistory(
         next,
         'backup',
-        `备份 ${chosen.length} 个工作区：新增 ${created}、更新 ${updated}、${humanBytes(bytes)}`,
+        `备份 ${chosen.length} 个工作区：新增 ${created}、更新 ${updated}、${humanBytes(bytes)}` +
+          `${skipped.length ? `；跳过 ${skipped.length} 个没有本机特征文件夹的` : ''}`,
       );
       saveState(next);
 
       json(res, 200, {
         ok: true,
         results,
-        summary: { workspaces: chosen.length, created, updated, bytes },
+        skipped,
+        summary: { workspaces: chosen.length, created, updated, bytes, skipped: skipped.length },
       });
     },
 
-    /** 一键拉取：多选工作区。 */
+    /**
+     * 一键拉取：多选工作区。
+     *
+     * 1.2.0 起只拉「有本机特征文件夹」的工作区——没建格子的本机不参与同步，
+     * 往里拉会话等于替人做决定。拉完的会话归属登记是拉取的一部分，不再单列按钮：
+     * 只写文件不登记，DSH 侧栏只会把它显示成「未分组」。
+     */
     'POST /pull': async (req, res) => {
       const body = await readJson(req);
       const state = loadState();
       const machineId = deps.machineId() || state.machineId;
       const all = listWorkspaces();
-      const matched = pickWorkspaces(all, state.folders);
+      const matchedAll = pickWorkspaces(all, state.folders);
+      const matched = matchedAll.filter((w) => hasFeature(w.path, machineId));
+      const skipped = matchedAll
+        .filter((w) => !hasFeature(w.path, machineId))
+        .map((w) => ({
+          id: w.id,
+          path: w.path,
+          title: w.title || w.path,
+          reason: '没有本机特征文件夹（未参与拉取）',
+        }));
       const chosen =
         Array.isArray(body.workspaceIds) && body.workspaceIds.length
           ? matched.filter((w) => body.workspaceIds.includes(w.id))
@@ -364,22 +440,33 @@ export function createApi(deps) {
        *
        * 这是「拉取后显示在未分组」最常见的原因之一：目录里有别的机器的
        * 会话备份，可它压根不在 workspaceRegistry 里，/pull 的匹配范围就没有它。
-       * 用户点「一键拉取」本身就是明确意图，这里先注册再拉。
+       *
+       * 但它同时是「本机还没建特征文件夹」的目录 —— 1.2.0 起**不再自动注册**：
+       * 注册 + 建格子必须由人在面板上确认（POST /features/adopt）。
+       * 这里只把它们列在 unregistered 里交回去。
        */
-      const autoRegister = body.autoRegister !== false;
+      const autoRegister = body.autoRegister === true;
       const registered = [];
       const registerErrors = [];
-      if (autoRegister && typeof deps.registerWorkspace === 'function') {
+      const unregistered = [];
+      if (typeof deps.registerWorkspace === 'function') {
         const scan = scanFolders({
           folders: state.folders,
           workspaces: all,
           machineId,
         });
         for (const item of scan.discover) {
-          // 只自动处理「确实有别的机器的备份」那些，别把空壳目录也注册进来
+          // 只关心「确实有别的机器的备份」那些，空壳目录不提
           const hasRemote = listMachines(item.path).some((m) => m.machineId !== machineId);
           if (!hasRemote) continue;
+          if (hasFeature(item.path, machineId)) continue;
+          if (!autoRegister) {
+            unregistered.push({ path: item.path, title: item.title, why: '需要先建本机特征文件夹' });
+            continue;
+          }
+          // 显式 autoRegister:true（供脚本/测试用），仍然要先建格子再注册
           try {
+            adoptFeature(item.path, machineId);
             const out = await deps.registerWorkspace(item.path, item.title);
             registered.push({ path: item.path, id: out?.id });
             all.push({ id: out?.id, path: item.path, title: item.title });
@@ -389,8 +476,8 @@ export function createApi(deps) {
         }
       }
 
-      // 注册完重新匹配一次，把新注册的目录纳入拉取范围
-      const matched2 = pickWorkspaces(all, state.folders);
+      // 注册完重新匹配一次，把新注册的目录纳入拉取范围（仍只含有格子的）
+      const matched2 = pickWorkspaces(all, state.folders).filter((w) => hasFeature(w.path, machineId));
       const chosen2 =
         Array.isArray(body.workspaceIds) && body.workspaceIds.length
           ? matched2.filter((w) =>
@@ -443,8 +530,10 @@ export function createApi(deps) {
       json(res, 200, {
         ok: true,
         results,
+        skipped,
         registered,
         registerErrors,
+        unregistered,
         summary: {
           workspaces: chosen2.length,
           imported,
@@ -453,27 +542,162 @@ export function createApi(deps) {
           attached,
           attachFailed,
           registered: registered.length,
+          skipped: skipped.length,
         },
         // 全部登记成功就不需要重开会话索引：会话列表是实时读盘 + 归属表的
         needsRestart: imported + forked > attached,
       });
     },
 
+    /**
+     * 采纳：给选中的目录建本机特征文件夹；未注册的顺带注册成工作区。
+     *
+     * 这是「检测到匹配的工作区文件夹 → 人工选择要不要在里面建本机特征文件夹」
+     * 的那个人工入口。同意之后立刻生效：进侧边栏、参与备份与拉取，
+     * 不需要再点一次注册。
+     */
+    'POST /features/adopt': async (req, res) => {
+      const body = await readJson(req);
+      const state = loadState();
+      const machineId = deps.machineId() || state.machineId;
+      const wanted = Array.isArray(body.paths)
+        ? body.paths.filter((p) => typeof p === 'string' && p.trim())
+        : [];
+      if (!wanted.length) {
+        json(res, 400, { ok: false, error: '未选择任何目录' });
+        return;
+      }
+
+      const existing = new Set(listWorkspaces().map((w) => pathKey(w.path)));
+      const adopted = [];
+      const registeredList = [];
+      const errors = [];
+
+      for (const raw of wanted) {
+        const p = normSlash(raw);
+        try {
+          const target = adoptFeature(p, machineId);
+          rememberDecision(state, p, 'adopt');
+          let registeredId;
+          if (!existing.has(pathKey(p))) {
+            if (typeof deps.registerWorkspace === 'function') {
+              const out = await deps.registerWorkspace(p, path.basename(p));
+              registeredId = out?.id;
+              existing.add(pathKey(p));
+              registeredList.push({ path: p, id: registeredId });
+            }
+          } else {
+            registeredId = listWorkspaces().find((w) => pathKey(w.path) === pathKey(p))?.id;
+          }
+          adopted.push({ path: p, id: registeredId, feature: target });
+        } catch (err) {
+          errors.push({ path: p, message: String((err && err.message) || err) });
+        }
+      }
+
+      // 基线补上：刚采纳的立刻算「已知」，否则下一轮会被当成新建/缺失再处理一遍
+      if (!state.features) state.features = { initialized: true, decisions: {}, known: {} };
+      for (const item of adopted) {
+        if (item.id !== undefined && item.id !== null) state.features.known[String(item.id)] = item.path;
+      }
+      pushHistory(
+        state,
+        'features',
+        `按人工选择建本机特征文件夹 ${adopted.length} 个${
+          registeredList.length ? `（其中注册工作区 ${registeredList.length} 个）` : ''
+        }`,
+      );
+      saveState(state);
+
+      json(res, 200, { ok: true, adopted, registered: registeredList, errors });
+    },
+
+    /** 拒绝：记录「这个目录本机不要建格子」，之后巡检不再反复建。 */
+    'POST /features/decline': async (req, res) => {
+      const body = await readJson(req);
+      const state = loadState();
+      const wanted = Array.isArray(body.paths)
+        ? body.paths.filter((p) => typeof p === 'string' && p.trim())
+        : [];
+      if (!wanted.length) {
+        json(res, 400, { ok: false, error: '未选择任何目录' });
+        return;
+      }
+      for (const raw of wanted) rememberDecision(state, normSlash(raw), 'decline');
+      pushHistory(state, 'features', `跳过 ${wanted.length} 个目录（不建本机特征文件夹）`);
+      saveState(state);
+      json(res, 200, { ok: true, declined: wanted.map((p) => normSlash(p)) });
+    },
+
+    /**
+     * 删除：删本机特征文件夹（等于本机不再参与这个工作区的同步）。
+     *
+     * body.removeWorkspace=true 时连工作区注册一起去掉（侧边栏不再显示）；
+     * 默认只删格子，保留工作区，因为「不想同步」和「不想在这里干活」是两件事。
+     */
+    'POST /features/drop': async (req, res) => {
+      const body = await readJson(req);
+      const state = loadState();
+      const machineId = deps.machineId() || state.machineId;
+      const wanted = Array.isArray(body.paths)
+        ? body.paths.filter((p) => typeof p === 'string' && p.trim())
+        : [];
+      if (!wanted.length) {
+        json(res, 400, { ok: false, error: '未选择任何目录' });
+        return;
+      }
+      const removeWorkspace = body.removeWorkspace === true;
+      const all = listWorkspaces();
+      const dropped = [];
+      const errors = [];
+
+      for (const raw of wanted) {
+        const p = normSlash(raw);
+        try {
+          const out = dropFeature(p, machineId, { log });
+          if (!out.removed && out.reason !== '本来就没有') {
+            errors.push({ path: p, message: out.reason || '删除失败' });
+            continue;
+          }
+          rememberDecision(state, p, 'decline');
+          let removedWorkspace = false;
+          if (removeWorkspace && typeof deps.deleteWorkspace === 'function') {
+            const hit = all.find((w) => pathKey(w.path) === pathKey(p));
+            if (hit) {
+              await deps.deleteWorkspace(hit.id);
+              removedWorkspace = true;
+            }
+          }
+          for (const [id, knownPath] of Object.entries(state.features.known || {})) {
+            if (pathKey(knownPath) === pathKey(p)) delete state.features.known[id];
+          }
+          dropped.push({ path: p, removed: true, removedWorkspace });
+        } catch (err) {
+          errors.push({ path: p, message: String((err && err.message) || err) });
+        }
+      }
+
+      pushHistory(state, 'features', `删除本机特征文件夹 ${dropped.length} 个`);
+      saveState(state);
+      json(res, 200, { ok: true, dropped, errors });
+    },
+
     /**
      * 补登记：把「本插件拉进来、但没进归属账」的会话补进 sessionIds。
      *
      * 这是历史遗留数据的清理入口——旧版拉取只写文件不登记，
-     * 那些会话至今仍散在「未分组」里。
+     * 那些会话至今仍散在「未分组」里。**日常不需要点**：/pull 拉完自己会登记。
      *
      * 默认只补拉取产物（别的机器备份目录里有它），不会把自动化插件和
      * 子代理留下的会话一起刷进来。要全量补必须显式传 all:true。
+     * 1.2.0 起只处理有本机特征文件夹的工作区。
      */
     'POST /attach/repair': async (req, res) => {
       const body = await readJson(req);
       const state = loadState();
       const machineId = deps.machineId() || state.machineId;
       const all = listWorkspaces();
-      const matched = pickWorkspaces(all, state.folders);
+      const matched = pickWorkspaces(all, state.folders).filter((w) => hasFeature(w.path, machineId));
       const chosen =
         Array.isArray(body.workspaceIds) && body.workspaceIds.length
           ? matched.filter((w) => body.workspaceIds.includes(w.id))
@@ -527,27 +751,60 @@ export function createApi(deps) {
       });
     },
 
-    /** 巡检：发现待注册工作区 + 缺本机特征文件夹的。只扫描，不改任何东西。 */
+    /**
+     * 巡检：只扫描，不动任何文件。
+     *
+     * 返回四类：
+     *   discover   符合插件结构、但本机还没注册的目录（要人点）
+     *   pending    需要人工决定「要不要在本机建特征文件夹」的（含 discover 与存量工作区）
+     *   restore/drop  下一轮巡检会自动做的（外部删除自愈 / 随工作区删除）
+     *   repair     已注册但缺格子——1.2.0 起不再自动补，归到 pending 让人点头
+     */
     'POST /patrol/scan': async (req, res) => {
       const state = loadState();
       const machineId = deps.machineId() || state.machineId;
+      const all = listWorkspaces();
       const result = scanFolders({
         folders: state.folders,
-        workspaces: listWorkspaces(),
+        workspaces: all,
+        machineId,
+      });
+      const plan = planFeatures({
+        folders: state.folders,
+        workspaces: all,
+        discover: result.discover,
+        state,
         machineId,
       });
 
       const next = loadState();
-      next.patrol = { ...next.patrol, lastRunAt: Date.now(), lastResult: {
-        discover: result.discover.length,
-        repair: result.repair.length,
-      } };
+      next.patrol = {
+        ...next.patrol,
+        lastRunAt: Date.now(),
+        lastResult: {
+          discover: result.discover.length,
+          repair: result.repair.length,
+          pending: plan.pending.length,
+        },
+      };
       saveState(next);
 
-      json(res, 200, { ok: true, ...result, machineId });
+      json(res, 200, {
+        ok: true,
+        ...result,
+        pending: plan.pending,
+        autoAdopt: plan.adopt,
+        autoRestore: plan.restore,
+        autoDrop: plan.drop,
+        machineId,
+      });
     },
 
-    /** 注册：把选中的目录注册为工作区（用户确认后才调用）。 */
+    /**
+     * 注册：把选中的目录注册为工作区，并建本机特征文件夹。
+     *
+     * 与 /features/adopt 等价（保留旧路由给已有面板/脚本用）。
+     */
     'POST /patrol/register': async (req, res) => {
       const body = await readJson(req);
       const state = loadState();
@@ -569,26 +826,35 @@ export function createApi(deps) {
       for (const p of paths) {
         try {
           if (existing.has(pathKey(p))) {
-            registered.push({ path: p, skipped: '已注册' });
+            // 已注册但可能缺格子：这次点了同意就等于确认建格子
+            const target = adoptFeature(p, machineId);
+            rememberDecision(state, p, 'adopt');
+            registered.push({ path: p, skipped: '已注册', own: target });
             continue;
           }
           const out = await deps.registerWorkspace(p, path.basename(p));
-          // 注册完顺手补齐本机特征文件夹
-          const target = ensureOwnFolder(p, machineId);
+          // 注册 + 建格子一起做：人点了同意，就该立刻参与
+          const target = adoptFeature(p, machineId);
+          rememberDecision(state, p, 'adopt');
+          if (out?.id !== undefined) state.features.known[String(out.id)] = normSlash(p);
           registered.push({ path: p, id: out?.id, created: !!out?.created, own: target });
         } catch (err) {
           errors.push({ path: p, message: String((err && err.message) || err) });
         }
       }
 
-      const next = loadState();
-      pushHistory(next, 'register', `注册 ${registered.length} 个工作区`);
-      saveState(next);
+      pushHistory(state, 'register', `注册 ${registered.length} 个工作区（含建本机特征文件夹）`);
+      saveState(state);
 
       json(res, 200, { ok: true, registered, errors });
     },
 
-    /** 补全：给缺本机特征文件夹的工作区补上。 */
+    /**
+     * 补建：给选中的工作区建本机特征文件夹。
+     *
+     * 1.2.0 起**不再**「发现问题就自动补」：只补传进来的 paths，
+     * 没传就什么都不做（历史上这里会对全部匹配工作区动手）。
+     */
     'POST /patrol/repair': async (req, res) => {
       const body = await readJson(req);
       const state = loadState();
@@ -596,12 +862,17 @@ export function createApi(deps) {
       const all = listWorkspaces();
       const targets = Array.isArray(body.paths) && body.paths.length
         ? all.filter((w) => body.paths.some((p) => pathKey(p) === pathKey(w.path)))
-        : pickWorkspaces(all, state.folders);
+        : [];
 
       const out = repairAll(targets, machineId);
-      const next = loadState();
-      pushHistory(next, 'repair', `补全 ${out.created.length} 个特征文件夹`);
-      saveState(next);
+      for (const p of body.paths || []) rememberDecision(state, p, 'adopt');
+      if (!state.features) state.features = { initialized: true, decisions: {}, known: {} };
+      for (const ws of targets) {
+        if (!hasFeature(ws.path, machineId)) continue;
+        state.features.known[String(ws.id)] = normSlash(ws.path);
+      }
+      pushHistory(state, 'repair', `补建 ${out.created.length} 个本机特征文件夹（人工指定）`);
+      saveState(state);
 
       json(res, 200, { ok: true, ...out });
     },

package/lib/core.js

@@ -182,6 +182,23 @@ const DEFAULT_STATE = {
     lastResult: null,
     lastError: '',
   },
+  /**
+   * 本机特征文件夹的采纳状态（1.2.0 新增）。
+   *
+   * 判据永远是磁盘：`<工作区>/.dsh-sync/sessions/<本机标识>/` 存在 = 已采纳。
+   * 这里只记两样辅助信息：
+   *   decisions  人对某个路径的表态（adopt / decline），防止每轮重复问；
+   *   known      上一轮看到的工作区清单，用来判「本机新建」与「本机已删除」。
+   */
+  features: {
+    /** 1.2.0 首次运行是否已把「存量工作区」归过档：没有就一律问人，不自己建。 */
+    initialized: false,
+    /** 路径（小写归一）→ { action, path, at } */
+    decisions: {},
+    /** 工作区 id → 路径；只记已采纳过的 */
+    known: {},
+    lastPlanAt: 0,
+  },
 };
 
 export function loadState() {
@@ -196,6 +213,7 @@ export function loadState() {
     patrol: false,
     patrolInterval: false,
     plugins: false,
+    features: false,
   };
   try {
     const raw = fs.readFileSync(STATE_FILE, 'utf8');
@@ -209,6 +227,7 @@ export function loadState() {
       patrol: parsed.patrol !== undefined,
       patrolInterval: !!(parsed.patrol && parsed.patrol.intervalMinutes !== undefined),
       plugins: parsed.plugins !== undefined,
+      features: parsed.features !== undefined,
     };
     state = { ...state, ...parsed };
     // skills 与 patrol 需要深拷贝，否则后续就地修改会改到 parsed
@@ -220,6 +239,14 @@ export function loadState() {
     }
     if (parsed.patrol && typeof parsed.patrol === 'object') state.patrol = { ...parsed.patrol };
     if (parsed.plugins && typeof parsed.plugins === 'object') state.plugins = { ...parsed.plugins };
+    if (parsed.features && typeof parsed.features === 'object') {
+      state.features = {
+        initialized: parsed.features.initialized === true,
+        decisions: { ...(parsed.features.decisions || {}) },
+        known: { ...(parsed.features.known || {}) },
+        lastPlanAt: Number(parsed.features.lastPlanAt) || 0,
+      };
+    }
     if (!Array.isArray(state.folders)) state.folders = [];
     if (!Array.isArray(state.history)) state.history = [];
   } catch {
@@ -285,6 +312,19 @@ export function loadState() {
     state.plugins.lastResult && typeof state.plugins.lastResult === 'object' ? state.plugins.lastResult : null;
   state.plugins.lastError = typeof state.plugins.lastError === 'string' ? state.plugins.lastError.slice(0, 800) : '';
 
+  // 本机特征文件夹的采纳状态（1.2.0 新增；老 state 没有这一段）
+  if (!state.features || typeof state.features !== 'object' || Array.isArray(state.features)) {
+    state.features = { initialized: false, decisions: {}, known: {}, lastPlanAt: 0 };
+  }
+  state.features.initialized = state.features.initialized === true;
+  if (!state.features.decisions || typeof state.features.decisions !== 'object' || Array.isArray(state.features.decisions)) {
+    state.features.decisions = {};
+  }
+  if (!state.features.known || typeof state.features.known !== 'object' || Array.isArray(state.features.known)) {
+    state.features.known = {};
+  }
+  state.features.lastPlanAt = Number(state.features.lastPlanAt) || 0;
+
   if (!state.machineHashGeneratedAt) state.machineHashGeneratedAt = 0;
 
   /**
@@ -323,7 +363,8 @@ export function loadState() {
     !diskHas.modes ||
     !diskHas.mnemonAuto ||
     !diskHas.patrol ||
-    !diskHas.patrolInterval;
+    !diskHas.patrolInterval ||
+    !diskHas.features;
 
   if (needsWrite) saveState(state);
   return state;