@yottameta/yotta-memory 0.5.2 → 0.5.4

package/README.md

@@ -40,7 +40,7 @@
 | **检索与生命周期** | 索引 + TF 打分（中文分词友好）；质量分 / 盖棺分 / 自动归档，记忆库不会无限膨胀 |
 | **生态分发** | GitHub + npm 双源同步发布；npx skills / npm / install.sh 三种方式，覆盖 17+ 类智能体目录 |
 | **便携记忆盘（随盘走）** | 记忆库即引擎：装在硬盘 / 主机上，插上即恢复全部记忆；引擎主机只需装 CLI 当存放点，无需装任何 AI 智能体 |
-| **局域网共享与自启** | 每智能体独立 token（Bearer + X-Agent-Id）鉴权、可吊销；`lan enable` 注册开机自启（默认登录自启，可选开机即启）；MCP 工具集与 CLI 一致（8 个工具），管理动作不远程暴露 |
+| **局域网共享与自启** | 每智能体独立 token（Bearer + X-Agent-Id）鉴权、可吊销；`lan enable` 注册开机自启（Windows：优先计划任务；非管理员自动降级用户级 Startup 静默自启）；MCP 工具集与 CLI 一致（8 个工具），管理动作不远程暴露 |
 | **本地 / 局域网双模式** | 本地 `serve --stdio` 零进程、按需拉起（无常驻）；局域网 streamable HTTP 常驻——两种模式可并存、按需选用 |
 
 ## 功能详解
@@ -106,7 +106,7 @@
 
 - **记忆库即引擎**：`serve` 把记忆目录挂成 MCP 服务，目录随盘走；引擎主机只需装 CLI 当存放点，无需装任何 AI 智能体。
 - **双模式可并存**：本地 `serve --stdio` 零进程（客户端按需拉起）；局域网 streamable HTTP（默认 `0.0.0.0:8787`）+ 每智能体 token 鉴权。
-- **开机自启**：`lan enable` 注册 Windows 计划任务（默认登录自启，`--onstart` 开机即启需管理员）；`lan disable` 移除，`lan status` 查询。
+- **开机自启**：`lan enable` 注册 Windows 开机自启——优先计划任务（默认登录自启，`--onstart` 开机即启需管理员）；非管理员（计划任务被拒）自动降级为**用户级 Startup 静默自启**（免管理员）；`lan disable` 移除，`lan status` 查询。
 - **安全边界**：管理动作（init / config / token / lan / serve）不进 MCP，token 不远程暴露；远程智能体只能读写记忆，不能改配置、不能管 token。
 - 完整操作步骤见上文「局域网多机共享」章节与 [USER_GUIDE.md](USER_GUIDE.md)。
 
@@ -185,7 +185,7 @@ npm i -g @yottameta/yotta-memory
 | `yotta-memory iam <id> [--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 鉴权）|
-| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows 计划任务，默认 ONLOGON 登录自启；--onstart 开机即启需管理员）|
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务，默认 ONLOGON 登录自启、--onstart 开机即启需管理员；非管理员自动降级用户级 Startup 静默自启）|
 
 类型：`FACT`（事实，公共共享）/ `PREF`（偏好）/ `BOUND`（边界）/ `COMMIT`（承诺）。
 
@@ -226,10 +226,10 @@ yotta-memory recall --type FACT --limit 10
 3. 启动服务（默认监听 0.0.0.0:8787，Bearer token + X-Agent-Id 鉴权）——临时运行或注册开机自启二选一：
    ```bash
    yotta-memory serve                          # 临时前台运行
