@yottameta/yotta-memory 0.22.3 → 0.22.5

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## v0.22.5 (2026-10-07)
+
+- **修复 Electron 宿主（YottaCode shim）下开机自启拉起 GUI 而非服务**：宿主运行时为 Electron 时（`process.versions.electron`；`process.execPath` 指向 Electron 可执行文件），此前生成的任务 / 兜底 / 定时配置不带 `ELECTRON_RUN_AS_NODE=1`，开机拉起的是桌面程序本体、8787 无监听（新机首例实测）。现在自动检测并统一注入：Windows 主任务与每日备份任务（cmd /c + `set "ELECTRON_RUN_AS_NODE=1"`）、Windows Startup 兜底 .cmd（set 前缀）、Linux systemd 单元 / crontab @reboot / 备份定时器（`Environment=` / 行内前缀）、macOS 备份 LaunchAgent（EnvironmentVariables）。
+- `lan status` 新增告警：任务或 Startup 兜底命令指向 Electron 可执行文件且缺少 `ELECTRON_RUN_AS_NODE` 时，提示重新 `lan enable` 修复。
+- 非 Electron 宿主行为不变（纯 Node 下生成的命令与旧版一致）。
+- `test/lan-windows-autostart.test.js` 新增 8 项（Electron / 非 Electron 双态：任务 XML / 兜底 cmd / 备份任务 / Linux 单元与 crontab / macOS plist / status 告警两例）；全量 `npm test` 352/352。
+
+## v0.22.4 (2026-10-07)
+
+- **修复 Windows `lan enable` 开机自启三缺陷（实测复现）**：此前计划任务用 schtasks 默认交互式主体——① 在登录会话运行会弹控制台窗口；② `--onstart` 开机触发时无登录会话，任务起不来且不补跑（实测 LastTaskResult 267011）；③ schtasks 默认带电池限制与 72 小时执行时限。本版改为 **S4U 主体 + 任务 XML 注册**（零依赖）：后台静默运行不弹窗口，开机 / 登录触发均可用；默认去掉电池限制与 72h 时限（`ExecutionTimeLimit=PT0S` 不限时）；`--onstart` 在 Windows 真正生效（BootTrigger）。任务注册成功时自动清理旧 Startup 兜底文件，避免双份自启。
+- `lan status` 增加显示「登录模式」并对旧交互式任务给出重新 `lan enable` 的修复提示；非管理员执行 `lan disable` 无法移除管理员注册的任务时，明确提示改用管理员终端。
+- 非管理员路径行为不变：schtasks 失败（含 Access denied）自动降级用户级 Startup 静默自启（VBS 自愈保留）。
+- 新增 `test/lan-windows-autostart.test.js`（11 项：任务 XML 结构 / S4U / 无电池与时限 / XML 转义 / XML 注册 / 旧兜底清理 / 权限与非权限失败降级 / status 登录模式与旧任务告警 / disable 双通道）。
+
 ## v0.22.3 (2026-10-05)
 
 - **安装器 junction 守卫**：`bin/install.js` 对目标基目录 / 技能目录为符号链接（含 Windows junction）时 fail-closed 拒绝（退出码 4，与 `install.sh` 同口径）——不再写穿 Hub 链接指向的真源，也不再误删 Hub 侧 `bin/` runtimePayload。统一安装器以分技能灰度补丁落地（模板与其余技能输出不变）。

package/README.md

