engine7 7.1.39 → 7.1.41

package/dist/cli.mjs

@@ -22,20 +22,20 @@ __export(cli_travel_exports, {
   loadTravelConfig: () => loadTravelConfig,
   saveTravelConfig: () => saveTravelConfig
 });
-import * as path from "node:path";
-import * as fs from "node:fs";
-import * as os from "node:os";
+import * as path2 from "node:path";
+import * as fs2 from "node:fs";
+import * as os2 from "node:os";
 import { execSync } from "node:child_process";
 function loadTravelConfig() {
   try {
-    if (!fs.existsSync(CONFIG_PATH)) return null;
-    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    if (!fs2.existsSync(CONFIG_PATH)) return null;
+    return JSON.parse(fs2.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveTravelConfig(cfg) {
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+  fs2.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
 }
 function sanitizeContent(content, dirs) {
   let result = content;
@@ -60,7 +60,7 @@ function restoreContent(content, dirs) {
   return result;
 }
 function isTextFile(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
+  const ext = path2.extname(filePath).toLowerCase();
   return TEXT_EXTENSIONS.has(ext);
 }
 function shouldExclude(name) {
@@ -75,14 +75,14 @@ function shouldExclude(name) {
 }
 function collectFiles(rootDir, includeSet, optionalSet) {
   const files = [];
-  const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+  const entries = fs2.readdirSync(rootDir, { withFileTypes: true });
   for (const entry of entries) {
     if (shouldExclude(entry.name)) continue;
-    const fullPath = path.join(rootDir, entry.name);
-    const realPath = fs.realpathSync(fullPath);
+    const fullPath = path2.join(rootDir, entry.name);
+    const realPath = fs2.realpathSync(fullPath);
     if (realPath !== fullPath) {
       try {
-        const lstat = fs.lstatSync(fullPath);
+        const lstat = fs2.lstatSync(fullPath);
         if (lstat.isSymbolicLink()) {
           continue;
         }
@@ -103,12 +103,12 @@ function collectFiles(rootDir, includeSet, optionalSet) {
 function collectAllFiles(dir) {
   const files = [];
   try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (shouldExclude(entry.name)) continue;
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
       try {
-        if (fs.lstatSync(fullPath).isSymbolicLink()) continue;
+        if (fs2.lstatSync(fullPath).isSymbolicLink()) continue;
       } catch {
       }
       if (entry.isDirectory()) {
@@ -123,30 +123,30 @@ function collectAllFiles(dir) {
 }
 function readMainEngineUuid(agentsDir) {
   try {
-    const platformMapPath = path.join(agentsDir, "main", "sessions", "platform-map.json");
-    const indexMapPath = path.join(agentsDir, "main", "sessions", "session-index.json");
-    if (!fs.existsSync(platformMapPath) || !fs.existsSync(indexMapPath)) return null;
-    const platformMap = JSON.parse(fs.readFileSync(platformMapPath, "utf-8"));
+    const platformMapPath = path2.join(agentsDir, "main", "sessions", "platform-map.json");
+    const indexMapPath = path2.join(agentsDir, "main", "sessions", "session-index.json");
+    if (!fs2.existsSync(platformMapPath) || !fs2.existsSync(indexMapPath)) return null;
+    const platformMap = JSON.parse(fs2.readFileSync(platformMapPath, "utf-8"));
     const mainPlatformId = platformMap["scope:main"] || platformMap["main"];
     if (!mainPlatformId) return null;
-    const indexMap = JSON.parse(fs.readFileSync(indexMapPath, "utf-8"));
+    const indexMap = JSON.parse(fs2.readFileSync(indexMapPath, "utf-8"));
     const entry = indexMap[mainPlatformId];
     if (!entry || !entry.file) return null;
-    const basename3 = path.basename(entry.file).replace(/\.jsonl$/, "");
-    return basename3;
+    const basename4 = path2.basename(entry.file).replace(/\.jsonl$/, "");
+    return basename4;
   } catch {
     return null;
   }
 }
 function collectRecentSessions(agentsDir, _days = 7) {
   const files = [];
-  if (!fs.existsSync(agentsDir)) return files;
+  if (!fs2.existsSync(agentsDir)) return files;
   const sessionGroups = /* @__PURE__ */ new Map();
   function scanSessionsDir(dir) {
     try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      const entries = fs2.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
+        const fullPath = path2.join(dir, entry.name);
         if (entry.isDirectory()) {
           scanSessionsDir(fullPath);
           continue;
@@ -170,7 +170,7 @@ function collectRecentSessions(agentsDir, _days = 7) {
         if (entry.name.endsWith(".jsonl")) {
           group.jsonl = fullPath;
         } else {
-          const stat = fs.statSync(fullPath);
+          const stat = fs2.statSync(fullPath);
           group.archived.push({ file: fullPath, mtime: stat.mtimeMs });
         }
       }
@@ -189,37 +189,37 @@ function collectRecentSessions(agentsDir, _days = 7) {
 }
 async function doExport(opts) {
   const { agentName, stateDir, note, dryRun: dryRun2 } = opts;
-  const workspace = (opts.workspace || path.join(stateDir, "workspace")).replace(/[/\\]+$/, "");
-  const engineHome = path.join(os.homedir(), ".engine7").replace(/[/\\]+$/, "");
+  const workspace = (opts.workspace || path2.join(stateDir, "workspace")).replace(/[/\\]+$/, "");
+  const engineHome = path2.join(os2.homedir(), ".engine7").replace(/[/\\]+$/, "");
   console.log(`\u{1F4E6} engine7 export`);
   console.log(`   agent: ${agentName}`);
   console.log(`   state: ${stateDir}`);
   console.log(`   workspace: ${workspace}`);
-  if (!fs.existsSync(workspace)) {
+  if (!fs2.existsSync(workspace)) {
     console.error(`\u274C workspace \u4E0D\u5B58\u5728: ${workspace}`);
     process.exit(1);
   }
   const dirs = { workspace, stateDir, engineHome };
   const wsFiles = collectFiles(workspace, WORKSPACE_INCLUDE, WORKSPACE_OPTIONAL);
-  const sessionFiles = collectRecentSessions(path.join(stateDir, "agents"), 7);
-  const configsDir = path.join(stateDir, "configs");
+  const sessionFiles = collectRecentSessions(path2.join(stateDir, "agents"), 7);
+  const configsDir = path2.join(stateDir, "configs");
   const configFiles = [];
-  if (fs.existsSync(configsDir)) {
+  if (fs2.existsSync(configsDir)) {
     for (const f of collectAllFiles(configsDir)) {
-      if (shouldExclude(path.basename(f))) continue;
+      if (shouldExclude(path2.basename(f))) continue;
       configFiles.push(f);
     }
   }
   const EVEROS_SKIP = /* @__PURE__ */ new Set([".tmp", ".lock", "import.log", "import_progress.json"]);
-  const everosDir = path.join(stateDir, ".everos");
+  const everosDir = path2.join(stateDir, ".everos");
   const everosFiles = [];
-  if (fs.existsSync(everosDir)) {
+  if (fs2.existsSync(everosDir)) {
     for (const f of collectAllFiles(everosDir)) {
-      if (EVEROS_SKIP.has(path.basename(f))) continue;
+      if (EVEROS_SKIP.has(path2.basename(f))) continue;
       everosFiles.push(f);
     }
-    const walFile = path.join(everosDir, ".index", "sqlite", "system.db-wal");
-    if (fs.existsSync(walFile) && fs.statSync(walFile).size > 0) {
+    const walFile = path2.join(everosDir, ".index", "sqlite", "system.db-wal");
+    if (fs2.existsSync(walFile) && fs2.statSync(walFile).size > 0) {
       console.warn(`\u26A0\uFE0F  .everos/system.db-wal \u975E\u7A7A\u2014\u2014everos \u670D\u52A1\u53EF\u80FD\u6B63\u5728\u5199\u5165\uFF0C\u5FEB\u7167\u53EF\u80FD\u4E0D\u4E00\u81F4`);
       console.warn(`   \u5EFA\u8BAE: \u5148\u505C everos \u670D\u52A1\u518D export\uFF0C\u6216 import \u540E\u91CD\u5EFA\u7D22\u5F15`);
     }
@@ -227,16 +227,16 @@ async function doExport(opts) {
   console.log(`   workspace \u6587\u4EF6: ${wsFiles.length}`);
   console.log(`   session jsonl: ${sessionFiles.length} (\u6700\u8FD17\u5929)`);
   console.log(`   configs: ${configFiles.length}`);
-  console.log(`   everos: ${everosFiles.length} (${(everosFiles.reduce((s, f) => s + fs.statSync(f).size, 0) / 1024 / 1024).toFixed(1)} MB)`);
+  console.log(`   everos: ${everosFiles.length} (${(everosFiles.reduce((s, f) => s + fs2.statSync(f).size, 0) / 1024 / 1024).toFixed(1)} MB)`);
   if (dryRun2) {
     console.log(`
 [DRY RUN] \u4F1A\u6253\u5305\u4EE5\u4E0B\u6587\u4EF6:`);
-    wsFiles.slice(0, 20).forEach((f) => console.log(`   ${path.relative(workspace, f)}`));
+    wsFiles.slice(0, 20).forEach((f) => console.log(`   ${path2.relative(workspace, f)}`));
     if (wsFiles.length > 20) console.log(`   ... \u8FD8\u6709 ${wsFiles.length - 20} \u4E2A\u6587\u4EF6`);
     if (everosFiles.length > 0) {
       console.log(`
 [DRY RUN] everos (${everosFiles.length} \u6587\u4EF6):`);
-      everosFiles.slice(0, 10).forEach((f) => console.log(`   ${path.relative(stateDir, f)}`));
+      everosFiles.slice(0, 10).forEach((f) => console.log(`   ${path2.relative(stateDir, f)}`));
       if (everosFiles.length > 10) console.log(`   ... \u8FD8\u6709 ${everosFiles.length - 10} \u4E2A\u6587\u4EF6`);
     }
     console.log(`
@@ -245,46 +245,46 @@ async function doExport(opts) {
   }
   const now = /* @__PURE__ */ new Date();
   const version = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, "0")}${String(now.getDate()).padStart(2, "0")}-${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
-  const tmpDir = path.join(os.tmpdir(), `engine7-export-${agentName}-${version}`);
-  fs.mkdirSync(tmpDir, { recursive: true });
-  const stagingDir = path.join(tmpDir, agentName);
-  fs.mkdirSync(stagingDir, { recursive: true });
+  const tmpDir = path2.join(os2.tmpdir(), `engine7-export-${agentName}-${version}`);
+  fs2.mkdirSync(tmpDir, { recursive: true });
+  const stagingDir = path2.join(tmpDir, agentName);
+  fs2.mkdirSync(stagingDir, { recursive: true });
   let fileCount = 0;
   let totalSize = 0;
   let copyFail = 0;
   const copyOne = (srcFile, relRoot, destRoot) => {
-    const relPath = path.relative(relRoot, srcFile);
-    const destFile = path.join(destRoot, relPath);
-    fs.mkdirSync(path.dirname(destFile), { recursive: true });
+    const relPath = path2.relative(relRoot, srcFile);
+    const destFile = path2.join(destRoot, relPath);
+    fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
     try {
       if (isTextFile(srcFile)) {
-        const content = fs.readFileSync(srcFile, "utf-8");
-        fs.writeFileSync(destFile, sanitizeContent(content, dirs));
+        const content = fs2.readFileSync(srcFile, "utf-8");
+        fs2.writeFileSync(destFile, sanitizeContent(content, dirs));
       } else {
-        fs.copyFileSync(srcFile, destFile);
+        fs2.copyFileSync(srcFile, destFile);
       }
       fileCount++;
-      totalSize += fs.statSync(srcFile).size;
+      totalSize += fs2.statSync(srcFile).size;
     } catch (e) {
       copyFail++;
       console.warn(`   \u26A0\uFE0F \u62F7\u8D1D\u5931\u8D25: ${relPath} (${e.code || e.message})`);
     }
   };
-  for (const srcFile of wsFiles) copyOne(srcFile, workspace, path.join(stagingDir, "workspace"));
+  for (const srcFile of wsFiles) copyOne(srcFile, workspace, path2.join(stagingDir, "workspace"));
   for (const srcFile of sessionFiles) {
-    const relPath = path.relative(stateDir, srcFile);
-    const destFile = path.join(stagingDir, relPath);
-    fs.mkdirSync(path.dirname(destFile), { recursive: true });
+    const relPath = path2.relative(stateDir, srcFile);
+    const destFile = path2.join(stagingDir, relPath);
+    fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
     try {
-      let content = fs.readFileSync(srcFile, "utf-8");
+      let content = fs2.readFileSync(srcFile, "utf-8");
       content = sanitizeContent(content, dirs);
-      const baseName = path.basename(srcFile);
+      const baseName = path2.basename(srcFile);
       if (baseName === "session-index.json" || baseName === "platform-map.json") {
         content = content.split("\\\\").join("/");
       }
-      fs.writeFileSync(destFile, content);
+      fs2.writeFileSync(destFile, content);
       fileCount++;
-      totalSize += fs.statSync(srcFile).size;
+      totalSize += fs2.statSync(srcFile).size;
     } catch (e) {
       copyFail++;
       console.warn(`   \u26A0\uFE0F \u62F7\u8D1D\u5931\u8D25: ${relPath} (${e.code || e.message})`);
@@ -306,13 +306,13 @@ async function doExport(opts) {
     totalSize,
     note
   };
-  fs.writeFileSync(path.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-  const archiveFile = path.join(tmpDir, `${agentName}-${version}.tar.gz`);
+  fs2.writeFileSync(path2.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+  const archiveFile = path2.join(tmpDir, `${agentName}-${version}.tar.gz`);
   console.log(`
 \u{1F5DC}\uFE0F  \u6253\u5305\u4E2D...`);
   const tarExe = process.platform === "win32" ? "C:\\Windows\\System32\\tar.exe" : "tar";
   execSync(`"${tarExe}" -czf "${archiveFile}" -C "${tmpDir}" ${agentName}`, { stdio: "pipe" });
-  const archiveSize = fs.statSync(archiveFile).size;
+  const archiveSize = fs2.statSync(archiveFile).size;
   console.log(`\u2705 \u6253\u5305\u5B8C\u6210: ${archiveFile} (${(archiveSize / 1024 / 1024).toFixed(1)} MB, ${fileCount} \u6587\u4EF6${copyFail ? `, \u5931\u8D25 ${copyFail}` : ""})`);
   const cfg = loadTravelConfig();
   if (!cfg || !cfg.githubToken) {
@@ -335,8 +335,8 @@ async function doImport(opts) {
     console.error(`   \u914D\u7F6E: \u7F16\u8F91 ${CONFIG_PATH}`);
     process.exit(1);
   }
-  const tmpDir = path.join(os.tmpdir(), `engine7-import-${agentName}-${Date.now()}`);
-  fs.mkdirSync(tmpDir, { recursive: true });
+  const tmpDir = path2.join(os2.tmpdir(), `engine7-import-${agentName}-${Date.now()}`);
+  fs2.mkdirSync(tmpDir, { recursive: true });
   const archiveFile = await downloadFromGitHub(cfg, agentName, version, tmpDir);
   console.log(`\u2705 \u4E0B\u8F7D\u5B8C\u6210: ${archiveFile}`);
   if (dryRun2) {
@@ -347,99 +347,99 @@ async function doImport(opts) {
   console.log(`\u{1F4C2} \u89E3\u5305\u4E2D...`);
   const tarExe = process.platform === "win32" ? "C:\\Windows\\System32\\tar.exe" : "tar";
   execSync(`"${tarExe}" -xzf "${archiveFile}" -C "${tmpDir}"`, { stdio: "pipe" });
-  const stagingDir = path.join(tmpDir, agentName);
-  const manifestPath = path.join(stagingDir, "manifest.json");
-  if (!fs.existsSync(manifestPath)) {
+  const stagingDir = path2.join(tmpDir, agentName);
+  const manifestPath = path2.join(stagingDir, "manifest.json");
+  if (!fs2.existsSync(manifestPath)) {
     console.error(`\u274C manifest.json \u4E0D\u5B58\u5728\uFF0C\u6587\u4EF6\u53EF\u80FD\u635F\u574F`);
     process.exit(1);
   }
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-  const workspace = path.join(stateDir, "workspace").replace(/\\/g, "/").replace(/[/\\]+$/, "");
-  const engineHome = path.join(os.homedir(), ".engine7").replace(/\\/g, "/").replace(/[/\\]+$/, "");
+  const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
+  const workspace = path2.join(stateDir, "workspace").replace(/\\/g, "/").replace(/[/\\]+$/, "");
+  const engineHome = path2.join(os2.homedir(), ".engine7").replace(/\\/g, "/").replace(/[/\\]+$/, "");
   const dirs = { workspace, stateDir: stateDir.replace(/\\/g, "/").replace(/[/\\]+$/, ""), engineHome };
   console.log(`   \u7248\u672C: ${manifest.version}`);
   console.log(`   \u521B\u5EFA: ${manifest.createdAt}`);
   console.log(`   \u6587\u4EF6\u6570: ${manifest.fileCount}`);
-  const wsStaging = path.join(stagingDir, "workspace");
+  const wsStaging = path2.join(stagingDir, "workspace");
   let restoredCount = 0;
   let skipCount = 0;
-  if (fs.existsSync(wsStaging)) {
+  if (fs2.existsSync(wsStaging)) {
     const allFiles = collectAllFiles(wsStaging);
     for (const srcFile of allFiles) {
-      const relPath = path.relative(wsStaging, srcFile);
-      const destFile = path.join(workspace, relPath);
-      fs.mkdirSync(path.dirname(destFile), { recursive: true });
+      const relPath = path2.relative(wsStaging, srcFile);
+      const destFile = path2.join(workspace, relPath);
+      fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
       try {
         if (isTextFile(srcFile)) {
-          const content = fs.readFileSync(srcFile, "utf-8");
-          fs.writeFileSync(destFile, restoreContent(content, dirs));
+          const content = fs2.readFileSync(srcFile, "utf-8");
+          fs2.writeFileSync(destFile, restoreContent(content, dirs));
         } else {
-          fs.copyFileSync(srcFile, destFile);
+          fs2.copyFileSync(srcFile, destFile);
         }
         restoredCount++;
       } catch (e) {
         skipCount++;
-        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path.relative(wsStaging, srcFile)} (${e.code || e.message})`);
+        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path2.relative(wsStaging, srcFile)} (${e.code || e.message})`);
       }
     }
   }
-  const agentsStaging = path.join(stagingDir, "agents");
-  if (fs.existsSync(agentsStaging)) {
+  const agentsStaging = path2.join(stagingDir, "agents");
+  if (fs2.existsSync(agentsStaging)) {
     const sessionFiles = collectAllFiles(agentsStaging);
     for (const srcFile of sessionFiles) {
-      const relPath = path.relative(stagingDir, srcFile);
-      const destFile = path.join(stateDir, relPath);
-      fs.mkdirSync(path.dirname(destFile), { recursive: true });
-      const content = fs.readFileSync(srcFile, "utf-8");
-      fs.writeFileSync(destFile, restoreContent(content, dirs));
+      const relPath = path2.relative(stagingDir, srcFile);
+      const destFile = path2.join(stateDir, relPath);
+      fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
+      const content = fs2.readFileSync(srcFile, "utf-8");
+      fs2.writeFileSync(destFile, restoreContent(content, dirs));
       restoredCount++;
     }
   }
-  const configsStaging = path.join(stagingDir, "configs");
-  if (fs.existsSync(configsStaging)) {
+  const configsStaging = path2.join(stagingDir, "configs");
+  if (fs2.existsSync(configsStaging)) {
     const cfgFiles = collectAllFiles(configsStaging);
     for (const srcFile of cfgFiles) {
-      const relPath = path.relative(stagingDir, srcFile);
-      const destFile = path.join(stateDir, relPath);
-      fs.mkdirSync(path.dirname(destFile), { recursive: true });
+      const relPath = path2.relative(stagingDir, srcFile);
+      const destFile = path2.join(stateDir, relPath);
+      fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
       if (isTextFile(srcFile)) {
-        const content = fs.readFileSync(srcFile, "utf-8");
-        fs.writeFileSync(destFile, restoreContent(content, dirs));
+        const content = fs2.readFileSync(srcFile, "utf-8");
+        fs2.writeFileSync(destFile, restoreContent(content, dirs));
       } else {
-        fs.copyFileSync(srcFile, destFile);
+        fs2.copyFileSync(srcFile, destFile);
       }
       restoredCount++;
     }
   }
-  const everosStaging = path.join(stagingDir, ".everos");
-  if (fs.existsSync(everosStaging)) {
+  const everosStaging = path2.join(stagingDir, ".everos");
+  if (fs2.existsSync(everosStaging)) {
     const everosFiles = collectAllFiles(everosStaging);
     for (const srcFile of everosFiles) {
-      const relPath = path.relative(stagingDir, srcFile);
-      const destFile = path.join(stateDir, relPath);
-      fs.mkdirSync(path.dirname(destFile), { recursive: true });
+      const relPath = path2.relative(stagingDir, srcFile);
+      const destFile = path2.join(stateDir, relPath);
+      fs2.mkdirSync(path2.dirname(destFile), { recursive: true });
       try {
         if (isTextFile(srcFile)) {
-          const content = fs.readFileSync(srcFile, "utf-8");
-          fs.writeFileSync(destFile, restoreContent(content, dirs));
+          const content = fs2.readFileSync(srcFile, "utf-8");
+          fs2.writeFileSync(destFile, restoreContent(content, dirs));
         } else {
-          fs.copyFileSync(srcFile, destFile);
+          fs2.copyFileSync(srcFile, destFile);
         }
         restoredCount++;
       } catch (e) {
         skipCount++;
-        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path.relative(everosStaging, srcFile)} (${e.code || e.message})`);
+        console.log(`   \u26A0\uFE0F \u8DF3\u8FC7: ${path2.relative(everosStaging, srcFile)} (${e.code || e.message})`);
       }
     }
     console.log(`   everos: ${everosFiles.length} \u6587\u4EF6\u5DF2\u6062\u590D`);
   }
   console.log(`\u2705 \u6062\u590D\u5B8C\u6210: ${restoredCount} \u6587\u4EF6 \u2192 ${stateDir}${skipCount ? ` (\u8DF3\u8FC7 ${skipCount})` : ""}`);
   const platformConfigName = process.platform === "darwin" ? "xiaoke-mac.json" : "xiaoke-win.json";
-  const restoredConfigPath = path.join(stateDir, "configs", platformConfigName);
-  const configToUse = fs.existsSync(restoredConfigPath) ? restoredConfigPath : path.join(stateDir, "configs", "xiaoke.json");
+  const restoredConfigPath = path2.join(stateDir, "configs", platformConfigName);
+  const configToUse = fs2.existsSync(restoredConfigPath) ? restoredConfigPath : path2.join(stateDir, "configs", "xiaoke.json");
   console.log(`
 \u{1F4A1} \u4E0B\u4E00\u6B65: engine7 start --config "${configToUse}"`);
-  fs.rmSync(tmpDir, { recursive: true, force: true });
+  fs2.rmSync(tmpDir, { recursive: true, force: true });
 }
 async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
   const repo = `${cfg.githubOwner}/${cfg.repoName}`;
@@ -469,8 +469,8 @@ async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
     }
     const release = await createRes.json();
     const uploadUrl = release.upload_url.replace("{?name,label}", "");
-    const fileBuffer = fs.readFileSync(archiveFile);
-    const fileName = path.basename(archiveFile);
+    const fileBuffer = fs2.readFileSync(archiveFile);
+    const fileName = path2.basename(archiveFile);
     const uploadRes = await fetch(`${uploadUrl}?name=${fileName}`, {
       method: "POST",
       headers: {
@@ -493,7 +493,7 @@ async function uploadToGitHub(cfg, archiveFile, agentName, version, manifest) {
     throw e;
   }
   try {
-    fs.rmSync(path.dirname(archiveFile), { recursive: true, force: true });
+    fs2.rmSync(path2.dirname(archiveFile), { recursive: true, force: true });
   } catch {
   }
 }
@@ -525,8 +525,8 @@ async function downloadFromGitHub(cfg, agentName, version, destDir) {
     throw new Error(`\u4E0B\u8F7D asset \u5931\u8D25: ${downloadRes.status}`);
   }
   const buffer = Buffer.from(await downloadRes.arrayBuffer());
-  const archiveFile = path.join(destDir, asset.name);
-  fs.writeFileSync(archiveFile, buffer);
+  const archiveFile = path2.join(destDir, asset.name);
+  fs2.writeFileSync(archiveFile, buffer);
   return archiveFile;
 }
 async function getLatestReleaseTag(cfg, agentName) {
@@ -551,7 +551,7 @@ var CONFIG_PATH, PATH_PLACEHOLDERS, WORKSPACE_INCLUDE, WORKSPACE_OPTIONAL, WORKS
 var init_cli_travel = __esm({
   "src/cli-travel.ts"() {
     "use strict";
-    CONFIG_PATH = path.join(os.homedir(), ".engine7-travel.json");
+    CONFIG_PATH = path2.join(os2.homedir(), ".engine7-travel.json");
     PATH_PLACEHOLDERS = [
       { placeholder: "{{WORKSPACE}}", getOriginal: (d) => d.workspace },
       { placeholder: "{{ENGINE_HOME}}", getOriginal: (d) => d.engineHome },
@@ -624,8 +624,8 @@ var init_cli_travel = __esm({
 });
 
 // src/cli-init.ts
-import * as path2 from "node:path";
-import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import * as fs3 from "node:fs";
 import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
 
@@ -743,6 +743,128 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
+// src/channels/wechat.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var ILINK_BASE_URL = "https://ilinkai.weixin.qq.com";
+var ILINK_APP_CLIENT_VERSION = 2 << 16 | 2 << 8 | 0;
+var EP_GET_BOT_QR = "ilink/bot/get_bot_qrcode";
+var EP_GET_QR_STATUS = "ilink/bot/get_qrcode_status";
+var QR_TIMEOUT_MS = 15e3;
+async function wechatQrLogin(options) {
+  const botType = options?.botType || "3";
+  const timeoutSeconds = options?.timeoutSeconds || 480;
+  const stateDir = options?.stateDir || path.join(os.homedir?.() || "/tmp", ".engine7");
+  console.log("[wechat] Fetching QR code from iLink...");
+  let qrResp;
+  try {
+    qrResp = await apiGet(ILINK_BASE_URL, `${EP_GET_BOT_QR}?bot_type=${botType}`, "", QR_TIMEOUT_MS);
+  } catch (err) {
+    console.error(`[wechat] Failed to fetch QR code: ${err.message}`);
+    return null;
+  }
+  const qrcodeValue = String(qrResp?.qrcode || "");
+  const qrcodeUrl = String(qrResp?.qrcode_img_content || "");
+  if (!qrcodeValue) {
+    console.error("[wechat] QR response missing qrcode field");
+    return null;
+  }
+  const qrScanData = qrcodeUrl || qrcodeValue;
+  console.log("\n========== \u5FAE\u4FE1\u626B\u7801\u767B\u5F55 ==========");
+  if (qrcodeUrl) {
+    console.log(`\u626B\u7801\u94FE\u63A5: ${qrcodeUrl}`);
+  }
+  console.log("\u8BF7\u7528\u5FAE\u4FE1\u626B\u63CF\u4E8C\u7EF4\u7801\uFF08\u6216\u6253\u5F00\u4E0A\u9762\u7684\u94FE\u63A5\uFF09:");
+  console.log("===================================\n");
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  let currentBaseUrl = ILINK_BASE_URL;
+  let refreshCount = 0;
+  while (Date.now() < deadline) {
+    let statusResp;
+    try {
+      statusResp = await apiGet(currentBaseUrl, `${EP_GET_QR_STATUS}?qrcode=${qrcodeValue}`, "", QR_TIMEOUT_MS);
+    } catch {
+      await sleep2(1e3);
+      continue;
+    }
+    const status = String(statusResp?.status || "wait");
+    if (status === "wait") {
+      process.stdout.write(".");
+    } else if (status === "scaned") {
+      console.log("\n\u5DF2\u626B\u7801\uFF0C\u8BF7\u5728\u5FAE\u4FE1\u91CC\u786E\u8BA4...");
+    } else if (status === "scaned_but_redirect") {
+      const redirectHost = String(statusResp?.redirect_host || "");
+      if (redirectHost) currentBaseUrl = `https://${redirectHost}`;
+    } else if (status === "expired") {
+      refreshCount++;
+      if (refreshCount > 3) {
+        console.log("\n\u4E8C\u7EF4\u7801\u591A\u6B21\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C\u767B\u5F55\u3002");
+        return null;
+      }
+      console.log(`
+\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F\uFF0C\u5237\u65B0\u4E2D... (${refreshCount}/3)`);
+      try {
+        qrResp = await apiGet(ILINK_BASE_URL, `${EP_GET_BOT_QR}?bot_type=${botType}`, "", QR_TIMEOUT_MS);
+        const newQrValue = String(qrResp?.qrcode || "");
+        const newQrUrl = String(qrResp?.qrcode_img_content || "");
+        if (newQrUrl) console.log(`\u65B0\u626B\u7801\u94FE\u63A5: ${newQrUrl}`);
+      } catch (err) {
+        console.error(`[wechat] QR refresh failed: ${err.message}`);
+        return null;
+      }
+    } else if (status === "confirmed") {
+      const accountId = String(statusResp?.ilink_bot_id || "");
+      const token = String(statusResp?.bot_token || "");
+      const baseUrl = String(statusResp?.baseurl || ILINK_BASE_URL);
+      const userId = String(statusResp?.ilink_user_id || "");
+      if (!accountId || !token) {
+        console.error("[wechat] QR confirmed but credential payload incomplete");
+        return null;
+      }
+      if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
+      const credFile = path.join(stateDir, `weixin-${accountId}.json`);
+      fs.writeFileSync(credFile, JSON.stringify({ accountId, token, baseUrl, userId }, null, 2), "utf8");
+      console.log(`
+\u2705 \u5FAE\u4FE1\u767B\u5F55\u6210\u529F!`);
+      console.log(`   accountId: ${accountId}`);
+      console.log(`   \u51ED\u8BC1\u5DF2\u4FDD\u5B58: ${credFile}`);
+      console.log(`
+\u8BF7\u5C06\u4EE5\u4E0B\u914D\u7F6E\u6DFB\u52A0\u5230 xiaoke.json:`);
+      console.log(JSON.stringify({
+        wechat: {
+          token,
+          accountId,
+          baseUrl: baseUrl !== ILINK_BASE_URL ? baseUrl : void 0
+        }
+      }, null, 2));
+      return { accountId, token, baseUrl, userId };
+    }
+    await sleep2(1e3);
+  }
+  console.log("\n[wechat] QR login timed out");
+  return null;
+}
+async function apiGet(baseUrl, endpoint, _token, timeoutMs) {
+  const url = `${baseUrl.replace(/\/$/, "")}/${endpoint.replace(/^\//, "")}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const resp = await fetch(url, {
+      method: "GET",
+      signal: controller.signal,
+      headers: { "Accept": "application/json" }
+    });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    return await resp.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // src/qr-render.ts
 import { createRequire } from "node:module";
 var require2 = createRequire(import.meta.url);
@@ -761,7 +883,7 @@ async function renderQrTerminal(url, options) {
 
 // src/cli-init.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path2.dirname(__filename);
+var __dirname = path3.dirname(__filename);
 var SCHEMA_VERSION = 1;
 function parseArgs() {
   const args = process.argv.slice(2);
@@ -786,10 +908,10 @@ function parseArgs() {
     }
   }
   if (!stateDir) {
-    stateDir = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+    stateDir = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
     console.log(`   \u4F7F\u7528\u9ED8\u8BA4\u76EE\u5F55: ${stateDir}`);
   }
-  stateDir = path2.resolve(stateDir);
+  stateDir = path3.resolve(stateDir);
   return { stateDir, quick, dryRun: dryRun2, force };
 }
 function printHelp() {
@@ -860,6 +982,7 @@ function getDefaultValues(stateDir) {
     stateDir,
     agentName: "Agent",
     primaryProvider: "dashscope",
+    zhipuPlan: "",
     primaryApiKey: "",
     primaryModel: "dashscope/qwen3.7-max",
     visionModel: "dashscope/qwen3.7-max",
@@ -870,6 +993,9 @@ function getDefaultValues(stateDir) {
     feishuAppId: "",
     feishuAppSecret: "",
     feishuOpenId: "",
+    wechatEnabled: false,
+    wechatToken: "",
+    wechatAccountId: "",
     tavilyKey: "",
     apiPort: 16990
   };
@@ -887,6 +1013,12 @@ async function interactiveConfig(rl, defaults) {
   };
   const chosenProvider = await askChoice(rl, "\u4E3B\u6A21\u578B Provider:", providers, 0);
   v.primaryProvider = providerMap[chosenProvider] || "dashscope";
+  v.zhipuPlan = "";
+  if (v.primaryProvider === "zhipu") {
+    const planOptions = ["coding-plan (GLM Coding \u8BA2\u9605)", "token-plan (\u666E\u901A\u6309\u91CF/TokenPlan)"];
+    const chosenPlan = await askChoice(rl, "\u667A\u8C31\u8BA2\u9605\u7C7B\u578B:", planOptions, 0);
+    v.zhipuPlan = chosenPlan.startsWith("coding") ? "coding" : "token";
+  }
   const keyMap = {
     dashscope: "DashScope API Key",
     minimax: "MiniMax API Key",
@@ -974,6 +1106,44 @@ async function interactiveConfig(rl, defaults) {
       v.feishuOpenId = await ask(rl, "\u4F60\u7684\u98DE\u4E66 open_id\uFF08\u56DE\u8F66\u8DF3\u8FC7\uFF09", "");
     }
   }
+  const wechatAns = await ask(rl, "\u542F\u7528\u5FAE\u4FE1? (y/n)", "n");
+  v.wechatEnabled = wechatAns.toLowerCase() === "y";
+  if (v.wechatEnabled) {
+    console.log("\n  \u5FAE\u4FE1\u63A5\u5165\u65B9\u5F0F\uFF1A");
+    console.log("  1. \u626B\u7801\u7ED1\u5B9A\uFF08\u63A8\u8350\uFF0C\u7528\u4F60\u81EA\u5DF1\u7684\u5FAE\u4FE1\u626B\u4E00\u4E0B\u5C31\u884C\uFF09");
+    console.log("  2. \u624B\u52A8\u8F93\u5165 token\uFF08\u5DF2\u6709\u51ED\u8BC1\u65F6\uFF09");
+    const wechatMode = await ask(rl, "\u9009\u62E9 (1/2)", "1");
+    if (wechatMode === "1") {
+      console.log("\n\u{1F4DD} \u6B63\u5728\u751F\u6210\u5FAE\u4FE1\u4E8C\u7EF4\u7801...\n");
+      console.log("  \u63D0\u793A\uFF1A\u4E00\u4E2A\u5FAE\u4FE1\u53F7\u53EA\u80FD\u7ED1\u4E00\u4E2A bot\uFF1Bbot \u4E0D\u8FDB\u7FA4\uFF08\u817E\u8BAF\u9650\u5236\uFF09\uFF0C\u79C1\u804A 1v1");
+      const cred = await wechatQrLogin({ timeoutSeconds: 300, stateDir: v.stateDir });
+      if (cred) {
+        v.wechatToken = cred.token;
+        v.wechatAccountId = cred.accountId;
+        console.log(`
+  \u2705 accountId: ${cred.accountId}`);
+        console.log(`  \u2705 \u51ED\u8BC1\u5DF2\u81EA\u52A8\u4FDD\u5B58\uFF0Cconfig \u5C06\u81EA\u52A8\u5199\u5165`);
+      } else {
+        console.log("\n  \u26A0\uFE0F \u626B\u7801\u8D85\u65F6\u6216\u5931\u8D25");
+        const retry = await ask(rl, "\u91CD\u8BD5\u626B\u7801? (y/n)", "y");
+        if (retry.toLowerCase() === "y") {
+          const cred2 = await wechatQrLogin({ timeoutSeconds: 300, stateDir: v.stateDir });
+          if (cred2) {
+            v.wechatToken = cred2.token;
+            v.wechatAccountId = cred2.accountId;
+          } else {
+            console.log("\n  \u26A0\uFE0F \u518D\u6B21\u5931\u8D25\uFF0C\u8DF3\u8FC7\u5FAE\u4FE1\uFF08\u4E4B\u540E\u53EF\u624B\u52A8\u914D\u7F6E\uFF09");
+            v.wechatEnabled = false;
+          }
+        } else {
+          v.wechatEnabled = false;
+        }
+      }
+    } else {
+      v.wechatToken = await ask(rl, "\u5FAE\u4FE1 token");
+      v.wechatAccountId = await ask(rl, "\u5FAE\u4FE1 accountId");
+    }
+  }
   const tavilyKey = await ask(rl, "Tavily API Key\uFF08\u8054\u7F51\u641C\u7D22\uFF0C\u56DE\u8F66\u8DF3\u8FC7\uFF09", "");
   v.tavilyKey = tavilyKey;
   const portAns = await ask(rl, "API \u7AEF\u53E3", String(defaults.apiPort));
@@ -981,7 +1151,7 @@ async function interactiveConfig(rl, defaults) {
   return v;
 }
 function generateConfig(v) {
-  const workspace = path2.join(v.stateDir, "workspace").replace(/\\/g, "/");
+  const workspace = path3.join(v.stateDir, "workspace").replace(/\\/g, "/");
   const config = {
     schemaVersion: SCHEMA_VERSION,
     stateDir: v.stateDir.replace(/\\/g, "/"),
@@ -1041,7 +1211,16 @@ function generateConfig(v) {
         connectionMode: "websocket",
         dmPolicy: "pairing",
         groupPolicy: "open"
-      }
+      },
+      ...v.wechatEnabled && v.wechatToken ? {
+        wechat: {
+          enabled: true,
+          token: v.wechatToken,
+          accountId: v.wechatAccountId,
+          dmPolicy: "pairing",
+          group: { policy: "disabled" }
+        }
+      } : {}
     },
     api: { port: v.apiPort },
     prompt: {
@@ -1080,7 +1259,7 @@ function generateConfig(v) {
       ]
     },
     zhipu: {
-      baseUrl: "https://open.bigmodel.cn/api/coding/paas/v4 ",
+      baseUrl: "https://open.bigmodel.cn/api/coding/paas/v4",
       api: "openai-completions",
       models: [
         { id: "glm-5.1", name: "GLM-5.1", reasoning: true, input: ["text"], contextWindow: 204800, maxTokens: 131072 },
@@ -1098,8 +1277,12 @@ function generateConfig(v) {
     }
   };
   if (providerDefs[v.primaryProvider]) {
+    const def = { ...providerDefs[v.primaryProvider] };
+    if (v.primaryProvider === "zhipu" && v.zhipuPlan === "token") {
+      def.baseUrl = "https://open.bigmodel.cn/api/paas/v4";
+    }
     config.models.providers[v.primaryProvider] = {
-      ...providerDefs[v.primaryProvider],
+      ...def,
       apiKey: v.primaryApiKey
     };
   }
@@ -1107,45 +1290,45 @@ function generateConfig(v) {
 }
 function buildDirTree(v) {
   const d = v.stateDir;
-  const w = path2.join(d, "workspace");
+  const w = path3.join(d, "workspace");
   const now = (/* @__PURE__ */ new Date()).toLocaleString("sv-SE", { timeZone: "Asia/Shanghai", hour12: false });
   return [
     // 目录
-    { path: path2.join(d, "configs"), type: "dir" },
-    { path: path2.join(d, "state", "agents", "main", "sessions"), type: "dir" },
-    { path: path2.join(w, "prompts"), type: "dir" },
-    { path: path2.join(w, "memory", "daily"), type: "dir" },
-    { path: path2.join(w, "docs", "research"), type: "dir" },
-    { path: path2.join(w, "docs", "todo"), type: "dir" },
-    { path: path2.join(w, "docs", "decisions"), type: "dir" },
-    { path: path2.join(w, "docs", "knowledge"), type: "dir" },
-    { path: path2.join(w, "docs", "sop"), type: "dir" },
-    { path: path2.join(d, "logs"), type: "dir" },
-    { path: path2.join(d, "media", "inbound"), type: "dir" },
+    { path: path3.join(d, "configs"), type: "dir" },
+    { path: path3.join(d, "state", "agents", "main", "sessions"), type: "dir" },
+    { path: path3.join(w, "prompts"), type: "dir" },
+    { path: path3.join(w, "memory", "daily"), type: "dir" },
+    { path: path3.join(w, "docs", "research"), type: "dir" },
+    { path: path3.join(w, "docs", "todo"), type: "dir" },
+    { path: path3.join(w, "docs", "decisions"), type: "dir" },
+    { path: path3.join(w, "docs", "knowledge"), type: "dir" },
+    { path: path3.join(w, "docs", "sop"), type: "dir" },
+    { path: path3.join(d, "logs"), type: "dir" },
+    { path: path3.join(d, "media", "inbound"), type: "dir" },
     // workspace 文件
     {
-      path: path2.join(w, "SESSION-STATE.md"),
+      path: path3.join(w, "SESSION-STATE.md"),
       type: "file",
       content: readTemplate("workspace/SESSION-STATE.md").replace("{{CURRENT_TIME}}", now)
     },
-    { path: path2.join(w, "HEARTBEAT.md"), type: "file", content: readTemplate("workspace/HEARTBEAT.md") },
+    { path: path3.join(w, "HEARTBEAT.md"), type: "file", content: readTemplate("workspace/HEARTBEAT.md") },
     {
-      path: path2.join(w, "SOUL.md"),
+      path: path3.join(w, "SOUL.md"),
       type: "file",
       content: readTemplate("workspace/SOUL.md").replace(/\{\{AGENT_NAME\}\}/g, v.agentName)
     },
-    { path: path2.join(w, "AGENTS.md"), type: "file", content: readTemplate("workspace/AGENTS.md") },
+    { path: path3.join(w, "AGENTS.md"), type: "file", content: readTemplate("workspace/AGENTS.md") },
     {
-      path: path2.join(w, "prompts", "contacts.md"),
+      path: path3.join(w, "prompts", "contacts.md"),
       type: "file",
       content: readTemplate("workspace/prompts/contacts.md").replace("{{DISCORD_USER_ID}}", v.discordUserId || "YOUR_DISCORD_ID").replace("{{FEISHU_OPEN_ID}}", v.feishuOpenId || "YOUR_FEISHU_OPEN_ID")
     },
-    { path: path2.join(w, "prompts", "auto-memory-instructions.md"), type: "file", content: readTemplate("workspace/prompts/auto-memory-instructions.md") },
-    { path: path2.join(w, "MEMORY.md"), type: "file", content: "# MEMORY.md \u2014 \u8BB0\u5FC6\u6587\u4EF6\u7D22\u5F15\n\n> \u6700\u540E\u66F4\u65B0\uFF1A\u521D\u59CB\u5316\n" },
-    { path: path2.join(w, "USER.md"), type: "file", content: "# USER.md \u2014 \u7528\u6237\u4FE1\u606F\n\n\uFF08\u5728\u8FD9\u91CC\u8BB0\u5F55\u7528\u6237\u7684\u504F\u597D\u3001\u80CC\u666F\u7B49\uFF09\n" },
+    { path: path3.join(w, "prompts", "auto-memory-instructions.md"), type: "file", content: readTemplate("workspace/prompts/auto-memory-instructions.md") },
+    { path: path3.join(w, "MEMORY.md"), type: "file", content: "# MEMORY.md \u2014 \u8BB0\u5FC6\u6587\u4EF6\u7D22\u5F15\n\n> \u6700\u540E\u66F4\u65B0\uFF1A\u521D\u59CB\u5316\n" },
+    { path: path3.join(w, "USER.md"), type: "file", content: "# USER.md \u2014 \u7528\u6237\u4FE1\u606F\n\n\uFF08\u5728\u8FD9\u91CC\u8BB0\u5F55\u7528\u6237\u7684\u504F\u597D\u3001\u80CC\u666F\u7B49\uFF09\n" },
     // package.json — 让 agent 目录成为独立 npm 项目根，防止 npm hoisting
     {
-      path: path2.join(d, "package.json"),
+      path: path3.join(d, "package.json"),
       type: "file",
       content: JSON.stringify({
         name: v.agentName.toLowerCase().replace(/[^a-z0-9-]/g, "-") || "agent",
@@ -1156,7 +1339,7 @@ function buildDirTree(v) {
     },
     // 启动脚本（根据 OS 生成）
     ...process.platform === "win32" ? [{
-      path: path2.join(d, "start.cmd"),
+      path: path3.join(d, "start.cmd"),
       type: "file",
       content: `@echo off
 rem Engine 7 startup script
@@ -1188,7 +1371,7 @@ if %ERRORLEVEL% NEQ 0 (
 )
 `
     }] : [{
-      path: path2.join(d, "start.sh"),
+      path: path3.join(d, "start.sh"),
       type: "file",
       content: `#!/bin/bash
 # Engine 7 startup script
@@ -1221,13 +1404,13 @@ node "$ENGINE7_BIN" --engine-config configs/main7.json
 }
 function readTemplate(relativePath) {
   const candidates = [
-    path2.join(__dirname, "..", "templates", relativePath),
-    path2.join(__dirname, "..", "..", "templates", relativePath),
-    path2.join(process.cwd(), "templates", relativePath)
+    path3.join(__dirname, "..", "templates", relativePath),
+    path3.join(__dirname, "..", "..", "templates", relativePath),
+    path3.join(process.cwd(), "templates", relativePath)
   ];
   for (const p of candidates) {
-    if (fs2.existsSync(p)) {
-      return fs2.readFileSync(p, "utf-8");
+    if (fs3.existsSync(p)) {
+      return fs3.readFileSync(p, "utf-8");
     }
   }
   throw new Error(`\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${relativePath}\uFF08\u627E\u4E86: ${candidates.join(", ")}\uFF09`);
@@ -1242,11 +1425,11 @@ function dryRun(entries) {
 function execute(entries) {
   for (const e of entries) {
     if (e.type === "dir") {
-      fs2.mkdirSync(e.path, { recursive: true });
+      fs3.mkdirSync(e.path, { recursive: true });
       console.log(`  \u{1F4C1} ${e.path}`);
     } else {
-      fs2.mkdirSync(path2.dirname(e.path), { recursive: true });
-      fs2.writeFileSync(e.path, e.content || "", "utf-8");
+      fs3.mkdirSync(path3.dirname(e.path), { recursive: true });
+      fs3.writeFileSync(e.path, e.content || "", "utf-8");
       console.log(`  \u{1F4C4} ${e.path}`);
     }
   }
@@ -1274,8 +1457,8 @@ async function main() {
       else if (args[i] === "--note" && args[i + 1]) note = args[++i];
       else if (args[i] === "--dry-run") dryRun2 = true;
     }
-    if (!exportStateDir) exportStateDir = path2.resolve(process.cwd());
-    if (!agentName) agentName = path2.basename(exportStateDir);
+    if (!exportStateDir) exportStateDir = path3.resolve(process.cwd());
+    if (!agentName) agentName = path3.basename(exportStateDir);
     await doExport2({ agentName, stateDir: exportStateDir, note, dryRun: dryRun2 });
     process.exit(0);
   }
@@ -1295,7 +1478,7 @@ async function main() {
       console.error("\u274C import \u9700\u8981 --state-dir <path>");
       process.exit(1);
     }
-    if (!agentName) agentName = path2.basename(importStateDir);
+    if (!agentName) agentName = path3.basename(importStateDir);
     await doImport2({ agentName, stateDir: importStateDir, version, dryRun: dryRun2 });
     process.exit(0);
   }
@@ -1320,18 +1503,18 @@ engine7 start \u2014 \u542F\u52A8 Engine
       }
     }
     if (!configPath2) {
-      const defaultCfg = path2.join("configs", "main7.json");
-      const homeCfg = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
-      if (fs2.existsSync(defaultCfg)) {
+      const defaultCfg = path3.join("configs", "main7.json");
+      const homeCfg = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
+      if (fs3.existsSync(defaultCfg)) {
         configPath2 = defaultCfg;
-      } else if (fs2.existsSync(homeCfg)) {
+      } else if (fs3.existsSync(homeCfg)) {
         configPath2 = homeCfg;
         console.log(`   \u4F7F\u7528\u9ED8\u8BA4 config: ${homeCfg}`);
       } else {
         const ptr = readHomePointer();
         if (ptr?.stateDir) {
-          const ptrCfg = path2.join(ptr.stateDir, "configs", "main7.json");
-          if (fs2.existsSync(ptrCfg)) {
+          const ptrCfg = path3.join(ptr.stateDir, "configs", "main7.json");
+          if (fs3.existsSync(ptrCfg)) {
             configPath2 = ptrCfg;
             console.log(`   \u4F7F\u7528 config: ${ptrCfg}`);
           }
@@ -1346,19 +1529,19 @@ engine7 start \u2014 \u542F\u52A8 Engine
     }
     const { execSync: execSync2, spawn } = await import("node:child_process");
     let enginePath;
-    const localPath = path2.join("node_modules", "engine7", "dist", "main.mjs");
-    if (fs2.existsSync(localPath)) {
+    const localPath = path3.join("node_modules", "engine7", "dist", "main.mjs");
+    if (fs3.existsSync(localPath)) {
       enginePath = localPath;
     } else {
-      const cliPath = path2.resolve(process.argv[1]);
-      const distDir = path2.dirname(cliPath);
-      const candidate = path2.join(distDir, "main.mjs");
-      if (fs2.existsSync(candidate)) {
+      const cliPath = path3.resolve(process.argv[1]);
+      const distDir = path3.dirname(cliPath);
+      const candidate = path3.join(distDir, "main.mjs");
+      if (fs3.existsSync(candidate)) {
         enginePath = candidate;
       } else {
         try {
           const globalRoot = execSync2("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-          enginePath = path2.join(globalRoot, "engine7", "dist", "main.mjs");
+          enginePath = path3.join(globalRoot, "engine7", "dist", "main.mjs");
         } catch {
           console.error("\u274C \u627E\u4E0D\u5230 engine7 main.mjs");
           process.exit(1);
@@ -1368,7 +1551,7 @@ engine7 start \u2014 \u542F\u52A8 Engine
     console.log(label);
     console.log(`   config: ${configPath2}`);
     console.log(`   engine: ${enginePath}`);
-    const configName = path2.basename(configPath2);
+    const configName = path3.basename(configPath2);
     const myPid = process.pid;
     try {
       if (process.platform === "win32") {
@@ -1386,16 +1569,16 @@ engine7 start \u2014 \u542F\u52A8 Engine
     }
     console.log("");
     const envForChild = { ...process.env };
-    const secretsDir = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
-    const cfgBase = path2.basename(configPath2, ".json");
+    const secretsDir = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7-secrets");
+    const cfgBase = path3.basename(configPath2, ".json");
     const secretCandidates = [
-      path2.join(secretsDir, `${cfgBase}.env`),
-      path2.join(path2.dirname(configPath2), `.env.${cfgBase}`),
-      path2.join(path2.dirname(configPath2), ".env")
+      path3.join(secretsDir, `${cfgBase}.env`),
+      path3.join(path3.dirname(configPath2), `.env.${cfgBase}`),
+      path3.join(path3.dirname(configPath2), ".env")
     ];
     for (const secretPath of secretCandidates) {
-      if (fs2.existsSync(secretPath)) {
-        const content = fs2.readFileSync(secretPath, "utf-8");
+      if (fs3.existsSync(secretPath)) {
+        const content = fs3.readFileSync(secretPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -1469,14 +1652,14 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
         console.error(`\u274C \u672A\u77E5\u6A21\u5F0F: ${mode}\uFF08\u53EF\u9009: archive / drop-last / strip-images\uFF09`);
         process.exit(1);
       }
-      const configRaw = JSON.parse(fs2.readFileSync(configPath2, "utf-8"));
+      const configRaw = JSON.parse(fs3.readFileSync(configPath2, "utf-8"));
       const stateDir = configRaw.stateDir;
       if (!stateDir) {
         console.error("\u274C config \u91CC\u6CA1\u6709 stateDir");
         process.exit(1);
       }
-      const sessionsDir = path2.join(stateDir, "agents", "main", "sessions");
-      if (!fs2.existsSync(sessionsDir)) {
+      const sessionsDir = path3.join(stateDir, "agents", "main", "sessions");
+      if (!fs3.existsSync(sessionsDir)) {
         console.error(`\u274C sessions \u76EE\u5F55\u4E0D\u5B58\u5728: ${sessionsDir}`);
         process.exit(1);
       }
@@ -1484,37 +1667,37 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
       console.log(`   config: ${configPath2}`);
       console.log(`   mode:   ${mode}`);
       if (mode === "drop-last") console.log(`   n:      ${dropN}`);
-      const platformMapPath = path2.join(sessionsDir, "platform-map.json");
-      const indexPath = path2.join(sessionsDir, "session-index.json");
+      const platformMapPath = path3.join(sessionsDir, "platform-map.json");
+      const indexPath = path3.join(sessionsDir, "session-index.json");
       let sessionFileUUID = null;
-      if (fs2.existsSync(indexPath)) {
-        const index = JSON.parse(fs2.readFileSync(indexPath, "utf-8"));
+      if (fs3.existsSync(indexPath)) {
+        const index = JSON.parse(fs3.readFileSync(indexPath, "utf-8"));
         const entries = Object.values(index);
         if (entries.length > 0) {
           const fileVal = entries[0].file || "";
-          sessionFileUUID = path2.isAbsolute(fileVal) ? path2.basename(fileVal, ".jsonl") : fileVal.replace(".jsonl", "");
+          sessionFileUUID = path3.isAbsolute(fileVal) ? path3.basename(fileVal, ".jsonl") : fileVal.replace(".jsonl", "");
         }
       }
       if (!sessionFileUUID) {
-        const jsonlFiles = fs2.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs2.statSync(path2.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+        const jsonlFiles = fs3.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs3.statSync(path3.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
         if (jsonlFiles.length === 0) {
           console.error("\u274C \u627E\u4E0D\u5230\u6D3B\u8DC3\u7684 session JSONL \u6587\u4EF6");
           process.exit(1);
         }
         sessionFileUUID = jsonlFiles[0].name.replace(".jsonl", "");
       }
-      let jsonlPath = path2.join(sessionsDir, `${sessionFileUUID}.jsonl`);
-      if (!fs2.existsSync(jsonlPath)) {
-        const jsonlFiles = fs2.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs2.statSync(path2.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+      let jsonlPath = path3.join(sessionsDir, `${sessionFileUUID}.jsonl`);
+      if (!fs3.existsSync(jsonlPath)) {
+        const jsonlFiles = fs3.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".archived.") && !f.includes(".compaction.")).map((f) => ({ name: f, mtime: fs3.statSync(path3.join(sessionsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
         if (jsonlFiles.length === 0) {
           console.error(`\u274C JSONL \u6587\u4EF6\u4E0D\u5B58\u5728: ${jsonlPath}`);
           process.exit(1);
         }
         sessionFileUUID = jsonlFiles[0].name.replace(".jsonl", "");
-        jsonlPath = path2.join(sessionsDir, `${sessionFileUUID}.jsonl`);
+        jsonlPath = path3.join(sessionsDir, `${sessionFileUUID}.jsonl`);
       }
       console.log(`   file:   ${jsonlPath}`);
-      const configName = path2.basename(configPath2);
+      const configName = path3.basename(configPath2);
       if (autoRestart) {
         try {
           const myPid = process.pid;
@@ -1530,15 +1713,15 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
         }
       }
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const { readFileSync: readFileSync3, writeFileSync: writeFileSync3, renameSync } = fs2;
+      const { readFileSync: readFileSync4, writeFileSync: writeFileSync4, renameSync } = fs3;
       if (mode === "archive") {
         const archiveName = `${sessionFileUUID}.jsonl.archived.${timestamp}`;
-        renameSync(jsonlPath, path2.join(sessionsDir, archiveName));
+        renameSync(jsonlPath, path3.join(sessionsDir, archiveName));
         console.log(`
 \u2705 \u5F52\u6863\u5B8C\u6210: ${archiveName}`);
         console.log(`   \u91CD\u542F\u540E\u5C06\u4ECE\u7A7A\u767D\u4F1A\u8BDD\u5F00\u59CB`);
       } else if (mode === "drop-last") {
-        const lines = readFileSync3(jsonlPath, "utf-8").trim().split("\n");
+        const lines = readFileSync4(jsonlPath, "utf-8").trim().split("\n");
         const parsed = lines.map((l) => {
           try {
             return JSON.parse(l);
@@ -1557,12 +1740,12 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
         }
         const kept = parsed.slice(0, cutIndex);
         const newContent = kept.map((p) => JSON.stringify(p)).join("\n") + "\n";
-        writeFileSync3(jsonlPath, newContent);
+        writeFileSync4(jsonlPath, newContent);
         console.log(`
 \u2705 \u780D\u6389\u6700\u8FD1 ${parsed.length - cutIndex} \u884C\uFF08${dropN} \u8F6E\uFF09`);
         console.log(`   \u4FDD\u7559 ${kept.length} \u884C`);
       } else if (mode === "strip-images") {
-        const lines = readFileSync3(jsonlPath, "utf-8").trim().split("\n");
+        const lines = readFileSync4(jsonlPath, "utf-8").trim().split("\n");
         let stripped = 0;
         const newLines = lines.map((line) => {
           try {
@@ -1603,17 +1786,17 @@ engine7 session \u2014 \u4F1A\u8BDD\u7BA1\u7406\u5DE5\u5177
             return line;
           }
         });
-        writeFileSync3(jsonlPath, newLines.join("\n") + "\n");
+        writeFileSync4(jsonlPath, newLines.join("\n") + "\n");
         console.log(`
 \u2705 \u6458\u9664 ${stripped} \u884C\u56FE\u7247\u76F8\u5173\u5185\u5BB9`);
       }
       if (autoRestart) {
-        const realCliPath = fs2.realpathSync(process.argv[1]);
-        const cliDir = path2.dirname(realCliPath);
-        const pkgRoot = path2.resolve(cliDir, "..");
-        let enginePath = path2.join(pkgRoot, "dist", "main.mjs");
-        if (!fs2.existsSync(enginePath)) {
-          enginePath = path2.join(cliDir, "main.mjs");
+        const realCliPath = fs3.realpathSync(process.argv[1]);
+        const cliDir = path3.dirname(realCliPath);
+        const pkgRoot = path3.resolve(cliDir, "..");
+        let enginePath = path3.join(pkgRoot, "dist", "main.mjs");
+        if (!fs3.existsSync(enginePath)) {
+          enginePath = path3.join(cliDir, "main.mjs");
         }
         console.log(`
 \u{1F680} \u62C9\u8D77 engine...`);
@@ -1656,18 +1839,18 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
       else if (args[i] === "--cwd" && args[i + 1]) cwd = args[++i];
     }
     if (!configPath2) {
-      const defaultCfg = path2.join(cwd, "configs", "main7.json");
-      const homeCfg = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
-      if (fs2.existsSync(defaultCfg)) {
+      const defaultCfg = path3.join(cwd, "configs", "main7.json");
+      const homeCfg = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7", "configs", "main7.json");
+      if (fs3.existsSync(defaultCfg)) {
         configPath2 = defaultCfg;
-      } else if (fs2.existsSync(homeCfg)) {
+      } else if (fs3.existsSync(homeCfg)) {
         configPath2 = homeCfg;
-        cwd = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
+        cwd = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7");
       } else {
         const ptr = readHomePointer();
         if (ptr?.stateDir) {
-          const ptrCfg = path2.join(ptr.stateDir, "configs", "main7.json");
-          if (fs2.existsSync(ptrCfg)) {
+          const ptrCfg = path3.join(ptr.stateDir, "configs", "main7.json");
+          if (fs3.existsSync(ptrCfg)) {
             configPath2 = ptrCfg;
             cwd = ptr.stateDir;
           }
@@ -1686,14 +1869,14 @@ engine7 service \u2014 \u5F00\u673A\u81EA\u542F\u52A8\u7BA1\u7406
       if (process.platform === "win32") {
         const taskName = "Engine7";
         const nodeExe = process.execPath;
-        const cliMjs = path2.resolve(engine7Bin);
-        const absConfig = path2.resolve(configPath2);
-        const wrapperPath = path2.join(cwd, "engine7-start.cmd");
+        const cliMjs = path3.resolve(engine7Bin);
+        const absConfig = path3.resolve(configPath2);
+        const wrapperPath = path3.join(cwd, "engine7-start.cmd");
         const wrapperContent = `@echo off\r
 cd /d "${cwd}"\r
 "${nodeExe}" "${cliMjs}" start --config "${absConfig}"\r
 `;
-        fs2.writeFileSync(wrapperPath, wrapperContent);
+        fs3.writeFileSync(wrapperPath, wrapperContent);
         try {
           execSync2(`schtasks /create /tn "${taskName}" /tr "${wrapperPath}" /sc onlogon /rl highest /f`, { stdio: "inherit", shell: true });
           console.log(`\u2705 Windows \u8BA1\u5212\u4EFB\u52A1 "${taskName}" \u5DF2\u521B\u5EFA\uFF08\u5F00\u673A\u81EA\u542F\u52A8\uFF09`);
@@ -1704,11 +1887,11 @@ cd /d "${cwd}"\r
         }
       } else if (process.platform === "darwin") {
         const label = "com.engine7.agent";
-        const plistDir = path2.join(process.env.HOME, "Library", "LaunchAgents");
-        fs2.mkdirSync(plistDir, { recursive: true });
-        const plistPath = path2.join(plistDir, `${label}.plist`);
-        const localCli = path2.join("node_modules", "engine7", "dist", "cli.mjs");
-        const cliMjs = fs2.existsSync(localCli) ? path2.resolve(localCli) : path2.join(path2.dirname(path2.dirname(engine7Bin)), "lib", "node_modules", "engine7", "dist", "cli.mjs");
+        const plistDir = path3.join(process.env.HOME, "Library", "LaunchAgents");
+        fs3.mkdirSync(plistDir, { recursive: true });
+        const plistPath = path3.join(plistDir, `${label}.plist`);
+        const localCli = path3.join("node_modules", "engine7", "dist", "cli.mjs");
+        const cliMjs = fs3.existsSync(localCli) ? path3.resolve(localCli) : path3.join(path3.dirname(path3.dirname(engine7Bin)), "lib", "node_modules", "engine7", "dist", "cli.mjs");
         const plist = `<?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">
@@ -1720,14 +1903,14 @@ cd /d "${cwd}"\r
     <string>${cliMjs}</string>
     <string>start</string>
     <string>--config</string>
-    <string>${path2.resolve(configPath2)}</string>
+    <string>${path3.resolve(configPath2)}</string>
   </array>
   <key>WorkingDirectory</key><string>${cwd}</string>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
 </dict>
 </plist>`;
-        fs2.writeFileSync(plistPath, plist);
+        fs3.writeFileSync(plistPath, plist);
         try {
           execSync2(`launchctl load "${plistPath}"`, { stdio: "inherit" });
           console.log(`\u2705 Mac launchd \u670D\u52A1\u5DF2\u521B\u5EFA\uFF08\u5F00\u673A\u81EA\u542F\u52A8\uFF09`);
@@ -1738,9 +1921,9 @@ cd /d "${cwd}"\r
         }
       } else {
         const svcName = "engine7";
-        const svcDir = path2.join(process.env.HOME, ".config", "systemd", "user");
-        fs2.mkdirSync(svcDir, { recursive: true });
-        const svcPath = path2.join(svcDir, `${svcName}.service`);
+        const svcDir = path3.join(process.env.HOME, ".config", "systemd", "user");
+        fs3.mkdirSync(svcDir, { recursive: true });
+        const svcPath = path3.join(svcDir, `${svcName}.service`);
         const svc = `[Unit]
 Description=Engine 7 Agent
 After=network.target
@@ -1748,13 +1931,13 @@ After=network.target
 [Service]
 Type=simple
 WorkingDirectory=${cwd}
-ExecStart=${process.execPath} ${engine7Bin} start --config ${path2.resolve(configPath2)}
+ExecStart=${process.execPath} ${engine7Bin} start --config ${path3.resolve(configPath2)}
 Restart=on-failure
 RestartSec=10
 
 [Install]
 WantedBy=default.target`;
-        fs2.writeFileSync(svcPath, svc);
+        fs3.writeFileSync(svcPath, svc);
         try {
           execSync2(`systemctl --user daemon-reload`, { stdio: "inherit" });
           execSync2(`systemctl --user enable ${svcName}`, { stdio: "inherit" });
@@ -1775,13 +1958,13 @@ WantedBy=default.target`;
           process.exit(1);
         }
       } else if (process.platform === "darwin") {
-        const plistPath = path2.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
+        const plistPath = path3.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
         try {
           execSync2(`launchctl unload "${plistPath}"`, { stdio: "inherit" });
         } catch {
         }
         try {
-          fs2.unlinkSync(plistPath);
+          fs3.unlinkSync(plistPath);
         } catch {
         }
         console.log(`\u2705 Mac launchd \u670D\u52A1\u5DF2\u5220\u9664`);
@@ -1790,9 +1973,9 @@ WantedBy=default.target`;
           execSync2(`systemctl --user disable engine7`, { stdio: "inherit" });
         } catch {
         }
-        const svcPath = path2.join(process.env.HOME, ".config", "systemd", "user", "engine7.service");
+        const svcPath = path3.join(process.env.HOME, ".config", "systemd", "user", "engine7.service");
         try {
-          fs2.unlinkSync(svcPath);
+          fs3.unlinkSync(svcPath);
         } catch {
         }
         try {
@@ -1809,8 +1992,8 @@ WantedBy=default.target`;
           console.log("\u274C \u672A\u5B89\u88C5");
         }
       } else if (process.platform === "darwin") {
-        const plistPath = path2.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
-        if (fs2.existsSync(plistPath)) {
+        const plistPath = path3.join(process.env.HOME, "Library", "LaunchAgents", "com.engine7.agent.plist");
+        if (fs3.existsSync(plistPath)) {
           console.log("\u2705 \u5DF2\u5B89\u88C5\uFF08launchd\uFF09");
         } else {
           console.log("\u274C \u672A\u5B89\u88C5");
@@ -1833,13 +2016,13 @@ WantedBy=default.target`;
   console.log(`
 \u{1F680} engine7 init`);
   console.log(`   state-dir: ${opts.stateDir}`);
-  if (fs2.existsSync(opts.stateDir) && !opts.dryRun) {
-    const files = fs2.readdirSync(opts.stateDir);
+  if (fs3.existsSync(opts.stateDir) && !opts.dryRun) {
+    const files = fs3.readdirSync(opts.stateDir);
     if (files.length > 0) {
       if (opts.force) {
         console.log(`
 \u26A0\uFE0F --force: \u6E05\u7A7A\u5DF2\u6709\u76EE\u5F55 ${opts.stateDir}`);
-        fs2.rmSync(opts.stateDir, { recursive: true, force: true });
+        fs3.rmSync(opts.stateDir, { recursive: true, force: true });
       } else {
         console.error(`
 \u274C \u76EE\u5F55\u5DF2\u5B58\u5728\u4E14\u975E\u7A7A: ${opts.stateDir}`);
@@ -1859,7 +2042,7 @@ WantedBy=default.target`;
     rl.close();
   }
   const config = generateConfig(values);
-  const configPath = path2.join(opts.stateDir, "configs", "main7.json");
+  const configPath = path3.join(opts.stateDir, "configs", "main7.json");
   const tree = buildDirTree(values);
   tree.push({
     path: configPath,
@@ -1870,9 +2053,9 @@ WantedBy=default.target`;
     dryRun(tree);
     const skillsSrc = findTemplateDir("skills");
     if (skillsSrc) {
-      const skills = fs2.readdirSync(skillsSrc);
+      const skills = fs3.readdirSync(skillsSrc);
       for (const s of skills) {
-        console.log(`  \u{1F4C1} ${path2.join(opts.stateDir, "workspace", "skills", s)}`);
+        console.log(`  \u{1F4C1} ${path3.join(opts.stateDir, "workspace", "skills", s)}`);
       }
     }
   } else {
@@ -1880,55 +2063,55 @@ WantedBy=default.target`;
     execute(tree);
     const skillsSrc = findTemplateDir("skills");
     if (skillsSrc) {
-      const skillsDest = path2.join(opts.stateDir, "workspace", "skills");
-      fs2.mkdirSync(skillsDest, { recursive: true });
-      const skills = fs2.readdirSync(skillsSrc);
+      const skillsDest = path3.join(opts.stateDir, "workspace", "skills");
+      fs3.mkdirSync(skillsDest, { recursive: true });
+      const skills = fs3.readdirSync(skillsSrc);
       for (const s of skills) {
-        copyDirRecursive(path2.join(skillsSrc, s), path2.join(skillsDest, s));
+        copyDirRecursive(path3.join(skillsSrc, s), path3.join(skillsDest, s));
         console.log(`  \u{1F4E6} skill: ${s}`);
       }
     }
     console.log(`
 \u2705 \u521D\u59CB\u5316\u5B8C\u6210\uFF01
 `);
-    const homePointer = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
+    const homePointer = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
     const pointerData = { stateDir: opts.stateDir };
-    fs2.writeFileSync(homePointer, JSON.stringify(pointerData, null, 2) + "\n");
+    fs3.writeFileSync(homePointer, JSON.stringify(pointerData, null, 2) + "\n");
     console.log(`   \u{1F4C4} ${homePointer}\uFF08\u4ECE\u4EFB\u610F\u76EE\u5F55\u90FD\u80FD\u627E\u5230\u6B64 agent\uFF09`);
     console.log(`\u4E0B\u4E00\u6B65\uFF1A`);
     console.log(`  1. \u68C0\u67E5\u5E76\u4FEE\u6539 ${opts.stateDir}/configs/main7.json`);
     console.log(`  2. \u542F\u52A8 Engine: engine7 start\uFF08\u5728\u4EFB\u610F\u76EE\u5F55\u90FD\u884C\uFF09`);
     console.log(`  3. \u5F00\u673A\u81EA\u542F: engine7 service install\uFF08\u5728\u4EFB\u610F\u76EE\u5F55\u90FD\u884C\uFF09`);
-    console.log(`  4. \u67E5\u770B workspace: ${path2.join(opts.stateDir, "workspace")}`);
+    console.log(`  4. \u67E5\u770B workspace: ${path3.join(opts.stateDir, "workspace")}`);
   }
 }
 function copyDirRecursive(src, dest) {
-  fs2.mkdirSync(dest, { recursive: true });
-  for (const entry of fs2.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path2.join(src, entry.name);
-    const destPath = path2.join(dest, entry.name);
+  fs3.mkdirSync(dest, { recursive: true });
+  for (const entry of fs3.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      fs2.copyFileSync(srcPath, destPath);
+      fs3.copyFileSync(srcPath, destPath);
     }
   }
 }
 function findTemplateDir(name) {
   const candidates = [
-    path2.join(__dirname, "..", "templates", name),
-    path2.join(__dirname, "..", "..", "templates", name),
-    path2.join(process.cwd(), "templates", name)
+    path3.join(__dirname, "..", "templates", name),
+    path3.join(__dirname, "..", "..", "templates", name),
+    path3.join(process.cwd(), "templates", name)
   ];
   for (const p of candidates) {
-    if (fs2.existsSync(p)) return p;
+    if (fs3.existsSync(p)) return p;
   }
   return null;
 }
 function readHomePointer() {
-  const ptrPath = path2.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
+  const ptrPath = path3.join(process.env.HOME || process.env.USERPROFILE || ".", ".engine7.json");
   try {
-    return JSON.parse(fs2.readFileSync(ptrPath, "utf-8"));
+    return JSON.parse(fs3.readFileSync(ptrPath, "utf-8"));
   } catch {
     return null;
   }