-   yotta-memory lan enable                     # 注册开机自启（Windows 计划任务，登录自启）
+   yotta-memory lan enable                     # 注册开机自启（Windows：计划任务；非管理员自动降级用户级 Startup 静默自启）
    yotta-memory lan status                     # 查看自启状态
    ```
-   > `lan enable --onstart` 改为开机即启（需管理员）；`lan disable` 移除自启。
+   > `lan enable --onstart` 改为开机即启（需管理员）；非管理员时 `lan enable` 自动改用用户级 Startup 静默自启（无需管理员）；`lan disable` 移除自启。
 
 > 首次监听 0.0.0.0 时，Windows / 系统防火墙可能询问是否放行，需允许放行，否则局域网内其它主机无法访问；`--no-auth` 会关闭鉴权，仅限可信内网使用。
 

package/SKILL.md

@@ -1,14 +1,14 @@
 ---
 name: yotta-memory
 description: "元忆 —— 有权限边界的文件式智能体记忆。文件式、零依赖、可 diff/回滚：让任何 AI 智能体活过会话，开工 recall 恢复上下文、重要信息 remember 落盘、收工归档。类型体系 FACT（公共共享）/ PREF / BOUND / COMMIT（私密隔离）。触发：记住、别忘了、记一笔、记忆、remember、recall、跨会话、上次说到、续测、交接、归档、记忆盘、共享记忆、局域网记忆"
-version: 0.5.2
+version: 0.5.4
 license: MIT
 ---
 
 # yotta-memory（元忆）— 有权限边界的文件式智能体记忆
 
 > 一句话：元忆 —— 有权限边界的文件式智能体记忆（不注入、可 diff、能回滚；FACT 共享、PREF / BOUND / COMMIT 私密隔离）。
-> 版本：0.5.2 | 最后更新：2026-08-25
+> 版本：0.5.4 | 最后更新：2026-08-25
 
 ## 这是什么
 
@@ -79,7 +79,7 @@ license: MIT
 | `yotta-memory iam <id> [--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 鉴权）|
-| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows 计划任务，默认 ONLOGON 登录自启；--onstart 开机即启需管理员）|
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务，默认 ONLOGON 登录自启、--onstart 开机即启需管理员；非管理员自动降级用户级 Startup 静默自启）|
 
 ## 存储格式（摘要）
 
@@ -137,7 +137,7 @@ yotta-memory --version    # 或 command -v yotta-memory / where yotta-memory
 > 记忆盘场景：硬盘插上 → AI 检查盘上目录是否有数据 → 有则接入 + config 记住 → 插盘即恢复，机器记住位置。
 
 **步骤 0.5 启动记忆引擎（仅引擎主机，供远程接入）**
-- 本机若作引擎：🔒 **征得同意后**启动服务——临时运行 `yotta-memory serve`（默认 `0.0.0.0:8787`，Bearer token + X-Agent-Id 鉴权；`--no-auth` 仅限可信内网），或注册开机自启 `yotta-memory lan enable`（Windows 计划任务，默认登录自启；`--onstart` 开机即启需管理员）。
+- 本机若作引擎：🔒 **征得同意后**启动服务——临时运行 `yotta-memory serve`（默认 `0.0.0.0:8787`，Bearer token + X-Agent-Id 鉴权；`--no-auth` 仅限可信内网），或注册开机自启 `yotta-memory lan enable`（Windows：优先计划任务，默认登录自启；非管理员自动降级用户级 Startup 静默自启，免管理员）。
 - 本地零进程模式：本机 AI 也可用 `serve --stdio` 由 MCP 客户端按需拉起 CLI（无常驻进程，照灵魂盘）。
 - 远程客户端接入前，先确认引擎主机 serve 已运行（`lan status` 可查）。
 

package/USER_GUIDE.md

@@ -111,7 +111,7 @@ yotta-memory init --dir /srv/yotta-memory               # 新库：初始化（
 **第 3 步：注册开机自启（可选，推荐）**
 
 ```bash
-# Windows：内置命令（计划任务）
+# Windows：内置命令（优先计划任务；非管理员自动降级用户级 Startup 静默自启）
 yotta-memory lan enable              # 登录后自动启动（默认）
 yotta-memory lan enable --onstart    # 开机即启（需管理员）
 yotta-memory lan status              # 查看状态
@@ -242,7 +242,7 @@ yotta-memory remember FACT 主题 内容    # 智能体落盘
 | `yotta-memory iam <id> [--force]` | 登记本智能体唯一身份并自动落自我档案（`agents.json`，ID 必须唯一）|
 | `yotta-memory token new --agent <id> [--force]` / `token list` / `token revoke --agent <id>` | 访问 token（同 ID 已被其它来源占用需 `--force` 覆盖）|
 | `yotta-memory serve [--port 8787] [--stdio] [--no-auth]` | 启动记忆引擎（--no-auth 关闭鉴权，仅限可信内网）|
-| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理 |
+| `yotta-memory lan enable [--onstart] / disable / status` | 开机自启管理（Windows：计划任务；非管理员自动降级用户级 Startup 静默自启）|
 
 类型：`FACT`（事实，共享）/ `PREF`（偏好）/ `BOUND`（边界）/ `COMMIT`（承诺），后三类按智能体物理分目录隔离（`private/<owner>/<type>/`）。
 
@@ -259,7 +259,7 @@ yotta-memory remember FACT 主题 内容    # 智能体落盘
    - 返回 401：服务在运行，是鉴权问题（token / 请求头不对）。
    - 连接被拒 / 超时：服务没启动，或防火墙拦截。
 
-**`lan enable` 失败提示 Access denied：** 需要管理员权限，请用管理员终端重新执行；`--onstart` 模式必须管理员。
+**`lan enable` 计划任务被拒（Access denied 等）：** 无需担心——会自动降级为**用户级 Startup 静默自启**（免管理员，重新登录后生效，启动脚本位于用户 Startup 目录）；如确需计划任务，请用管理员终端重新执行；`--onstart` 模式必须管理员。
 
 **启动引擎报端口被占用（EADDRINUSE）：** 用 `--port <其它端口>` 换端口启动，两端保持一致；或先查占用：Linux `ss -tlnp | grep 8787`，Windows `netstat -ano | findstr 8787`。
 

package/bin/yotta-memory.js

@@ -3,6 +3,8 @@
 // v0.4.0 新增：lan（Windows 计划任务开机自启 serve）/ init --dir（显式指定位置）/ serve --stdio（本地零进程模式）/ MCP 工具补 reindex/export/import
 // v0.5.0 新增：隐私硬隔离——私密物理分目录 private/<agent_id>/{prefs,bounds,commits}/ + 关闭 --agent 越权读 + 私密写跨智能体需 --unsafe + 禁 shell 直读写（文档红线）
 // v0.4.2 新增：iam/whoami 智能体身份自注册（agents.json 唯一性）+ 自我档案 PREF + 私密记忆须声明 owner
+// v0.5.3 新增：CLI 选项可前置（--agent 等允许放在子命令前，不再误报"未知命令"）/ lan enable 成功补"服务不会立刻启动"提示（v0.5.2 lan 引号修复无回归）
+// v0.5.4 新增：lan enable 在非管理员（schtasks Access denied）时自动降级为用户级 Startup 静默自启（VBS sh.Run 窗口0 + autostart.cmd，node 路径 process.execPath 自动探测）；lan disable/status 同时管理计划任务与 Startup 双机制
 'use strict';
 
 const fs = require('fs');
@@ -12,7 +14,7 @@ const crypto = require('crypto');
 const http = require('http');
 const child_process = require('child_process');
 
-const VERSION = '0.5.2';
+const VERSION = '0.5.4';
 const TYPES = ['FACT', 'PREF', 'BOUND', 'COMMIT'];
 const TYPE_DIRS = { FACT: 'facts', PREF: 'prefs', BOUND: 'bounds', COMMIT: 'commits' };
 const PUBLIC_DIR = 'facts';
@@ -959,8 +961,11 @@ function cmdServeStdio() {
   process.stdin.on('end', function () { process.exit(0); });
 }
 
-// ---- lan 命令（Windows 计划任务管理开机自启 serve）----
+// ---- lan 命令（Windows 开机自启管理 serve）----
+// 双机制：① schtasks 计划任务（默认，需相应权限）；② 非管理员（Access denied）自动降级为
+// 用户级 Startup 静默自启（VBS sh.Run <autostart.cmd>, 0, False + autostart.cmd；node 路径 process.execPath 自动探测，0.5.4）
 const LAN_TASK_NAME = 'YottaMemoryServe';
+const LAN_GEN_MARKER = 'Generated by yotta-memory lan enable';
 function lanTaskRunCmd(opts) {
   const host = opts.host || '0.0.0.0';
   const port = opts.port || 8787;
@@ -968,58 +973,158 @@ function lanTaskRunCmd(opts) {
   const q = (p) => /[\s"]/.test(p) ? '\\"' + p.replace(/"/g, '\\"') + '\\"' : p;
   return q(process.execPath) + ' ' + q(__filename) + ' serve --host ' + host + ' --port ' + port;
 }
+function lanStartupDir() {
+  // 测试/高级用途可用 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() {
+  // 产品自有目录 ~/.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 lanLogPath(opts) {
+  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) {
+  const host = opts.host || '0.0.0.0';
+  const port = opts.port || 8787;
+  const q = (p) => '"' + String(p).replace(/"/g, '""') + '"';
+  // 生成文件用纯 ASCII（避免 cmd/VBS 按系统代码页读取中文注释乱码）
+  return '@echo off\r\n'
+    + 'chcp 65001 >nul\r\n'
+    + 'rem ' + LAN_GEN_MARKER + '; remove with: yotta-memory lan disable\r\n'
+    + q(process.execPath) + ' ' + q(__filename) + ' serve --host ' + host + ' --port ' + port + ' >> ' + q(lanLogPath(opts)) + ' 2>&1\r\n';
+}
+function lanVbsContent() {
+  return "' " + LAN_GEN_MARKER + '; remove with: yotta-memory lan disable\r\n'
+    + 'Set sh = CreateObject("WScript.Shell")\r\n'
+    + 'sh.Run "' + String(lanAutostartCmdPath()).replace(/"/g, '""') + '", 0, False\r\n';
+}
+function lanInstallStartup(opts) {
+  fs.mkdirSync(lanAutostartDir(), { recursive: true });
+  fs.writeFileSync(lanAutostartCmdPath(), lanAutostartCmdContent(opts), 'utf8');
+  fs.mkdirSync(lanStartupDir(), { recursive: true });
+  // VBS 用 UTF-16LE+BOM：wscript 按 Unicode 读取，中文路径不乱码（纯 ANSI 读取会按系统代码页误读）
+  fs.writeFileSync(lanVbsPath(), '\ufeff' + lanVbsContent(), 'utf16le');
+}
+function lanRemoveStartupFiles() {
+  // 只删除带产品标记的生成文件，绝不误删用户自己的 Startup 文件
+  const removed = [];
+  for (const f of [lanVbsPath(), lanAutostartCmdPath()]) {
+    try {
+      if (lanFileHasMarker(f)) { fs.unlinkSync(f); removed.push(f); }
+    } catch (e) { /* 单个文件失败不阻断其它清理 */ }
+  }
+  return removed;
+}
+function lanFileHasMarker(f) {
+  try {
+    if (!fs.existsSync(f)) return false;
+    const buf = fs.readFileSync(f);
+    const m8 = Buffer.from(LAN_GEN_MARKER, 'utf8');
+    const m16 = Buffer.from(LAN_GEN_MARKER, 'utf16le');
+    return buf.indexOf(m8) !== -1 || buf.indexOf(m16) !== -1;
+  } catch (e) { return false; }
+}
+function isSchtasksAccessDenied(e) {
+  const msg = String((e && e.stderr) || (e && e.message) || e);
+  return /access\s+is\s+denied|access\s+denied|拒绝访问/i.test(msg);
+}
 function cmdLanEnable(opts) {
   if (process.platform !== 'win32') {
-    console.error('lan 命令当前仅支持 Windows（计划任务）；本机平台: ' + process.platform);
+    console.error('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
     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) {
-    console.error('注册计划任务失败（ONSTART 需要管理员权限；ONLOGON 一般不需要；如仍失败请用管理员终端执行）: ' + String((e && e.stderr) || (e && e.message) || e).split(/\r?\n/)[0]);
-    process.exit(1);
+    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);
+    }
+    console.log('已启用用户级 Startup 静默自启（无需管理员）');
+    console.log('启动脚本: ' + lanVbsPath());
+    console.log('启动命令: ' + lanAutostartCmdPath());
+    console.log('日志: ' + lanLogPath(opts));
+    console.log('备注: 服务不会立刻启动，需重新登录后自动启动；如需现在运行请执行 yotta-memory serve');
+    console.log('提示: 如需改回计划任务，请用管理员终端重新执行 yotta-memory lan enable');
+    return;
   }
-  console.log('已注册开机自启: 计划任务 ' + LAN_TASK_NAME + '（触发器 ' + trigger + '）');
-  console.log('运行命令: ' + tr);
 }
 function cmdLanDisable() {
   if (process.platform !== 'win32') {
-    console.error('lan 命令当前仅支持 Windows（计划任务）；本机平台: ' + process.platform);
+    console.error('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
     process.exit(2);
   }
+  let sawError = false;
+  let removedAny = false;
   try {
-    child_process.execFileSync('schtasks', ['/delete', '/tn', LAN_TASK_NAME, '/f'], { stdio: ['ignore', 'pipe', 'ignore'] });
+    child_process.execFileSync('schtasks', ['/delete', '/tn', LAN_TASK_NAME, '/f'], { stdio: ['ignore', 'pipe', 'pipe'] });
+    console.log('已移除开机自启计划任务 ' + LAN_TASK_NAME);
+    removedAny = true;
   } catch (e) {
     const msg = String((e && e.stderr) || (e && e.message) || e);
-    if (msg.indexOf('cannot find the path') !== -1 || msg.indexOf('没有找到') !== -1) {
-      console.log('未启用: 计划任务 ' + LAN_TASK_NAME + ' 不存在，无需移除');
-      return;
+    if (!/cannot find the (path|file)|没有找到|找不到|不存在/i.test(msg)) {
+      console.error('移除计划任务失败: ' + msg.split(/\r?\n/)[0]);
+      sawError = true;
     }
-    console.error('移除计划任务失败: ' + msg.split(/\r?\n/)[0]);
-    process.exit(1);
   }
-  console.log('已移除开机自启计划任务 ' + LAN_TASK_NAME);
+  for (const f of lanRemoveStartupFiles()) {
+    console.log('已移除 Startup 自启文件: ' + f);
+    removedAny = true;
+  }
+  if (!removedAny && !sawError) console.log('未启用: 未发现任何自启配置（计划任务与 Startup 文件均不存在）');
+  if (sawError) process.exit(1);
 }
 function cmdLanStatus() {
   if (process.platform !== 'win32') {
-    console.log('lan 命令当前仅支持 Windows（计划任务）；本机平台: ' + process.platform);
+    console.log('lan 命令当前仅支持 Windows（计划任务 / Startup 自启）；本机平台: ' + process.platform);
     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'] });
-    console.log('已启用: 计划任务 ' + LAN_TASK_NAME + ' 存在');
+    taskFound = true;
+    console.log('计划任务 ' + LAN_TASK_NAME + ': 已启用');
     const re = /^(状态|Status)\s*:\s*(.+)$/;
     for (const line of String(out).split(/\r?\n/)) {
       const m = re.exec(line.trim());
-      if (m) console.log(m[1] + ': ' + m[2]);
+      if (m) console.log('  ' + m[1] + ': ' + m[2]);
     }
   } catch (e) {
-    console.log('未启用: 计划任务 ' + LAN_TASK_NAME + ' 不存在（可用 yotta-memory lan enable 注册）');
+    console.log('计划任务 ' + LAN_TASK_NAME + ': 未启用');
   }
+  const vbsOk = lanFileHasMarker(lanVbsPath());
+  const cmdOk = lanFileHasMarker(lanAutostartCmdPath());
+  if (vbsOk && cmdOk) {
+    console.log('Startup 静默自启（免管理员）: 已启用');
+    console.log('  启动脚本: ' + lanVbsPath());
+    console.log('  启动命令: ' + lanAutostartCmdPath());
+  } else if (vbsOk || cmdOk) {
+    console.log('Startup 静默自启: 部分残留（建议执行 yotta-memory lan disable 后重新 lan enable）');
+  } else {
+    console.log('Startup 静默自启（免管理员）: 未启用');
+  }
+  if (!taskFound && !vbsOk && !cmdOk) console.log('未启用任何开机自启（可用 yotta-memory lan enable 注册）');
 }
-
 // ---- usage / main ----
 function usage() {
   console.log([
@@ -1042,7 +1147,7 @@ function usage() {
     '  yotta-memory token list                   列出已登记智能体',
     '  yotta-memory token revoke --agent <id>    吊销某智能体 token',
     '  yotta-memory serve [--host 0.0.0.0] [--port 8787] [--no-auth] [--stdio]  启动 MCP 记忆引擎（streamable HTTP；--stdio 本地零进程模式）',
-    '  yotta-memory lan enable [--onstart] | disable | status  开机自启管理（Windows 计划任务，默认 ONLOGON）',
+    '  yotta-memory lan enable [--onstart] | disable | status  开机自启管理（Windows 计划任务，默认 ONLOGON；非管理员自动降级用户级 Startup 静默自启）',
     '  yotta-memory --version                    版本',
     '',
     '类型: FACT(公共共享) / PREF(偏好) / BOUND(边界) / COMMIT(承诺)',
@@ -1055,14 +1160,13 @@ function usage() {
 function main() {
   const args = process.argv.slice(2);
   if (!args.length) { usage(); return; }
-  const first = args[0];
-  if (first === '--version' || first === '-v') { console.log(VERSION); return; }
-  if (first === '--help' || first === '-h') { usage(); return; }
   const opts = {};
   const positional = [];
   const valueOpts = new Set(['--type', '--limit', '--days', '--out', '--owner', '--agent', '--threshold', '--scope', '--host', '--port', '--dir']);
-  for (let i = 1; i < args.length; i++) {
+  for (let i = 0; i < args.length; i++) {
     const a = args[i];
+    if (a === '--version' || a === '-v') { console.log(VERSION); return; }
+    if (a === '--help' || a === '-h') { usage(); return; }
     if (a === '--project') opts.project = true;
     else if (a === '--all') opts.all = true;
     else if (a === '--unsafe') opts.unsafe = true;
@@ -1090,26 +1194,28 @@ function main() {
       positional.push(a);
     }
   }
+  const first = positional[0];
+  const rest = positional.slice(1);
   switch (first) {
     case 'init': cmdInit(opts); break;
     case 'whoami': cmdWhoami(); break;
-    case 'iam': cmdIam(positional[0], opts); break;
+    case 'iam': cmdIam(rest[0], opts); break;
     case 'config': {
-      const sub = positional[0];
-      if (sub === 'set') cmdConfigSet(positional[1], positional[2]);
+      const sub = rest[0];
+      if (sub === 'set') cmdConfigSet(rest[1], rest[2]);
       else if (sub === 'get') cmdConfigGet();
       else { console.error('config 子命令: set memory_home <目录> / get'); process.exit(2); }
       break;
     }
-    case 'remember': cmdRemember(positional[0], positional[1], positional[2], opts); break;
-    case 'recall': cmdRecall(positional[0] || null, opts); break;
-    case 'forget': cmdForget(positional[0]); break;
+    case 'remember': cmdRemember(rest[0], rest[1], rest[2], opts); break;
+    case 'recall': cmdRecall(rest[0] || null, opts); break;
+    case 'forget': cmdForget(rest[0]); break;
     case 'archive': cmdArchive(opts); break;
     case 'reindex': cmdReindex(); break;
     case 'export': cmdExport(opts.out); break;
-    case 'import': cmdImport(positional[0]); break;
+    case 'import': cmdImport(rest[0]); break;
     case 'token': {
-      const sub = positional[0];
+      const sub = rest[0];
       if (sub === 'new') cmdTokenNew(opts.agent, opts);
       else if (sub === 'list') cmdTokenList();
       else if (sub === 'revoke') cmdTokenRevoke(opts.agent);
@@ -1118,7 +1224,7 @@ function main() {
     }
     case 'serve': cmdServe(opts); break;
     case 'lan': {
-      const sub = positional[0];
+      const sub = rest[0];
       if (sub === 'enable') cmdLanEnable(opts);
       else if (sub === 'disable') cmdLanDisable();
       else if (sub === 'status') cmdLanStatus();
@@ -1126,6 +1232,7 @@ function main() {
       break;
     }
     default:
+      if (!first) { usage(); return; }
       console.error('未知命令: ' + first);
       usage();
       process.exit(2);
@@ -1151,4 +1258,16 @@ module.exports = {
   collectEntryFiles: collectEntryFiles,
   migrateLayout: migrateLayout,
   typeSubdir: typeSubdir,
+  lanTaskRunCmd: lanTaskRunCmd,
+  lanStartupDir: lanStartupDir,
+  lanAutostartDir: lanAutostartDir,
+  lanVbsPath: lanVbsPath,
+  lanAutostartCmdPath: lanAutostartCmdPath,
+  lanLogPath: lanLogPath,
+  lanAutostartCmdContent: lanAutostartCmdContent,
+  lanVbsContent: lanVbsContent,
+  lanInstallStartup: lanInstallStartup,
+  lanRemoveStartupFiles: lanRemoveStartupFiles,
+  lanFileHasMarker: lanFileHasMarker,
+  isSchtasksAccessDenied: isSchtasksAccessDenied,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yottameta/yotta-memory",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "元忆 —— 有权限边界的文件式智能体记忆。文件式、零依赖、可 diff/回滚；FACT/PREF/BOUND/COMMIT 四分类（公共共享/私密隔离），用户级+项目级双级存储。",
   "license": "MIT",
   "keywords": [

package/references/protocol.md

@@ -1,4 +1,4 @@
-# yotta-memory 协议规范 v0.5.2
+# yotta-memory 协议规范 v0.5.4
 
 > 本文件定义 yotta-memory 记忆标准：存储位置、目录结构、文件格式、类型体系与 CLI 命令参考。
 > 目标：任何支持 Agent Skills 开放标准的智能体，装完即可读写同一份记忆。