@@ -306,7 +306,7 @@ Optional post-upgrade self-check: `yotta-memory config get` (confirm `memory_hom
 | `yotta-memory iam <id> [--name <name>] [--user <user>] [--relationship <rel>] [--force]` | Register this agent's unique identity and auto-write the self profile (`agents.json`, ID must be unique) |
 | `yotta-memory token new --agent <id> [--force]` / `token list` / `token revoke --agent <id>` | Create / list / revoke access tokens for agents (registered at `.server/tokens.json`) |
 | `yotta-memory serve [--host 0.0.0.0] [--port 8787] [--no-auth] [--stdio]` | Start the MCP memory engine (streamable HTTP LAN / --stdio local zero-process mode; Bearer token + X-Agent-Id + X-Agent-Key auth) |
-| `yotta-memory lan enable [--onstart] / disable / status` | Autostart management (Windows: scheduled task, default ONLOGON, --onstart needs admin, non-admin auto-degrades to user-level Startup; Linux: systemd user unit, falls back to user crontab @reboot) |
+| `yotta-memory lan enable [--onstart] / disable / status` | Autostart management (Windows: scheduled task with an S4U principal — runs silently in the background with no console window; `--onstart` starts at boot without a logon session, registration needs admin; non-admin auto-degrades to user-level silent Startup; Linux: systemd user unit, falls back to user crontab @reboot) |
 | `yotta-memory maintain [--dry-run] [--apply] [--purge] [--threshold N] [--age N] [--dedup] [--dedup --apply] [--merge A,B]` | Self-organization: archive / forget candidates / confidence-scored dedup / auto-merge high-confidence groups; dry-run by default; `--dedup` is mutually exclusive with archiving |
 | `yotta-memory consolidate [--min-age N] [--min-idle N] [--max-utility N] [--min-group N] [--period N] [--type T] [--model <cmd>] [--apply] [--undo <batch>] [--batches]` | Periodic-summary compression (v0.10.0): group old idle low-value memories into one traceable summary and archive the originals; dry-run by default; `--undo <batch>` rolls a batch back; `--batches` lists batches |
 | `yotta-memory feedback <file> --useful|--useless [--reason <r>] [--undo]` | Usage feedback (useful/useless adjusts weight / confidence / feedback_net; --undo rolls back the last one) |
@@ -384,7 +384,7 @@ The store can live on any host or disk (= the memory engine) and be reached by a
    yotta-memory lan enable                     # register autostart (Windows: scheduled task / user-level Startup; Linux: systemd user unit / user crontab)
    yotta-memory lan status                     # autostart status
    ```
-   > `lan enable --onstart` switches to start-at-boot (needs admin); non-admin `lan enable` auto-degrades to user-level silent Startup; `lan disable` removes it.
+   > `lan enable` registers a silent S4U scheduled task (no console window); `--onstart` switches to start-at-boot without a logon session (registration needs admin); non-admin `lan enable` auto-degrades to user-level silent Startup; `lan disable` removes it.
 
 > On first listen on 0.0.0.0, Windows / the system firewall may ask to allow it — allow it, or other LAN hosts cannot reach it; `--no-auth` disables auth for trusted intranets only.
 

package/README.zh-CN.md

@@ -174,7 +174,7 @@
 
 - **记忆库即引擎**：`serve` 把记忆目录挂成 MCP 服务，目录随盘走；引擎主机只需装 CLI 当存放点，无需装任何 AI 智能体。
 - **双模式可并存**：本地 `serve --stdio` 零进程（客户端按需拉起）；局域网 streamable HTTP（默认 `0.0.0.0:8787`）+ 每智能体 token 鉴权。
-- **开机自启**：`lan enable` 注册开机自启——Windows 优先计划任务（默认登录自启，`--onstart` 开机即启需管理员），非管理员自动降级为**用户级 Startup 静默自启**（免管理员，启动脚本内联启动命令、被清理也会在开机时自动重建，v0.6.3 起不再弹 80070002）；Linux 优先 **systemd 用户单元**（`systemctl --user`，登录自启；`--onstart` 附加 `loginctl enable-linger` 开机即启），systemd 不可用时自动降级**用户 crontab @reboot**（v0.6.4）；`lan disable` 移除，`lan status` 查询。
+- **开机自启**：`lan enable` 注册开机自启——Windows 优先计划任务（v0.22.4 起 S4U 主体后台静默、不弹窗口；默认登录自启，`--onstart` 开机即启、无登录会话也可启动，计划任务注册需管理员），非管理员自动降级为**用户级 Startup 静默自启**（免管理员，启动脚本内联启动命令、被清理也会在开机时自动重建，v0.6.3 起不再弹 80070002）；**v0.22.5 起 Electron 宿主（如 YottaCode）自动注入 ELECTRON_RUN_AS_NODE，任务不再拉起 GUI**；Linux 优先 **systemd 用户单元**（`systemctl --user`，登录自启；`--onstart` 附加 `loginctl enable-linger` 开机即启），systemd 不可用时自动降级**用户 crontab @reboot**（v0.6.4）；`lan disable` 移除，`lan status` 查询。
 - **安全边界**：管理动作（init / config / token / lan / serve）不进 MCP，token 不远程暴露；远程智能体只能读写记忆，且路径限记忆库内（export/import 的 out/src 必须落在库内）、distill 不支持 `--model`（仅本地 CLI），不能改配置、不能管 token。
 - 完整操作步骤见上文「局域网多机共享」章节与 [USER_GUIDE.md](USER_GUIDE.md)。
 
@@ -350,7 +350,7 @@ bash install.sh --agent <智能体名称>
 | `yotta-memory iam <id> [--name <显示名>] [--user <用户名>] [--relationship <关系>] [--force]` | 登记本智能体唯一身份并自动落自我档案（`agents.json`，ID 必须唯一；可选扩展显示名 / 用户 / 关系）|
 | `yotta-memory token new --agent <id> [--force]` / `token list` / `token revoke --agent <id>` | 为智能体生成 / 列出 / 吊销访问 token（登记于记忆库 `.server/tokens.json`；同 ID 已被其它来源占用需 `--force` 覆盖，防不同智能体合流）|
 | `yotta-memory serve [--host 0.0.0.0] [--port 8787] [--no-auth] [--stdio]` | 启动 MCP 记忆引擎（streamable HTTP 局域网 / --stdio 本地零进程模式；Bearer token + X-Agent-Id + X-Agent-Key 鉴权）|
-| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务，默认 ONLOGON、--onstart 开机即启需管理员，非管理员自动降级用户级 Startup 静默自启；Linux：systemd 用户单元，不可用时自动降级用户 crontab @reboot）|
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务 S4U 主体后台静默、不弹窗口；默认登录自启、`--onstart` 开机即启（无登录会话也可启动，注册需管理员），非管理员自动降级用户级 Startup 静默自启；Linux：systemd 用户单元，不可用时自动降级用户 crontab @reboot）|
 | `yotta-memory maintain [--dry-run] [--apply] [--purge] [--threshold N] [--age N] [--dedup] [--dedup --apply] [--merge A,B]` / `maintain --capacity [--json]` | 记忆自组织：归档 / 遗忘候选 / 置信度查重 / 自动合并高置信组；默认 dry-run；`--dedup` 与归档互斥。`--capacity` 只读报告容量水位、LRU / LFU 淘汰候选与晋升建议（冷却期与常青条目豁免）|
 | `yotta-memory consolidate [--propose] [--min-age N] [--min-idle N] [--max-utility N] [--min-group N] [--period N] [--type T] [--model <cmd>] [--apply [--yes]] [--undo <batch>] [--batches]` | 周期摘要压缩：同主题旧记忆 → 带溯源摘要 + 原文归档；默认等价 `--propose`（结构化报告，不写盘）；`--apply` 需确认（非交互必须 `--yes`）；`--undo <batch>` 回滚批次；`--batches` 查批次 |
 | `yotta-memory feedback <文件|主题> --useful|--useless [--reason <原因>] [--undo]` | 使用反馈（useful/useless 调整 weight / confidence / feedback_net；`--undo` 回滚最近一次）|
@@ -428,7 +428,7 @@ yotta-memory recall --type FACT --limit 10
    yotta-memory lan enable                     # 注册开机自启（Windows：计划任务/用户级 Startup；Linux：systemd 用户单元/用户 crontab）
    yotta-memory lan status                     # 查看自启状态
    ```
-   > `lan enable --onstart` 改为开机即启（需管理员）；非管理员时 `lan enable` 自动改用用户级 Startup 静默自启（无需管理员）；`lan disable` 移除自启。
+   > `lan enable` 注册 S4U 后台静默计划任务（不弹窗口）；`--onstart` 改为开机即启、无登录会话也可启动（注册需管理员）；非管理员时 `lan enable` 自动改用用户级 Startup 静默自启（无需管理员）；`lan disable` 移除自启。
 
 > 首次监听 0.0.0.0 时，Windows / 系统防火墙可能询问是否放行，需允许放行，否则局域网内其它主机无法访问；`--no-auth` 会关闭鉴权，仅限可信内网使用。
 

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: yotta-memory
 description: 元忆 —— 有权限边界的文件式智能体记忆。文件式、零依赖、可 diff/可回滚：让任何 AI 智能体活过会话，开工 recall 恢复上下文、重要信息 remember 落盘、收工归档。类型体系 FACT（公共共享）/ PREF / BOUND / COMMIT（私密隔离）。触发：记住、别忘了、记一笔、记忆、remember、recall、跨会话、上次说到、续测、交接、归档、记忆盘、共享记忆、局域网记忆、画像、开工上下文、长期理解摘要、近期走廊、会话闭环、记忆守则、profile、context、越用越懂、语义检索、反馈、维护、蒸馏、feedback、maintain、distill、explain、自我学习、自我进化、自我提升、查看平台分页、recall 候选预过滤、任务相关记忆、--focus、--embedding、压缩遗忘、consolidate、周期摘要、自动合并、分类型衰减、回滚、备份、backup、防误删、doctor、事务快照、基线探针、恢复演练、记忆库安全扫描、scan、命中打点、容量水位、--capacity、--propose、上下文压缩审计、context --audit
-version: 0.22.3
+version: 0.22.5
 license: MIT
 ---
 
@@ -333,7 +333,7 @@ yotta-memory doctor --json
 | `yotta-memory token new --agent <id> [--force]` / `token list` / `token revoke --agent <id>` | 每智能体访问 token：生成 / 列出 / 吊销（登记 `<记忆库>/.server/tokens.json`；同 ID 已被其它来源占用需 `--force` 覆盖，防不同智能体合流）|
 | `yotta-memory serve [--host 0.0.0.0] [--port 8787] [--no-auth] [--stdio] [--tools core|full]` | 启动 MCP 记忆引擎（streamable HTTP 局域网 / --stdio 本地零进程模式；Bearer token + X-Agent-Id + X-Agent-Key 鉴权；工具分组默认 full）|
 | `yotta-memory runtime list / install <tarball|版本> [--from-current] [--force] / use <版本> [--restart] / rollback [--restart] / status` | 运行时稳定入口（runtime.json + versions + current；安装 / 切换 / 回滚 / 查看漂移；`--restart` 尝试重启受管 server，失败自动切回旧版本）；漂移诊断用 `doctor --runtime` |
-| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务，默认 ONLOGON、--onstart 开机即启需管理员，非管理员自动降级用户级 Startup 静默自启，v0.6.3 起 VBS 自愈不弹 80070002；Linux：systemd 用户单元，不可用时自动降级用户 crontab @reboot）|
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：任务计划程序，S4U 主体后台静默——v0.22.4 起不弹窗口，`--onstart` 无登录会话也可启动；任务 XML 注册，去电池限制与 72h 时限；非管理员自动降级用户级 Startup 静默自启，v0.6.3 起 VBS 自愈不弹 80070002；v0.22.5 起 Electron 宿主（如 YottaCode）自动注入 ELECTRON_RUN_AS_NODE，不再拉起 GUI；Linux：systemd 用户单元，不可用时自动降级用户 crontab @reboot）|
 | `yotta-memory feedback <文件|主题> --useful|--useless [--reason <原因>] [--undo]` | 显式使用反馈（v0.8.0 自我学习闭环：useful → weight×1.2 / useless → weight×0.8，confidence / feedback_net 同步演化；`--undo` 回滚最近一次；审计写 `.archive/feedback-<日期>.jsonl`）|
 | `yotta-memory maintain [--dry-run] [--apply] [--purge] [--threshold N] [--age N] [--dedup] [--dedup --apply] [--merge A,B] [--rules]` | 记忆自组织（v0.8.0 自我进化 + v0.10.0 自动合并）：默认 dry-run 预览；`--apply` 执行归档（immutable / BOUND 豁免；私密归档入 `.archive/private/<owner>/<type>/`），`--purge` 才真删遗忘候选；`--dedup` 查重并给**置信度分档**（≥0.85 高置信 / 0.65–0.85 建议手动 / 其余忽略），`--dedup --apply` 自动合并同归属高置信组（写批次审计可回滚；与归档互斥，不误归档）；`--merge A,B` 手动合并两条；`--rules` 只读输出重复踩坑 → 建议升级为规则的清单（阈值 `maintain_rule_min_hits`，默认 3；只给建议不写 BOUND）；审计写 `.archive/audit-<日期>.jsonl`）|
 | `yotta-memory consolidate [--min-age N] [--min-idle N] [--max-utility N] [--min-group N] [--period N] [--type T] [--model <cmd>] [--apply] [--undo <batch>] [--batches]` | 周期摘要压缩（v0.10.0 压缩遗忘 + v0.18.0 提案闸门 + v0.18.1 日期 / 标记：把超龄 + 长期闲置 + 低效用的同主题旧记忆归纳成**带溯源**的周期摘要并留在活跃区，原文整体进 `.archive/`；摘要正文按条目 `created` 把「昨天 / 上周 / 本月 / 今年」等绝对化，归档副本追加一行巩固标记；默认 dry-run；immutable / BOUND 豁免，活跃 / 高效用记忆不动；`--apply` 执行并写批次审计，`--undo <batch>` 剥离标记并回滚（幂等），`--batches` 查近期批次；`--model` 仅本地 CLI）|
@@ -555,7 +555,7 @@ MCP 模式由宿主显式声明身份：stdio 用 `--agent-id <agent_id> --agent
 > 记忆盘场景：硬盘插上 → AI 检查盘上目录是否有数据 → 有则接入 + config 记住 → 插盘即恢复，机器记住位置。
 
 **步骤 0.5 启动记忆引擎（仅引擎主机，供远程接入）**
-- 本机若作引擎：🔒 **征得同意后**启动服务——临时运行 `yotta-memory serve`（默认 `0.0.0.0:8787`，Bearer token + X-Agent-Id + X-Agent-Key 鉴权；`--no-auth` 仅限可信内网），或注册开机自启 `yotta-memory lan enable`（Windows：优先计划任务，默认登录自启；非管理员自动降级用户级 Startup 静默自启，免管理员）。
+- 本机若作引擎：🔒 **征得同意后**启动服务——临时运行 `yotta-memory serve`（默认 `0.0.0.0:8787`，Bearer token + X-Agent-Id + X-Agent-Key 鉴权；`--no-auth` 仅限可信内网），或注册开机自启 `yotta-memory lan enable`（Windows：任务计划程序 S4U 后台静默，默认登录自启、`--onstart` 开机即启；非管理员自动降级用户级 Startup 静默自启，免管理员）。
 - 本地零进程模式：本机 AI 也可用 `serve --stdio` 由 MCP 客户端按需拉起 CLI（无常驻进程）。
 - 远程客户端接入前，先确认引擎主机 serve 已运行（`lan status` 可查）。
 

package/USER_GUIDE.md

@@ -334,10 +334,11 @@ yotta-memory init --dir /srv/yotta-memory               # 新库：初始化（
 `lan enable` 会先准备稳定运行时入口：没有 `<runtimeRoot>/current` 时自动执行 `runtime install --from-current`，然后把计划任务 / systemd / crontab 指向 `<runtimeRoot>/current/bin/yotta-memory.js`。如需手动准备，可先执行 `yotta-memory runtime install --from-current && yotta-memory runtime status`。
 
 ```bash
-# Windows：内置命令（优先计划任务；非管理员自动降级用户级 Startup 静默自启；
-# v0.6.3 起启动脚本自愈——启动文件被清理也会在开机时自动重建，无需手动处理）
+# Windows：内置命令（优先计划任务——v0.22.4 起 S4U 主体后台静默、不弹窗口；
+# 非管理员自动降级用户级 Startup 静默自启；v0.6.3 起启动脚本自愈——启动文件被清理也会在开机时自动重建；
+# v0.22.5 起 Electron 宿主（如 YottaCode）自动注入 ELECTRON_RUN_AS_NODE，不再拉起 GUI）
 yotta-memory lan enable              # 登录后自动启动（默认）
-yotta-memory lan enable --onstart    # 开机即启（需管理员）
+yotta-memory lan enable --onstart    # 开机即启、无登录会话也可启动（计划任务注册需管理员）
 yotta-memory lan status              # 查看状态
 yotta-memory lan disable             # 取消
 

package/bin/yotta-memory.js

@@ -25,7 +25,7 @@ const net = require('net');
 const child_process = require('child_process');
 const { AsyncLocalStorage } = require('async_hooks');
 
-const VERSION = '0.22.3';
+const VERSION = '0.22.5';
 const CLI_VALUE_OPTS = new Set(['--type', '--limit', '--days', '--out', '--owner', '--agent', '--agent-id', '--agent-key', '--agent-key-file', '--plugin-data', '--threshold', '--scope', '--host', '--port', '--dir', '--name', '--user', '--relationship', '--source', '--weight', '--budget', '--password', '--new-password', '--recovery-key', '--recovery-key-out', '--reason', '--merge', '--model', '--subject', '--embedding', '--focus', '--embedding-timeout', '--min-age', '--min-idle', '--max-utility', '--min-group', '--period', '--to', '--id', '--time', '--tools', '--mcp-config', '--skill-dir', '--year', '--evalset', '--k', '--seed', '--bootstrap', '--gate', '--against', '--template', '--path', '--from']);
 const CLI_FLAG_OPTS = new Set(['--project', '--all', '--unsafe', '--no-auth', '--stdio', '--onstart', '--from-current', '--restart', '--force', '--attach', '--allow-same-volume', '--verify', '--no-hint', '--encrypt', '--no-encrypt', '--password-stdin', '--json', '--manual', '--skip-schedule', '--useful', '--useless', '--undo', '--dry-run', '--apply', '--purge', '--dedup', '--batches', '--propose', '--audit', '--capacity', '--rules', '--explain', '--semantic', '--runtime', '--ablate', '--timing', '--baseline', '--probe', '--quarantine', '--restore', '--no-usage', '--yes', '--keep-memories', '--keep-identity']);
 
@@ -298,7 +298,7 @@ const HELP_MODEL = [
       helpOption('--agent-key-file', '<文件>', 'stdio 模式下从文件读取 agent_key', '宿主使用标准 key 文件时', ''),
     ] },
     { name: 'lan', usage: 'lan <子命令> [选项]', what: '管理开机自启', when: '需要元忆服务随系统或登录启动时', subcommands: [
-      helpSub('enable', 'enable [--onstart]', '启用开机自启', '希望元忆服务长期可用时', [helpOption('--onstart', '', '同时启用未登录也启动', 'Linux 上希望开机即启动、不依赖登录时', 'Windows 上此选项不改变计划任务语义')]),
+      helpSub('enable', 'enable [--onstart]', '启用开机自启', '希望元忆服务长期可用时', [helpOption('--onstart', '', '同时启用未登录也启动', 'Windows / Linux 上希望开机即启动、不依赖登录时', '')]),
       helpSub('disable', 'disable', '关闭开机自启', '不再需要常驻服务时', []),
       helpSub('status', 'status', '查看自启状态', '确认服务是否会随系统启动时', []),
     ] },
@@ -2919,6 +2919,12 @@ function backupWindowsTaskXml(opts) {
   const principal = userId
     ? '<Principal id="Author"><UserId>' + xmlEscape(userId) + '</UserId><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal>'
     : '<Principal id="Author"><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal>';
+  const cmdPath = opts.cmdPath || process.env.ComSpec || 'cmd.exe';
+  // v0.22.5: Electron 宿主（如 YottaCode shim）下 process.execPath 是 Electron 可执行文件，
+  // 任务需经 cmd /c + ELECTRON_RUN_AS_NODE=1 包装，否则拉起的是桌面程序本体而非 Node。
+  const action = lanElectronHost(opts)
+    ? '<Actions Context="Author"><Exec><Command>' + xmlEscape(cmdPath) + '</Command><Arguments>/c "set "ELECTRON_RUN_AS_NODE=1" &amp;&amp; "' + xmlEscape(nodePath) + '" "' + xmlEscape(scriptPath) + '" backup ensure-daily"</Arguments></Exec></Actions>'
+    : '<Actions Context="Author"><Exec><Command>' + xmlEscape(nodePath) + '</Command><Arguments>"' + xmlEscape(scriptPath) + '" backup ensure-daily</Arguments></Exec></Actions>';
   return [
     '<?xml version="1.0" encoding="UTF-16"?>',
     '<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">',
@@ -2940,7 +2946,7 @@ function backupWindowsTaskXml(opts) {
     '<ExecutionTimeLimit>PT2H</ExecutionTimeLimit>',
     '<Priority>7</Priority>',
     '</Settings>',
-    '<Actions Context="Author"><Exec><Command>' + xmlEscape(nodePath) + '</Command><Arguments>"' + xmlEscape(scriptPath) + '" backup ensure-daily</Arguments></Exec></Actions>',
+    action,
     '</Task>',
   ].join('\r\n');
 }
@@ -2948,16 +2954,20 @@ function backupSystemdServiceContent(opts) {
   opts = opts || {};
   const nodePath = opts.nodePath || process.execPath;
   const scriptPath = opts.scriptPath || runtimeManagedScript();
-  return [
+  const lines = [
     '[Unit]',
     'Description=Yotta Memory daily backup',
     '',
     '[Service]',
     'Type=oneshot',
+  ];
+  if (lanElectronHost(opts)) lines.push('Environment=ELECTRON_RUN_AS_NODE=1');
+  lines.push(
     'ExecStart=' + systemdEscapeArg(nodePath) + ' ' + systemdEscapeArg(scriptPath) + ' backup ensure-daily',
     'Nice=10',
     '',
-  ].join('\n');
+  );
+  return lines.join('\n');
 }
 function backupSystemdTimerContent(opts) {
   opts = opts || {};
@@ -2983,7 +2993,8 @@ function backupCronLine(opts) {
   const scriptPath = opts.scriptPath || runtimeManagedScript();
   const logPath = opts.logPath || '';
   const redirect = logPath ? ' >> ' + shQuote(logPath) + ' 2>&1' : '';
-  return time.minute + ' ' + time.hour + ' * * * ' + shQuote(nodePath) + ' ' + shQuote(scriptPath) + ' backup ensure-daily' + redirect + ' ' + BACKUP_CRON_MARKER;
+  const env = lanElectronHost(opts) ? 'ELECTRON_RUN_AS_NODE=1 ' : '';
+  return time.minute + ' ' + time.hour + ' * * * ' + env + shQuote(nodePath) + ' ' + shQuote(scriptPath) + ' backup ensure-daily' + redirect + ' ' + BACKUP_CRON_MARKER;
 }
 function backupLaunchdPlist(opts) {
   opts = opts || {};
@@ -2995,6 +3006,11 @@ function backupLaunchdPlist(opts) {
     '<?xml version="1.0" encoding="UTF-8"?>',
     '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
     '<plist version="1.0"><dict>',
+  ];
+  if (lanElectronHost(opts)) {
+    lines.push('<key>EnvironmentVariables</key><dict><key>ELECTRON_RUN_AS_NODE</key><string>1</string></dict>');
+  }
+  lines.push(
     '<key>Label</key><string>' + BACKUP_LAUNCHD_LABEL + '</string>',
     '<key>ProgramArguments</key><array>',
     '<string>' + xmlEscape(nodePath) + '</string>',
@@ -3006,7 +3022,7 @@ function backupLaunchdPlist(opts) {
     '<key>Hour</key><integer>' + time.hour + '</integer>',
     '<key>Minute</key><integer>' + time.minute + '</integer>',
     '</dict>',
-  ];
+  );
   if (logPath) {
     lines.push('<key>StandardOutPath</key><string>' + xmlEscape(logPath) + '</string>');
     lines.push('<key>StandardErrorPath</key><string>' + xmlEscape(logPath) + '</string>');
@@ -3046,7 +3062,7 @@ function backupScheduleEnableCore(opts) {
       const userId = opts.userId || (process.env.USERDOMAIN && process.env.USERNAME ? process.env.USERDOMAIN + '\\' + process.env.USERNAME : '');
       const taskName = opts.taskName || BACKUP_TASK_NAME;
       const xmlPath = opts.xmlPath || path.join(os.tmpdir(), taskName + '.xml');
-      fs.writeFileSync(xmlPath, '\ufeff' + backupWindowsTaskXml({ time: time, nodePath: nodePath, scriptPath: scriptPath, userId: userId }), 'utf16le');
+      fs.writeFileSync(xmlPath, '\ufeff' + backupWindowsTaskXml({ time: time, nodePath: nodePath, scriptPath: scriptPath, userId: userId, electronHost: opts.electronHost }), 'utf16le');
       schedulerExec(opts, 'schtasks', ['/create', '/tn', taskName, '/xml', xmlPath, '/f']);
       return { error: false, scheduler: 'windows-task', taskName: taskName, text: '已注册 Windows 每日备份任务: ' + taskName };
     }
@@ -3055,7 +3071,7 @@ function backupScheduleEnableCore(opts) {
       const servicePath = path.join(unitDir, BACKUP_SYSTEMD_SERVICE);
       const timerPath = path.join(unitDir, BACKUP_SYSTEMD_TIMER);
       fs.mkdirSync(unitDir, { recursive: true });
-      fs.writeFileSync(servicePath, backupSystemdServiceContent({ nodePath: nodePath, scriptPath: scriptPath }), 'utf8');
+      fs.writeFileSync(servicePath, backupSystemdServiceContent({ nodePath: nodePath, scriptPath: scriptPath, electronHost: opts.electronHost }), 'utf8');
       fs.writeFileSync(timerPath, backupSystemdTimerContent({ time: time }), 'utf8');
       const reload = schedulerTry(opts, 'systemctl', ['--user', 'daemon-reload']);
       const enable = reload.ok ? schedulerTry(opts, 'systemctl', ['--user', 'enable', '--now', BACKUP_SYSTEMD_TIMER]) : reload;
@@ -3063,7 +3079,7 @@ function backupScheduleEnableCore(opts) {
         return { error: false, scheduler: 'linux-systemd', unit: BACKUP_SYSTEMD_TIMER, text: '已注册 systemd 用户定时器: ' + BACKUP_SYSTEMD_TIMER };
       }
       const logPath = opts.logPath || path.join(os.homedir(), '.yottamemory', 'backup.log');
-      const line = backupCronLine({ time: time, nodePath: nodePath, scriptPath: scriptPath, logPath: logPath });
+      const line = backupCronLine({ time: time, nodePath: nodePath, scriptPath: scriptPath, logPath: logPath, electronHost: opts.electronHost });
       const current = schedulerTry(opts, 'crontab', ['-l']);
       const kept = current.stdout.split(/\r?\n/).filter(function (item) {
         return item && item.indexOf(BACKUP_CRON_MARKER) === -1;
@@ -3087,6 +3103,7 @@ function backupScheduleEnableCore(opts) {
         nodePath: nodePath,
         scriptPath: scriptPath,
         logPath: opts.logPath || path.join(os.homedir(), 'Library', 'Logs', 'yotta-memory-backup.log'),
+        electronHost: opts.electronHost,
       }), 'utf8');
       const uid = typeof process.getuid === 'function' ? process.getuid() : '';
       const bootstrap = schedulerTry(opts, 'launchctl', ['bootstrap', 'gui/' + uid, plistPath]);
@@ -10381,7 +10398,9 @@ function cmdServeStdio(opts) {
 }
 
 // ---- lan command (autostart management for serve) ----
-// Windows dual mechanism: (1) schtasks scheduled task (default, needs permission); (2) non-admin
+// Windows dual mechanism: (1) schtasks scheduled task registered from task XML (default, needs
+// permission; v0.22.4: S4U principal -> silent in background for both logon/boot triggers, no
+// console window; battery limits and the 72h execution time limit removed); (2) non-admin
 // (Access denied) auto-fallback to user-level Startup silent autostart (VBS sh.Run <autostart.cmd>,
 // 0, False + autostart.cmd; node path process.execPath auto-detected, 0.5.4)
 // Linux (v0.6.4): (1) systemd user unit (systemctl --user enable/start, login autostart; --onstart
@@ -10392,11 +10411,13 @@ const LAN_GEN_MARKER = 'Generated by yotta-memory lan enable';
 const LAN_UNIT_NAME = 'yotta-memory-serve.service';
 const LAN_CRONTAB_MARKER = '#YTM_LAN:yotta-memory-serve';
 function lanTaskRunCmd(opts) {
+  opts = opts || {};
   const host = opts.host || '0.0.0.0';
   const port = opts.port || 8787;
   // schtasks /tr 不接受多余内嵌引号：路径无空格不加引号，含空格/引号用 \" 转义（0.5.2 修复）
   const q = (p) => /[\s"]/.test(p) ? '\\"' + p.replace(/"/g, '\\"') + '\\"' : p;
-  return q(process.execPath) + ' ' + q(runtimeManagedScript()) + ' serve --host ' + host + ' --port ' + port;
+  const prefix = lanElectronHost(opts) ? 'set "ELECTRON_RUN_AS_NODE=1" && ' : '';
+  return prefix + q(process.execPath) + ' ' + q(runtimeManagedScript()) + ' serve --host ' + host + ' --port ' + port;
 }
 
 function lanServeArgs(opts) {
@@ -10412,6 +10433,28 @@ function lanSpawn(bin, args, spawnOpts) {
 }
 // platform override for testing/advanced use (YOTTA_LAN_PLATFORM=linux/win32/...)
 function lanPlatform() { return process.env.YOTTA_LAN_PLATFORM || process.platform; }
+// ---- v0.22.5: Electron 宿主（YottaCode shim）适配 ----
+// 背景：宿主运行时为 Electron 时（如 YottaCode.exe 以 ELECTRON_RUN_AS_NODE=1 当 Node 运行本脚本），
+// process.execPath 指向 Electron 可执行文件；自启 / 定时任务环境不带 ELECTRON_RUN_AS_NODE=1 时，
+// 拉起的是桌面程序本体而非 Node 服务（0.22.4 后新机首例实测）。生成任务 / 兜底 / 定时配置时统一注入。
+function lanElectronHost(opts) {
+  opts = opts || {};
+  if (typeof opts.electronHost === 'boolean') return opts.electronHost;
+  if (process.env.YOTTA_LAN_ELECTRON_HOST === '1') return true;
+  if (process.env.YOTTA_LAN_ELECTRON_HOST === '0') return false;
+  return !!(process.versions && process.versions.electron);
+}
+// 任务 / 兜底命令是否指向 Electron 可执行文件且缺少 ELECTRON_RUN_AS_NODE（旧任务告警用）
+function lanTaskCommandNeedsElectronEnv(text) {
+  const t = String(text || '');
+  if (!t || /ELECTRON_RUN_AS_NODE/.test(t)) return false;
+  if (/electron|yottacode/i.test(t)) return true;
+  if (lanElectronHost({})) {
+    const exe = String(process.execPath || '');
+    if (exe && t.toLowerCase().indexOf(exe.toLowerCase()) !== -1) return true;
+  }
+  return false;
+}
 // sh-style single-quote quoting (crontab line is executed via /bin/sh -c)
 function shQuote(s) {
   const p = String(s);
@@ -10425,31 +10468,37 @@ function systemdEscapeArg(s) {
   if (!/[\s"\\$;]/.test(p)) return p;
   return '"' + p.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
 }
-function lanStartupDir() {
+function lanStartupDir(opts) {
+  if (opts && opts.startupDir) return String(opts.startupDir);
   // 测试/高级用途可用 YOTTA_LAN_STARTUP_DIR 覆盖（默认用户级 Startup 目录，免管理员）
   if (process.env.YOTTA_LAN_STARTUP_DIR) return process.env.YOTTA_LAN_STARTUP_DIR;
   const base = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
   return path.join(base, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
 }
-function lanAutostartDir() {
+function lanAutostartDir(opts) {
+  if (opts && opts.autostartDir) return String(opts.autostartDir);
   // 产品自有目录 ~/.yottamemory/autostart/（引擎数据目录内，非系统配置）；测试可用 YOTTA_LAN_AUTOSTART_DIR 覆盖
   if (process.env.YOTTA_LAN_AUTOSTART_DIR) return process.env.YOTTA_LAN_AUTOSTART_DIR;
   return path.join(os.homedir(), '.yottamemory', 'autostart');
 }
-function lanVbsPath() { return path.join(lanStartupDir(), 'yotta-memory-serve.vbs'); }
-function lanAutostartCmdPath() { return path.join(lanAutostartDir(), 'yotta-memory-autostart.cmd'); }
+function lanVbsPath(opts) { return path.join(lanStartupDir(opts), 'yotta-memory-serve.vbs'); }
+function lanAutostartCmdPath(opts) { return path.join(lanAutostartDir(opts), 'yotta-memory-autostart.cmd'); }
 function lanLogPath(opts) {
+  if (opts && opts.logPath) return String(opts.logPath);
   if (process.env.YOTTA_LAN_LOG_FILE) return process.env.YOTTA_LAN_LOG_FILE;
   return path.join(os.homedir(), '.yottamemory', 'serve-' + (opts.port || 8787) + '.log');
 }
 function lanAutostartCmdContent(opts) {
+  opts = opts || {};
   const host = opts.host || '0.0.0.0';
   const port = opts.port || 8787;
   const q = (p) => '"' + String(p).replace(/"/g, '""') + '"';
   // 生成文件用纯 ASCII（避免 cmd/VBS 按系统代码页读取中文注释乱码；VBS 自愈内联同一内容）
+  // v0.22.5: Electron 宿主下需先设 ELECTRON_RUN_AS_NODE=1，否则拉起桌面程序本体而非 Node。
   return '@echo off\r\n'
     + 'chcp 65001 >nul\r\n'
     + 'rem ' + LAN_GEN_MARKER + '; remove with: yotta-memory lan disable (English only, keep ASCII)\r\n'
+    + (lanElectronHost(opts) ? 'set "ELECTRON_RUN_AS_NODE=1"\r\n' : '')
     + q(process.execPath) + ' ' + q(runtimeManagedScript()) + ' serve --host ' + host + ' --port ' + port + ' >> ' + q(lanLogPath(opts)) + ' 2>&1\r\n';
 }
 function lanVbsContent(opts) {
@@ -10467,7 +10516,7 @@ function lanVbsContent(opts) {
       return '"' + seg.replace(/"/g, '""') + '"';
     })
     .join(' & Chr(13) & Chr(10) & ');
-  const vbsCmdPath = String(lanAutostartCmdPath()).replace(/"/g, '""');
+  const vbsCmdPath = String(lanAutostartCmdPath(opts)).replace(/"/g, '""');
   const lines = [
     "' " + LAN_GEN_MARKER + '; remove with: yotta-memory lan disable',
     "' v0.6.3 self-heal: always rebuild autostart.cmd from embedded content, then run it (fix 80070002)",
@@ -10486,16 +10535,16 @@ function lanVbsContent(opts) {
   return lines.join('\r\n') + '\r\n';
 }
 function lanInstallStartup(opts) {
-  fs.mkdirSync(lanAutostartDir(), { recursive: true });
-  fs.writeFileSync(lanAutostartCmdPath(), lanAutostartCmdContent(opts), 'utf8');
-  fs.mkdirSync(lanStartupDir(), { recursive: true });
+  fs.mkdirSync(lanAutostartDir(opts), { recursive: true });
+  fs.writeFileSync(lanAutostartCmdPath(opts), lanAutostartCmdContent(opts), 'utf8');
+  fs.mkdirSync(lanStartupDir(opts), { recursive: true });
   // VBS 用 UTF-16LE+BOM：wscript 按 Unicode 读取，中文路径不乱码（纯 ANSI 读取会按系统代码页误读）
-  fs.writeFileSync(lanVbsPath(), '\ufeff' + lanVbsContent(opts), 'utf16le');
+  fs.writeFileSync(lanVbsPath(opts), '\ufeff' + lanVbsContent(opts), 'utf16le');
 }
-function lanRemoveStartupFiles() {
+function lanRemoveStartupFiles(opts) {
   // 只删除带产品标记的生成文件，绝不误删用户自己的 Startup 文件
   const removed = [];
-  for (const f of [lanVbsPath(), lanAutostartCmdPath()]) {
+  for (const f of [lanVbsPath(opts), lanAutostartCmdPath(opts)]) {
     try {
       if (lanFileHasMarker(f)) { fs.unlinkSync(f); removed.push(f); }
     } catch (e) { /* 单个文件失败不阻断其它清理 */ }
@@ -10512,10 +10561,145 @@ function lanFileHasMarker(f) {
   } catch (e) { return false; }
 }
 function isSchtasksAccessDenied(e) {
-  const msg = String((e && e.stderr) || (e && e.message) || e);
+  const msg = typeof e === 'string' ? e : String((e && e.stderr) || (e && e.message) || e || '');
   return /access\s+is\s+denied|access\s+denied|拒绝访问/i.test(msg);
 }
 
+// ---- lan Windows task XML (v0.22.4: S4U silent principal) ----
+// 背景（0.22.3 及更早缺陷）：schtasks /create 未指定主体 -> 默认交互式（仅登录时运行）：
+// ① 在登录会话里运行控制台程序会弹窗口；② --onstart 开机触发时无登录会话，任务起不来且不补跑。
+// 修复：改为注册任务 XML —— S4U 主体（“不管用户是否登录都运行”，不存密码、非交互、无窗口），
+// 默认去掉电池限制与 72 小时执行时限（PT0S = 不限时），开机/登录触发均可后台静默启动。
+function lanSchTasksBin() { return process.env.YOTTA_LAN_SCHTASKS_BIN || 'schtasks'; }
+function lanWindowsRunSchtasks(opts, args) {
+  if (opts && typeof opts.execFileFn === 'function') {
+    try {
+      const out = opts.execFileFn(lanSchTasksBin(), args);
+      return { status: 0, stdout: String(out || ''), stderr: '' };
+    } catch (e) {
+      return {
+        status: typeof e.status === 'number' ? e.status : 1,
+        stdout: String((e && e.stdout) || ''),
+        stderr: String((e && e.stderr) || (e && e.message) || e),
+      };
+    }
+  }
+  const r = lanSpawn(lanSchTasksBin(), args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  return {
+    status: r.error ? 1 : r.status,
+    stdout: String(r.stdout || ''),
+    stderr: String(r.stderr || (r.error && r.error.message) || ''),
+  };
+}
+function lanWindowsTaskUser(opts) {
+  opts = opts || {};
+  if (opts.userId) return String(opts.userId);
+  // 测试/高级用途可用 YOTTA_LAN_TASK_USER 覆盖（S4U 主体必须是当前用户名）
+  if (process.env.YOTTA_LAN_TASK_USER) return String(process.env.YOTTA_LAN_TASK_USER);
+  if (process.env.USERDOMAIN && process.env.USERNAME) return process.env.USERDOMAIN + '\\' + process.env.USERNAME;
+  if (process.env.COMPUTERNAME && process.env.USERNAME) return process.env.COMPUTERNAME + '\\' + process.env.USERNAME;
+  try {
+    const r = lanSpawn('whoami', [], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    if (r.status === 0 && String(r.stdout || '').trim()) return String(r.stdout).trim();
+  } catch (e) { /* 用户名探测失败 -> 主体省略 UserId，由 schtasks 按当前用户注册 */ }
+  return '';
+}
+function lanWindowsTaskXml(opts) {
+  opts = opts || {};
+  const onstart = opts.trigger ? String(opts.trigger) === 'onstart' : !!opts.onstart;
+  const host = opts.host || '0.0.0.0';
+  const port = opts.port || 8787;
+  const nodePath = opts.nodePath || process.execPath;
+  const scriptPath = opts.scriptPath || runtimeManagedScript();
+  const logPath = opts.logPath || lanLogPath(opts);
+  const userId = opts.userId || '';
+  const cmdPath = opts.cmdPath || process.env.ComSpec || 'cmd.exe';
+  // cmd /c 外层引号：命令首段带引号时必须用 ""..." 包裹（cmd 的 /c 引号规则），
+  // 让 node/脚本/日志路径里的空格与中文都能安全传递；S4U 非交互会话下不弹窗口。
+  // 注意：重定向 `2>&1` 的 & 在 XML 文本里必须写成 &amp;（DOM 解码后仍是 2>&1），
+  // 否则 schtasks 报 "The task XML is malformed"。
+  // v0.22.5: Electron 宿主（YottaCode shim）下先 set ELECTRON_RUN_AS_NODE=1，
+  // 否则任务会拉起桌面程序本体（GUI）而不是 Node 服务。
+  const envPrefix = lanElectronHost(opts) ? 'set "ELECTRON_RUN_AS_NODE=1" &amp;&amp; ' : '';
+  const inner = envPrefix + '"' + xmlEscape(nodePath) + '" "' + xmlEscape(scriptPath) + '" serve --host ' + host + ' --port ' + port
+    + ' >> "' + xmlEscape(logPath) + '" 2>&amp;1';
+  const triggerXml = onstart
+    ? '<BootTrigger><Enabled>true</Enabled></BootTrigger>'
+    : '<LogonTrigger><Enabled>true</Enabled></LogonTrigger>';
+  const principal = userId
+    ? '<Principal id="Author"><UserId>' + xmlEscape(userId) + '</UserId><LogonType>S4U</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal>'
+    : '<Principal id="Author"><LogonType>S4U</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal>';
+  return [
+    '<?xml version="1.0" encoding="UTF-16"?>',
+    '<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">',
+    '<RegistrationInfo><Description>Yotta Memory serve autostart (generated by yotta-memory lan enable; S4U silent, no window)</Description></RegistrationInfo>',
+    '<Triggers>' + triggerXml + '</Triggers>',
+    '<Principals>' + principal + '</Principals>',
+    '<Settings>',
+    '<MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>',
+    '<DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>',
+    '<StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>',
+    '<AllowHardTerminate>true</AllowHardTerminate>',
+    '<StartWhenAvailable>true</StartWhenAvailable>',
+    '<RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>',
+    '<IdleSettings><StopOnIdleEnd>false</StopOnIdleEnd><RestartOnIdle>false</RestartOnIdle></IdleSettings>',
+    '<Enabled>true</Enabled>',
+    '<Hidden>false</Hidden>',
+    '<RunOnlyIfIdle>false</RunOnlyIfIdle>',
+    '<WakeToRun>false</WakeToRun>',
+    '<ExecutionTimeLimit>PT0S</ExecutionTimeLimit>',
+    '<Priority>7</Priority>',
+    '</Settings>',
+    '<Actions Context="Author"><Exec><Command>' + xmlEscape(cmdPath) + '</Command><Arguments>/c "' + inner + '"</Arguments></Exec></Actions>',
+    '</Task>',
+  ].join('\r\n');
+}
+function lanWindowsEnableCore(opts) {
+  opts = opts || {};
+  const trigger = opts.onstart ? 'onstart' : 'onlogon';
+  const host = opts.host || '0.0.0.0';
+  const port = opts.port || 8787;
+  const nodePath = opts.nodePath || process.execPath;
+  const scriptPath = opts.scriptPath || runtimeManagedScript();
+  const logPath = lanLogPath(opts);
+  const userId = lanWindowsTaskUser(opts);
+  const xml = lanWindowsTaskXml({ trigger: trigger, host: host, port: port, nodePath: nodePath, scriptPath: scriptPath, logPath: logPath, userId: userId, electronHost: opts.electronHost });
+  const xmlDir = opts.xmlDir || process.env.YOTTA_LAN_TASK_XML_DIR || os.tmpdir();
+  const xmlPath = opts.xmlPath || path.join(xmlDir, LAN_TASK_NAME + '-task-' + process.pid + '-' + Date.now() + '.xml');
+  let failure = null;
+  try {
+    fs.mkdirSync(path.dirname(xmlPath), { recursive: true });
+    // UTF-16LE + BOM：与 schtasks /query /xml 导出格式一致，schtasks /create /xml 必然可读
+    fs.writeFileSync(xmlPath, '\ufeff' + xml, 'utf16le');
+    const r = lanWindowsRunSchtasks(opts, ['/create', '/tn', LAN_TASK_NAME, '/xml', xmlPath, '/f']);
+    if (r.status !== 0) failure = String(r.stderr || r.stdout || '').trim() || ('schtasks 退出码 ' + r.status);
+  } catch (e) {
+    failure = String((e && e.message) || e);
+  } finally {
+    try { fs.unlinkSync(xmlPath); } catch (e) { /* 临时 XML 清理尽力而为 */ }
+  }
+  if (!failure) {
+    let removedStartup = [];
+    try { removedStartup = lanRemoveStartupFiles(opts); } catch (e) { removedStartup = []; }
+    return { error: false, mode: 'task', taskName: LAN_TASK_NAME, trigger: trigger, logPath: logPath, removedStartup: removedStartup };
+  }
+  try {
+    lanInstallStartup(opts);
+  } catch (e2) {
+    return { error: true, mode: 'startup', reason: failure, text: String((e2 && e2.message) || e2) };
+  }
+  return {
+    error: false,
+    mode: 'startup',
+    trigger: trigger,
+    reason: failure,
+    accessDenied: isSchtasksAccessDenied(failure),
+    vbsPath: lanVbsPath(opts),
+    cmdPath: lanAutostartCmdPath(opts),
+    logPath: logPath,
+  };
+}
+
 // ---- lan Linux (systemd user unit / user crontab @reboot) ----
 function lanLinuxSystemdUserDir() {
   // override with YOTTA_LAN_SYSTEMD_USER_DIR for testing/advanced use (default ~/.config/systemd/user)
@@ -10531,7 +10715,7 @@ function lanLinuxExecStart(opts) {
 }
 function lanLinuxUnitContent(opts) {
   // keep comments ASCII (avoid locale/encoding issues); ExecStart uses systemd's own quote rules
-  return [
+  const lines = [
     '# ' + LAN_GEN_MARKER + '; remove with: yotta-memory lan disable (English only, keep ASCII)',
     '',
     '[Unit]',
@@ -10539,6 +10723,9 @@ function lanLinuxUnitContent(opts) {
     '',
     '[Service]',
     'Type=simple',
+  ];
+  if (lanElectronHost(opts)) lines.push('Environment=ELECTRON_RUN_AS_NODE=1');
+  lines.push(
     'ExecStart=' + lanLinuxExecStart(opts),
     'Restart=on-failure',
     'RestartSec=3',
@@ -10546,12 +10733,15 @@ function lanLinuxUnitContent(opts) {
     '[Install]',
     'WantedBy=default.target',
     '',
-  ].join('\n');
+  );
+  return lines.join('\n');
 }
 function lanCrontabBin() { return process.env.YOTTA_LAN_CRONTAB_BIN || 'crontab'; }
 function lanCrontabLine(opts) {
-  const parts = ['@reboot', shQuote(process.execPath), shQuote(runtimeManagedScript())].concat(lanServeArgs(opts));
-  return parts.join(' ') + ' >> ' + shQuote(lanLogPath(opts)) + ' 2>&1 ' + LAN_CRONTAB_MARKER;
+  const parts = ['@reboot'];
+  if (lanElectronHost(opts)) parts.push('ELECTRON_RUN_AS_NODE=1');
+  parts.push(shQuote(process.execPath), shQuote(runtimeManagedScript()));
+  return parts.concat(lanServeArgs(opts)).join(' ') + ' >> ' + shQuote(lanLogPath(opts)) + ' 2>&1 ' + LAN_CRONTAB_MARKER;
 }
 function lanCrontabRead() {
   try {
@@ -10700,54 +10890,55 @@ function cmdLanLinuxStatus() {
   if (!any) console.log('未启用任何开机自启（可用 yotta-memory lan enable 注册）');
 }
 function cmdLanWinEnable(opts) {
-  if (process.platform !== 'win32') {
-    console.error('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
+  if (lanPlatform() !== 'win32') {
+    console.error('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + lanPlatform());
     process.exit(2);
   }
-  const trigger = opts.onstart ? 'onstart' : 'onlogon';
-  const tr = lanTaskRunCmd(opts);
-  try {
-    child_process.execFileSync('schtasks', ['/create', '/tn', LAN_TASK_NAME, '/tr', tr, '/sc', trigger, '/f'], { stdio: 'inherit' });
-    console.log('已注册开机自启: 计划任务 ' + LAN_TASK_NAME + '（触发器 ' + trigger + '）');
-    console.log('运行命令: ' + tr);
-    console.log('备注: 服务不会立刻启动，需重启/重新登录后自动启动；如需现在运行请执行 yotta-memory serve');
-    return;
-  } catch (e) {
-    const firstLine = String((e && e.stderr) || (e && e.message) || e).split(/\r?\n/)[0];
-    if (isSchtasksAccessDenied(e)) console.error('计划任务注册被拒绝（当前用户非管理员，Access denied）: ' + firstLine);
-    else console.error('计划任务注册失败（当前环境不可用计划任务）: ' + firstLine);
-    console.log('自动改用用户级 Startup 静默自启（免管理员）...');
-    try {
-      lanInstallStartup(opts);
-    } catch (e2) {
-      console.error('写 Startup 自启失败: ' + String((e2 && e2.message) || e2).split(/\r?\n/)[0]);
-      console.error('请用管理员终端执行 yotta-memory lan enable，或将以下命令手动加入启动项: ' + tr);
-      process.exit(1);
+  const result = lanWindowsEnableCore(opts);
+  if (result.mode === 'task') {
+    const triggerText = result.trigger === 'onstart' ? '开机触发（无需登录）' : '登录触发';
+    console.log('已注册开机自启: 计划任务 ' + LAN_TASK_NAME + '（' + triggerText + '，后台静默运行，不弹窗口）');
+    console.log('运行命令: ' + lanTaskRunCmd(opts));
+    console.log('日志: ' + result.logPath);
+    if (result.removedStartup && result.removedStartup.length) {
+      console.log('已清理旧 Startup 兜底文件 ' + result.removedStartup.length + ' 个（避免双份自启）');
     }
-    console.log('已启用用户级 Startup 静默自启（无需管理员）');
-    console.log('启动脚本: ' + lanVbsPath());
-    console.log('启动命令: ' + lanAutostartCmdPath());
-    console.log('日志: ' + lanLogPath(opts));
-    console.log('备注: 服务不会立刻启动，需重新登录后自动启动；如需现在运行请执行 yotta-memory serve');
-    console.log('提示: 如需改回计划任务，请用管理员终端重新执行 yotta-memory lan enable');
+    console.log('备注: 服务不会立刻启动，需重启/重新登录后自动启动；如需现在运行请执行 yotta-memory serve');
     return;
   }
+  if (result.error) {
+    console.error('计划任务注册失败: ' + String(result.reason || '').split(/\r?\n/)[0]);
+    console.error('写 Startup 自启失败: ' + String(result.text || '').split(/\r?\n/)[0]);
+    console.error('请用管理员终端执行 yotta-memory lan enable，或将以下命令手动加入启动项: ' + lanTaskRunCmd(opts));
+    process.exit(1);
+  }
+  const firstLine = String(result.reason || '').split(/\r?\n/)[0];
+  if (result.accessDenied) console.error('计划任务注册被拒绝（当前用户非管理员，Access denied）: ' + firstLine);
+  else console.error('计划任务注册失败（当前环境不可用计划任务）: ' + firstLine);
+  console.log('自动改用用户级 Startup 静默自启（免管理员）...');
+  console.log('已启用用户级 Startup 静默自启（无需管理员）');
+  console.log('启动脚本: ' + result.vbsPath);
+  console.log('启动命令: ' + result.cmdPath);
+  console.log('日志: ' + result.logPath);
+  console.log('备注: 服务不会立刻启动，需重新登录后自动启动；如需现在运行请执行 yotta-memory serve');
+  console.log('提示: 如需改回计划任务（后台静默），请用管理员终端重新执行 yotta-memory lan enable');
 }
 function cmdLanWinDisable() {
-  if (process.platform !== 'win32') {
-    console.error('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
+  if (lanPlatform() !== 'win32') {
+    console.error('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + lanPlatform());
     process.exit(2);
   }
   let sawError = false;
   let removedAny = false;
-  try {
-    child_process.execFileSync('schtasks', ['/delete', '/tn', LAN_TASK_NAME, '/f'], { stdio: ['ignore', 'pipe', 'pipe'] });
+  const del = lanWindowsRunSchtasks({}, ['/delete', '/tn', LAN_TASK_NAME, '/f']);
+  if (del.status === 0) {
     console.log('已移除开机自启计划任务 ' + LAN_TASK_NAME);
     removedAny = true;
-  } catch (e) {
-    const msg = String((e && e.stderr) || (e && e.message) || e);
+  } else {
+    const msg = String(del.stderr || del.stdout || '');
     if (!/cannot find the (path|file)|没有找到|找不到|不存在/i.test(msg)) {
       console.error('移除计划任务失败: ' + msg.split(/\r?\n/)[0]);
+      if (isSchtasksAccessDenied(msg)) console.error('（当前非管理员，无法移除管理员注册的计划任务；请用管理员终端执行 yotta-memory lan disable）');
       sawError = true;
     }
   }
@@ -10759,21 +10950,32 @@ function cmdLanWinDisable() {
   if (sawError) process.exit(1);
 }
 function cmdLanWinStatus() {
-  if (process.platform !== 'win32') {
-    console.log('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
+  if (lanPlatform() !== 'win32') {
+    console.log('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + lanPlatform());
     return;
   }
   let taskFound = false;
-  try {
-    const out = child_process.execFileSync('schtasks', ['/query', '/tn', LAN_TASK_NAME, '/fo', 'LIST', '/v'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+  const q = lanWindowsRunSchtasks({}, ['/query', '/tn', LAN_TASK_NAME, '/fo', 'LIST', '/v']);
+  if (q.status === 0) {
     taskFound = true;
     console.log('计划任务 ' + LAN_TASK_NAME + ': 已启用');
-    const re = /^(状态|Status)\s*:\s*(.+)$/;
-    for (const line of String(out).split(/\r?\n/)) {
+    const re = /^(状态|Status|登录模式|Logon Mode|上次运行时间|Last Run Time|上次结果|Last Result|要运行的任务|Task To Run)\s*[:=]\s*(.+)$/;
+    let logonMode = '';
+    let taskRun = '';
+    for (const line of String(q.stdout).split(/\r?\n/)) {
       const m = re.exec(line.trim());
-      if (m) console.log('  ' + m[1] + ': ' + m[2]);
+      if (!m) continue;
+      console.log('  ' + m[1] + ': ' + m[2]);
+      if (/^(登录模式|Logon Mode)$/.test(m[1])) logonMode = m[2];
+      if (/^(要运行的任务|Task To Run)$/.test(m[1])) taskRun = m[2];
     }
-  } catch (e) {
+    if (/interactive|交互式/i.test(logonMode)) {
+      console.log('  提示: 登录模式为交互式（仅登录时运行，且在登录会话会弹窗口）——这是旧版任务；请重新执行 yotta-memory lan enable 修复为后台静默');
+    }
+    if (lanTaskCommandNeedsElectronEnv(taskRun)) {
+      console.log('  警告: 任务命令指向 Electron 可执行文件（如 YottaCode.exe）但缺少 ELECTRON_RUN_AS_NODE —— 开机将拉起桌面程序而非服务；请重新执行 yotta-memory lan enable 修复');
+    }
+  } else {
     console.log('计划任务 ' + LAN_TASK_NAME + ': 未启用');
   }
   const vbsOk = lanFileHasMarker(lanVbsPath());
@@ -10782,6 +10984,12 @@ function cmdLanWinStatus() {
     console.log('Startup 静默自启（免管理员）: 已启用');
     console.log('  启动脚本: ' + lanVbsPath());
     console.log('  启动命令: ' + lanAutostartCmdPath());
+    try {
+      const cmdText = fs.readFileSync(lanAutostartCmdPath(), 'utf8');
+      if (lanTaskCommandNeedsElectronEnv(cmdText)) {
+        console.log('  警告: Startup 兜底脚本缺少 ELECTRON_RUN_AS_NODE —— Electron 宿主下会拉起桌面程序而非服务；请重新执行 yotta-memory lan enable 修复');
+      }
+    } catch (e) { /* 读取失败不影响状态输出 */ }
   } else if (vbsOk || cmdOk) {
     console.log('Startup 静默自启: 部分残留（建议执行 yotta-memory lan disable 后重新 lan enable）');
   } else {
@@ -12016,6 +12224,7 @@ module.exports = {
   lanServeArgs: lanServeArgs,
   lanSpawn: lanSpawn,
   lanPlatform: lanPlatform,
+  lanElectronHost: lanElectronHost,
   shQuote: shQuote,
   systemdEscapeArg: systemdEscapeArg,
   lanLinuxSystemdUserDir: lanLinuxSystemdUserDir,
@@ -12124,6 +12333,9 @@ module.exports = {
   doctorCore: doctorCore,
   destructiveGuardCore: destructiveGuardCore,
   backupWindowsTaskXml: backupWindowsTaskXml,
+  lanWindowsTaskXml: lanWindowsTaskXml,
+  lanWindowsEnableCore: lanWindowsEnableCore,
+  lanWindowsTaskUser: lanWindowsTaskUser,
   backupSystemdServiceContent: backupSystemdServiceContent,
   backupSystemdTimerContent: backupSystemdTimerContent,
   backupCronLine: backupCronLine,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yottameta/yotta-memory",
-  "version": "0.22.3",
+  "version": "0.22.5",
   "description": "Yuanyi (元忆) — boundary-aware, file-based memory for AI agents. File-based, zero-dependency, diff/rollback-able; FACT/PREF/BOUND/COMMIT types (public shared / private isolated), user-level + project-level storage; v0.12 reliability baseline (init guard, trash-based deletion, independent-volume backup/list/doctor/restore, start-of-work doctor, transactional snapshots before destructive writes), v0.10 consolidation (periodic summaries with provenance, near-duplicate auto-merge, per-type decay, batch audit + rollback), v0.9 recall quality + context focus + optional local embedding plugin, plus v0.8 semantic search, feedback loop, self-organization and distillation.",
   "license": "MIT",
   "keywords": [

package/skill-manifest.json

@@ -3,7 +3,7 @@
   "slug": "yotta-memory",
   "name": "元忆",
   "package": "@yottameta/yotta-memory",
-  "version": "0.22.3",
+  "version": "0.22.5",
   "trust": "yottameta",
   "install": {
     "idempotent": true