larkway 0.3.33 → 0.3.34

package/dist/cli/index.js

@@ -43,6 +43,89 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/config/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  LEGACY_BOT_ID: () => LEGACY_BOT_ID,
+  larkwayHome: () => larkwayHome,
+  resolveAgentSessionPath: () => resolveAgentSessionPath,
+  resolveAgentWorkspacePath: () => resolveAgentWorkspacePath,
+  resolveAgentWorkspacePathFromHome: () => resolveAgentWorkspacePathFromHome,
+  resolveAgentWorkspaceReposDir: () => resolveAgentWorkspaceReposDir,
+  resolveAgentWorkspaceSessionsDir: () => resolveAgentWorkspaceSessionsDir,
+  resolveCandidateAlertsPath: () => resolveCandidateAlertsPath,
+  resolveLarkwayDir: () => resolveLarkwayDir,
+  resolveLogsDir: () => resolveLogsDir,
+  resolveSessionsPath: () => resolveSessionsPath,
+  resolveTaskHandlesPath: () => resolveTaskHandlesPath,
+  resolveTaskTeamRegistryPath: () => resolveTaskTeamRegistryPath,
+  resolveWorktreePath: () => resolveWorktreePath,
+  resolveWorktreesDir: () => resolveWorktreesDir
+});
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+function larkwayHome() {
+  const env = process.env.LARKWAY_HOME;
+  if (env && env.trim() !== "") return resolve(env);
+  return join(homedir(), ".larkway");
+}
+function resolveLarkwayDir(botId) {
+  if (botId === void 0 || botId === LEGACY_BOT_ID) {
+    return larkwayHome();
+  }
+  return join(larkwayHome(), botId);
+}
+function resolveSessionsPath(botId) {
+  return join(resolveLarkwayDir(botId), "sessions.json");
+}
+function resolveWorktreePath(botId, threadId) {
+  return join(resolveLarkwayDir(botId), "worktrees", threadId);
+}
+function resolveWorktreesDir(botId) {
+  return join(resolveLarkwayDir(botId), "worktrees");
+}
+function resolveLogsDir(botId) {
+  return join(resolveLarkwayDir(botId), "logs");
+}
+function resolveTaskHandlesPath(botId) {
+  return join(resolveLarkwayDir(botId), "task-handles.json");
+}
+function resolveTaskTeamRegistryPath() {
+  return join(larkwayHome(), "task-team.json");
+}
+function resolveCandidateAlertsPath(tasklistGuid) {
+  return join(larkwayHome(), `candidate-alerts-${tasklistGuid}.json`);
+}
+function assertSafePathSegment(label, value) {
+  if (!/^[A-Za-z0-9_-]+$/.test(value)) {
+    throw new Error(`${label} must be a safe path segment`);
+  }
+}
+function resolveAgentWorkspacePathFromHome(home, agentId) {
+  assertSafePathSegment("agentId", agentId);
+  return join(home, "agents", agentId, "workspace");
+}
+function resolveAgentWorkspacePath(agentId) {
+  return resolveAgentWorkspacePathFromHome(larkwayHome(), agentId);
+}
+function resolveAgentWorkspaceSessionsDir(agentId) {
+  return join(resolveAgentWorkspacePath(agentId), "sessions");
+}
+function resolveAgentSessionPath(agentId, threadId) {
+  assertSafePathSegment("threadId", threadId);
+  return join(resolveAgentWorkspaceSessionsDir(agentId), threadId);
+}
+function resolveAgentWorkspaceReposDir(agentId) {
+  return join(resolveAgentWorkspacePath(agentId), "repos");
+}
+var LEGACY_BOT_ID;
+var init_paths = __esm({
+  "src/config/paths.ts"() {
+    "use strict";
+    LEGACY_BOT_ID = "v1-default";
+  }
+});
+
 // node_modules/.pnpm/dotenv@16.6.1/node_modules/dotenv/package.json
 var require_package = __commonJS({
   "node_modules/.pnpm/dotenv@16.6.1/node_modules/dotenv/package.json"(exports, module) {
@@ -10740,6 +10823,769 @@ var require_proxy_from_env = __commonJS({
   }
 });
 
+// node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js
+var require_ms = __commonJS({
+  "node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js"(exports, module) {
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type2 = typeof val;
+      if (type2 === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type2 === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str2) {
+      str2 = String(str2);
+      if (str2.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str2
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type2 = (match[2] || "ms").toLowerCase();
+      switch (type2) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural(ms, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js"(exports, module) {
+    function setup(env) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce2;
+      createDebug.disable = disable;
+      createDebug.enable = enable;
+      createDebug.enabled = enabled;
+      createDebug.humanize = require_ms();
+      createDebug.destroy = destroy;
+      Object.keys(env).forEach((key) => {
+        createDebug[key] = env[key];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
+        }
+        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+      }
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug(...args) {
+          if (!debug.enabled) {
+            return;
+          }
+          const self2 = debug;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self2.diff = ms;
+          self2.prev = prevTime;
+          self2.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self2, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self2, args);
+          const logFn = self2.log || createDebug.log;
+          logFn.apply(self2, args);
+        }
+        debug.namespace = namespace;
+        debug.useColors = createDebug.useColors();
+        debug.color = createDebug.selectColor(namespace);
+        debug.extend = extend3;
+        debug.destroy = createDebug.destroy;
+        Object.defineProperty(debug, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug);
+        }
+        return debug;
+      }
+      function extend3(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns of split) {
+          if (ns[0] === "-") {
+            createDebug.skips.push(ns.slice(1));
+          } else {
+            createDebug.names.push(ns);
+          }
+        }
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
+            } else {
+              searchIndex++;
+              templateIndex++;
+            }
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
+          } else {
+            return false;
+          }
+        }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug.names,
+          ...createDebug.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      function enabled(name) {
+        for (const skip of createDebug.skips) {
+          if (matchesTemplate(name, skip)) {
+            return false;
+          }
+        }
+        for (const ns of createDebug.names) {
+          if (matchesTemplate(name, ns)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function coerce2(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug.enable(createDebug.load());
+      return createDebug;
+    }
+    module.exports = setup;
+  }
+});
+
+// node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js"(exports, module) {
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load2;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load2() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports, module) {
+    "use strict";
+    module.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module) {
+    "use strict";
+    var os2 = __require("os");
+    var tty = __require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os2.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
+// node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js"(exports, module) {
+    var tty = __require("tty");
+    var util2 = __require("util");
+    exports.init = init;
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load2;
+    exports.useColors = useColors;
+    exports.destroy = util2.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor = require_supports_color();
+      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+        exports.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (error) {
+    }
+    exports.inspectOpts = Object.keys(process.env).filter((key) => {
+      return /^debug_/i.test(key);
+    }).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+        return k.toUpperCase();
+      });
+      let val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c = this.color;
+        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+        const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util2.formatWithOptions(exports.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load2() {
+      return process.env.DEBUG;
+    }
+    function init(debug) {
+      debug.inspectOpts = {};
+      const keys = Object.keys(exports.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util2.inspect(v, this.inspectOpts).split("\n").map((str2) => str2.trim()).join(" ");
+    };
+    formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util2.inspect(v, this.inspectOpts);
+    };
+  }
+});
+
+// node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js"(exports, module) {
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module.exports = require_browser();
+    } else {
+      module.exports = require_node();
+    }
+  }
+});
+
 // node_modules/.pnpm/follow-redirects@1.16.0/node_modules/follow-redirects/debug.js
 var require_debug = __commonJS({
   "node_modules/.pnpm/follow-redirects@1.16.0/node_modules/follow-redirects/debug.js"(exports, module) {
@@ -10747,7 +11593,7 @@ var require_debug = __commonJS({
     module.exports = function() {
       if (!debug) {
         try {
-          debug = __require("debug")("follow-redirects");
+          debug = require_src()("follow-redirects");
         } catch (error) {
         }
         if (typeof debug !== "function") {
@@ -111539,7 +112385,9 @@ var init_channelPostClient = __esm({
 var channelClient_exports = {};
 __export(channelClient_exports, {
   ChannelClient: () => ChannelClient,
+  DEFAULT_OPEN_CHAT_DISCOVERY_MS: () => DEFAULT_OPEN_CHAT_DISCOVERY_MS,
   channelMsgToLarkEvent: () => channelMsgToLarkEvent,
+  resolveOpenChatDiscoveryMs: () => resolveOpenChatDiscoveryMs,
   resolveRecoveredThreadId: () => resolveRecoveredThreadId,
   synthesizeCardActionEvent: () => synthesizeCardActionEvent
 });
@@ -112044,6 +112892,20 @@ var init_channelClient = __esm({
         log(`cardAction \u2192 synthesized turn: value=${JSON.stringify(evt.action?.value)} thread=${ev.thread_id ?? "?"}`);
         this.queue.push(ev);
       }
+      /**
+       * Push an already-built synthetic LarkMessageEvent onto the inbound queue,
+       * so handler.ts processes it as an ordinary turn. Same mechanism as
+       * {@link handleCardAction}'s cardAction → queue.push, generalized for other
+       * bridge-external signal sources — currently only the task-handle comment
+       * poller (src/tasklist/commentPoller.ts), which synthesizes a turn from a
+       * new Feishu task comment. Public because the poller lives outside this
+       * class (main.ts wires it); the caller is fully responsible for building a
+       * well-formed event (thread_id/root_id resolved, etc.) — this method does
+       * no validation of its own, mirroring handleCardAction's contract.
+       */
+      enqueueSyntheticEvent(ev) {
+        this.queue.push(ev);
+      }
       /**
        * Return an OutboundCardClient bound to this client's channel handle.
        *
@@ -112654,6 +113516,403 @@ var init_channelClient = __esm({
   }
 });
 
+// src/tasklist/client.ts
+var client_exports = {};
+__export(client_exports, {
+  TaskApiError: () => TaskApiError,
+  TaskListClient: () => TaskListClient,
+  TaskRequestTimeoutError: () => TaskRequestTimeoutError,
+  isPermissionDeniedError: () => isPermissionDeniedError,
+  isTaskNotFoundError: () => isTaskNotFoundError,
+  isTaskRequestTimeoutError: () => isTaskRequestTimeoutError
+});
+function isTaskNotFoundError(err2) {
+  if (err2 instanceof TaskApiError) {
+    if (err2.status === 404) return true;
+    if (typeof err2.message === "string" && /not.?found|不存在|resource_not_exist/i.test(err2.message)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isPermissionDeniedError(err2) {
+  if (err2 instanceof TaskApiError) {
+    if (err2.status === 403) return true;
+    if (typeof err2.message === "string" && /no permission|no.access|forbidden|access.denied|无权限|未授权/i.test(err2.message)) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseDueMs(task) {
+  const due = asRecord(task["due"]);
+  const timestamp2 = due["timestamp"];
+  if (typeof timestamp2 !== "string") return void 0;
+  const ms = Number(timestamp2);
+  if (!Number.isFinite(ms)) return void 0;
+  return due["is_all_day"] === true ? ms + MS_PER_DAY : ms;
+}
+function asRecord(v) {
+  return typeof v === "object" && v !== null ? v : {};
+}
+function wrapErr(label, err2) {
+  if (err2 instanceof TaskApiError) throw err2;
+  const rec = asRecord(err2);
+  const response = asRecord(rec["response"]);
+  const status = typeof response["status"] === "number" ? response["status"] : void 0;
+  const body = asRecord(response["data"]);
+  const code = typeof body["code"] === "number" ? body["code"] : void 0;
+  const bodyMsg = typeof body["msg"] === "string" ? body["msg"] : void 0;
+  const message = `[tasklist.client] ${label} failed: ${bodyMsg ?? err2?.message ?? String(err2)}`;
+  throw new TaskApiError(message, { status, code, cause: err2 });
+}
+function isTaskRequestTimeoutError(err2) {
+  if (err2 instanceof TaskRequestTimeoutError) return true;
+  if (err2 instanceof TaskApiError && err2.cause instanceof TaskRequestTimeoutError) return true;
+  return false;
+}
+function withTimeout(promise, ms, label) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new TaskRequestTimeoutError(`${label} timed out after ${ms}ms`)), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+function isNotFoundLikeRaw(err2) {
+  const rec = asRecord(err2);
+  const response = asRecord(rec["response"]);
+  if (response["status"] === 404) return true;
+  const body = asRecord(response["data"]);
+  const msg = typeof body["msg"] === "string" ? body["msg"] : "";
+  return /not.?found|不存在|resource_not_exist/i.test(msg);
+}
+var DEFAULT_TIMEOUT_MS, TaskApiError, MS_PER_DAY, TaskRequestTimeoutError, TASK_V2_BASE, TaskListClient;
+var init_client = __esm({
+  "src/tasklist/client.ts"() {
+    "use strict";
+    DEFAULT_TIMEOUT_MS = 12e3;
+    TaskApiError = class extends Error {
+      status;
+      code;
+      constructor(message, opts) {
+        super(message);
+        this.name = "TaskApiError";
+        this.status = opts.status;
+        this.code = opts.code;
+        this.cause = opts.cause;
+      }
+    };
+    MS_PER_DAY = 24 * 60 * 6e4;
+    TaskRequestTimeoutError = class extends Error {
+    };
+    TASK_V2_BASE = "/open-apis/task/v2";
+    TaskListClient = class {
+      #requester;
+      #timeoutMs;
+      constructor(requester, opts = {}) {
+        this.#requester = requester;
+        this.#timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+      }
+      /** Single choke point for every outbound call — applies the timeout race uniformly. */
+      #request(config, label) {
+        return withTimeout(this.#requester.request(config), this.#timeoutMs, label);
+      }
+      async getTask(taskGuid) {
+        let resp;
+        try {
+          resp = await this.#request(
+            {
+              method: "GET",
+              url: `${TASK_V2_BASE}/tasks/${encodeURIComponent(taskGuid)}`,
+              params: { user_id_type: "open_id" }
+            },
+            `getTask(${taskGuid})`
+          );
+        } catch (err2) {
+          if (isNotFoundLikeRaw(err2)) return null;
+          wrapErr(`getTask(${taskGuid})`, err2);
+        }
+        const task = resp.data?.task;
+        if (!task) return null;
+        return {
+          guid: String(task["guid"] ?? task["id"] ?? taskGuid),
+          summary: typeof task["summary"] === "string" ? task["summary"] : void 0,
+          description: typeof task["description"] === "string" ? task["description"] : void 0,
+          completedAt: typeof task["completed_at"] === "string" ? task["completed_at"] : void 0,
+          dueMs: parseDueMs(task)
+        };
+      }
+      /** Overwrite the task description (bridge-owned status-snapshot block only — see writeback.ts). */
+      async patchDescription(taskGuid, description) {
+        await this.#patchTask(taskGuid, { description }, ["description"]);
+      }
+      /** Mark the task complete "now". */
+      async complete(taskGuid) {
+        await this.#patchTask(taskGuid, { completed_at: String(Date.now()) }, ["completed_at"]);
+      }
+      /**
+       * Clear completed_at (task v2 patch semantics: an `update_fields` entry with
+       * no corresponding value in `task` clears that field — verified via
+       * `lark-cli schema task tasks patch`).
+       */
+      async reopen(taskGuid) {
+        await this.#patchTask(taskGuid, {}, ["completed_at"]);
+      }
+      async #patchTask(taskGuid, task, updateFields) {
+        const label = `patchTask(${taskGuid}, fields=${updateFields.join(",")})`;
+        try {
+          await this.#request(
+            {
+              method: "PATCH",
+              url: `${TASK_V2_BASE}/tasks/${encodeURIComponent(taskGuid)}`,
+              params: { user_id_type: "open_id" },
+              data: { task, update_fields: updateFields }
+            },
+            label
+          );
+        } catch (err2) {
+          wrapErr(label, err2);
+        }
+      }
+      async addComment(taskGuid, content) {
+        const label = `addComment(${taskGuid})`;
+        try {
+          await this.#request(
+            {
+              method: "POST",
+              url: `${TASK_V2_BASE}/comments`,
+              data: { resource_type: "task", resource_id: taskGuid, content }
+            },
+            label
+          );
+        } catch (err2) {
+          wrapErr(label, err2);
+        }
+      }
+      async listComments(taskGuid, opts = {}) {
+        const label = `listComments(${taskGuid})`;
+        let resp;
+        try {
+          resp = await this.#request(
+            {
+              method: "GET",
+              url: `${TASK_V2_BASE}/comments`,
+              params: {
+                resource_type: "task",
+                resource_id: taskGuid,
+                page_size: opts.pageSize ?? 50,
+                // Spread-omit: the SDK serializes a literal `undefined` value into
+                // the query string ("page_token=undefined"), which strict endpoints
+                // reject with 1470400 — only send the key when we hold a real token.
+                ...opts.pageToken ? { page_token: opts.pageToken } : {}
+              }
+            },
+            label
+          );
+        } catch (err2) {
+          wrapErr(label, err2);
+        }
+        const items = resp.data?.items ?? [];
+        const comments = items.map((raw) => {
+          const creator = asRecord(raw["creator"] ?? raw["commentator"]);
+          return {
+            id: String(raw["id"] ?? raw["comment_id"] ?? ""),
+            content: typeof raw["content"] === "string" ? raw["content"] : "",
+            // Real API response uses `created_at` (string ms). create_milli_time/
+            // create_time are kept as fallbacks only in case a differently-versioned
+            // tenant/response shape uses them — created_at is checked first since
+            // it's the verified real field (2026-07 live check against docs/task-handle.md).
+            createMillis: typeof raw["created_at"] === "string" ? raw["created_at"] : typeof raw["create_milli_time"] === "string" ? raw["create_milli_time"] : typeof raw["create_time"] === "string" ? raw["create_time"] : void 0,
+            creatorId: typeof creator["id"] === "string" ? creator["id"] : void 0,
+            creatorType: typeof creator["type"] === "string" ? creator["type"] : void 0
+          };
+        });
+        return {
+          comments,
+          hasMore: Boolean(resp.data?.has_more),
+          pageToken: resp.data?.page_token
+        };
+      }
+      /**
+       * Fetch a tasklist's current guid + member list (verified against live
+       * `lark-cli schema task tasklists get`, 1.0.64 — `GET /tasklists/
+       * :tasklist_guid`). Used by `tasklist-init` as a post-create/post-reuse
+       * safety net: read the membership back and warn if the owner's open_id
+       * didn't actually land as a member (a silently-dropped member is a real
+       * platform failure mode this guards against — see tasklistInit.ts).
+       */
+      async getTasklist(tasklistGuid) {
+        const label = `getTasklist(${tasklistGuid})`;
+        let resp;
+        try {
+          resp = await this.#request(
+            {
+              method: "GET",
+              url: `${TASK_V2_BASE}/tasklists/${encodeURIComponent(tasklistGuid)}`,
+              params: { user_id_type: "open_id" }
+            },
+            label
+          );
+        } catch (err2) {
+          if (isNotFoundLikeRaw(err2)) return null;
+          wrapErr(label, err2);
+        }
+        const tasklist = resp.data?.tasklist;
+        if (!tasklist) return null;
+        const rawMembers = Array.isArray(tasklist["members"]) ? tasklist["members"] : [];
+        const members = rawMembers.map((m) => ({
+          id: String(m["id"] ?? ""),
+          type: m["type"] === "user" || m["type"] === "chat" || m["type"] === "app" ? m["type"] : void 0,
+          role: m["role"] === "assignee" || m["role"] === "follower" || m["role"] === "editor" || m["role"] === "viewer" ? m["role"] : "editor"
+        }));
+        return { guid: String(tasklist["guid"] ?? tasklistGuid), members };
+      }
+      async createTasklist(name, members = []) {
+        const label = `createTasklist(${name})`;
+        let resp;
+        try {
+          resp = await this.#request(
+            {
+              method: "POST",
+              url: `${TASK_V2_BASE}/tasklists`,
+              params: { user_id_type: "open_id" },
+              data: { name, members }
+            },
+            label
+          );
+        } catch (err2) {
+          wrapErr(label, err2);
+        }
+        const guid = resp.data?.tasklist?.["guid"];
+        if (typeof guid !== "string" || guid.length === 0) {
+          throw new TaskApiError(`[tasklist.client] createTasklist(${name}) returned no guid`, {});
+        }
+        return { guid };
+      }
+      /**
+       * List tasks belonging to a tasklist (used by TasklistPoller,
+       * src/tasklist/tasklistPoller.ts, for the v3 "候选注入" candidate
+       * discovery). `GET /tasklists/:tasklist_guid/tasks` verified live
+       * 2026-07-04 against a real tasklist (200 + items[]); note this endpoint
+       * strictly validates `page_token` (a literal "undefined" query value is a
+       * hard 1470400), hence the spread-omit below. Treat as best-effort like
+       * every other tasklist call: TasklistPoller swallows failures and keeps
+       * its previous candidate snapshot rather than propagating.
+       */
+      async listTasklistTasks(tasklistGuid, opts = {}) {
+        const label = `listTasklistTasks(${tasklistGuid})`;
+        let resp;
+        try {
+          resp = await this.#request(
+            {
+              method: "GET",
+              url: `${TASK_V2_BASE}/tasklists/${encodeURIComponent(tasklistGuid)}/tasks`,
+              params: {
+                user_id_type: "open_id",
+                page_size: opts.pageSize ?? 50,
+                // Same spread-omit as listComments: "page_token=undefined" in the
+                // query string is a hard 400 (1470400) on this endpoint — verified
+                // live 2026-07-04 against a real tasklist.
+                ...opts.pageToken ? { page_token: opts.pageToken } : {}
+              }
+            },
+            label
+          );
+        } catch (err2) {
+          wrapErr(label, err2);
+        }
+        const items = resp.data?.items ?? [];
+        const tasks = items.map((task) => ({
+          guid: String(task["guid"] ?? task["id"] ?? ""),
+          summary: typeof task["summary"] === "string" ? task["summary"] : void 0,
+          description: typeof task["description"] === "string" ? task["description"] : void 0,
+          completedAt: typeof task["completed_at"] === "string" ? task["completed_at"] : void 0,
+          dueMs: parseDueMs(task)
+        }));
+        return { tasks, hasMore: Boolean(resp.data?.has_more), pageToken: resp.data?.page_token };
+      }
+      /**
+       * Add members to an existing tasklist (verified against `lark-cli schema
+       * task tasklists add_members`, 1.0.64 — `POST /tasklists/:tasklist_guid/
+       * members`). Used by `tasklist-init --team` and by a bot's own first-run
+       * self-join (docs/task-handle.md §7 "同一 owner 的一组 bot… 把自己加为
+       * editor") to add sibling bot apps as `editor` members of the shared
+       * "Agent Team" list. Idempotent from the caller's perspective: re-adding an
+       * existing member is a harmless no-op per the platform (not independently
+       * verified against a live 409/duplicate-shaped error — callers should treat
+       * any failure here as best-effort, same swallow-and-warn posture as the
+       * rest of this feature).
+       */
+      async addTasklistMembers(tasklistGuid, members) {
+        const label = `addTasklistMembers(${tasklistGuid})`;
+        try {
+          await this.#request(
+            {
+              method: "POST",
+              url: `${TASK_V2_BASE}/tasklists/${encodeURIComponent(tasklistGuid)}/members`,
+              params: { user_id_type: "open_id" },
+              data: { members }
+            },
+            label
+          );
+        } catch (err2) {
+          wrapErr(label, err2);
+        }
+      }
+    };
+  }
+});
+
+// src/tasklist/teamRegistry.ts
+var teamRegistry_exports = {};
+__export(teamRegistry_exports, {
+  claimTeamTasklistGuid: () => claimTeamTasklistGuid,
+  overwriteTeamTasklistGuid: () => overwriteTeamTasklistGuid,
+  readTeamTasklistGuid: () => readTeamTasklistGuid
+});
+import { rename as rename4, readFile as readFile6, writeFile as writeFile5, mkdir as mkdir4 } from "node:fs/promises";
+import { dirname } from "node:path";
+async function readTeamTasklistGuid(filePath) {
+  try {
+    const raw = await readFile6(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return void 0;
+    const guid = parsed["tasklistGuid"];
+    return typeof guid === "string" && guid.length > 0 ? guid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function claimTeamTasklistGuid(filePath, tasklistGuid) {
+  const existing = await readTeamTasklistGuid(filePath);
+  if (existing) return existing;
+  await writeTeamTasklistGuid(filePath, tasklistGuid);
+  return tasklistGuid;
+}
+async function overwriteTeamTasklistGuid(filePath, tasklistGuid) {
+  await writeTeamTasklistGuid(filePath, tasklistGuid);
+}
+async function writeTeamTasklistGuid(filePath, tasklistGuid) {
+  try {
+    const file = { version: 1, tasklistGuid };
+    const json2 = JSON.stringify(file, null, 2);
+    const tmpPath = `${filePath}.tmp`;
+    await mkdir4(dirname(filePath), { recursive: true });
+    await writeFile5(tmpPath, json2, "utf8");
+    await rename4(tmpPath, filePath);
+  } catch (err2) {
+    console.warn(
+      `[tasklist.teamRegistry] failed to persist tasklistGuid to ${filePath} (continuing, best-effort):`,
+      err2
+    );
+  }
+}
+var init_teamRegistry = __esm({
+  "src/tasklist/teamRegistry.ts"() {
+    "use strict";
+  }
+});
+
 // node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/can-promise.js
 var require_can_promise = __commonJS({
   "node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/can-promise.js"(exports, module) {
@@ -116991,7 +118250,7 @@ var require_canvas = __commonJS({
 });
 
 // node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/browser.js
-var require_browser = __commonJS({
+var require_browser2 = __commonJS({
   "node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/browser.js"(exports) {
     var canPromise = require_can_promise();
     var QRCode2 = require_qrcode();
@@ -117138,7 +118397,7 @@ var require_server = __commonJS({
       }
     }
     exports.create = QRCode2.create;
-    exports.toCanvas = require_browser().toCanvas;
+    exports.toCanvas = require_browser2().toCanvas;
     exports.toString = function toString3(text, opts, cb) {
       const params = checkParams(text, opts, cb);
       const type2 = params.opts ? params.opts.type : void 0;
@@ -124196,10 +125455,81 @@ var ResponseSurfacePrototypeConfigSchema = external_exports.object({
 }).default(responseSurfacePrototypeConfigDefaults);
 
 // src/config/botLoader.ts
+var KNOWN_EFFORT_VALUES = /* @__PURE__ */ new Set(["low", "medium", "high", "max"]);
 var GitIdentitySchema = external_exports.object({
   name: external_exports.string().min(1),
   email: external_exports.string().email()
 });
+var TaskHandleConfigSchema = external_exports.object({
+  /**
+   * owner 的「Agent Team」共享清单 GUID。由 `larkway tasklist-init --team`
+   * provisioning 子命令产出并手工填入,或经共享注册文件(task-team.json)被
+   * 同组 bot 自动发现。缺失 = 功能休眠(main.ts 不会替你建)。
+   */
+  tasklistGuid: external_exports.string().min(1).optional(),
+  /**
+   * @deprecated v1 遗留字段,v2 已去掉「enabled 开关」语义 —— 真正门槛见上。
+   * 仅为了不 break 现网已写 `enabled: true` 的 yaml(strict schema 否则会拒绝
+   * 未知字段)而接受它;接受后从不读取,loadBots() 会打一条 deprecation warn
+   * 提示删除。新 yaml 不要再写这个字段。
+   */
+  enabled: external_exports.boolean().optional(),
+  /**
+   * v3.1 停滞检测(docs/task-handle.md §12)全部可选,均有保守默认值——不配
+   * 就用默认阈值,不是新的 enable 开关(检测本身跟 tasklistGuid 一样,只要有
+   * 认领记录就跑;想彻底关掉停滞检测本身,见 stallDetectionDisabled)。
+   */
+  /** 绑定话题超过这个时长(ms)无活动 → 判定停滞,唤醒认领的 agent。默认 24h。 */
+  stallThresholdMs: external_exports.number().positive().optional(),
+  /** 若该话题最后一轮 turn 以失败/崩溃收场,改用这个更短的阈值(ms)。默认 30min。 */
+  stallFastThresholdMs: external_exports.number().positive().optional(),
+  /**
+   * v3.2 交接断链检测(docs/task-handle.md §13):若最后一轮完成 turn 的回复
+   * @ 了花名册上的另一个 bot,且对方的 bridge 在这个阈值(ms)内在同一话题没
+   * 有收到任何事件,改用这个更短的阈值(优先级高于上面两个,取更短者)。
+   * 默认 5min——协作断链比一般停滞紧急得多,任务多为小时级,理应分钟级发现。
+   * **下限提示**:5min 对应本机 open 模式 bot 的 gap-fill 巡检周期(300s)+
+   * 一个 patrol tick 缓冲——配更短不会被拦,但低于部署实际的 gap-fill 周期
+   * 有跟补投撞车、同一事件被提醒两次的风险,见 docs/task-handle.md §13。只有
+   * 明确 chats 白名单(非 open 模式)的 bot 没有周期性 gap-fill(只有断线重连
+   * 触发),下限可以放宽到 2min。且只对**同一 bridge 进程内**的协作 bot 生
+   * 效——跨 bridge 的 @ 天生观察不到对方的收到时间,走一般停滞阈值。
+   * **收到只是暂缓,不是永久解除**——见 stallHandoffReceiptGraceMs。
+   */
+  stallHandoffThresholdMs: external_exports.number().positive().optional(),
+  /**
+   * v3.2 revision 3(docs/task-handle.md §13):对方"收到了事件"只在这个阈值
+   * (ms)内被信任——收到之后这段时间里,如果对方**真的跑完一轮 turn**(不是
+   * 又收到一次事件),才算真正解除交接断链;超过这个时长仍没有对方跑完 turn
+   * 的记录,重新判定为断链、再次提醒。默认 30min(相对 handler.ts 自己注释的
+   * 单轮 turn 5-15 分钟耗时留足余量)。防的是反向漏洞:如果"收到"永久解除
+   * 断链判定,对方收到后真的崩了/卡死,就再也不会被判定断链了。
+   */
+  stallHandoffReceiptGraceMs: external_exports.number().positive().optional(),
+  /** 同一任务两次提醒之间的最短间隔(ms),防止骚扰。默认 24h。 */
+  stallNudgeCooldownMs: external_exports.number().positive().optional(),
+  /** 连续几次提醒仍无进展后改为升级(任务评论通知人类,此后对该任务静默直到有新活动)。默认 2。 */
+  stallEscalateAfterNudges: external_exports.number().int().positive().optional(),
+  /** 彻底关闭停滞检测(默认 false = 开启,阈值保守)。 */
+  stallDetectionDisabled: external_exports.boolean().optional(),
+  /**
+   * v3.3 候选黑洞提示(docs/task-handle.md §14):共享清单里一个未认领候选
+   * 任务连续滞留超过这个时长(ms)仍没被任何话题绑定(自动或人工认领都算解除),
+   * TasklistPoller 就在该任务下留一条机械提示评论(每个候选只提一次,绑定
+   * 成功后从"已提示"集合清除,再次滞留可再提)。默认 1h。只对同一 tasklistGuid
+   * 共享组里"首个解析出该 guid 的 bot"的配置生效(跟 TasklistPoller 本身
+   * "一个 guid 一个实例"的粒度一致,见 clientOwnerBotId 的同款约定)。
+   */
+  candidateUnboundAlertMs: external_exports.number().positive().optional(),
+  /**
+   * v3.3 全局唤醒保险丝(docs/task-handle.md §14):这个 bot 的 StallDetector
+   * 每小时(滚动窗口,非整点分桶)最多合成几次唤醒 turn(含通用/断链/过期各
+   * 档,不含升级评论)。超限本轮抑制,只打一条点名哪个任务被抑制的 warn 日志,
+   * 不改任何持久状态,下一轮正常重新评估。默认 6——纯粹是防止未知 bug 导致
+   * 唤醒风暴烧推理额度的保险丝,正常路径永远碰不到它,不是需要调优的阈值。
+   */
+  stallNudgeHourlyCap: external_exports.number().int().positive().optional()
+}).strict();
 var GitCloneUrlSchema = external_exports.string().min(1).refine(
   (value) => {
     if (/^https?:\/\/\S+$/i.test(value)) return true;
@@ -124387,7 +125717,67 @@ var BotConfigSchema = external_exports.object({
    *
    * @default "claude"
    */
-  backend: external_exports.string().min(1).default("claude")
+  backend: external_exports.string().min(1).default("claude"),
+  /**
+   * 话题 ↔ 飞书任务句柄(docs/task-handle.md,v2)。省略此字段不代表关闭,但也
+   * 不会触发任何自动建清单——main.ts 在 startup 时只做只读解析(yaml 里的
+   * tasklistGuid,或共享注册文件里已有的 guid);清单本身只由
+   * `larkway tasklist-init --team` 建一次。
+   */
+  taskHandle: TaskHandleConfigSchema.optional(),
+  /**
+   * Per-bot model override (perf plan 批 C 旋钮). Passed through verbatim to
+   * the backend CLI as `--model <value>` (claude) / `turn/start.model`
+   * (codex) — larkway does not validate or allowlist model ids, same
+   * precedent as `backend` above. Omitted = unchanged host/backend default
+   * behavior (byte-identical to before this field existed).
+   */
+  model: external_exports.string().min(1).optional(),
+  /**
+   * Per-bot reasoning-effort override (perf plan 批 C 旋钮). Passed through
+   * verbatim as `--effort <value>` on the claude CLI (confirmed supported:
+   * `claude --effort low|medium|high|max`, also non-interactive). Also
+   * confirmed supported on codex via `turn/start.effort`, mapped through
+   * codexEffortFromLarkway (src/codex/runner.ts) since codex's own value
+   * space is low/medium/high/xhigh, not low/medium/high/max. Omitted =
+   * unchanged default behavior.
+   */
+  effort: external_exports.string().min(1).optional(),
+  /**
+   * docs/larkway-perf-plan.md §4 — opt into a persistent warm process
+   * instead of the default one-shot cold-start-per-turn behavior. Takes
+   * effect for `backend: "codex"` (a single bot-level `codex app-server`
+   * process — src/codex/pool.ts CodexProcessPool) and `backend: "claude"`
+   * (one warm process per active thread — src/claude/pool.ts
+   * ClaudeProcessPool). Any other backend value is a no-op (main.ts only
+   * constructs a pool for these two; botLoader's advisory warn below flags
+   * the mismatch upfront). Byte-identical behavior when unset, matching
+   * every other perf-plan flag in this schema. `.optional()` (not
+   * `.default(false)`, deliberately — B1 fix): a `.default()` would make
+   * every future `larkway bot` yaml write-out include `warmProcess: false`
+   * even when nobody asked for it, and — because this schema is `.strict()`
+   * — would break loading that yaml back with an OLDER larkway build that
+   * predates this field. `undefined` and `false` are treated identically at
+   * both read sites (main.ts's `bot.warmProcess && …` and the advisory warn
+   * below).
+   */
+  warmProcess: external_exports.boolean().optional(),
+  /**
+   * Idle threshold (ms) before a warm process (see `warmProcess` above) with
+   * no in-flight turn gets SIGTERM'd. Only meaningful when `warmProcess` is
+   * true. @default 10 * 60 * 1000 (10 min) — see DEFAULT_WARM_PROCESS_IDLE_MS
+   * in src/codex/pool.ts (backend "codex") / src/claude/pool.ts (backend
+   * "claude") — both use the same default value.
+   */
+  warmProcessIdleMs: external_exports.number().int().positive().optional(),
+  /**
+   * `backend: "claude"` only: cap on how many warm per-thread processes
+   * ClaudeProcessPool keeps alive at once (LRU-evicts the longest-idle one
+   * past this). Meaningless for `backend: "codex"`, which only ever holds
+   * one bot-level process regardless. @default 6 — see DEFAULT_MAX_PROCESSES
+   * in src/claude/pool.ts.
+   */
+  warmProcessMaxProcesses: external_exports.number().int().positive().optional()
 }).strict();
 async function loadBots(botsDir) {
   let entries;
@@ -124425,6 +125815,21 @@ async function loadBots(botsDir) {
 ${issues}`);
     }
     const bot = result.data;
+    if (bot.effort && !KNOWN_EFFORT_VALUES.has(bot.effort)) {
+      console.warn(
+        `[botLoader] Bot "${bot.id}" effort "${bot.effort}" is not one of the known values (${[...KNOWN_EFFORT_VALUES].join(", ")}). Continuing \u2014 the value is still passed through to the backend CLI verbatim (claude: --effort; codex: mapped through codexEffortFromLarkway), but a typo here will silently fail the bot's spawn every turn.`
+      );
+    }
+    if (bot.warmProcess && bot.backend !== "codex" && bot.backend !== "claude") {
+      console.warn(
+        `[botLoader] Bot "${bot.id}" sets warmProcess:true but backend is "${bot.backend}" (only "codex"/"claude" are supported as of this writing). warmProcess will be a no-op for this bot.`
+      );
+    }
+    if (bot.taskHandle?.enabled !== void 0) {
+      console.warn(
+        `[botLoader] Bot "${bot.id}" has taskHandle.enabled set, but this field was removed in v2 (docs/task-handle.md \xA76.3 \u2014 the gate is now whether a tasklistGuid resolves, not a flag). The value is accepted for backward compat but never read; safe to delete it from the yaml.`
+      );
+    }
     if (bot.memory_file) {
       const memoryPath2 = path.join(botsDir, bot.memory_file);
       try {
@@ -124456,25 +125861,8 @@ ${issues}`);
   return bots;
 }
 
-// src/config/paths.ts
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-function larkwayHome() {
-  const env = process.env.LARKWAY_HOME;
-  if (env && env.trim() !== "") return resolve(env);
-  return join(homedir(), ".larkway");
-}
-function assertSafePathSegment(label, value) {
-  if (!/^[A-Za-z0-9_-]+$/.test(value)) {
-    throw new Error(`${label} must be a safe path segment`);
-  }
-}
-function resolveAgentWorkspacePathFromHome(home, agentId) {
-  assertSafePathSegment("agentId", agentId);
-  return join(home, "agents", agentId, "workspace");
-}
-
 // src/cli/botsStore.ts
+init_paths();
 function resolveBotsDir() {
   const override = process.env.LARKWAY_BOTS_DIR;
   if (override && override.trim() !== "") return path2.resolve(override);
@@ -124637,6 +126025,7 @@ var import_dotenv = __toESM(require_main(), 1);
 import { readFile as readFile3 } from "node:fs/promises";
 import os from "node:os";
 import path3 from "node:path";
+init_paths();
 import_dotenv.default.config();
 import_dotenv.default.config({ path: path3.join(larkwayHome(), ".env") });
 var ConfigSchema = external_exports.object({
@@ -124696,6 +126085,7 @@ var ConfigJson = external_exports.object({
 var DEFAULT_CONFIG_PATH = path3.join(larkwayHome(), "config.json");
 
 // src/cli/hostConfig.ts
+init_paths();
 function resolveLarkwayHome() {
   return larkwayHome();
 }
@@ -125420,6 +126810,7 @@ async function ensureMemoryScaffold(workspacePath) {
 }
 
 // src/cli/commands/init.ts
+init_paths();
 var execFileAsync3 = promisify3(execFile3);
 function checkNodeVersion() {
   const version = process.versions.node;
@@ -126103,7 +127494,7 @@ async function run(ctx, args) {
 }
 
 // src/cli/commands/doctor.ts
-import { access as access6, readdir as readdir4, readFile as readFile6, rm } from "node:fs/promises";
+import { access as access6, readdir as readdir4, readFile as readFile7, rm } from "node:fs/promises";
 import { execFile as execFile5 } from "node:child_process";
 import path10 from "node:path";
 import { promisify as promisify5 } from "node:util";
@@ -126325,7 +127716,7 @@ async function checkWorktrees(ctx) {
       const gitPath = path10.join(worktreeDir, ".git");
       let gitContent = null;
       try {
-        const stat6 = await readFile6(gitPath, "utf-8").catch(() => null);
+        const stat6 = await readFile7(gitPath, "utf-8").catch(() => null);
         gitContent = stat6;
       } catch {
       }
@@ -126471,6 +127862,94 @@ async function checkWsConnectivity(ctx, opts) {
     message: `WS \u63A2\u6D4B\u5931\u8D25: ${result.message ?? "\u672A\u77E5\u9519\u8BEF"}\u3002${opts.lint ? "(CI \u6A21\u5F0F: \u7F51\u7EDC/\u8D85\u65F6\u4E0D\u8BA1\u5165 error)" : "\u8BF7\u68C0\u67E5\u98DE\u4E66 app \u51ED\u636E\u53CA\u7F51\u7EDC\u53EF\u8FBE\u6027\u3002"}`
   };
 }
+async function probeTaskScope(appId, appSecret, tasklistGuid) {
+  try {
+    const { Client: LarkSdkClient2 } = await Promise.resolve().then(() => __toESM(require_lib2(), 1));
+    const { TaskListClient: TaskListClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+    const sdkClient = new LarkSdkClient2({ appId, appSecret });
+    const taskClient = new TaskListClient2({
+      request: (config) => sdkClient.request(config)
+    });
+    await taskClient.listTasklistTasks(tasklistGuid, { pageSize: 1 });
+    return { ok: true };
+  } catch (err2) {
+    return { ok: false, message: err2 instanceof Error ? err2.message : String(err2) };
+  }
+}
+var TASK_HANDLE_REQUIRED_SCOPES = [
+  "task:tasklist:read",
+  "task:tasklist:write",
+  "task:task:read",
+  "task:comment:write"
+];
+async function checkTaskHandle(ctx, opts) {
+  const results = [];
+  const botIds = await ctx.botsStore.listBots();
+  if (botIds.length === 0) return results;
+  const { resolveTaskTeamRegistryPath: resolveTaskTeamRegistryPath2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+  const { readTeamTasklistGuid: readTeamTasklistGuid2 } = await Promise.resolve().then(() => (init_teamRegistry(), teamRegistry_exports));
+  const registryGuid = await readTeamTasklistGuid2(resolveTaskTeamRegistryPath2());
+  let anyConfigured = false;
+  for (const id of botIds) {
+    let bot;
+    try {
+      bot = await ctx.botsStore.readBot(id);
+    } catch {
+      continue;
+    }
+    const guid = bot.taskHandle?.tasklistGuid ?? registryGuid;
+    if (!guid) continue;
+    anyConfigured = true;
+    if (process.env["LARKWAY_SKIP_WS_PROBE"] === "1") {
+      results.push({
+        id: `task-handle-${id}`,
+        label: `bot "${id}" \u8BDD\u9898\u2194\u4EFB\u52A1\u53E5\u67C4`,
+        status: "ok",
+        message: `\u5DF2\u914D\u7F6E(guid=${guid}),scope \u63A2\u6D4B\u5DF2\u8DF3\u8FC7(LARKWAY_SKIP_WS_PROBE=1)\u3002`
+      });
+      continue;
+    }
+    const appSecret = await ctx.hostConfig.readSecret(bot.app_secret_env);
+    if (!appSecret) {
+      results.push({
+        id: `task-handle-${id}`,
+        label: `bot "${id}" \u8BDD\u9898\u2194\u4EFB\u52A1\u53E5\u67C4`,
+        status: "warn",
+        message: `\u5DF2\u914D\u7F6E guid=${guid},\u4F46 AppSecret \u7F3A\u5931,\u8DF3\u8FC7 scope \u63A2\u6D4B(\u89C1\u98DE\u4E66\u51ED\u636E\u68C0\u67E5\u9879)\u3002`
+      });
+      continue;
+    }
+    const probe = await probeTaskScope(bot.app_id, appSecret, guid);
+    if (probe.ok) {
+      results.push({
+        id: `task-handle-${id}`,
+        label: `bot "${id}" \u8BDD\u9898\u2194\u4EFB\u52A1\u53E5\u67C4`,
+        status: "ok",
+        message: `\u5DF2\u914D\u7F6E(guid=${guid}),task scope \u63A2\u6D4B\u6210\u529F\u3002`
+      });
+    } else {
+      const scopeLink = `https://open.feishu.cn/app/${bot.app_id}/auth?q=${TASK_HANDLE_REQUIRED_SCOPES.join(",")}&op_from=doctor&token_type=tenant`;
+      const looksLikeScopeError = /scope|permission|无权限|未授权|access.denied/i.test(probe.message ?? "");
+      results.push({
+        id: `task-handle-${id}`,
+        label: `bot "${id}" \u8BDD\u9898\u2194\u4EFB\u52A1\u53E5\u67C4`,
+        status: opts.lint && !looksLikeScopeError ? "warn" : "error",
+        message: `\u5DF2\u914D\u7F6E guid=${guid},\u4F46 task scope \u63A2\u6D4B\u5931\u8D25:${probe.message ?? "\u672A\u77E5\u9519\u8BEF"}
+  \u9700\u8981\u4EE5\u4E0B scope:${TASK_HANDLE_REQUIRED_SCOPES.join(", ")}
+  \u5F00\u901A\u94FE\u63A5:${scopeLink}`
+      });
+    }
+  }
+  if (!anyConfigured) {
+    results.push({
+      id: "task-handle-not-configured",
+      label: "\u8BDD\u9898\u2194\u4EFB\u52A1\u53E5\u67C4 (\u53EF\u9009)",
+      status: "ok",
+      message: '\u672A\u914D\u7F6E\u4EFB\u4F55 bot \u7684\u8BDD\u9898\u2194\u4EFB\u52A1\u53E5\u67C4(\u53EF\u9009\u529F\u80FD)\u3002\u60F3\u542F\u7528:larkway tasklist-init --adopt "<\u6E05\u5355\u540D>" --team <bot1,bot2,\u2026>(\u89C1 docs/task-handle.md \xA77)\u3002'
+    });
+  }
+  return results;
+}
 async function runAllChecks(ctx, opts) {
   const results = [];
   results.push(await checkClaude(ctx));
@@ -126483,6 +127962,8 @@ async function runAllChecks(ctx, opts) {
   results.push(await checkWsConnectivity(ctx, opts));
   const codexChecks = await checkCodex(ctx);
   results.push(...codexChecks);
+  const taskHandleChecks = await checkTaskHandle(ctx, opts);
+  results.push(...taskHandleChecks);
   return results;
 }
 function exitCodeFromResults(results) {
@@ -126664,6 +128145,7 @@ async function run2(ctx, args) {
 
 // src/cli/commands/bot.ts
 import path11 from "node:path";
+init_paths();
 async function run3(ctx, args) {
   const sub = args[0];
   const rest = args.slice(1);
@@ -127265,10 +128747,10 @@ function inferLarkwayHome(botsDir, fallback) {
 }
 
 // src/cli/commands/memory.ts
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
-import { mkdir as mkdir4, writeFile as writeFile5, rm as rm2 } from "node:fs/promises";
+import { mkdir as mkdir5, writeFile as writeFile6, rm as rm2 } from "node:fs/promises";
 import path12 from "node:path";
 import process2 from "node:process";
 function parseArgs(args) {
@@ -127289,10 +128771,10 @@ function parseArgs(args) {
 async function openInEditor(initial) {
   const editor = process2.env.EDITOR || process2.env.VISUAL || "vi";
   const tmpDir = path12.join(tmpdir(), `larkway-memory-${process2.pid}`);
-  await mkdir4(tmpDir, { recursive: true });
+  await mkdir5(tmpDir, { recursive: true });
   const tmpFile = path12.join(tmpDir, "memory.md");
   try {
-    await writeFile5(tmpFile, initial, "utf-8");
+    await writeFile6(tmpFile, initial, "utf-8");
     await new Promise((resolve2, reject) => {
       const child = spawn(editor, [tmpFile], {
         stdio: "inherit",
@@ -127305,7 +128787,7 @@ async function openInEditor(initial) {
         else resolve2();
       });
     });
-    return await readFile7(tmpFile, "utf-8");
+    return await readFile8(tmpFile, "utf-8");
   } finally {
     await rm2(tmpDir, { recursive: true, force: true });
   }
@@ -127346,7 +128828,7 @@ async function subSet(ctx, id, file) {
   if (!await assertBotExists(ctx, id)) return 1;
   let content;
   try {
-    content = await readFile7(file, "utf-8");
+    content = await readFile8(file, "utf-8");
   } catch (e) {
     const msg = `\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6 "${file}": ${e instanceof Error ? e.message : String(e)}`;
     if (ctx.flags.json) {
@@ -127467,8 +128949,9 @@ async function run4(ctx, args) {
 }
 
 // src/cli/commands/perms.ts
-import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
 import path13 from "node:path";
+init_paths();
 function parsePermsArgs(args) {
   const flags = {
     addChats: [],
@@ -127664,7 +129147,7 @@ async function writePermissionGrants(ctx, id, flags) {
   const grantedPath = path13.join(workspacePath, "permissions-granted.md");
   const grants = [];
   if (flags.grantFromRequest) {
-    const requestText = await readFile8(requestPath, "utf8").catch(() => "");
+    const requestText = await readFile9(requestPath, "utf8").catch(() => "");
     grants.push(...extractRequestLines(requestText));
   }
   grants.push(...renderCapabilityGrantLines(splitPermissionList(flags.grantPermissions)));
@@ -127684,8 +129167,8 @@ async function writePermissionGrants(ctx, id, flags) {
     "Do not record secret values here.",
     ""
   ].filter((line) => line !== void 0).join("\n");
-  await mkdir5(path13.dirname(grantedPath), { recursive: true });
-  await writeFile6(grantedPath, body, "utf8");
+  await mkdir6(path13.dirname(grantedPath), { recursive: true });
+  await writeFile7(grantedPath, body, "utf8");
   return { filePath: grantedPath, grants };
 }
 async function editChatsInteractive(config, ctx) {
@@ -128036,13 +129519,14 @@ __export(bridgeControl_exports, {
 });
 import { spawn as spawn2, execFile as execFile6 } from "node:child_process";
 import { openSync, constants as fsConstants } from "node:fs";
-import { readFile as readFile9, writeFile as writeFile7, unlink as unlink5, mkdir as mkdir6, readdir as readdir5, access as access7 } from "node:fs/promises";
+import { readFile as readFile10, writeFile as writeFile8, unlink as unlink5, mkdir as mkdir7, readdir as readdir5, access as access7 } from "node:fs/promises";
 import { promisify as promisify6 } from "node:util";
 import path15 from "node:path";
 import process3 from "node:process";
 import { stat as stat3 } from "node:fs/promises";
 
 // src/bridge/statusFile.ts
+init_paths();
 import fs2 from "node:fs/promises";
 import path14 from "node:path";
 var DEFAULT_STALE_MS = 9e4;
@@ -128113,7 +129597,7 @@ async function resolveDistMain() {
 async function readPid(larkwayDir) {
   const pidFile = bridgePidPath(larkwayDir);
   try {
-    const raw = (await readFile9(pidFile, "utf-8")).trim();
+    const raw = (await readFile10(pidFile, "utf-8")).trim();
     const n = Number(raw);
     return Number.isInteger(n) && n > 0 ? n : null;
   } catch (e) {
@@ -128123,8 +129607,8 @@ async function readPid(larkwayDir) {
 }
 async function writePid(larkwayDir, pid) {
   const pidFile = bridgePidPath(larkwayDir);
-  await mkdir6(path15.dirname(pidFile), { recursive: true });
-  await writeFile7(pidFile, String(pid) + "\n", "utf-8");
+  await mkdir7(path15.dirname(pidFile), { recursive: true });
+  await writeFile8(pidFile, String(pid) + "\n", "utf-8");
 }
 async function removePid(larkwayDir) {
   const pidFile = bridgePidPath(larkwayDir);
@@ -128184,7 +129668,7 @@ async function listMainBridgePids(mainProcessPattern) {
 async function hasAnyFreshStatusJson(larkwayDir, nowMs, staleMs = DEFAULT_STALE_MS) {
   const checkFile2 = async (file) => {
     try {
-      const raw = await readFile9(file, "utf-8");
+      const raw = await readFile10(file, "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed["updatedAt"] !== "string") return { fresh: false, pid: null };
       const updatedMs = Date.parse(parsed["updatedAt"]);
@@ -128271,7 +129755,7 @@ async function startBridge(larkwayDir, opts) {
     await stopBridge(larkwayDir, opts);
   }
   const logPath = bridgeLogPath(larkwayDir);
-  await mkdir6(path15.dirname(logPath), { recursive: true });
+  await mkdir7(path15.dirname(logPath), { recursive: true });
   let supervisorExists = false;
   try {
     await access7(supervisorScript);
@@ -128382,7 +129866,7 @@ async function tailBridgeLog(larkwayDir, n = 80) {
         await fh.close();
       }
     } else {
-      content = await readFile9(logPath, "utf-8");
+      content = await readFile10(logPath, "utf-8");
     }
   } catch (e) {
     if (e.code === "ENOENT") {
@@ -128645,7 +130129,7 @@ async function run6(ctx, args) {
 
 // src/cli/commands/update.ts
 import { spawn as spawn4 } from "node:child_process";
-import { readFile as readFile10, access as access9 } from "node:fs/promises";
+import { readFile as readFile11, access as access9 } from "node:fs/promises";
 import "node:module";
 import path17 from "node:path";
 var DEFAULT_NPM_PACKAGE_SPEC = "larkway@latest";
@@ -128724,7 +130208,7 @@ async function findRepoRoot(startDir) {
     const pkgPath = path17.join(dir, "package.json");
     try {
       await access9(pkgPath);
-      const raw = await readFile10(pkgPath, "utf-8");
+      const raw = await readFile11(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name === "larkway") return dir;
     } catch {
@@ -128961,15 +130445,16 @@ async function run7(ctx, args) {
 import http from "node:http";
 import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
-import { readFile as readFile13, stat as stat5 } from "node:fs/promises";
+import { readFile as readFile14, stat as stat5 } from "node:fs/promises";
 import path22 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/web/api.ts
-import { readdir as readdir6, readFile as readFile12, stat as stat4 } from "node:fs/promises";
+import { readdir as readdir6, readFile as readFile13, stat as stat4 } from "node:fs/promises";
 import { execFile as execFileCallback2 } from "node:child_process";
 import path21 from "node:path";
 import { promisify as promisify8 } from "node:util";
+init_paths();
 
 // src/version.ts
 import { readFileSync } from "node:fs";
@@ -129036,8 +130521,9 @@ function isRuntimeEventRecord(value) {
 // src/web/onboardSession.ts
 var QRCode = __toESM(require_lib3(), 1);
 import { randomUUID } from "node:crypto";
-import { mkdir as mkdir7, writeFile as writeFile8, rename as rename4, chmod as chmod2, readFile as readFile11 } from "node:fs/promises";
+import { mkdir as mkdir8, writeFile as writeFile9, rename as rename5, chmod as chmod2, readFile as readFile12 } from "node:fs/promises";
 import path20 from "node:path";
+init_paths();
 async function defaultRegisterApp(opts) {
   const sdk = await Promise.resolve().then(() => __toESM(require_lib2(), 1));
   return sdk.registerApp(opts);
@@ -129069,10 +130555,10 @@ function quoteIfNeeded2(v) {
   return /[\s#"'=]/.test(v) ? `"${v.replace(/"/g, '\\"')}"` : v;
 }
 async function atomicWrite3(file, content) {
-  await mkdir7(path20.dirname(file), { recursive: true });
+  await mkdir8(path20.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile8(tmp, content, "utf-8");
-  await rename4(tmp, file);
+  await writeFile9(tmp, content, "utf-8");
+  await rename5(tmp, file);
 }
 async function writeSecretTo(envPath, envName, value) {
   if (!ENV_NAME_RE.test(envName)) {
@@ -129080,7 +130566,7 @@ async function writeSecretTo(envPath, envName, value) {
   }
   const map2 = /* @__PURE__ */ new Map();
   try {
-    const raw = await readFile11(envPath, "utf-8");
+    const raw = await readFile12(envPath, "utf-8");
     for (const line of raw.split("\n")) {
       const m = ENV_LINE_RE.exec(line.trim());
       if (m) map2.set(m[1], stripQuotes2(m[2]));
@@ -129095,7 +130581,7 @@ async function writeSecretTo(envPath, envName, value) {
 }
 async function botYamlExists(botsDir, id) {
   try {
-    await readFile11(path20.join(botsDir, `${id}.yaml`), "utf-8");
+    await readFile12(path20.join(botsDir, `${id}.yaml`), "utf-8");
     return true;
   } catch {
     return false;
@@ -129524,7 +131010,7 @@ async function readBotFromDir(dir, id) {
   const memFile = path21.join(dir, `${id}.memory.md`);
   let raw;
   try {
-    raw = await readFile12(yamlFile, "utf-8");
+    raw = await readFile13(yamlFile, "utf-8");
   } catch (e) {
     if (e.code === "ENOENT") {
       throw new Error(`Bot "${id}" not found`);
@@ -129539,7 +131025,7 @@ async function readBotFromDir(dir, id) {
   }
   let memory = null;
   try {
-    memory = await readFile12(memFile, "utf-8");
+    memory = await readFile13(memFile, "utf-8");
   } catch {
   }
   return { config, memory };
@@ -129764,6 +131250,13 @@ var putBot = async (req) => {
       for (const k of ["name", "description", "chats", "repos", "turn_taking_limit", "backend"]) {
         if (k in bodyWithoutTokenFields) merged[k] = bodyWithoutTokenFields[k];
       }
+      for (const k of ["model", "effort"]) {
+        if (k in bodyWithoutTokenFields) {
+          const v = bodyWithoutTokenFields[k];
+          if (typeof v === "string" && v.trim().length > 0) merged[k] = v.trim();
+          else delete merged[k];
+        }
+      }
       if (tokenValue !== void 0) {
         if (tokenValue.trim().length > 0) {
           const envName = gitlabTokenEnvNameForBot(id);
@@ -129786,6 +131279,10 @@ var putBot = async (req) => {
         backend: "codex",
         ...bodyWithoutTokenFields
       };
+      for (const k of ["model", "effort"]) {
+        const v = draft[k];
+        if (typeof v === "string" && v.trim().length === 0) delete draft[k];
+      }
       if (tokenValue !== void 0) {
         if (tokenValue.trim().length > 0) {
           const envName = gitlabTokenEnvNameForBot(id);
@@ -130418,7 +131915,7 @@ async function handleStatic(res, pathname, token) {
   }
   let buf;
   try {
-    buf = await readFile13(target);
+    buf = await readFile14(target);
   } catch {
     writeText(res, 404, "not found");
     return;
@@ -130531,7 +132028,8 @@ async function run8(ctx, args) {
 }
 
 // src/cli/commands/dogfood.ts
-import { access as access10, readFile as readFile14, readdir as readdir7 } from "node:fs/promises";
+init_paths();
+import { access as access10, readFile as readFile15, readdir as readdir7 } from "node:fs/promises";
 import path24 from "node:path";
 
 // src/agent/permissionGate.ts
@@ -131113,7 +132611,7 @@ async function listMarkdownFiles(root) {
 }
 async function readTextOrNull(filePath) {
   try {
-    return await readFile14(filePath, "utf8");
+    return await readFile15(filePath, "utf8");
   } catch {
     return null;
   }
@@ -131124,6 +132622,563 @@ function exitCodeFor(checks) {
   return 0;
 }
 
+// src/cli/commands/tasklistInit.ts
+var import_node_sdk2 = __toESM(require_lib2(), 1);
+init_client();
+init_paths();
+init_teamRegistry();
+
+// src/cli/ownerIdentity.ts
+import { spawnSync } from "node:child_process";
+function resolveOwnerOpenId(profile, _spawnSync = spawnSync) {
+  try {
+    const result = _spawnSync("lark-cli", ["auth", "status", "--profile", profile, "--json"], {
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    if (result.status !== 0) return void 0;
+    const stdout2 = typeof result.stdout === "string" ? result.stdout : "";
+    if (stdout2.trim().length === 0) return void 0;
+    const parsed = JSON.parse(stdout2);
+    if (typeof parsed !== "object" || parsed === null) return void 0;
+    const identities = parsed["identities"];
+    if (typeof identities !== "object" || identities === null) return void 0;
+    const user = identities["user"];
+    if (typeof user !== "object" || user === null) return void 0;
+    const openId = user["openId"];
+    return typeof openId === "string" && openId.length > 0 ? openId : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/lark/profileBootstrap.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+function deriveLarkCliProfile(explicitProfile, appId) {
+  return explicitProfile ?? appId;
+}
+
+// src/cli/userTasklistOps.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+var SPAWN_TIMEOUT_MS = 15e3;
+function runLarkCliJson(args, spawnSyncFn) {
+  let result;
+  try {
+    result = spawnSyncFn("lark-cli", args, { encoding: "utf-8", timeout: SPAWN_TIMEOUT_MS });
+  } catch (err2) {
+    return {
+      ok: false,
+      error: `\u65E0\u6CD5\u6267\u884C lark-cli(${err2 instanceof Error ? err2.message : String(err2)})\u2014\u2014 \u786E\u8BA4 lark-cli \u5DF2\u5B89\u88C5\u4E14\u5728 PATH \u91CC\u3002`
+    };
+  }
+  const stdout2 = typeof result.stdout === "string" ? result.stdout : "";
+  const stderr = typeof result.stderr === "string" ? result.stderr : "";
+  if (stdout2.trim().length === 0) {
+    return {
+      ok: false,
+      error: `lark-cli \u6CA1\u6709\u8F93\u51FA\u4EFB\u4F55\u5185\u5BB9(exit=${result.status ?? "unknown"})\u3002${stderr ? `stderr: ${stderr.slice(0, 500)}` : ""}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout2);
+  } catch {
+    return { ok: false, error: `lark-cli \u8F93\u51FA\u4E0D\u662F\u5408\u6CD5 JSON(exit=${result.status ?? "unknown"}): ${stdout2.slice(0, 500)}` };
+  }
+  if (typeof parsed === "object" && parsed !== null && parsed["ok"] === false) {
+    const errObj = parsed["error"];
+    const rec = typeof errObj === "object" && errObj !== null ? errObj : {};
+    const message = typeof rec["message"] === "string" ? rec["message"] : "\u672A\u77E5\u9519\u8BEF";
+    const hint = typeof rec["hint"] === "string" && rec["hint"] ? `
+\u63D0\u793A:${rec["hint"]}` : "";
+    return { ok: false, error: `${message}${hint}` };
+  }
+  return { ok: true, data: parsed };
+}
+function listUserTasklists(profile, spawnSyncFn = spawnSync3) {
+  const result = runLarkCliJson(
+    ["task", "tasklists", "list", "--as", "user", "--profile", profile, "--page-all", "--json"],
+    spawnSyncFn
+  );
+  if (!result.ok) return result;
+  const data = result.data;
+  const items = typeof data === "object" && data !== null ? data["items"] : void 0;
+  if (!Array.isArray(items)) {
+    return { ok: false, error: `lark-cli \u8FD4\u56DE\u7684\u6E05\u5355\u5217\u8868\u5F62\u72B6\u4E0D\u5BF9(\u7F3A\u5C11 items \u6570\u7EC4):${JSON.stringify(data).slice(0, 300)}` };
+  }
+  const tasklists = [];
+  for (const raw of items) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const guid = raw["guid"];
+    const name = raw["name"];
+    if (typeof guid === "string" && guid.length > 0) {
+      tasklists.push({ guid, name: typeof name === "string" ? name : "(\u65E0\u6807\u9898)" });
+    }
+  }
+  return { ok: true, data: tasklists };
+}
+function addTasklistMembersAsUser(profile, tasklistGuid, members, spawnSyncFn = spawnSync3) {
+  const dataJson = JSON.stringify({ members });
+  return runLarkCliJson(
+    [
+      "task",
+      "tasklists",
+      "add_members",
+      "--as",
+      "user",
+      "--profile",
+      profile,
+      "--tasklist-guid",
+      tasklistGuid,
+      "--data",
+      dataJson,
+      "--json"
+    ],
+    spawnSyncFn
+  );
+}
+function getUserTasklistMembers(profile, tasklistGuid, spawnSyncFn = spawnSync3) {
+  const result = runLarkCliJson(
+    ["task", "tasklists", "get", "--as", "user", "--profile", profile, "--tasklist-guid", tasklistGuid, "--json"],
+    spawnSyncFn
+  );
+  if (!result.ok) return result;
+  const data = result.data;
+  const tasklist = typeof data === "object" && data !== null ? data["tasklist"] : void 0;
+  const members = typeof tasklist === "object" && tasklist !== null ? tasklist["members"] : void 0;
+  if (!Array.isArray(members)) {
+    return { ok: false, error: `lark-cli \u8FD4\u56DE\u7684\u6E05\u5355\u8BE6\u60C5\u5F62\u72B6\u4E0D\u5BF9(\u7F3A\u5C11 tasklist.members \u6570\u7EC4):${JSON.stringify(data).slice(0, 300)}` };
+  }
+  return {
+    ok: true,
+    data: members.filter((m) => typeof m === "object" && m !== null).map((m) => ({
+      id: String(m["id"] ?? ""),
+      type: typeof m["type"] === "string" ? m["type"] : void 0,
+      role: typeof m["role"] === "string" ? m["role"] : void 0
+    }))
+  };
+}
+
+// src/cli/commands/tasklistInit.ts
+function parseArgs2(args) {
+  let team = [];
+  let name = "Agent Team";
+  let owner;
+  let force = false;
+  let adopt;
+  let adoptGuid;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--team" && i + 1 < args.length) {
+      team = args[++i].split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (arg.startsWith("--team=")) {
+      team = arg.slice("--team=".length).split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (arg === "--name" && i + 1 < args.length) {
+      name = args[++i];
+    } else if (arg.startsWith("--name=")) {
+      name = arg.slice("--name=".length);
+    } else if (arg === "--owner" && i + 1 < args.length) {
+      owner = args[++i];
+    } else if (arg.startsWith("--owner=")) {
+      owner = arg.slice("--owner=".length);
+    } else if (arg === "--force") {
+      force = true;
+    } else if (arg === "--adopt" && i + 1 < args.length) {
+      adopt = args[++i];
+    } else if (arg.startsWith("--adopt=")) {
+      adopt = arg.slice("--adopt=".length);
+    } else if (arg === "--adopt-guid" && i + 1 < args.length) {
+      adoptGuid = args[++i];
+    } else if (arg.startsWith("--adopt-guid=")) {
+      adoptGuid = arg.slice("--adopt-guid=".length);
+    }
+  }
+  return { team, name, owner, force, adopt, adoptGuid };
+}
+var USAGE2 = `larkway tasklist-init [--team <bot1,bot2,\u2026>] [--name <\u6E05\u5355\u540D>] [--owner <open_id>] [--force]
+                      [--adopt "<\u6E05\u5355\u540D>" | --adopt-guid <guid>]
+
+\u5BF9\u7740 Claude Code / Codex \u8BF4\u4E00\u53E5\u300C\u5E2E\u6211\u914D\u7F6E\u4E00\u4E0B Agent Team\u300D\u5C31\u591F\u4E86 \u2014\u2014 \u4E00\u4E2A\u6CA1\u8BFB\u8FC7\u8FD9\u4EFD
+\u5E2E\u52A9\u7684 agent,\u7B2C\u4E00\u6B65\u5FC5\u7136\u4F1A\u8DD1 \`larkway tasklist-init --help\`(\u5C31\u662F\u4F60\u6B63\u5728\u770B\u7684\u8FD9\u6BB5),
+\u4ECE\u8FD9\u91CC\u5C31\u80FD\u5B66\u4F1A\u600E\u4E48\u628A\u672C\u673A\u6240\u6709\u5DF2\u914D\u7F6E\u7684 bot \u90FD\u914D\u6210\u6E05\u5355\u6210\u5458,\u4E0D\u9700\u8981\u4F60\u518D\u624B\u52A8\u4F20\u4EFB\u4F55\u53C2\u6570\u3002
+
+\u96F6\u53C2\u6570\u4E09\u6B65 Quickstart:
+  1. (\u53EF\u9009)\u5148\u5728\u98DE\u4E66\u4EFB\u52A1\u4E2D\u5FC3\u624B\u52A8\u5EFA\u4E00\u4E2A\u6E05\u5355,\u540D\u5B57\u968F\u4FBF\u53D6,\u6BD4\u5982 "Agent Team"\u3002
+  2. \u8DD1:larkway tasklist-init
+     \u2014\u2014 \u4F1A\u81EA\u52A8:--team = \u672C\u673A bots/ \u76EE\u5F55\u4E0B\u5168\u90E8\u5DF2\u914D\u7F6E bot;--name = "Agent Team";
+     \u7528\u4F60\u7684 lark-cli \u7528\u6237\u8EAB\u4EFD\u6309\u540D\u5B57\u67E5\u4E00\u904D\u80FD\u770B\u5230\u7684\u6E05\u5355 \u2014\u2014 \u67E5\u5230\u540C\u540D\u7684\u5C31 adopt(\u628A\u8FD9\u4E9B
+     bot \u52A0\u4E3A editor);\u67E5\u4E0D\u5230(\u6216\u6CA1\u767B\u5F55/\u7F3A scope)\u5C31\u9759\u9ED8\u56DE\u9000\u5230\u65E7\u7684\u521B\u5EFA\u8DEF\u5F84(\u7528\u7B2C\u4E00\u4E2A
+     bot \u7684 app \u8EAB\u4EFD\u65B0\u5EFA\u4E00\u4E2A\u6E05\u5355,\u5E76\u81EA\u52A8\u628A\u4F60\u52A0\u4E3A owner)\u3002
+  3. \u53BB\u98DE\u4E66\u4EFB\u52A1\u4E2D\u5FC3\u786E\u8BA4\u8FD9\u4E2A\u6E05\u5355\u5728\u4F60\u7684\u5217\u8868\u91CC\u53EF\u89C1,\u4E4B\u540E\u53F3\u952E\u8BDD\u9898\u6D88\u606F\u9009"\u8F6C\u4EFB\u52A1"\u5373\u53EF\u3002
+
+\u4EE5\u4E0A\u5168\u90E8\u662F\u7F3A\u7701\u884C\u4E3A,\u4EE5\u4E0B flag \u4EC5\u7528\u4E8E\u8986\u76D6:
+
+  --team <bot1,bot2,\u2026>   \u663E\u5F0F\u6307\u5B9A\u8981\u52A0\u5165\u6E05\u5355\u7684 bot(\u9ED8\u8BA4 = \u5168\u90E8\u5DF2\u914D\u7F6E bot)
+  --name <\u6E05\u5355\u540D>          \u663E\u5F0F\u6307\u5B9A\u6E05\u5355\u540D(\u9ED8\u8BA4 "Agent Team"),\u4EC5\u5728\u81EA\u52A8/\u663E\u5F0F create
+                          \u8DEF\u5F84\u91CC\u751F\u6548;--adopt/--adopt-guid \u4F1A\u5FFD\u7565\u5B83,\u6309\u540D\u5B57/guid \u67E5
+  --adopt "<\u6E05\u5355\u540D>"       \u5F3A\u5236\u8D70 adopt \u6A21\u5F0F\u5E76\u7528\u8FD9\u4E2A\u540D\u5B57\u67E5\u627E\u2014\u2014\u67E5\u4E0D\u5230/\u67E5\u51FA\u591A\u4E2A\u90FD\u4F1A
+                          \u76F4\u63A5\u62A5\u9519\u9000\u51FA,\u4E0D\u4F1A\u9759\u9ED8\u56DE\u9000\u5230\u521B\u5EFA\u8DEF\u5F84(\u4F60\u5DF2\u7ECF\u660E\u786E\u8981 adopt\u4E86)
+  --adopt-guid <guid>     \u8DF3\u8FC7\u6309\u540D\u5B57\u67E5\u627E,\u76F4\u63A5 adopt \u8FD9\u4E2A guid \u7684\u6E05\u5355(\u5355\u72EC\u4F7F\u7528\u4E5F
+                          \u7B49\u4EF7\u4E8E\u5F3A\u5236 adopt \u6A21\u5F0F);\u591A\u4E2A\u540C\u540D\u6E05\u5355\u65F6\u7528\u5B83\u6D88\u6B67
+  --owner <open_id>       \u663E\u5F0F\u6307\u5B9A\u4EBA\u7C7B owner(\u4EC5\u521B\u5EFA\u8DEF\u5F84\u7528\u5230,adopt \u6A21\u5F0F\u4E0B\u4F60\u672C\u6765\u5C31\u662F
+                          owner,\u4E0D\u9700\u8981\u8FD9\u4E2A)
+  --force                 \u8986\u76D6\u5171\u4EAB\u6CE8\u518C\u6587\u4EF6\u91CC\u5DF2\u6709\u7684 guid(\u9ED8\u8BA4\u4E0D\u8986\u76D6,\u907F\u514D\u8BEF\u64CD\u4F5C\u628A
+                          \u6574\u4E2A\u56E2\u961F\u5207\u5230\u4E00\u4E2A\u65B0\u677F)
+
+\u2500\u2500 adopt \u6A21\u5F0F\u5185\u90E8\u6B65\u9AA4(\u81EA\u52A8\u9009\u4E2D,\u6216\u663E\u5F0F --adopt/--adopt-guid \u89E6\u53D1)\u2500\u2500
+  1. \u4EE5\u4F60(\u64CD\u4F5C\u8005)\u7684\u7528\u6237\u8EAB\u4EFD\u6309\u540D\u5B57\u7CBE\u786E\u5339\u914D\u4F60\u80FD\u770B\u5230\u7684\u6E05\u5355(\u91CD\u540D \u2192 \u62A5\u9519\u5217\u51FA\u5168\u90E8
+     guid,\u8BA9\u4F60\u52A0 --adopt-guid <guid> \u6D88\u6B67\u91CD\u8DD1;\u4E00\u4E2A\u90FD\u627E\u4E0D\u5230 \u2192 \u81EA\u52A8\u6A21\u5F0F\u4E0B\u9759\u9ED8\u56DE\u9000
+     \u521B\u5EFA\u8DEF\u5F84,\u663E\u5F0F --adopt \u4E0B\u62A5\u9519\u63D0\u793A\u5148\u53BB\u4EFB\u52A1\u4E2D\u5FC3\u5EFA\u4E00\u4E2A)
+  2. \u628A\u6BCF\u4E2A bot \u7684 app \u52A0\u4E3A\u6E05\u5355\u6210\u5458(role=editor,\u5E42\u7B49,\u5DF2\u662F\u6210\u5458\u7684\u8DF3\u8FC7/\u65E0\u5BB3\u91CD\u590D)
+  3. \u5199\u5165\u5171\u4EAB\u6CE8\u518C\u6587\u4EF6 <LARKWAY_HOME>/task-team.json(\u4E0E\u521B\u5EFA\u8DEF\u5F84\u540C\u4E00\u5957
+     first-writer-wins / --force \u8986\u76D6\u8BED\u4E49)
+  4. \u8BFB\u56DE\u6210\u5458\u5217\u8868,\u6838\u5B9E\u6BCF\u4E2A bot \u771F\u7684\u52A0\u5165\u6210\u529F
+
+\u524D\u7F6E\u6761\u4EF6(\u4EC5 adopt \u9700\u8981):\u8FD9\u4E2A profile \u5FC5\u987B\u5DF2\u7ECF\u7528**\u7528\u6237\u8EAB\u4EFD**\u767B\u5F55\u8FC7 lark-cli \u4E14
+\u7533\u8BF7\u4E86 task \u57DF\u6743\u9650:
+  lark-cli auth login --profile <profile> --domain task
+(\u7528\u54EA\u4E2A profile:\u7B2C\u4E00\u4E2A\u56E2\u961F bot \u7684 lark_cli_profile,\u7F3A\u7701\u65F6\u7528\u5B83\u7684 app_id)\u3002
+\u6CA1\u6709\u4E8B\u5148\u767B\u5F55/\u7F3A scope \u4F1A\u5728 adopt \u6B65\u9AA4 1 \u62A5\u9519,\u62A5\u9519\u4FE1\u606F\u4F1A\u5E26\u4E0A\u9762\u8FD9\u6761\u547D\u4EE4\u4F5C\u4E3A\u63D0\u793A\u3002
+
+\u2500\u2500 \u521B\u5EFA\u8DEF\u5F84\u5185\u90E8\u6B65\u9AA4(\u81EA\u52A8\u56DE\u9000,\u6216\u672A\u5339\u914D\u5230\u540C\u540D\u6E05\u5355\u65F6\u89E6\u53D1)\u2500\u2500
+  1. \u5148\u67E5\u5171\u4EAB\u6CE8\u518C\u6587\u4EF6:\u5DF2\u6709 guid \u4E14\u672A\u4F20 --force \u2192 \u590D\u7528;\u5426\u5219\u5EFA\u4E00\u4E2A\u65B0\u6E05\u5355
+  2. \u628A\u4F60(owner)\u52A0\u4E3A\u4EBA\u7C7B\u6210\u5458(role=editor)\u2014\u2014 \u5426\u5219\u4F60\u5728\u98DE\u4E66\u4EFB\u52A1\u4E2D\u5FC3\u770B\u4E0D\u5230\u8FD9\u4E2A\u6E05\u5355
+  3. \u628A\u6BCF\u4E2A bot \u7684 app \u90FD\u52A0\u4E3A\u6E05\u5355\u6210\u5458(role=editor)
+  4. \u8BFB\u56DE\u6210\u5458\u5217\u8868,\u82E5 owner \u672A\u6210\u529F\u52A0\u5165\u4F1A\u6253\u5370\u4E00\u6761 warning(\u4E0D\u4F1A\u8BA9\u547D\u4EE4\u5931\u8D25)
+  5. (\u4EC5\u65B0\u5EFA\u65F6)\u628A guid \u5199\u8FDB\u5171\u4EAB\u6CE8\u518C\u6587\u4EF6
+
+owner open_id \u89E3\u6790\u987A\u5E8F(\u4EC5\u521B\u5EFA\u8DEF\u5F84\u7528\u5230):\u663E\u5F0F --owner \u4F18\u5148;\u7701\u7565\u65F6\u5C1D\u8BD5\u4ECE lark-cli
+\u5F53\u524D\u767B\u5F55\u7684\u7528\u6237\u8EAB\u4EFD\u81EA\u52A8\u89E3\u6790(\u9700\u8981\u4F60\u4E4B\u524D\u5BF9\u8BE5 profile \u8DD1\u8FC7 \`lark-cli auth login\`);
+\u4E24\u8005\u90FD\u62FF\u4E0D\u5230\u4F1A\u76F4\u63A5\u62A5\u9519\u9000\u51FA,\u4E0D\u5EFA/\u4E0D\u52A8\u4EFB\u4F55\u6E05\u5355\u3002
+
+\u4E0D\u4F1A\u628A\u4EFB\u4F55\u7FA4\u52A0\u4E3A\u6210\u5458 \u2014\u2014 v2 \u6E05\u5355\u9ED8\u8BA4\u53EA\u5BF9 owner \u79C1\u6709;\u5206\u4EAB\u7ED9\u540C\u4E8B\u770B,\u8981\u7ED9 editor \u6743\u9650
+\u5BF9\u65B9\u624D\u80FD\u628A\u8BDD\u9898\u8F6C\u4EFB\u52A1\u8FDB\u6765,\u7ED9 viewer \u53EA\u80FD\u770B\u4E0D\u80FD\u8F6C(\u89C1 docs/task-handle.md \xA75.3)\u3002
+
+\u5168\u7A0B\u975E\u4EA4\u4E92:\u4EFB\u4F55\u6B67\u4E49\u90FD\u76F4\u63A5\u975E\u96F6\u9000\u51FA\u5E76\u628A\u5019\u9009 + \u4E0B\u4E00\u6B65\u6307\u5F15\u6253\u5230 stderr,\u4E0D\u4F1A\u5F39\u4EFB\u4F55
+\u4EA4\u4E92\u5F0F\u95EE\u9898(\u8FD9\u4E2A\u547D\u4EE4\u672C\u6765\u5C31\u8BBE\u8BA1\u7ED9 agent \u5728 headless \u73AF\u5883\u91CC\u8DD1)\u3002
+
+\u26A0\uFE0F \u9996\u6B21\u8DD1\u5B8C\u540E,\u8BF7\u5728\u98DE\u4E66\u4EFB\u52A1\u4E2D\u5FC3\u786E\u8BA4\u8FD9\u4E2A\u6E05\u5355\u786E\u5B9E\u53EF\u89C1(\u89C1 docs/task-handle.md \xA77 \u2014
+\u672C\u5B9E\u73B0\u65E0\u6CD5\u5728\u65E0\u7F51\u7EDC\u73AF\u5883\u4E0B\u7AEF\u5230\u7AEF\u9A8C\u8BC1 editor \u6210\u5458\u7684\u53EF\u89C1\u6027,\u7559\u7ED9\u8FD9\u4E00\u6B65\u4EBA\u5DE5\u786E\u8BA4)\u3002
+
+\u793A\u4F8B:
+  larkway tasklist-init
+  larkway tasklist-init --adopt "Agent Team"
+  larkway tasklist-init --adopt "Agent Team" --adopt-guid abc-123-guid
+  larkway tasklist-init --team larkway-devops,larkway-marketing --name "Agent Team"
+  larkway tasklist-init --team larkway-devops --owner ou_1234567890abcdef
+  larkway tasklist-init --team larkway-devops --force`;
+async function run10(ctx, args) {
+  if (args.includes("help")) {
+    ctx.ui.print(USAGE2);
+    return 0;
+  }
+  const { team, name, owner: explicitOwner, force, adopt, adoptGuid: explicitAdoptGuid } = parseArgs2(args);
+  let team_ = team;
+  if (team_.length === 0) {
+    team_ = await ctx.botsStore.listBots();
+    if (team_.length === 0) {
+      const msg = "\u672C\u673A\u6CA1\u6709\u914D\u7F6E\u4EFB\u4F55 bot\u3002\u5148\u8FD0\u884C `larkway bot add` \u6DFB\u52A0\u81F3\u5C11\u4E00\u4E2A bot,\u518D\u91CD\u8DD1\u8FD9\u4E2A\u547D\u4EE4\u3002";
+      if (ctx.flags.json) ctx.ui.emitJson({ ok: false, error: msg });
+      else {
+        ctx.ui.failure(msg);
+        ctx.ui.print(USAGE2);
+      }
+      return 1;
+    }
+  }
+  const bots = [];
+  for (const botId of team_) {
+    let bot;
+    try {
+      bot = await ctx.botsStore.readBot(botId);
+    } catch (err2) {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
+      if (ctx.flags.json) ctx.ui.emitJson({ ok: false, error: msg });
+      else ctx.ui.failure(msg);
+      return 1;
+    }
+    const appSecret = await ctx.hostConfig.readSecret(bot.app_secret_env);
+    if (!appSecret) {
+      const msg = `Bot "${botId}" \u7684 app_secret_env "${bot.app_secret_env}" \u5728 ~/.larkway/.env \u4E2D\u672A\u8BBE\u7F6E\u3002`;
+      if (ctx.flags.json) ctx.ui.emitJson({ ok: false, error: msg });
+      else ctx.ui.failure(msg);
+      return 1;
+    }
+    bots.push({ id: bot.id, app_id: bot.app_id, appSecret, lark_cli_profile: bot.lark_cli_profile });
+  }
+  const creator = bots[0];
+  const creatorProfile = deriveLarkCliProfile(creator.lark_cli_profile, creator.app_id);
+  const loginHint = `lark-cli auth login --profile ${creatorProfile} --domain task`;
+  if (adopt !== void 0 || explicitAdoptGuid !== void 0) {
+    const adoptName = adopt ?? name;
+    if (adoptName.trim().length === 0) {
+      const msg = '--adopt \u9700\u8981\u4E00\u4E2A\u975E\u7A7A\u7684\u6E05\u5355\u540D\u5B57,\u4F8B\u5982 --adopt "Agent Team"\u3002';
+      if (ctx.flags.json) ctx.ui.emitJson({ ok: false, error: msg });
+      else {
+        ctx.ui.failure(msg);
+        ctx.ui.print(USAGE2);
+      }
+      return 1;
+    }
+    const target = resolveAdoptTarget(creatorProfile, adoptName, explicitAdoptGuid, loginHint);
+    if (!target.ok) {
+      if (ctx.flags.json) ctx.ui.emitJson({ ok: false, error: target.message });
+      else {
+        ctx.ui.failure(target.message);
+        if (target.reason === "list-failed") ctx.ui.print(USAGE2);
+      }
+      return 1;
+    }
+    return runAdoptWithGuid(ctx, {
+      guid: target.guid,
+      matchedName: target.matchedName,
+      bots,
+      force,
+      creatorProfile,
+      loginHint
+    });
+  }
+  const autoTarget = resolveAdoptTarget(creatorProfile, name, void 0, loginHint);
+  if (autoTarget.ok) {
+    return runAdoptWithGuid(ctx, {
+      guid: autoTarget.guid,
+      matchedName: autoTarget.matchedName,
+      bots,
+      force,
+      creatorProfile,
+      loginHint
+    });
+  }
+  if (autoTarget.reason === "ambiguous") {
+    if (ctx.flags.json) ctx.ui.emitJson({ ok: false, error: autoTarget.message });
+    else ctx.ui.failure(autoTarget.message);
+    return 1;
+  }
+  if (!ctx.flags.json) {
+    const why = autoTarget.reason === "list-failed" ? "\u65E0\u6CD5\u4EE5\u4F60\u7684\u7528\u6237\u8EAB\u4EFD\u67E5\u8BE2\u6E05\u5355" : `\u6CA1\u627E\u5230\u540C\u540D\u6E05\u5355 "${name}"`;
+    ctx.ui.print(ctx.ui.dim(`(${why},\u56DE\u9000\u5230\u7528 bot app \u8EAB\u4EFD\u521B\u5EFA/\u590D\u7528\u6E05\u5355\u2014\u2014\u5982\u9700\u5F3A\u5236 adopt \u89C1 --adopt)`));
+  }
+  const ownerOpenId = explicitOwner ?? resolveOwnerOpenId(creatorProfile);
+  if (!ownerOpenId) {
+    const msg = `\u65E0\u6CD5\u786E\u5B9A\u6E05\u5355\u7684\u4EBA\u7C7B owner:\u672A\u4F20 --owner,\u4E14\u65E0\u6CD5\u4ECE lark-cli \u5F53\u524D\u767B\u5F55\u7684\u7528\u6237\u8EAB\u4EFD\u81EA\u52A8\u89E3\u6790(\u5C1D\u8BD5\u7684 profile: "${creatorProfile}")\u3002\u8BF7\u663E\u5F0F\u4F20\u5165 --owner <open_id>(\u53EF\u7528 \`lark-cli auth status --profile ${creatorProfile} --json\` \u67E5\u770B\u662F\u5426\u5DF2\u767B\u5F55\u7528\u6237\u8EAB\u4EFD,\u6216\u7528 lark-cli contact \u6309\u59D3\u540D/\u90AE\u7BB1\u67E5 open_id)\u3002\u4E0D\u4F1A\u5EFA/\u4E0D\u4F1A\u52A8\u4EFB\u4F55\u6E05\u5355\u3002`;
+    if (ctx.flags.json) ctx.ui.emitJson({ ok: false, error: msg });
+    else {
+      ctx.ui.failure(msg);
+      ctx.ui.print(USAGE2);
+    }
+    return 1;
+  }
+  const sdkClient = new import_node_sdk2.Client({ appId: creator.app_id, appSecret: creator.appSecret });
+  const requester = {
+    request: (config) => sdkClient.request(config)
+  };
+  const taskClient = new TaskListClient(requester);
+  const members = [
+    { id: ownerOpenId, type: "user", role: "editor" },
+    ...bots.map((b) => ({ id: b.app_id, type: "app", role: "editor" }))
+  ];
+  const registryPath = resolveTaskTeamRegistryPath();
+  const existingGuid = await readTeamTasklistGuid(registryPath);
+  let tasklistGuid;
+  let reused;
+  if (existingGuid && !force) {
+    tasklistGuid = existingGuid;
+    reused = true;
+    try {
+      await taskClient.addTasklistMembers(tasklistGuid, members);
+    } catch (err2) {
+      const msg = `\u590D\u7528\u5DF2\u6709\u6E05\u5355 ${tasklistGuid} \u65F6\u8865\u5145\u6210\u5458\u5931\u8D25: ${err2 instanceof Error ? err2.message : String(err2)}`;
+      if (ctx.flags.json) ctx.ui.emitJson({ ok: false, error: msg });
+      else {
+        ctx.ui.failure(msg);
+        ctx.ui.print("\u5E38\u89C1\u539F\u56E0:app \u672A\u5728\u5F00\u653E\u5E73\u53F0\u540E\u53F0\u52FE\u9009 task:tasklist:write / task:task:write scope(\u89C1 docs/task-handle.md \xA77)\u3002");
+      }
+      return 1;
+    }
+  } else {
+    reused = false;
+    try {
+      const created = await taskClient.createTasklist(name, members);
+      tasklistGuid = created.guid;
+    } catch (err2) {
+      const msg = `\u5EFA\u6E05\u5355\u5931\u8D25: ${err2 instanceof Error ? err2.message : String(err2)}`;
+      if (ctx.flags.json) ctx.ui.emitJson({ ok: false, error: msg });
+      else {
+        ctx.ui.failure(msg);
+        ctx.ui.print("\u5E38\u89C1\u539F\u56E0:app \u672A\u5728\u5F00\u653E\u5E73\u53F0\u540E\u53F0\u52FE\u9009 task:tasklist:write / task:task:write scope(\u89C1 docs/task-handle.md \xA77)\u3002");
+      }
+      return 1;
+    }
+    if (force && existingGuid) {
+      await overwriteTeamTasklistGuid(registryPath, tasklistGuid);
+    } else {
+      await claimTeamTasklistGuid(registryPath, tasklistGuid);
+    }
+  }
+  let ownerConfirmedMember;
+  let membershipCheckError;
+  try {
+    const snapshot = await taskClient.getTasklist(tasklistGuid);
+    ownerConfirmedMember = snapshot?.members.some((m) => m.id === ownerOpenId) ?? void 0;
+  } catch (err2) {
+    membershipCheckError = err2 instanceof Error ? err2.message : String(err2);
+  }
+  if (ctx.flags.json) {
+    ctx.ui.emitJson({
+      ok: true,
+      team: team_,
+      name,
+      ownerOpenId,
+      tasklistGuid,
+      reused,
+      ownerConfirmedMember: ownerConfirmedMember ?? null,
+      membershipCheckError: membershipCheckError ?? null
+    });
+    return 0;
+  }
+  if (ownerConfirmedMember === false) {
+    ctx.ui.warning(
+      `owner(${ownerOpenId})\u672A\u51FA\u73B0\u5728\u6E05\u5355 ${tasklistGuid} \u7684\u6210\u5458\u5217\u8868\u91CC\u2014\u2014\u53EF\u80FD\u88AB\u9759\u9ED8\u4E22\u5F03,owner \u5927\u6982\u7387\u770B\u4E0D\u5230\u8FD9\u4E2A\u677F\u3002\u8BF7\u68C0\u67E5 open_id \u662F\u5426\u6B63\u786E\u3001\u662F\u5426\u8DE8\u79DF\u6237,\u6216\u624B\u52A8\u5728\u98DE\u4E66\u4EFB\u52A1\u4E2D\u5FC3\u628A owner \u52A0\u4E3A\u8BE5\u6E05\u5355\u6210\u5458\u3002`
+    );
+  } else if (membershipCheckError) {
+    ctx.ui.warning(
+      `\u65E0\u6CD5\u8BFB\u56DE\u6E05\u5355 ${tasklistGuid} \u7684\u6210\u5458\u5217\u8868\u4EE5\u6838\u5B9E owner \u662F\u5426\u52A0\u5165\u6210\u529F(\u7EE7\u7EED,\u4E0D\u5F71\u54CD\u672C\u6B21\u7ED3\u679C): ${membershipCheckError}`
+    );
+  }
+  if (reused) {
+    ctx.ui.success(`\u590D\u7528\u5DF2\u6709\u6E05\u5355: ${tasklistGuid}`);
+  } else {
+    ctx.ui.success(`\u6E05\u5355 "${name}" \u5DF2\u521B\u5EFA: ${tasklistGuid}`);
+  }
+  ctx.ui.print(`owner \u6210\u5458: ${ownerOpenId}${explicitOwner ? "" : "(\u4ECE lark-cli \u5F53\u524D\u767B\u5F55\u7528\u6237\u81EA\u52A8\u89E3\u6790)"}`);
+  ctx.ui.print(`\u5DF2\u52A0\u5165\u6210\u5458(editor): ${bots.map((b) => b.id).join(", ")}`);
+  ctx.ui.print("");
+  if (!reused) {
+    ctx.ui.print(
+      `\u5DF2\u5199\u5165\u5171\u4EAB\u6CE8\u518C\u6587\u4EF6 ${registryPath} \u2014\u2014 \u56E2\u961F\u91CC\u7684 bot \u4E0B\u6B21\u91CD\u542F\u4F1A\u81EA\u52A8\u53D1\u73B0\u5E76\u4F7F\u7528\u8FD9\u4E2A guid,\u4E0D\u9700\u8981\u624B\u5DE5\u6539 yaml\u3002`
+    );
+    ctx.ui.print("");
+  }
+  ctx.ui.print(
+    ctx.ui.bold("\u53EF\u9009:") + " \u5982\u679C\u60F3\u56FA\u5B9A\u7ED1\u5B9A\u3001\u4E0D\u4F9D\u8D56\u5171\u4EAB\u6CE8\u518C\u6587\u4EF6\u7684\u81EA\u52A8\u53D1\u73B0,\u4E5F\u53EF\u4EE5\u628A guid \u624B\u5199\u8FDB\u5404 bot \u7684 bots/<id>.yaml:"
+  );
+  ctx.ui.print(`  taskHandle:`);
+  ctx.ui.print(`    tasklistGuid: "${tasklistGuid}"`);
+  ctx.ui.print("");
+  ctx.ui.print(
+    ctx.ui.bold("\u26A0\uFE0F \u8BF7\u624B\u52A8\u786E\u8BA4:") + " \u53BB\u98DE\u4E66\u4EFB\u52A1\u4E2D\u5FC3\u786E\u8BA4\u8FD9\u4E2A\u6E05\u5355\u786E\u5B9E\u53EF\u89C1(\u89C1 docs/task-handle.md \xA77)\u3002"
+  );
+  return 0;
+}
+function resolveAdoptTarget(creatorProfile, name, explicitGuid, loginHint) {
+  if (explicitGuid) {
+    return { ok: true, guid: explicitGuid, matchedName: name };
+  }
+  const listResult = listUserTasklists(creatorProfile);
+  if (!listResult.ok) {
+    return {
+      ok: false,
+      reason: "list-failed",
+      message: `\u65E0\u6CD5\u4EE5\u4F60\u7684\u7528\u6237\u8EAB\u4EFD\u5217\u51FA\u6E05\u5355:${listResult.error}
+
+\u8BF7\u5148\u786E\u8BA4\u5DF2\u7528\u8FD9\u4E2A profile \u767B\u5F55\u8FC7\u7528\u6237\u8EAB\u4EFD\u3001\u4E14\u7533\u8BF7\u4E86 task \u57DF\u6743\u9650:
+  ${loginHint}
+(\u53EF\u7528 \`lark-cli auth status --profile ${creatorProfile} --json\` \u68C0\u67E5\u5F53\u524D\u72B6\u6001)`
+    };
+  }
+  const matches = listResult.data.filter((t) => t.name === name);
+  if (matches.length === 0) {
+    return {
+      ok: false,
+      reason: "not-found",
+      message: `\u5728\u4F60\u80FD\u770B\u5230\u7684\u6E05\u5355\u91CC\u6CA1\u627E\u5230\u540D\u4E3A "${name}" \u7684\u6E05\u5355\u3002\u8BF7\u5148\u53BB\u98DE\u4E66\u4EFB\u52A1\u4E2D\u5FC3\u65B0\u5EFA\u4E00\u4E2A\u540C\u540D\u6E05\u5355,\u518D\u91CD\u8DD1\u8FD9\u4E2A\u547D\u4EE4;\u6216\u8005\u68C0\u67E5\u540D\u5B57\u662F\u5426\u5B8C\u5168\u4E00\u81F4(\u6CE8\u610F\u5168\u534A\u89D2\u5B57\u7B26\u3001\u591A\u4F59\u7A7A\u683C)\u3002`
+    };
+  }
+  if (matches.length > 1) {
+    return {
+      ok: false,
+      reason: "ambiguous",
+      message: `\u627E\u5230 ${matches.length} \u4E2A\u540C\u540D\u6E05\u5355 "${name}",\u65E0\u6CD5\u786E\u5B9A\u8981 adopt \u54EA\u4E00\u4E2A:
+` + matches.map((t) => `  - ${t.guid}`).join("\n") + "\n\u8BF7\u52A0 --adopt-guid <guid> \u663E\u5F0F\u6307\u5B9A\u5176\u4E2D\u4E00\u4E2A\u91CD\u8DD1,\u6216\u53BB\u98DE\u4E66\u4EFB\u52A1\u4E2D\u5FC3\u628A\u5176\u4E2D\u4E00\u4E2A\u6539\u540D\u540E\u518D\u91CD\u8DD1\u3002",
+      matches
+    };
+  }
+  return { ok: true, guid: matches[0].guid, matchedName: matches[0].name };
+}
+async function runAdoptWithGuid(ctx, opts) {
+  const { guid: tasklistGuid, matchedName, bots, force, creatorProfile, loginHint } = opts;
+  const members = bots.map((b) => ({ id: b.app_id, type: "app", role: "editor" }));
+  const addResult = addTasklistMembersAsUser(creatorProfile, tasklistGuid, members);
+  if (!addResult.ok) {
+    const msg = `\u628A bot app \u52A0\u4E3A\u6E05\u5355 ${tasklistGuid} \u7684 editor \u5931\u8D25:${addResult.error}
+
+\u5E38\u89C1\u539F\u56E0:\u8FD9\u4E2A profile \u7684\u7528\u6237\u8EAB\u4EFD\u7F3A task:tasklist:write scope \u2014\u2014 \u91CD\u65B0\u767B\u5F55\u5E76\u7533\u8BF7 task \u57DF\u6743\u9650:
+  ${loginHint}`;
+    if (ctx.flags.json) ctx.ui.emitJson({ ok: false, error: msg });
+    else ctx.ui.failure(msg);
+    return 1;
+  }
+  const registryPath = resolveTaskTeamRegistryPath();
+  let registeredGuid;
+  if (force) {
+    await overwriteTeamTasklistGuid(registryPath, tasklistGuid);
+    registeredGuid = tasklistGuid;
+  } else {
+    registeredGuid = await claimTeamTasklistGuid(registryPath, tasklistGuid);
+  }
+  const registryMismatch = registeredGuid !== tasklistGuid;
+  const membersResult = getUserTasklistMembers(creatorProfile, tasklistGuid);
+  const missingBots = [];
+  let membershipCheckError;
+  if (membersResult.ok) {
+    for (const b of bots) {
+      if (!membersResult.data.some((m) => m.id === b.app_id)) missingBots.push(b.id);
+    }
+  } else {
+    membershipCheckError = membersResult.error;
+  }
+  if (ctx.flags.json) {
+    ctx.ui.emitJson({
+      ok: true,
+      mode: "adopt",
+      adoptedName: matchedName,
+      tasklistGuid,
+      addedMembers: bots.map((b) => b.id),
+      missingBots,
+      membershipCheckError: membershipCheckError ?? null,
+      registeredGuid,
+      registryMismatch
+    });
+    return 0;
+  }
+  ctx.ui.success(`\u5DF2 adopt \u6E05\u5355 "${matchedName}": ${tasklistGuid}`);
+  ctx.ui.print(`\u5DF2\u52A0\u5165\u6210\u5458(editor): ${bots.map((b) => b.id).join(", ")}`);
+  ctx.ui.print("");
+  if (missingBots.length > 0) {
+    ctx.ui.warning(
+      `\u4EE5\u4E0B bot \u7684 app \u672A\u51FA\u73B0\u5728\u6E05\u5355\u6210\u5458\u5217\u8868\u91CC\u2014\u2014\u53EF\u80FD\u88AB\u9759\u9ED8\u4E22\u5F03:${missingBots.join(", ")}\u3002\u8BF7\u68C0\u67E5 app_id \u662F\u5426\u6B63\u786E,\u6216\u624B\u52A8\u5728\u98DE\u4E66\u4EFB\u52A1\u4E2D\u5FC3\u628A\u5B83\u4EEC\u52A0\u4E3A\u8BE5\u6E05\u5355\u7684 editor\u3002`
+    );
+  } else if (membershipCheckError) {
+    ctx.ui.warning(`\u65E0\u6CD5\u8BFB\u56DE\u6E05\u5355 ${tasklistGuid} \u7684\u6210\u5458\u5217\u8868\u4EE5\u6838\u5B9E\u662F\u5426\u52A0\u5165\u6210\u529F(\u7EE7\u7EED,\u4E0D\u5F71\u54CD\u672C\u6B21\u7ED3\u679C): ${membershipCheckError}`);
+  }
+  if (registryMismatch) {
+    ctx.ui.warning(
+      `\u5171\u4EAB\u6CE8\u518C\u6587\u4EF6\u91CC\u5DF2\u7ECF\u7ED1\u5B9A\u4E86\u53E6\u4E00\u4E2A\u6E05\u5355(${registeredGuid}),\u8FD9\u6B21 adopt \u7684\u6E05\u5355(${tasklistGuid})\u672A\u5199\u5165\u5171\u4EAB\u6CE8\u518C\u6587\u4EF6\u2014\u2014\u907F\u514D\u7834\u574F\u73B0\u6709\u56E2\u961F\u7ED1\u5B9A\u3002\u5982\u679C\u786E\u5B9E\u60F3\u5207\u6362\u5230\u8FD9\u4E2A\u65B0\u6E05\u5355,\u52A0 --force \u91CD\u8DD1\u3002`
+    );
+  } else {
+    ctx.ui.print(
+      `\u5DF2\u5199\u5165\u5171\u4EAB\u6CE8\u518C\u6587\u4EF6 ${registryPath} \u2014\u2014 \u56E2\u961F\u91CC\u7684 bot \u4E0B\u6B21\u91CD\u542F\u4F1A\u81EA\u52A8\u53D1\u73B0\u5E76\u4F7F\u7528\u8FD9\u4E2A guid,\u4E0D\u9700\u8981\u624B\u5DE5\u6539 yaml\u3002`
+    );
+  }
+  ctx.ui.print("");
+  ctx.ui.print(
+    ctx.ui.bold("\u53EF\u9009:") + " \u5982\u679C\u60F3\u56FA\u5B9A\u7ED1\u5B9A\u3001\u4E0D\u4F9D\u8D56\u5171\u4EAB\u6CE8\u518C\u6587\u4EF6\u7684\u81EA\u52A8\u53D1\u73B0,\u4E5F\u53EF\u4EE5\u628A guid \u624B\u5199\u8FDB\u5404 bot \u7684 bots/<id>.yaml:"
+  );
+  ctx.ui.print(`  taskHandle:`);
+  ctx.ui.print(`    tasklistGuid: "${tasklistGuid}"`);
+  return 0;
+}
+
 // src/cli/index.ts
 var _require2 = createRequire3(import.meta.url);
 var _pkg = _require2("../../package.json");
@@ -131140,9 +133195,10 @@ var COMMANDS = {
   logs: run6,
   update: run7,
   dogfood: run9,
-  ui: run8
+  ui: run8,
+  "tasklist-init": run10
 };
-var USAGE2 = `larkway \u2014 Feishu \u2194 local CLI agent bridge host manager
+var USAGE3 = `larkway \u2014 Feishu \u2194 local CLI agent bridge host manager
 
 \u7528\u6CD5:
   larkway                \u76F4\u63A5\u6253\u5F00\u7F51\u9875\u7BA1\u7406\u9762(\u63A8\u8350 \u2014\u2014 \u626B\u7801\u7ED1\u5B9A + \u914D\u7F6E\u5168\u5728\u6D4F\u89C8\u5668\u91CC\u70B9\u70B9\u70B9)
@@ -131158,6 +133214,7 @@ var USAGE2 = `larkway \u2014 Feishu \u2194 local CLI agent bridge host manager
   update                 pull + install + restart
   dogfood preflight|guide [id] v0.3 Phase 1 dogfood \u524D\u7F6E\u9A8C\u6536 / \u4E0B\u4E00\u6B65\u6307\u5F15
   ui                     \u542F\u52A8\u8F7B\u91CF Web UI \u7BA1\u7406\u9762(127.0.0.1 + token)
+  tasklist-init          \u4E3A\u8BDD\u9898\u2194\u4EFB\u52A1\u53E5\u67C4 feature provisioning \u5171\u4EAB\u6E05\u5355(docs/task-handle.md)
 
 \u5168\u5C40 flags:
   --json                 \u673A\u5668\u53EF\u8BFB\u8F93\u51FA(\u4E0E\u5176\u4ED6 flag \u6B63\u4EA4)
@@ -131222,29 +133279,32 @@ async function main(argv) {
     return 0;
   }
   if (help) {
-    print(USAGE2);
+    if (command === "tasklist-init") {
+      return run10(buildContext(flags), ["help"]);
+    }
+    print(USAGE3);
     return 0;
   }
   if (command === void 0) {
     if (flags.json || flags.nonInteractive) {
-      print(USAGE2);
+      print(USAGE3);
       return 1;
     }
     print("\u542F\u52A8\u7F51\u9875\u7BA1\u7406\u9762\u2026(\u9996\u6B21\u4F7F\u7528:\u5728\u6D4F\u89C8\u5668\u91CC\u626B\u7801\u7ED1\u5B9A + \u914D\u7F6E,\u5168\u7A0B\u70B9\u70B9\u70B9)");
     print(dim("\u65E0\u6D4F\u89C8\u5668 / \u670D\u52A1\u5668\u573A\u666F\u8BF7\u6539\u7528 `larkway init`(CLI \u5411\u5BFC)\u3002"));
     return run8(buildContext(flags), []);
   }
-  const run10 = COMMANDS[command];
-  if (!run10) {
+  const run11 = COMMANDS[command];
+  if (!run11) {
     failure(`\u672A\u77E5\u547D\u4EE4: ${command}`);
     print("");
-    print(USAGE2);
+    print(USAGE3);
     return 1;
   }
   const ctx = buildContext(flags);
   const isLifecycle = command === "start" || command === "stop" || command === "status" || command === "logs";
   const runArgs = isLifecycle ? [command, ...args] : args;
-  return run10(ctx, runArgs);
+  return run11(ctx, runArgs);
 }
 main(process4.argv.slice(2)).then((code) => process4.exit(code)).catch((e) => {
   const message = e instanceof Error ? e.message : String(e);