⚠ 初始化失败
preload.js 未正确加载，window.api 不可用。
可能的原因：
- Electron 版本过低，不支持当前 preload 配置
- preload.js 路径配置错误
- 安全策略（contextIsolation）配置错误
请尝试重启应用，或运行 npm install 后重试。
`;
document.body.innerHTML = errorHtml;
throw new Error('window.api not available');
}
// ============================================
// 初始化
// ============================================
const settingsStore = new SettingsStore();
// 把 settingsStore 注入 TaskStore —— 让 _appendTaskWithPosition 能读到
// newTaskPosition / completedPosition / trashPosition 偏好。
// 不注入时 TaskStore 默认按 'front' 走（与 DEFAULT_SETTINGS 对齐），
// 但生产环境里 settingsStore 永远先创建出来，所以这里必须传，避免新加任务时
// 用错落点（追加到末尾而不是最新在最上）。
const store = new TaskStore({ settingsStore });
// H4 修复：全局未处理 IPC 拒绝兜底 —— 之前 settings-dialog / toolbar / sidebar
// 里大量 `await window.api.xxx().catch(console.warn)` 只打日志、不通知用户，
// 用户看到按钮「点了没反应」却无从知晓是 IPC 通道断了。
// 这里装一个 unhandledrejection 监听，吞掉那些没被业务方处理的拒绝，转成 toast
// 让用户至少知道「刚才那个动作失败了」。业务方已经在 catch 里 toast 的不会冒到这里。
if (typeof window !== 'undefined' && !window.__todoUnhandledRejectionInstalled) {
window.__todoUnhandledRejectionInstalled = true;
window.addEventListener('unhandledrejection', (e) => {
const reason = e && e.reason;
const text = reason && (reason.message || reason.code || String(reason));
// 过滤明显可忽略的拒绝（用户主动取消的对话框等）
if (!text || /abort/i.test(text) || /user cancelled/i.test(text)) return;
rendererLog('unhandledrejection:', text);
toast(`操作失败：${text}`, 'error', 3000);
});
}
// bootstrap 幂等守卫：模块可能因 HMR / devtools 重载被多次执行，
// 而 window.api.onXxx 返回的解绑函数此前从未被持有 —— 每次重跑都会再叠加
// 一份监听器，导致 'menu:save' 一类事件被处理两次（双重保存、双重 toast）。
let bootstrapped = false;
// ============================================
// 启动流程
// ============================================
// 模块级：bootstrap 注册的所有监听器的取消函数。
// 生产单例里不会被消费 —— renderer 进程与窗口同生死，window unload 时整个进程销毁，
// 不存在"跨生命周期需要解绑"的场景。Electron renderer 默认也没有 HMR（devtools
// reload 会重启整个进程）。这里只是统一收集 cancel 函数，**避免 HMR / 单元测试场景
// 后续真的有需要时再补 cleanup**。当前实现下，bootstrapUnsubs 是单纯 reference
// 池 —— push 而不读 —— 不会泄漏。
const bootstrapUnsubs = [];
/**
* 取消 bootstrap 注册的所有监听器。仅供 hot-reload / 测试场景使用。
* - 直接调每个 cancel 函数，不存在「取消一半」状态 —— 任意顺序都安全。
* - cancel 后把池清零，再调 bootstrap() 会重新注册（重新走 reset 分支）。
*/
export function disposeBootstrap() {
while (bootstrapUnsubs.length) {
const fn = bootstrapUnsubs.pop();
try { fn(); } catch (e) { console.error('[renderer] bootstrap dispose 异常:', e); }
}
bootstrapped = false;
}
async function bootstrap() {
if (bootstrapped) {
console.warn('[renderer] bootstrap 已在执行，跳过重复调用');
return;
}
bootstrapped = true;
rendererLog('bootstrap 开始');
// 跟踪所有 bootstrap 注册的 store / IPC / DOM 监听器的取消函数。
// 生产单例生命周期里不会被消费（renderer 与窗口同生死），
// 但保留在 cleanupBootstrap() 给将来 hot-reload / 单元测试使用。
// 直接调 cancel 即可，不存在「取消一半」状态 —— 任何顺序都能保证 listener 不再被触发。
bootstrapUnsubs.length = 0; // 重置（万一 bootstrap 被以某种方式二次调用）
try {
// 加载设置（用户配置）
await settingsStore.load();
const settings = settingsStore.all;
rendererLog('设置:', settings);
// 应用主题
const theme = settings.theme || 'dark';
store.theme = theme;
document.body.dataset.theme = store.resolveTheme();
// 应用字体大小
document.body.dataset.fontSize = settings.fontSize || 'medium';
// 应用配色风格（与 theme 正交 —— 由 CSS 复合选择器解析，body 上只要一个 data 属性即可）
document.body.dataset.colorStyle = settings.colorStyle || 'indigo';
// 恢复全局过滤 / 排序偏好（在 UI 组件实例化之前设置，避免一次空渲染）
// 这里直接赋值即可：setFilter/setSortBy 早于 UI 订阅，没有 UI 副作用
if (Object.values(Filter).includes(settings.filter)) {
store.filter = settings.filter;
}
if (Object.values(SortBy).includes(settings.sortBy)) {
store.sortBy = settings.sortBy;
}
// 将后续 setFilter/setSortBy 的变更同步持久化（用户切换偏好后立即写入设置）
bootstrapUnsubs.push(store.on('filter', (filter) => settingsStore.update({ filter })));
bootstrapUnsubs.push(store.on('sort', (sortBy) => settingsStore.update({ sortBy })));
// 监听设置变化（字体大小实时生效）
bootstrapUnsubs.push(settingsStore.on('change', ({ changed }) => {
if (changed.includes('fontSize')) {
document.body.dataset.fontSize = settingsStore.get('fontSize');
}
// 配色风格由 settingsStore → body data 属性 → CSS 复合选择器解析；
// 与 theme 一样只写一个属性即可，无需触发额外 JS 重新渲染
if (changed.includes('colorStyle')) {
document.body.dataset.colorStyle = settingsStore.get('colorStyle');
}
}));
// v4+ 修复：**必须**在任何 file:read / file:write IPC 之前注册 file:external-change 监听。
// 旧实现把这条 listener 注册放在 bootstrap 后段（line 289+）—— readFile 调用 main 进程
// 立刻 startWatchingFile（main.js:902），但渲染端还没注册 listener，期间云同步 / 外部编辑器
// 修改 todo.md 触发的 IPC 全部被吞，用户启动后看到的就是旧内容、也不会弹冲突对话框。
// resolveExternalChangeConflict 自身已有 `!pathsEqual(...) return` 守卫（store.filePath
// 未绑定前直接 return），所以这里可以安全地在 filePath 尚未赋值时就注册。
bootstrapUnsubs.push(window.api.onFileExternalChange((payload) => {
// 兼容旧实现可能仍然只发字符串
const filePath = typeof payload === 'string' ? payload : payload?.filePath;
const diskContent = typeof payload === 'object' ? payload?.diskContent : null;
resolveExternalChangeConflict(filePath, { diskContent });
}));
// 决定初始文件（根据用户配置的数据目录）
const dataDir = await window.api.getDataDir();
rendererLog('数据目录:', dataDir);
const defaultPath = joinPath(dataDir, 'todo.md');
rendererLog('默认文件路径:', defaultPath);
let filePath = null;
let content = null;
// 文件存在但读取失败 —— 必须与"文件不存在"区分开：
// 前者绝不能写入初始文档，否则会覆盖掉读不出来的用户数据
let readFailed = false;
// 尝试加载默认文件
try {
const exists = await window.api.fileExists(defaultPath);
rendererLog('默认文件存在:', exists);
if (exists) {
const result = await window.api.readFile(defaultPath);
rendererLog('默认文件存在:', exists, '→ 读取结果:', result.ok);
if (result.ok) {
filePath = defaultPath;
content = result.content;
} else {
readFailed = true;
rendererLog('读取默认文件失败:', result.error);
}
}
} catch (e) {
readFailed = true;
rendererLog('检查默认文件出错:', e.message);
}
// 加载到 Store
if (content !== null) {
// C1 修复：解析失败时自动回退到 .bak —— 旧实现只在 readFailed 路径报错，
// 但 parseMarkdown 在「读成功 + 解析为空数组」或「解析抛错」路径上仍会让
// 后续 autoSave 把损坏内容写回磁盘（覆盖掉可恢复的 .bak）。
// 先尝试直接解析；失败 / 内容为空 → 退回 .bak；.bak 也失败才进入临时模式。
try {
store.loadFromContent(content, filePath);
// 双重保险：parseMarkdown 返回空数组（极少但发生过：文件被外部工具清空、
// 解析器漏抛）。空数组 + _ensureBaseStructure 会塞回默认 4 个子分类，
// 下一次 save 直接覆盖磁盘。
const cats = store.categories;
const looksLegit = Array.isArray(cats) && cats.some(c =>
c.tasks && c.tasks.length > 0);
if (!looksLegit) {
rendererLog('loadFromContent 后无任务，疑似解析失败 —— 尝试 .bak 回退');
const bak = await tryReadBak(filePath);
if (bak) {
store.loadFromContent(bak, filePath);
toast(`主文件疑似损坏，已从备份恢复`, 'warning', 4000);
} else {
toast(`主文件为空且无备份，进入临时模式`, 'warning', 4000);
store.loadDefault(null);
}
} else {
toast(`已加载：${shortenPath(filePath)}`, 'success', 1500);
}
} catch (e) {
rendererLog('loadFromContent 抛错，尝试 .bak 回退:', e.message);
const bak = await tryReadBak(filePath);
if (bak) {
store.loadFromContent(bak, filePath);
toast(`主文件解析失败，已从备份恢复：${e.code || ''} ${e.message}`, 'warning', 4000);
} else {
store.loadDefault(null);
toast(`主文件解析失败且无备份：${e.code || ''} ${e.message}`, 'error', 6000);
}
}
} else if (readFailed) {
// 读不出来（磁盘错误 / 权限拒绝） —— 尝试 .bak 回退；都没有才进入临时模式
const bak = await tryReadBak(filePath || defaultPath);
if (bak) {
store.loadFromContent(bak, defaultPath);
toast(`无法读取主文件，已从备份恢复`, 'warning', 4000);
} else {
// 只读入内存、不绑定路径，避免任何写入动作碰到那个文件
store.loadDefault(null);
toast(`无法读取 ${shortenPath(defaultPath)}，已进入临时模式。请检查该文件后重启，勿在此状态下保存`, 'error', 8000);
}
} else {
// 确认不存在：写出一份初始文档，避免数据只存在于内存中
await createDefaultFile(defaultPath, `已创建: ${shortenPath(defaultPath)}`);
}
// 初始化 UI 组件
const toolbar = new Toolbar(store, settingsStore);
const sidebar = new Sidebar(store);
const taskList = new TaskList(store, { settingsStore });
// 状态栏
bootstrapUnsubs.push(setupStatusBar());
// 监听 Store 状态变化
// 职责划分：
// #status-text = 进度统计（由 setupStatusBar() 写），它已挂 'change' / 'load'
// #status-meta = 保存状态：未保存 / 已同步 HH:MM
// （CSS ::before 已提供 6px 状态点，dirty/saved 切换颜色，
// 不要在文本里再加 ●/✓ 否则会和圆点重叠）
// 旧实现：dirty 写 #status-meta，saved 写 #status-text，但 setupStatusBar 又把
// 统计塞回 #status-meta —— 三方争抢同一格，渲染顺序决定谁最终胜出。
//
// 保存成功的事件顺序：emit('saved') → emit('dirty', false)。
// 因此 dirty(false) 处理器不能再写 textContent=''，否则会立刻把刚刚
// 写好的「已同步 HH:MM」时间戳抹掉 —— 用户看到的现象是「Ctrl+S 之后
// 状态栏空空的，好像没保存过」。
bootstrapUnsubs.push(store.on('dirty', (isDirty) => {
const meta = document.getElementById('status-meta');
if (isDirty) {
// 只有进入「有未保存修改」时才覆写文本；离开时不动文本，
// 把「已同步 HH:MM」留给 saved 处理器去维护
meta.textContent = '未保存';
}
meta.classList.toggle('dirty', isDirty);
meta.classList.toggle('saved', !isDirty);
// 通知主进程 dirty 状态变化，用于退出时判断是否需要刷写保存
window.api.notifyDirtyChanged(isDirty);
}));
bootstrapUnsubs.push(store.on('saved', () => {
const meta = document.getElementById('status-meta');
const t = new Date().toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' });
meta.textContent = `已同步 ${t}`;
meta.classList.remove('dirty');
meta.classList.add('saved');
}));
// 重新加载文件后清掉旧的保存状态提示 —— loadFromContent / loadDefault
// 内部 _suppressDirty=true 期间不会 emit dirty，外部修改监听也走这里
// 重置状态栏；不重置会让上一秒保存的「已同步 14:32」看上去像新加载
// 出来的内容也是「已同步」状态，误导用户
bootstrapUnsubs.push(store.on('load', () => {
const meta = document.getElementById('status-meta');
meta.textContent = '';
meta.classList.remove('dirty');
meta.classList.remove('saved');
}));
// 保存失败：把错误抛给用户（之前完全无反馈，磁盘满/权限问题会让用户误以为
// 「未保存」只是延迟）。EXTERNAL_CHANGE_DETECTED 由主进程 mtime 检查触发：
// 自动保存试图覆盖一个被外部动过的文件 —— 这正是数据丢失防护的核心触发点，
// 必须走冲突解决流程，而不是简单地 toast 一行「保存失败」就丢弃用户的修改。
//
// v3.4+：save-error 载荷升级为 {code, message, diskContent} 对象（见 task-store._buildSaveErrorPayload）。
bootstrapUnsubs.push(store.on('save-error', (errorInfo) => {
// 兼容旧实现可能仍然发字符串（防御性）
const code = typeof errorInfo === 'string' ? errorInfo : errorInfo?.code;
const message = typeof errorInfo === 'string'
? errorInfo
: (errorInfo?.message || errorInfo?.code || '未知错误');
const diskContent = typeof errorInfo === 'object' ? errorInfo?.diskContent : null;
if (code === 'EXTERNAL_CHANGE_DETECTED') {
// 防御性：save-error 触发时 store.filePath 应已绑定，但理论上未关联文件
// （loadDefault(null) 模式）下走 autoSave 的极端路径也可能发出此事件。
// 这种场景 pathsEqual(null, null) 会短路通过（a===b），随即 readFile(null)
// 在主进程抛错 —— 提前拦截并 toast 跳过。
if (!store.filePath) {
toast('检测到外部修改冲突，但当前未关联文件 —— 已跳过自动保存', 'warning', 4000);
return;
}
// 主进程已经塞了 diskContent —— 不用再发 file:read
syncLog('autoSave-race-blocked', { filePath: store.filePath });
resolveExternalChangeConflict(store.filePath, { diskContent, source: 'save-error' });
} else {
toast(`保存失败：${message}`, 'error', 4000);
}
}));
// 退出前刷写：主进程在 before-quit 时发送此消息，渲染进程立即保存
// 保存完成后通知主进程，主进程随即真正退出（避免等待 5 秒超时）
//
// 多轮 saveNow 直到真的没有 dirty —— 防止「await saveNow 期间用户又改了」：
// saveNow 内部用 _dirtyVersion 在 await 后比对，若检测到中途改动会保留
// dirty=true 让后续 autoSave 兜底，但 quit 流程下没有「后续」，必须自己再写。
// 上限 5 轮：用户一直狂敲键盘时不死循环，让主进程的 5s 超时兜底。
bootstrapUnsubs.push(window.api.onFlushPendingSave(async () => {
// v4+ 修复（H-Critical）：
// 1) saveNow() 可能 reject（IPC 异常 / EXTERNAL_CHANGE_DETECTED 等），
// 必须 try/catch/finally 包裹，否则 notifyFlushDone 永不调用，
// 主进程 5s 超时兜底后强制 app.quit() —— 未保存内容被静默吞掉。
// 2) store.filePath === null 但 dirty=true 时（用户改了内容但还没保存到磁盘）
// 旧循环条件 `&& store.filePath` 直接不进入，必须先弹 Save As 让用户
// 选位置，否则循环结束后 notifyFlushDone、主进程退出 → 永久丢数据。
try {
if (store.dirty && !store.filePath) {
// 退出流程触发 —— 弹原生 Save As 对话框
const result = await window.api.saveFileDialog();
if (result) {
store.setFilePath(result);
}
}
// 多轮 saveNow 直到真的没有 dirty —— 防止「await saveNow 期间用户又改了」：
// saveNow 内部用 _dirtyVersion 在 await 后比对，若检测到中途改动会保留
// dirty=true 让后续 autoSave 兜底，但 quit 流程下没有「后续」，必须自己再写。
// 上限 5 轮：用户一直狂敲键盘时不死循环，让主进程的 5s 超时兜底。
for (let i = 0; i < 5 && store.dirty && store.filePath; i++) {
await store.saveNow();
}
} catch (e) {
// 兜底：saveNow reject 时记录错误但仍通知主进程放行退出
// —— 强制挂起主进程不会让数据凭空恢复，反而让用户以为"卡死"。
console.error('[flush] saveNow 异常:', e);
} finally {
window.api.notifyFlushDone();
}
}));
// 文件外部修改检测
// 已在 bootstrap 前段（line 143）注册 onFileExternalChange 监听，
// 这里**不再重复注册** —— 旧实现 line 302 是 v3 时期的 listener，
// 注释里说"必须在 file:read 之前注册"已搬到 line 143，旧 listener 应删除。
// 重复注册会导致每次外部修改 IPC 被处理两次（虽然 conflictDialogShowing
// 守卫能挡住重复弹框，但 CPU 开销翻倍 + 未来若守卫改动会埋雷）。
// 主进程菜单事件
bootstrapUnsubs.push(window.api.onMenuCommand((cmd) => {
switch (cmd) {
case 'menu:save': handleSaveFile(); break;
case 'menu:reload': handleReload(); break;
case 'menu:toggle-theme': toggleTheme(); break;
case 'menu:settings': openSettings(); break;
}
}));
// 工具栏事件
document.addEventListener('toolbar:toggle-theme', toggleTheme);
document.addEventListener('toolbar:settings', openSettings);
bootstrapUnsubs.push(
() => document.removeEventListener('toolbar:toggle-theme', toggleTheme),
() => document.removeEventListener('toolbar:settings', openSettings)
);
// Cmd/Ctrl+K 调起命令面板
const onCmdK = (e) => {
// 已经在命令面板 / 模态中就别再触发
if (document.querySelector('.modal-overlay, .command-palette-overlay')) return;
// H13-1: 在 input/textarea 里 Cmd+K 是某些编辑器的"删除到行尾"，
// 不要拦截；让浏览器 / 编辑器按自己的语义处理。
const isInEditable = ['INPUT', 'TEXTAREA'].includes(document.activeElement?.tagName);
if (isInEditable) return;
const ctrl = e.ctrlKey || e.metaKey;
if (ctrl && (e.key === 'k' || e.key === 'K')) {
e.preventDefault();
openCommandPaletteHandler();
}
};
document.addEventListener('keydown', onCmdK);
bootstrapUnsubs.push(() => document.removeEventListener('keydown', onCmdK));
// 全局快捷键
bootstrapUnsubs.push(setupGlobalShortcuts());
// 监听系统主题变化（仅在 store.theme === 'auto' 时生效）
const mm = window.matchMedia?.('(prefers-color-scheme: light)');
if (mm && mm.addEventListener) {
const onMm = () => {
if (store.theme === 'auto') {
document.body.dataset.theme = store.resolveTheme();
}
};
mm.addEventListener('change', onMm);
bootstrapUnsubs.push(() => mm.removeEventListener('change', onMm));
}
rendererLog('bootstrap 完成');
} catch (err) {
console.error('[renderer] bootstrap 失败:', err);
toast(`启动失败：${err.message}`, 'error', 5000);
}
}
// ============================================
// 外部修改冲突解决（共用：file:external-change + save-error 中的
// EXTERNAL_CHANGE_DETECTED 两条入口都走这里）
// ============================================
//
// 同步事件开发日志 —— 仅在 dev 模式（window.api.isDev）打印，生产环境静默。
// 生产环境不应被这些 [sync] 日志污染控制台，但 dev 模式用户可以打开 DevTools
// 看完整的事件流，调试"为什么没同步 / 为什么弹了冲突对话框"。
//
// 关键事件：
// - external-change-detected：file:external-change 或 saveNow EXTERNAL_CHANGE_DETECTED 触发
// - conflict-dialog-opened / -resolved：用户在对话框里做出选择
// - autoSave-race-blocked：自动保存被主进程 mtime/size 二次确认拦截
// - reload-from-disk（手动 Cmd/Ctrl+R 或菜单触发）
function syncLog(event, payload) {
if (!window.api?.isDev) return;
if (payload !== undefined) {
console.info(`[sync] ${event}`, payload);
} else {
console.info(`[sync] ${event}`);
}
}
//
// 这条路径有两个触发点：
// 1) 主进程 fs.watch / 0.5 秒 polling 检测到文件被外部修改 → IPC 通知渲染端
// 2) 主进程 file:write 的 mtime 预检发现上次基线和当前文件状态不一致 →
// 自动保存被拒绝，save-error 携带 EXTERNAL_CHANGE_DETECTED
//
// 两条入口合并成一个函数，确保逻辑（取消 autoSave / 读取 / 比对 / 弹对话框）
// 永远一致 —— 任何一处修改都能自动惠及另一处。
//
// 「保留本地」分支调 store.saveNow() 内部 force=true：用户已明确表态要覆盖外部
// 修改，主进程的 mtime 保护不会拦截这次写入。
//
// 「重入守卫」conflictDialogShowing：fs.watch + polling 在外部保存时可能各发一次
// IPC，加上 save-error 触发的话 800ms 内可能连弹两三个对话框。在 await 期间记录
// 状态，后续调用直接 return，避免栈叠对话框。
//
// 防御性：try/catch 包住整个处理流程。理论上 finally 一定会执行，但若 confirmDialog
// 实现里同步抛错、或 _doResolveExternalChangeConflict 自身在 await 之外同步抛错，
// 没有这个 try/catch 会让标志位永久卡住 —— 之后所有外部修改都被吞，用户再也看不到
// 「文件被外部修改」提示。catch 里至少 console.error + 一次性 toast，flag 仍然释放。
let conflictDialogShowing = false;
async function resolveExternalChangeConflict(changedPath, options = {}) {
// 路径比较必须平台感知：详见 pathsEqual 注释。
// Windows 上 store.filePath 是 `D:/...`（joinPath）、changedPath 是 `D:\...`（path.resolve），
// 直接 !== 会让所有外部修改静默被吞。
if (!pathsEqual(changedPath, store.filePath)) return;
if (conflictDialogShowing) return;
conflictDialogShowing = true;
syncLog('external-change-detected', { source: options.source || 'file:external-change' });
try {
return await _doResolveExternalChangeConflict(changedPath, options);
} catch (err) {
// 防御性：万一处理流程内部抛错，标志位仍要在 finally 里释放（下面的 finally
// 保证），同时给用户一个可观察的反馈 —— 不要静默吞掉。
console.error('[renderer] 外部修改冲突处理失败:', err);
toast(`外部修改处理失败：${err.message || err}`, 'error', 4000);
} finally {
conflictDialogShowing = false;
}
}
async function _doResolveExternalChangeConflict(changedPath, options = {}) {
// 第一件事：让 in-flight 的自动保存「作废」。
// 下面有 await，若不先作废，那条 writeFile 会在我们还在问用户的时候
// 把内存内容盖回文件 —— 用户手工删掉的行原地复活，且毫无提示。
// v4 全实时同步后没有 debounce 定时器可掐，只需让 in-flight 的代次过期：
// 它的 await 回来时发现代次对不上、不复位 dirty、不发 saved 假象。
store.cancelPendingSave();
// ── 取磁盘当前内容 ──
// 优先用主进程随 IPC 附带的 diskContent（onFileExternalChange / save-error 都带），
// 避免再发一次 file:read —— 渲染端起步就是冲突流程时，主进程已经把内容塞过来。
let diskContent = typeof options.diskContent === 'string' ? options.diskContent : null;
let diskParseFailed = false;
if (diskContent === null) {
const result = await window.api.readFile(changedPath);
if (!result.ok) {
if (result.error === 'FILE_NOT_FOUND') {
toast(result.message || '文件已被删除', 'error', 4000);
} else {
toast(`读取文件失败：${result.error}`, 'error', 4000);
}
return;
}
diskContent = result.content;
}
// 自写入抑制：磁盘内容与内存 serialize() 字节一致 → 是自己写入的产物（autoSave
// 完成、reload 无变化）→ 静默。这是判断「这次保存是不是我们自己写入的」唯一可靠
// 办法 —— 主进程层无法可靠做（fs.watch 在 Windows 上的 callback 时序不稳）。
if (diskContent === store.serialize()) {
return;
}
// ── 解析磁盘内容 ──
let diskCategories;
try {
diskCategories = parseMarkdown(diskContent);
} catch (e) {
diskParseFailed = true;
}
if (!store.dirty) {
// 本地没有未保存的改动 → 直接 reload（不弹冲突对话框 —— 没东西可冲突）
//
// UX 细节：loadFromContent 会触发整列重渲，用户的滚动位置与焦点任务会丢失
// —— 云同步偶发触发自动 reload 时，视图跳到顶部 + 焦点跳到首条，体验像「被
// 刷新了」。这里在 reload 前抓 scrollTop + 焦点任务的 task.id，render 完后
// requestAnimationFrame 还原（render 是同步 DOM 重建，下一帧取元素已存在）。
//
// 滚动容器 = #task-list（task-list.js line 39 取这个 id，CSS 给它 overflow:auto）。
// 焦点任务按 data-id 找回（task-list.js line 1040 给每条