@dhf-claude/grix 0.1.8 → 0.1.9

package/dist/daemon.js

@@ -1049,11 +1049,11 @@ var hasColors, format, reset, bold, dim, italic, underline, overline, inverse, h
 var init_base = __esm({
   "node_modules/yoctocolors/base.js"() {
     hasColors = tty?.WriteStream?.prototype?.hasColors?.() ?? false;
-    format = (open3, close) => {
+    format = (open4, close) => {
       if (!hasColors) {
         return (input) => input;
       }
-      const openCode = `\x1B[${open3}m`;
+      const openCode = `\x1B[${open4}m`;
       const closeCode = `\x1B[${close}m`;
       return (input) => {
         const string = input + "";
@@ -1332,7 +1332,7 @@ var require_windows = __commonJS({
     module.exports = isexe;
     isexe.sync = sync;
     var fs = __require("fs");
-    function checkPathExt(path24, options) {
+    function checkPathExt(path25, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -1343,25 +1343,25 @@ var require_windows = __commonJS({
       }
       for (var i2 = 0; i2 < pathext.length; i2++) {
         var p = pathext[i2].toLowerCase();
-        if (p && path24.substr(-p.length).toLowerCase() === p) {
+        if (p && path25.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat3, path24, options) {
-      if (!stat3.isSymbolicLink() && !stat3.isFile()) {
+    function checkStat(stat4, path25, options) {
+      if (!stat4.isSymbolicLink() && !stat4.isFile()) {
         return false;
       }
-      return checkPathExt(path24, options);
+      return checkPathExt(path25, options);
     }
-    function isexe(path24, options, cb) {
-      fs.stat(path24, function(er, stat3) {
-        cb(er, er ? false : checkStat(stat3, path24, options));
+    function isexe(path25, options, cb) {
+      fs.stat(path25, function(er, stat4) {
+        cb(er, er ? false : checkStat(stat4, path25, options));
       });
     }
-    function sync(path24, options) {
-      return checkStat(fs.statSync(path24), path24, options);
+    function sync(path25, options) {
+      return checkStat(fs.statSync(path25), path25, options);
     }
   }
 });
@@ -1372,21 +1372,21 @@ var require_mode = __commonJS({
     module.exports = isexe;
     isexe.sync = sync;
     var fs = __require("fs");
-    function isexe(path24, options, cb) {
-      fs.stat(path24, function(er, stat3) {
-        cb(er, er ? false : checkStat(stat3, options));
+    function isexe(path25, options, cb) {
+      fs.stat(path25, function(er, stat4) {
+        cb(er, er ? false : checkStat(stat4, options));
       });
     }
-    function sync(path24, options) {
-      return checkStat(fs.statSync(path24), options);
+    function sync(path25, options) {
+      return checkStat(fs.statSync(path25), options);
     }
-    function checkStat(stat3, options) {
-      return stat3.isFile() && checkMode(stat3, options);
+    function checkStat(stat4, options) {
+      return stat4.isFile() && checkMode(stat4, options);
     }
-    function checkMode(stat3, options) {
-      var mod = stat3.mode;
-      var uid = stat3.uid;
-      var gid = stat3.gid;
+    function checkMode(stat4, options) {
+      var mod = stat4.mode;
+      var uid = stat4.uid;
+      var gid = stat4.gid;
       var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
       var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
       var u2 = parseInt("100", 8);
@@ -1411,7 +1411,7 @@ var require_isexe = __commonJS({
     }
     module.exports = isexe;
     isexe.sync = sync;
-    function isexe(path24, options, cb) {
+    function isexe(path25, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -1421,7 +1421,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve, reject) {
-          isexe(path24, options || {}, function(er, is) {
+          isexe(path25, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -1430,7 +1430,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path24, options || {}, function(er, is) {
+      core(path25, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -1440,9 +1440,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path24, options) {
+    function sync(path25, options) {
       try {
-        return core.sync(path24, options || {});
+        return core.sync(path25, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -1458,7 +1458,7 @@ var require_isexe = __commonJS({
 var require_which = __commonJS({
   "node_modules/which/which.js"(exports, module) {
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path24 = __require("path");
+    var path25 = __require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -1496,7 +1496,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path24.join(pathPart, cmd);
+        const pCmd = path25.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve(subStep(p, i2, 0));
       });
@@ -1523,7 +1523,7 @@ var require_which = __commonJS({
       for (let i2 = 0; i2 < pathEnv.length; i2++) {
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path24.join(pathPart, cmd);
+        const pCmd = path25.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -1571,7 +1571,7 @@ var require_path_key = __commonJS({
 var require_resolveCommand = __commonJS({
   "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
     "use strict";
-    var path24 = __require("path");
+    var path25 = __require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -1589,7 +1589,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path24.delimiter : void 0
+          pathExt: withoutPathExt ? path25.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -1598,7 +1598,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path24.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path25.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -1652,8 +1652,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path24, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path24.split("/").pop();
+      const [path25, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path25.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -1688,7 +1688,7 @@ var require_readShebang = __commonJS({
 var require_parse = __commonJS({
   "node_modules/cross-spawn/lib/parse.js"(exports, module) {
     "use strict";
-    var path24 = __require("path");
+    var path25 = __require("path");
     var resolveCommand = require_resolveCommand();
     var escape = require_escape();
     var readShebang = require_readShebang();
@@ -1713,7 +1713,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path24.normalize(parsed.command);
+        parsed.command = path25.normalize(parsed.command);
         parsed.command = escape.command(parsed.command);
         parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -1809,7 +1809,7 @@ var require_cross_spawn = __commonJS({
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
-    function spawnSync3(command, args, options) {
+    function spawnSync4(command, args, options) {
       const parsed = parse(command, args, options);
       const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
@@ -1817,7 +1817,7 @@ var require_cross_spawn = __commonJS({
     }
     module.exports = spawn4;
     module.exports.spawn = spawn4;
-    module.exports.sync = spawnSync3;
+    module.exports.sync = spawnSync4;
     module.exports._parse = parse;
     module.exports._enoent = enoent;
   }
@@ -5843,13 +5843,13 @@ var init_output_sync = __esm({
       }
     };
     writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-      for (const { path: path24, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
-        const pathString = typeof path24 === "string" ? path24 : path24.toString();
+      for (const { path: path25, append } of stdioItems.filter(({ type }) => FILE_TYPES.has(type))) {
+        const pathString = typeof path25 === "string" ? path25 : path25.toString();
         if (append || outputFiles.has(pathString)) {
-          appendFileSync(path24, serializedResult);
+          appendFileSync(path25, serializedResult);
         } else {
           outputFiles.add(pathString);
-          writeFileSync(path24, serializedResult);
+          writeFileSync(path25, serializedResult);
         }
       }
     };
@@ -6780,7 +6780,7 @@ var processOk, kExitEmitter, global2, ObjectDefineProperty, Emitter, SignalExitB
 var init_mjs = __esm({
   "node_modules/signal-exit/dist/mjs/index.js"() {
     init_signals2();
-    processOk = (process17) => !!process17 && typeof process17 === "object" && typeof process17.removeListener === "function" && typeof process17.emit === "function" && typeof process17.reallyExit === "function" && typeof process17.listeners === "function" && typeof process17.kill === "function" && typeof process17.pid === "number" && typeof process17.on === "function";
+    processOk = (process18) => !!process18 && typeof process18 === "object" && typeof process18.removeListener === "function" && typeof process18.emit === "function" && typeof process18.reallyExit === "function" && typeof process18.listeners === "function" && typeof process18.kill === "function" && typeof process18.pid === "number" && typeof process18.on === "function";
     kExitEmitter = /* @__PURE__ */ Symbol.for("signal-exit emitter");
     global2 = globalThis;
     ObjectDefineProperty = Object.defineProperty.bind(Object);
@@ -6873,15 +6873,15 @@ var init_mjs = __esm({
       #originalProcessReallyExit;
       #sigListeners = {};
       #loaded = false;
-      constructor(process17) {
+      constructor(process18) {
         super();
-        this.#process = process17;
+        this.#process = process18;
         this.#sigListeners = {};
         for (const sig of signals) {
           this.#sigListeners[sig] = () => {
             const listeners = this.#process.listeners(sig);
             let { count: count2 } = this.#emitter;
-            const p = process17;
+            const p = process18;
             if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
               count2 += p.__signal_exit_emitter__.count;
             }
@@ -6890,12 +6890,12 @@ var init_mjs = __esm({
               const ret = this.#emitter.emit("exit", null, sig);
               const s = sig === "SIGHUP" ? this.#hupSig : sig;
               if (!ret)
-                process17.kill(process17.pid, s);
+                process18.kill(process18.pid, s);
             }
           };
         }
-        this.#originalProcessReallyExit = process17.reallyExit;
-        this.#originalProcessEmit = process17.emit;
+        this.#originalProcessReallyExit = process18.reallyExit;
+        this.#originalProcessEmit = process18.emit;
       }
       onExit(cb, opts) {
         if (!processOk(this.#process)) {
@@ -8649,7 +8649,7 @@ var require_bin = __commonJS({
 var require_ps = __commonJS({
   "node_modules/pidtree/lib/ps.js"(exports, module) {
     "use strict";
-    var os7 = __require("os");
+    var os8 = __require("os");
     var bin = require_bin();
     function ps(callback) {
       var args = ["-A", "-o", "ppid,pid"];
@@ -8659,7 +8659,7 @@ var require_ps = __commonJS({
           return callback(new Error("pidtree ps command exited with code " + code));
         }
         try {
-          stdout = stdout.split(os7.EOL);
+          stdout = stdout.split(os8.EOL);
           var list = [];
           for (var i2 = 1; i2 < stdout.length; i2++) {
             stdout[i2] = stdout[i2].trim();
@@ -8683,7 +8683,7 @@ var require_ps = __commonJS({
 var require_wmic = __commonJS({
   "node_modules/pidtree/lib/wmic.js"(exports, module) {
     "use strict";
-    var os7 = __require("os");
+    var os8 = __require("os");
     var bin = require_bin();
     function wmic(callback) {
       var args = ["PROCESS", "get", "ParentProcessId,ProcessId"];
@@ -8698,7 +8698,7 @@ var require_wmic = __commonJS({
           return;
         }
         try {
-          stdout = stdout.split(os7.EOL);
+          stdout = stdout.split(os8.EOL);
           var list = [];
           for (var i2 = 1; i2 < stdout.length; i2++) {
             stdout[i2] = stdout[i2].trim();
@@ -8722,7 +8722,7 @@ var require_wmic = __commonJS({
 var require_get = __commonJS({
   "node_modules/pidtree/lib/get.js"(exports, module) {
     "use strict";
-    var os7 = __require("os");
+    var os8 = __require("os");
     var platformToMethod = {
       darwin: "ps",
       sunos: "ps",
@@ -8736,7 +8736,7 @@ var require_get = __commonJS({
       ps: () => require_ps(),
       wmic: () => require_wmic()
     };
-    var platform2 = os7.platform();
+    var platform2 = os8.platform();
     if (platform2.startsWith("win")) {
       platform2 = "win";
     }
@@ -8745,7 +8745,7 @@ var require_get = __commonJS({
       if (method === void 0) {
         callback(
           new Error(
-            os7.platform() + " is not supported yet, please open an issue (https://github.com/simonepri/pidtree)"
+            os8.platform() + " is not supported yet, please open an issue (https://github.com/simonepri/pidtree)"
           )
         );
       }
@@ -9429,32 +9429,6 @@ function canDeliverToWorker(binding) {
   const responseState = normalizeWorkerResponseState(binding?.worker_response_state);
   return hasReadyWorkerBridge(binding) && responseState === "healthy";
 }
-function formatWorkerResponseAssessment(binding) {
-  const workerStatus = normalizeString10(binding?.worker_status);
-  const responseState = normalizeWorkerResponseState(binding?.worker_response_state);
-  if (workerStatus === "ready") {
-    if (responseState === "healthy") {
-      return "\u53EF\u7528\uFF08\u6700\u8FD1\u4E00\u6B21\u771F\u5B9E\u4EA4\u4E92\u5DF2\u9A8C\u8BC1\uFF09";
-    }
-    if (responseState === "probing") {
-      return "\u63A2\u6D4B\u4E2D\uFF08\u6B63\u5728\u7B49\u5F85 ping/pong\uFF09";
-    }
-    if (responseState === "failed") {
-      return "\u5F02\u5E38\uFF08\u6700\u8FD1\u4E00\u6B21\u771F\u5B9E\u4EA4\u4E92\u5931\u8D25\uFF09";
-    }
-    return "\u5F85\u9A8C\u8BC1\uFF08\u5DF2\u5C31\u7EEA\uFF0C\u4F46\u8FD8\u6CA1\u6709\u771F\u5B9E\u4EA4\u4E92\u8BC1\u660E\uFF09";
-  }
-  if (workerStatus === "starting" || workerStatus === "connected") {
-    return "\u542F\u52A8\u4E2D";
-  }
-  if (workerStatus === "stopped") {
-    return "\u5DF2\u505C\u6B62";
-  }
-  if (workerStatus === "failed") {
-    return "\u5DF2\u5931\u8D25";
-  }
-  return "\u672A\u77E5";
-}
 var init_worker_state = __esm({
   "server/daemon/worker-state.js"() {
   }
@@ -10380,7 +10354,9 @@ var init_worker_bridge_server = __esm({
         onSendEventResult = null,
         onSendEventStopAck = null,
         onSendEventStopResult = null,
-        onSetSessionComposing = null
+        onSetSessionComposing = null,
+        onAgentInvoke = null,
+        onLocalActionResult = null
       } = {}) {
         this.host = host;
         this.port = port;
@@ -10396,6 +10372,8 @@ var init_worker_bridge_server = __esm({
         this.onSendEventStopAck = typeof onSendEventStopAck === "function" ? onSendEventStopAck : null;
         this.onSendEventStopResult = typeof onSendEventStopResult === "function" ? onSendEventStopResult : null;
         this.onSetSessionComposing = typeof onSetSessionComposing === "function" ? onSetSessionComposing : null;
+        this.onAgentInvoke = typeof onAgentInvoke === "function" ? onAgentInvoke : null;
+        this.onLocalActionResult = typeof onLocalActionResult === "function" ? onLocalActionResult : null;
         this.server = null;
         this.address = null;
       }
@@ -10438,6 +10416,8 @@ var init_worker_bridge_server = __esm({
         const server = this.server;
         this.server = null;
         this.address = null;
+        server.closeIdleConnections?.();
+        server.closeAllConnections?.();
         await new Promise((resolve, reject) => {
           server.close((error) => {
             if (error) {
@@ -10576,6 +10556,30 @@ var init_worker_bridge_server = __esm({
           ok(response, result ?? { ok: true });
           return;
         }
+        if (pathname === "/v1/worker/agent-invoke") {
+          this.trace({
+            stage: "worker_agent_invoke_received",
+            worker_id: payload?.worker_id,
+            aibot_session_id: payload?.aibot_session_id,
+            invoke_id: payload?.invoke_id,
+            action: payload?.action
+          });
+          const result = this.onAgentInvoke ? await this.onAgentInvoke(payload) : { code: 4004, msg: "agent invoke handler is not configured" };
+          ok(response, result ?? { code: 4004, msg: "agent invoke handler is not configured" });
+          return;
+        }
+        if (pathname === "/v1/worker/local-action-result") {
+          this.trace({
+            stage: "worker_local_action_result_received",
+            worker_id: payload?.worker_id,
+            aibot_session_id: payload?.aibot_session_id,
+            action_id: payload?.action_id,
+            status: payload?.status
+          });
+          const result = this.onLocalActionResult ? await this.onLocalActionResult(payload) : { ok: true };
+          ok(response, result ?? { ok: true });
+          return;
+        }
         notFound(response);
       }
     };
@@ -10788,7 +10792,7 @@ var init_paths = __esm({
 });
 
 // server/hook-signal-store.js
-import { appendFile, mkdir as mkdir9 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir9, open as open2, rm as rm5, stat } from "node:fs/promises";
 import path19 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 function normalizeString17(value) {
@@ -10805,12 +10809,21 @@ function pickHookEventDetail(input = {}, hookEventName) {
   if (hookEventName === "SessionStart") {
     return normalizeString17(input.source);
   }
+  if (hookEventName === "PermissionRequest") {
+    return normalizeString17(input.tool_name);
+  }
   if (hookEventName === "PostToolUse" || hookEventName === "PostToolUseFailure") {
     return normalizeString17(input.tool_name);
   }
+  if (hookEventName === "PermissionDenied") {
+    return normalizeString17(input.tool_name) || normalizeString17(input.reason);
+  }
   if (hookEventName === "Elicitation") {
     return normalizeString17(input.mode);
   }
+  if (hookEventName === "ElicitationResult") {
+    return normalizeString17(input.action) || normalizeString17(input.mode);
+  }
   if (hookEventName === "Notification") {
     return normalizeString17(input.matcher) || normalizeString17(input.notification_type) || normalizeString17(input.type);
   }
@@ -10829,11 +10842,7 @@ function normalizeHookSignalEvent(input) {
     event_id: eventID,
     hook_event_name: hookEventName,
     event_at: normalizeOptionalTimestamp3(input.event_at),
-    detail: normalizeString17(input.detail),
-    tool_name: normalizeString17(input.tool_name),
-    session_id: normalizeString17(input.session_id),
-    cwd: normalizeString17(input.cwd),
-    transcript_path: normalizeString17(input.transcript_path)
+    detail: normalizeString17(input.detail)
   };
 }
 function normalizeState4(input) {
@@ -10856,6 +10865,26 @@ function normalizeState4(input) {
 function resolveHookSignalsPath(pluginID) {
   return path19.join(resolvePluginDataDir(pluginID), "hook-signals.json");
 }
+function resolveHookSignalsLockPathFromDataDir(pluginDataDir, pluginID) {
+  const normalizedDir = normalizeString17(pluginDataDir);
+  if (normalizedDir) {
+    return path19.join(normalizedDir, "hook-signals.lock");
+  }
+  return path19.join(resolvePluginDataDir(pluginID), "hook-signals.lock");
+}
+function sleep(delayMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+async function readLockAgeMs(filePath) {
+  try {
+    const details = await stat(filePath);
+    return Date.now() - Number(details.mtimeMs ?? 0);
+  } catch {
+    return 0;
+  }
+}
 function buildHookSignalEvent(input, { recordedAt = Date.now() } = {}) {
   const hookEventName = normalizeString17(input?.hook_event_name);
   if (!hookEventName) {
@@ -10865,24 +10894,10 @@ function buildHookSignalEvent(input, { recordedAt = Date.now() } = {}) {
     event_id: randomUUID3(),
     hook_event_name: hookEventName,
     event_at: normalizeOptionalTimestamp3(recordedAt) || Date.now(),
-    detail: pickHookEventDetail(input, hookEventName),
-    tool_name: normalizeString17(input?.tool_name),
-    session_id: normalizeString17(input?.session_id),
-    cwd: normalizeString17(input?.cwd),
-    transcript_path: normalizeString17(input?.transcript_path)
+    detail: pickHookEventDetail(input, hookEventName)
   };
 }
-function summarizeHookSignalEvent(event) {
-  const normalized = normalizeHookSignalEvent(event);
-  if (!normalized) {
-    return "";
-  }
-  if (normalized.detail) {
-    return `${normalized.hook_event_name}:${normalized.detail}`;
-  }
-  return normalized.hook_event_name;
-}
-var schemaVersion4, defaultRecentEventLimit, HookSignalStore;
+var schemaVersion4, defaultRecentEventLimit, defaultLockTimeoutMs, defaultLockPollMs, defaultLockStaleMs, HookSignalStore;
 var init_hook_signal_store = __esm({
   "server/hook-signal-store.js"() {
     init_json_file();
@@ -10890,10 +10905,17 @@ var init_hook_signal_store = __esm({
     init_paths();
     schemaVersion4 = 1;
     defaultRecentEventLimit = 20;
+    defaultLockTimeoutMs = 5e3;
+    defaultLockPollMs = 25;
+    defaultLockStaleMs = 3e4;
     HookSignalStore = class {
-      constructor(filePath = resolveHookSignalsPath(), { logPath = path19.join(path19.dirname(filePath), "hook-signals.log") } = {}) {
+      constructor(filePath = resolveHookSignalsPath(), {
+        logPath = path19.join(path19.dirname(filePath), "hook-signals.log"),
+        lockPath = resolveHookSignalsLockPathFromDataDir(path19.dirname(filePath))
+      } = {}) {
         this.filePath = filePath;
         this.logPath = logPath;
+        this.lockPath = lockPath;
       }
       async readState() {
         const stored = await readJSONFile(this.filePath, null);
@@ -10903,9 +10925,54 @@ var init_hook_signal_store = __esm({
         await mkdir9(path19.dirname(this.filePath), { recursive: true });
         await writeJSONFileAtomic(this.filePath, normalizeState4(state));
       }
+      async withStateLock(callback, {
+        timeoutMs = defaultLockTimeoutMs,
+        pollMs = defaultLockPollMs,
+        staleMs = defaultLockStaleMs
+      } = {}) {
+        await mkdir9(path19.dirname(this.lockPath), { recursive: true });
+        const deadlineAt = Date.now() + Math.max(1, Number(timeoutMs) || defaultLockTimeoutMs);
+        while (Date.now() < deadlineAt) {
+          let handle = null;
+          try {
+            handle = await open2(this.lockPath, "wx", 384);
+            await handle.writeFile(JSON.stringify({
+              schema_version: schemaVersion4,
+              pid: process.pid,
+              acquired_at: Date.now()
+            }), "utf8");
+            try {
+              return await callback();
+            } finally {
+              await handle.close().catch(() => {
+              });
+              await rm5(this.lockPath, { force: true }).catch(() => {
+              });
+            }
+          } catch (error) {
+            if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
+              if (handle) {
+                await handle.close().catch(() => {
+                });
+              }
+              throw error;
+            }
+            const lockAgeMs = await readLockAgeMs(this.lockPath);
+            if (lockAgeMs > staleMs) {
+              await rm5(this.lockPath, { force: true }).catch(() => {
+              });
+              continue;
+            }
+            await sleep(Math.min(pollMs, Math.max(1, deadlineAt - Date.now())));
+          }
+        }
+        throw new Error("hook signal store lock timeout");
+      }
       async reset() {
-        await this.writeState(normalizeState4(null));
-        return this.readState();
+        return this.withStateLock(async () => {
+          await this.writeState(normalizeState4(null));
+          return this.readState();
+        });
       }
       async appendEventLog(event) {
         const normalized = normalizeHookSignalEvent(event);
@@ -10918,11 +10985,7 @@ var init_hook_signal_store = __esm({
           event_id: normalized.event_id,
           hook_event_name: normalized.hook_event_name,
           hook_detail: normalized.detail,
-          event_at: normalized.event_at,
-          tool_name: normalized.tool_name,
-          session_id: normalized.session_id,
-          cwd: normalized.cwd,
-          transcript_path: normalized.transcript_path
+          event_at: normalized.event_at
         })}
 `, "utf8");
         return true;
@@ -10935,29 +10998,100 @@ var init_hook_signal_store = __esm({
         if (!nextEvent) {
           return this.readState();
         }
-        const current = await this.readState();
-        const nextState = {
-          schema_version: schemaVersion4,
-          updated_at: nextEvent.event_at,
-          latest_event: nextEvent,
-          recent_events: [
+        return this.withStateLock(async () => {
+          const current = await this.readState();
+          const recentEvents = [
             ...current.recent_events,
             nextEvent
-          ].slice(-Math.max(1, Number(recentEventLimit) || defaultRecentEventLimit))
-        };
-        await this.writeState(nextState);
-        await this.appendEventLog(nextEvent);
-        return normalizeState4(nextState);
+          ].sort((left, right) => left.event_at - right.event_at).slice(-Math.max(1, Number(recentEventLimit) || defaultRecentEventLimit));
+          const latestEvent = !current.latest_event || nextEvent.event_at >= current.updated_at ? nextEvent : current.latest_event;
+          const nextState = {
+            schema_version: schemaVersion4,
+            updated_at: Math.max(current.updated_at, nextEvent.event_at),
+            latest_event: latestEvent,
+            recent_events: recentEvents
+          };
+          await this.writeState(nextState);
+          await this.appendEventLog(nextEvent);
+          return normalizeState4(nextState);
+        });
       }
     };
   }
 });
 
-// server/daemon/worker-process.js
-import { chmod as chmod2, mkdir as mkdir10, open as open2, readdir, readFile as readFile4, stat, writeFile as writeFile3 } from "node:fs/promises";
-import { execSync, spawn as spawn3 } from "node:child_process";
+// server/claude-command.js
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { accessSync, constants as fsConstants } from "node:fs";
+import os7 from "node:os";
 import path20 from "node:path";
 import process13 from "node:process";
+function normalizeString18(value) {
+  return String(value ?? "").trim();
+}
+function defaultClaudeCommandName(platform2 = process13.platform) {
+  return platform2 === "win32" ? "claude.cmd" : "claude";
+}
+function buildClaudeCommandCandidates(env = process13.env) {
+  const candidates = [];
+  const explicit = normalizeString18(env.CLAUDE_BIN);
+  if (explicit) {
+    candidates.push(explicit);
+  }
+  const commandName = defaultClaudeCommandName();
+  candidates.push(commandName);
+  if (process13.platform !== "win32") {
+    const homeDir = normalizeString18(env.HOME || env.USERPROFILE) || os7.homedir();
+    if (homeDir) {
+      candidates.push(path20.join(homeDir, ".local", "bin", "claude"));
+    }
+    candidates.push("/opt/homebrew/bin/claude");
+    candidates.push("/usr/local/bin/claude");
+  }
+  return Array.from(new Set(candidates.filter((value) => normalizeString18(value))));
+}
+function claudeCommandExists(command, env = process13.env) {
+  const normalized = normalizeString18(command);
+  if (!normalized) {
+    return false;
+  }
+  if (path20.isAbsolute(normalized) || normalized.includes(path20.sep)) {
+    try {
+      accessSync(normalized, fsConstants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  const locator = process13.platform === "win32" ? "where" : "which";
+  const located = spawnSync3(locator, [normalized], {
+    stdio: "ignore",
+    env
+  });
+  return located.status === 0;
+}
+function resolveClaudeCommand(env = process13.env) {
+  const explicit = normalizeString18(env.CLAUDE_BIN);
+  if (explicit) {
+    return explicit;
+  }
+  for (const candidate of buildClaudeCommandCandidates(env)) {
+    if (claudeCommandExists(candidate, env)) {
+      return candidate;
+    }
+  }
+  return defaultClaudeCommandName();
+}
+var init_claude_command = __esm({
+  "server/claude-command.js"() {
+  }
+});
+
+// server/daemon/worker-process.js
+import { chmod as chmod2, mkdir as mkdir10, open as open3, readdir, readFile as readFile4, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import { execSync, spawn as spawn3 } from "node:child_process";
+import path21 from "node:path";
+import process14 from "node:process";
 import { randomUUID as randomUUID4 } from "node:crypto";
 function stripTerminalControlSequences(content) {
   return String(content ?? "").replace(/\u001B\][^\u0007]*(?:\u0007|\u001B\\)/gu, " ").replace(/\u001B\[[0-?]*[ -/]*[@-~]/gu, " ").replace(/\r/g, "\n");
@@ -10969,7 +11103,7 @@ function patternMatches(pattern, content) {
   pattern.lastIndex = 0;
   return pattern.test(content);
 }
-function normalizeString18(value) {
+function normalizeString19(value) {
   return String(value ?? "").trim();
 }
 function normalizeNonNegativeOffset(value) {
@@ -10990,13 +11124,13 @@ async function readLogSlice(filePath, {
   startOffset = 0,
   maxBytes = 0
 } = {}) {
-  const normalizedPath = normalizeString18(filePath);
+  const normalizedPath = normalizeString19(filePath);
   if (!normalizedPath) {
     return "";
   }
   let fileSize = 0;
   try {
-    const info = await stat(normalizedPath);
+    const info = await stat2(normalizedPath);
     fileSize = normalizeNonNegativeOffset(info?.size);
   } catch {
     return "";
@@ -11013,7 +11147,7 @@ async function readLogSlice(filePath, {
   if (bytesToRead <= 0) {
     return "";
   }
-  const handle = await open2(normalizedPath, "r");
+  const handle = await open3(normalizedPath, "r");
   try {
     const buffer = Buffer.alloc(bytesToRead);
     const { bytesRead = 0 } = await handle.read(buffer, 0, bytesToRead, start);
@@ -11023,12 +11157,6 @@ async function readLogSlice(filePath, {
     });
   }
 }
-function resolveClaudeCommand(env = process13.env) {
-  if (process13.platform === "win32") {
-    return env.CLAUDE_BIN || "claude.cmd";
-  }
-  return env.CLAUDE_BIN || "claude";
-}
 function shellEscape(value) {
   return `'${String(value ?? "").replace(/'/g, `'\\''`)}'`;
 }
@@ -11063,24 +11191,24 @@ function buildVisibleTerminalCleanupLines() {
   ];
 }
 function buildShellEnvArgs(env) {
-  return Object.entries(env).filter(([key, value]) => normalizeString18(key) && !String(key).includes("=") && value !== void 0).map(([key, value]) => shellEscape(`${String(key)}=${String(value ?? "")}`));
+  return Object.entries(env).filter(([key, value]) => normalizeString19(key) && !String(key).includes("=") && value !== void 0).map(([key, value]) => shellEscape(`${String(key)}=${String(value ?? "")}`));
 }
-function shouldShowClaudeWindow(env = process13.env) {
+function shouldShowClaudeWindow(env = process14.env) {
   return env.GRIX_CLAUDE_SHOW_CLAUDE_WINDOW === "1";
 }
 function buildWorkerSessionName(aibotSessionID) {
-  const normalized = normalizeString18(aibotSessionID).replace(/[^a-zA-Z0-9._-]+/g, "-");
+  const normalized = normalizeString19(aibotSessionID).replace(/[^a-zA-Z0-9._-]+/g, "-");
   return normalized ? `grix-${normalized}` : "grix-worker";
 }
 function resolveWorkerLogPaths({ logsDir, workerID }) {
-  const normalizedWorkerID = normalizeString18(workerID) || randomUUID4();
+  const normalizedWorkerID = normalizeString19(workerID) || randomUUID4();
   return {
-    stdoutLogPath: path20.join(logsDir, `${normalizedWorkerID}.out.log`),
-    stderrLogPath: path20.join(logsDir, `${normalizedWorkerID}.err.log`)
+    stdoutLogPath: path21.join(logsDir, `${normalizedWorkerID}.out.log`),
+    stderrLogPath: path21.join(logsDir, `${normalizedWorkerID}.err.log`)
   };
 }
 function buildWorkerEnvironment({
-  baseEnv = process13.env,
+  baseEnv = process14.env,
   pluginDataDir,
   aibotSessionID,
   claudeSessionID,
@@ -11091,18 +11219,18 @@ function buildWorkerEnvironment({
 }) {
   const env = {
     ...baseEnv,
-    CLAUDE_PLUGIN_DATA: normalizeString18(pluginDataDir),
-    GRIX_CLAUDE_AIBOT_SESSION_ID: normalizeString18(aibotSessionID),
-    GRIX_CLAUDE_SESSION_ID: normalizeString18(claudeSessionID),
+    CLAUDE_PLUGIN_DATA: normalizeString19(pluginDataDir),
+    GRIX_CLAUDE_AIBOT_SESSION_ID: normalizeString19(aibotSessionID),
+    GRIX_CLAUDE_SESSION_ID: normalizeString19(claudeSessionID),
     GRIX_CLAUDE_DAEMON_MODE: "1",
-    GRIX_CLAUDE_WORKER_ID: normalizeString18(workerID),
-    GRIX_CLAUDE_DAEMON_BRIDGE_URL: normalizeString18(bridgeURL),
-    GRIX_CLAUDE_DAEMON_BRIDGE_TOKEN: normalizeString18(bridgeToken)
+    GRIX_CLAUDE_WORKER_ID: normalizeString19(workerID),
+    GRIX_CLAUDE_DAEMON_BRIDGE_URL: normalizeString19(bridgeURL),
+    GRIX_CLAUDE_DAEMON_BRIDGE_TOKEN: normalizeString19(bridgeToken)
   };
   if (connectionConfig) {
-    env.GRIX_CLAUDE_WS_URL = normalizeString18(connectionConfig.wsURL);
-    env.GRIX_CLAUDE_AGENT_ID = normalizeString18(connectionConfig.agentID);
-    env.GRIX_CLAUDE_API_KEY = normalizeString18(connectionConfig.apiKey);
+    env.GRIX_CLAUDE_WS_URL = normalizeString19(connectionConfig.wsURL);
+    env.GRIX_CLAUDE_AGENT_ID = normalizeString19(connectionConfig.agentID);
+    env.GRIX_CLAUDE_API_KEY = normalizeString19(connectionConfig.apiKey);
     if (Number.isFinite(Number(connectionConfig.outboundTextChunkLimit))) {
       env.GRIX_CLAUDE_OUTBOUND_TEXT_CHUNK_LIMIT = String(
         Math.floor(Number(connectionConfig.outboundTextChunkLimit))
@@ -11117,8 +11245,8 @@ function buildWorkerClaudeArgs({
   claudeSessionID,
   resumeSession = false
 }) {
-  const normalizedPackageRoot = normalizeString18(packageRoot);
-  const normalizedClaudeSessionID = normalizeString18(claudeSessionID);
+  const normalizedPackageRoot = normalizeString19(packageRoot);
+  const normalizedClaudeSessionID = normalizeString19(claudeSessionID);
   if (!normalizedPackageRoot) {
     throw new Error("packageRoot is required");
   }
@@ -11153,10 +11281,10 @@ async function createVisibleClaudeLaunchScript({
   captureOutputInExpectLog = true
 }) {
   await mkdir10(logsDir, { recursive: true });
-  const normalizedWorkerID = normalizeString18(workerID) || randomUUID4();
-  const scriptPath = path20.join(logsDir, `${normalizedWorkerID}.launch.command`);
-  const expectPath = path20.join(logsDir, `${normalizedWorkerID}.launch.expect`);
-  const pidPath = path20.join(logsDir, `${normalizedWorkerID}.pid`);
+  const normalizedWorkerID = normalizeString19(workerID) || randomUUID4();
+  const scriptPath = path21.join(logsDir, `${normalizedWorkerID}.launch.command`);
+  const expectPath = path21.join(logsDir, `${normalizedWorkerID}.launch.expect`);
+  const pidPath = path21.join(logsDir, `${normalizedWorkerID}.pid`);
   const { stdoutLogPath } = resolveWorkerLogPaths({
     logsDir,
     workerID: normalizedWorkerID
@@ -11256,7 +11384,7 @@ async function launchClaudeInVisibleTerminal({
   env,
   spawnImpl
 }) {
-  if (process13.platform !== "darwin") {
+  if (process14.platform !== "darwin") {
     throw new Error("show-claude currently only supports macOS Terminal");
   }
   const { scriptPath, pidPath } = await createVisibleClaudeLaunchScript({
@@ -11350,17 +11478,17 @@ async function launchClaudeInHiddenPty({
   };
 }
 function resolveWorkerPIDPath(logsDir, workerID) {
-  const normalizedWorkerID = normalizeString18(workerID) || randomUUID4();
-  return path20.join(logsDir, `${normalizedWorkerID}.pid`);
+  const normalizedWorkerID = normalizeString19(workerID) || randomUUID4();
+  return path21.join(logsDir, `${normalizedWorkerID}.pid`);
 }
 async function listManagedPIDFiles(logsDir) {
-  const normalizedLogsDir = normalizeString18(logsDir);
+  const normalizedLogsDir = normalizeString19(logsDir);
   if (!normalizedLogsDir) {
     return [];
   }
   try {
     const entries = await readdir(normalizedLogsDir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".pid")).map((entry) => path20.join(normalizedLogsDir, entry.name));
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".pid")).map((entry) => path21.join(normalizedLogsDir, entry.name));
   } catch {
     return [];
   }
@@ -11383,6 +11511,7 @@ var init_worker_process = __esm({
     init_mcp();
     init_daemon_paths();
     init_hook_signal_store();
+    init_claude_command();
     init_process_control();
     missingResumeSessionPattern = /No conversation found with session ID:/u;
     authLoginRequiredPatterns = [
@@ -11410,7 +11539,7 @@ var init_worker_process = __esm({
     startupMcpServerFailedMarkerPattern = /\[grix\]\s+startup_mcp_server_failed/u;
     WorkerProcessManager = class {
       constructor({
-        env = process13.env,
+        env = process14.env,
         packageRoot = resolvePackageRoot(),
         connectionConfig = null,
         spawnImpl = spawn3,
@@ -11430,14 +11559,14 @@ var init_worker_process = __esm({
         this.spawnQueues = /* @__PURE__ */ new Map();
       }
       getWorkerRuntime(workerID) {
-        const runtime = this.runtimes.get(normalizeString18(workerID));
+        const runtime = this.runtimes.get(normalizeString19(workerID));
         return runtime ? { ...runtime } : null;
       }
       markWorkerRuntimeStopped(workerID, {
         exitCode = 0,
         exitSignal = ""
       } = {}) {
-        const normalizedWorkerID = normalizeString18(workerID);
+        const normalizedWorkerID = normalizeString19(workerID);
         if (!normalizedWorkerID) {
           return null;
         }
@@ -11449,7 +11578,7 @@ var init_worker_process = __esm({
           ...current,
           status: "stopped",
           exit_code: Number(exitCode ?? 0),
-          exit_signal: normalizeString18(exitSignal),
+          exit_signal: normalizeString19(exitSignal),
           stopped_at: Date.now()
         };
         this.runtimes.set(normalizedWorkerID, next);
@@ -11460,7 +11589,7 @@ var init_worker_process = __esm({
         const serverEntryPath = resolveServerEntryPath(this.packageRoot);
         await this.ensureUserMcpServer({
           claudeCommand,
-          serverCommand: process13.execPath,
+          serverCommand: process14.execPath,
           serverArgs: [serverEntryPath],
           env
         });
@@ -11471,7 +11600,7 @@ var init_worker_process = __esm({
       }
       async cleanupStaleManagedProcesses(aibotSessionIDs = []) {
         const normalizedSessionIDs = Array.from(new Set(
-          (Array.isArray(aibotSessionIDs) ? aibotSessionIDs : []).map((value) => normalizeString18(value)).filter((value) => value)
+          (Array.isArray(aibotSessionIDs) ? aibotSessionIDs : []).map((value) => normalizeString19(value)).filter((value) => value)
         ));
         if (normalizedSessionIDs.length === 0) {
           return [];
@@ -11496,7 +11625,7 @@ var init_worker_process = __esm({
           if (!entry?.pid) {
             continue;
           }
-          await this.terminateProcessTree(entry.pid, { platform: process13.platform });
+          await this.terminateProcessTree(entry.pid, { platform: process14.platform });
           terminatedPIDs.push(entry.pid);
           if (entry.pidPath) {
             await writeFile3(entry.pidPath, "", "utf8").catch(() => {
@@ -11511,7 +11640,7 @@ var init_worker_process = __esm({
             );
             const orphanPIDs = output.trim().split("\n").map(Number).filter((n2) => n2 > 0);
             for (const pid of orphanPIDs) {
-              await this.terminateProcessTree(pid, { platform: process13.platform });
+              await this.terminateProcessTree(pid, { platform: process14.platform });
               terminatedPIDs.push(pid);
             }
           } catch {
@@ -11520,7 +11649,7 @@ var init_worker_process = __esm({
         return terminatedPIDs;
       }
       enqueueSpawnForSession(aibotSessionID, task) {
-        const normalizedSessionID = normalizeString18(aibotSessionID);
+        const normalizedSessionID = normalizeString19(aibotSessionID);
         if (!normalizedSessionID || typeof task !== "function") {
           return Promise.resolve().then(task);
         }
@@ -11546,18 +11675,18 @@ var init_worker_process = __esm({
         bridgeToken = "",
         resumeSession = false
       }) {
-        const normalizedWorkerID = normalizeString18(workerID) || randomUUID4();
-        const normalizedSessionID = normalizeString18(aibotSessionID);
-        const normalizedCwd = normalizeString18(cwd);
-        const normalizedPluginDataDir = normalizeString18(pluginDataDir);
-        const normalizedClaudeSessionID = normalizeString18(claudeSessionID) || randomUUID4();
+        const normalizedWorkerID = normalizeString19(workerID) || randomUUID4();
+        const normalizedSessionID = normalizeString19(aibotSessionID);
+        const normalizedCwd = normalizeString19(cwd);
+        const normalizedPluginDataDir = normalizeString19(pluginDataDir);
+        const normalizedClaudeSessionID = normalizeString19(claudeSessionID) || randomUUID4();
         if (!normalizedSessionID || !normalizedCwd || !normalizedPluginDataDir) {
           throw new Error("aibotSessionID, cwd, and pluginDataDir are required");
         }
         return this.enqueueSpawnForSession(normalizedSessionID, async () => {
           const logsDir = resolveWorkerLogsDir(normalizedSessionID, this.env);
           await mkdir10(logsDir, { recursive: true });
-          await new HookSignalStore(path20.join(normalizedPluginDataDir, "hook-signals.json")).reset();
+          await new HookSignalStore(path21.join(normalizedPluginDataDir, "hook-signals.json")).reset();
           const workerEnv = buildWorkerEnvironment({
             baseEnv: this.env,
             pluginDataDir: normalizedPluginDataDir,
@@ -11584,8 +11713,8 @@ var init_worker_process = __esm({
             logsDir,
             workerID: normalizedWorkerID
           });
-          const stdoutHandle = await open2(stdoutLogPath, "w");
-          const stderrHandle = await open2(stderrLogPath, "w");
+          const stdoutHandle = await open3(stdoutLogPath, "w");
+          const stderrHandle = await open3(stderrLogPath, "w");
           let deferFDClose = false;
           try {
             await this.cleanupStaleManagedProcesses([normalizedSessionID]);
@@ -11604,8 +11733,8 @@ var init_worker_process = __esm({
                 spawnImpl: this.spawnImpl
               });
               pid = Number(visibleTerminal.pid ?? 0);
-              pidPath = normalizeString18(visibleTerminal.pidPath);
-            } else if (process13.platform === "darwin") {
+              pidPath = normalizeString19(visibleTerminal.pidPath);
+            } else if (process14.platform === "darwin") {
               const hiddenPty = await launchClaudeInHiddenPty({
                 logsDir,
                 workerID: normalizedWorkerID,
@@ -11618,7 +11747,7 @@ var init_worker_process = __esm({
                 stderrFD: stderrHandle.fd
               });
               pid = hiddenPty.pid;
-              pidPath = normalizeString18(hiddenPty.pidPath);
+              pidPath = normalizeString19(hiddenPty.pidPath);
               if (hiddenPty.child) {
                 child = hiddenPty.child;
                 const exitWorkerID = normalizedWorkerID;
@@ -11674,7 +11803,7 @@ var init_worker_process = __esm({
             if (!Number.isFinite(pid) || pid <= 0) {
               throw new Error("failed to determine spawned Claude pid");
             }
-            const isHiddenPty = !visibleTerminal && process13.platform === "darwin";
+            const isHiddenPty = !visibleTerminal && process14.platform === "darwin";
             deferFDClose = isHiddenPty;
             const runtime = {
               worker_id: normalizedWorkerID,
@@ -11710,7 +11839,7 @@ var init_worker_process = __esm({
         });
       }
       async stopWorker(workerID) {
-        const normalizedWorkerID = normalizeString18(workerID);
+        const normalizedWorkerID = normalizeString19(workerID);
         const runtime = this.runtimes.get(normalizedWorkerID);
         if (!runtime) {
           return false;
@@ -11719,7 +11848,7 @@ var init_worker_process = __esm({
         let exitSignal = "SIGTERM";
         if (pid > 0) {
           const terminated = await this.terminateProcessTree(pid, {
-            platform: process13.platform,
+            platform: process14.platform,
             signal: exitSignal
           });
           if (!terminated) {
@@ -11731,7 +11860,7 @@ var init_worker_process = __esm({
           if (!exited) {
             exitSignal = "SIGKILL";
             await this.terminateProcessTree(pid, {
-              platform: process13.platform,
+              platform: process14.platform,
               signal: exitSignal
             });
             const forceExited = await this.waitForProcessExit(pid, {
@@ -11762,7 +11891,7 @@ var init_worker_process = __esm({
         logCursor = null,
         maxBytes = 0
       } = {}) {
-        const runtime = this.runtimes.get(normalizeString18(workerID));
+        const runtime = this.runtimes.get(normalizeString19(workerID));
         if (!runtime) {
           return false;
         }
@@ -11782,7 +11911,7 @@ var init_worker_process = __esm({
           }
         ];
         for (const target of logTargets) {
-          const normalizedFilePath = normalizeString18(target.filePath);
+          const normalizedFilePath = normalizeString19(target.filePath);
           if (!normalizedFilePath) {
             continue;
           }
@@ -11819,19 +11948,19 @@ var init_worker_process = __esm({
         });
       }
       async captureLogCursor(workerID) {
-        const runtime = this.runtimes.get(normalizeString18(workerID));
+        const runtime = this.runtimes.get(normalizeString19(workerID));
         if (!runtime) {
           return null;
         }
         let stdoutOffset = 0;
         let stderrOffset = 0;
         try {
-          stdoutOffset = normalizeNonNegativeOffset((await stat(runtime.stdout_log_path)).size);
+          stdoutOffset = normalizeNonNegativeOffset((await stat2(runtime.stdout_log_path)).size);
         } catch {
           stdoutOffset = 0;
         }
         try {
-          stderrOffset = normalizeNonNegativeOffset((await stat(runtime.stderr_log_path)).size);
+          stderrOffset = normalizeNonNegativeOffset((await stat2(runtime.stderr_log_path)).size);
         } catch {
           stderrOffset = 0;
         }
@@ -15052,7 +15181,7 @@ var require_stream = __commonJS({
       };
       duplex2._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open3() {
+          ws.once("open", function open4() {
             duplex2._final(callback);
           });
           return;
@@ -15073,7 +15202,7 @@ var require_stream = __commonJS({
       };
       duplex2._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open3() {
+          ws.once("open", function open4() {
             duplex2._write(chunk, encoding, callback);
           });
           return;
@@ -15539,10 +15668,258 @@ var init_wrapper = __esm({
   }
 });
 
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "@dhf-claude/grix",
+      version: "0.1.9",
+      description: "Claude Code channel plugin for Aibot Grix",
+      type: "module",
+      repository: {
+        type: "git",
+        url: "git+https://github.com/askie/clawpool-claude.git"
+      },
+      bugs: {
+        url: "https://github.com/askie/clawpool-claude/issues"
+      },
+      homepage: "https://github.com/askie/clawpool-claude#readme",
+      publishConfig: {
+        access: "public"
+      },
+      bin: {
+        "grix-claude": "bin/grix-claude.js"
+      },
+      files: [
+        "bin",
+        "cli",
+        "dist",
+        "hooks",
+        "scripts",
+        "skills",
+        ".claude-plugin",
+        "start.sh"
+      ],
+      scripts: {
+        prepublishOnly: "npm run build",
+        clean: `node -e "const fs=require('node:fs'); fs.rmSync('dist', { recursive: true, force: true });"`,
+        "build:worker": "esbuild server/main.js --bundle --platform=node --format=esm --target=node20 --outfile=dist/index.js",
+        "build:daemon": `esbuild bin/grix-claude.js --bundle --platform=node --format=esm --target=node20 --banner:js="import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);" --outfile=dist/daemon.js`,
+        build: "npm run clean && npm run build:worker && npm run build:daemon",
+        dev: "node ./scripts/dev-start.js",
+        "dev:build": "node ./scripts/dev-build.js",
+        daemon: "node ./dist/daemon.js --show-claude",
+        prod: "node ./scripts/prod-start.js",
+        test: "node --test server/*.test.js cli/*.test.js",
+        "test:daemon-sim": "node --test server/daemon-simulated-e2e.scenario.js"
+      },
+      dependencies: {
+        "@modelcontextprotocol/sdk": "^1.18.0",
+        execa: "^9.6.0",
+        pidtree: "^0.6.0",
+        ws: "^8.18.3",
+        zod: "^4.3.6"
+      },
+      devDependencies: {
+        esbuild: "^0.27.0"
+      }
+    };
+  }
+});
+
+// server/protocol-contract.js
+var contractVersion, protocolVersion, adapterHint, declaredCapabilities, localActionTypes, declaredLocalActions, agentInvokeActions, sessionControlVerbs, interactionKinds, interactionResolutionTypes, accessControlVerbs, resultDomains, bindingWorkerStatuses, sessionControlOutcomes, localActionResultStatuses, localActionErrorCodes, sessionControlErrorCodes, interactionReplyOutcomes, interactionReplyErrorCodes, eventResultStatuses, publicProtocolContract;
+var init_protocol_contract = __esm({
+  "server/protocol-contract.js"() {
+    contractVersion = 1;
+    protocolVersion = "aibot-agent-api-v1";
+    adapterHint = "claude/base";
+    declaredCapabilities = Object.freeze([
+      "session_route",
+      "local_action_v1",
+      "agent_invoke"
+    ]);
+    localActionTypes = Object.freeze({
+      sessionControl: "claude_session_control",
+      interactionReply: "claude_interaction_reply"
+    });
+    declaredLocalActions = Object.freeze([
+      localActionTypes.sessionControl,
+      localActionTypes.interactionReply
+    ]);
+    agentInvokeActions = Object.freeze({
+      interactionRequestCreate: "claude_interaction_request_create",
+      accessControl: "claude_access_control"
+    });
+    sessionControlVerbs = Object.freeze({
+      open: "open",
+      status: "status",
+      where: "where",
+      stop: "stop"
+    });
+    interactionKinds = Object.freeze({
+      permission: "permission",
+      elicitation: "elicitation"
+    });
+    interactionResolutionTypes = Object.freeze({
+      decision: "decision",
+      action: "action",
+      text: "text",
+      map: "map"
+    });
+    accessControlVerbs = Object.freeze({
+      statusRead: "status_read",
+      pairApprove: "pair_approve",
+      pairDeny: "pair_deny",
+      senderAllow: "sender_allow",
+      senderRemove: "sender_remove",
+      policySet: "policy_set"
+    });
+    resultDomains = Object.freeze({
+      sessionControl: "session_control",
+      interactionReply: "interaction_reply"
+    });
+    bindingWorkerStatuses = Object.freeze({
+      starting: "starting",
+      connected: "connected",
+      ready: "ready",
+      stopped: "stopped",
+      failed: "failed"
+    });
+    sessionControlOutcomes = Object.freeze({
+      opened: "opened",
+      alreadyBound: "already_bound",
+      status: "status",
+      where: "where",
+      stopped: "stopped"
+    });
+    localActionResultStatuses = Object.freeze({
+      ok: "ok",
+      failed: "failed"
+    });
+    localActionErrorCodes = Object.freeze({
+      unsupportedLocalAction: "unsupported_local_action",
+      localActionRouteMissing: "local_action_route_missing"
+    });
+    sessionControlErrorCodes = Object.freeze({
+      cwdRequired: "session_cwd_required",
+      invalidCwd: "session_invalid_cwd",
+      bindingMissing: "session_binding_missing",
+      rebindForbidden: "session_rebind_forbidden",
+      verbInvalid: "session_verb_invalid",
+      runtimeError: "session_runtime_error"
+    });
+    interactionReplyOutcomes = Object.freeze({
+      resolved: "resolved"
+    });
+    interactionReplyErrorCodes = Object.freeze({
+      requestIDRequired: "interaction_request_id_required",
+      requestNotFound: "interaction_request_not_found",
+      requestNotPending: "interaction_request_not_pending",
+      resolutionInvalid: "interaction_resolution_invalid",
+      forwardFailed: "interaction_forward_failed"
+    });
+    eventResultStatuses = Object.freeze({
+      responded: "responded",
+      failed: "failed",
+      canceled: "canceled"
+    });
+    publicProtocolContract = Object.freeze({
+      contract_version: contractVersion,
+      protocol_version: protocolVersion,
+      adapter_hint: adapterHint,
+      capabilities: [...declaredCapabilities],
+      local_actions: [...declaredLocalActions],
+      agent_invoke_actions: [
+        agentInvokeActions.interactionRequestCreate,
+        agentInvokeActions.accessControl
+      ],
+      local_action_types: [
+        localActionTypes.sessionControl,
+        localActionTypes.interactionReply
+      ],
+      session_control_verbs: [
+        sessionControlVerbs.open,
+        sessionControlVerbs.status,
+        sessionControlVerbs.where,
+        sessionControlVerbs.stop
+      ],
+      interaction_kinds: [
+        interactionKinds.permission,
+        interactionKinds.elicitation
+      ],
+      interaction_resolution_types: [
+        interactionResolutionTypes.decision,
+        interactionResolutionTypes.action,
+        interactionResolutionTypes.text,
+        interactionResolutionTypes.map
+      ],
+      access_control_verbs: [
+        accessControlVerbs.statusRead,
+        accessControlVerbs.pairApprove,
+        accessControlVerbs.pairDeny,
+        accessControlVerbs.senderAllow,
+        accessControlVerbs.senderRemove,
+        accessControlVerbs.policySet
+      ],
+      result_domains: [
+        resultDomains.sessionControl,
+        resultDomains.interactionReply
+      ],
+      binding_worker_statuses: [
+        bindingWorkerStatuses.starting,
+        bindingWorkerStatuses.connected,
+        bindingWorkerStatuses.ready,
+        bindingWorkerStatuses.stopped,
+        bindingWorkerStatuses.failed
+      ],
+      session_control_outcomes: [
+        sessionControlOutcomes.opened,
+        sessionControlOutcomes.alreadyBound,
+        sessionControlOutcomes.status,
+        sessionControlOutcomes.where,
+        sessionControlOutcomes.stopped
+      ],
+      local_action_result_statuses: [
+        localActionResultStatuses.ok,
+        localActionResultStatuses.failed
+      ],
+      local_action_error_codes: [
+        localActionErrorCodes.unsupportedLocalAction,
+        localActionErrorCodes.localActionRouteMissing
+      ],
+      session_control_error_codes: [
+        sessionControlErrorCodes.cwdRequired,
+        sessionControlErrorCodes.invalidCwd,
+        sessionControlErrorCodes.bindingMissing,
+        sessionControlErrorCodes.rebindForbidden,
+        sessionControlErrorCodes.verbInvalid,
+        sessionControlErrorCodes.runtimeError
+      ],
+      interaction_reply_outcomes: [
+        interactionReplyOutcomes.resolved
+      ],
+      interaction_reply_error_codes: [
+        interactionReplyErrorCodes.requestIDRequired,
+        interactionReplyErrorCodes.requestNotFound,
+        interactionReplyErrorCodes.requestNotPending,
+        interactionReplyErrorCodes.resolutionInvalid,
+        interactionReplyErrorCodes.forwardFailed
+      ],
+      event_result_statuses: [
+        eventResultStatuses.responded,
+        eventResultStatuses.failed,
+        eventResultStatuses.canceled
+      ]
+    });
+  }
+});
+
 // server/aibot-client.js
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { appendFileSync as appendFileSync3 } from "node:fs";
-function normalizeString19(value) {
+function normalizeString20(value) {
   return String(value ?? "").trim();
 }
 function logDebug(message) {
@@ -15557,23 +15934,33 @@ function logDebug(message) {
 function buildSendNackError(packet) {
   const payload = packet?.payload ?? {};
   const code = Number(payload.code ?? 5001);
-  const msg = normalizeString19(payload.msg) || packet?.cmd || "unknown error";
+  const msg = normalizeString20(payload.msg) || packet?.cmd || "unknown error";
   const error = new Error(`aibot ${packet?.cmd ?? "packet"} error ${code}: ${msg}`);
   error.code = code;
   return error;
 }
 function withOptionalString(target, key, value) {
-  const normalized = normalizeString19(value);
+  const normalized = normalizeString20(value);
   if (normalized) {
     target[key] = normalized;
   }
 }
 function buildAuthPayload(config) {
+  const clientVersion = normalizeString20(config?.clientVersion) || pluginVersion;
+  const hostVersion = normalizeString20(config?.hostVersion) || clientVersion;
   return {
     agent_id: config.agentID,
     api_key: config.apiKey,
     client: "claude-grix-claude-channel",
-    client_type: "claude"
+    client_type: "claude",
+    contract_version: contractVersion,
+    client_version: clientVersion,
+    host_type: "claude",
+    host_version: hostVersion,
+    protocol_version: protocolVersion,
+    capabilities: [...declaredCapabilities],
+    local_actions: [...declaredLocalActions],
+    adapter_hint: adapterHint
   };
 }
 function buildSessionActivityPayload({
@@ -15585,8 +15972,8 @@ function buildSessionActivityPayload({
   refEventID = ""
 }) {
   const payload = {
-    session_id: normalizeString19(sessionID),
-    kind: normalizeString19(kind),
+    session_id: normalizeString20(sessionID),
+    kind: normalizeString20(kind),
     active: active === true
   };
   if (Number.isFinite(Number(ttlMs)) && Number(ttlMs) > 0) {
@@ -15596,17 +15983,21 @@ function buildSessionActivityPayload({
   withOptionalString(payload, "ref_event_id", refEventID);
   return payload;
 }
-var verboseDebugEnabled, verboseDebugLogPath, AibotClient;
+var verboseDebugEnabled, verboseDebugLogPath, pluginVersion, AibotClient;
 var init_aibot_client = __esm({
   "server/aibot-client.js"() {
     init_wrapper();
+    init_package();
+    init_protocol_contract();
     verboseDebugEnabled = process.env.GRIX_CLAUDE_E2E_DEBUG === "1";
-    verboseDebugLogPath = normalizeString19(process.env.GRIX_CLAUDE_E2E_DEBUG_LOG);
+    verboseDebugLogPath = normalizeString20(process.env.GRIX_CLAUDE_E2E_DEBUG_LOG);
+    pluginVersion = normalizeString20(package_default?.version) || "0.1.0";
     AibotClient = class {
-      constructor({ onEventMessage, onEventStop, onEventRevoke, onStatus } = {}) {
+      constructor({ onEventMessage, onEventStop, onEventRevoke, onLocalAction, onStatus } = {}) {
         this.onEventMessage = onEventMessage;
         this.onEventStop = onEventStop;
         this.onEventRevoke = onEventRevoke;
+        this.onLocalAction = onLocalAction;
         this.onStatus = onStatus;
         this.desired = false;
         this.config = null;
@@ -15736,10 +16127,10 @@ var init_aibot_client = __esm({
           expected: ["auth_ack"],
           timeoutMs: 1e4
         });
-        logDebug(`auth response code=${Number(auth?.payload?.code ?? 0)} msg=${normalizeString19(auth?.payload?.msg)}`);
+        logDebug(`auth response code=${Number(auth?.payload?.code ?? 0)} msg=${normalizeString20(auth?.payload?.msg)}`);
         const code = Number(auth?.payload?.code ?? 0);
         if (code !== 0) {
-          throw new Error(normalizeString19(auth?.payload?.msg) || `auth failed code=${code}`);
+          throw new Error(normalizeString20(auth?.payload?.msg) || `auth failed code=${code}`);
         }
         this.setStatus({
           connecting: false,
@@ -15847,7 +16238,7 @@ var init_aibot_client = __esm({
       }
       async handleMessage(text) {
         const packet = JSON.parse(text);
-        const cmd = normalizeString19(packet.cmd);
+        const cmd = normalizeString20(packet.cmd);
         const seq = Number(packet.seq ?? 0);
         logDebug(`recv cmd=${cmd} seq=${seq}`);
         if (cmd === "ping") {
@@ -15871,6 +16262,10 @@ var init_aibot_client = __esm({
         }
         if (cmd === "event_revoke" && this.onEventRevoke) {
           await this.onEventRevoke(packet.payload ?? {});
+          return;
+        }
+        if (cmd === "local_action" && this.onLocalAction) {
+          await this.onLocalAction(packet.payload ?? {});
         }
       }
       setStatus(patch) {
@@ -15940,7 +16335,7 @@ var init_aibot_client = __esm({
       }
       ackEvent(eventID, { sessionID, msgID, receivedAt = Date.now() } = {}) {
         const payload = {
-          event_id: normalizeString19(eventID),
+          event_id: normalizeString20(eventID),
           received_at: Math.floor(receivedAt)
         };
         withOptionalString(payload, "session_id", sessionID);
@@ -15949,8 +16344,8 @@ var init_aibot_client = __esm({
       }
       sendEventResult({ event_id, status, code = "", msg = "", updated_at = Date.now() }) {
         const payload = {
-          event_id: normalizeString19(event_id),
-          status: normalizeString19(status),
+          event_id: normalizeString20(event_id),
+          status: normalizeString20(status),
           updated_at: Math.floor(updated_at)
         };
         withOptionalString(payload, "code", code);
@@ -15959,7 +16354,7 @@ var init_aibot_client = __esm({
       }
       sendEventStopAck({ event_id, stop_id = "", accepted, updated_at = Date.now() }) {
         const payload = {
-          event_id: normalizeString19(event_id),
+          event_id: normalizeString20(event_id),
           accepted: accepted === true,
           updated_at: Math.floor(updated_at)
         };
@@ -15975,8 +16370,8 @@ var init_aibot_client = __esm({
         updated_at = Date.now()
       }) {
         const payload = {
-          event_id: normalizeString19(event_id),
-          status: normalizeString19(status),
+          event_id: normalizeString20(event_id),
+          status: normalizeString20(status),
           updated_at: Math.floor(updated_at)
         };
         withOptionalString(payload, "stop_id", stop_id);
@@ -16013,8 +16408,8 @@ var init_aibot_client = __esm({
         extra = {}
       }) {
         const payload = {
-          session_id: normalizeString19(sessionID),
-          client_msg_id: normalizeString19(clientMsgID),
+          session_id: normalizeString20(sessionID),
+          client_msg_id: normalizeString20(clientMsgID),
           msg_type: 1,
           content: String(text ?? ""),
           extra
@@ -16040,11 +16435,11 @@ var init_aibot_client = __esm({
         extra = {}
       }) {
         const payload = {
-          session_id: normalizeString19(sessionID),
-          client_msg_id: normalizeString19(clientMsgID),
+          session_id: normalizeString20(sessionID),
+          client_msg_id: normalizeString20(clientMsgID),
           msg_type: 2,
-          content: normalizeString19(caption) || "[attachment]",
-          media_url: normalizeString19(mediaURL),
+          content: normalizeString20(caption) || "[attachment]",
+          media_url: normalizeString20(mediaURL),
           extra
         };
         withOptionalString(payload, "event_id", eventID);
@@ -16058,9 +16453,69 @@ var init_aibot_client = __esm({
         }
         return packet.payload ?? {};
       }
+      async sendAgentInvoke({
+        invokeID = randomUUID5(),
+        action,
+        params = {},
+        timeoutMs = 15e3
+      } = {}) {
+        const normalizedAction = normalizeString20(action);
+        if (!normalizedAction) {
+          throw new Error("sendAgentInvoke requires action");
+        }
+        const normalizedTimeoutMs = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0 ? Math.floor(Number(timeoutMs)) : 15e3;
+        const packet = await this.request("agent_invoke", {
+          invoke_id: normalizeString20(invokeID) || randomUUID5(),
+          action: normalizedAction,
+          params: params && typeof params === "object" && !Array.isArray(params) ? params : {},
+          timeout_ms: normalizedTimeoutMs
+        }, {
+          expected: ["agent_invoke_result", "error"],
+          timeoutMs: normalizedTimeoutMs + 1e3
+        });
+        if (packet.cmd !== "agent_invoke_result") {
+          throw buildSendNackError(packet);
+        }
+        return packet.payload ?? {};
+      }
+      async sendLocalActionResult({
+        actionID,
+        status,
+        result = void 0,
+        errorCode = "",
+        errorMsg = "",
+        timeoutMs = 15e3
+      } = {}) {
+        const normalizedActionID = normalizeString20(actionID);
+        if (!normalizedActionID) {
+          throw new Error("sendLocalActionResult requires actionID");
+        }
+        const normalizedStatus = normalizeString20(status);
+        if (!normalizedStatus) {
+          throw new Error("sendLocalActionResult requires status");
+        }
+        const normalizedTimeoutMs = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0 ? Math.floor(Number(timeoutMs)) : 15e3;
+        const payload = {
+          action_id: normalizedActionID,
+          status: normalizedStatus
+        };
+        if (arguments[0] && Object.prototype.hasOwnProperty.call(arguments[0], "result")) {
+          payload.result = result;
+        }
+        withOptionalString(payload, "error_code", errorCode);
+        withOptionalString(payload, "error_msg", errorMsg);
+        const packet = await this.request("local_action_result", payload, {
+          expected: ["local_action_ack", "error"],
+          timeoutMs: normalizedTimeoutMs
+        });
+        if (packet.cmd !== "local_action_ack") {
+          throw buildSendNackError(packet);
+        }
+        return packet.payload ?? {};
+      }
       async deleteMessage(sessionID, messageID, { timeoutMs = 2e4 } = {}) {
-        const normalizedSessionID = normalizeString19(sessionID);
-        const normalizedMessageID = normalizeString19(messageID);
+        const normalizedSessionID = normalizeString20(sessionID);
+        const normalizedMessageID = normalizeString20(messageID);
         if (!normalizedSessionID) {
           throw new Error("deleteMessage requires sessionID");
         }
@@ -16083,74 +16538,113 @@ var init_aibot_client = __esm({
   }
 });
 
-// server/daemon/control-command.js
-import path21 from "node:path";
-function normalizeString20(value) {
+// server/grix-card-link.js
+function normalizeString21(value) {
   return String(value ?? "").trim();
 }
-function normalizeTokens(text) {
-  return normalizeString20(text).split(/\s+/).filter(Boolean);
+function hasComplexPayload(payload) {
+  return Object.values(payload ?? {}).some((value) => Array.isArray(value) || value && typeof value === "object");
 }
-function parseControlCommand(text) {
-  const normalizedText = normalizeString20(text);
-  if (!normalizedText) {
-    return { matched: false, command: "", args: {}, error: "" };
-  }
-  const tokens = normalizeTokens(normalizedText);
-  if (tokens.length === 0) {
-    return { matched: false, command: "", args: {}, error: "" };
+function appendFlatPayload(params, payload) {
+  for (const [rawKey, value] of Object.entries(payload ?? {})) {
+    const key = normalizeString21(rawKey);
+    if (!key || value == null) {
+      continue;
+    }
+    if (typeof value === "string") {
+      if (!value) {
+        continue;
+      }
+      params.set(key, value);
+      continue;
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+      params.set(key, String(value));
+    }
   }
-  let startIndex = 0;
-  if (tokens[0] === "/grix" || tokens[0] === "grix") {
-    startIndex = 1;
+}
+function buildGrixCardURI(cardType, payload = {}) {
+  const normalizedType = normalizeString21(cardType);
+  if (!normalizedType) {
+    throw new Error("cardType is required");
   }
-  const command = normalizeString20(tokens[startIndex]).toLowerCase();
-  if (!command) {
-    return { matched: false, command: "", args: {}, error: "" };
+  const params = new URLSearchParams();
+  if (hasComplexPayload(payload)) {
+    params.set("d", JSON.stringify(payload));
+  } else {
+    appendFlatPayload(params, payload);
   }
-  if (command === "open") {
-    const cwd = normalizeString20(tokens.slice(startIndex + 1).join(" "));
-    if (!cwd) {
-      return { matched: true, ok: false, command, args: {}, error: "open \u7F3A\u5C11\u76EE\u5F55\u8DEF\u5F84\u3002" };
-    }
-    return {
-      matched: true,
-      ok: true,
-      command,
-      args: {
-        cwd: path21.resolve(cwd)
-      },
-      error: ""
-    };
+  const query = params.toString();
+  return `grix://card/${encodeURIComponent(normalizedType)}${query ? `?${query}` : ""}`;
+}
+function buildGrixCardLink({
+  fallbackText,
+  cardType,
+  payload = {}
+}) {
+  const normalizedFallbackText = normalizeString21(fallbackText);
+  if (!normalizedFallbackText) {
+    throw new Error("fallbackText is required");
   }
-  if (command === "status" || command === "stop" || command === "where") {
-    return {
-      matched: true,
-      ok: true,
-      command,
-      args: {},
-      error: ""
-    };
+  return `[${normalizedFallbackText}](${buildGrixCardURI(cardType, payload)})`;
+}
+var init_grix_card_link = __esm({
+  "server/grix-card-link.js"() {
   }
-  return { matched: false, command: "", args: {}, error: "" };
+});
+
+// server/agent-open-session-card.js
+function normalizeString22(value) {
+  return String(value ?? "").trim();
+}
+function buildAgentOpenSessionCardLink({
+  fallbackText = "\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55",
+  summaryText = "",
+  detailText = "",
+  initialCwd = "",
+  submittedPath = ""
+} = {}) {
+  const payload = {};
+  const normalizedSummaryText = normalizeString22(summaryText);
+  const normalizedDetailText = normalizeString22(detailText);
+  const normalizedInitialCwd = normalizeString22(initialCwd);
+  const normalizedSubmittedPath = normalizeString22(submittedPath);
+  if (normalizedSummaryText) {
+    payload.summary_text = normalizedSummaryText;
+  }
+  if (normalizedDetailText) {
+    payload.detail_text = normalizedDetailText;
+  }
+  if (normalizedInitialCwd) {
+    payload.initial_cwd = normalizedInitialCwd;
+  }
+  if (normalizedSubmittedPath) {
+    payload.submitted_path = normalizedSubmittedPath;
+  }
+  return buildGrixCardLink({
+    fallbackText: normalizeString22(fallbackText) || "\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55",
+    cardType: "agent_open_session",
+    payload
+  });
 }
-var init_control_command = __esm({
-  "server/daemon/control-command.js"() {
+var init_agent_open_session_card = __esm({
+  "server/agent-open-session-card.js"() {
+    init_grix_card_link();
   }
 });
 
 // server/inbound-event-meta.js
-function normalizeString21(value) {
+function normalizeString23(value) {
   return String(value ?? "").trim();
 }
 function normalizeOptionalString(value) {
-  return normalizeString21(value) || "";
+  return normalizeString23(value) || "";
 }
 function normalizeStringArray(value) {
   if (!Array.isArray(value)) {
     return [];
   }
-  return value.map((item) => normalizeString21(item)).filter((item) => item);
+  return value.map((item) => normalizeString23(item)).filter((item) => item);
 }
 function normalizeJSONObject(value) {
   if (!value) {
@@ -16206,6 +16700,43 @@ function normalizeAttachmentRecord(value) {
   }
   return attachment;
 }
+function normalizeContextMessageRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const normalized = {
+    msg_id: normalizeOptionalString(value.msg_id),
+    sender_id: normalizeOptionalString(value.sender_id),
+    sender_type: Number(value.sender_type ?? 0),
+    msg_type: Number(value.msg_type ?? 0),
+    content: String(value.content ?? ""),
+    quoted_message_id: normalizeOptionalString(value.quoted_message_id),
+    mention_user_ids: normalizeStringArray(value.mention_user_ids),
+    created_at: Number(value.created_at ?? 0)
+  };
+  if (!normalized.msg_id) {
+    return null;
+  }
+  return normalized;
+}
+function normalizeContextMessageArray(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeContextMessageRecord(item)).filter(Boolean);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      return normalizeContextMessageArray(parsed);
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
 function deriveAttachments(payload, extra) {
   const explicit = normalizeJSONArray(payload.attachments).map((item) => normalizeAttachmentRecord(item)).filter(Boolean);
   if (explicit.length > 0) {
@@ -16235,19 +16766,25 @@ function stringifyJSON(value) {
   }
   return JSON.stringify(value);
 }
+function deriveContextMessages(payload) {
+  const currentMsgID = normalizeString23(payload.msg_id);
+  return normalizeContextMessageArray(payload.context_messages).filter((entry) => entry.msg_id !== currentMsgID);
+}
 function normalizeInboundEventPayload(rawPayload) {
   const extra = normalizeJSONObject(rawPayload.extra);
   const attachments = deriveAttachments(rawPayload, extra);
   const bizCard = normalizeJSONObject(rawPayload.biz_card) ?? normalizeJSONObject(extra?.biz_card);
   const channelData = normalizeJSONObject(rawPayload.channel_data) ?? normalizeJSONObject(extra?.channel_data);
+  const contextMessages = deriveContextMessages(rawPayload);
   return {
-    event_id: normalizeString21(rawPayload.event_id),
-    event_type: normalizeString21(rawPayload.event_type),
-    session_id: normalizeString21(rawPayload.session_id),
+    event_id: normalizeString23(rawPayload.event_id),
+    event_type: normalizeString23(rawPayload.event_type),
+    mirror_mode: normalizeString23(rawPayload.mirror_mode),
+    session_id: normalizeString23(rawPayload.session_id),
     session_type: normalizeOptionalString(rawPayload.session_type),
-    msg_id: normalizeString21(rawPayload.msg_id),
+    msg_id: normalizeString23(rawPayload.msg_id),
     quoted_message_id: normalizeOptionalString(rawPayload.quoted_message_id),
-    sender_id: normalizeString21(rawPayload.sender_id),
+    sender_id: normalizeString23(rawPayload.sender_id),
     owner_id: normalizeOptionalString(rawPayload.owner_id),
     agent_id: normalizeOptionalString(rawPayload.agent_id),
     msg_type: normalizeOptionalString(rawPayload.msg_type),
@@ -16258,7 +16795,8 @@ function normalizeInboundEventPayload(rawPayload) {
     attachments_json: stringifyJSON(attachments),
     attachment_count: attachments.length > 0 ? String(attachments.length) : "",
     biz_card_json: stringifyJSON(bizCard),
-    channel_data_json: stringifyJSON(channelData)
+    channel_data_json: stringifyJSON(channelData),
+    context_messages_json: stringifyJSON(contextMessages)
   };
 }
 var init_inbound_event_meta = __esm({
@@ -16267,7 +16805,7 @@ var init_inbound_event_meta = __esm({
 });
 
 // server/daemon/worker-control-client.js
-function normalizeString22(value) {
+function normalizeString24(value) {
   return String(value ?? "").trim();
 }
 async function parseJSONResponse(response) {
@@ -16282,8 +16820,8 @@ var init_worker_control_client = __esm({
   "server/daemon/worker-control-client.js"() {
     WorkerControlClient = class {
       constructor({ controlURL, token, fetchImpl = globalThis.fetch, pingTimeoutMs = 5e3, deliverTimeoutMs = 1e4 } = {}) {
-        this.controlURL = normalizeString22(controlURL).replace(/\/+$/u, "");
-        this.token = normalizeString22(token);
+        this.controlURL = normalizeString24(controlURL).replace(/\/+$/u, "");
+        this.token = normalizeString24(token);
         this.fetchImpl = fetchImpl;
         this.pingTimeoutMs = pingTimeoutMs;
         this.deliverTimeoutMs = deliverTimeoutMs;
@@ -16291,135 +16829,52 @@ var init_worker_control_client = __esm({
       isConfigured() {
         return Boolean(this.controlURL && this.token && typeof this.fetchImpl === "function");
       }
-      async deliverEvent(rawPayload) {
+      async post(pathname, payload, timeoutMs) {
         if (!this.isConfigured()) {
           throw new Error("worker control is not configured");
         }
-        const response = await this.fetchImpl(`${this.controlURL}/v1/worker/deliver-event`, {
+        const response = await this.fetchImpl(`${this.controlURL}${pathname}`, {
           method: "POST",
           headers: {
             "content-type": "application/json",
             authorization: `Bearer ${this.token}`
           },
-          body: JSON.stringify({ payload: rawPayload }),
-          signal: AbortSignal.timeout(this.deliverTimeoutMs)
+          body: JSON.stringify(payload),
+          signal: AbortSignal.timeout(timeoutMs)
         });
         const json = await parseJSONResponse(response);
         if (!response.ok) {
-          throw new Error(normalizeString22(json.error) || `worker control failed ${response.status}`);
+          throw new Error(normalizeString24(json.error) || `worker control failed ${response.status}`);
         }
         return json;
       }
+      async deliverEvent(rawPayload) {
+        return this.post("/v1/worker/deliver-event", { payload: rawPayload }, this.deliverTimeoutMs);
+      }
       async deliverStop(rawPayload) {
-        if (!this.isConfigured()) {
-          throw new Error("worker control is not configured");
-        }
-        const response = await this.fetchImpl(`${this.controlURL}/v1/worker/deliver-stop`, {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            authorization: `Bearer ${this.token}`
-          },
-          body: JSON.stringify({ payload: rawPayload }),
-          signal: AbortSignal.timeout(this.deliverTimeoutMs)
-        });
-        const json = await parseJSONResponse(response);
-        if (!response.ok) {
-          throw new Error(normalizeString22(json.error) || `worker control failed ${response.status}`);
-        }
-        return json;
+        return this.post("/v1/worker/deliver-stop", { payload: rawPayload }, this.deliverTimeoutMs);
       }
       async deliverRevoke(rawPayload) {
-        if (!this.isConfigured()) {
-          throw new Error("worker control is not configured");
-        }
-        const response = await this.fetchImpl(`${this.controlURL}/v1/worker/deliver-revoke`, {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            authorization: `Bearer ${this.token}`
-          },
-          body: JSON.stringify({ payload: rawPayload }),
-          signal: AbortSignal.timeout(this.deliverTimeoutMs)
-        });
-        const json = await parseJSONResponse(response);
-        if (!response.ok) {
-          throw new Error(normalizeString22(json.error) || `worker control failed ${response.status}`);
-        }
-        return json;
+        return this.post("/v1/worker/deliver-revoke", { payload: rawPayload }, this.deliverTimeoutMs);
+      }
+      async deliverLocalAction(rawPayload) {
+        return this.post("/v1/worker/deliver-local-action", { payload: rawPayload }, this.deliverTimeoutMs);
       }
       async ping() {
-        if (!this.isConfigured()) {
-          throw new Error("worker control is not configured");
-        }
-        const response = await this.fetchImpl(`${this.controlURL}/v1/worker/ping`, {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            authorization: `Bearer ${this.token}`
-          },
-          body: JSON.stringify({}),
-          signal: AbortSignal.timeout(this.pingTimeoutMs)
-        });
-        const json = await parseJSONResponse(response);
-        if (!response.ok) {
-          throw new Error(normalizeString22(json.error) || `worker control failed ${response.status}`);
-        }
-        return json;
+        return this.post("/v1/worker/ping", {}, this.pingTimeoutMs);
       }
     };
   }
 });
 
-// server/message-card-envelope.js
-function buildMessageCardEnvelope(type, payload) {
-  return {
-    version: currentVersion,
-    type,
-    payload
-  };
-}
-var currentVersion;
-var init_message_card_envelope = __esm({
-  "server/message-card-envelope.js"() {
-    currentVersion = 1;
-  }
-});
-
-// server/daemon/control-card.js
-function normalizeString23(value) {
-  return String(value ?? "").trim();
-}
-function buildOpenWorkspaceCard({
-  summaryText = "open \u7F3A\u5C11\u76EE\u5F55\u8DEF\u5F84\u3002",
-  detailText = "\u8BF7\u8F93\u5165\u5DE5\u4F5C\u76EE\u5F55\u6765\u542F\u52A8\u6216\u6062\u590D Claude \u4F1A\u8BDD\u3002",
-  initialCwd = ""
-} = {}) {
-  return buildMessageCardEnvelope("claude_open_session", {
-    summary_text: normalizeString23(summaryText),
-    detail_text: normalizeString23(detailText),
-    command_prefix: openCommandPrefix,
-    command_hint: openCommandHint,
-    initial_cwd: normalizeString23(initialCwd)
-  });
-}
-var openCommandPrefix, openCommandHint;
-var init_control_card = __esm({
-  "server/daemon/control-card.js"() {
-    init_message_card_envelope();
-    openCommandPrefix = "/grix open";
-    openCommandHint = "/grix open <working-directory>";
-  }
-});
-
 // server/daemon/claude-session-store.js
 import path22 from "node:path";
 import { access } from "node:fs/promises";
-function normalizeString24(value) {
+function normalizeString25(value) {
   return String(value ?? "").trim();
 }
 function encodeClaudeProjectPath(cwd) {
-  const normalized = normalizeString24(cwd);
+  const normalized = normalizeString25(cwd);
   if (!normalized) {
     return "";
   }
@@ -16427,8 +16882,8 @@ function encodeClaudeProjectPath(cwd) {
 }
 function resolveClaudeSessionPath({ cwd, claudeSessionID, env = process.env } = {}) {
   const projectKey = encodeClaudeProjectPath(cwd);
-  const sessionID = normalizeString24(claudeSessionID);
-  const homeDir = normalizeString24(env?.HOME);
+  const sessionID = normalizeString25(claudeSessionID);
+  const homeDir = normalizeString25(env?.HOME);
   if (!projectKey || !sessionID || !homeDir) {
     return "";
   }
@@ -16451,228 +16906,6 @@ var init_claude_session_store = __esm({
   }
 });
 
-// server/daemon/control-command-handler.js
-import { randomUUID as randomUUID6 } from "node:crypto";
-function normalizeString25(value) {
-  return String(value ?? "").trim();
-}
-function defaultFormatBindingSummary(binding) {
-  if (!binding) {
-    return "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u7ED1\u5B9A\u76EE\u5F55\u3002";
-  }
-  const lines = [
-    `Aibot \u4F1A\u8BDD: ${binding.aibot_session_id}`,
-    `Claude \u4F1A\u8BDD: ${binding.claude_session_id}`,
-    `\u76EE\u5F55: ${binding.cwd}`,
-    `Worker \u72B6\u6001: ${binding.worker_status}`,
-    `\u53EF\u7528\u6027\u8BC4\u4F30: ${formatWorkerResponseAssessment(binding)}`
-  ];
-  if (normalizeString25(binding.worker_response_reason)) {
-    lines.push(`\u8BC4\u4F30\u539F\u56E0: ${normalizeString25(binding.worker_response_reason)}`);
-  }
-  return lines.join("\n");
-}
-function defaultBuildMissingBindingCardOptions() {
-  return {
-    summaryText: "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u7ED1\u5B9A\u76EE\u5F55\u3002",
-    detailText: "\u53D1\u9001 open <\u76EE\u5F55> \u6765\u521B\u5EFA\u4F1A\u8BDD\u3002"
-  };
-}
-function defaultFormatRuntimeError(error, fallback = "\u5904\u7406\u5931\u8D25\u3002") {
-  const message = normalizeString25(error?.message || error);
-  return message || fallback;
-}
-var DaemonControlCommandHandler;
-var init_control_command_handler = __esm({
-  "server/daemon/control-command-handler.js"() {
-    init_daemon_paths();
-    init_worker_state();
-    DaemonControlCommandHandler = class {
-      constructor({
-        env = process.env,
-        bindingRegistry,
-        workerProcessManager,
-        bridgeServer,
-        ensureWorker,
-        respond,
-        respondWithOpenWorkspaceCard,
-        ensureDirectoryExists: ensureDirectoryExists2,
-        formatBindingSummary: formatBindingSummary2 = defaultFormatBindingSummary,
-        buildMissingBindingCardOptions: buildMissingBindingCardOptions2 = defaultBuildMissingBindingCardOptions,
-        formatRuntimeError: formatRuntimeError2 = defaultFormatRuntimeError
-      } = {}) {
-        this.env = env;
-        this.bindingRegistry = bindingRegistry;
-        this.workerProcessManager = workerProcessManager;
-        this.bridgeServer = bridgeServer;
-        this.ensureWorker = ensureWorker;
-        this.respond = respond;
-        this.respondWithOpenWorkspaceCard = respondWithOpenWorkspaceCard;
-        this.ensureDirectoryExists = ensureDirectoryExists2;
-        this.formatBindingSummary = formatBindingSummary2;
-        this.buildMissingBindingCardOptions = buildMissingBindingCardOptions2;
-        this.formatRuntimeError = formatRuntimeError2;
-      }
-      async handleOpenCommand(event, parsed) {
-        const cwd = normalizeString25(parsed.args.cwd);
-        await this.ensureDirectoryExists(cwd);
-        const existing = this.bindingRegistry.getByAibotSessionID(event.session_id);
-        if (existing) {
-          if (existing.cwd !== cwd) {
-            await this.respond(
-              event,
-              `\u5F53\u524D\u4F1A\u8BDD\u5DF2\u7ECF\u56FA\u5B9A\u7ED1\u5B9A\u76EE\u5F55\uFF0C\u4E0D\u80FD\u6539\u6210\u65B0\u76EE\u5F55\u3002
-
-${this.formatBindingSummary(existing)}`,
-              { reply_source: "daemon_control_open_reject" }
-            );
-            return;
-          }
-          await this.ensureWorker(existing, { ignoreAuthCooldown: true });
-          await this.respond(
-            event,
-            `\u5F53\u524D\u4F1A\u8BDD\u5DF2\u7ECF\u7ED1\u5B9A\uFF0C\u5DF2\u6309\u539F\u76EE\u5F55\u6062\u590D\u6216\u4FDD\u6301\u539F\u4F1A\u8BDD\u3002
-
-${this.formatBindingSummary(existing)}`,
-            { reply_source: "daemon_control_open_existing" }
-          );
-          return;
-        }
-        const workerID = randomUUID6();
-        const claudeSessionID = randomUUID6();
-        const pluginDataDir = resolveWorkerPluginDataDir(event.session_id, this.env);
-        const created = await this.bindingRegistry.createBinding({
-          aibot_session_id: event.session_id,
-          claude_session_id: claudeSessionID,
-          cwd,
-          worker_id: workerID,
-          worker_status: "starting",
-          plugin_data_dir: pluginDataDir,
-          created_at: Date.now(),
-          updated_at: Date.now(),
-          last_started_at: Date.now(),
-          last_stopped_at: 0
-        });
-        await this.workerProcessManager.spawnWorker({
-          aibotSessionID: created.aibot_session_id,
-          cwd: created.cwd,
-          pluginDataDir: created.plugin_data_dir,
-          claudeSessionID: created.claude_session_id,
-          workerID: created.worker_id,
-          bridgeURL: this.bridgeServer.getURL(),
-          bridgeToken: this.bridgeServer.token
-        });
-        await this.respond(
-          event,
-          `\u5DF2\u65B0\u5EFA\u76EE\u5F55\u4F1A\u8BDD\u3002
-
-${this.formatBindingSummary(created)}`,
-          { reply_source: "daemon_control_open_created" }
-        );
-      }
-      async handleStatusCommand(event) {
-        const binding = this.bindingRegistry.getByAibotSessionID(event.session_id);
-        if (!binding) {
-          await this.respondWithOpenWorkspaceCard(event, {
-            ...this.buildMissingBindingCardOptions(),
-            replySource: "daemon_control_status_missing"
-          });
-          return;
-        }
-        await this.respond(event, this.formatBindingSummary(binding), {
-          reply_source: "daemon_control_status"
-        });
-      }
-      async handleWhereCommand(event) {
-        const binding = this.bindingRegistry.getByAibotSessionID(event.session_id);
-        if (!binding) {
-          await this.respondWithOpenWorkspaceCard(event, {
-            ...this.buildMissingBindingCardOptions(),
-            replySource: "daemon_control_where_missing"
-          });
-          return;
-        }
-        const text = `\u5F53\u524D\u76EE\u5F55: ${binding.cwd}`;
-        await this.respond(event, text, {
-          reply_source: "daemon_control_where"
-        });
-      }
-      async handleStopCommand(event) {
-        const binding = this.bindingRegistry.getByAibotSessionID(event.session_id);
-        if (!binding) {
-          await this.respondWithOpenWorkspaceCard(event, {
-            ...this.buildMissingBindingCardOptions(),
-            replySource: "daemon_control_stop_missing"
-          });
-          return;
-        }
-        if (binding.worker_id) {
-          await this.workerProcessManager.stopWorker(binding.worker_id);
-        }
-        await this.bindingRegistry.markWorkerStopped(event.session_id, {
-          updatedAt: Date.now(),
-          lastStoppedAt: Date.now()
-        });
-        await this.respond(event, `\u5DF2\u505C\u6B62\u5F53\u524D\u4F1A\u8BDD\u5BF9\u5E94\u7684 Claude\u3002
-
-${this.formatBindingSummary({
-          ...binding,
-          worker_status: "stopped"
-        })}`, {
-          reply_source: "daemon_control_stop"
-        });
-      }
-      async handleControlCommand(event, parsed) {
-        if (!parsed.ok) {
-          if (parsed.command === "open") {
-            await this.respondWithOpenWorkspaceCard(event, {
-              summaryText: parsed.error,
-              replySource: "daemon_control_invalid"
-            });
-            return true;
-          }
-          await this.respond(event, parsed.error, {
-            reply_source: "daemon_control_invalid"
-          });
-          return true;
-        }
-        try {
-          switch (parsed.command) {
-            case "open":
-              await this.handleOpenCommand(event, parsed);
-              return true;
-            case "status":
-              await this.handleStatusCommand(event);
-              return true;
-            case "where":
-              await this.handleWhereCommand(event);
-              return true;
-            case "stop":
-              await this.handleStopCommand(event);
-              return true;
-            default:
-              return false;
-          }
-        } catch (error) {
-          const message = this.formatRuntimeError(error, "\u547D\u4EE4\u6267\u884C\u5931\u8D25\u3002");
-          if (parsed.command === "open") {
-            await this.respondWithOpenWorkspaceCard(event, {
-              summaryText: message,
-              detailText: "\u53D1\u9001 open <\u76EE\u5F55> \u6765\u521B\u5EFA\u4F1A\u8BDD\u3002",
-              replySource: "daemon_control_open_error"
-            });
-            return true;
-          }
-          await this.respond(event, message, {
-            reply_source: "daemon_control_error"
-          });
-          return true;
-        }
-      }
-    };
-  }
-});
-
 // server/daemon/worker-health-inspector.js
 function normalizeString26(value) {
   return String(value ?? "").trim();
@@ -16930,7 +17163,7 @@ function resolveRecordInFlightActivityAt(record) {
   const normalizedComposingAt = Number.isFinite(composingAt) && composingAt > 0 ? composingAt : 0;
   return Math.max(normalizedUpdatedAt, normalizedComposingAt);
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 var PendingEventOrchestrator;
@@ -17077,7 +17310,7 @@ var init_pending_event_orchestrator = __esm({
               error: error instanceof Error ? error.message : String(error)
             }, "error");
           }
-          await sleep(this.retryDelayMs);
+          await sleep2(this.retryDelayMs);
           const latestBinding = this.bindingRegistry.getByAibotSessionID(normalizedSessionID);
           if (!canDeliverToWorker(latestBinding)) {
             this.trace({
@@ -17185,8 +17418,473 @@ var init_session_queue = __esm({
       delete(sessionID) {
         this._queues.delete(String(sessionID ?? "").trim());
       }
-      clear() {
-        this._queues.clear();
+      clear() {
+        this._queues.clear();
+      }
+    };
+  }
+});
+
+// server/inbound-interaction-action.js
+import path23 from "node:path";
+function normalizeString29(value) {
+  return String(value ?? "").trim();
+}
+function buildUnmatchedResult() {
+  return {
+    matched: false,
+    ok: false,
+    source: "",
+    action: null,
+    errorCode: "",
+    errorMsg: ""
+  };
+}
+function buildErrorResult({
+  source,
+  errorCode,
+  errorMsg
+} = {}) {
+  return {
+    matched: true,
+    ok: false,
+    source: normalizeString29(source),
+    action: null,
+    errorCode: normalizeString29(errorCode),
+    errorMsg: normalizeString29(errorMsg)
+  };
+}
+function buildSuccessResult({
+  source,
+  actionType,
+  params,
+  timeoutMs = 0
+} = {}) {
+  return {
+    matched: true,
+    ok: true,
+    source: normalizeString29(source),
+    action: {
+      action_type: normalizeString29(actionType),
+      params: params && typeof params === "object" && !Array.isArray(params) ? params : {},
+      timeout_ms: Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0 ? Math.floor(Number(timeoutMs)) : 0
+    },
+    errorCode: "",
+    errorMsg: ""
+  };
+}
+function decodeUrlComponentRepeatedly(value) {
+  let current = normalizeString29(value);
+  if (!current) {
+    return "";
+  }
+  for (let index = 0; index < 3; index += 1) {
+    try {
+      const decoded = decodeURIComponent(current);
+      if (decoded === current) {
+        break;
+      }
+      current = decoded;
+    } catch {
+      break;
+    }
+  }
+  return normalizeString29(current);
+}
+function extractGrixCardURI(text) {
+  const normalizedText = normalizeString29(text).replace(/&amp;/giu, "&");
+  if (!normalizedText) {
+    return "";
+  }
+  const match = normalizedText.match(/grix:\/\/card\/[^\s)]+/u);
+  return normalizeString29(match?.[0] ?? normalizedText);
+}
+function parseGrixCardURI(text) {
+  const rawURI = extractGrixCardURI(text);
+  if (!rawURI) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = new URL(rawURI);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "grix:" || normalizeString29(parsed.hostname) !== "card") {
+    return null;
+  }
+  return parsed;
+}
+function normalizeResolutionMapEntries(entries) {
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  return entries.map((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      return null;
+    }
+    const key = normalizeString29(entry.key);
+    const value = normalizeString29(entry.value);
+    if (!key || !value) {
+      return null;
+    }
+    return { key, value };
+  }).filter(Boolean);
+}
+function parseQuestionReplyPayload(rawPayload) {
+  const decoded = decodeUrlComponentRepeatedly(rawPayload);
+  if (!decoded) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(decoded);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function parseQuestionReplyAction(parsedURI) {
+  const payload = parseQuestionReplyPayload(parsedURI?.searchParams?.get("d"));
+  if (!payload) {
+    return buildErrorResult({
+      source: "grix_card_question_reply",
+      errorCode: interactionReplyErrorCodes.resolutionInvalid,
+      errorMsg: "\u4EA4\u4E92\u56DE\u590D\u5185\u5BB9\u683C\u5F0F\u4E0D\u6B63\u786E\u3002"
+    });
+  }
+  const requestID = normalizeString29(payload.request_id);
+  if (!requestID) {
+    return buildErrorResult({
+      source: "grix_card_question_reply",
+      errorCode: interactionReplyErrorCodes.requestIDRequired,
+      errorMsg: "\u4EA4\u4E92\u56DE\u590D\u7F3A\u5C11 request_id\u3002"
+    });
+  }
+  const action = normalizeString29(payload.action).toLowerCase();
+  if (action) {
+    if (!["accept", "cancel", "decline"].includes(action)) {
+      return buildErrorResult({
+        source: "grix_card_question_reply",
+        errorCode: interactionReplyErrorCodes.resolutionInvalid,
+        errorMsg: "\u4EA4\u4E92\u56DE\u590D\u52A8\u4F5C\u65E0\u6548\u3002"
+      });
+    }
+    return buildSuccessResult({
+      source: "grix_card_question_reply",
+      actionType: localActionTypes.interactionReply,
+      timeoutMs: 15e3,
+      params: {
+        kind: interactionKinds.elicitation,
+        request_id: requestID,
+        resolution: {
+          type: interactionResolutionTypes.action,
+          value: action
+        }
+      }
+    });
+  }
+  const response = payload.response;
+  if (!response || typeof response !== "object" || Array.isArray(response)) {
+    return buildErrorResult({
+      source: "grix_card_question_reply",
+      errorCode: interactionReplyErrorCodes.resolutionInvalid,
+      errorMsg: "\u4EA4\u4E92\u56DE\u590D\u7F3A\u5C11\u7B54\u6848\u5185\u5BB9\u3002"
+    });
+  }
+  const responseType = normalizeString29(response.type).toLowerCase();
+  if (responseType === "single") {
+    const value = normalizeString29(response.value);
+    if (!value) {
+      return buildErrorResult({
+        source: "grix_card_question_reply",
+        errorCode: interactionReplyErrorCodes.resolutionInvalid,
+        errorMsg: "\u4EA4\u4E92\u56DE\u590D\u7F3A\u5C11\u7B54\u6848\u5185\u5BB9\u3002"
+      });
+    }
+    return buildSuccessResult({
+      source: "grix_card_question_reply",
+      actionType: localActionTypes.interactionReply,
+      timeoutMs: 15e3,
+      params: {
+        kind: interactionKinds.elicitation,
+        request_id: requestID,
+        resolution: {
+          type: interactionResolutionTypes.text,
+          value
+        }
+      }
+    });
+  }
+  if (responseType === "map") {
+    const entries = normalizeResolutionMapEntries(response.entries);
+    if (entries.length === 0) {
+      return buildErrorResult({
+        source: "grix_card_question_reply",
+        errorCode: interactionReplyErrorCodes.resolutionInvalid,
+        errorMsg: "\u4EA4\u4E92\u56DE\u590D\u7F3A\u5C11\u6709\u6548\u7B54\u6848\u3002"
+      });
+    }
+    return buildSuccessResult({
+      source: "grix_card_question_reply",
+      actionType: localActionTypes.interactionReply,
+      timeoutMs: 15e3,
+      params: {
+        kind: interactionKinds.elicitation,
+        request_id: requestID,
+        resolution: {
+          type: interactionResolutionTypes.map,
+          entries
+        }
+      }
+    });
+  }
+  return buildErrorResult({
+    source: "grix_card_question_reply",
+    errorCode: interactionReplyErrorCodes.resolutionInvalid,
+    errorMsg: "\u4EA4\u4E92\u56DE\u590D\u7C7B\u578B\u65E0\u6548\u3002"
+  });
+}
+function parseOpenSessionAction(parsedURI) {
+  const cwd = decodeUrlComponentRepeatedly(parsedURI?.searchParams?.get("cwd"));
+  if (!cwd) {
+    return buildErrorResult({
+      source: "grix_card_open_session_submit",
+      errorCode: sessionControlErrorCodes.cwdRequired,
+      errorMsg: "\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55\u65F6\u7F3A\u5C11\u76EE\u5F55\u8DEF\u5F84\u3002"
+    });
+  }
+  return buildSuccessResult({
+    source: "grix_card_open_session_submit",
+    actionType: localActionTypes.sessionControl,
+    params: {
+      verb: "open",
+      cwd: path23.resolve(cwd)
+    }
+  });
+}
+function parseInboundInteractionAction(text) {
+  const parsedURI = parseGrixCardURI(text);
+  if (!parsedURI) {
+    return buildUnmatchedResult();
+  }
+  const cardType = normalizeString29(parsedURI.pathname).replace(/^\/+/u, "");
+  if (cardType === "agent_open_session_submit") {
+    return parseOpenSessionAction(parsedURI);
+  }
+  if (cardType === "agent_question_reply") {
+    return parseQuestionReplyAction(parsedURI);
+  }
+  return buildUnmatchedResult();
+}
+var init_inbound_interaction_action = __esm({
+  "server/inbound-interaction-action.js"() {
+    init_protocol_contract();
+  }
+});
+
+// server/daemon/session-control-action-handler.js
+import { randomUUID as randomUUID6 } from "node:crypto";
+function normalizeString30(value) {
+  return String(value ?? "").trim();
+}
+function buildBindingResult(binding) {
+  return {
+    aibot_session_id: normalizeString30(binding?.aibot_session_id),
+    claude_session_id: normalizeString30(binding?.claude_session_id),
+    cwd: normalizeString30(binding?.cwd),
+    worker_status: normalizeString30(binding?.worker_status)
+  };
+}
+function buildSuccessResult2(verb, outcome, binding) {
+  return {
+    status: localActionResultStatuses.ok,
+    result: {
+      domain: resultDomains.sessionControl,
+      verb,
+      outcome,
+      binding: buildBindingResult(binding)
+    }
+  };
+}
+function buildFailure(errorCode, errorMsg) {
+  return {
+    status: localActionResultStatuses.failed,
+    errorCode,
+    errorMsg
+  };
+}
+var DaemonSessionControlActionHandler;
+var init_session_control_action_handler = __esm({
+  "server/daemon/session-control-action-handler.js"() {
+    init_protocol_contract();
+    init_daemon_paths();
+    DaemonSessionControlActionHandler = class {
+      constructor({
+        env = process.env,
+        bindingRegistry,
+        workerProcessManager,
+        bridgeServer,
+        ensureWorker,
+        ensureDirectoryExists: ensureDirectoryExists2
+      } = {}) {
+        this.env = env;
+        this.bindingRegistry = bindingRegistry;
+        this.workerProcessManager = workerProcessManager;
+        this.bridgeServer = bridgeServer;
+        this.ensureWorker = ensureWorker;
+        this.ensureDirectoryExists = ensureDirectoryExists2;
+      }
+      getBinding(sessionID) {
+        return this.bindingRegistry.getByAibotSessionID(sessionID);
+      }
+      async createBinding(sessionID, cwd) {
+        const workerID = randomUUID6();
+        const claudeSessionID = randomUUID6();
+        const pluginDataDir = resolveWorkerPluginDataDir(sessionID, this.env);
+        const now = Date.now();
+        const created = await this.bindingRegistry.createBinding({
+          aibot_session_id: sessionID,
+          claude_session_id: claudeSessionID,
+          cwd,
+          worker_id: workerID,
+          worker_status: bindingWorkerStatuses.starting,
+          plugin_data_dir: pluginDataDir,
+          created_at: now,
+          updated_at: now,
+          last_started_at: now,
+          last_stopped_at: 0
+        });
+        await this.workerProcessManager.spawnWorker({
+          aibotSessionID: created.aibot_session_id,
+          cwd: created.cwd,
+          pluginDataDir: created.plugin_data_dir,
+          claudeSessionID: created.claude_session_id,
+          workerID: created.worker_id,
+          bridgeURL: this.bridgeServer.getURL(),
+          bridgeToken: this.bridgeServer.token
+        });
+        return this.getBinding(sessionID) ?? created;
+      }
+      async handleOpen(sessionID, params) {
+        const cwd = normalizeString30(params?.cwd);
+        if (!cwd) {
+          return buildFailure(sessionControlErrorCodes.cwdRequired, "session control cwd is required");
+        }
+        try {
+          await this.ensureDirectoryExists(cwd);
+        } catch (error) {
+          return buildFailure(
+            sessionControlErrorCodes.invalidCwd,
+            normalizeString30(error?.message || error) || "session control cwd is invalid"
+          );
+        }
+        const existing = this.getBinding(sessionID);
+        if (existing) {
+          if (existing.cwd !== cwd) {
+            return buildFailure(
+              sessionControlErrorCodes.rebindForbidden,
+              "session binding cannot be changed to another working directory"
+            );
+          }
+          try {
+            await this.ensureWorker(existing, { ignoreAuthCooldown: true });
+          } catch (error) {
+            return buildFailure(
+              sessionControlErrorCodes.runtimeError,
+              normalizeString30(error?.message || error) || "session control open failed"
+            );
+          }
+          return buildSuccessResult2(sessionControlVerbs.open, sessionControlOutcomes.alreadyBound, this.getBinding(sessionID) ?? existing);
+        }
+        try {
+          const created = await this.createBinding(sessionID, cwd);
+          return buildSuccessResult2(sessionControlVerbs.open, sessionControlOutcomes.opened, created);
+        } catch (error) {
+          return buildFailure(
+            sessionControlErrorCodes.runtimeError,
+            normalizeString30(error?.message || error) || "session control open failed"
+          );
+        }
+      }
+      handleStatus(sessionID) {
+        const binding = this.getBinding(sessionID);
+        if (!binding) {
+          return buildFailure(sessionControlErrorCodes.bindingMissing, "session binding was not found");
+        }
+        return buildSuccessResult2(sessionControlVerbs.status, sessionControlOutcomes.status, binding);
+      }
+      handleWhere(sessionID) {
+        const binding = this.getBinding(sessionID);
+        if (!binding) {
+          return buildFailure(sessionControlErrorCodes.bindingMissing, "session binding was not found");
+        }
+        return buildSuccessResult2(sessionControlVerbs.where, sessionControlOutcomes.where, binding);
+      }
+      async handleStop(sessionID) {
+        const binding = this.getBinding(sessionID);
+        if (!binding) {
+          return buildFailure(sessionControlErrorCodes.bindingMissing, "session binding was not found");
+        }
+        try {
+          if (binding.worker_id) {
+            await this.workerProcessManager.stopWorker(binding.worker_id);
+          }
+          await this.bindingRegistry.markWorkerStopped(sessionID, {
+            updatedAt: Date.now(),
+            lastStoppedAt: Date.now()
+          });
+        } catch (error) {
+          return buildFailure(
+            sessionControlErrorCodes.runtimeError,
+            normalizeString30(error?.message || error) || "session control stop failed"
+          );
+        }
+        return buildSuccessResult2(sessionControlVerbs.stop, sessionControlOutcomes.stopped, this.getBinding(sessionID) ?? {
+          ...binding,
+          worker_status: bindingWorkerStatuses.stopped
+        });
+      }
+      async handleLocalAction(action) {
+        if (normalizeString30(action?.action_type) !== localActionTypes.sessionControl) {
+          return {
+            handled: false
+          };
+        }
+        const sessionID = normalizeString30(action?.params?.session_id);
+        if (!sessionID) {
+          return {
+            handled: true,
+            response: buildFailure(localActionErrorCodes.localActionRouteMissing, "local action session_id is required")
+          };
+        }
+        const verb = normalizeString30(action?.params?.verb).toLowerCase();
+        switch (verb) {
+          case sessionControlVerbs.open:
+            return {
+              handled: true,
+              response: await this.handleOpen(sessionID, action.params)
+            };
+          case sessionControlVerbs.status:
+            return {
+              handled: true,
+              response: this.handleStatus(sessionID)
+            };
+          case sessionControlVerbs.where:
+            return {
+              handled: true,
+              response: this.handleWhere(sessionID)
+            };
+          case sessionControlVerbs.stop:
+            return {
+              handled: true,
+              response: await this.handleStop(sessionID)
+            };
+          default:
+            return {
+              handled: true,
+              response: buildFailure(sessionControlErrorCodes.verbInvalid, "session control verb is invalid")
+            };
+        }
       }
     };
   }
@@ -17194,7 +17892,7 @@ var init_session_queue = __esm({
 
 // server/worker-probe.js
 import { randomUUID as randomUUID7 } from "node:crypto";
-function normalizeString29(value) {
+function normalizeString31(value) {
   return String(value ?? "").trim();
 }
 function buildWorkerPingProbePayload({ sessionID, workerID = "", claudeSessionID = "" } = {}) {
@@ -17211,7 +17909,7 @@ function buildWorkerPingProbePayload({ sessionID, workerID = "", claudeSessionID
   return {
     event_id: `probe_${probeID}`,
     event_type: "user_chat",
-    session_id: normalizeString29(sessionID),
+    session_id: normalizeString31(sessionID),
     session_type: "1",
     msg_id: `probe_msg_${probeID}`,
     sender_id: probeSenderID,
@@ -17220,13 +17918,13 @@ function buildWorkerPingProbePayload({ sessionID, workerID = "", claudeSessionID
     msg_type: "1",
     content: "ping",
     created_at: Date.now(),
-    worker_id: normalizeString29(workerID),
-    claude_session_id: normalizeString29(claudeSessionID),
+    worker_id: normalizeString31(workerID),
+    claude_session_id: normalizeString31(claudeSessionID),
     channel_data: channelData
   };
 }
 function isExpectedWorkerProbeReply(text, expectedReply = "pong") {
-  return normalizeString29(text).toLowerCase() === normalizeString29(expectedReply).toLowerCase();
+  return normalizeString31(text).toLowerCase() === normalizeString31(expectedReply).toLowerCase();
 }
 var probeChannelNamespace, probeSenderID, probeKind, defaultWorkerPingProbeTimeoutMs;
 var init_worker_probe = __esm({
@@ -17240,19 +17938,22 @@ var init_worker_probe = __esm({
 
 // server/daemon/runtime.js
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { stat as stat2 } from "node:fs/promises";
-function normalizeString30(value) {
+import { stat as stat3 } from "node:fs/promises";
+function normalizeString32(value) {
   return String(value ?? "").trim();
 }
-function sleep2(ms) {
+function isRecordOnlyMirror(event) {
+  return normalizeString32(event?.mirror_mode) === "record_only";
+}
+function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function ensureDirectoryExists(directoryPath) {
   let info;
   try {
-    info = await stat2(directoryPath);
+    info = await stat3(directoryPath);
   } catch (error) {
-    const code = normalizeString30(error?.code);
+    const code = normalizeString32(error?.code);
     if (code === "ENOENT") {
       throw new Error("\u6307\u5B9A\u8DEF\u5F84\u4E0D\u5B58\u5728\u3002");
     }
@@ -17265,44 +17966,6 @@ async function ensureDirectoryExists(directoryPath) {
     throw new Error("\u6307\u5B9A\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55\u3002");
   }
 }
-function formatBindingSummary(binding) {
-  if (!binding) {
-    return "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u7ED1\u5B9A\u76EE\u5F55\u3002";
-  }
-  const lines = [
-    `Aibot \u4F1A\u8BDD: ${binding.aibot_session_id}`,
-    `Claude \u4F1A\u8BDD: ${binding.claude_session_id}`,
-    `\u76EE\u5F55: ${binding.cwd}`,
-    `Worker \u72B6\u6001: ${binding.worker_status}`,
-    `\u53EF\u7528\u6027\u8BC4\u4F30: ${formatWorkerResponseAssessment(binding)}`
-  ];
-  const responseReason = normalizeString30(binding?.worker_response_reason);
-  if (responseReason) {
-    lines.push(`\u8BC4\u4F30\u539F\u56E0: ${responseReason}`);
-  }
-  const lastReplyAt = formatStatusTimestamp(binding?.worker_last_reply_at);
-  if (lastReplyAt) {
-    lines.push(`\u6700\u8FD1\u6210\u529F: ${lastReplyAt}`);
-  }
-  const lastFailureAt = formatStatusTimestamp(binding?.worker_last_failure_at);
-  if (lastFailureAt) {
-    const failureCode = normalizeString30(binding?.worker_last_failure_code);
-    lines.push(`\u6700\u8FD1\u5931\u8D25: ${lastFailureAt}${failureCode ? ` (${failureCode})` : ""}`);
-  }
-  const lastHookAt = formatStatusTimestamp(binding?.worker_last_hook_event_at);
-  if (lastHookAt) {
-    const lastHookSummary = summarizeHookSignalEvent({
-      event_id: binding?.worker_last_hook_event_id,
-      hook_event_name: binding?.worker_last_hook_event_name,
-      event_at: binding?.worker_last_hook_event_at,
-      detail: binding?.worker_last_hook_event_detail
-    });
-    if (lastHookSummary) {
-      lines.push(`\u6700\u8FD1 Hook: ${lastHookSummary} @ ${lastHookAt}`);
-    }
-  }
-  return lines.join("\n");
-}
 function buildInterruptedEventNotice() {
   return "Claude \u521A\u521A\u4E2D\u65AD\u4E86\uFF0C\u8FD9\u6761\u6D88\u606F\u6CA1\u6709\u5904\u7406\u5B8C\u6210\u3002\u8BF7\u518D\u53D1\u4E00\u6B21\u3002";
 }
@@ -17312,46 +17975,147 @@ function buildAuthLoginRequiredEventNotice() {
 function buildUsageLimitReachedEventNotice() {
   return "Claude \u5F53\u524D\u989D\u5EA6\u5DF2\u7528\u5B8C\uFF0C\u6CA1\u6CD5\u7EE7\u7EED\u56DE\u590D\u3002\u8BF7\u5148\u5728 Claude \u91CC\u5904\u7406\u989D\u5EA6\u63D0\u793A\uFF0C\u7136\u540E\u628A\u8FD9\u6761\u6D88\u606F\u518D\u53D1\u4E00\u6B21\u3002";
 }
+function buildBindingMissingEventNotice() {
+  return buildAgentOpenSessionCardLink({
+    summaryText: "\u5F53\u524D\u5BF9\u8BDD\u8FD8\u6CA1\u6709\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55\u3002",
+    detailText: "\u5148\u63D0\u4EA4\u4E00\u4E2A\u5DE5\u4F5C\u76EE\u5F55\uFF0CClaude \u624D\u80FD\u7EE7\u7EED\u5904\u7406\u6D88\u606F\u3002\u63D0\u4EA4\u540E\uFF0C\u628A\u521A\u624D\u90A3\u6761\u6D88\u606F\u518D\u53D1\u4E00\u6B21\u3002"
+  });
+}
+function buildSessionControlOpenCardNotice({
+  summaryText = "",
+  detailText = "",
+  initialCwd = ""
+} = {}) {
+  return buildAgentOpenSessionCardLink({
+    summaryText: normalizeString32(summaryText) || "\u5F53\u524D\u5BF9\u8BDD\u8FD8\u6CA1\u6709\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55\u3002",
+    detailText: normalizeString32(detailText) || "\u5148\u63D0\u4EA4\u4E00\u4E2A\u5DE5\u4F5C\u76EE\u5F55\uFF0CClaude \u624D\u80FD\u7EE7\u7EED\u5904\u7406\u6D88\u606F\u3002",
+    initialCwd
+  });
+}
+function formatSessionControlBindingSummary(binding) {
+  const normalizedBinding = binding ?? {};
+  const cwd = normalizeString32(normalizedBinding.cwd);
+  const workerStatus = normalizeString32(normalizedBinding.worker_status);
+  const lines = [];
+  if (cwd) {
+    lines.push(`\u5DE5\u4F5C\u76EE\u5F55\uFF1A${cwd}`);
+  }
+  if (workerStatus) {
+    lines.push(`\u72B6\u6001\uFF1A${workerStatus}`);
+  }
+  return lines.join("\n");
+}
+function buildSessionControlSuccessNotice(result) {
+  const verb = normalizeString32(result?.verb);
+  const outcome = normalizeString32(result?.outcome);
+  const binding = result?.binding ?? {};
+  const summary = formatSessionControlBindingSummary(binding);
+  if (verb === sessionControlVerbs.open) {
+    const title = outcome === sessionControlOutcomes.alreadyBound ? "\u5F53\u524D\u5BF9\u8BDD\u5DF2\u7ECF\u6253\u5F00\u8FD9\u4E2A\u5DE5\u4F5C\u76EE\u5F55\u3002" : "\u5DF2\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55\u3002";
+    return summary ? `${title}
+
+${summary}` : title;
+  }
+  if (verb === sessionControlVerbs.status) {
+    return summary || "\u5F53\u524D\u5BF9\u8BDD\u5DF2\u7ECF\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55\u3002";
+  }
+  if (verb === sessionControlVerbs.where) {
+    const cwd = normalizeString32(binding.cwd);
+    return cwd ? `\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF1A${cwd}` : "\u5F53\u524D\u5BF9\u8BDD\u8FD8\u6CA1\u6709\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55\u3002";
+  }
+  if (verb === sessionControlVerbs.stop) {
+    return summary ? `\u5DF2\u505C\u6B62\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u4F1A\u8BDD\u3002
+
+${summary}` : "\u5DF2\u505C\u6B62\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u4F1A\u8BDD\u3002";
+  }
+  return "\u5DE5\u4F5C\u76EE\u5F55\u64CD\u4F5C\u5DF2\u5B8C\u6210\u3002";
+}
+function buildSessionControlFailureNotice({
+  errorCode = "",
+  errorMsg = ""
+} = {}) {
+  const normalizedErrorCode = normalizeString32(errorCode);
+  const normalizedErrorMsg = normalizeString32(errorMsg);
+  if (normalizedErrorCode === sessionControlErrorCodes.rebindForbidden) {
+    return normalizedErrorMsg || "\u5F53\u524D\u5BF9\u8BDD\u5DF2\u7ECF\u56FA\u5B9A\u7ED1\u5B9A\u5230\u53E6\u4E00\u4E2A\u5DE5\u4F5C\u76EE\u5F55\u3002";
+  }
+  if (normalizedErrorCode === sessionControlErrorCodes.verbInvalid) {
+    return normalizedErrorMsg || "\u547D\u4EE4\u683C\u5F0F\u4E0D\u6B63\u786E\u3002";
+  }
+  return normalizedErrorMsg || "\u5DE5\u4F5C\u76EE\u5F55\u64CD\u4F5C\u5931\u8D25\u3002";
+}
+function buildSessionControlCardSummary(errorCode, errorMsg) {
+  const normalizedErrorCode = normalizeString32(errorCode);
+  const normalizedErrorMsg = normalizeString32(errorMsg);
+  if (normalizedErrorCode === sessionControlErrorCodes.bindingMissing) {
+    return "\u5F53\u524D\u5BF9\u8BDD\u8FD8\u6CA1\u6709\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55\u3002";
+  }
+  if (normalizedErrorCode === sessionControlErrorCodes.invalidCwd) {
+    return normalizedErrorMsg || "\u6307\u5B9A\u8DEF\u5F84\u4E0D\u53EF\u7528\u3002";
+  }
+  if (normalizedErrorCode === sessionControlErrorCodes.cwdRequired) {
+    return normalizedErrorMsg || "\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55\u65F6\u7F3A\u5C11\u76EE\u5F55\u8DEF\u5F84\u3002";
+  }
+  return normalizedErrorMsg || "\u5F53\u524D\u5BF9\u8BDD\u8FD8\u6CA1\u6709\u6253\u5F00\u5DE5\u4F5C\u76EE\u5F55\u3002";
+}
+function buildInteractionReplyFailureNotice({
+  errorCode = "",
+  errorMsg = ""
+} = {}) {
+  const normalizedErrorCode = normalizeString32(errorCode);
+  const normalizedErrorMsg = normalizeString32(errorMsg);
+  if (normalizedErrorCode === interactionReplyErrorCodes.requestNotPending) {
+    return "\u8FD9\u6761\u4EA4\u4E92\u5DF2\u7ECF\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u53D1\u8D77\u3002";
+  }
+  if (normalizedErrorCode === interactionReplyErrorCodes.requestNotFound) {
+    return "\u6CA1\u6709\u627E\u5230\u5BF9\u5E94\u7684\u4EA4\u4E92\u8BF7\u6C42\u3002";
+  }
+  if (normalizedErrorCode === interactionReplyErrorCodes.requestIDRequired || normalizedErrorCode === interactionReplyErrorCodes.resolutionInvalid) {
+    return normalizedErrorMsg || "\u4EA4\u4E92\u56DE\u590D\u683C\u5F0F\u4E0D\u6B63\u786E\u3002";
+  }
+  if (normalizedErrorCode === "local_action_delivery_failed") {
+    return "Claude \u8FD8\u6CA1\u51C6\u5907\u597D\u5904\u7406\u8FD9\u6761\u4EA4\u4E92\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+  }
+  if (normalizedErrorCode === "local_action_result_timeout") {
+    return "\u4EA4\u4E92\u56DE\u590D\u63D0\u4EA4\u8D85\u65F6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+  }
+  return normalizedErrorMsg || "\u4EA4\u4E92\u56DE\u590D\u63D0\u4EA4\u5931\u8D25\u3002";
+}
 function buildWorkerStartupFailedNotice() {
   return "Claude \u542F\u52A8\u672A\u5B8C\u6210\uFF0C\u6D88\u606F\u672A\u53D1\u9001\u3002\u8BF7\u6267\u884C grix-claude restart \u540E\u91CD\u8BD5\u3002";
 }
 function buildUsageLimitFailureOptions() {
   return {
     noticeText: buildUsageLimitReachedEventNotice(),
-    replySource: "daemon_worker_usage_limit_reached",
     resultCode: "claude_usage_limit_reached",
     resultMessage: "claude usage limit reached; user action required"
   };
 }
-function buildMissingBindingCardOptions() {
+function normalizeLocalActionPayload(rawPayload) {
   return {
-    summaryText: "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u7ED1\u5B9A\u76EE\u5F55\u3002",
-    detailText: "\u53D1\u9001 open <\u76EE\u5F55> \u6765\u521B\u5EFA\u4F1A\u8BDD\u3002"
+    action_id: normalizeString32(rawPayload?.action_id),
+    event_id: normalizeString32(rawPayload?.event_id),
+    action_type: normalizeString32(rawPayload?.action_type),
+    params: rawPayload?.params && typeof rawPayload.params === "object" && !Array.isArray(rawPayload.params) ? rawPayload.params : {},
+    timeout_ms: normalizeNonNegativeInt(rawPayload?.timeout_ms, 0)
   };
 }
 function withWorkerLaunchFailure(binding, code) {
   return {
     ...binding ?? {},
-    worker_launch_failure: normalizeString30(code)
+    worker_launch_failure: normalizeString32(code)
   };
 }
 function formatRuntimeError(error, fallback = "\u5904\u7406\u5931\u8D25\u3002") {
-  const message = normalizeString30(error?.message || error);
+  const message = normalizeString32(error?.message || error);
   return message || fallback;
 }
-function formatStatusTimestamp(value) {
-  const numeric = Number(value);
-  if (!Number.isFinite(numeric) || numeric <= 0) {
-    return "";
-  }
-  return new Date(numeric).toISOString();
-}
 function normalizeHookSignalRecord(input) {
   if (!input || typeof input !== "object") {
     return null;
   }
-  const eventID = normalizeString30(input.event_id);
-  const eventName = normalizeString30(input.hook_event_name);
+  const eventID = normalizeString32(input.event_id);
+  const eventName = normalizeString32(input.hook_event_name);
   const eventAt = Number(input.event_at ?? 0);
   if (!eventID || !eventName || !Number.isFinite(eventAt) || eventAt <= 0) {
     return null;
@@ -17360,7 +18124,7 @@ function normalizeHookSignalRecord(input) {
     event_id: eventID,
     hook_event_name: eventName,
     event_at: Math.floor(eventAt),
-    detail: normalizeString30(input.detail)
+    detail: normalizeString32(input.detail)
   };
 }
 function listHookSignalRecords(pingPayload) {
@@ -17386,12 +18150,12 @@ function buildPingActivityTraceFields(pingPayload = {}) {
     reported_mcp_ready: pingPayload?.mcp_ready === true ? true : pingPayload?.mcp_ready === false ? false : "",
     reported_mcp_last_activity_at: normalizeNonNegativeInt(pingPayload?.mcp_last_activity_at, 0),
     reported_hook_last_activity_at: normalizeNonNegativeInt(pingPayload?.hook_last_activity_at, 0),
-    reported_hook_event_name: normalizeString30(pingPayload?.hook_latest_event?.hook_event_name)
+    reported_hook_event_name: normalizeString32(pingPayload?.hook_latest_event?.hook_event_name)
   };
 }
 function buildMcpHealthTraceFields(mcpHealth = {}) {
   return {
-    mcp_health_reason: normalizeString30(mcpHealth?.reason),
+    mcp_health_reason: normalizeString32(mcpHealth?.reason),
     mcp_health_idle_ms: normalizeNonNegativeInt(mcpHealth?.idleMs, 0),
     inflight_event_count: normalizeNonNegativeInt(mcpHealth?.inFlightCount, 0),
     latest_event_activity_at: normalizeNonNegativeInt(mcpHealth?.latestInteractionAt, 0),
@@ -17400,7 +18164,7 @@ function buildMcpHealthTraceFields(mcpHealth = {}) {
 }
 function buildMcpResultTimeoutTraceFields(details = {}) {
   return {
-    delivery_state: normalizeString30(details?.deliveryState),
+    delivery_state: normalizeString32(details?.deliveryState),
     record_updated_at: normalizeNonNegativeInt(details?.updatedAt, 0),
     record_last_composing_at: normalizeNonNegativeInt(details?.lastComposingAt, 0),
     record_interaction_at: normalizeNonNegativeInt(details?.recordInteractionAt, 0),
@@ -17416,6 +18180,9 @@ function normalizeNonNegativeInt(value, fallbackValue) {
   }
   return Math.max(0, Math.floor(numeric));
 }
+function isSyntheticLocalActionID(actionID) {
+  return normalizeString32(actionID).startsWith(syntheticLocalActionIDPrefix);
+}
 function resolveExpectedWorkerPid(binding, runtime) {
   const bindingPid = Number(binding?.worker_pid ?? 0);
   if (Number.isFinite(bindingPid) && bindingPid > 0) {
@@ -17435,15 +18202,15 @@ function resolveExpectedIdentityWorkerPid(binding) {
   return 0;
 }
 function buildRevokeDedupKey({ eventID = "", sessionID = "", msgID = "" } = {}) {
-  const normalizedSessionID = normalizeString30(sessionID);
-  const normalizedMsgID = normalizeString30(msgID);
+  const normalizedSessionID = normalizeString32(sessionID);
+  const normalizedMsgID = normalizeString32(msgID);
   if (normalizedSessionID && normalizedMsgID) {
     return `${normalizedSessionID}:${normalizedMsgID}`;
   }
-  return normalizeString30(eventID);
+  return normalizeString32(eventID);
 }
 function classifyWorkerEventResult(payload) {
-  const code = normalizeString30(payload?.code);
+  const code = normalizeString32(payload?.code);
   if (workerResponseFailureCodes.has(code)) {
     return {
       state: "failed",
@@ -17453,27 +18220,28 @@ function classifyWorkerEventResult(payload) {
   }
   return {
     state: "healthy",
-    reason: code || normalizeString30(payload?.status) || "worker_event_result_observed",
+    reason: code || normalizeString32(payload?.status) || "worker_event_result_observed",
     failureCode: ""
   };
 }
-var defaultDeliveredInFlightMaxAgeMs, defaultWorkerControlProbeFailureThreshold, defaultMcpInteractionIdleMs, defaultMcpResultTimeoutMs, defaultRecentRevokeRetentionMs, defaultAuthFailureCooldownMs, defaultWorkerPingProbeRetentionMs, workerResponseFailureCodes, DaemonRuntime;
+var defaultDeliveredInFlightMaxAgeMs, defaultWorkerControlProbeFailureThreshold, defaultMcpInteractionIdleMs, defaultMcpResultTimeoutMs, defaultRecentRevokeRetentionMs, defaultAuthFailureCooldownMs, defaultWorkerPingProbeRetentionMs, syntheticLocalActionIDPrefix, workerResponseFailureCodes, DaemonRuntime;
 var init_runtime = __esm({
   "server/daemon/runtime.js"() {
-    init_control_command();
+    init_agent_open_session_card();
     init_inbound_event_meta();
     init_message_delivery_store();
     init_worker_control_client();
-    init_control_card();
     init_claude_session_store();
-    init_control_command_handler();
     init_worker_health_inspector();
     init_pending_event_orchestrator();
     init_session_queue();
     init_process_control();
     init_hook_signal_store();
+    init_inbound_interaction_action();
+    init_session_control_action_handler();
     init_worker_state();
     init_worker_probe();
+    init_protocol_contract();
     defaultDeliveredInFlightMaxAgeMs = 60 * 1e3;
     defaultWorkerControlProbeFailureThreshold = 3;
     defaultMcpInteractionIdleMs = 15 * 60 * 1e3;
@@ -17481,6 +18249,7 @@ var init_runtime = __esm({
     defaultRecentRevokeRetentionMs = 24 * 60 * 60 * 1e3;
     defaultAuthFailureCooldownMs = 60 * 1e3;
     defaultWorkerPingProbeRetentionMs = 60 * 1e3;
+    syntheticLocalActionIDPrefix = "synthetic-local-action:";
     workerResponseFailureCodes = /* @__PURE__ */ new Set([
       "claude_result_timeout",
       "claude_usage_limit_reached",
@@ -17562,6 +18331,7 @@ var init_runtime = __esm({
         this.workerControlProbeFailures = /* @__PURE__ */ new Map();
         this.workerPingProbeRecords = /* @__PURE__ */ new Map();
         this.workerPingProbeInFlight = /* @__PURE__ */ new Map();
+        this.syntheticLocalActionWaiters = /* @__PURE__ */ new Map();
         this.pendingEventWorkerLogCursors = /* @__PURE__ */ new Map();
         this.ensureWorkerInFlight = /* @__PURE__ */ new Map();
         this.resumeAuthRecoveryInFlight = /* @__PURE__ */ new Map();
@@ -17569,18 +18339,13 @@ var init_runtime = __esm({
         this.sessionQueues = new SessionQueueRegistry(
           (fields, level) => this.trace(fields, level)
         );
-        this.controlCommandHandler = new DaemonControlCommandHandler({
+        this.sessionControlActionHandler = new DaemonSessionControlActionHandler({
           env: this.env,
           bindingRegistry: this.bindingRegistry,
           workerProcessManager: this.workerProcessManager,
           bridgeServer: this.bridgeServer,
           ensureWorker: async (...args) => this.ensureWorker(...args),
-          respond: async (event, text, extra = {}, result = {}) => this.respond(event, text, extra, result),
-          respondWithOpenWorkspaceCard: async (event, options = {}, result = {}) => this.respondWithOpenWorkspaceCard(event, options, result),
-          ensureDirectoryExists,
-          formatBindingSummary,
-          buildMissingBindingCardOptions,
-          formatRuntimeError
+          ensureDirectoryExists
         });
         this.pendingEventOrchestrator = new PendingEventOrchestrator({
           messageDeliveryStore: this.messageDeliveryStore,
@@ -17612,18 +18377,18 @@ var init_runtime = __esm({
         }, { level });
       }
       async handleWorkerProcessExit({ workerID, aibotSessionID, exitCode, exitSignal }) {
-        const sessionID = normalizeString30(aibotSessionID);
+        const sessionID = normalizeString32(aibotSessionID);
         if (!sessionID) return;
         const queue = this.sessionQueues.ensure(sessionID);
         queue.run(async () => {
           const binding = this.bindingRegistry.getByAibotSessionID(sessionID);
-          if (!binding || normalizeString30(binding.worker_id) !== normalizeString30(workerID)) {
+          if (!binding || normalizeString32(binding.worker_id) !== normalizeString32(workerID)) {
             return;
           }
           if (binding.worker_status === "stopped" || binding.worker_status === "failed") {
             return;
           }
-          let signal = normalizeString30(exitSignal) || "wrapper_exited";
+          let signal = normalizeString32(exitSignal) || "wrapper_exited";
           const hasAuthError = await this.workerProcessManager?.hasAuthLoginRequiredError?.(workerID);
           if (hasAuthError) {
             const runtime = this.workerProcessManager?.getWorkerRuntime?.(workerID);
@@ -17661,14 +18426,14 @@ var init_runtime = __esm({
         });
       }
       getWorkerPingProbeRecord(eventID) {
-        const normalizedEventID = normalizeString30(eventID);
+        const normalizedEventID = normalizeString32(eventID);
         if (!normalizedEventID) {
           return null;
         }
         return this.workerPingProbeRecords.get(normalizedEventID) ?? null;
       }
       clearWorkerPingProbeRecord(eventID) {
-        const normalizedEventID = normalizeString30(eventID);
+        const normalizedEventID = normalizeString32(eventID);
         if (!normalizedEventID) {
           return;
         }
@@ -17737,9 +18502,9 @@ var init_runtime = __esm({
           event_id: record.eventID,
           response_state: nextBinding?.worker_response_state,
           response_reason: nextBinding?.worker_response_reason,
-          terminal_status: normalizeString30(payload?.status),
-          terminal_code: normalizeString30(payload?.code),
-          probe_text: normalizeString30(payload?.text)
+          terminal_status: normalizeString32(payload?.status),
+          terminal_code: normalizeString32(payload?.code),
+          probe_text: normalizeString32(payload?.text)
         }, level);
         this.scheduleWorkerPingProbeRecordCleanup(record.eventID);
         record.resolve?.(nextBinding);
@@ -17747,7 +18512,7 @@ var init_runtime = __esm({
         return nextBinding;
       }
       async ensureWorkerPingProbe(binding) {
-        const sessionID = normalizeString30(binding?.aibot_session_id);
+        const sessionID = normalizeString32(binding?.aibot_session_id);
         if (!sessionID) {
           return binding;
         }
@@ -17769,7 +18534,7 @@ var init_runtime = __esm({
         }
       }
       async runWorkerPingProbe(binding) {
-        const sessionID = normalizeString30(binding?.aibot_session_id);
+        const sessionID = normalizeString32(binding?.aibot_session_id);
         if (!sessionID || !hasReadyWorkerBridge(binding)) {
           return binding;
         }
@@ -17808,8 +18573,8 @@ var init_runtime = __esm({
         const record = {
           eventID: probePayload.event_id,
           sessionID,
-          workerID: normalizeString30(probingBinding?.worker_id),
-          claudeSessionID: normalizeString30(probingBinding?.claude_session_id),
+          workerID: normalizeString32(probingBinding?.worker_id),
+          claudeSessionID: normalizeString32(probingBinding?.claude_session_id),
           expectedReply: "pong",
           state: "probing",
           settled: false,
@@ -17849,7 +18614,7 @@ var init_runtime = __esm({
           worker_id: record.workerID,
           claude_session_id: record.claudeSessionID,
           event_id: record.eventID,
-          fallback_reason: normalizeString30(record.lastControlPingReason) || "control_ping_unavailable"
+          fallback_reason: normalizeString32(record.lastControlPingReason) || "control_ping_unavailable"
         }, "debug");
         try {
           await client.deliverEvent(probePayload);
@@ -17895,10 +18660,10 @@ var init_runtime = __esm({
           }, "debug");
           return null;
         }
-        const expectedWorkerID = normalizeString30(record?.workerID);
-        const expectedClaudeSessionID = normalizeString30(record?.claudeSessionID);
-        const currentWorkerID = normalizeString30(currentBinding?.worker_id);
-        const currentClaudeSessionID = normalizeString30(currentBinding?.claude_session_id);
+        const expectedWorkerID = normalizeString32(record?.workerID);
+        const expectedClaudeSessionID = normalizeString32(record?.claudeSessionID);
+        const currentWorkerID = normalizeString32(currentBinding?.worker_id);
+        const currentClaudeSessionID = normalizeString32(currentBinding?.claude_session_id);
         if (expectedWorkerID && currentWorkerID && expectedWorkerID !== currentWorkerID) {
           record.lastControlPingReason = "worker_id_mismatch";
           this.trace({
@@ -17940,26 +18705,26 @@ var init_runtime = __esm({
         const runtime = this.workerProcessManager?.getWorkerRuntime?.(currentWorkerID);
         const identityHealth = this.inspectWorkerIdentityHealth(currentBinding, runtime, pingPayload);
         if (!identityHealth.ok) {
-          record.lastControlPingReason = normalizeString30(identityHealth.reason) || "identity_unhealthy";
+          record.lastControlPingReason = normalizeString32(identityHealth.reason) || "identity_unhealthy";
           this.trace({
             stage: "worker_ping_probe_control_ping_unhealthy",
             ...traceContext,
             reason: record.lastControlPingReason,
             expected_pid: normalizeNonNegativeInt(identityHealth.expectedPid, 0),
             reported_pid: normalizeNonNegativeInt(identityHealth.reportedPid, 0),
-            expected_worker_id: normalizeString30(identityHealth.expectedWorkerID),
-            reported_worker_id: normalizeString30(identityHealth.reportedWorkerID),
-            expected_session_id: normalizeString30(identityHealth.expectedSessionID),
-            reported_session_id: normalizeString30(identityHealth.reportedSessionID),
-            expected_claude_session_id: normalizeString30(identityHealth.expectedClaudeSessionID),
-            reported_claude_session_id: normalizeString30(identityHealth.reportedClaudeSessionID),
+            expected_worker_id: normalizeString32(identityHealth.expectedWorkerID),
+            reported_worker_id: normalizeString32(identityHealth.reportedWorkerID),
+            expected_session_id: normalizeString32(identityHealth.expectedSessionID),
+            reported_session_id: normalizeString32(identityHealth.reportedSessionID),
+            expected_claude_session_id: normalizeString32(identityHealth.expectedClaudeSessionID),
+            reported_claude_session_id: normalizeString32(identityHealth.reportedClaudeSessionID),
             ...buildPingActivityTraceFields(pingPayload)
           });
           return null;
         }
         const mcpHealth = this.inspectMcpInteractionHealth(currentBinding, pingPayload);
         if (!mcpHealth.ok) {
-          record.lastControlPingReason = normalizeString30(mcpHealth.reason) || "mcp_unhealthy";
+          record.lastControlPingReason = normalizeString32(mcpHealth.reason) || "mcp_unhealthy";
           this.trace({
             stage: "worker_ping_probe_control_ping_unhealthy",
             ...traceContext,
@@ -18020,7 +18785,7 @@ var init_runtime = __esm({
         if (record.settled) {
           return { handled: true, ack: { msg_id: `probe_${record.eventID}` } };
         }
-        const replyText = normalizeString30(payload?.text);
+        const replyText = normalizeString32(payload?.text);
         if (isExpectedWorkerProbeReply(replyText, record.expectedReply)) {
           await this.updateWorkerPingProbeOutcome(record, {
             state: "healthy",
@@ -18044,8 +18809,8 @@ var init_runtime = __esm({
           return { handled: false };
         }
         if (!record.settled) {
-          const status = normalizeString30(payload?.status);
-          const code = normalizeString30(payload?.code);
+          const status = normalizeString32(payload?.status);
+          const code = normalizeString32(payload?.code);
           if (record.timeoutRecovering && status !== "responded" && code === "claude_result_timeout") {
             this.trace({
               stage: "worker_ping_probe_event_result_ignored_timeout_during_recovery",
@@ -18084,6 +18849,9 @@ var init_runtime = __esm({
           this.clearWorkerPingProbeRecord(eventID);
         }
         this.workerPingProbeInFlight.clear();
+        for (const actionID of [...this.syntheticLocalActionWaiters.keys()]) {
+          this.clearSyntheticLocalActionWaiter(actionID);
+        }
         this.ensureWorkerInFlight.clear();
         this.resumeAuthRecoveryInFlight.clear();
         this.lastAuthRecoverySpawnAt.clear();
@@ -18120,8 +18888,8 @@ var init_runtime = __esm({
           event_id: event.event_id,
           status
         };
-        const normalizedCode = normalizeString30(code);
-        const normalizedMsg = normalizeString30(msg);
+        const normalizedCode = normalizeString32(code);
+        const normalizedMsg = normalizeString32(msg);
         if (normalizedCode) {
           payload.code = normalizedCode;
         }
@@ -18142,26 +18910,278 @@ var init_runtime = __esm({
         this.complete(event, result);
         return response;
       }
-      async respondWithOpenWorkspaceCard(event, {
-        summaryText,
-        detailText,
-        initialCwd = "",
-        replySource = ""
-      } = {}, result = {}) {
-        const fallbackText = normalizeString30(summaryText) || "\u5F53\u524D\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u7ED1\u5B9A\u76EE\u5F55\u3002";
-        return this.respond(
+      createSyntheticLocalActionWaiter(actionID, sessionID, timeoutMs) {
+        const normalizedActionID = normalizeString32(actionID);
+        const normalizedSessionID = normalizeString32(sessionID);
+        const effectiveTimeoutMs = Math.max(1, normalizeNonNegativeInt(timeoutMs, 15e3));
+        let resolvePromise = () => {
+        };
+        const promise = new Promise((resolve) => {
+          resolvePromise = resolve;
+        });
+        const timer = setTimeout(() => {
+          if (!this.syntheticLocalActionWaiters.has(normalizedActionID)) {
+            return;
+          }
+          this.syntheticLocalActionWaiters.delete(normalizedActionID);
+          resolvePromise({
+            status: localActionResultStatuses.failed,
+            result: void 0,
+            errorCode: "local_action_result_timeout",
+            errorMsg: "worker local action result timed out"
+          });
+        }, effectiveTimeoutMs);
+        timer.unref?.();
+        this.syntheticLocalActionWaiters.set(normalizedActionID, {
+          sessionID: normalizedSessionID,
+          resolve: resolvePromise,
+          timer
+        });
+        return promise;
+      }
+      clearSyntheticLocalActionWaiter(actionID) {
+        const normalizedActionID = normalizeString32(actionID);
+        const pending = this.syntheticLocalActionWaiters.get(normalizedActionID);
+        if (!pending) {
+          return null;
+        }
+        clearTimeout(pending.timer);
+        this.syntheticLocalActionWaiters.delete(normalizedActionID);
+        return pending;
+      }
+      resolveSyntheticLocalActionWaiter(actionID, result) {
+        const pending = this.clearSyntheticLocalActionWaiter(actionID);
+        if (!pending) {
+          return false;
+        }
+        pending.resolve(result);
+        return true;
+      }
+      async observeWorkerLocalActionResult(payload) {
+        const actionID = normalizeString32(payload?.action_id);
+        if (!actionID) {
+          return { handled: false };
+        }
+        const pending = this.syntheticLocalActionWaiters.get(actionID);
+        if (!pending) {
+          if (isSyntheticLocalActionID(actionID)) {
+            this.trace({
+              stage: "synthetic_local_action_result_ignored_late",
+              action_id: actionID,
+              session_id: this.resolveObservedSessionID(payload),
+              worker_id: payload?.worker_id,
+              claude_session_id: payload?.claude_session_id
+            });
+            return { handled: true };
+          }
+          return { handled: false };
+        }
+        const binding = this.bindingRegistry.getByAibotSessionID(pending.sessionID);
+        if (binding && this.shouldIgnoreObservedWorker(binding, payload)) {
+          this.trace({
+            stage: "synthetic_local_action_result_ignored",
+            action_id: actionID,
+            session_id: pending.sessionID,
+            worker_id: payload?.worker_id,
+            claude_session_id: payload?.claude_session_id
+          });
+          return { handled: true };
+        }
+        this.trace({
+          stage: "synthetic_local_action_result_observed",
+          action_id: actionID,
+          session_id: pending.sessionID,
+          status: payload?.status,
+          worker_id: payload?.worker_id
+        });
+        this.resolveSyntheticLocalActionWaiter(actionID, {
+          status: normalizeString32(payload?.status) || localActionResultStatuses.failed,
+          result: payload?.result,
+          errorCode: normalizeString32(payload?.error_code),
+          errorMsg: normalizeString32(payload?.error_msg)
+        });
+        return { handled: true };
+      }
+      async runSyntheticWorkerLocalAction(event, action) {
+        const normalizedActionType = normalizeString32(action?.action_type);
+        const params = action?.params && typeof action.params === "object" && !Array.isArray(action.params) ? action.params : {};
+        const sessionID = normalizeString32(params.session_id) || normalizeString32(event?.session_id);
+        if (!sessionID) {
+          return {
+            status: localActionResultStatuses.failed,
+            result: void 0,
+            errorCode: localActionErrorCodes.localActionRouteMissing,
+            errorMsg: "local action session_id is required"
+          };
+        }
+        const timeoutMs = Math.max(1, normalizeNonNegativeInt(action?.timeout_ms, 15e3));
+        const actionID = `${syntheticLocalActionIDPrefix}${event?.event_id || randomUUID8()}:${randomUUID8()}`;
+        const payload = {
+          action_id: actionID,
+          event_id: normalizeString32(event?.event_id),
+          action_type: normalizedActionType,
+          params: {
+            ...params,
+            session_id: sessionID
+          },
+          timeout_ms: timeoutMs
+        };
+        const waitPromise = this.createSyntheticLocalActionWaiter(actionID, sessionID, timeoutMs);
+        try {
+          const routedBinding = await this.deliverWithRecovery(
+            sessionID,
+            payload,
+            this.deliverLocalActionToWorker
+          );
+          if (routedBinding && canDeliverToWorker(routedBinding)) {
+            return waitPromise;
+          }
+          this.resolveSyntheticLocalActionWaiter(actionID, {
+            status: localActionResultStatuses.failed,
+            result: void 0,
+            errorCode: "local_action_delivery_failed",
+            errorMsg: "worker is not ready for local action delivery"
+          });
+          return waitPromise;
+        } catch (error) {
+          this.resolveSyntheticLocalActionWaiter(actionID, {
+            status: localActionResultStatuses.failed,
+            result: void 0,
+            errorCode: "local_action_delivery_failed",
+            errorMsg: normalizeString32(error?.message || error) || "worker local action delivery failed"
+          });
+          return waitPromise;
+        }
+      }
+      async handleSyntheticSessionControlEvent(event, action) {
+        const params = action?.params && typeof action.params === "object" && !Array.isArray(action.params) ? action.params : {};
+        const sessionControlResult = await this.sessionControlActionHandler.handleLocalAction({
+          action_type: localActionTypes.sessionControl,
+          params: {
+            ...params,
+            session_id: event.session_id
+          }
+        });
+        if (!sessionControlResult?.handled) {
+          return false;
+        }
+        const response = sessionControlResult.response ?? {};
+        const result = response.result ?? {};
+        if (response.status === localActionResultStatuses.ok && normalizeString32(result.domain) === resultDomains.sessionControl) {
+          await this.respond(event, buildSessionControlSuccessNotice(result), {}, {
+            status: "responded"
+          });
+          return true;
+        }
+        const errorCode = normalizeString32(response.errorCode);
+        const errorMsg = normalizeString32(response.errorMsg);
+        if (errorCode === sessionControlErrorCodes.cwdRequired || errorCode === sessionControlErrorCodes.invalidCwd || errorCode === sessionControlErrorCodes.bindingMissing) {
+          await this.respond(
+            event,
+            buildSessionControlOpenCardNotice({
+              summaryText: buildSessionControlCardSummary(errorCode, errorMsg),
+              initialCwd: normalizeString32(params.cwd)
+            }),
+            {},
+            {
+              status: "responded",
+              code: errorCode,
+              msg: errorMsg
+            }
+          );
+          return true;
+        }
+        await this.respond(
           event,
-          fallbackText,
+          buildSessionControlFailureNotice({
+            errorCode,
+            errorMsg
+          }),
+          {},
           {
-            ...replySource ? { reply_source: replySource } : {},
-            biz_card: buildOpenWorkspaceCard({
-              summaryText,
-              detailText,
-              initialCwd
-            })
-          },
-          result
+            status: "responded",
+            code: errorCode,
+            msg: errorMsg
+          }
+        );
+        return true;
+      }
+      async handleSyntheticInteractionReplyEvent(event, action) {
+        const actionResult = await this.runSyntheticWorkerLocalAction(event, action);
+        if (normalizeString32(actionResult?.status) === localActionResultStatuses.ok) {
+          this.complete(event, {
+            status: "responded"
+          });
+          return true;
+        }
+        const errorCode = normalizeString32(actionResult?.errorCode);
+        const errorMsg = normalizeString32(actionResult?.errorMsg);
+        await this.respond(
+          event,
+          buildInteractionReplyFailureNotice({
+            errorCode,
+            errorMsg
+          }),
+          {},
+          {
+            status: "responded",
+            code: errorCode,
+            msg: errorMsg
+          }
         );
+        return true;
+      }
+      async handleInteractionActionEvent(event) {
+        const parsed = parseInboundInteractionAction(event.content);
+        if (!parsed.matched) {
+          return false;
+        }
+        this.trace({
+          stage: "interaction_action_received",
+          event_id: event.event_id,
+          session_id: event.session_id,
+          source: parsed.source,
+          action_type: parsed.action?.action_type,
+          ok: parsed.ok === true
+        });
+        if (!parsed.ok) {
+          if (parsed.errorCode === sessionControlErrorCodes.cwdRequired) {
+            await this.respond(
+              event,
+              buildSessionControlOpenCardNotice({
+                summaryText: buildSessionControlCardSummary(parsed.errorCode, parsed.errorMsg)
+              }),
+              {},
+              {
+                status: "responded",
+                code: parsed.errorCode,
+                msg: parsed.errorMsg
+              }
+            );
+            return true;
+          }
+          await this.respond(
+            event,
+            buildInteractionReplyFailureNotice({
+              errorCode: parsed.errorCode,
+              errorMsg: parsed.errorMsg
+            }),
+            {},
+            {
+              status: "responded",
+              code: parsed.errorCode,
+              msg: parsed.errorMsg
+            }
+          );
+          return true;
+        }
+        if (normalizeString32(parsed.action?.action_type) === localActionTypes.sessionControl) {
+          return this.handleSyntheticSessionControlEvent(event, parsed.action);
+        }
+        if (normalizeString32(parsed.action?.action_type) === localActionTypes.interactionReply) {
+          return this.handleSyntheticInteractionReplyEvent(event, parsed.action);
+        }
+        return false;
       }
       ack(event) {
         this.aibotClient.ackEvent(event.event_id, {
@@ -18177,8 +19197,8 @@ var init_runtime = __esm({
         });
       }
       async shouldResumeClaudeSession(binding) {
-        const claudeSessionID = normalizeString30(binding?.claude_session_id);
-        const cwd = normalizeString30(binding?.cwd);
+        const claudeSessionID = normalizeString32(binding?.claude_session_id);
+        const cwd = normalizeString32(binding?.cwd);
         if (!claudeSessionID || !cwd) {
           return false;
         }
@@ -18198,19 +19218,19 @@ var init_runtime = __esm({
         if (this.authFailureCooldownMs <= 0) {
           return null;
         }
-        const normalizedStatus = normalizeString30(binding?.worker_status);
+        const normalizedStatus = normalizeString32(binding?.worker_status);
         if (normalizedStatus !== "stopped" && normalizedStatus !== "failed") {
           return null;
         }
-        const workerID = normalizeString30(binding?.worker_id);
+        const workerID = normalizeString32(binding?.worker_id);
         if (!workerID) {
           return null;
         }
         const runtime = this.workerProcessManager?.getWorkerRuntime?.(workerID);
-        if (normalizeString30(runtime?.status) !== "stopped") {
+        if (normalizeString32(runtime?.status) !== "stopped") {
           return null;
         }
-        if (normalizeString30(runtime?.exit_signal) !== "auth_login_required") {
+        if (normalizeString32(runtime?.exit_signal) !== "auth_login_required") {
           return null;
         }
         const runtimeStoppedAt = Number(runtime?.stopped_at ?? 0);
@@ -18233,7 +19253,7 @@ var init_runtime = __esm({
         };
       }
       async ensureWorker(binding, { ignoreAuthCooldown = false } = {}) {
-        const sessionID = normalizeString30(binding?.aibot_session_id);
+        const sessionID = normalizeString32(binding?.aibot_session_id);
         if (!sessionID) {
           return null;
         }
@@ -18314,7 +19334,7 @@ var init_runtime = __esm({
             };
           }
           const currentReadyFailed = hasReadyWorkerBridge(current) && normalizeWorkerResponseState(current?.worker_response_state) === "failed";
-          const workerID2 = normalizeString30(binding.worker_id);
+          const workerID2 = normalizeString32(binding.worker_id);
           if (!currentReadyFailed && workerID2) {
             const existingRuntime = this.workerProcessManager?.getWorkerRuntime?.(workerID2);
             const existingPid = Number(existingRuntime?.pid ?? 0);
@@ -18393,13 +19413,13 @@ var init_runtime = __esm({
           if (current && current.worker_status === "ready" && current.worker_control_url && current.worker_control_token) {
             return current;
           }
-          await sleep2(intervalMs);
+          await sleep3(intervalMs);
         }
         return this.bindingRegistry.getByAibotSessionID(aibotSessionID);
       }
       async resolveWorkerLaunchFailure(binding) {
-        const workerID = normalizeString30(binding?.worker_id);
-        const workerStatus = normalizeString30(binding?.worker_status);
+        const workerID = normalizeString32(binding?.worker_id);
+        const workerStatus = normalizeString32(binding?.worker_status);
         if (!workerID || !["starting", "connected"].includes(workerStatus)) {
           return "";
         }
@@ -18433,27 +19453,27 @@ var init_runtime = __esm({
           if (current2.worker_status === "stopped" || current2.worker_status === "failed") {
             return current2;
           }
-          await sleep2(intervalMs);
+          await sleep3(intervalMs);
         }
         const current = this.bindingRegistry.getByAibotSessionID(aibotSessionID);
         const launchFailure = await this.resolveWorkerLaunchFailure(current);
         if (launchFailure) {
           return withWorkerLaunchFailure(current, launchFailure);
         }
-        if (["starting", "connected"].includes(normalizeString30(current?.worker_status))) {
+        if (["starting", "connected"].includes(normalizeString32(current?.worker_status))) {
           return withWorkerLaunchFailure(current, "startup_wait_timeout");
         }
         return current;
       }
       clearWorkerControlProbeFailure(workerID) {
-        const normalizedWorkerID = normalizeString30(workerID);
+        const normalizedWorkerID = normalizeString32(workerID);
         if (!normalizedWorkerID) {
           return;
         }
         this.workerControlProbeFailures.delete(normalizedWorkerID);
       }
       markWorkerControlProbeFailure(workerID, error, extraFields = {}) {
-        const normalizedWorkerID = normalizeString30(workerID);
+        const normalizedWorkerID = normalizeString32(workerID);
         if (!normalizedWorkerID) {
           return 0;
         }
@@ -18492,22 +19512,22 @@ var init_runtime = __esm({
         });
       }
       resolveObservedSessionID(payload = {}) {
-        const explicitSessionID = normalizeString30(payload?.session_id);
+        const explicitSessionID = normalizeString32(payload?.session_id);
         if (explicitSessionID) {
           return explicitSessionID;
         }
-        return normalizeString30(this.messageDeliveryStore.getRememberedSessionID(payload?.event_id));
+        return normalizeString32(this.messageDeliveryStore.getRememberedSessionID(payload?.event_id));
       }
       shouldIgnoreObservedWorker(binding, payload = {}) {
         if (!binding) {
           return false;
         }
-        const observedWorkerID = normalizeString30(payload?.worker_id);
-        if (observedWorkerID && normalizeString30(binding?.worker_id) && observedWorkerID !== normalizeString30(binding.worker_id)) {
+        const observedWorkerID = normalizeString32(payload?.worker_id);
+        if (observedWorkerID && normalizeString32(binding?.worker_id) && observedWorkerID !== normalizeString32(binding.worker_id)) {
           return true;
         }
-        const observedClaudeSessionID = normalizeString30(payload?.claude_session_id);
-        if (observedClaudeSessionID && normalizeString30(binding?.claude_session_id) && observedClaudeSessionID !== normalizeString30(binding.claude_session_id)) {
+        const observedClaudeSessionID = normalizeString32(payload?.claude_session_id);
+        if (observedClaudeSessionID && normalizeString32(binding?.claude_session_id) && observedClaudeSessionID !== normalizeString32(binding.claude_session_id)) {
           return true;
         }
         return false;
@@ -18517,10 +19537,10 @@ var init_runtime = __esm({
           stage,
           event_id: payload?.event_id,
           session_id: this.resolveObservedSessionID(payload),
-          worker_id: normalizeString30(payload?.worker_id),
-          expected_worker_id: normalizeString30(binding?.worker_id),
-          claude_session_id: normalizeString30(payload?.claude_session_id),
-          expected_claude_session_id: normalizeString30(binding?.claude_session_id)
+          worker_id: normalizeString32(payload?.worker_id),
+          expected_worker_id: normalizeString32(binding?.worker_id),
+          claude_session_id: normalizeString32(payload?.claude_session_id),
+          expected_claude_session_id: normalizeString32(binding?.claude_session_id)
         }, "error");
       }
       async recordWorkerReplyObserved(payload, { kind = "text" } = {}) {
@@ -18583,19 +19603,19 @@ var init_runtime = __esm({
           response_state: nextBinding?.worker_response_state,
           response_reason: nextBinding?.worker_response_reason,
           event_id: payload?.event_id,
-          terminal_status: normalizeString30(payload?.status),
-          terminal_code: normalizeString30(payload?.code)
+          terminal_status: normalizeString32(payload?.status),
+          terminal_code: normalizeString32(payload?.code)
         }, classification.state === "failed" ? "error" : "info");
         return nextBinding;
       }
       async recordWorkerHookSignalsObserved(binding, pingPayload) {
-        const sessionID = normalizeString30(binding?.aibot_session_id);
+        const sessionID = normalizeString32(binding?.aibot_session_id);
         if (!sessionID) {
           return binding;
         }
         let nextBinding = binding;
         let lastEventAt = Number(binding?.worker_last_hook_event_at ?? 0);
-        let lastEventID = normalizeString30(binding?.worker_last_hook_event_id);
+        let lastEventID = normalizeString32(binding?.worker_last_hook_event_id);
         for (const event of listHookSignalRecords(pingPayload)) {
           const isNewer = event.event_at > lastEventAt || event.event_at === lastEventAt && event.event_id !== lastEventID;
           if (!isNewer) {
@@ -18625,16 +19645,16 @@ var init_runtime = __esm({
         if (this.workerControlProbeFailureThreshold <= 0) {
           return { ok: true };
         }
-        if (normalizeString30(binding?.worker_status) !== "ready") {
+        if (normalizeString32(binding?.worker_status) !== "ready") {
           return { ok: true };
         }
-        const workerID = normalizeString30(binding?.worker_id);
+        const workerID = normalizeString32(binding?.worker_id);
         if (!workerID) {
           return { ok: true };
         }
         const probeTraceFields = {
-          session_id: normalizeString30(binding?.aibot_session_id),
-          claude_session_id: normalizeString30(binding?.claude_session_id),
+          session_id: normalizeString32(binding?.aibot_session_id),
+          claude_session_id: normalizeString32(binding?.claude_session_id),
           expected_pid: resolveExpectedWorkerPid(binding, runtime)
         };
         let client = null;
@@ -18673,12 +19693,12 @@ var init_runtime = __esm({
               reason: identityHealth.reason,
               expected_pid: normalizeNonNegativeInt(identityHealth.expectedPid, 0),
               reported_pid: normalizeNonNegativeInt(identityHealth.reportedPid, 0),
-              expected_worker_id: normalizeString30(identityHealth.expectedWorkerID),
-              reported_worker_id: normalizeString30(identityHealth.reportedWorkerID),
-              expected_session_id: normalizeString30(identityHealth.expectedSessionID),
-              reported_session_id: normalizeString30(identityHealth.reportedSessionID),
-              expected_claude_session_id: normalizeString30(identityHealth.expectedClaudeSessionID),
-              reported_claude_session_id: normalizeString30(identityHealth.reportedClaudeSessionID),
+              expected_worker_id: normalizeString32(identityHealth.expectedWorkerID),
+              reported_worker_id: normalizeString32(identityHealth.reportedWorkerID),
+              expected_session_id: normalizeString32(identityHealth.expectedSessionID),
+              reported_session_id: normalizeString32(identityHealth.reportedSessionID),
+              expected_claude_session_id: normalizeString32(identityHealth.expectedClaudeSessionID),
+              reported_claude_session_id: normalizeString32(identityHealth.reportedClaudeSessionID),
               ...buildPingActivityTraceFields(pingPayload)
             });
             const failures = this.markWorkerControlProbeFailure(
@@ -18750,6 +19770,13 @@ var init_runtime = __esm({
         }
         return client.deliverRevoke(rawPayload);
       }
+      async deliverLocalActionToWorker(binding, rawPayload) {
+        const client = this.workerControlClientFactory(binding);
+        if (!client?.isConfigured?.()) {
+          throw new Error("worker control client is not configured");
+        }
+        return client.deliverLocalAction(rawPayload);
+      }
       async trackPendingEvent(rawPayload) {
         return this.pendingEventOrchestrator.trackPendingEvent(rawPayload);
       }
@@ -18766,22 +19793,22 @@ var init_runtime = __esm({
         return this.pendingEventOrchestrator.markPendingEventInterrupted(eventID);
       }
       async clearPendingEvent(eventID) {
-        const normalizedEventID = normalizeString30(eventID);
+        const normalizedEventID = normalizeString32(eventID);
         if (normalizedEventID) {
           this.pendingEventWorkerLogCursors.delete(normalizedEventID);
         }
         return this.pendingEventOrchestrator.clearPendingEvent(eventID);
       }
       getPendingEventWorkerLogCursor(eventID) {
-        const normalizedEventID = normalizeString30(eventID);
+        const normalizedEventID = normalizeString32(eventID);
         if (!normalizedEventID) {
           return null;
         }
         return this.pendingEventWorkerLogCursors.get(normalizedEventID) ?? null;
       }
       async recordPendingEventWorkerLogCursor(eventID, workerID) {
-        const normalizedEventID = normalizeString30(eventID);
-        const normalizedWorkerID = normalizeString30(workerID);
+        const normalizedEventID = normalizeString32(eventID);
+        const normalizedWorkerID = normalizeString32(workerID);
         if (!normalizedEventID || !normalizedWorkerID) {
           return null;
         }
@@ -18822,19 +19849,19 @@ var init_runtime = __esm({
         return this.pendingEventOrchestrator.touchPendingEventComposing(eventID);
       }
       async handleWorkerSessionComposing(payload = {}) {
-        const eventID = normalizeString30(payload.ref_event_id);
+        const eventID = normalizeString32(payload.ref_event_id);
         if (!eventID) {
           return null;
         }
-        const workerID = normalizeString30(payload.worker_id);
-        const workerSessionID = normalizeString30(payload.session_id || payload.aibot_session_id);
-        const claudeSessionID = normalizeString30(payload.claude_session_id);
+        const workerID = normalizeString32(payload.worker_id);
+        const workerSessionID = normalizeString32(payload.session_id || payload.aibot_session_id);
+        const claudeSessionID = normalizeString32(payload.claude_session_id);
         const reportedPid = Number(payload.pid ?? 0);
         const record = this.getPendingEvent(eventID);
         if (!record) {
           return null;
         }
-        const deliveryState = normalizeString30(record.delivery_state);
+        const deliveryState = normalizeString32(record.delivery_state);
         if (deliveryState !== "dispatching" && deliveryState !== "delivered") {
           this.trace({
             stage: "pending_event_activity_rejected",
@@ -18845,7 +19872,7 @@ var init_runtime = __esm({
           }, "error");
           return null;
         }
-        const sessionID = normalizeString30(record.sessionID);
+        const sessionID = normalizeString32(record.sessionID);
         if (workerSessionID && workerSessionID !== sessionID) {
           this.trace({
             stage: "pending_event_activity_rejected",
@@ -18866,7 +19893,7 @@ var init_runtime = __esm({
           }, "error");
           return null;
         }
-        const expectedWorkerID = normalizeString30(binding.worker_id);
+        const expectedWorkerID = normalizeString32(binding.worker_id);
         if (!workerID || !expectedWorkerID || workerID !== expectedWorkerID) {
           this.trace({
             stage: "pending_event_activity_rejected",
@@ -18892,7 +19919,7 @@ var init_runtime = __esm({
             return null;
           }
         }
-        const dispatchedWorkerID = normalizeString30(record.last_worker_id);
+        const dispatchedWorkerID = normalizeString32(record.last_worker_id);
         if (dispatchedWorkerID && workerID !== dispatchedWorkerID) {
           this.trace({
             stage: "pending_event_activity_rejected",
@@ -18904,7 +19931,7 @@ var init_runtime = __esm({
           }, "error");
           return null;
         }
-        const expectedClaudeSessionID = normalizeString30(binding.claude_session_id);
+        const expectedClaudeSessionID = normalizeString32(binding.claude_session_id);
         if (!claudeSessionID || !expectedClaudeSessionID || claudeSessionID !== expectedClaudeSessionID) {
           this.trace({
             stage: "pending_event_activity_rejected",
@@ -18941,12 +19968,12 @@ var init_runtime = __esm({
       async flushStalePendingEvents() {
         const bindings = this.bindingRegistry?.listBindings?.() ?? [];
         for (const binding of bindings) {
-          const sessionID = normalizeString30(binding?.aibot_session_id);
+          const sessionID = normalizeString32(binding?.aibot_session_id);
           if (!sessionID) continue;
           if (!canDeliverToWorker(binding)) continue;
           const pendingEvents = this.listPendingEventsForSession(sessionID);
           const hasPending = pendingEvents.some(
-            (r) => normalizeString30(r.delivery_state) === "pending"
+            (r) => normalizeString32(r.delivery_state) === "pending"
           );
           if (!hasPending) continue;
           const queue = this.sessionQueues.ensure(sessionID);
@@ -18966,7 +19993,6 @@ var init_runtime = __esm({
       async failPendingEvent(record, {
         notifyText = true,
         noticeText = buildInterruptedEventNotice(),
-        replySource = "daemon_worker_interrupted",
         resultCode = "worker_interrupted",
         resultMessage = "worker interrupted while processing event"
       } = {}) {
@@ -18983,10 +20009,7 @@ var init_runtime = __esm({
               eventID: record.eventID,
               sessionID: record.sessionID,
               text: noticeText,
-              quotedMessageID: record.msgID,
-              extra: {
-                reply_source: replySource
-              }
+              quotedMessageID: record.msgID
             });
           } catch {
           }
@@ -19009,7 +20032,7 @@ var init_runtime = __esm({
         }, "error");
       }
       async resolveWorkerFailureEventOptions(workerID) {
-        const normalizedWorkerID = normalizeString30(workerID);
+        const normalizedWorkerID = normalizeString32(workerID);
         if (!normalizedWorkerID) {
           return null;
         }
@@ -19027,23 +20050,22 @@ var init_runtime = __esm({
         }
         return {
           noticeText: buildAuthLoginRequiredEventNotice(),
-          replySource: "daemon_worker_auth_login_required",
           resultCode: "claude_auth_login_required",
           resultMessage: "claude authentication expired; run claude auth login"
         };
       }
       resolveWorkerIDForEventResult(payload) {
-        const explicitWorkerID = normalizeString30(payload?.worker_id);
+        const explicitWorkerID = normalizeString32(payload?.worker_id);
         if (explicitWorkerID) {
           return explicitWorkerID;
         }
         const sessionID = this.resolveObservedSessionID(payload);
         const binding = sessionID ? this.bindingRegistry.getByAibotSessionID(sessionID) : null;
-        return normalizeString30(binding?.worker_id);
+        return normalizeString32(binding?.worker_id);
       }
       async resolveWorkerEventResultFailureOptions(payload) {
-        const status = normalizeString30(payload?.status);
-        const code = normalizeString30(payload?.code);
+        const status = normalizeString32(payload?.status);
+        const code = normalizeString32(payload?.code);
         if (status !== "failed" || code !== "claude_result_timeout") {
           return null;
         }
@@ -19051,7 +20073,7 @@ var init_runtime = __esm({
         if (!workerID) {
           return null;
         }
-        const eventID = normalizeString30(payload?.event_id);
+        const eventID = normalizeString32(payload?.event_id);
         const logCursor = this.getPendingEventWorkerLogCursor(eventID);
         const hasExtraUsageLimitPrompt = await this.workerProcessManager?.hasExtraUsageLimitPrompt?.(
           workerID,
@@ -19079,7 +20101,7 @@ var init_runtime = __esm({
         if (!failureOptions?.noticeText) {
           return null;
         }
-        const eventID = normalizeString30(payload?.event_id);
+        const eventID = normalizeString32(payload?.event_id);
         const record = this.getPendingEvent(eventID);
         if (!record?.eventID || !record?.sessionID) {
           return null;
@@ -19089,10 +20111,7 @@ var init_runtime = __esm({
             eventID: record.eventID,
             sessionID: record.sessionID,
             text: failureOptions.noticeText,
-            quotedMessageID: record.msgID,
-            extra: {
-              reply_source: failureOptions.replySource
-            }
+            quotedMessageID: record.msgID
           });
         } catch {
           return null;
@@ -19108,18 +20127,18 @@ var init_runtime = __esm({
         return nextPayload;
       }
       async requeuePendingEventsForWorker(sessionID, workerID) {
-        const normalizedSessionID = normalizeString30(sessionID);
-        const normalizedWorkerID = normalizeString30(workerID);
+        const normalizedSessionID = normalizeString32(sessionID);
+        const normalizedWorkerID = normalizeString32(workerID);
         if (!normalizedSessionID || !normalizedWorkerID) {
           return 0;
         }
         let requeuedCount = 0;
         const requeuedEventIDs = [];
         for (const record of this.listPendingEventsForSession(normalizedSessionID)) {
-          if (normalizeString30(record.last_worker_id) !== normalizedWorkerID) {
+          if (normalizeString32(record.last_worker_id) !== normalizedWorkerID) {
             continue;
           }
-          const deliveryState = normalizeString30(record.delivery_state);
+          const deliveryState = normalizeString32(record.delivery_state);
           if (!["dispatching", "delivered", "interrupted"].includes(deliveryState)) {
             continue;
           }
@@ -19142,8 +20161,8 @@ var init_runtime = __esm({
         return requeuedCount;
       }
       async tryRecoverResumeAuthFailure(previousBinding, nextBinding) {
-        const sessionID = normalizeString30(nextBinding?.aibot_session_id || previousBinding?.aibot_session_id);
-        const workerID = normalizeString30(previousBinding?.worker_id || nextBinding?.worker_id);
+        const sessionID = normalizeString32(nextBinding?.aibot_session_id || previousBinding?.aibot_session_id);
+        const workerID = normalizeString32(previousBinding?.worker_id || nextBinding?.worker_id);
         if (!sessionID || !workerID) {
           return false;
         }
@@ -19195,7 +20214,7 @@ var init_runtime = __esm({
             return false;
           }
           const fallbackBinding = await this.rotateClaudeSession(latestBinding);
-          const nextWorkerID = normalizeString30(nextBinding?.worker_id) || workerID || randomUUID8();
+          const nextWorkerID = normalizeString32(nextBinding?.worker_id) || workerID || randomUUID8();
           await this.bindingRegistry.markWorkerStarting(sessionID, {
             workerID: nextWorkerID,
             updatedAt: Date.now(),
@@ -19232,7 +20251,7 @@ var init_runtime = __esm({
       async reconcileWorkerProcesses() {
         const bindings = this.bindingRegistry?.listBindings?.() ?? [];
         for (const binding of bindings) {
-          const sessionID = normalizeString30(binding?.aibot_session_id);
+          const sessionID = normalizeString32(binding?.aibot_session_id);
           if (!sessionID) continue;
           const queue = this.sessionQueues.ensure(sessionID);
           queue.run(() => this.reconcileWorkerProcess(binding)).catch((err) => {
@@ -19241,11 +20260,11 @@ var init_runtime = __esm({
         }
       }
       async reconcileWorkerProcess(binding) {
-        const sessionID = normalizeString30(binding?.aibot_session_id);
+        const sessionID = normalizeString32(binding?.aibot_session_id);
         if (!sessionID) return false;
         const freshBinding = this.bindingRegistry?.getByAibotSessionID?.(sessionID) ?? binding;
-        const workerID = normalizeString30(freshBinding?.worker_id);
-        const workerStatus = normalizeString30(freshBinding?.worker_status);
+        const workerID = normalizeString32(freshBinding?.worker_id);
+        const workerStatus = normalizeString32(freshBinding?.worker_status);
         if (!workerID || !["starting", "connected", "ready"].includes(workerStatus)) {
           return false;
         }
@@ -19297,7 +20316,7 @@ var init_runtime = __esm({
           return true;
         }
         const previousBinding = this.bindingRegistry.getByAibotSessionID(sessionID) ?? binding;
-        if (normalizeString30(previousBinding?.worker_id) !== workerID || ["stopped", "failed"].includes(normalizeString30(previousBinding?.worker_status))) {
+        if (normalizeString32(previousBinding?.worker_id) !== workerID || ["stopped", "failed"].includes(normalizeString32(previousBinding?.worker_status))) {
           return false;
         }
         const runtime = this.workerProcessManager?.getWorkerRuntime?.(workerID);
@@ -19306,7 +20325,7 @@ var init_runtime = __esm({
         }
         const pid = resolveExpectedWorkerPid(previousBinding, runtime);
         if (Number.isFinite(pid) && pid > 0 && !this.isProcessRunning(pid)) {
-          const exitSignal = normalizeString30(runtime.exit_signal) || "worker_exited";
+          const exitSignal = normalizeString32(runtime.exit_signal) || "worker_exited";
           this.workerProcessManager?.markWorkerRuntimeStopped?.(workerID, {
             exitCode: Number(runtime.exit_code ?? 0),
             exitSignal
@@ -19350,7 +20369,7 @@ var init_runtime = __esm({
           }, "error");
           await this.bindingRegistry.markWorkerResponseFailed(sessionID, {
             observedAt: Date.now(),
-            reason: normalizeString30(probe.reason) || "worker_control_unreachable",
+            reason: normalizeString32(probe.reason) || "worker_control_unreachable",
             failureCode: "worker_control_unreachable"
           });
           const nextBinding = await this.bindingRegistry.markWorkerStopped(sessionID, {
@@ -19421,7 +20440,7 @@ var init_runtime = __esm({
        * handling.
        */
       async handleWorkerStatusUpdateQueued(previousBinding, nextBinding) {
-        const sessionID = normalizeString30(
+        const sessionID = normalizeString32(
           nextBinding?.aibot_session_id || previousBinding?.aibot_session_id
         );
         if (!sessionID) {
@@ -19433,8 +20452,8 @@ var init_runtime = __esm({
         );
       }
       async handleWorkerStatusUpdate(previousBinding, nextBinding) {
-        const sessionID = normalizeString30(nextBinding?.aibot_session_id || previousBinding?.aibot_session_id);
-        const nextStatus = normalizeString30(nextBinding?.worker_status);
+        const sessionID = normalizeString32(nextBinding?.aibot_session_id || previousBinding?.aibot_session_id);
+        const nextStatus = normalizeString32(nextBinding?.worker_status);
         if (!sessionID || !nextStatus) {
           return;
         }
@@ -19446,8 +20465,8 @@ var init_runtime = __esm({
           claude_session_id: nextBinding?.claude_session_id || previousBinding?.claude_session_id,
           status: nextStatus
         });
-        const previousWorkerID = normalizeString30(previousBinding?.worker_id);
-        const nextWorkerID = normalizeString30(nextBinding?.worker_id);
+        const previousWorkerID = normalizeString32(previousBinding?.worker_id);
+        const nextWorkerID = normalizeString32(nextBinding?.worker_id);
         if (nextStatus === "ready" || nextStatus === "connected") {
           if (nextWorkerID) {
             this.clearWorkerControlProbeFailure(nextWorkerID);
@@ -19499,11 +20518,11 @@ var init_runtime = __esm({
           }, "error");
         }
         for (const record of this.listPendingEventsForSession(sessionID)) {
-          if (previousWorkerID && normalizeString30(record.last_worker_id) !== previousWorkerID) {
-            if (normalizeString30(record.last_worker_id)) {
+          if (previousWorkerID && normalizeString32(record.last_worker_id) !== previousWorkerID) {
+            if (normalizeString32(record.last_worker_id)) {
               continue;
             }
-            if (!["pending", "dispatching", "interrupted"].includes(normalizeString30(record.delivery_state))) {
+            if (!["pending", "dispatching", "interrupted"].includes(normalizeString32(record.delivery_state))) {
               continue;
             }
           }
@@ -19513,7 +20532,7 @@ var init_runtime = __esm({
       }
       async handleEventCompleted(eventID) {
         const record = this.getPendingEvent(eventID);
-        const sessionID = normalizeString30(record?.sessionID || this.messageDeliveryStore.getRememberedSessionID(eventID));
+        const sessionID = normalizeString32(record?.sessionID || this.messageDeliveryStore.getRememberedSessionID(eventID));
         await this.clearPendingEvent(eventID);
         this.trace({
           stage: "event_completed",
@@ -19581,7 +20600,6 @@ var init_runtime = __esm({
             const currentRecord = this.getPendingEvent(record.eventID) ?? record;
             await this.failPendingEvent(currentRecord, {
               notifyText: false,
-              replySource: "daemon_recover_failed",
               resultCode: "worker_recover_failed",
               resultMessage: message
             });
@@ -19658,7 +20676,7 @@ var init_runtime = __esm({
           });
           return null;
         }
-        if (currentRecord && ["dispatching", "delivered"].includes(normalizeString30(currentRecord.delivery_state)) && normalizeString30(currentRecord.last_worker_id) === normalizeString30(readyBinding?.worker_id)) {
+        if (currentRecord && ["dispatching", "delivered"].includes(normalizeString32(currentRecord.delivery_state)) && normalizeString32(currentRecord.last_worker_id) === normalizeString32(readyBinding?.worker_id)) {
           this.trace({
             stage: "event_dispatch_skipped",
             event_id: rawPayload?.event_id,
@@ -19710,7 +20728,7 @@ var init_runtime = __esm({
           } else {
             readyBinding = this.bindingRegistry.getByAibotSessionID(aibotSessionID) ?? readyBinding;
           }
-          if (readyBinding?.worker_launch_failure === "resume_session_missing" && normalizeString30(binding.claude_session_id)) {
+          if (readyBinding?.worker_launch_failure === "resume_session_missing" && normalizeString32(binding.claude_session_id)) {
             this.trace({
               stage: "worker_resume_missing_recovering",
               session_id: binding.aibot_session_id,
@@ -19764,9 +20782,6 @@ var init_runtime = __esm({
         }
         return readyBinding ?? binding;
       }
-      async handleControlCommand(event, parsed) {
-        return this.controlCommandHandler.handleControlCommand(event, parsed);
-      }
       /**
        * Queue-aware wrapper: routes handleEvent through the per-session
        * serial queue to prevent races with reconcile and worker status updates.
@@ -19794,10 +20809,18 @@ var init_runtime = __esm({
           sender_id: event.sender_id
         });
         this.ack(event);
+        if (isRecordOnlyMirror(event)) {
+          this.trace({
+            stage: "event_mirrored_record_only",
+            event_id: event.event_id,
+            session_id: event.session_id,
+            msg_id: event.msg_id,
+            sender_id: event.sender_id
+          });
+          return;
+        }
         try {
-          const parsed = parseControlCommand(event.content);
-          if (parsed.matched) {
-            await this.handleControlCommand(event, parsed);
+          if (await this.handleInteractionActionEvent(event)) {
             return;
           }
           const binding = this.bindingRegistry.getByAibotSessionID(event.session_id);
@@ -19807,9 +20830,10 @@ var init_runtime = __esm({
               event_id: event.event_id,
               session_id: event.session_id
             }, "error");
-            await this.respondWithOpenWorkspaceCard(event, {
-              ...buildMissingBindingCardOptions(),
-              replySource: "daemon_route_missing"
+            await this.respond(event, buildBindingMissingEventNotice(), {}, {
+              status: "responded",
+              code: sessionControlErrorCodes.bindingMissing,
+              msg: "session binding is required before event delivery"
             });
             return;
           }
@@ -19827,9 +20851,7 @@ var init_runtime = __esm({
             await this.respond(
               event,
               buildAuthLoginRequiredEventNotice(),
-              {
-                reply_source: "daemon_worker_auth_login_required"
-              },
+              {},
               {
                 status: "failed",
                 code: "claude_auth_login_required",
@@ -19881,7 +20903,7 @@ var init_runtime = __esm({
           }
           const readyBinding = routedBinding ?? this.bindingRegistry.getByAibotSessionID(binding.aibot_session_id) ?? binding;
           if (!readyBinding.worker_control_url || !readyBinding.worker_control_token) {
-            const launchFailure = normalizeString30(readyBinding?.worker_launch_failure);
+            const launchFailure = normalizeString32(readyBinding?.worker_launch_failure);
             this.trace({
               stage: "event_worker_not_ready",
               event_id: event.event_id,
@@ -19891,7 +20913,7 @@ var init_runtime = __esm({
               worker_launch_failure: launchFailure
             }, "error");
             if (pending && (launchFailure === "startup_mcp_server_failed" || launchFailure === "startup_wait_timeout")) {
-              const workerID = normalizeString30(readyBinding?.worker_id);
+              const workerID = normalizeString32(readyBinding?.worker_id);
               if (workerID) {
                 try {
                   await this.workerProcessManager?.stopWorker?.(workerID);
@@ -19917,7 +20939,6 @@ var init_runtime = __esm({
               await this.markPendingEventInterrupted(pending.eventID);
               await this.failPendingEvent(pending, {
                 noticeText: buildWorkerStartupFailedNotice(),
-                replySource: "daemon_worker_startup_failed",
                 resultCode: launchFailure === "startup_mcp_server_failed" ? "claude_startup_mcp_failed" : "claude_startup_timeout",
                 resultMessage: launchFailure === "startup_mcp_server_failed" ? "claude worker startup failed: mcp server not ready" : "claude worker startup timed out"
               });
@@ -19933,9 +20954,7 @@ var init_runtime = __esm({
             error: message
           }, "error");
           try {
-            await this.respond(event, `\u5904\u7406\u5931\u8D25\uFF1A${message}`, {
-              reply_source: "daemon_event_error"
-            }, {
+            await this.respond(event, `\u5904\u7406\u5931\u8D25\uFF1A${message}`, {}, {
               status: "failed",
               code: "daemon_event_handle_failed",
               msg: message
@@ -19950,7 +20969,7 @@ var init_runtime = __esm({
         }
       }
       async handleStopEvent(rawPayload) {
-        const eventID = normalizeString30(rawPayload?.event_id);
+        const eventID = normalizeString32(rawPayload?.event_id);
         if (!eventID) {
           return;
         }
@@ -19960,7 +20979,7 @@ var init_runtime = __esm({
           session_id: rawPayload?.session_id,
           stop_id: rawPayload?.stop_id
         });
-        const sessionID = normalizeString30(rawPayload?.session_id) || this.messageDeliveryStore.getRememberedSessionID(eventID);
+        const sessionID = normalizeString32(rawPayload?.session_id) || this.messageDeliveryStore.getRememberedSessionID(eventID);
         if (!sessionID) {
           this.trace({
             stage: "stop_route_missing",
@@ -19978,12 +20997,12 @@ var init_runtime = __esm({
         });
       }
       async handleRevokeEvent(rawPayload) {
-        const eventID = normalizeString30(rawPayload?.event_id);
+        const eventID = normalizeString32(rawPayload?.event_id);
         if (!eventID) {
           return;
         }
         const receivedAt = Date.now();
-        const resolvedSessionID = normalizeString30(rawPayload?.session_id) || this.messageDeliveryStore.getRememberedSessionID(eventID);
+        const resolvedSessionID = normalizeString32(rawPayload?.session_id) || this.messageDeliveryStore.getRememberedSessionID(eventID);
         this.aibotClient.ackEvent(eventID, {
           sessionID: resolvedSessionID,
           msgID: rawPayload?.msg_id,
@@ -20028,12 +21047,80 @@ var init_runtime = __esm({
           msg_id: rawPayload?.msg_id
         });
       }
+      async handleLocalAction(rawPayload) {
+        const action = normalizeLocalActionPayload(rawPayload);
+        if (!action.action_id) {
+          this.trace({
+            stage: "local_action_invalid",
+            reason: "missing_action_id",
+            action_type: action.action_type
+          }, "error");
+          return;
+        }
+        const sessionControlResult = await this.sessionControlActionHandler.handleLocalAction(action);
+        if (sessionControlResult?.handled) {
+          await this.aibotClient.sendLocalActionResult({
+            actionID: action.action_id,
+            status: sessionControlResult.response?.status,
+            result: sessionControlResult.response?.result,
+            errorCode: sessionControlResult.response?.errorCode,
+            errorMsg: sessionControlResult.response?.errorMsg,
+            timeoutMs: action.timeout_ms
+          });
+          return;
+        }
+        const sessionID = normalizeString32(action.params?.session_id) || this.messageDeliveryStore.getRememberedSessionID(action.event_id);
+        if (!sessionID) {
+          this.trace({
+            stage: "local_action_route_missing",
+            action_id: action.action_id,
+            action_type: action.action_type,
+            event_id: action.event_id
+          }, "error");
+          await this.aibotClient.sendLocalActionResult({
+            actionID: action.action_id,
+            status: localActionResultStatuses.failed,
+            errorCode: localActionErrorCodes.localActionRouteMissing,
+            errorMsg: "local action session_id is required",
+            timeoutMs: action.timeout_ms
+          });
+          return;
+        }
+        const routedBinding = await this.deliverWithRecovery(
+          sessionID,
+          action,
+          this.deliverLocalActionToWorker
+        );
+        if (routedBinding && canDeliverToWorker(routedBinding)) {
+          this.trace({
+            stage: "local_action_forwarded",
+            action_id: action.action_id,
+            action_type: action.action_type,
+            session_id: sessionID,
+            worker_id: routedBinding?.worker_id
+          });
+          return;
+        }
+        this.trace({
+          stage: "local_action_delivery_failed",
+          action_id: action.action_id,
+          action_type: action.action_type,
+          session_id: sessionID
+        }, "error");
+        await this.aibotClient.sendLocalActionResult({
+          actionID: action.action_id,
+          status: "failed",
+          errorCode: "local_action_delivery_failed",
+          errorMsg: "worker is not ready for local action delivery",
+          timeoutMs: action.timeout_ms
+        });
+      }
     };
   }
 });
 
 // server/session-activity-dispatcher.js
-function normalizeString31(value) {
+function normalizeString33(value) {
   return String(value ?? "").trim();
 }
 function buildSessionActivityDispatchKey({
@@ -20042,10 +21129,10 @@ function buildSessionActivityDispatchKey({
   refEventID = "",
   refMsgID = ""
 } = {}) {
-  const normalizedSessionID = normalizeString31(sessionID);
-  const normalizedKind = normalizeString31(kind) || "composing";
-  const normalizedRefEventID = normalizeString31(refEventID);
-  const normalizedRefMsgID = normalizeString31(refMsgID);
+  const normalizedSessionID = normalizeString33(sessionID);
+  const normalizedKind = normalizeString33(kind) || "composing";
+  const normalizedRefEventID = normalizeString33(refEventID);
+  const normalizedRefMsgID = normalizeString33(refMsgID);
   if (normalizedRefEventID) {
     return `event:${normalizedRefEventID}`;
   }
@@ -20082,19 +21169,19 @@ var init_session_activity_dispatcher = __esm({
 
 // server/daemon/session-log-writer.js
 import { appendFile as appendFile2, mkdir as mkdir11 } from "node:fs/promises";
-import path23 from "node:path";
-function normalizeString32(value) {
+import path24 from "node:path";
+function normalizeString34(value) {
   return String(value ?? "").trim();
 }
 function normalizeSessionID(value) {
-  return normalizeString32(value).replace(/[^a-zA-Z0-9._-]+/g, "-");
+  return normalizeString34(value).replace(/[^a-zA-Z0-9._-]+/g, "-");
 }
 function resolveSessionID(fields = {}) {
-  const explicitSessionID = normalizeString32(fields.session_id);
+  const explicitSessionID = normalizeString34(fields.session_id);
   if (explicitSessionID) {
     return explicitSessionID;
   }
-  return normalizeString32(fields.aibot_session_id);
+  return normalizeString34(fields.aibot_session_id);
 }
 var SessionLogWriter;
 var init_session_log_writer = __esm({
@@ -20109,7 +21196,7 @@ var init_session_log_writer = __esm({
         appendFileImpl = appendFile2
       } = {}) {
         this.env = env;
-        this.logFileName = normalizeString32(logFileName) || "daemon-session.log";
+        this.logFileName = normalizeString34(logFileName) || "daemon-session.log";
         this.mkdirImpl = typeof mkdirImpl === "function" ? mkdirImpl : mkdir11;
         this.appendFileImpl = typeof appendFileImpl === "function" ? appendFileImpl : appendFile2;
         this.writeQueues = /* @__PURE__ */ new Map();
@@ -20119,7 +21206,7 @@ var init_session_log_writer = __esm({
         if (!normalizedSessionID) {
           return "";
         }
-        return path23.join(resolveWorkerLogsDir(normalizedSessionID, this.env), this.logFileName);
+        return path24.join(resolveWorkerLogsDir(normalizedSessionID, this.env), this.logFileName);
       }
       enqueueWrite(aibotSessionID, task) {
         const normalizedSessionID = normalizeSessionID(aibotSessionID);
@@ -20143,7 +21230,7 @@ var init_session_log_writer = __esm({
           return false;
         }
         const line = formatTraceLine({
-          level: normalizeString32(level) || "info",
+          level: normalizeString34(level) || "info",
           ...fields
         });
         return this.enqueueWrite(sessionID, async () => {
@@ -20151,7 +21238,7 @@ var init_session_log_writer = __esm({
           if (!logPath) {
             return false;
           }
-          await this.mkdirImpl(path23.dirname(logPath), { recursive: true });
+          await this.mkdirImpl(path24.dirname(logPath), { recursive: true });
           await this.appendFileImpl(logPath, `${line}
 `, "utf8");
           return true;
@@ -20171,7 +21258,7 @@ __export(main_exports, {
   shouldIgnoreWorkerStatusUpdate: () => shouldIgnoreWorkerStatusUpdate,
   shouldNotifyWorkerReady: () => shouldNotifyWorkerReady
 });
-import process14 from "node:process";
+import process15 from "node:process";
 function usage() {
   return `\u7528\u6CD5:
   grix-claude daemon [options]
@@ -20190,7 +21277,7 @@ function usage() {
 `;
 }
 function print(message) {
-  process14.stdout.write(`${message}
+  process15.stdout.write(`${message}
 `);
 }
 function parseArgs(argv) {
@@ -20216,7 +21303,7 @@ function readOption(argv, name) {
   }
   return value;
 }
-function normalizeString33(value) {
+function normalizeString35(value) {
   return String(value ?? "").trim();
 }
 function normalizePid3(value) {
@@ -20239,13 +21326,13 @@ function shouldIgnoreWorkerStatusUpdate(previousBinding, payload) {
   if (!previousBinding) {
     return false;
   }
-  const expectedWorkerID = normalizeString33(previousBinding.worker_id);
-  const incomingWorkerID = normalizeString33(payload?.worker_id);
+  const expectedWorkerID = normalizeString35(previousBinding.worker_id);
+  const incomingWorkerID = normalizeString35(payload?.worker_id);
   if (expectedWorkerID && incomingWorkerID && expectedWorkerID !== incomingWorkerID) {
     return true;
   }
-  const expectedClaudeSessionID = normalizeString33(previousBinding.claude_session_id);
-  const incomingClaudeSessionID = normalizeString33(payload?.claude_session_id);
+  const expectedClaudeSessionID = normalizeString35(previousBinding.claude_session_id);
+  const incomingClaudeSessionID = normalizeString35(payload?.claude_session_id);
   if (expectedClaudeSessionID && incomingClaudeSessionID && expectedClaudeSessionID !== incomingClaudeSessionID) {
     return true;
   }
@@ -20260,13 +21347,10 @@ async function notifyWorkerReady(aibotClient, binding) {
   }
   return aibotClient.sendText({
     sessionID: binding.aibot_session_id,
-    text: buildWorkerReadyNoticeText(binding),
-    extra: {
-      reply_source: "daemon_worker_ready"
-    }
+    text: buildWorkerReadyNoticeText(binding)
   });
 }
-async function run(argv = [], env = process14.env) {
+async function run(argv = [], env = process15.env) {
   const options = parseArgs(argv);
   if (options.help) {
     print(usage());
@@ -20514,6 +21598,25 @@ async function run(argv = [], env = process14.env) {
         refEventID: payload.ref_event_id
       });
       return { ok: true };
+    },
+    onAgentInvoke: async (payload) => aibotClient.sendAgentInvoke({
+      invokeID: payload?.invoke_id,
+      action: payload?.action,
+      params: payload?.params,
+      timeoutMs: payload?.timeout_ms
+    }),
+    onLocalActionResult: async (payload) => {
+      const syntheticResult = await runtime?.observeWorkerLocalActionResult?.(payload);
+      if (syntheticResult?.handled) {
+        return { ok: true };
+      }
+      return aibotClient.sendLocalActionResult({
+        actionID: payload?.action_id,
+        status: payload?.status,
+        result: payload?.result,
+        errorCode: payload?.error_code,
+        errorMsg: payload?.error_msg
+      });
     }
   });
   try {
@@ -20538,6 +21641,9 @@ async function run(argv = [], env = process14.env) {
     aibotClient.onEventRevoke = async (payload) => {
       await runtime.handleRevokeEvent(payload);
     };
+    aibotClient.onLocalAction = async (payload) => {
+      await runtime.handleLocalAction(payload);
+    };
     print("grix-claude daemon \u5DF2\u542F\u52A8\u3002");
     print(`\u6570\u636E\u76EE\u5F55: ${dataDir}`);
     print(`Bridge: ${bridgeServer.getURL()}`);
@@ -20577,15 +21683,15 @@ async function run(argv = [], env = process14.env) {
     }
     await new Promise((resolve) => {
       const stop = async () => {
-        process14.off("SIGINT", stop);
-        process14.off("SIGTERM", stop);
+        process15.off("SIGINT", stop);
+        process15.off("SIGTERM", stop);
         await processState.markStopping("signal");
         await aibotClient.stop();
         await bridgeServer.stop();
         resolve();
       };
-      process14.once("SIGINT", stop);
-      process14.once("SIGTERM", stop);
+      process15.once("SIGINT", stop);
+      process15.once("SIGTERM", stop);
     });
     await processState.release({
       exitCode: 0,
@@ -20597,8 +21703,8 @@ async function run(argv = [], env = process14.env) {
     throw error;
   }
 }
-async function main(argv = process14.argv.slice(2), env = process14.env) {
-  process14.exitCode = await run(argv, env);
+async function main(argv = process15.argv.slice(2), env = process15.env) {
+  process15.exitCode = await run(argv, env);
 }
 var workerReadySettleDelayMs;
 var init_main2 = __esm({
@@ -20627,7 +21733,7 @@ __export(main_exports2, {
   main: () => main2,
   run: () => run2
 });
-import process15 from "node:process";
+import process16 from "node:process";
 function usage2() {
   return `\u7528\u6CD5:
   grix-claude worker
@@ -20637,7 +21743,7 @@ function usage2() {
 `;
 }
 function print2(message) {
-  process15.stdout.write(`${message}
+  process16.stdout.write(`${message}
 `);
 }
 async function run2(argv = []) {
@@ -20648,8 +21754,8 @@ async function run2(argv = []) {
   print2("\u4E0D\u8981\u624B\u52A8\u8FD0\u884C worker\u3002Claude \u4F1A\u8BDD\u4F1A\u5728 daemon \u8C03\u5EA6\u4E0B\u81EA\u52A8\u52A0\u8F7D\u5B83\u3002");
   return 1;
 }
-async function main2(argv = process15.argv.slice(2)) {
-  process15.exitCode = await run2(argv);
+async function main2(argv = process16.argv.slice(2)) {
+  process16.exitCode = await run2(argv);
 }
 var init_main3 = __esm({
   "server/worker/main.js"() {
@@ -20660,7 +21766,7 @@ var init_main3 = __esm({
 init_config();
 init_config_store();
 init_daemon_paths();
-import process16 from "node:process";
+import process17 from "node:process";
 
 // server/service/service-manager.js
 init_config();
@@ -21263,7 +22369,7 @@ var ServiceManager = class {
     minUpdatedAt = 0,
     timeoutMs = 5e3
   } = {}) {
-    const { setTimeout: sleep3 } = await import("node:timers/promises");
+    const { setTimeout: sleep4 } = await import("node:timers/promises");
     const start = this.now();
     let lastState = null;
     while (this.now() - start < timeoutMs) {
@@ -21273,7 +22379,7 @@ var ServiceManager = class {
       if (state.running && state.pid && restarted) {
         return state;
       }
-      await sleep3(100);
+      await sleep4(100);
     }
     throw new Error(
       `daemon start timeout (${timeoutMs}ms), state=${lastState?.state || "unknown"}, pid=${Number(lastState?.pid ?? 0)}`
@@ -21502,11 +22608,11 @@ function parseArgs2(argv) {
   return options;
 }
 function print3(message) {
-  process16.stdout.write(`${message}
+  process17.stdout.write(`${message}
 `);
 }
 function printError(message) {
-  process16.stderr.write(`${message}
+  process17.stderr.write(`${message}
 `);
 }
 function shellQuoteForDisplay(value) {
@@ -21545,10 +22651,10 @@ function formatRunningCommand(argv) {
   return command.map((item) => shellQuoteForDisplay(item)).join(" ");
 }
 function formatRuntimeEntryCommand(argv) {
-  const command = [process16.execPath, resolvePackageBinPath(), ...redactSensitiveArgs(argv)];
+  const command = [process17.execPath, resolvePackageBinPath(), ...redactSensitiveArgs(argv)];
   return command.map((item) => shellQuoteForDisplay(item)).join(" ");
 }
-function createServiceManager(env = process16.env) {
+function createServiceManager(env = process17.env) {
   return new ServiceManager({ env });
 }
 function buildRuntimeEnv(options, env) {
@@ -21566,7 +22672,7 @@ function buildDaemonStatus(configStore) {
     configPath: configStore.filePath
   };
 }
-async function prepareDaemonConfig(options, env = process16.env, { persistResolvedConfig = false } = {}) {
+async function prepareDaemonConfig(options, env = process17.env, { persistResolvedConfig = false } = {}) {
   const runtimeEnv = buildRuntimeEnv(options, env);
   const configStore = new ConfigStore(resolveDaemonConfigPath(runtimeEnv), {
     env: runtimeEnv
@@ -21591,7 +22697,7 @@ async function prepareDaemonConfig(options, env = process16.env, { persistResolv
     ...buildDaemonStatus(configStore)
   };
 }
-async function runDefault(argv, env = process16.env) {
+async function runDefault(argv, env = process17.env) {
   const options = parseArgs2(argv);
   if (options.help) {
     print3(usage3());
@@ -21705,7 +22811,7 @@ async function runSubcommand(name, argv, env, deps = {}) {
   }
   throw new Error(`\u672A\u77E5\u5B50\u547D\u4EE4: ${name}`);
 }
-async function run3(argv, env = process16.env, deps = {}) {
+async function run3(argv, env = process17.env, deps = {}) {
   const [first = ""] = argv;
   if ([
     "daemon",
@@ -21721,17 +22827,17 @@ async function run3(argv, env = process16.env, deps = {}) {
   }
   return runDefault(argv, env);
 }
-async function main3(argv = process16.argv.slice(2), env = process16.env) {
+async function main3(argv = process17.argv.slice(2), env = process17.env) {
   try {
     print3(`\u8FD0\u884C\u547D\u4EE4: ${formatRunningCommand(argv)}`);
     print3(`\u5B9E\u9645\u5165\u53E3: ${formatRuntimeEntryCommand(argv)}`);
     const exitCode = await run3(argv, env);
-    process16.exitCode = exitCode;
+    process17.exitCode = exitCode;
   } catch (error) {
     printError(error instanceof Error ? error.message : String(error));
     printError("");
     printError(usage3());
-    process16.exitCode = 1;
+    process17.exitCode = 1;
   }
 }