nikou-cli 0.1.5 → 0.1.7

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   normalizeCliArgs
-} from "./chunk-F3EPGM5N.js";
+} from "./chunk-OQQEIFQV.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -463,17 +463,17 @@ var TOOL_CONFIG = {
   gemini: { filePath: join6(homedir(), ".gemini", "settings.json"), format: "json", jsonPath: ["mcpServers"] },
   opencode: { filePath: join6(homedir(), ".config", "opencode", "opencode.json"), format: "json", jsonPath: ["mcp"] }
 };
-function readJsonFile(path29) {
-  if (!existsSync5(path29)) return {};
+function readJsonFile(path30) {
+  if (!existsSync5(path30)) return {};
   try {
-    return JSON.parse(readFileSync4(path29, "utf-8"));
+    return JSON.parse(readFileSync4(path30, "utf-8"));
   } catch {
     return {};
   }
 }
-function writeJsonFile(path29, data) {
-  mkdirSync4(dirname2(path29), { recursive: true });
-  writeFileSync3(path29, JSON.stringify(data, null, 2) + "\n", "utf-8");
+function writeJsonFile(path30, data) {
+  mkdirSync4(dirname2(path30), { recursive: true });
+  writeFileSync3(path30, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 function getNestedObj(root, keys) {
   let cur = root;
@@ -500,10 +500,10 @@ function extractServerFromContent(content, jsonPath) {
     return null;
   }
 }
-function readTomlFile(path29) {
-  if (!existsSync5(path29)) return "";
+function readTomlFile(path30) {
+  if (!existsSync5(path30)) return "";
   try {
-    return readFileSync4(path29, "utf-8");
+    return readFileSync4(path30, "utf-8");
   } catch {
     return "";
   }
@@ -549,9 +549,9 @@ function tomlListServers(toml) {
   }
   return results;
 }
-function backupFile(path29) {
-  if (existsSync5(path29)) {
-    copyFileSync(path29, path29 + ".bak");
+function backupFile(path30) {
+  if (existsSync5(path30)) {
+    copyFileSync(path30, path30 + ".bak");
   }
 }
 function writeMcpToTool(toolId, serverName, variantContent, force) {
@@ -912,7 +912,7 @@ function pad3(str, width) {
 
 // src/hook/master/master-command.ts
 import * as lark2 from "@larksuiteoapi/node-sdk";
-import fs8 from "fs";
+import fs7 from "fs";
 import path8 from "path";
 import process4 from "process";
 
@@ -975,7 +975,7 @@ var CARD_STREAM_STDOUT_MAX_LENGTH = 12e3;
 var BIND_WHITELIST_REFRESH_MS = 5e3;
 
 // src/hook/utils.ts
-import fs2 from "fs";
+import fs from "fs";
 import os2 from "os";
 import path2 from "path";
 import process2 from "process";
@@ -1029,9 +1029,9 @@ function resolveAiHookGuestPath() {
 }
 function resolveOpsUserName() {
   const propsPath = path2.join(os2.homedir(), "ops", "ops_global.properties");
-  if (!fs2.existsSync(propsPath)) return "\u672A\u77E5";
+  if (!fs.existsSync(propsPath)) return "\u672A\u77E5";
   try {
-    const lines = fs2.readFileSync(propsPath, "utf-8").split(/\r?\n/);
+    const lines = fs.readFileSync(propsPath, "utf-8").split(/\r?\n/);
     for (const line of lines) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
@@ -1056,8 +1056,8 @@ function resolveCardPathDisplay(dirPath) {
   return `${segments[segments.length - 2]}\\${segments[segments.length - 1]}`;
 }
 function ensureDirExists(dirPath) {
-  if (!fs2.existsSync(dirPath)) {
-    fs2.mkdirSync(dirPath, { recursive: true });
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
   }
 }
 function normalizeHost(value) {
@@ -1369,7 +1369,7 @@ function formatCompactTokenCount(value) {
 }
 
 // src/hook/config-loader.ts
-import fs3 from "fs";
+import fs2 from "fs";
 
 // src/hook/json-config.ts
 function stripJsonLineComments(content) {
@@ -1413,7 +1413,7 @@ function parseJsonWithLineComments(content, filePath = "JSON \u914D\u7F6E") {
 // src/hook/config-loader.ts
 function resolveConfigPath(role = "worker") {
   const configPath = role === "master" ? MASTER_CONFIG_PATH : WORKER_CONFIG_PATH;
-  return fs3.existsSync(configPath) ? configPath : null;
+  return fs2.existsSync(configPath) ? configPath : null;
 }
 function loadRoleConfig(role) {
   const configPath = resolveConfigPath(role);
@@ -1427,7 +1427,7 @@ function loadRoleConfig(role) {
 ` + sampleBody + "}"
     );
   }
-  const raw = fs3.readFileSync(configPath, "utf-8");
+  const raw = fs2.readFileSync(configPath, "utf-8");
   const config = parseJsonWithLineComments(raw, configPath);
   return { config, configPath };
 }
@@ -1538,6 +1538,19 @@ function resolveContextConfig(config) {
     )
   };
 }
+function resolveNacosSkillSyncConfig(config) {
+  const raw = config.nacos_skill_sync ?? config.nacosSkillSync ?? {};
+  return {
+    enabled: parseBoolean(raw.enabled, true),
+    profile: String(raw.profile || "nikou-block").trim(),
+    label: String(raw.label || "latest").trim(),
+    interval: String(raw.interval || "30s").trim(),
+    plan_poll_interval_ms: parsePositiveInt(raw.plan_poll_interval_ms ?? raw.planPollIntervalMs, 6e4),
+    planPollIntervalMs: parsePositiveInt(raw.plan_poll_interval_ms ?? raw.planPollIntervalMs, 6e4),
+    auto_upload: parseBoolean(raw.auto_upload ?? raw.autoUpload, false),
+    autoUpload: parseBoolean(raw.auto_upload ?? raw.autoUpload, false)
+  };
+}
 function resolveMasterConfig(config, overrides = {}) {
   const hook2 = resolveHookSection(config);
   const feishuConfig = extractFeishuConfig(config);
@@ -1584,7 +1597,7 @@ function resolveAuthConfig(config) {
 }
 
 // src/hook/state-manager.ts
-import fs4 from "fs";
+import fs3 from "fs";
 import path3 from "path";
 import process3 from "process";
 var StateManager = class {
@@ -1596,13 +1609,13 @@ var StateManager = class {
     this.logger = logger3;
   }
   read() {
-    if (!fs4.existsSync(this.statePath)) {
+    if (!fs3.existsSync(this.statePath)) {
       this.state = null;
       return null;
     }
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
-        const raw = fs4.readFileSync(this.statePath, "utf-8");
+        const raw = fs3.readFileSync(this.statePath, "utf-8");
         this.state = JSON.parse(raw);
         return this.state;
       } catch (error) {
@@ -1621,13 +1634,13 @@ var StateManager = class {
     const tempPath = `${this.statePath}.tmp.${process3.pid}`;
     try {
       ensureDirExists(path3.dirname(this.statePath));
-      fs4.writeFileSync(tempPath, JSON.stringify(nextState, null, 4));
-      fs4.renameSync(tempPath, this.statePath);
+      fs3.writeFileSync(tempPath, JSON.stringify(nextState, null, 4));
+      fs3.renameSync(tempPath, this.statePath);
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
       this.logger.warn(`\u5199\u5165\u72B6\u6001\u6587\u4EF6\u5931\u8D25: ${msg}`);
       try {
-        if (fs4.existsSync(tempPath)) fs4.unlinkSync(tempPath);
+        if (fs3.existsSync(tempPath)) fs3.unlinkSync(tempPath);
       } catch (cleanupError) {
         const cmsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
         this.logger.warn(`\u6E05\u7406\u4E34\u65F6\u72B6\u6001\u6587\u4EF6\u5931\u8D25: ${cmsg}`);
@@ -2582,7 +2595,7 @@ var CardStreamUpdater = class {
   lastTokenUsage = "";
   sequence = 1;
   flushTimer = null;
-  flushing = false;
+  flushPromise = null;
   disposed = false;
   constructor(larkClient, cardId, taskId, logger3, intervalMs = CARD_STREAM_INTERVAL_MS) {
     this.larkClient = larkClient;
@@ -2670,8 +2683,19 @@ ${incoming}`, CARD_STREAM_STDOUT_MAX_LENGTH);
     }, this.intervalMs);
   }
   async flush() {
-    if (this.disposed || this.flushing) return;
-    this.flushing = true;
+    if (this.disposed) return;
+    if (this.flushPromise) {
+      await this.flushPromise;
+      return;
+    }
+    this.flushPromise = this.flushNow();
+    try {
+      await this.flushPromise;
+    } finally {
+      this.flushPromise = null;
+    }
+  }
+  async flushNow() {
     try {
       const tokenKey = JSON.stringify(this.tokenUsage);
       const needsFullUpdate = this.lastSession !== this.sessionBuffer || this.lastPath !== this.pathBuffer || this.lastHostName !== this.hostName || this.lastStopResult !== this.stopResultBuffer || this.lastDisableStop !== this.stopDisabled || this.lastTokenUsage !== tokenKey;
@@ -2703,8 +2727,6 @@ ${incoming}`, CARD_STREAM_STDOUT_MAX_LENGTH);
       }
     } catch (error) {
       this.logger.warn(`\u5361\u7247\u5237\u65B0\u5931\u8D25: ${formatCardUpdateError(error)}`);
-    } finally {
-      this.flushing = false;
     }
   }
   // ─── 飞书 API 调用 ──────────────────────────────
@@ -2814,19 +2836,64 @@ ${incoming}`, CARD_STREAM_STDOUT_MAX_LENGTH);
       clearTimeout(this.flushTimer);
       this.flushTimer = null;
     }
-    this.flushing = false;
+    if (this.flushPromise) {
+      await this.flushPromise;
+    }
     await this.flush();
     this.disposed = true;
   }
 };
 
+// src/hook/message-content-parser.ts
+function parseContent(content) {
+  if (content && typeof content === "object" && !Array.isArray(content)) {
+    return content;
+  }
+  if (typeof content !== "string") {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function extractFeishuPostText(content) {
+  const parsed = parseContent(content);
+  const title = String(parsed.title || "").trim();
+  const rows = Array.isArray(parsed.content) ? parsed.content : Array.isArray(parsed.content_v2) ? parsed.content_v2 : [];
+  const parts = [];
+  if (title) {
+    parts.push(title);
+  }
+  rows.forEach((row) => {
+    if (!Array.isArray(row)) {
+      return;
+    }
+    row.forEach((item) => {
+      const block = item;
+      const tag = String(block.tag || "").trim();
+      if ((tag === "text" || tag === "a") && block.text) {
+        parts.push(String(block.text));
+        return;
+      }
+      if (tag === "at") {
+        const name = String(block.user_name || block.name || "").replace(/^@/, "").trim();
+        parts.push(name ? `@${name}` : "@");
+      }
+    });
+  });
+  return parts.join("").replace(/\s+/g, " ").trim();
+}
+
 // src/hook/master/message-parser.ts
 function extractMessageText(message) {
   const content = message?.content || message?.body?.content;
   if (!content) return "";
   try {
     const parsed = typeof content === "string" ? JSON.parse(content) : content;
-    const text = String(parsed?.text || "") || extractPostText(parsed);
+    const text = String(parsed?.text || "") || extractFeishuPostText(parsed);
     return stripMentions(text, message);
   } catch {
     return stripMentions(String(content || ""), message);
@@ -2858,47 +2925,6 @@ function isMentionBot(message, botName) {
     return name === botName || name === DEFAULT_BOT_NAME;
   });
 }
-function extractPostText(content) {
-  const parsed = parseContent(content);
-  const title = String(parsed?.title || "").trim();
-  const rows = Array.isArray(parsed?.content) ? parsed.content : [];
-  const parts = [];
-  if (title) {
-    parts.push(title);
-  }
-  rows.forEach((row) => {
-    if (!Array.isArray(row)) {
-      return;
-    }
-    row.forEach((item) => {
-      const block = item;
-      const tag = String(block?.tag || "").trim();
-      if ((tag === "text" || tag === "a") && block?.text) {
-        parts.push(String(block.text));
-        return;
-      }
-      if (tag === "at") {
-        const name = String(block.user_name || block.name || "").replace(/^@/, "").trim();
-        parts.push(name ? `@${name}` : "@");
-      }
-    });
-  });
-  return parts.join("").replace(/\s+/g, " ").trim();
-}
-function parseContent(content) {
-  if (content && typeof content === "object" && !Array.isArray(content)) {
-    return content;
-  }
-  if (typeof content !== "string") {
-    return {};
-  }
-  try {
-    const parsed = JSON.parse(content);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
 function stripMentions(text, message) {
   let cleaned = String(text || "");
   const mentions = Array.isArray(message?.mentions) ? message.mentions : [];
@@ -3883,7 +3909,7 @@ var DirectWorkerRegistry = class {
 };
 
 // src/hook/master/routing/chat-binding-registry.ts
-import fs5 from "fs";
+import fs4 from "fs";
 import path4 from "path";
 function normalize2(value) {
   return String(value || "").trim();
@@ -3944,12 +3970,12 @@ var ChatBindingRegistry = class {
   }
   load() {
     this.bindings.clear();
-    if (!fs5.existsSync(this.filePath)) {
+    if (!fs4.existsSync(this.filePath)) {
       this.save();
       return;
     }
     try {
-      const parsed = JSON.parse(fs5.readFileSync(this.filePath, "utf-8") || "{}");
+      const parsed = JSON.parse(fs4.readFileSync(this.filePath, "utf-8") || "{}");
       for (const [chatId, value] of Object.entries(parsed.bindings || {})) {
         const normalizedChatId = normalize2(chatId);
         if (!normalizedChatId || !value || typeof value !== "object") {
@@ -3977,7 +4003,7 @@ var ChatBindingRegistry = class {
     }
   }
   save() {
-    fs5.mkdirSync(path4.dirname(this.filePath), { recursive: true });
+    fs4.mkdirSync(path4.dirname(this.filePath), { recursive: true });
     const bindings = {};
     for (const [chatId, chatMap] of this.bindings.entries()) {
       const serialized = {};
@@ -3986,7 +4012,7 @@ var ChatBindingRegistry = class {
       }
       bindings[chatId] = serialized;
     }
-    fs5.writeFileSync(
+    fs4.writeFileSync(
       this.filePath,
       `${JSON.stringify({ version: 2, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), bindings }, null, 2)}
 `,
@@ -4110,7 +4136,7 @@ var ChatBindingRegistry = class {
 };
 
 // src/hook/master/routing/worker-diagnostics-registry.ts
-import fs6 from "fs";
+import fs5 from "fs";
 import path5 from "path";
 function normalize3(value) {
   return String(value || "").trim();
@@ -4135,12 +4161,12 @@ var WorkerDiagnosticsRegistry = class {
   }
   load() {
     this.workers.clear();
-    if (!fs6.existsSync(this.filePath)) {
+    if (!fs5.existsSync(this.filePath)) {
       this.save();
       return;
     }
     try {
-      const parsed = JSON.parse(fs6.readFileSync(this.filePath, "utf-8") || "{}");
+      const parsed = JSON.parse(fs5.readFileSync(this.filePath, "utf-8") || "{}");
       for (const [workerId, diagnostics] of Object.entries(safeObject(parsed.workers))) {
         const normalizedWorkerId = normalize3(diagnostics.workerId || workerId);
         const registryKey = buildRegistryKey({
@@ -4172,12 +4198,12 @@ var WorkerDiagnosticsRegistry = class {
     }
   }
   save() {
-    fs6.mkdirSync(path5.dirname(this.filePath), { recursive: true });
+    fs5.mkdirSync(path5.dirname(this.filePath), { recursive: true });
     const workers = {};
     for (const [key, diagnostics] of this.workers.entries()) {
       workers[key] = diagnostics;
     }
-    fs6.writeFileSync(
+    fs5.writeFileSync(
       this.filePath,
       `${JSON.stringify({ version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), workers }, null, 2)}
 `,
@@ -4226,7 +4252,7 @@ var WorkerDiagnosticsRegistry = class {
 };
 
 // src/hook/master/master-event-utils.ts
-import fs7 from "fs";
+import fs6 from "fs";
 import os3 from "os";
 import path6 from "path";
 var VOPS_USER_CACHE_PATH = path6.join(os3.homedir(), "ops", "vops_user.json");
@@ -4313,11 +4339,11 @@ function isTaskOperatorMatched(task, operatorUserId, operatorOpenId) {
 function resolveSenderNameFromCache(senderUserId, senderOpenId = "") {
   const targetUserId = String(senderUserId || "").trim();
   const targetOpenId = String(senderOpenId || "").trim();
-  if (!targetUserId && !targetOpenId || !fs7.existsSync(VOPS_USER_CACHE_PATH)) {
+  if (!targetUserId && !targetOpenId || !fs6.existsSync(VOPS_USER_CACHE_PATH)) {
     return "";
   }
   try {
-    const parsed = JSON.parse(fs7.readFileSync(VOPS_USER_CACHE_PATH, "utf-8"));
+    const parsed = JSON.parse(fs6.readFileSync(VOPS_USER_CACHE_PATH, "utf-8"));
     const entries = Array.isArray(parsed) ? parsed : [];
     const matched = entries.find((item) => {
       if (!item || typeof item !== "object" || item.__cacheType) {
@@ -5205,7 +5231,7 @@ var HookMasterCommand = class {
     if (masterConfig.botName) {
       this.botName = masterConfig.botName;
     }
-    const configStat = fs8.statSync(configPath);
+    const configStat = fs7.statSync(configPath);
     this.bindWhitelistConfigMtimeMs = Number(configStat.mtimeMs || 0);
     this.chatBindingRegistry.load();
     this.workerDiagnosticsRegistry.load();
@@ -5275,13 +5301,20 @@ var HookMasterCommand = class {
       onCardAction: (data) => this.handleCardActionTrigger(data)
     });
     this.startBindWhitelistWatcher();
-    this.setupExitHandlers();
+    if (this.options.manageProcessSignals !== false) {
+      this.setupExitHandlers();
+    }
     this.heartbeatTimer = setInterval(() => {
       this.stateManager?.updateHeartbeat();
     }, HEARTBEAT_INTERVAL_MS);
     this.logger.info(
       `\u4E3B\u8282\u70B9\u542F\u52A8\u5B8C\u6210 host=${masterConfig.masterHost} port=${masterConfig.masterPort}`
     );
+    return {
+      masterHost: masterConfig.masterHost,
+      masterPort: masterConfig.masterPort,
+      sharedSecret: masterConfig.sharedSecret
+    };
   }
   async handleFeishuMessage(data) {
     const message = resolveEventMessage(data);
@@ -5720,8 +5753,8 @@ var HookMasterCommand = class {
   }
   refreshBindWhitelistIfNeeded() {
     try {
-      if (!this.configPath || !fs8.existsSync(this.configPath)) return;
-      const stat = fs8.statSync(this.configPath);
+      if (!this.configPath || !fs7.existsSync(this.configPath)) return;
+      const stat = fs7.statSync(this.configPath);
       const mtimeMs = Number(stat.mtimeMs || 0);
       if (!mtimeMs || mtimeMs <= this.bindWhitelistConfigMtimeMs) return;
       const { config } = loadMasterHstMcpConfig();
@@ -5772,42 +5805,42 @@ var HookMasterCommand = class {
     });
   }
   setupExitHandlers() {
-    const cleanup2 = async (signal) => {
-      this.logger.info(`\u6536\u5230\u4FE1\u53F7 ${signal}\uFF0C\u6B63\u5728\u5173\u95ED...`);
-      if (this.heartbeatTimer) {
-        clearInterval(this.heartbeatTimer);
-        this.heartbeatTimer = null;
-      }
-      if (this.bindWhitelistWatchTimer) {
-        clearInterval(this.bindWhitelistWatchTimer);
-        this.bindWhitelistWatchTimer = null;
-      }
-      this.groupRouteDispatcher?.clear();
-      this.wsServer?.stop();
-      this.stateManager?.update({
-        status: "stopped",
-        stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        lastSignal: signal
-      });
-      await this.usageRecorder.close();
-    };
     process4.on("SIGINT", async () => {
-      await cleanup2("SIGINT");
+      await this.stop("SIGINT");
       process4.exit(0);
     });
     process4.on("SIGTERM", async () => {
-      await cleanup2("SIGTERM");
+      await this.stop("SIGTERM");
       process4.exit(0);
     });
   }
+  async stop(signal = "manual") {
+    this.logger.info(`\u6536\u5230\u4FE1\u53F7 ${signal}\uFF0C\u6B63\u5728\u5173\u95ED...`);
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.bindWhitelistWatchTimer) {
+      clearInterval(this.bindWhitelistWatchTimer);
+      this.bindWhitelistWatchTimer = null;
+    }
+    this.groupRouteDispatcher?.clear();
+    this.wsServer?.stop();
+    this.stateManager?.update({
+      status: "stopped",
+      stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastSignal: signal
+    });
+    await this.usageRecorder.close();
+  }
 };
 
 // src/hook/logger.ts
-import fs9 from "fs";
+import fs8 from "fs";
 import path9 from "path";
 function ensureLogsDir() {
-  if (!fs9.existsSync(LOGS_DIR)) {
-    fs9.mkdirSync(LOGS_DIR, { recursive: true });
+  if (!fs8.existsSync(LOGS_DIR)) {
+    fs8.mkdirSync(LOGS_DIR, { recursive: true });
   }
 }
 function todaySuffix() {
@@ -5818,8 +5851,8 @@ function timestamp() {
 }
 function appendLine(filePath, line) {
   try {
-    fs9.mkdirSync(path9.dirname(filePath), { recursive: true });
-    fs9.appendFileSync(filePath, line + "\n", "utf-8");
+    fs8.mkdirSync(path9.dirname(filePath), { recursive: true });
+    fs8.appendFileSync(filePath, line + "\n", "utf-8");
   } catch {
   }
 }
@@ -5844,22 +5877,22 @@ function resolveServiceLogName(role) {
 }
 function ensureCurrentLogLink(currentPath, dailyPath) {
   try {
-    fs9.mkdirSync(path9.dirname(currentPath), { recursive: true });
-    fs9.mkdirSync(path9.dirname(dailyPath), { recursive: true });
-    fs9.writeFileSync(dailyPath, "", { flag: "a" });
-    if (fs9.existsSync(currentPath)) {
-      const stat = fs9.lstatSync(currentPath);
+    fs8.mkdirSync(path9.dirname(currentPath), { recursive: true });
+    fs8.mkdirSync(path9.dirname(dailyPath), { recursive: true });
+    fs8.writeFileSync(dailyPath, "", { flag: "a" });
+    if (fs8.existsSync(currentPath)) {
+      const stat = fs8.lstatSync(currentPath);
       if (!stat.isSymbolicLink()) {
         const legacyDir = path9.join(path9.dirname(currentPath), "logs", "legacy");
-        fs9.mkdirSync(legacyDir, { recursive: true });
+        fs8.mkdirSync(legacyDir, { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        fs9.renameSync(currentPath, path9.join(legacyDir, `${path9.basename(currentPath)}.${stamp}`));
+        fs8.renameSync(currentPath, path9.join(legacyDir, `${path9.basename(currentPath)}.${stamp}`));
       }
     }
-    fs9.rmSync(currentPath, { force: true });
-    fs9.symlinkSync(dailyPath, currentPath);
+    fs8.rmSync(currentPath, { force: true });
+    fs8.symlinkSync(dailyPath, currentPath);
   } catch {
-    fs9.writeFileSync(currentPath, "", { flag: "a" });
+    fs8.writeFileSync(currentPath, "", { flag: "a" });
   }
 }
 function createLogger(name, verbose = false) {
@@ -5920,16 +5953,19 @@ async function hookMasterAction(options) {
 
 // src/hook/worker/worker-command.ts
 import process10 from "process";
-import os16 from "os";
-import path26 from "path";
+import os17 from "os";
+import path27 from "path";
 import * as lark3 from "@larksuiteoapi/node-sdk";
 
+// src/hook/worker/message-strategy.ts
+import fs14 from "fs";
+
 // src/hook/worker/runners/codex-runner.ts
 import process7 from "process";
 import { spawn, spawnSync as spawnSync4 } from "child_process";
 
 // src/hook/runtime-env.ts
-import fs10 from "fs";
+import fs9 from "fs";
 import process5 from "process";
 import { spawnSync as spawnSync2 } from "child_process";
 var HST_MCP_DISABLED_MODULES_ENV_KEY = "HST_MCP_DISABLED_MODULES";
@@ -5974,11 +6010,11 @@ function parseEnvFileContent(content = "") {
   return env;
 }
 function loadRuntimeEnvFile(filePath = RUNTIME_ENV_PATH) {
-  if (!filePath || !fs10.existsSync(filePath)) {
+  if (!filePath || !fs9.existsSync(filePath)) {
     return {};
   }
   try {
-    return parseEnvFileContent(fs10.readFileSync(filePath, "utf-8"));
+    return parseEnvFileContent(fs9.readFileSync(filePath, "utf-8"));
   } catch {
     return {};
   }
@@ -5990,7 +6026,7 @@ function resolveUnixShell(baseEnv = process5.env) {
     "/bin/bash",
     "/bin/sh"
   ].filter(Boolean);
-  return candidates.find((item) => fs10.existsSync(item)) || "/bin/sh";
+  return candidates.find((item) => fs9.existsSync(item)) || "/bin/sh";
 }
 function parseNullSeparatedEnv(output = "") {
   const env = {};
@@ -6111,23 +6147,23 @@ function buildHookRuntimeEnv(baseEnv = process5.env, {
 }
 
 // src/hook/worker/runners/command-resolver.ts
-import fs11 from "fs";
+import fs10 from "fs";
 import path10 from "path";
 import process6 from "process";
 import { spawnSync as spawnSync3 } from "child_process";
 function isExecutableFile(filePath) {
-  if (!filePath || !fs11.existsSync(filePath)) {
+  if (!filePath || !fs10.existsSync(filePath)) {
     return false;
   }
   try {
-    const stat = fs11.statSync(filePath);
+    const stat = fs10.statSync(filePath);
     if (!stat.isFile()) {
       return false;
     }
     if (process6.platform === "win32") {
       return true;
     }
-    fs11.accessSync(filePath, fs11.constants.X_OK);
+    fs10.accessSync(filePath, fs10.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -6672,7 +6708,7 @@ command=${execConfig.displayCommand}`));
 };
 
 // src/hook/context/identity-resolver.ts
-import fs12 from "fs";
+import fs11 from "fs";
 import os5 from "os";
 import path11 from "path";
 
@@ -6877,12 +6913,12 @@ var IdentityResolver = class {
     if (Array.isArray(this.cache)) {
       return this.cache;
     }
-    if (!fs12.existsSync(this.cachePath)) {
+    if (!fs11.existsSync(this.cachePath)) {
       this.cache = [];
       return this.cache;
     }
     try {
-      const parsed = JSON.parse(fs12.readFileSync(this.cachePath, "utf-8"));
+      const parsed = JSON.parse(fs11.readFileSync(this.cachePath, "utf-8"));
       const input = Array.isArray(parsed) ? parsed : [];
       this.cache = this.dedupeCacheEntries(input);
       if (this.cache.length !== input.length) {
@@ -6899,7 +6935,7 @@ var IdentityResolver = class {
   saveCache() {
     try {
       this.cache = this.dedupeCacheEntries(this.cache || []);
-      fs12.writeFileSync(this.cachePath, JSON.stringify(this.cache, null, 2));
+      fs11.writeFileSync(this.cachePath, JSON.stringify(this.cache, null, 2));
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.logger.warn(`\u5199\u5165 vops_user.json \u5931\u8D25: ${message}`);
@@ -7232,7 +7268,7 @@ var IdentityResolver = class {
 };
 
 // src/hook/prompt/nikou-prompt-store.ts
-import fs13 from "fs";
+import fs12 from "fs";
 import os6 from "os";
 import path12 from "path";
 
@@ -7287,7 +7323,7 @@ function normalizeText2(value) {
   return String(value || "").trim();
 }
 function ensureDir(dirPath) {
-  fs13.mkdirSync(dirPath, { recursive: true });
+  fs12.mkdirSync(dirPath, { recursive: true });
 }
 function parseFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
@@ -7334,18 +7370,18 @@ ${body}
 ` : "\n"}`;
 }
 function readTextFile(filePath) {
-  if (!fs13.existsSync(filePath)) {
+  if (!fs12.existsSync(filePath)) {
     return "";
   }
   try {
-    return fs13.readFileSync(filePath, "utf-8").trim();
+    return fs12.readFileSync(filePath, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function writeTextFile(filePath, content) {
   ensureDir(path12.dirname(filePath));
-  fs13.writeFileSync(filePath, content, "utf-8");
+  fs12.writeFileSync(filePath, content, "utf-8");
 }
 function buildPromptDefinitions() {
   const roleDefinitions = Object.entries(REQUESTER_PERSONA_RULES.roles).map(([roleKey, roleConfig]) => ({
@@ -7406,7 +7442,7 @@ var NikouPromptStore = class {
     return definition.defaultContent.trim();
   }
   readPromptFile(definition) {
-    if (!fs13.existsSync(definition.path)) {
+    if (!fs12.existsSync(definition.path)) {
       const content = this.resolveBootstrapContent(definition);
       const file = {
         title: definition.title,
@@ -7417,7 +7453,7 @@ var NikouPromptStore = class {
       this.syncLegacyFiles(definition, file);
       return file;
     }
-    return parseFrontmatter(fs13.readFileSync(definition.path, "utf-8"));
+    return parseFrontmatter(fs12.readFileSync(definition.path, "utf-8"));
   }
   syncLegacyFiles(definition, file) {
     if (!definition.legacyPaths.length) {
@@ -7430,7 +7466,7 @@ var NikouPromptStore = class {
     }
   }
   toSummary(definition, file) {
-    const stat = fs13.existsSync(definition.path) ? fs13.statSync(definition.path) : null;
+    const stat = fs12.existsSync(definition.path) ? fs12.statSync(definition.path) : null;
     return {
       id: definition.id,
       kind: definition.kind,
@@ -7511,7 +7547,7 @@ var NikouPromptStore = class {
 };
 
 // src/hook/worker/task-route-binding.ts
-import fs14 from "fs";
+import fs13 from "fs";
 import path13 from "path";
 function resolveTaskRouteDir(routeBinding, fallbackDir) {
   if (routeBinding) {
@@ -7520,7 +7556,7 @@ function resolveTaskRouteDir(routeBinding, fallbackDir) {
       return { dirPath: "", reason: "invalid_route_dir" };
     }
     try {
-      if (!fs14.statSync(dirPath2).isDirectory()) {
+      if (!fs13.statSync(dirPath2).isDirectory()) {
         return { dirPath: "", reason: "invalid_route_dir" };
       }
     } catch {
@@ -7657,7 +7693,7 @@ var MessageReceiveStrategy = class {
     if (!raw) return "";
     try {
       const parsed = JSON.parse(raw);
-      const text = String(parsed?.text || "");
+      const text = String(parsed?.text || "") || extractFeishuPostText(parsed);
       return this.stripMentions(text, message);
     } catch {
       return this.stripMentions(String(raw), message);
@@ -7665,25 +7701,7 @@ var MessageReceiveStrategy = class {
   }
   extractPostText(messageLike) {
     const raw = messageLike?.content || messageLike?.body?.content;
-    if (!raw) return "";
-    try {
-      const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
-      const blocks = parsed?.content || [];
-      const parts = [];
-      blocks.forEach((row) => {
-        (row || []).forEach((item) => {
-          if ((item?.tag === "text" || item?.tag === "a") && item?.text) {
-            parts.push(String(item.text));
-          }
-          if (item?.tag === "at") {
-            parts.push(String(item.user_name || item.name || ""));
-          }
-        });
-      });
-      return parts.join("").replace(/\s+/g, " ").trim();
-    } catch {
-      return "";
-    }
+    return extractFeishuPostText(raw);
   }
   stripMentions(text, message) {
     let cleaned = String(text || "");
@@ -8308,7 +8326,7 @@ ${question}` : question;
     if (!bindTarget) {
       return { ...baseTask, canHandle: true, type: "quick_result", quickResult: "\u8BF7\u6307\u5B9A\u7ED1\u5B9A\u8DEF\u5F84\uFF0C\u683C\u5F0F: \u7ED1\u5B9A:/path/to/project" };
     }
-    if (!fs.existsSync(bindTarget)) {
+    if (!fs14.existsSync(bindTarget)) {
       return { ...baseTask, canHandle: true, type: "quick_result", quickResult: `\u8DEF\u5F84\u4E0D\u5B58\u5728: ${bindTarget}` };
     }
     this.stateManager.rebindChatToDir(message.chatId, bindTarget);
@@ -9744,7 +9762,15 @@ var SlaveRelayClient = class {
         this.resolvePendingClaim(packet.task_id, false);
         break;
       case "task_offer":
-        this.handleTaskOffer(packet);
+        void this.handleTaskOffer(packet).catch((error) => {
+          const taskId = String(packet.task_id || "").trim();
+          const traceId = resolveTraceId(taskId);
+          const message = error instanceof Error ? error.message : String(error);
+          this.logger.error(formatTraceLog(
+            traceId,
+            `\u5904\u7406\u4EFB\u52A1 offer \u5931\u8D25: task_id=${taskId || "-"}, error=${message}`
+          ));
+        });
         break;
       case "task_cancel": {
         const cancelResult = this.taskExecutor.cancelTask(packet.task_id);
@@ -10496,6 +10522,7 @@ var LocalBrowserWsServer = class {
   workerId;
   workerType;
   larkClient;
+  getNacosSyncStatus;
   wss = null;
   profile;
   startTime = (/* @__PURE__ */ new Date()).toISOString();
@@ -10505,6 +10532,7 @@ var LocalBrowserWsServer = class {
     this.workerId = options.workerId;
     this.workerType = options.workerType;
     this.larkClient = options.larkClient;
+    this.getNacosSyncStatus = options.getNacosSyncStatus;
   }
   async start() {
     if (this.wss) {
@@ -10685,7 +10713,8 @@ var LocalBrowserWsServer = class {
         cliTools: {
           codex: this.detectCliTool("codex"),
           claude: this.detectCliTool("claude")
-        }
+        },
+        nacosSync: this.getNacosSyncStatus?.() ?? null
       }
     });
   }
@@ -13974,6 +14003,263 @@ var OwnerNotifyService = class {
   }
 };
 
+// src/hook/worker/nacos-subscription-sync.ts
+import fs27 from "fs";
+import os16 from "os";
+import path26 from "path";
+import { execFile, spawn as spawn4 } from "child_process";
+import { createRequire } from "module";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var NacosSubscriptionSyncCoordinator = class {
+  logger;
+  workerId;
+  config;
+  timer = null;
+  daemon = null;
+  running = false;
+  stopped = false;
+  status;
+  statePath = path26.join(os16.homedir(), ".nikou-block", "worker", "nacos-subscriptions.json");
+  constructor(options) {
+    this.logger = options.logger;
+    this.workerId = options.workerId;
+    this.config = options.config;
+    this.status = {
+      enabled: this.config.enabled,
+      configured: false,
+      profile: this.config.profile,
+      label: this.config.label,
+      daemonRunning: false,
+      totalSkills: 0,
+      synced: 0,
+      pending: 0,
+      conflicts: 0,
+      failed: 0
+    };
+  }
+  start() {
+    if (!this.config.enabled || this.timer) return;
+    void this.syncOnce();
+    this.timer = setInterval(() => {
+      void this.syncOnce();
+    }, this.config.plan_poll_interval_ms);
+  }
+  async stop() {
+    this.stopped = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.daemon) {
+      this.daemon.kill("SIGTERM");
+      this.daemon = null;
+      this.status.daemonRunning = false;
+    }
+  }
+  getStatus() {
+    return { ...this.status };
+  }
+  async syncOnce() {
+    if (this.running || this.stopped) return;
+    this.running = true;
+    try {
+      const plan = await this.fetchPlan();
+      this.status.enabled = plan.nacos.enabled;
+      this.status.host = plan.nacos.host;
+      this.status.profile = plan.nacos.profile || this.config.profile;
+      this.status.label = plan.nacos.label || this.config.label;
+      this.status.lastPlanAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (!plan.nacos.enabled) {
+        this.status.configured = false;
+        this.status.totalSkills = 0;
+        this.status.pending = 0;
+        return;
+      }
+      await this.configureProfile(plan);
+      await this.ensureMode(plan);
+      this.ensureDaemon(plan);
+      const results = [];
+      for (const skill of plan.skills) {
+        const result = await this.syncSkill(plan, skill);
+        results.push(result);
+      }
+      await this.report(results);
+      this.persistManagedState(plan.skills);
+      this.applySummary(results);
+      this.status.lastSyncAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.status.lastError = void 0;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.status.lastError = message;
+      this.logger.warn(`Nacos Skill \u8BA2\u9605\u540C\u6B65\u5931\u8D25: ${message}`);
+    } finally {
+      this.running = false;
+    }
+  }
+  async fetchPlan() {
+    const runtime = resolveCliAuthRuntimeConfig();
+    if (!runtime.cliAuthSecret) {
+      throw new Error("\u672A\u914D\u7F6E CLI_AUTH_SECRET\uFF0C\u65E0\u6CD5\u62C9\u53D6 Nacos \u540C\u6B65\u8BA1\u5212");
+    }
+    const response = await fetch(`${runtime.apiUrl}/worker-skills/nacos-sync/plan`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ secret: runtime.cliAuthSecret, workerId: this.workerId })
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`\u62C9\u53D6 Nacos \u540C\u6B65\u8BA1\u5212\u5931\u8D25: ${response.status} ${text}`);
+    }
+    return await response.json();
+  }
+  async report(results) {
+    if (!results.length) return;
+    const runtime = resolveCliAuthRuntimeConfig();
+    const response = await fetch(`${runtime.apiUrl}/worker-skills/nacos-sync/report`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ secret: runtime.cliAuthSecret, workerId: this.workerId, results })
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`\u4E0A\u62A5 Nacos \u540C\u6B65\u72B6\u6001\u5931\u8D25: ${response.status} ${text}`);
+    }
+  }
+  async configureProfile(plan) {
+    const nacos = plan.nacos;
+    const profile = nacos.profile || this.config.profile;
+    const args = [
+      "profile",
+      "set",
+      profile,
+      `host=${nacos.serverHost || this.parseHost(nacos.host).host}`,
+      `port=${nacos.port || this.parseHost(nacos.host).port}`,
+      `scheme=${nacos.scheme || this.parseHost(nacos.host).scheme}`,
+      `namespace=${nacos.namespace || "public"}`,
+      `auth-type=${nacos.authType || "none"}`
+    ];
+    if (nacos.username) args.push(`username=${nacos.username}`);
+    if (nacos.password) args.push(`password=${nacos.password}`);
+    await this.run(args);
+    this.status.configured = true;
+  }
+  async ensureMode(plan) {
+    await this.run(["skill-sync", "mode", "nacos", "--profile", plan.nacos.profile || this.config.profile, "--switch-profile"]);
+  }
+  ensureDaemon(plan) {
+    if (this.daemon && !this.daemon.killed) return;
+    const args = [
+      "skill-sync",
+      "start",
+      "--foreground",
+      "--non-interactive",
+      "--profile",
+      plan.nacos.profile || this.config.profile,
+      "--label",
+      plan.nacos.label || this.config.label,
+      "--interval",
+      this.config.interval,
+      "--switch-profile"
+    ];
+    if (!this.config.auto_upload) {
+      args.push("--no-auto-upload");
+    }
+    const bin = this.resolveNacosCliBin();
+    this.daemon = spawn4(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    this.status.daemonRunning = true;
+    this.daemon.stdout?.on("data", (chunk) => this.logger.debug(`nacos-cli: ${String(chunk).trim()}`));
+    this.daemon.stderr?.on("data", (chunk) => this.logger.warn(`nacos-cli: ${String(chunk).trim()}`));
+    this.daemon.once("exit", (code, signal) => {
+      this.status.daemonRunning = false;
+      this.daemon = null;
+      if (!this.stopped) {
+        this.status.lastError = `Nacos daemon \u5DF2\u9000\u51FA: code=${code ?? "-"}, signal=${signal ?? "-"}`;
+      }
+    });
+  }
+  async syncSkill(plan, skill) {
+    try {
+      await this.run([
+        "skill-sync",
+        skill.status === "pending_remove" ? "remove" : "add",
+        skill.nacosSkillName,
+        "--profile",
+        plan.nacos.profile || this.config.profile,
+        "--switch-profile",
+        ...skill.status === "pending_remove" ? [] : ["--non-interactive"]
+      ]);
+      return {
+        resourceId: skill.resourceId,
+        nacosSkillName: skill.nacosSkillName,
+        desiredVersionKey: skill.desiredVersionKey,
+        status: skill.status === "pending_remove" ? "removed" : "synced",
+        message: "Nacos Skill Sync \u6267\u884C\u6210\u529F"
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = /conflict|冲突/i.test(message) ? "conflict" : "failed";
+      return {
+        resourceId: skill.resourceId,
+        nacosSkillName: skill.nacosSkillName,
+        desiredVersionKey: skill.desiredVersionKey,
+        status,
+        message
+      };
+    }
+  }
+  async run(args) {
+    const bin = this.resolveNacosCliBin();
+    const result = await execFileAsync(bin, args, { timeout: 6e4, maxBuffer: 1024 * 1024 * 2 });
+    return `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  }
+  resolveNacosCliBin() {
+    try {
+      const require2 = createRequire(import.meta.url);
+      const pkgPath = require2.resolve("@nacos-group/cli/package.json");
+      return path26.join(path26.dirname(pkgPath), "bin", "cli.js");
+    } catch {
+      return "nacos-cli";
+    }
+  }
+  applySummary(results) {
+    this.status.totalSkills = results.length;
+    this.status.synced = results.filter((item) => item.status === "synced" || item.status === "removed").length;
+    this.status.pending = results.filter((item) => item.status.startsWith("pending")).length;
+    this.status.conflicts = results.filter((item) => item.status === "conflict").length;
+    this.status.failed = results.filter((item) => item.status === "failed").length;
+  }
+  persistManagedState(skills) {
+    try {
+      fs27.mkdirSync(path26.dirname(this.statePath), { recursive: true });
+      fs27.writeFileSync(this.statePath, JSON.stringify({
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        skills: skills.map((item) => ({
+          resourceId: item.resourceId,
+          nacosSkillName: item.nacosSkillName,
+          desiredLabel: item.desiredLabel,
+          desiredVersionKey: item.desiredVersionKey,
+          status: item.status
+        }))
+      }, null, 2));
+    } catch (error) {
+      this.logger.warn(`\u5199\u5165 Nacos \u8BA2\u9605\u72B6\u6001\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  parseHost(raw) {
+    try {
+      const url = new URL(raw.includes("://") ? raw : `http://${raw}`);
+      return {
+        scheme: url.protocol.replace(":", "") || "http",
+        host: url.hostname,
+        port: url.port || (url.protocol === "https:" ? "443" : "8848")
+      };
+    } catch {
+      return { scheme: "http", host: raw.replace(/^https?:\/\//, ""), port: "8848" };
+    }
+  }
+};
+
 // src/hook/worker/worker-command.ts
 var HookWorkerCommand = class {
   logger;
@@ -13982,11 +14268,21 @@ var HookWorkerCommand = class {
   localBrowserWs = null;
   reminderService = null;
   ownerNotifyService = null;
+  nacosSyncCoordinator = null;
   heartbeatTimer = null;
   stateManager = null;
+  stopped = false;
+  stoppedPromise;
+  resolveStopped = () => void 0;
   constructor(logger3, options = {}) {
     this.logger = logger3;
     this.options = options;
+    this.stoppedPromise = new Promise((resolve3) => {
+      this.resolveStopped = resolve3;
+    });
+  }
+  waitUntilStopped() {
+    return this.stoppedPromise;
   }
   async start() {
     const existingPid = findRunningAiHookProcess(process10.pid);
@@ -14009,6 +14305,7 @@ var HookWorkerCommand = class {
     });
     const bindAllowedUserIds = resolveBindAllowedUserIds(config);
     const contextConfig = resolveContextConfig(config);
+    const nacosSyncConfig = resolveNacosSkillSyncConfig(config);
     const opsUserName = resolveOpsUserName();
     const larkClient = new lark3.Client({
       appId: feishuConfig.appId,
@@ -14074,13 +14371,20 @@ var HookWorkerCommand = class {
       config: this.options.runnerConfig || {}
     });
     this.logger.info(`\u5F15\u64CE\u5DF2\u521B\u5EFA: engine=${engine}, \u53EF\u7528\u5F15\u64CE=[${registry.list().join(", ")}]`);
+    this.nacosSyncCoordinator = new NacosSubscriptionSyncCoordinator({
+      logger: this.logger,
+      workerId: ownerUserId || `worker-${process10.pid}`,
+      config: nacosSyncConfig
+    });
     this.localBrowserWs = new LocalBrowserWsServer({
       logger: this.logger,
       workerId: ownerUserId || `worker-${process10.pid}`,
       workerType: "tooling-cli",
-      larkClient
+      larkClient,
+      getNacosSyncStatus: () => this.nacosSyncCoordinator?.getStatus() ?? null
     });
     await this.localBrowserWs.start();
+    this.nacosSyncCoordinator.start();
     const hostProfileService = new HostProfileService({
       logger: this.logger,
       ownerUserId,
@@ -14109,7 +14413,7 @@ var HookWorkerCommand = class {
     const requesterPersonaService = new RequesterPersonaService({
       logger: this.logger,
       larkClient,
-      rootDir: process10.env.HOOK_REQUESTER_PERSONA_DIR || path26.join(os16.homedir(), "ops", "ai-hook", "persona")
+      rootDir: process10.env.HOOK_REQUESTER_PERSONA_DIR || path27.join(os17.homedir(), "ops", "ai-hook", "persona")
     });
     const taskExecutor = new TaskExecutor({
       logger: this.logger,
@@ -14166,17 +14470,19 @@ var HookWorkerCommand = class {
     await this.relayClient.startAndWait();
     await reminderService.start();
     await this.ownerNotifyService.notifyOnline();
-    const gracefulExit = async (signal) => {
-      this.logger.info(`\u6536\u5230 ${signal}\uFF0C\u6B63\u5728\u505C\u6B62\u4ECE\u8282\u70B9...`);
-      await this.stop(signal);
-      process10.exit(0);
-    };
-    process10.on("SIGINT", () => {
-      void gracefulExit("SIGINT");
-    });
-    process10.on("SIGTERM", () => {
-      void gracefulExit("SIGTERM");
-    });
+    if (this.options.manageProcessSignals !== false) {
+      const gracefulExit = async (signal) => {
+        this.logger.info(`\u6536\u5230 ${signal}\uFF0C\u6B63\u5728\u505C\u6B62\u4ECE\u8282\u70B9...`);
+        await this.stop(signal);
+        process10.exit(0);
+      };
+      process10.on("SIGINT", () => {
+        void gracefulExit("SIGINT");
+      });
+      process10.on("SIGTERM", () => {
+        void gracefulExit("SIGTERM");
+      });
+    }
     this.heartbeatTimer = setInterval(() => {
       stateManager.updateHeartbeat();
     }, HEARTBEAT_INTERVAL_MS);
@@ -14186,6 +14492,10 @@ var HookWorkerCommand = class {
   }
   /** 停止从节点 */
   async stop(signal) {
+    if (this.stopped) {
+      return;
+    }
+    this.stopped = true;
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
@@ -14194,6 +14504,10 @@ var HookWorkerCommand = class {
       this.localBrowserWs.stop();
       this.localBrowserWs = null;
     }
+    if (this.nacosSyncCoordinator) {
+      await this.nacosSyncCoordinator.stop();
+      this.nacosSyncCoordinator = null;
+    }
     if (this.reminderService) {
       this.reminderService.stop();
       this.reminderService = null;
@@ -14219,10 +14533,65 @@ var HookWorkerCommand = class {
         slaveConnectionStatus: "offline"
       });
     }
+    this.resolveStopped();
   }
 };
 
-// src/commands/hook/hook-worker.ts
+// src/commands/hook/worker-options.ts
+var WORKER_BOOLEAN_OPTIONS = /* @__PURE__ */ new Set([
+  "--verbose"
+]);
+var WORKER_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+  "--master-host",
+  "--master-port",
+  "--shared-secret",
+  "--claim-timeout-ms",
+  "--connect-timeout-ms",
+  "--model",
+  "--fallback-model",
+  "--permission-mode",
+  "--max-budget-usd",
+  "--settings",
+  "--mcp-config",
+  "--add-dir",
+  "--system-prompt",
+  "--append-system-prompt",
+  "--agent",
+  "--agents",
+  "--tools",
+  "--allowedTools",
+  "--disallowedTools"
+]);
+function resolveWorkerPassthroughArgs(engine, commandName = "worker", rawArgs = process.argv.slice(2)) {
+  const commandIndex = rawArgs.findIndex((item, index) => item === commandName && rawArgs[index - 1] === "hook");
+  if (commandIndex < 0) {
+    return [];
+  }
+  const tail = rawArgs.slice(commandIndex + 1);
+  const args = tail[0] === commandName ? tail.slice(1) : tail;
+  const normalizedEngine = String(engine || "codex").trim();
+  const scanArgs = args[0] === normalizedEngine ? args.slice(1) : args;
+  const passthroughArgs = [];
+  for (let index = 0; index < scanArgs.length; index += 1) {
+    const item = scanArgs[index];
+    if (item === "--") {
+      passthroughArgs.push(...scanArgs.slice(index + 1));
+      break;
+    }
+    const key = item.includes("=") ? item.split("=")[0] : item;
+    if (WORKER_BOOLEAN_OPTIONS.has(key)) {
+      continue;
+    }
+    if (WORKER_VALUE_OPTIONS.has(key)) {
+      if (!item.includes("=")) {
+        index += 1;
+      }
+      continue;
+    }
+    passthroughArgs.push(item);
+  }
+  return passthroughArgs;
+}
 function normalizeClaudeArgs(options) {
   const args = [];
   const pushPair = (flag, value) => {
@@ -14254,6 +14623,8 @@ function normalizeClaudeArgs(options) {
   });
   return args;
 }
+
+// src/commands/hook/hook-worker.ts
 async function hookWorkerAction(engine, options) {
   const logger3 = createLogger("worker", options.verbose === true);
   const normalizedEngine = (engine || "codex").toLowerCase();
@@ -14263,10 +14634,12 @@ async function hookWorkerAction(engine, options) {
     masterPort: parsePositiveInt(options.masterPort, 0) || void 0,
     sharedSecret: options.sharedSecret,
     connectTimeoutMs: parsePositiveInt(options.connectTimeoutMs, 0) || void 0,
-    runnerConfig: normalizedEngine === "claude" ? { claudeArgs: normalizeClaudeArgs(options) } : {}
+    runnerConfig: normalizedEngine === "claude" ? { claudeArgs: normalizeClaudeArgs(options) } : {},
+    manageProcessSignals: true
   });
   try {
     await command.start();
+    await command.waitUntilStopped();
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     logger3.error(`\u4ECE\u8282\u70B9\u542F\u52A8\u5931\u8D25: ${msg}`);
@@ -14274,23 +14647,98 @@ async function hookWorkerAction(engine, options) {
   }
 }
 
+// src/commands/hook/hook-local.ts
+function resolveLocalWorkerMasterHost(masterHost) {
+  const host = String(masterHost || "").trim();
+  if (host === "0.0.0.0" || host === "::" || host === "[::]") {
+    return "127.0.0.1";
+  }
+  return host;
+}
+function resolveLocalWorkerOverrides(runtime) {
+  return {
+    masterHost: resolveLocalWorkerMasterHost(runtime.masterHost),
+    masterPort: runtime.masterPort,
+    sharedSecret: runtime.sharedSecret
+  };
+}
+async function hookLocalAction(engine, options) {
+  const localLogger = createLogger("local", options.verbose === true);
+  const masterLogger = createLogger("master");
+  const workerLogger = createLogger("worker", options.verbose === true);
+  const normalizedEngine = (engine || "codex").toLowerCase();
+  const master = new HookMasterCommand({
+    logger: masterLogger,
+    masterHost: options.masterHost,
+    masterPort: parsePositiveInt(options.masterPort, 0) || void 0,
+    sharedSecret: options.sharedSecret,
+    claimTimeoutMs: parsePositiveInt(options.claimTimeoutMs, 0) || void 0,
+    manageProcessSignals: false
+  });
+  let worker = null;
+  let stopping = false;
+  const stopAll = async (signal) => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    localLogger.info(`\u6536\u5230 ${signal}\uFF0C\u6B63\u5728\u505C\u6B62\u672C\u673A\u4E00\u4F53\u8282\u70B9...`);
+    if (worker) {
+      await worker.stop(signal);
+      worker = null;
+    }
+    await master.stop(signal);
+  };
+  process.on("SIGINT", async () => {
+    await stopAll("SIGINT");
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await stopAll("SIGTERM");
+    process.exit(0);
+  });
+  try {
+    const runtime = await master.start();
+    const workerOverrides = resolveLocalWorkerOverrides(runtime);
+    worker = new HookWorkerCommand(workerLogger, {
+      engine: normalizedEngine,
+      masterHost: workerOverrides.masterHost,
+      masterPort: workerOverrides.masterPort,
+      sharedSecret: workerOverrides.sharedSecret,
+      connectTimeoutMs: parsePositiveInt(options.connectTimeoutMs, 0) || void 0,
+      runnerConfig: normalizedEngine === "claude" ? { claudeArgs: normalizeClaudeArgs(options) } : {},
+      manageProcessSignals: false
+    });
+    await worker.start();
+    localLogger.info(
+      `\u672C\u673A\u4E00\u4F53\u8282\u70B9\u542F\u52A8\u5B8C\u6210 | engine=${normalizedEngine} | master=${workerOverrides.masterHost}:${workerOverrides.masterPort}`
+    );
+    await worker.waitUntilStopped();
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    localLogger.error(`\u672C\u673A\u4E00\u4F53\u8282\u70B9\u542F\u52A8\u5931\u8D25: ${msg}`);
+    await stopAll("startup_error");
+    process.exit(1);
+  }
+}
+
 // src/hook/init/hook-init-command.ts
-import fs28 from "fs";
-import os17 from "os";
-import path27 from "path";
+import fs29 from "fs";
+import os18 from "os";
+import path28 from "path";
 import process11 from "process";
 import { createInterface as createInterface3 } from "readline/promises";
 import chalk9 from "chalk";
 
 // src/hook/init/legacy-ai-hook-migrator.ts
-import fs27 from "fs";
+import fs28 from "fs";
 function loadLegacyMigrationResult(logger3) {
   const sourcePath = LEGACY_STATE_PATH;
-  if (!fs27.existsSync(sourcePath)) {
+  if (!fs28.existsSync(sourcePath)) {
     return { state: null, summary: null };
   }
   try {
-    const parsed = parseJsonWithLineComments(fs27.readFileSync(sourcePath, "utf-8"), sourcePath);
+    const parsed = parseJsonWithLineComments(fs28.readFileSync(sourcePath, "utf-8"), sourcePath);
     if (!parsed || typeof parsed !== "object") {
       return { state: null, summary: null };
     }
@@ -14318,6 +14766,7 @@ function countObjectKeys(value) {
 
 // src/hook/init/hook-init-normalizer.ts
 var DEFAULT_MASTER_HOST_ENV = "NIKOU_HOOK_MASTER_HOST";
+var LOCAL_MASTER_HOST = "127.0.0.1";
 function resolveHookSection2(config) {
   return config.hook ?? config.ai_hook ?? config.aiHook ?? {};
 }
@@ -14377,6 +14826,15 @@ function resolveContextConfigFromHook(hook2) {
 function resolveDefaultMasterHost(env = process.env) {
   return String(env[DEFAULT_MASTER_HOST_ENV] || "").trim();
 }
+function resolveHookInitDeploymentDefaults(config, env = process.env) {
+  const configuredHost = resolveConfiguredMasterHost(config);
+  const envHost = resolveDefaultMasterHost(env);
+  const masterHost = configuredHost || envHost || LOCAL_MASTER_HOST;
+  return {
+    deploymentMode: isLocalHost(masterHost) ? "local" : "slave",
+    masterHost
+  };
+}
 function normalizeHookInitConfig(config, defaults = {}) {
   const hook2 = resolveHookSection2(config);
   const appId = String(config.feishu?.app_id || config.feishu?.appId || config.feishu?.appid || "").trim();
@@ -14392,7 +14850,9 @@ function normalizeHookInitConfig(config, defaults = {}) {
   if (!appSecret) missing.push("feishu.app_secret");
   if (!masterHost) missing.push(`hook.master_host \u6216 ${DEFAULT_MASTER_HOST_ENV}`);
   if (!sharedSecret) missing.push("hook.shared_secret");
-  if (bindAllowedUserIds.length === 0) missing.push("hook.bind_allowed_user_ids");
+  if (defaults.deploymentMode !== "slave" && bindAllowedUserIds.length === 0) {
+    missing.push("hook.bind_allowed_user_ids");
+  }
   if (missing.length > 0) {
     throw new Error(`\u521D\u59CB\u5316\u6240\u9700\u914D\u7F6E\u7F3A\u5931: ${missing.join(", ")}`);
   }
@@ -14418,7 +14878,8 @@ function normalizeHookInitConfig(config, defaults = {}) {
 // src/hook/init/hook-init-command.ts
 var BOT_OPTIONS = [{ label: "\u59AE\u853B", value: "\u59AE\u853B" }];
 var DEPLOYMENT_OPTIONS = [
-  { label: "\u4ECE\u8282\u70B9", value: "slave", description: "\u4E3B\u8282\u70B9\u521D\u59CB\u5316\u672C\u671F\u4E0D\u5F00\u653E\uFF0C\u4E3B\u914D\u7F6E\u4F7F\u7528\u56FA\u5B9A\u503C" }
+  { label: "\u672C\u673A\u4E00\u4F53", value: "local", description: "\u540C\u4E00\u53F0\u673A\u5668\u542F\u52A8\u4E3B\u8282\u70B9\u548C\u672C\u5730\u4ECE\u8282\u70B9" },
+  { label: "\u4ECE\u8282\u70B9", value: "slave", description: "\u8FDE\u63A5\u5DF2\u6709\u8FDC\u7AEF\u4E3B\u8282\u70B9" }
 ];
 var HookInitCommand = class {
   constructor(logger3) {
@@ -14432,22 +14893,32 @@ var HookInitCommand = class {
     const existingAggregateConfig = this.readJson(DEFAULT_CONFIG_PATH);
     const existingMasterConfig = this.readJson(MASTER_CONFIG_PATH);
     const existingWorkerConfig = this.readJson(WORKER_CONFIG_PATH);
-    const existingWorkerStatePath = path27.join(STATE_DIR, "worker.json");
+    const existingWorkerStatePath = path28.join(STATE_DIR, "worker.json");
     const existingWorkerState = this.readJson(existingWorkerStatePath);
     const rl = createInterface3({ input: process11.stdin, output: process11.stdout });
     try {
       this.printEnvironmentSummary(source.path, { existingAggregateConfig, existingMasterConfig, existingWorkerConfig }, migration.summary);
       const botName = await this.askChoice(rl, "\u7B2C\u4E00\u6B65\uFF1A\u9009\u62E9\u98DE\u4E66\u673A\u5668\u4EBA", BOT_OPTIONS, 0);
-      await this.askChoice(rl, "\u7B2C\u4E8C\u6B65\uFF1A\u9009\u62E9\u90E8\u7F72\u65B9\u5F0F", DEPLOYMENT_OPTIONS, 0);
-      const masterHost = await this.askMasterHost(rl, source.config);
+      const deploymentDefaults = resolveHookInitDeploymentDefaults(source.config);
+      const deploymentDefaultIndex = DEPLOYMENT_OPTIONS.findIndex((item) => item.value === deploymentDefaults.deploymentMode);
+      const deploymentMode = await this.askChoice(
+        rl,
+        "\u7B2C\u4E8C\u6B65\uFF1A\u9009\u62E9\u90E8\u7F72\u65B9\u5F0F",
+        DEPLOYMENT_OPTIONS,
+        deploymentDefaultIndex >= 0 ? deploymentDefaultIndex : 0
+      );
+      const defaultMasterHost = deploymentMode === "local" ? LOCAL_MASTER_HOST : deploymentDefaults.masterHost;
+      const masterHost = await this.askMasterHost(rl, source.config, defaultMasterHost);
       const normalized = this.normalizeSourceConfig(
-        mergeHookInitMasterHost(source.config, masterHost)
+        mergeHookInitMasterHost(source.config, masterHost),
+        deploymentMode
       );
       const nextMasterConfig = this.buildMasterConfigPayload(normalized, botName);
       const nextWorkerConfig = this.buildWorkerConfigPayload(normalized, botName);
       const nextWorkerState = this.buildSeedWorkerState({
         botName,
         configPath: WORKER_CONFIG_PATH,
+        deploymentMode,
         normalized,
         existingWorkerState,
         legacyState: migration.state
@@ -14456,6 +14927,7 @@ var HookInitCommand = class {
         nextMasterConfig,
         nextWorkerConfig,
         nextWorkerState,
+        deploymentMode,
         sourcePath: source.path,
         migrationSummary: migration.summary,
         existingAggregateConfig,
@@ -14480,7 +14952,10 @@ var HookInitCommand = class {
       console.log(chalk9.dim(`\u4E3B\u8282\u70B9\u914D\u7F6E: ${MASTER_CONFIG_PATH}`));
       console.log(chalk9.dim(`\u4ECE\u8282\u70B9\u914D\u7F6E: ${WORKER_CONFIG_PATH}`));
       console.log(chalk9.dim(`\u72B6\u6001\u6587\u4EF6: ${existingWorkerStatePath}`));
-      console.log(chalk9.dim("\n\u4E0B\u4E00\u6B65: nikou-cli hook worker codex\n"));
+      const nextCommand = deploymentMode === "local" ? "ai-hook local" : "nikou-cli hook worker codex";
+      console.log(chalk9.dim(`
+\u4E0B\u4E00\u6B65: ${nextCommand}
+`));
     } finally {
       rl.close();
     }
@@ -14493,11 +14968,11 @@ var HookInitCommand = class {
   resolveSourceConfig() {
     const candidates = [LEGACY_CONFIG_PATH, DEFAULT_CONFIG_PATH, MASTER_CONFIG_PATH, WORKER_CONFIG_PATH];
     for (const candidate of candidates) {
-      if (!fs28.existsSync(candidate)) {
+      if (!fs29.existsSync(candidate)) {
         continue;
       }
       try {
-        const parsed = parseJsonWithLineComments(fs28.readFileSync(candidate, "utf-8"), candidate);
+        const parsed = parseJsonWithLineComments(fs29.readFileSync(candidate, "utf-8"), candidate);
         if (parsed && typeof parsed === "object") {
           return { config: parsed, path: candidate };
         }
@@ -14508,9 +14983,10 @@ var HookInitCommand = class {
     }
     throw new Error(`\u672A\u627E\u5230\u53EF\u521D\u59CB\u5316\u7684\u914D\u7F6E\u6E90\uFF0C\u8BF7\u5148\u51C6\u5907 ${LEGACY_CONFIG_PATH}\u3001${DEFAULT_CONFIG_PATH} \u6216\u89D2\u8272\u914D\u7F6E\u6587\u4EF6`);
   }
-  normalizeSourceConfig(config) {
+  normalizeSourceConfig(config, deploymentMode) {
     return normalizeHookInitConfig(config, {
-      defaultMasterHost: resolveDefaultMasterHost()
+      defaultMasterHost: resolveDefaultMasterHost(),
+      deploymentMode
     });
   }
   printEnvironmentSummary(sourcePath, existingConfig, migrationSummary) {
@@ -14559,8 +15035,8 @@ var HookInitCommand = class {
       console.log(chalk9.yellow("\u8BF7\u8F93\u5165 y \u6216 n\u3002\n"));
     }
   }
-  async askMasterHost(rl, config) {
-    const defaultHost = resolveConfiguredMasterHost(config) || resolveDefaultMasterHost();
+  async askMasterHost(rl, config, fallbackHost) {
+    const defaultHost = fallbackHost || resolveConfiguredMasterHost(config) || resolveDefaultMasterHost();
     while (true) {
       const label = defaultHost ? `\u7B2C\u4E09\u6B65\uFF1A\u4E3B\u8282\u70B9\u5730\u5740 [\u9ED8\u8BA4 ${defaultHost}]: ` : "\u7B2C\u4E09\u6B65\uFF1A\u4E3B\u8282\u70B9\u5730\u5740: ";
       const answer = (await rl.question(chalk9.dim(label))).trim();
@@ -14650,7 +15126,7 @@ var HookInitCommand = class {
       contextConfig: params.normalized.contextConfig,
       slaveConnectionStatus: "offline",
       status: "stopped",
-      lastCommand: "nikou-cli hook worker codex"
+      lastCommand: params.deploymentMode === "local" ? "ai-hook local" : "nikou-cli hook worker codex"
     });
     const mergedState = mergeWorkerState(
       initialState,
@@ -14661,7 +15137,7 @@ var HookInitCommand = class {
     mergedState.initializedAt = now;
     mergedState.initMode = "interactive";
     mergedState.migration = params.legacyState ? {
-      source: path27.join(os17.homedir(), "ops", "ai-hook.json"),
+      source: path28.join(os18.homedir(), "ops", "ai-hook.json"),
       migratedAt: now,
       legacyBindingsCount: countObjectKeys2(params.legacyState.bindings),
       legacyChatIndexCount: countObjectKeys2(params.legacyState.chatIndex),
@@ -14682,10 +15158,10 @@ var HookInitCommand = class {
     console.log(chalk9.dim(`- \u4ECE\u8282\u70B9\u914D\u7F6E: ${WORKER_CONFIG_PATH}`));
     console.log(chalk9.dim(`- \u98DE\u4E66 AppId: ${String(params.nextMasterConfig.feishu?.app_id || "")}`));
     console.log(chalk9.dim(`- \u673A\u5668\u4EBA: ${String(masterHook.bot_name || workerHook.bot_name || "")}`));
-    console.log(chalk9.dim(`- \u90E8\u7F72\u65B9\u5F0F: \u4ECE\u8282\u70B9`));
+    console.log(chalk9.dim(`- \u90E8\u7F72\u65B9\u5F0F: ${params.deploymentMode === "local" ? "\u672C\u673A\u4E00\u4F53" : "\u4ECE\u8282\u70B9"}`));
     console.log(chalk9.dim(`- \u4E3B\u8282\u70B9: ${String(masterHook.master_host || "")}:${String(masterHook.master_port || "")}`));
     console.log(chalk9.dim(`- \u4E3B\u8282\u70B9\u767D\u540D\u5355\u6570\u91CF: ${Array.isArray(masterHook.bind_allowed_user_ids) ? masterHook.bind_allowed_user_ids.length : 0}`));
-    console.log(chalk9.dim(`- \u79CD\u5B50\u72B6\u6001: ${path27.join(STATE_DIR, "worker.json")}`));
+    console.log(chalk9.dim(`- \u79CD\u5B50\u72B6\u6001: ${path28.join(STATE_DIR, "worker.json")}`));
     console.log(chalk9.dim(`- \u8FC1\u79FB\u540E\u7FA4\u7ED1\u5B9A\u6570: ${Object.keys(params.nextWorkerState.bindings || {}).length}`));
     console.log(chalk9.dim(`- \u8FC1\u79FB\u540E chatIndex \u6570: ${Object.keys(params.nextWorkerState.chatIndex || {}).length}`));
     console.log(chalk9.dim(`- \u8FC1\u79FB\u540E P2P \u4F1A\u8BDD\u6570: ${countObjectKeys2(params.nextWorkerState.p2pSessions)}`));
@@ -14711,28 +15187,28 @@ var HookInitCommand = class {
     });
   }
   backupIfNeeded(targetPath, prefix) {
-    if (!fs28.existsSync(targetPath)) {
+    if (!fs29.existsSync(targetPath)) {
       return;
     }
-    const backupDir = path27.join(STATE_DIR, "backups");
+    const backupDir = path28.join(STATE_DIR, "backups");
     ensureDirExists(backupDir);
     const fileName = `${prefix}.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`;
-    fs28.copyFileSync(targetPath, path27.join(backupDir, fileName));
+    fs29.copyFileSync(targetPath, path28.join(backupDir, fileName));
   }
   readJson(filePath) {
-    if (!fs28.existsSync(filePath)) {
+    if (!fs29.existsSync(filePath)) {
       return null;
     }
     try {
-      const parsed = parseJsonWithLineComments(fs28.readFileSync(filePath, "utf-8"), filePath);
+      const parsed = parseJsonWithLineComments(fs29.readFileSync(filePath, "utf-8"), filePath);
       return parsed && typeof parsed === "object" ? parsed : null;
     } catch {
       return null;
     }
   }
   writeJson(filePath, value) {
-    ensureDirExists(path27.dirname(filePath));
-    fs28.writeFileSync(filePath, JSON.stringify(value, null, 2));
+    ensureDirExists(path28.dirname(filePath));
+    fs29.writeFileSync(filePath, JSON.stringify(value, null, 2));
   }
 };
 function countObjectKeys2(value) {
@@ -14756,12 +15232,12 @@ async function hookInitAction() {
 }
 
 // src/commands/hook/hook-log.ts
-import fs30 from "fs";
+import fs31 from "fs";
 import chalk10 from "chalk";
 
 // src/hook/log-searcher.ts
-import fs29 from "fs";
-import path28 from "path";
+import fs30 from "fs";
+import path29 from "path";
 function normalizeString(value) {
   if (value === null || value === void 0) {
     return "";
@@ -14799,8 +15275,8 @@ var HookLogSearcher = class {
   logPaths;
   constructor(options = {}) {
     this.logPaths = {
-      master: options.masterPath || path28.join(LOGS_DIR, "master", "ai-hook-master.service.log"),
-      worker: options.workerPath || path28.join(LOGS_DIR, "worker", "ai-hook-worker.service.log")
+      master: options.masterPath || path29.join(LOGS_DIR, "master", "ai-hook-master.service.log"),
+      worker: options.workerPath || path29.join(LOGS_DIR, "worker", "ai-hook-worker.service.log")
     };
   }
   resolveScope(scope) {
@@ -14863,7 +15339,7 @@ var HookLogSearcher = class {
   }
   searchSingleFile(role, query = {}, options = {}) {
     const filePath = this.logPaths[role];
-    if (!filePath || !fs29.existsSync(filePath)) {
+    if (!filePath || !fs30.existsSync(filePath)) {
       return {
         role,
         path: filePath,
@@ -14874,7 +15350,7 @@ var HookLogSearcher = class {
         lines: []
       };
     }
-    const raw = fs29.readFileSync(filePath, "utf8");
+    const raw = fs30.readFileSync(filePath, "utf8");
     const lines = raw.split(/\r?\n/);
     if (lines.length > 0 && lines[lines.length - 1] === "") {
       lines.pop();
@@ -14992,7 +15468,7 @@ function buildFollowState(file) {
   return {
     role: file.role,
     path: file.path,
-    offset: fs30.existsSync(file.path) ? fs30.statSync(file.path).size : 0,
+    offset: fs31.existsSync(file.path) ? fs31.statSync(file.path).size : 0,
     remainder: ""
   };
 }
@@ -15019,10 +15495,10 @@ function flushChunk(state, chunk, queryText) {
   output.forEach((line) => console.log(line));
 }
 function readAppendedChunk(state, queryText) {
-  if (!fs30.existsSync(state.path)) {
+  if (!fs31.existsSync(state.path)) {
     return;
   }
-  const stat = fs30.statSync(state.path);
+  const stat = fs31.statSync(state.path);
   if (stat.size < state.offset) {
     state.offset = 0;
     state.remainder = "";
@@ -15030,15 +15506,15 @@ function readAppendedChunk(state, queryText) {
   if (stat.size === state.offset) {
     return;
   }
-  const fd = fs30.openSync(state.path, "r");
+  const fd = fs31.openSync(state.path, "r");
   try {
     const length = stat.size - state.offset;
     const buffer = Buffer.alloc(length);
-    fs30.readSync(fd, buffer, 0, length, state.offset);
+    fs31.readSync(fd, buffer, 0, length, state.offset);
     state.offset = stat.size;
     flushChunk(state, buffer.toString("utf8"), queryText);
   } finally {
-    fs30.closeSync(fd);
+    fs31.closeSync(fd);
   }
 }
 async function followLogs(queryText, options = {}) {
@@ -15079,60 +15555,6 @@ async function hookLogAction(query = "", options = {}) {
 
 // src/index.ts
 var DEFAULT_DEST = ".agents/skills";
-var WORKER_BOOLEAN_OPTIONS = /* @__PURE__ */ new Set([
-  "--verbose"
-]);
-var WORKER_VALUE_OPTIONS = /* @__PURE__ */ new Set([
-  "--master-host",
-  "--master-port",
-  "--shared-secret",
-  "--connect-timeout-ms",
-  "--model",
-  "--fallback-model",
-  "--permission-mode",
-  "--max-budget-usd",
-  "--settings",
-  "--mcp-config",
-  "--add-dir",
-  "--system-prompt",
-  "--append-system-prompt",
-  "--agent",
-  "--agents",
-  "--tools",
-  "--allowedTools",
-  "--disallowedTools"
-]);
-function resolveWorkerPassthroughArgs(engine) {
-  const rawArgs = process.argv.slice(2);
-  const workerIndex = rawArgs.findIndex((item, index) => item === "worker" && rawArgs[index - 1] === "hook");
-  if (workerIndex < 0) {
-    return [];
-  }
-  const tail = rawArgs.slice(workerIndex + 1);
-  const args = tail[0] === "worker" ? tail.slice(1) : tail;
-  const normalizedEngine = String(engine || "codex").trim();
-  const scanArgs = args[0] === normalizedEngine ? args.slice(1) : args;
-  const passthroughArgs = [];
-  for (let index = 0; index < scanArgs.length; index += 1) {
-    const item = scanArgs[index];
-    if (item === "--") {
-      passthroughArgs.push(...scanArgs.slice(index + 1));
-      break;
-    }
-    const key = item.includes("=") ? item.split("=")[0] : item;
-    if (WORKER_BOOLEAN_OPTIONS.has(key)) {
-      continue;
-    }
-    if (WORKER_VALUE_OPTIONS.has(key)) {
-      if (!item.includes("=")) {
-        index += 1;
-      }
-      continue;
-    }
-    passthroughArgs.push(item);
-  }
-  return passthroughArgs;
-}
 var program = new Command();
 program.name("nikou-cli").description("CLI to install and manage Agent Skills from GitHub repos").version("0.1.0");
 program.command("add").argument("<source>", 'GitHub repo in "owner/repo" format (e.g., vercel-labs/agent-skills)').description("Install skill(s) from a GitHub repository").option("-p, --path <path>", "Specific subfolder path in the repo").option("-d, --dest <dir>", "Destination directory", DEFAULT_DEST).option("-b, --branch <branch>", "Git branch", "main").option("-f, --force", "Overwrite existing skills", false).action(async (source, options) => {
@@ -15161,16 +15583,23 @@ mcp.command("search").argument("<keyword>", "Search keyword").description("Searc
   await mcpSearchCommand(keyword, options);
 });
 var hook = program.command("hook").description("\u4E3B\u4ECE\u8282\u70B9\u4EFB\u52A1\u5206\u53D1\u4E0E\u6267\u884C\uFF08\u98DE\u4E66\u96C6\u6210\uFF09");
+function addWorkerRuntimeOptions(command) {
+  return command.allowUnknownOption(true).allowExcessArguments(true).option("--verbose", "\u5F00\u542F\u8C03\u8BD5\u65E5\u5FD7", false).option("--connect-timeout-ms <ms>", "\u4ECE\u8282\u70B9\u8FDE\u63A5\u4E3B\u8282\u70B9\u8D85\u65F6\u6BEB\u79D2\u6570").option("--model <model>", "Claude \u6A21\u578B").option("--fallback-model <model>", "Claude fallback \u6A21\u578B").option("--permission-mode <mode>", "Claude \u6743\u9650\u6A21\u5F0F").option("--max-budget-usd <usd>", "Claude \u6700\u5927\u9884\u7B97").option("--settings <path>", "Claude settings \u6587\u4EF6").option("--mcp-config <path>", "Claude MCP \u914D\u7F6E").option("--add-dir <path>", "Claude \u989D\u5916\u53EF\u8BBF\u95EE\u76EE\u5F55").option("--system-prompt <prompt>", "Claude system prompt").option("--append-system-prompt <prompt>", "Claude \u8FFD\u52A0 system prompt").option("--agent <agent>", "Claude agent").option("--agents <agents>", "Claude agents").option("--tools <tools>", "Claude tools").option("--allowedTools <tools>", "Claude allowedTools").option("--disallowedTools <tools>", "Claude disallowedTools");
+}
 hook.command("master").description("\u542F\u52A8\u4E3B\u8282\u70B9\uFF1A\u63A5\u6536\u98DE\u4E66\u6D88\u606F\u5E76\u5206\u53D1\u4EFB\u52A1\u7ED9\u4ECE\u8282\u70B9").option("--master-host <host>", "\u4E3B\u8282\u70B9\u76D1\u542C\u5730\u5740").option("--master-port <port>", "\u4E3B\u8282\u70B9\u7AEF\u53E3\uFF08\u9ED8\u8BA4 19732\uFF09").option("--shared-secret <secret>", "\u4E3B\u4ECE\u901A\u4FE1\u9274\u6743\u5BC6\u94A5").option("--claim-timeout-ms <ms>", "\u4EFB\u52A1\u8BA4\u9886\u8D85\u65F6\u6BEB\u79D2\u6570").action(async (options) => {
   await hookMasterAction(options);
 });
 hook.command("init").description("\u4EA4\u4E92\u5F0F\u521D\u59CB\u5316 Hook \u4ECE\u8282\u70B9\u914D\u7F6E\u4E0E\u5386\u53F2\u72B6\u6001\u8FC1\u79FB").action(async () => {
   await hookInitAction();
 });
-hook.command("worker").argument("[engine]", "codex|gemini|claude", "codex").description("\u542F\u52A8\u4ECE\u8282\u70B9\uFF1A\u8FDE\u63A5\u4E3B\u8282\u70B9\u540E\u6267\u884C\u5DE5\u5177\u4EFB\u52A1").allowUnknownOption(true).allowExcessArguments(true).option("--verbose", "\u5F00\u542F\u8C03\u8BD5\u65E5\u5FD7", false).option("--master-host <host>", "\u4E3B\u8282\u70B9\u5730\u5740\uFF08IP \u6216\u57DF\u540D\uFF09").option("--master-port <port>", "\u4E3B\u8282\u70B9\u7AEF\u53E3").option("--shared-secret <secret>", "\u4E3B\u4ECE\u901A\u4FE1\u9274\u6743\u5BC6\u94A5").option("--connect-timeout-ms <ms>", "\u4ECE\u8282\u70B9\u8FDE\u63A5\u4E3B\u8282\u70B9\u8D85\u65F6\u6BEB\u79D2\u6570").option("--model <model>", "Claude \u6A21\u578B").option("--fallback-model <model>", "Claude fallback \u6A21\u578B").option("--permission-mode <mode>", "Claude \u6743\u9650\u6A21\u5F0F").option("--max-budget-usd <usd>", "Claude \u6700\u5927\u9884\u7B97").option("--settings <path>", "Claude settings \u6587\u4EF6").option("--mcp-config <path>", "Claude MCP \u914D\u7F6E").option("--add-dir <path>", "Claude \u989D\u5916\u53EF\u8BBF\u95EE\u76EE\u5F55").option("--system-prompt <prompt>", "Claude system prompt").option("--append-system-prompt <prompt>", "Claude \u8FFD\u52A0 system prompt").option("--agent <agent>", "Claude agent").option("--agents <agents>", "Claude agents").option("--tools <tools>", "Claude tools").option("--allowedTools <tools>", "Claude allowedTools").option("--disallowedTools <tools>", "Claude disallowedTools").action(async (engine, options) => {
-  const passthroughArgs = resolveWorkerPassthroughArgs(engine);
+addWorkerRuntimeOptions(hook.command("worker").argument("[engine]", "codex|gemini|claude", "codex").description("\u542F\u52A8\u4ECE\u8282\u70B9\uFF1A\u8FDE\u63A5\u4E3B\u8282\u70B9\u540E\u6267\u884C\u5DE5\u5177\u4EFB\u52A1").option("--master-host <host>", "\u4E3B\u8282\u70B9\u5730\u5740\uFF08IP \u6216\u57DF\u540D\uFF09").option("--master-port <port>", "\u4E3B\u8282\u70B9\u7AEF\u53E3").option("--shared-secret <secret>", "\u4E3B\u4ECE\u901A\u4FE1\u9274\u6743\u5BC6\u94A5")).action(async (engine, options) => {
+  const passthroughArgs = resolveWorkerPassthroughArgs(engine, "worker");
   await hookWorkerAction(engine, { ...options, passthroughArgs });
 });
+addWorkerRuntimeOptions(hook.command("local").argument("[engine]", "codex|gemini|claude", "codex").description("\u542F\u52A8\u672C\u673A\u4E00\u4F53\u8282\u70B9\uFF1A\u540C\u4E00\u8FDB\u7A0B\u5185\u542F\u52A8\u4E3B\u8282\u70B9\u548C\u672C\u5730\u4ECE\u8282\u70B9").option("--master-host <host>", "\u4E3B\u8282\u70B9\u76D1\u542C\u5730\u5740").option("--master-port <port>", "\u4E3B\u8282\u70B9\u7AEF\u53E3\uFF08\u9ED8\u8BA4 19732\uFF09").option("--shared-secret <secret>", "\u4E3B\u4ECE\u901A\u4FE1\u9274\u6743\u5BC6\u94A5").option("--claim-timeout-ms <ms>", "\u4EFB\u52A1\u8BA4\u9886\u8D85\u65F6\u6BEB\u79D2\u6570")).action(async (engine, options) => {
+  const passthroughArgs = resolveWorkerPassthroughArgs(engine, "local");
+  await hookLocalAction(engine, { ...options, passthroughArgs });
+});
 hook.command("log").argument("[query]", "\u53EF\u9009\uFF0CtraceId / messageId / \u5173\u952E\u5B57").description("\u67E5\u770B\u672C\u673A agent-block hook master/worker \u65E5\u5FD7").option("--worker", "\u53EA\u770B worker \u65E5\u5FD7", false).option("--slave", "\u53EA\u770B worker \u65E5\u5FD7\uFF08\u517C\u5BB9\u65E7 ai-hook \u4E60\u60EF\uFF09", false).option("--master", "\u53EA\u770B master \u65E5\u5FD7", false).option("-n, --lines <lines>", "\u9ED8\u8BA4\u8FD4\u56DE\u6700\u8FD1\u591A\u5C11\u884C\uFF0C\u9ED8\u8BA4 200").option("-f, --follow", "\u6301\u7EED\u8DDF\u968F\u65E5\u5FD7\u8F93\u51FA\uFF0C\u7B49\u4EF7 tail -f", false).option("-c, --context <lines>", "\u5E26 query \u65F6\u8FD4\u56DE\u524D\u540E\u6587\uFF0C\u9ED8\u8BA4 20").action(async (query, options) => {
   await hookLogAction(query, options);
 });