@clawos-dev/clawd 0.2.269 → 0.2.271

package/dist/cli.cjs

@@ -450,8 +450,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path76, errorMaps, issueData } = params;
-      const fullPath = [...path76, ...issueData.path || []];
+      const { data, path: path77, errorMaps, issueData } = params;
+      const fullPath = [...path77, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -762,11 +762,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path76, key) {
+      constructor(parent, value, path77, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path76;
+        this._path = path77;
         this._key = key;
       }
       get path() {
@@ -4149,6 +4149,1626 @@ var init_zod = __esm({
   }
 });
 
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Options.js
+var ignoreOverride, defaultOptions, getDefaultOptions;
+var init_Options = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Options.js"() {
+    "use strict";
+    ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
+    defaultOptions = {
+      name: void 0,
+      $refStrategy: "root",
+      basePath: ["#"],
+      effectStrategy: "input",
+      pipeStrategy: "all",
+      dateStrategy: "format:date-time",
+      mapStrategy: "entries",
+      removeAdditionalStrategy: "passthrough",
+      allowedAdditionalProperties: true,
+      rejectedAdditionalProperties: false,
+      definitionPath: "definitions",
+      target: "jsonSchema7",
+      strictUnions: false,
+      definitions: {},
+      errorMessages: false,
+      markdownDescription: false,
+      patternStrategy: "escape",
+      applyRegexFlags: false,
+      emailStrategy: "format:email",
+      base64Strategy: "contentEncoding:base64",
+      nameStrategy: "ref",
+      openAiAnyTypeName: "OpenAiAnyType"
+    };
+    getDefaultOptions = (options) => typeof options === "string" ? {
+      ...defaultOptions,
+      name: options
+    } : {
+      ...defaultOptions,
+      ...options
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Refs.js
+var getRefs;
+var init_Refs = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Refs.js"() {
+    "use strict";
+    init_Options();
+    getRefs = (options) => {
+      const _options = getDefaultOptions(options);
+      const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+      return {
+        ..._options,
+        flags: { hasReferencedOpenAiAnyType: false },
+        currentPath,
+        propertyPath: void 0,
+        seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+          def._def,
+          {
+            def: def._def,
+            path: [..._options.basePath, _options.definitionPath, name],
+            // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+            jsonSchema: void 0
+          }
+        ]))
+      };
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+function addErrorMessage(res, key, errorMessage, refs) {
+  if (!refs?.errorMessages)
+    return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage
+    };
+  }
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}
+var init_errorMessages = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/errorMessages.js"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
+var getRelativePath;
+var init_getRelativePath = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js"() {
+    "use strict";
+    getRelativePath = (pathA, pathB) => {
+      let i = 0;
+      for (; i < pathA.length && i < pathB.length; i++) {
+        if (pathA[i] !== pathB[i])
+          break;
+      }
+      return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/index.js
+var init_v3 = __esm({
+  "../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/index.js"() {
+    "use strict";
+    init_external();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+function parseAnyDef(refs) {
+  if (refs.target !== "openAi") {
+    return {};
+  }
+  const anyDefinitionPath = [
+    ...refs.basePath,
+    refs.definitionPath,
+    refs.openAiAnyTypeName
+  ];
+  refs.flags.hasReferencedOpenAiAnyType = true;
+  return {
+    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+  };
+}
+var init_any = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/any.js"() {
+    "use strict";
+    init_getRelativePath();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+function parseArrayDef(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}
+var init_array = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/array.js"() {
+    "use strict";
+    init_v3();
+    init_errorMessages();
+    init_parseDef();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+function parseBigintDef(def, refs) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+var init_bigint = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js"() {
+    "use strict";
+    init_errorMessages();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+function parseBooleanDef() {
+  return {
+    type: "boolean"
+  };
+}
+var init_boolean = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+var init_branded = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js"() {
+    "use strict";
+    init_parseDef();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+var parseCatchDef;
+var init_catch = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js"() {
+    "use strict";
+    init_parseDef();
+    parseCatchDef = (def, refs) => {
+      return parseDef(def.innerType._def, refs);
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+    };
+  }
+  switch (strategy) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return integerDateParser(def, refs);
+  }
+}
+var integerDateParser;
+var init_date = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/date.js"() {
+    "use strict";
+    init_errorMessages();
+    integerDateParser = (def, refs) => {
+      const res = {
+        type: "integer",
+        format: "unix-time"
+      };
+      if (refs.target === "openApi3") {
+        return res;
+      }
+      for (const check of def.checks) {
+        switch (check.kind) {
+          case "min":
+            setResponseValueAndErrors(
+              res,
+              "minimum",
+              check.value,
+              // This is in milliseconds
+              check.message,
+              refs
+            );
+            break;
+          case "max":
+            setResponseValueAndErrors(
+              res,
+              "maximum",
+              check.value,
+              // This is in milliseconds
+              check.message,
+              refs
+            );
+            break;
+        }
+      }
+      return res;
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+var init_default = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/default.js"() {
+    "use strict";
+    init_parseDef();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
+}
+var init_effects = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js"() {
+    "use strict";
+    init_parseDef();
+    init_any();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+var init_enum = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+function parseIntersectionDef(def, refs) {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "1"]
+    })
+  ].filter((x) => !!x);
+  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === void 0) {
+        unevaluatedProperties = void 0;
+      }
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      } else {
+        unevaluatedProperties = void 0;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? {
+    allOf: mergedAllOf,
+    ...unevaluatedProperties
+  } : void 0;
+}
+var isJsonSchema7AllOfType;
+var init_intersection = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js"() {
+    "use strict";
+    init_parseDef();
+    isJsonSchema7AllOfType = (type) => {
+      if ("type" in type && type.type === "string")
+        return false;
+      return "allOf" in type;
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+function parseLiteralDef(def, refs) {
+  const parsedType = typeof def.value;
+  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  if (refs.target === "openApi3") {
+    return {
+      type: parsedType === "bigint" ? "integer" : parsedType,
+      enum: [def.value]
+    };
+  }
+  return {
+    type: parsedType === "bigint" ? "integer" : parsedType,
+    const: def.value
+  };
+}
+var init_literal = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+function parseStringDef(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          break;
+        case "max":
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          break;
+        case "email":
+          switch (refs.emailStrategy) {
+            case "format:email":
+              addFormat(res, "email", check.message, refs);
+              break;
+            case "format:idn-email":
+              addFormat(res, "idn-email", check.message, refs);
+              break;
+            case "pattern:zod":
+              addPattern(res, zodPatterns.email, check.message, refs);
+              break;
+          }
+          break;
+        case "url":
+          addFormat(res, "uri", check.message, refs);
+          break;
+        case "uuid":
+          addFormat(res, "uuid", check.message, refs);
+          break;
+        case "regex":
+          addPattern(res, check.regex, check.message, refs);
+          break;
+        case "cuid":
+          addPattern(res, zodPatterns.cuid, check.message, refs);
+          break;
+        case "cuid2":
+          addPattern(res, zodPatterns.cuid2, check.message, refs);
+          break;
+        case "startsWith":
+          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
+          break;
+        case "endsWith":
+          addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
+          break;
+        case "datetime":
+          addFormat(res, "date-time", check.message, refs);
+          break;
+        case "date":
+          addFormat(res, "date", check.message, refs);
+          break;
+        case "time":
+          addFormat(res, "time", check.message, refs);
+          break;
+        case "duration":
+          addFormat(res, "duration", check.message, refs);
+          break;
+        case "length":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          break;
+        case "includes": {
+          addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
+          break;
+        }
+        case "ip": {
+          if (check.version !== "v6") {
+            addFormat(res, "ipv4", check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addFormat(res, "ipv6", check.message, refs);
+          }
+          break;
+        }
+        case "base64url":
+          addPattern(res, zodPatterns.base64url, check.message, refs);
+          break;
+        case "jwt":
+          addPattern(res, zodPatterns.jwt, check.message, refs);
+          break;
+        case "cidr": {
+          if (check.version !== "v6") {
+            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+          }
+          break;
+        }
+        case "emoji":
+          addPattern(res, zodPatterns.emoji(), check.message, refs);
+          break;
+        case "ulid": {
+          addPattern(res, zodPatterns.ulid, check.message, refs);
+          break;
+        }
+        case "base64": {
+          switch (refs.base64Strategy) {
+            case "format:binary": {
+              addFormat(res, "binary", check.message, refs);
+              break;
+            }
+            case "contentEncoding:base64": {
+              setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
+              break;
+            }
+            case "pattern:zod": {
+              addPattern(res, zodPatterns.base64, check.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern(res, zodPatterns.nanoid, check.message, refs);
+        }
+        case "toLowerCase":
+        case "toUpperCase":
+        case "trim":
+          break;
+        default:
+          /* @__PURE__ */ ((_2) => {
+          })(check);
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i = 0; i < source.length; i++) {
+    if (!ALPHA_NUMERIC.has(source[i])) {
+      result += "\\";
+    }
+    result += source[i];
+  }
+  return result;
+}
+function addFormat(schema, value, message, refs) {
+  if (schema.format || schema.anyOf?.some((x) => x.format)) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { format: schema.errorMessage.format }
+        }
+      });
+      delete schema.format;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.format;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "format", value, message, refs);
+  }
+}
+function addPattern(schema, regex, message, refs) {
+  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { pattern: schema.errorMessage.pattern }
+        }
+      });
+      delete schema.pattern;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.pattern;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+  }
+}
+function stringifyRegExpWithFlags(regex, refs) {
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    m: regex.flags.includes("m"),
+    s: regex.flags.includes("s")
+    // `.` matches newlines
+  };
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = "";
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+  for (let i = 0; i < source.length; i++) {
+    if (isEscaped) {
+      pattern += source[i];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i];
+            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
+            pattern += source[i];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i]}${source[i].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i].match(/[a-z]/)) {
+        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i] === ".") {
+      pattern += inCharGroup ? `${source[i]}\r
+` : `[${source[i]}\r
+]`;
+      continue;
+    }
+    pattern += source[i];
+    if (source[i] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i] === "[") {
+      inCharGroup = true;
+    }
+  }
+  try {
+    new RegExp(pattern);
+  } catch {
+    console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
+    return regex.source;
+  }
+  return pattern;
+}
+var emojiRegex2, zodPatterns, ALPHA_NUMERIC;
+var init_string = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js"() {
+    "use strict";
+    init_errorMessages();
+    emojiRegex2 = void 0;
+    zodPatterns = {
+      /**
+       * `c` was changed to `[cC]` to replicate /i flag
+       */
+      cuid: /^[cC][^\s-]{8,}$/,
+      cuid2: /^[0-9a-z]+$/,
+      ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+      /**
+       * `a-z` was added to replicate /i flag
+       */
+      email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+      /**
+       * Constructed a valid Unicode RegExp
+       *
+       * Lazily instantiate since this type of regex isn't supported
+       * in all envs (e.g. React Native).
+       *
+       * See:
+       * https://github.com/colinhacks/zod/issues/2433
+       * Fix in Zod:
+       * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+       */
+      emoji: () => {
+        if (emojiRegex2 === void 0) {
+          emojiRegex2 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+        }
+        return emojiRegex2;
+      },
+      /**
+       * Unused
+       */
+      uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+      /**
+       * Unused
+       */
+      ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+      ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+      /**
+       * Unused
+       */
+      ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+      ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+      base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+      base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+      nanoid: /^[a-zA-Z0-9_-]{21}$/,
+      jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+    };
+    ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+function parseRecordDef(def, refs) {
+  if (refs.target === "openAi") {
+    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+  }
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      type: "object",
+      required: def.keyType._def.values,
+      properties: def.keyType._def.values.reduce((acc, key) => ({
+        ...acc,
+        [key]: parseDef(def.valueType._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "properties", key]
+        }) ?? parseAnyDef(refs)
+      }), {}),
+      additionalProperties: refs.rejectedAdditionalProperties
+    };
+  }
+  const schema = {
+    type: "object",
+    additionalProperties: parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? refs.allowedAdditionalProperties
+  };
+  if (refs.target === "openApi3") {
+    return schema;
+  }
+  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+var init_record = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/record.js"() {
+    "use strict";
+    init_v3();
+    init_parseDef();
+    init_string();
+    init_branded();
+    init_any();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef(def, refs);
+  }
+  const keys = parseDef(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || parseAnyDef(refs);
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef(refs);
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+var init_map = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/map.js"() {
+    "use strict";
+    init_parseDef();
+    init_record();
+    init_any();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+function parseNativeEnumDef(def) {
+  const object = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object[object[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object[key]);
+  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+  return {
+    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: actualValues
+  };
+}
+var init_nativeEnum = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+function parseNeverDef(refs) {
+  return refs.target === "openAi" ? void 0 : {
+    not: parseAnyDef({
+      ...refs,
+      currentPath: [...refs.currentPath, "not"]
+    })
+  };
+}
+var init_never = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/never.js"() {
+    "use strict";
+    init_any();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+function parseNullDef(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+var init_null = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/null.js"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+function parseUnionDef(def, refs) {
+  if (refs.target === "openApi3")
+    return asAnyOf(def, refs);
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
+    const types = options.reduce((types2, x) => {
+      const type = primitiveMappings[x._def.typeName];
+      return type && !types2.includes(type) ? [...types2, type] : types2;
+    }, []);
+    return {
+      type: types.length > 1 ? types : types[0]
+    };
+  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types = options.reduce((acc, x) => {
+      const type = typeof x._def.value;
+      switch (type) {
+        case "string":
+        case "number":
+        case "boolean":
+          return [...acc, type];
+        case "bigint":
+          return [...acc, "integer"];
+        case "object":
+          if (x._def.value === null)
+            return [...acc, "null"];
+        case "symbol":
+        case "undefined":
+        case "function":
+        default:
+          return acc;
+      }
+    }, []);
+    if (types.length === options.length) {
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce((acc, x) => {
+          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+        }, [])
+      };
+    }
+  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+    return {
+      type: "string",
+      enum: options.reduce((acc, x) => [
+        ...acc,
+        ...x._def.values.filter((x2) => !acc.includes(x2))
+      ], [])
+    };
+  }
+  return asAnyOf(def, refs);
+}
+var primitiveMappings, asAnyOf;
+var init_union = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/union.js"() {
+    "use strict";
+    init_parseDef();
+    primitiveMappings = {
+      ZodString: "string",
+      ZodNumber: "number",
+      ZodBigInt: "integer",
+      ZodBoolean: "boolean",
+      ZodNull: "null"
+    };
+    asAnyOf = (def, refs) => {
+      const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "anyOf", `${i}`]
+      })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
+      return anyOf.length ? { anyOf } : void 0;
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+function parseNullableDef(def, refs) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+    if (refs.target === "openApi3") {
+      return {
+        type: primitiveMappings[def.innerType._def.typeName],
+        nullable: true
+      };
+    }
+    return {
+      type: [
+        primitiveMappings[def.innerType._def.typeName],
+        "null"
+      ]
+    };
+  }
+  if (refs.target === "openApi3") {
+    const base2 = parseDef(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath]
+    });
+    if (base2 && "$ref" in base2)
+      return { allOf: [base2], nullable: true };
+    return base2 && { ...base2, nullable: true };
+  }
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+var init_nullable = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js"() {
+    "use strict";
+    init_parseDef();
+    init_union();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+function parseNumberDef(def, refs) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "int":
+        res.type = "integer";
+        addErrorMessage(res, "type", check.message, refs);
+        break;
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+var init_number = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/number.js"() {
+    "use strict";
+    init_errorMessages();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+function parseObjectDef(def, refs) {
+  const forceOptionalIntoNullable = refs.target === "openAi";
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required = [];
+  const shape = def.shape();
+  for (const propName in shape) {
+    let propDef = shape[propName];
+    if (propDef === void 0 || propDef._def === void 0) {
+      continue;
+    }
+    let propOptional = safeIsOptional(propDef);
+    if (propOptional && forceOptionalIntoNullable) {
+      if (propDef._def.typeName === "ZodOptional") {
+        propDef = propDef._def.innerType;
+      }
+      if (!propDef.isNullable()) {
+        propDef = propDef.nullable();
+      }
+      propOptional = false;
+    }
+    const parsedDef = parseDef(propDef._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "properties", propName],
+      propertyPath: [...refs.currentPath, "properties", propName]
+    });
+    if (parsedDef === void 0) {
+      continue;
+    }
+    result.properties[propName] = parsedDef;
+    if (!propOptional) {
+      required.push(propName);
+    }
+  }
+  if (required.length) {
+    result.required = required;
+  }
+  const additionalProperties = decideAdditionalProperties(def, refs);
+  if (additionalProperties !== void 0) {
+    result.additionalProperties = additionalProperties;
+  }
+  return result;
+}
+function decideAdditionalProperties(def, refs) {
+  if (def.catchall._def.typeName !== "ZodNever") {
+    return parseDef(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    });
+  }
+  switch (def.unknownKeys) {
+    case "passthrough":
+      return refs.allowedAdditionalProperties;
+    case "strict":
+      return refs.rejectedAdditionalProperties;
+    case "strip":
+      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+  }
+}
+function safeIsOptional(schema) {
+  try {
+    return schema.isOptional();
+  } catch {
+    return true;
+  }
+}
+var init_object = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/object.js"() {
+    "use strict";
+    init_parseDef();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+var parseOptionalDef;
+var init_optional = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js"() {
+    "use strict";
+    init_parseDef();
+    init_any();
+    parseOptionalDef = (def, refs) => {
+      if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+        return parseDef(def.innerType._def, refs);
+      }
+      const innerSchema = parseDef(def.innerType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "anyOf", "1"]
+      });
+      return innerSchema ? {
+        anyOf: [
+          {
+            not: parseAnyDef(refs)
+          },
+          innerSchema
+        ]
+      } : parseAnyDef(refs);
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+var parsePipelineDef;
+var init_pipeline = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js"() {
+    "use strict";
+    init_parseDef();
+    parsePipelineDef = (def, refs) => {
+      if (refs.pipeStrategy === "input") {
+        return parseDef(def.in._def, refs);
+      } else if (refs.pipeStrategy === "output") {
+        return parseDef(def.out._def, refs);
+      }
+      const a = parseDef(def.in._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "allOf", "0"]
+      });
+      const b2 = parseDef(def.out._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+      });
+      return {
+        allOf: [a, b2].filter((x) => x !== void 0)
+      };
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+var init_promise = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js"() {
+    "use strict";
+    init_parseDef();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+function parseSetDef(def, refs) {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items
+  };
+  if (def.minSize) {
+    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+  }
+  if (def.maxSize) {
+    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+  }
+  return schema;
+}
+var init_set = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/set.js"() {
+    "use strict";
+    init_errorMessages();
+    init_parseDef();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+function parseTupleDef(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
+      additionalItems: parseDef(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalItems"]
+      })
+    };
+  } else {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items.map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+    };
+  }
+}
+var init_tuple = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js"() {
+    "use strict";
+    init_parseDef();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+function parseUndefinedDef(refs) {
+  return {
+    not: parseAnyDef(refs)
+  };
+}
+var init_undefined = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js"() {
+    "use strict";
+    init_any();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+function parseUnknownDef(refs) {
+  return parseAnyDef(refs);
+}
+var init_unknown = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js"() {
+    "use strict";
+    init_any();
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+var parseReadonlyDef;
+var init_readonly = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js"() {
+    "use strict";
+    init_parseDef();
+    parseReadonlyDef = (def, refs) => {
+      return parseDef(def.innerType._def, refs);
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/selectParser.js
+var selectParser;
+var init_selectParser = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/selectParser.js"() {
+    "use strict";
+    init_v3();
+    init_any();
+    init_array();
+    init_bigint();
+    init_boolean();
+    init_branded();
+    init_catch();
+    init_date();
+    init_default();
+    init_effects();
+    init_enum();
+    init_intersection();
+    init_literal();
+    init_map();
+    init_nativeEnum();
+    init_never();
+    init_null();
+    init_nullable();
+    init_number();
+    init_object();
+    init_optional();
+    init_pipeline();
+    init_promise();
+    init_record();
+    init_set();
+    init_string();
+    init_tuple();
+    init_undefined();
+    init_union();
+    init_unknown();
+    init_readonly();
+    selectParser = (def, typeName, refs) => {
+      switch (typeName) {
+        case ZodFirstPartyTypeKind.ZodString:
+          return parseStringDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodNumber:
+          return parseNumberDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodObject:
+          return parseObjectDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodBigInt:
+          return parseBigintDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodBoolean:
+          return parseBooleanDef();
+        case ZodFirstPartyTypeKind.ZodDate:
+          return parseDateDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodUndefined:
+          return parseUndefinedDef(refs);
+        case ZodFirstPartyTypeKind.ZodNull:
+          return parseNullDef(refs);
+        case ZodFirstPartyTypeKind.ZodArray:
+          return parseArrayDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodUnion:
+        case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+          return parseUnionDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodIntersection:
+          return parseIntersectionDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodTuple:
+          return parseTupleDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodRecord:
+          return parseRecordDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodLiteral:
+          return parseLiteralDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodEnum:
+          return parseEnumDef(def);
+        case ZodFirstPartyTypeKind.ZodNativeEnum:
+          return parseNativeEnumDef(def);
+        case ZodFirstPartyTypeKind.ZodNullable:
+          return parseNullableDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodOptional:
+          return parseOptionalDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodMap:
+          return parseMapDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodSet:
+          return parseSetDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodLazy:
+          return () => def.getter()._def;
+        case ZodFirstPartyTypeKind.ZodPromise:
+          return parsePromiseDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodNaN:
+        case ZodFirstPartyTypeKind.ZodNever:
+          return parseNeverDef(refs);
+        case ZodFirstPartyTypeKind.ZodEffects:
+          return parseEffectsDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodAny:
+          return parseAnyDef(refs);
+        case ZodFirstPartyTypeKind.ZodUnknown:
+          return parseUnknownDef(refs);
+        case ZodFirstPartyTypeKind.ZodDefault:
+          return parseDefaultDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodBranded:
+          return parseBrandedDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodReadonly:
+          return parseReadonlyDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodCatch:
+          return parseCatchDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodPipeline:
+          return parsePipelineDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodFunction:
+        case ZodFirstPartyTypeKind.ZodVoid:
+        case ZodFirstPartyTypeKind.ZodSymbol:
+          return void 0;
+        default:
+          return /* @__PURE__ */ ((_2) => void 0)(typeName);
+      }
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parseDef.js
+function parseDef(def, refs, forceResolution = false) {
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+    if (overrideResult !== ignoreOverride) {
+      return overrideResult;
+    }
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+    if (seenSchema !== void 0) {
+      return seenSchema;
+    }
+  }
+  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
+  refs.seen.set(def, newItem);
+  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+  const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema) {
+    addMeta(def, refs, jsonSchema);
+  }
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema, def, refs);
+    newItem.jsonSchema = jsonSchema;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema;
+  return jsonSchema;
+}
+var get$ref, addMeta;
+var init_parseDef = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parseDef.js"() {
+    "use strict";
+    init_Options();
+    init_selectParser();
+    init_getRelativePath();
+    init_any();
+    get$ref = (item, refs) => {
+      switch (refs.$refStrategy) {
+        case "root":
+          return { $ref: item.path.join("/") };
+        case "relative":
+          return { $ref: getRelativePath(refs.currentPath, item.path) };
+        case "none":
+        case "seen": {
+          if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+            console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+            return parseAnyDef(refs);
+          }
+          return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
+        }
+      }
+    };
+    addMeta = (def, refs, jsonSchema) => {
+      if (def.description) {
+        jsonSchema.description = def.description;
+        if (refs.markdownDescription) {
+          jsonSchema.markdownDescription = def.description;
+        }
+      }
+      return jsonSchema;
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parseTypes.js
+var init_parseTypes = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parseTypes.js"() {
+    "use strict";
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+var zodToJsonSchema;
+var init_zodToJsonSchema = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js"() {
+    "use strict";
+    init_parseDef();
+    init_Refs();
+    init_any();
+    zodToJsonSchema = (schema, options) => {
+      const refs = getRefs(options);
+      let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
+        ...acc,
+        [name2]: parseDef(schema2._def, {
+          ...refs,
+          currentPath: [...refs.basePath, refs.definitionPath, name2]
+        }, true) ?? parseAnyDef(refs)
+      }), {}) : void 0;
+      const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
+      const main2 = parseDef(schema._def, name === void 0 ? refs : {
+        ...refs,
+        currentPath: [...refs.basePath, refs.definitionPath, name]
+      }, false) ?? parseAnyDef(refs);
+      const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+      if (title !== void 0) {
+        main2.title = title;
+      }
+      if (refs.flags.hasReferencedOpenAiAnyType) {
+        if (!definitions) {
+          definitions = {};
+        }
+        if (!definitions[refs.openAiAnyTypeName]) {
+          definitions[refs.openAiAnyTypeName] = {
+            // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+            type: ["string", "number", "integer", "boolean", "array", "null"],
+            items: {
+              $ref: refs.$refStrategy === "relative" ? "1" : [
+                ...refs.basePath,
+                refs.definitionPath,
+                refs.openAiAnyTypeName
+              ].join("/")
+            }
+          };
+        }
+      }
+      const combined = name === void 0 ? definitions ? {
+        ...main2,
+        [refs.definitionPath]: definitions
+      } : main2 : {
+        $ref: [
+          ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+          refs.definitionPath,
+          name
+        ].join("/"),
+        [refs.definitionPath]: {
+          ...definitions,
+          [name]: main2
+        }
+      };
+      if (refs.target === "jsonSchema7") {
+        combined.$schema = "http://json-schema.org/draft-07/schema#";
+      } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+        combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+      }
+      if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
+        console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+      }
+      return combined;
+    };
+  }
+});
+
+// ../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/index.js
+var init_esm = __esm({
+  "../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/index.js"() {
+    "use strict";
+    init_Options();
+    init_Refs();
+    init_errorMessages();
+    init_getRelativePath();
+    init_parseDef();
+    init_parseTypes();
+    init_any();
+    init_array();
+    init_bigint();
+    init_boolean();
+    init_branded();
+    init_catch();
+    init_date();
+    init_default();
+    init_effects();
+    init_enum();
+    init_intersection();
+    init_literal();
+    init_map();
+    init_nativeEnum();
+    init_never();
+    init_null();
+    init_nullable();
+    init_number();
+    init_object();
+    init_optional();
+    init_pipeline();
+    init_promise();
+    init_readonly();
+    init_record();
+    init_set();
+    init_string();
+    init_tuple();
+    init_undefined();
+    init_union();
+    init_unknown();
+    init_selectParser();
+    init_zodToJsonSchema();
+    init_zodToJsonSchema();
+  }
+});
+
 // ../protocol/src/attachment-schemas.ts
 var TOKEN_ROLES, GROUP_FILE_SOURCES, GroupFileEntrySchema, AttachmentSignUrlArgs, AttachmentSignUrlResponseSchema, AttachmentGroupAddArgs, AttachmentGroupAddResponseSchema, AttachmentGroupRemoveArgs, AttachmentGroupRemoveResponseSchema, AttachmentGroupListArgs, AttachmentGroupListResponseSchema, AttachmentUploadResponseSchema;
 var init_attachment_schemas = __esm({
@@ -4534,11 +6154,12 @@ var init_feishu_auth = __esm({
 });
 
 // ../protocol/src/dispatch.ts
-var DispatchOutcomeSchema, DispatchRunArgsSchema, DispatchCompleteArgsSchema, DISPATCH_STATUSES, DispatchStatusSchema, DispatchRecordSchema, DispatchListArgsSchema, DispatchListResultSchema, DispatchGetArgsSchema, DispatchGetOkSchema;
+var EXTERNAL_DISPATCH_SOURCE, DispatchOutcomeSchema, DispatchRunArgsSchema, DispatchCompleteArgsSchema, DISPATCH_STATUSES, DispatchStatusSchema, DispatchRecordSchema, DispatchListArgsSchema, DispatchListResultSchema, DispatchGetArgsSchema, DispatchGetOkSchema;
 var init_dispatch = __esm({
   "../protocol/src/dispatch.ts"() {
     "use strict";
     init_zod();
+    EXTERNAL_DISPATCH_SOURCE = "external-agent";
     DispatchOutcomeSchema = external_exports.discriminatedUnion("kind", [
       external_exports.object({
         kind: external_exports.literal("success"),
@@ -5153,7 +6774,7 @@ var init_principal = __esm({
 });
 
 // ../protocol/src/schemas.ts
-var SessionStatusSchema, UsageSchema, ContextUsageSchema, sessionMetaShape, SessionMetaSchema, ModelInfoSchema, ModeInfoSchema, ConfigFieldSchemaSchema, CapabilitiesGetArgs, ToolFeaturesSchema, CapabilitiesResponseSchema, AllowRuleSchema, SessionFileSchema, ParsedEventBase, HistoryUserMetaSchema, SubagentToolStatsSchema, StructuredPatchHunkSchema, ToolResultExtraSchema, MemoryEntrySchema, AskQuestionOptionSchema, AskQuestionItemSchema, ParsedEventSchema, SessionCreateArgs, SessionListArgs, SessionIdArgs, SessionUpdateArgs, SessionSendArgs, SessionInterruptArgs, SessionRewindArgs, SessionRewindResponseSchema, SessionRewindDiffArgs, RewindDiffHunkSchema, RewindDiffFileSchema, SessionRewindDiffResponseSchema, SessionRewindableMessageIdsArgs, SessionRewindableMessageIdsResponseSchema, SessionResumeArgs, SessionForkArgs, SessionForkResponseSchema, SessionObserveArgs, SessionEventsArgs, PermissionRespondArgs, HistoryListArgs, HistoryReadArgs, HistorySubagentsArgs, HistorySubagentReadArgs, WorkspaceListArgs, WorkspaceReadArgs, SkillsListArgs, SkillEntrySchema, AgentEntrySchema, AgentsListArgs, AgentsListResponseSchema, SessionCurrentTurnSenderArgs, SessionSubscribeArgs, SessionPinArgs, PeerSessionUpsertArgs, PeerSessionUpsertResponseSchema, PeerSessionRemoveArgs, PeerSessionRemoveResponseSchema, SessionReorderPinsArgs, GitRootArgs, GitRootResponseSchema, GitBranchArgs, GitBranchResponseSchema, GitBranchesArgs, GitBranchesResponseSchema, HistoryRecentDirsArgs, RecentDirEntrySchema, HistoryRecentDirsResponseSchema, SessionQuestionFrameSchema, SessionQuestionClearedFrameSchema, AnswerQuestionArgs, AnswerQuestionResponseSchema, CancelQuestionArgs, CancelQuestionResponseSchema, AuthRequestFrameSchema, AuthOkFrameSchema, TunnelReadyEventSchema, TunnelExitedEventSchema, TunnelUnavailableEventSchema, InfoRunningSessionSchema, InfoResponseSchema, PROJECT_PORT_MIN, PROJECT_PORT_MAX, projectNameRegex, DEFAULT_DEV_COMMAND, ProjectMetadataSchema, PROJECT_STAGE_VALUES, ProjectStageSchema, ProjectWithStatusSchema, ListProjectsArgsSchema, ListProjectsResultSchema, GetProjectArgsSchema, GetProjectResultSchema, CreateProjectArgsSchema, CreateProjectResultSchema, DeleteProjectArgsSchema, DeleteProjectResultSchema, UpdateProjectPortArgsSchema, UpdateProjectPortResultSchema, SetProdUrlArgsSchema, SetProdUrlResultSchema, StartDevServerArgsSchema, StartDevServerResultSchema, ASSISTANT_REPORTABLE_STAGES, ReportStageArgsSchema, ReportStageResultSchema, StopDevServerArgsSchema, StopDevServerResultSchema, AppBuilderProjectUpdatedEventSchema, PublishArgsSchema, PublishResultSchema, DismissPublishJobArgsSchema, DismissPublishJobResultSchema, AppBuilderPublishProgressEventSchema, AppBuilderPublishFailedEventSchema;
+var SessionStatusSchema, UsageSchema, ContextUsageSchema, sessionMetaShape, SessionMetaSchema, ModelInfoSchema, ModeInfoSchema, ConfigFieldSchemaSchema, CapabilitiesGetArgs, ToolFeaturesSchema, CapabilitiesResponseSchema, AllowRuleSchema, SessionFileSchema, ParsedEventBase, HistoryUserMetaSchema, SubagentToolStatsSchema, StructuredPatchHunkSchema, ToolResultExtraSchema, MemoryEntrySchema, AskQuestionOptionSchema, AskQuestionItemSchema, ParsedEventSchema, SessionCreateArgs, SessionListArgs, SessionIdArgs, SessionUpdateArgs, SessionSendArgs, SessionInterruptArgs, SessionRewindArgs, SessionRewindResponseSchema, SessionRewindDiffArgs, RewindDiffHunkSchema, RewindDiffFileSchema, SessionRewindDiffResponseSchema, SessionRewindableMessageIdsArgs, SessionRewindableMessageIdsResponseSchema, SessionResumeArgs, SessionForkArgs, SessionForkResponseSchema, SessionObserveArgs, SessionEventsArgs, PermissionRespondArgs, HistoryListArgs, HistoryReadArgs, HistorySubagentsArgs, HistorySubagentReadArgs, WorkspaceListArgs, WorkspaceReadArgs, SkillsListArgs, SkillEntrySchema, AgentEntrySchema, AgentsListArgs, AgentsListResponseSchema, SessionCurrentTurnSenderArgs, SessionSubscribeArgs, SessionPinArgs, PeerSessionUpsertArgs, PeerSessionUpsertResponseSchema, PeerSessionRemoveArgs, PeerSessionRemoveResponseSchema, SessionReorderPinsArgs, GitRootArgs, GitRootResponseSchema, GitBranchArgs, GitBranchResponseSchema, GitBranchesArgs, GitBranchesResponseSchema, HistoryRecentDirsArgs, RecentDirEntrySchema, HistoryRecentDirsResponseSchema, SessionQuestionFrameSchema, SessionQuestionClearedFrameSchema, AnswerQuestionArgs, AnswerQuestionResponseSchema, CancelQuestionArgs, CancelQuestionResponseSchema, ClientInfoSchema, AuthRequestFrameSchema, AuthOkFrameSchema, DeviceConnectionEntrySchema, DeviceConnectionsResponseSchema, TunnelReadyEventSchema, TunnelExitedEventSchema, TunnelUnavailableEventSchema, InfoRunningSessionSchema, InfoResponseSchema, PROJECT_PORT_MIN, PROJECT_PORT_MAX, projectNameRegex, DEFAULT_DEV_COMMAND, ProjectMetadataSchema, PROJECT_STAGE_VALUES, ProjectStageSchema, ProjectWithStatusSchema, ListProjectsArgsSchema, ListProjectsResultSchema, GetProjectArgsSchema, GetProjectResultSchema, CreateProjectArgsSchema, CreateProjectResultSchema, DeleteProjectArgsSchema, DeleteProjectResultSchema, UpdateProjectPortArgsSchema, UpdateProjectPortResultSchema, SetProdUrlArgsSchema, SetProdUrlResultSchema, StartDevServerArgsSchema, StartDevServerResultSchema, ASSISTANT_REPORTABLE_STAGES, ReportStageArgsSchema, ReportStageResultSchema, StopDevServerArgsSchema, StopDevServerResultSchema, AppBuilderProjectUpdatedEventSchema, PublishArgsSchema, PublishResultSchema, DismissPublishJobArgsSchema, DismissPublishJobResultSchema, AppBuilderPublishProgressEventSchema, AppBuilderPublishFailedEventSchema;
 var init_schemas = __esm({
   "../protocol/src/schemas.ts"() {
     "use strict";
@@ -5845,6 +7466,13 @@ var init_schemas = __esm({
       toolUseId: external_exports.string().min(1)
     });
     CancelQuestionResponseSchema = external_exports.object({ ok: external_exports.literal(true) });
+    ClientInfoSchema = external_exports.object({
+      name: external_exports.string().min(1),
+      version: external_exports.string().min(1),
+      instanceId: external_exports.string().min(1),
+      /** 自报设备名（如 os.hostname()），展示用非身份；trim 后截断 64 字符 */
+      deviceLabel: external_exports.string().transform((s) => s.trim().slice(0, 64)).optional()
+    });
     AuthRequestFrameSchema = external_exports.object({
       type: external_exports.literal("auth"),
       token: external_exports.string().min(1),
@@ -5865,17 +7493,23 @@ var init_schemas = __esm({
        * 'clawd-mobile-android' / ...），宽容未知值（将来加新客户端不动 schema）。
        * instanceId：客户端首启生成 UUID 并本地持久化——区分同种类多实例（多手机/多 desktop 同连）。
        */
-      clientInfo: external_exports.object({
-        name: external_exports.string().min(1),
-        version: external_exports.string().min(1),
-        instanceId: external_exports.string().min(1)
-      }).optional()
+      clientInfo: ClientInfoSchema.optional()
     });
     AuthOkFrameSchema = external_exports.object({
       type: external_exports.literal("auth:ok"),
       version: external_exports.string().min(1).optional(),
       protocolVersion: external_exports.number().int().nonnegative().optional()
     });
+    DeviceConnectionEntrySchema = external_exports.object({
+      clientId: external_exports.string().min(1),
+      connectedAt: external_exports.number().int().nonnegative(),
+      self: external_exports.boolean(),
+      clientInfo: ClientInfoSchema.optional()
+    });
+    DeviceConnectionsResponseSchema = external_exports.object({
+      type: external_exports.literal("device:connections:ok"),
+      connections: external_exports.array(DeviceConnectionEntrySchema)
+    });
     TunnelReadyEventSchema = external_exports.object({
       type: external_exports.literal("tunnel:ready"),
       url: external_exports.string().min(1),
@@ -6116,21 +7750,28 @@ var init_schemas = __esm({
 });
 
 // ../protocol/src/methods.ts
+function isMethodName(name) {
+  return METHOD_NAMES.includes(name);
+}
+function methodArgsSchema(method) {
+  const doc = METHOD_DOCS[method];
+  if (!doc.args) return null;
+  const base = zodToJsonSchema(doc.args, { $refStrategy: "none" });
+  return doc.argsConstraints ? { ...base, ...doc.argsConstraints } : base;
+}
 function methodArgFields(method) {
-  let schema = METHOD_DOCS[method].args;
+  const schema = methodArgsSchema(method);
   if (!schema) return null;
-  for (let i = 0; i < 5 && schema && !schema.shape; i += 1) {
-    schema = schema._def?.schema;
-  }
-  const shape = schema?.shape;
-  if (!shape) return null;
-  return Object.entries(shape).map(([name, def]) => ({ name, required: !def.isOptional() }));
+  const props = schema.properties ?? {};
+  const required = new Set(schema.required ?? []);
+  return Object.keys(props).map((name) => ({ name, required: required.has(name) }));
 }
-var NO_ARGS, METHOD_DOCS, METHOD_NAMES, RPC_METHOD_STATUSES, RpcMethodStatusSchema, RpcMethodInfoSchema, MetaMethodsResultSchema;
+var NO_ARGS, MetaMethodsArgs, METHOD_DOCS, METHOD_NAMES, RPC_METHOD_STATUSES, RpcMethodStatusSchema, RpcMethodInfoSchema, MetaMethodsResultSchema;
 var init_methods = __esm({
   "../protocol/src/methods.ts"() {
     "use strict";
     init_zod();
+    init_esm();
     init_attachment_schemas();
     init_contact_handshake();
     init_contact_remote_access();
@@ -6144,10 +7785,16 @@ var init_methods = __esm({
     init_persona_schemas();
     init_schemas();
     NO_ARGS = external_exports.object({});
+    MetaMethodsArgs = external_exports.object({
+      method: external_exports.string().min(1).optional()
+    });
     METHOD_DOCS = {
       "session:create": {
-        summary: "\u65B0\u5EFA\u4F1A\u8BDD\u5E76\u62C9\u8D77 tool \u8FDB\u7A0B\uFF08claude / codex\uFF09\u3002**cwd \u4E0E ownerPersonaId \u81F3\u5C11\u4F20\u4E00\u4E2A**\uFF08\u5E26 ownerPersonaId \u65F6 cwd \u7531 daemon \u6D3E\u751F\uFF09\u2014\u2014\u8FD9\u6761\u4E92\u65A5\u7EA6\u675F\u662F schema \u7684 refine\uFF0C\u53CD\u5C04\u4E0D\u51FA\u6765",
-        args: SessionCreateArgs
+        summary: "\u65B0\u5EFA\u4F1A\u8BDD\u5E76\u62C9\u8D77 tool \u8FDB\u7A0B\uFF08claude / codex\uFF09\u3002**cwd \u4E0E ownerPersonaId \u81F3\u5C11\u4F20\u4E00\u4E2A**\uFF08\u5E26 ownerPersonaId \u65F6 cwd \u7531 daemon \u6D3E\u751F\uFF09",
+        args: SessionCreateArgs,
+        argsConstraints: {
+          anyOf: [{ required: ["cwd"] }, { required: ["ownerPersonaId"] }]
+        }
       },
       "session:list": {
         summary: "\u5217\u51FA\u5F53\u524D\u8EAB\u4EFD\u53EF\u89C1\u7684\u4F1A\u8BDD\uFF08owner \u5168\u91CF\uFF1Bguest \u9650\u88AB\u6388\u6743 persona\uFF09",
@@ -6355,7 +8002,11 @@ var init_methods = __esm({
       },
       "personaDispatch:run": {
         summary: "\u628A\u4EFB\u52A1\u59D4\u6D3E\u7ED9\u53E6\u4E00\u4E2A persona\uFF08\u53EF\u8DE8\u8BBE\u5907\uFF09\uFF0C\u5F02\u6B65\u79D2\u56DE { dispatchId }\u3002targetPersona \u4E0E dispatchId **\u81F3\u5C11\u7ED9\u4E00\u4E2A**\uFF08\u524D\u8005\u65B0\u5F00\u3001\u540E\u8005\u7EED\u6D3E\uFF09\uFF1BdispatchId \u4E0E targetDeviceId **\u4E92\u65A5**",
-        args: DispatchRunArgsSchema
+        args: DispatchRunArgsSchema,
+        argsConstraints: {
+          anyOf: [{ required: ["targetPersona"] }, { required: ["dispatchId"] }],
+          not: { required: ["dispatchId", "targetDeviceId"] }
+        }
       },
       "personaDispatch:complete": {
         summary: '\u88AB\u59D4\u6D3E\u65B9\u56DE\u62A5\u7ED3\u679C\uFF1A\u5199\u53F0\u8D26\u5E76\u628A\u7ED3\u679C\u6295\u9012\u56DE\u53D1\u8D77\u65B9\u4F1A\u8BDD\u3002outcome \u662F { kind:"success", text, filePaths? } \u6216 { kind:"failure", reason } \u4E8C\u9009\u4E00',
@@ -6451,8 +8102,8 @@ var init_methods = __esm({
         args: NO_ARGS
       },
       "meta:methods": {
-        summary: "RPC \u81EA\u7701\uFF1A\u8FD4\u56DE METHOD_NAMES \u5168\u96C6 + **\u5BF9\u672C\u8FDE\u63A5**\u7684\u53EF\u8C03\u7528\u6027\u4E09\u6001\uFF08allowed / conditional / denied\uFF09+ \u6BCF\u6761\u7684\u8BF4\u660E\u3002agent \u4FA7 clawd-rpc \u7684 list tool \u662F\u552F\u4E00\u6D88\u8D39\u65B9",
-        args: NO_ARGS
+        summary: "RPC \u81EA\u7701\uFF1A\u8FD4\u56DE METHOD_NAMES \u5168\u96C6 + **\u5BF9\u672C\u8FDE\u63A5**\u7684\u53EF\u8C03\u7528\u6027\u4E09\u6001\uFF08allowed / conditional / denied\uFF09+ \u6BCF\u6761\u7684\u8BF4\u660E\u3002\u4F20 method \u5219\u53EA\u8FD4\u90A3\u4E00\u6761\uFF0C\u5E76\u989D\u5916\u5E26\u5B8C\u6574 args JSON Schema\u3002agent \u4FA7 clawd-rpc \u7684 list tool \u662F\u552F\u4E00\u6D88\u8D39\u65B9",
+        args: MetaMethodsArgs
       },
       "extension.list": {
         summary: "\u5217\u51FA\u5DF2\u5B89\u88C5\u7684 extension",
@@ -6518,6 +8169,10 @@ var init_methods = __esm({
         summary: "\u8FDE\u63A5\u76EE\u6807\u8BBE\u5907\uFF1A\u6362 aud \u7ED1\u5B9A\u7684\u7B7E\u540D token \u5E76\u8D70 contact:handshake \u5EFA\u8054\u3002owner-only",
         args: DeviceConnectArgsSchema
       },
+      "device:connections": {
+        summary: '\u5217\u51FA\u672C daemon \u5F53\u524D\u6240\u6709 owner WS \u8FDE\u63A5\uFF08\u672C\u673A UI / \u624B\u673A / \u7B2C\u4E8C\u53F0\u684C\u9762\uFF09+ \u5404\u81EA clientInfo\u3002owner-only\uFF1Bguest \u8FDE\u63A5\u4E0D\u5728\u5217\uFF08\u4E0D\u662F"\u6211\u7684\u8BBE\u5907"\u4E14\u4E0D\u5411 UI \u6CC4\u9732 guest \u4FE1\u606F\uFF09',
+        args: NO_ARGS
+      },
       "appBuilder:listProjects": {
         summary: "\u5217\u51FA app-builder project\uFF08\u542B dev server \u72B6\u6001\uFF09",
         args: ListProjectsArgsSchema
@@ -6577,6 +8232,11 @@ var init_methods = __esm({
        * `null` = 该 method 还没有中央 zod schema（欠账，见 RpcMethodDoc），调用方需自行试探。
        */
       args: external_exports.array(external_exports.object({ name: external_exports.string(), required: external_exports.boolean() })).nullable(),
+      /**
+       * 完整 args JSON Schema（draft-07），来自 {@link methodArgsSchema}。
+       * **只在按 method 单查时下发**——全量目录带上 105 份 schema 会吃掉消费方一大块 context。
+       */
+      argsSchema: external_exports.record(external_exports.unknown()).optional(),
       /**
        * `denied` 必带：daemon error code（`UNAUTHORIZED` / `FEISHU_LOGIN_REQUIRED` /
        * `METHOD_NOT_IMPLEMENTED`）。`conditional` 必带：谁来做二次校验。
@@ -7008,8 +8668,8 @@ var require_req = __commonJS({
       if (req.originalUrl) {
         _req.url = req.originalUrl;
       } else {
-        const path76 = req.path;
-        _req.url = typeof path76 === "string" ? path76 : req.url ? req.url.path || req.url : void 0;
+        const path77 = req.path;
+        _req.url = typeof path77 === "string" ? path77 : req.url ? req.url.path || req.url : void 0;
       }
       if (req.query) {
         _req.query = req.query;
@@ -7174,14 +8834,14 @@ var require_redact = __commonJS({
       }
       return obj;
     }
-    function parsePath(path76) {
+    function parsePath(path77) {
       const parts = [];
       let current = "";
       let inBrackets = false;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i = 0; i < path76.length; i++) {
-        const char = path76[i];
+      for (let i = 0; i < path77.length; i++) {
+        const char = path77[i];
         if (!inBrackets && char === ".") {
           if (current) {
             parts.push(current);
@@ -7312,10 +8972,10 @@ var require_redact = __commonJS({
       return current;
     }
     function redactPaths(obj, paths, censor, remove = false) {
-      for (const path76 of paths) {
-        const parts = parsePath(path76);
+      for (const path77 of paths) {
+        const parts = parsePath(path77);
         if (parts.includes("*")) {
-          redactWildcardPath(obj, parts, censor, path76, remove);
+          redactWildcardPath(obj, parts, censor, path77, remove);
         } else {
           if (remove) {
             removeKey(obj, parts);
@@ -7400,8 +9060,8 @@ var require_redact = __commonJS({
           }
         } else {
           if (afterWildcard.includes("*")) {
-            const wrappedCensor = typeof censor === "function" ? (value, path76) => {
-              const fullPath = [...pathArray.slice(0, pathLength), ...path76];
+            const wrappedCensor = typeof censor === "function" ? (value, path77) => {
+              const fullPath = [...pathArray.slice(0, pathLength), ...path77];
               return censor(value, fullPath);
             } : censor;
             redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove);
@@ -7436,8 +9096,8 @@ var require_redact = __commonJS({
         return null;
       }
       const pathStructure = /* @__PURE__ */ new Map();
-      for (const path76 of pathsToClone) {
-        const parts = parsePath(path76);
+      for (const path77 of pathsToClone) {
+        const parts = parsePath(path77);
         let current = pathStructure;
         for (let i = 0; i < parts.length; i++) {
           const part = parts[i];
@@ -7489,24 +9149,24 @@ var require_redact = __commonJS({
       }
       return cloneSelectively(obj, pathStructure);
     }
-    function validatePath(path76) {
-      if (typeof path76 !== "string") {
+    function validatePath(path77) {
+      if (typeof path77 !== "string") {
         throw new Error("Paths must be (non-empty) strings");
       }
-      if (path76 === "") {
+      if (path77 === "") {
         throw new Error("Invalid redaction path ()");
       }
-      if (path76.includes("..")) {
-        throw new Error(`Invalid redaction path (${path76})`);
+      if (path77.includes("..")) {
+        throw new Error(`Invalid redaction path (${path77})`);
       }
-      if (path76.includes(",")) {
-        throw new Error(`Invalid redaction path (${path76})`);
+      if (path77.includes(",")) {
+        throw new Error(`Invalid redaction path (${path77})`);
       }
       let bracketCount = 0;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i = 0; i < path76.length; i++) {
-        const char = path76[i];
+      for (let i = 0; i < path77.length; i++) {
+        const char = path77[i];
         if ((char === '"' || char === "'") && bracketCount > 0) {
           if (!inQuotes) {
             inQuotes = true;
@@ -7520,20 +9180,20 @@ var require_redact = __commonJS({
         } else if (char === "]" && !inQuotes) {
           bracketCount--;
           if (bracketCount < 0) {
-            throw new Error(`Invalid redaction path (${path76})`);
+            throw new Error(`Invalid redaction path (${path77})`);
           }
         }
       }
       if (bracketCount !== 0) {
-        throw new Error(`Invalid redaction path (${path76})`);
+        throw new Error(`Invalid redaction path (${path77})`);
       }
     }
     function validatePaths(paths) {
       if (!Array.isArray(paths)) {
         throw new TypeError("paths must be an array");
       }
-      for (const path76 of paths) {
-        validatePath(path76);
+      for (const path77 of paths) {
+        validatePath(path77);
       }
     }
     function slowRedact(options = {}) {
@@ -7701,8 +9361,8 @@ var require_redaction = __commonJS({
         if (shape[k2] === null) {
           o[k2] = (value) => topCensor(value, [k2]);
         } else {
-          const wrappedCensor = typeof censor === "function" ? (value, path76) => {
-            return censor(value, [k2, ...path76]);
+          const wrappedCensor = typeof censor === "function" ? (value, path77) => {
+            return censor(value, [k2, ...path77]);
           } : censor;
           o[k2] = Redact({
             paths: shape[k2],
@@ -7923,7 +9583,7 @@ var require_sonic_boom = __commonJS({
     var fs67 = require("fs");
     var EventEmitter3 = require("events");
     var inherits = require("util").inherits;
-    var path76 = require("path");
+    var path77 = require("path");
     var sleep2 = require_atomic_sleep();
     var assert = require("assert");
     var BUSY_WRITE_TIMEOUT = 100;
@@ -7977,7 +9637,7 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs67.mkdirSync(path76.dirname(file), { recursive: true });
+          if (sonic.mkdir) fs67.mkdirSync(path77.dirname(file), { recursive: true });
           const fd = fs67.openSync(file, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
@@ -7985,7 +9645,7 @@ var require_sonic_boom = __commonJS({
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs67.mkdir(path76.dirname(file), { recursive: true }, (err) => {
+        fs67.mkdir(path77.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
           fs67.open(file, flags, mode, fileOpened);
         });
@@ -9534,7 +11194,7 @@ var require_tools = __commonJS({
         stream.flushSync();
       }
     }
-    function createArgsNormalizer(defaultOptions) {
+    function createArgsNormalizer(defaultOptions2) {
       return function normalizeArgs(instance, caller, opts = {}, stream) {
         if (typeof opts === "string") {
           stream = buildSafeSonicBoom({ dest: opts });
@@ -9560,9 +11220,9 @@ var require_tools = __commonJS({
           }
           stream = transport({ caller, ...opts.transport, levels: customLevels });
         }
-        opts = Object.assign({}, defaultOptions, opts);
-        opts.serializers = Object.assign({}, defaultOptions.serializers, opts.serializers);
-        opts.formatters = Object.assign({}, defaultOptions.formatters, opts.formatters);
+        opts = Object.assign({}, defaultOptions2, opts);
+        opts.serializers = Object.assign({}, defaultOptions2.serializers, opts.serializers);
+        opts.formatters = Object.assign({}, defaultOptions2.formatters, opts.formatters);
         if (opts.prettyPrint) {
           throw new Error("prettyPrint option is no longer supported, see the pino-pretty package (https://github.com/pinojs/pino-pretty)");
         }
@@ -10894,7 +12554,7 @@ var require_pino = __commonJS({
     var { pid } = process;
     var hostname = os24.hostname();
     var defaultErrorSerializer = stdSerializers.err;
-    var defaultOptions = {
+    var defaultOptions2 = {
       level: "info",
       levelComparison: SORTING_ORDER.ASC,
       levels: DEFAULT_LEVELS,
@@ -10926,7 +12586,7 @@ var require_pino = __commonJS({
       depthLimit: 5,
       edgeLimit: 100
     };
-    var normalize = createArgsNormalizer(defaultOptions);
+    var normalize = createArgsNormalizer(defaultOptions2);
     var serializers = Object.assign(/* @__PURE__ */ Object.create(null), stdSerializers);
     function pino2(...args) {
       const instance = {};
@@ -11616,11 +13276,11 @@ var init_lib = __esm({
           }
         }
       },
-      addToPath: function addToPath(path76, added, removed, oldPosInc, options) {
-        var last = path76.lastComponent;
+      addToPath: function addToPath(path77, added, removed, oldPosInc, options) {
+        var last = path77.lastComponent;
         if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
           return {
-            oldPos: path76.oldPos + oldPosInc,
+            oldPos: path77.oldPos + oldPosInc,
             lastComponent: {
               count: last.count + 1,
               added,
@@ -11630,7 +13290,7 @@ var init_lib = __esm({
           };
         } else {
           return {
-            oldPos: path76.oldPos + oldPosInc,
+            oldPos: path77.oldPos + oldPosInc,
             lastComponent: {
               count: 1,
               added,
@@ -12139,10 +13799,10 @@ function attachmentToHistoryMessage(o, ts) {
     const memories = raw.map((m2) => {
       if (!m2 || typeof m2 !== "object") return null;
       const rec3 = m2;
-      const path76 = typeof rec3.path === "string" ? rec3.path : null;
+      const path77 = typeof rec3.path === "string" ? rec3.path : null;
       const content = typeof rec3.content === "string" ? rec3.content : null;
-      if (!path76 || content == null) return null;
-      const entry = { path: path76, content };
+      if (!path77 || content == null) return null;
+      const entry = { path: path77, content };
       if (typeof rec3.mtimeMs === "number") entry.mtimeMs = rec3.mtimeMs;
       return entry;
     }).filter((m2) => m2 !== null);
@@ -12945,10 +14605,10 @@ function parseAttachment(obj) {
     const memories = raw.map((m2) => {
       if (!m2 || typeof m2 !== "object") return null;
       const rec3 = m2;
-      const path76 = typeof rec3.path === "string" ? rec3.path : null;
+      const path77 = typeof rec3.path === "string" ? rec3.path : null;
       const content = typeof rec3.content === "string" ? rec3.content : null;
-      if (!path76 || content == null) return null;
-      const out = { path: path76, content };
+      if (!path77 || content == null) return null;
+      const out = { path: path77, content };
       if (typeof rec3.mtimeMs === "number") out.mtimeMs = rec3.mtimeMs;
       return out;
     }).filter((m2) => m2 !== null);
@@ -33917,8 +35577,8 @@ var require_utils = __commonJS({
       var result = transform[inputType][outputType](input);
       return result;
     };
-    exports2.resolve = function(path76) {
-      var parts = path76.split("/");
+    exports2.resolve = function(path77) {
+      var parts = path77.split("/");
       var result = [];
       for (var index = 0; index < parts.length; index++) {
         var part = parts[index];
@@ -39771,18 +41431,18 @@ var require_object = __commonJS({
       var object = new ZipObject(name, zipObjectContent, o);
       this.files[name] = object;
     };
-    var parentFolder = function(path76) {
-      if (path76.slice(-1) === "/") {
-        path76 = path76.substring(0, path76.length - 1);
+    var parentFolder = function(path77) {
+      if (path77.slice(-1) === "/") {
+        path77 = path77.substring(0, path77.length - 1);
       }
-      var lastSlash = path76.lastIndexOf("/");
-      return lastSlash > 0 ? path76.substring(0, lastSlash) : "";
+      var lastSlash = path77.lastIndexOf("/");
+      return lastSlash > 0 ? path77.substring(0, lastSlash) : "";
     };
-    var forceTrailingSlash = function(path76) {
-      if (path76.slice(-1) !== "/") {
-        path76 += "/";
+    var forceTrailingSlash = function(path77) {
+      if (path77.slice(-1) !== "/") {
+        path77 += "/";
       }
-      return path76;
+      return path77;
     };
     var folderAdd = function(name, createFolders) {
       createFolders = typeof createFolders !== "undefined" ? createFolders : defaults.createFolders;
@@ -40784,7 +42444,7 @@ var require_lib3 = __commonJS({
 // src/run-case/recorder.ts
 function startRunCaseRecorder(opts) {
   const now = opts.now ?? Date.now;
-  const dir = import_node_path63.default.dirname(opts.recordPath);
+  const dir = import_node_path64.default.dirname(opts.recordPath);
   let stream = null;
   let closing = false;
   let closedSettled = false;
@@ -40824,12 +42484,12 @@ function startRunCaseRecorder(opts) {
   };
   return { tap, close, closed };
 }
-var import_node_fs48, import_node_path63;
+var import_node_fs48, import_node_path64;
 var init_recorder = __esm({
   "src/run-case/recorder.ts"() {
     "use strict";
     import_node_fs48 = __toESM(require("fs"), 1);
-    import_node_path63 = __toESM(require("path"), 1);
+    import_node_path64 = __toESM(require("path"), 1);
   }
 });
 
@@ -40872,7 +42532,7 @@ var init_wire = __esm({
 // src/run-case/controller.ts
 async function runController(opts) {
   const now = opts.now ?? Date.now;
-  const cwd = opts.cwd ?? (0, import_node_fs49.mkdtempSync)(import_node_path64.default.join(import_node_os23.default.tmpdir(), "clawd-runcase-"));
+  const cwd = opts.cwd ?? (0, import_node_fs49.mkdtempSync)(import_node_path65.default.join(import_node_os23.default.tmpdir(), "clawd-runcase-"));
   const ownsCwd = opts.cwd === void 0;
   const recorder = startRunCaseRecorder({ recordPath: opts.record, now });
   const spawnCtx = { cwd };
@@ -41039,13 +42699,13 @@ async function runController(opts) {
   }
   return exitCode ?? 0;
 }
-var import_node_fs49, import_node_os23, import_node_path64;
+var import_node_fs49, import_node_os23, import_node_path65;
 var init_controller = __esm({
   "src/run-case/controller.ts"() {
     "use strict";
     import_node_fs49 = require("fs");
     import_node_os23 = __toESM(require("os"), 1);
-    import_node_path64 = __toESM(require("path"), 1);
+    import_node_path65 = __toESM(require("path"), 1);
     init_claude();
     init_stdout_splitter();
     init_permission_stdio();
@@ -41320,7 +42980,7 @@ Env (advanced):
 `;
 
 // src/index.ts
-var import_node_path62 = __toESM(require("path"), 1);
+var import_node_path63 = __toESM(require("path"), 1);
 var import_node_fs47 = __toESM(require("fs"), 1);
 var import_node_os22 = __toESM(require("os"), 1);
 
@@ -47248,8 +48908,8 @@ function turnStartInput(text) {
   const items = [];
   let leftover = text;
   for (const m2 of text.matchAll(SKILL_RE)) {
-    const [marker, name, path76] = m2;
-    items.push({ type: "skill", name, path: path76 });
+    const [marker, name, path77] = m2;
+    items.push({ type: "skill", name, path: path77 });
     leftover = leftover.replace(marker, "");
   }
   for (const m2 of text.matchAll(ATTACHMENT_RE2)) {
@@ -49174,9 +50834,24 @@ function writeRpcToolMcpConfig(args) {
   return cfgPath;
 }
 
+// src/dispatch/source-transcript.ts
+var import_node_path25 = __toESM(require("path"), 1);
+init_claude_history();
+var NO_SOURCE_TRANSCRIPT = "(no transcript yet \u2014 operate from the task description alone)";
+function resolveSourceJsonlPath(sourceFile, home) {
+  if (!sourceFile?.toolSessionId) return NO_SOURCE_TRANSCRIPT;
+  return import_node_path25.default.join(
+    home,
+    ".claude",
+    "projects",
+    cwdToHashDir(sourceFile.cwd),
+    `${sourceFile.toolSessionId}.jsonl`
+  );
+}
+
 // src/shift/store.ts
 var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_path26 = __toESM(require("path"), 1);
 var import_node_crypto6 = require("crypto");
 
 // src/shift/schedule.ts
@@ -49251,7 +50926,7 @@ function createShiftStore(deps) {
       flushTimer = null;
     }
     const content = { version: 1, shifts };
-    await import_promises2.default.mkdir(import_node_path25.default.dirname(deps.filePath), { recursive: true });
+    await import_promises2.default.mkdir(import_node_path26.default.dirname(deps.filePath), { recursive: true });
     const tmp = `${deps.filePath}.tmp-${deps.now()}-${Math.floor(Math.random() * 1e6)}`;
     await import_promises2.default.writeFile(tmp, JSON.stringify(content, null, 2), "utf8");
     await import_promises2.default.rename(tmp, deps.filePath);
@@ -49678,7 +51353,14 @@ function buildPersonaDispatchHandlers(deps) {
   const { personaDispatchManager: mgr, spawnB, logger } = deps;
   const run = async (frame, _client, ctx) => {
     const { type: _t, requestId: _r, ...rest } = frame;
-    const sourceSessionId = typeof rest.sessionId === "string" ? rest.sessionId : void 0;
+    const rawSessionId = typeof rest.sessionId === "string" && rest.sessionId.length > 0 ? rest.sessionId : void 0;
+    const sourceSessionId = rawSessionId ?? EXTERNAL_DISPATCH_SOURCE;
+    if (!rawSessionId) {
+      logger?.warn("dispatch.run.external-source", {
+        targetPersona: typeof rest.targetPersona === "string" ? rest.targetPersona : void 0,
+        sourceSessionId
+      });
+    }
     const args = DispatchRunArgsSchema.parse(rest);
     if (args.model !== void 0) {
       const targetPersona2 = args.targetPersona ?? (args.dispatchId ? deps.store.get(args.dispatchId)?.targetPersonaId : void 0);
@@ -49698,11 +51380,6 @@ function buildPersonaDispatchHandlers(deps) {
           "follow-up dispatch cannot be initiated by a guest"
         );
       }
-      if (!sourceSessionId) {
-        throw new Error(
-          "personaDispatch:run requires sessionId in the request body"
-        );
-      }
       const rec3 = deps.store.get(args.dispatchId);
       if (!rec3) {
         throw new ClawdError(ERROR_CODES.INVALID_PARAM, `dispatch not found: ${args.dispatchId}`);
@@ -49771,11 +51448,6 @@ function buildPersonaDispatchHandlers(deps) {
       if (!deps.forwardToPeer) {
         throw new Error("cross-device dispatch not wired (forwardToPeer missing)");
       }
-      if (!sourceSessionId) {
-        throw new Error(
-          "personaDispatch:run requires sessionId in the request body"
-        );
-      }
       const { dispatchId: dispatchId2 } = mgr.start({
         sourceSessionId,
         targetPersona,
@@ -49844,11 +51516,6 @@ function buildPersonaDispatchHandlers(deps) {
         response: { type: "personaDispatch:run:ok", dispatchId: dispatchId2 }
       };
     }
-    if (!sourceSessionId) {
-      throw new Error(
-        "personaDispatch:run requires sessionId in the request body"
-      );
-    }
     const { dispatchId } = mgr.start({
       sourceSessionId,
       targetPersona,
@@ -50271,7 +51938,7 @@ var CodexHistoryReader = class {
 
 // src/tools/codex-skills.ts
 var import_node_child_process7 = require("child_process");
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_path27 = __toESM(require("path"), 1);
 var DEFAULT_TIMEOUT_MS3 = 8e3;
 function str3(v2) {
   return typeof v2 === "string" ? v2 : void 0;
@@ -50287,13 +51954,13 @@ function mapSkillsListResponse(res) {
       const r = s ?? {};
       const name = str3(r.name);
       if (!name) continue;
-      const path76 = str3(r.path);
+      const path77 = str3(r.path);
       const description = str3(r.description);
       const isPlugin = name.includes(":");
       out.push({
         name,
         source: isPlugin ? "plugin" : "project",
-        ...path76 ? { path: path76 } : {},
+        ...path77 ? { path: path77 } : {},
         ...description ? { description } : {},
         ...isPlugin ? { plugin: name.split(":")[0] } : {}
       });
@@ -50323,7 +51990,7 @@ async function listCodexSkills(cwd, deps = {}) {
       })(),
       timeout
     ]);
-    void client.request("skills/extraRoots/set", { extraRoots: [import_node_path26.default.join(cwd, ".claude", "skills")] }).catch(() => void 0);
+    void client.request("skills/extraRoots/set", { extraRoots: [import_node_path27.default.join(cwd, ".claude", "skills")] }).catch(() => void 0);
     const res = await Promise.race([client.request("skills/list", { cwds: [cwd] }), timeout]);
     return mapSkillsListResponse(res);
   } finally {
@@ -50335,14 +52002,14 @@ async function listCodexSkills(cwd, deps = {}) {
 // src/workspace/browser.ts
 var import_node_fs26 = __toESM(require("fs"), 1);
 var import_node_os8 = __toESM(require("os"), 1);
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_path28 = __toESM(require("path"), 1);
 init_protocol();
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
 function resolveInsideCwd(cwd, subpath) {
-  const absCwd = import_node_path27.default.resolve(cwd);
-  const joined = import_node_path27.default.resolve(absCwd, subpath ?? ".");
-  const rel = import_node_path27.default.relative(absCwd, joined);
-  if (rel.startsWith("..") || import_node_path27.default.isAbsolute(rel)) {
+  const absCwd = import_node_path28.default.resolve(cwd);
+  const joined = import_node_path28.default.resolve(absCwd, subpath ?? ".");
+  const rel = import_node_path28.default.relative(absCwd, joined);
+  if (rel.startsWith("..") || import_node_path28.default.isAbsolute(rel)) {
     throw new ClawdError(ERROR_CODES.INVALID_PATH, `path escapes cwd: ${subpath}`);
   }
   return joined;
@@ -50373,7 +52040,7 @@ var WorkspaceBrowser = class {
         mtime: ""
       };
       try {
-        const st = import_node_fs26.default.statSync(import_node_path27.default.join(full, d.name));
+        const st = import_node_fs26.default.statSync(import_node_path28.default.join(full, d.name));
         entry.mtime = new Date(st.mtimeMs).toISOString();
         if (d.isFile()) entry.size = st.size;
       } catch {
@@ -50420,7 +52087,7 @@ var WorkspaceBrowser = class {
 // src/skills/agents-scanner.ts
 var import_node_fs27 = __toESM(require("fs"), 1);
 var import_node_os9 = __toESM(require("os"), 1);
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_path29 = __toESM(require("path"), 1);
 var DEFAULT_POLICY_DIR_DARWIN = "/Library/Application Support/ClaudeCode/.claude/agents";
 function isDirLikeSync2(p2) {
   try {
@@ -50458,10 +52125,10 @@ function scanAgentsDir(dir, source, seen, out) {
   }
   for (const ent of entries) {
     if (!ent.name.endsWith(".md")) continue;
-    if (!ent.isFile() && !(ent.isSymbolicLink() && fileExistsSync(import_node_path28.default.join(dir, ent.name)))) {
+    if (!ent.isFile() && !(ent.isSymbolicLink() && fileExistsSync(import_node_path29.default.join(dir, ent.name)))) {
       continue;
     }
-    const filePath = import_node_path28.default.join(dir, ent.name);
+    const filePath = import_node_path29.default.join(dir, ent.name);
     const baseName = ent.name.replace(/\.md$/, "");
     if (seen.has(baseName)) continue;
     seen.add(baseName);
@@ -50484,7 +52151,7 @@ function scanPluginAgentsTree(root, pluginName, seen, out) {
       return;
     }
     for (const ent of entries) {
-      const childPath = import_node_path28.default.join(dir, ent.name);
+      const childPath = import_node_path29.default.join(dir, ent.name);
       if (ent.isDirectory() || ent.isSymbolicLink() && isDirLikeSync2(childPath)) {
         walk2(childPath, [...namespaces, ent.name]);
         continue;
@@ -50509,9 +52176,9 @@ function scanPluginAgentsTree(root, pluginName, seen, out) {
   walk2(root, []);
 }
 function readInstalledPlugins2(home) {
-  const pluginsDir = import_node_path28.default.join(home, ".claude", "plugins");
-  const v2 = import_node_path28.default.join(pluginsDir, "installed_plugins_v2.json");
-  const v1 = import_node_path28.default.join(pluginsDir, "installed_plugins.json");
+  const pluginsDir = import_node_path29.default.join(home, ".claude", "plugins");
+  const v2 = import_node_path29.default.join(pluginsDir, "installed_plugins_v2.json");
+  const v1 = import_node_path29.default.join(pluginsDir, "installed_plugins.json");
   let raw = null;
   for (const candidate of [v2, v1]) {
     try {
@@ -50540,19 +52207,19 @@ function readInstalledPlugins2(home) {
   return out;
 }
 function walkUpProjectAgentsDirs(startCwd, home, seen, out) {
-  let cur = import_node_path28.default.resolve(startCwd);
-  const fsRoot = import_node_path28.default.parse(cur).root;
+  let cur = import_node_path29.default.resolve(startCwd);
+  const fsRoot = import_node_path29.default.parse(cur).root;
   while (true) {
-    scanAgentsDir(import_node_path28.default.join(cur, ".claude", "agents"), "project", seen, out);
+    scanAgentsDir(import_node_path29.default.join(cur, ".claude", "agents"), "project", seen, out);
     let hasGit = false;
     try {
-      hasGit = import_node_fs27.default.existsSync(import_node_path28.default.join(cur, ".git"));
+      hasGit = import_node_fs27.default.existsSync(import_node_path29.default.join(cur, ".git"));
     } catch {
     }
     if (hasGit) return;
     if (cur === home) return;
     if (cur === fsRoot) return;
-    const parent = import_node_path28.default.dirname(cur);
+    const parent = import_node_path29.default.dirname(cur);
     if (parent === cur) return;
     cur = parent;
   }
@@ -50587,7 +52254,7 @@ var AgentsScanner = class {
     }
     const fsBlock = [];
     scanAgentsDir(
-      import_node_path28.default.join(this.home, ".claude", "agents"),
+      import_node_path29.default.join(this.home, ".claude", "agents"),
       "global",
       seen,
       fsBlock
@@ -50601,7 +52268,7 @@ var AgentsScanner = class {
       ...this.extraPluginRoots
     ];
     for (const { name, root } of plugins) {
-      const agentsRoot = import_node_path28.default.join(root, "agents");
+      const agentsRoot = import_node_path29.default.join(root, "agents");
       scanPluginAgentsTree(agentsRoot, name, seen, fsBlock);
     }
     return [...builtinBlock, ...fsBlock];
@@ -50611,13 +52278,13 @@ var AgentsScanner = class {
 // src/observer/session-observer.ts
 var import_node_fs29 = __toESM(require("fs"), 1);
 var import_node_os11 = __toESM(require("os"), 1);
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_path31 = __toESM(require("path"), 1);
 init_claude_history();
 
 // src/observer/subagent-meta-observer.ts
 var import_node_fs28 = __toESM(require("fs"), 1);
 var import_node_os10 = __toESM(require("os"), 1);
-var import_node_path29 = __toESM(require("path"), 1);
+var import_node_path30 = __toESM(require("path"), 1);
 init_claude_history();
 var META_RE = /^agent-([A-Za-z0-9_-]+)\.meta\.json$/;
 var SubagentMetaObserver = class {
@@ -50630,7 +52297,7 @@ var SubagentMetaObserver = class {
   watches = /* @__PURE__ */ new Map();
   // public for spec only：测试直接拼路径写假 meta.json；生产 start() 内部自己解析
   resolveSubagentDir(cwd, toolSessionId) {
-    return import_node_path29.default.join(
+    return import_node_path30.default.join(
       this.home,
       ".claude",
       "projects",
@@ -50686,7 +52353,7 @@ var SubagentMetaObserver = class {
     if (!m2) return;
     const agentId = m2[1];
     if (w2.emitted.has(agentId)) return;
-    const file = import_node_path29.default.join(w2.dirPath, name);
+    const file = import_node_path30.default.join(w2.dirPath, name);
     let raw;
     try {
       raw = import_node_fs28.default.readFileSync(file, "utf8");
@@ -50746,7 +52413,7 @@ var SessionObserver = class {
   metaObserver;
   resolveJsonlPath(cwd, toolSessionId, override) {
     if (override) return override;
-    return import_node_path30.default.join(this.home, ".claude", "projects", cwdToHashDir(cwd), `${toolSessionId}.jsonl`);
+    return import_node_path31.default.join(this.home, ".claude", "projects", cwdToHashDir(cwd), `${toolSessionId}.jsonl`);
   }
   start(args) {
     this.stop(args.sessionId);
@@ -50772,10 +52439,10 @@ var SessionObserver = class {
       lastDeriveMs: 0
     };
     try {
-      import_node_fs29.default.mkdirSync(import_node_path30.default.dirname(filePath), { recursive: true });
+      import_node_fs29.default.mkdirSync(import_node_path31.default.dirname(filePath), { recursive: true });
     } catch {
     }
-    w2.watcher = import_node_fs29.default.watch(import_node_path30.default.dirname(filePath), { persistent: false }, (_event, changedName) => {
+    w2.watcher = import_node_fs29.default.watch(import_node_path31.default.dirname(filePath), { persistent: false }, (_event, changedName) => {
       if (!changedName || !w2.filePath.endsWith(changedName)) return;
       this.poll(w2);
     });
@@ -50872,7 +52539,7 @@ var SessionObserver = class {
     const now = Date.now();
     if (now - w2.lastRelocateScanMs < 1e3) return;
     w2.lastRelocateScanMs = now;
-    const projectsRoot = import_node_path30.default.join(this.home, ".claude", "projects");
+    const projectsRoot = import_node_path31.default.join(this.home, ".claude", "projects");
     const found = findTranscriptByToolSessionId(projectsRoot, w2.toolSessionId);
     if (!found || found === w2.filePath) return;
     try {
@@ -50881,7 +52548,7 @@ var SessionObserver = class {
     }
     w2.filePath = found;
     try {
-      w2.watcher = import_node_fs29.default.watch(import_node_path30.default.dirname(found), { persistent: false }, (_event, changedName) => {
+      w2.watcher = import_node_fs29.default.watch(import_node_path31.default.dirname(found), { persistent: false }, (_event, changedName) => {
         if (!changedName || !w2.filePath.endsWith(changedName)) return;
         this.poll(w2);
       });
@@ -51310,7 +52977,7 @@ var LocalWsServer = class {
       } catch {
       }
     }, this.pingIntervalMs);
-    this.clients.set(id, { handle, ws: socket, pingTimer, ctx: null });
+    this.clients.set(id, { handle, ws: socket, pingTimer, ctx: null, connectedAt: Date.now() });
     this.logger?.info("client connected", { clientId: id, total: this.clients.size, remoteAddress });
     const authGate = this.opts.authGate;
     let authed = true;
@@ -51435,6 +53102,18 @@ var LocalWsServer = class {
   clientCount() {
     return this.clients.size;
   }
+  // device:connections 数据源：owner 连接快照。
+  // principal.kind==='guest'（connect/visitor 票种）不列——不是"我的设备"，也不向 UI
+  // 泄露 guest 信息；ctx===null 是 noAuth localhost 路径（dispatcher 按 owner fallback
+  // 处理），视作 owner 列入。
+  listOwnerConnections() {
+    const out = [];
+    for (const [id, c] of this.clients) {
+      if (c.ctx && c.ctx.principal.kind !== "owner") continue;
+      out.push({ clientId: id, connectedAt: c.connectedAt, clientInfo: c.ctx?.clientInfo });
+    }
+    return out.sort((a, b2) => a.connectedAt - b2.connectedAt);
+  }
 };
 function addSubscription(client, sessionId) {
   const cur = client.subscribedSessions.get(sessionId) ?? 0;
@@ -51665,7 +53344,7 @@ async function authenticate(token, deps) {
 
 // src/legacy-cleanup.ts
 var fs34 = __toESM(require("fs/promises"), 1);
-var path35 = __toESM(require("path"), 1);
+var path36 = __toESM(require("path"), 1);
 var LEGACY_FILES = [
   "personal-capability.json",
   "received-capabilities.json",
@@ -51674,7 +53353,7 @@ var LEGACY_FILES = [
 async function cleanupLegacyCapabilityFiles(dataDir, logger) {
   const removed = [];
   for (const name of LEGACY_FILES) {
-    const p2 = path35.join(dataDir, name);
+    const p2 = path36.join(dataDir, name);
     try {
       await fs34.unlink(p2);
       removed.push(name);
@@ -51689,7 +53368,7 @@ async function cleanupLegacyCapabilityFiles(dataDir, logger) {
 
 // src/inbox/inbox-store.ts
 var fs35 = __toESM(require("fs"), 1);
-var path36 = __toESM(require("path"), 1);
+var path37 = __toESM(require("path"), 1);
 var INBOX_SUBDIR = "inbox";
 var InboxStore = class {
   constructor(dataDir) {
@@ -51787,10 +53466,10 @@ var InboxStore = class {
     }
   }
   dirPath() {
-    return path36.join(this.dataDir, INBOX_SUBDIR);
+    return path37.join(this.dataDir, INBOX_SUBDIR);
   }
   filePath(peerDeviceId) {
-    return path36.join(this.dirPath(), `${peerDeviceId}.jsonl`);
+    return path37.join(this.dirPath(), `${peerDeviceId}.jsonl`);
   }
 };
 function parseAllLines(raw) {
@@ -51879,7 +53558,7 @@ var InboxManager = class {
 
 // src/state/contact-store.ts
 var fs36 = __toESM(require("fs"), 1);
-var path37 = __toESM(require("path"), 1);
+var path38 = __toESM(require("path"), 1);
 var FILE_NAME = "contacts.json";
 var ContactStore = class {
   constructor(dataDir) {
@@ -51889,7 +53568,7 @@ var ContactStore = class {
   contacts = /* @__PURE__ */ new Map();
   load() {
     this.contacts.clear();
-    const file = path37.join(this.dataDir, FILE_NAME);
+    const file = path38.join(this.dataDir, FILE_NAME);
     let raw;
     try {
       raw = fs36.readFileSync(file, "utf8");
@@ -51961,7 +53640,7 @@ var ContactStore = class {
     return true;
   }
   flush() {
-    const file = path37.join(this.dataDir, FILE_NAME);
+    const file = path38.join(this.dataDir, FILE_NAME);
     const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
     const content = JSON.stringify(
       { contacts: Array.from(this.contacts.values()) },
@@ -52083,52 +53762,52 @@ async function connectRemote(args) {
 
 // src/migrations/2026-05-20-flatten-sessions.ts
 var fs37 = __toESM(require("fs"), 1);
-var path38 = __toESM(require("path"), 1);
+var path39 = __toESM(require("path"), 1);
 var MIGRATION_FLAG_NAME = ".migration.v1.done";
 function migrateFlattenSessions(opts) {
   const dataDir = opts.dataDir;
   const now = opts.now ?? Date.now;
-  const sessionsDir = path38.join(dataDir, "sessions");
-  const flagPath = path38.join(sessionsDir, MIGRATION_FLAG_NAME);
+  const sessionsDir = path39.join(dataDir, "sessions");
+  const flagPath = path39.join(sessionsDir, MIGRATION_FLAG_NAME);
   if (existsSync3(flagPath)) {
     return { skipped: true, flagWritten: false, movedBare: 0, movedVmOwner: 0, archivedListener: 0 };
   }
   let movedBare = 0;
   let movedVmOwner = 0;
   let archivedListener = 0;
-  const defaultDir = path38.join(sessionsDir, "default");
+  const defaultDir = path39.join(sessionsDir, "default");
   if (existsSync3(defaultDir)) {
     for (const entry of readdirSafe(defaultDir)) {
       if (!entry.endsWith(".json")) continue;
-      const src = path38.join(defaultDir, entry);
-      const dst = path38.join(sessionsDir, entry);
+      const src = path39.join(defaultDir, entry);
+      const dst = path39.join(sessionsDir, entry);
       fs37.renameSync(src, dst);
       movedBare += 1;
     }
     rmdirIfEmpty(defaultDir);
   }
   for (const pid of readdirSafe(sessionsDir)) {
-    const personaDir = path38.join(sessionsDir, pid);
+    const personaDir = path39.join(sessionsDir, pid);
     if (!isDir(personaDir)) continue;
     if (pid === "default") continue;
-    const ownerSrc = path38.join(personaDir, "owner");
+    const ownerSrc = path39.join(personaDir, "owner");
     if (existsSync3(ownerSrc) && isDir(ownerSrc)) {
-      const ownerDst = path38.join(dataDir, "personas", pid, ".clawd", "sessions", "owner");
+      const ownerDst = path39.join(dataDir, "personas", pid, ".clawd", "sessions", "owner");
       fs37.mkdirSync(ownerDst, { recursive: true });
       for (const file of readdirSafe(ownerSrc)) {
         if (!file.endsWith(".json")) continue;
-        fs37.renameSync(path38.join(ownerSrc, file), path38.join(ownerDst, file));
+        fs37.renameSync(path39.join(ownerSrc, file), path39.join(ownerDst, file));
         movedVmOwner += 1;
       }
       rmdirIfEmpty(ownerSrc);
     }
-    const listenerSrc = path38.join(personaDir, "listener");
+    const listenerSrc = path39.join(personaDir, "listener");
     if (existsSync3(listenerSrc) && isDir(listenerSrc)) {
-      const archiveDst = path38.join(dataDir, ".legacy", `listener-${pid}`);
+      const archiveDst = path39.join(dataDir, ".legacy", `listener-${pid}`);
       fs37.mkdirSync(archiveDst, { recursive: true });
       for (const file of readdirSafe(listenerSrc)) {
         if (!file.endsWith(".json")) continue;
-        fs37.renameSync(path38.join(listenerSrc, file), path38.join(archiveDst, file));
+        fs37.renameSync(path39.join(listenerSrc, file), path39.join(archiveDst, file));
         archivedListener += 1;
       }
       rmdirIfEmpty(listenerSrc);
@@ -52176,10 +53855,10 @@ function rmdirIfEmpty(p2) {
 
 // src/transport/http-router.ts
 var import_node_fs31 = __toESM(require("fs"), 1);
-var import_node_path34 = __toESM(require("path"), 1);
+var import_node_path35 = __toESM(require("path"), 1);
 
 // src/attachment/mime.ts
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_path32 = __toESM(require("path"), 1);
 var TEXT_PLAIN = "text/plain; charset=utf-8";
 var EXT_TO_NATIVE_MIME = {
   // 图片
@@ -52286,7 +53965,7 @@ var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
   ".mk"
 ]);
 function lookupMime(filePathOrName) {
-  const ext = import_node_path31.default.extname(filePathOrName).toLowerCase();
+  const ext = import_node_path32.default.extname(filePathOrName).toLowerCase();
   if (EXT_TO_NATIVE_MIME[ext]) return EXT_TO_NATIVE_MIME[ext];
   if (TEXT_EXTENSIONS.has(ext)) return TEXT_PLAIN;
   return "application/octet-stream";
@@ -52357,7 +54036,7 @@ function verifySignedUrl(secret, absPath, eRaw, s, now = Date.now) {
 
 // src/attachment/upload.ts
 var import_node_fs30 = __toESM(require("fs"), 1);
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_path33 = __toESM(require("path"), 1);
 var import_node_crypto8 = __toESM(require("crypto"), 1);
 var import_promises3 = require("stream/promises");
 var UploadError = class extends Error {
@@ -52369,14 +54048,14 @@ var UploadError = class extends Error {
   code;
 };
 function assertValidFileName(fileName) {
-  if (fileName.length === 0 || fileName === "." || fileName === ".." || fileName.startsWith(".") || fileName.includes("/") || fileName.includes("\\") || fileName !== import_node_path32.default.basename(fileName)) {
+  if (fileName.length === 0 || fileName === "." || fileName === ".." || fileName.startsWith(".") || fileName.includes("/") || fileName.includes("\\") || fileName !== import_node_path33.default.basename(fileName)) {
     throw new UploadError("INVALID_FILENAME", `fileName must be a plain basename, got: ${fileName}`);
   }
 }
 var HASH_PREFIX_LEN = 16;
 async function writeUploadedAttachment(args) {
   assertValidFileName(args.fileName);
-  const attachmentsRoot = import_node_path32.default.join(args.sessionDir, ".attachments");
+  const attachmentsRoot = import_node_path33.default.join(args.sessionDir, ".attachments");
   try {
     import_node_fs30.default.mkdirSync(attachmentsRoot, { recursive: true });
   } catch (err) {
@@ -52384,7 +54063,7 @@ async function writeUploadedAttachment(args) {
   }
   const hasher = import_node_crypto8.default.createHash("sha256");
   let actualSize = 0;
-  const tmpPath = import_node_path32.default.join(
+  const tmpPath = import_node_path33.default.join(
     attachmentsRoot,
     `.upload-${process.pid}-${Date.now()}-${import_node_crypto8.default.randomBytes(4).toString("hex")}`
   );
@@ -52419,7 +54098,7 @@ async function writeUploadedAttachment(args) {
     );
   }
   const attachmentId = hasher.digest("hex").slice(0, HASH_PREFIX_LEN);
-  const hashDir = import_node_path32.default.join(attachmentsRoot, attachmentId);
+  const hashDir = import_node_path33.default.join(attachmentsRoot, attachmentId);
   let finalFileName;
   let hashDirExists = false;
   try {
@@ -52437,7 +54116,7 @@ async function writeUploadedAttachment(args) {
     try {
       import_node_fs30.default.mkdirSync(hashDir, { recursive: true });
       finalFileName = args.fileName;
-      import_node_fs30.default.renameSync(tmpPath, import_node_path32.default.join(hashDir, finalFileName));
+      import_node_fs30.default.renameSync(tmpPath, import_node_path33.default.join(hashDir, finalFileName));
     } catch (err) {
       try {
         import_node_fs30.default.unlinkSync(tmpPath);
@@ -52446,8 +54125,8 @@ async function writeUploadedAttachment(args) {
       throw new UploadError("STORAGE_ERROR", `rename failed: ${err.message}`);
     }
   }
-  const absPath = import_node_path32.default.join(hashDir, finalFileName);
-  const relPath = import_node_path32.default.relative(args.sessionDir, absPath);
+  const absPath = import_node_path33.default.join(hashDir, finalFileName);
+  const relPath = import_node_path33.default.relative(args.sessionDir, absPath);
   args.groupFileStore.upsert(args.scope, args.sessionId, {
     relPath: absPath,
     // 存绝对路径，与现有 agent 入清单的形态一致（attachment.ts:144 双形态兼容）
@@ -52461,7 +54140,7 @@ async function writeUploadedAttachment(args) {
 
 // src/extension/import.ts
 var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_path33 = __toESM(require("path"), 1);
+var import_node_path34 = __toESM(require("path"), 1);
 var import_node_os12 = __toESM(require("os"), 1);
 var import_jszip = __toESM(require_lib3(), 1);
 var ImportError = class extends Error {
@@ -52479,7 +54158,7 @@ async function importZip(buf, root) {
     throw new ImportError("ZIP_INVALID", `failed to load zip: ${e.message}`);
   }
   for (const name of Object.keys(zip.files)) {
-    if (name.includes("..") || name.startsWith("/") || import_node_path33.default.isAbsolute(name)) {
+    if (name.includes("..") || name.startsWith("/") || import_node_path34.default.isAbsolute(name)) {
       throw new ImportError("ZIP_INVALID", `unsafe zip entry path: ${name}`);
     }
   }
@@ -52512,7 +54191,7 @@ async function importZip(buf, root) {
       );
     }
   }
-  const destDir = import_node_path33.default.join(root, manifest.id);
+  const destDir = import_node_path34.default.join(root, manifest.id);
   let destExists = false;
   try {
     await import_promises4.default.access(destDir);
@@ -52522,15 +54201,15 @@ async function importZip(buf, root) {
   if (destExists) {
     throw new ImportError("ALREADY_EXISTS", `extension ${manifest.id} already installed`);
   }
-  const stage = await import_promises4.default.mkdtemp(import_node_path33.default.join(import_node_os12.default.tmpdir(), `clawd-ext-stage-${manifest.id}-`));
+  const stage = await import_promises4.default.mkdtemp(import_node_path34.default.join(import_node_os12.default.tmpdir(), `clawd-ext-stage-${manifest.id}-`));
   try {
     for (const [name, entry] of Object.entries(zip.files)) {
-      const dest = import_node_path33.default.join(stage, name);
+      const dest = import_node_path34.default.join(stage, name);
       if (entry.dir) {
         await import_promises4.default.mkdir(dest, { recursive: true });
         continue;
       }
-      await import_promises4.default.mkdir(import_node_path33.default.dirname(dest), { recursive: true });
+      await import_promises4.default.mkdir(import_node_path34.default.dirname(dest), { recursive: true });
       const content = await entry.async("nodebuffer");
       await import_promises4.default.writeFile(dest, content);
     }
@@ -52560,7 +54239,7 @@ var SHARE_UI_ASSET_MIME = {
   ".wasm": "application/wasm"
 };
 function shareUiAssetMime(filePath) {
-  const ext = import_node_path34.default.extname(filePath).toLowerCase();
+  const ext = import_node_path35.default.extname(filePath).toLowerCase();
   return SHARE_UI_ASSET_MIME[ext] ?? lookupMime(filePath);
 }
 var AUTHED_RPC_ROUTE_PREFIX = "/rpc/";
@@ -52641,7 +54320,7 @@ function isValidUploadFileName(fileName) {
   if (fileName === "." || fileName === "..") return false;
   if (fileName.startsWith(".")) return false;
   if (fileName.includes("/") || fileName.includes("\\")) return false;
-  return fileName === import_node_path34.default.basename(fileName);
+  return fileName === import_node_path35.default.basename(fileName);
 }
 function createHttpRouter(deps) {
   return async (req, res) => {
@@ -52858,7 +54537,7 @@ function createHttpRouter(deps) {
         sendHtml(res, statusByCode[r.code], loader.renderErrorHtml(r.code, msgByCode[r.code]));
         return true;
       }
-      sendHtml(res, 200, loader.renderViewerHtml(import_node_path34.default.basename(r.absPath)));
+      sendHtml(res, 200, loader.renderViewerHtml(import_node_path35.default.basename(r.absPath)));
       return true;
     }
     const ctx = deps.authResolver.resolveFromHeader(
@@ -52979,7 +54658,7 @@ function createHttpRouter(deps) {
         return true;
       }
       let absPath;
-      if (import_node_path34.default.isAbsolute(pathParam)) {
+      if (import_node_path35.default.isAbsolute(pathParam)) {
         absPath = pathParam;
       } else if (deps.sessionStore) {
         const file = deps.sessionStore.read(sid);
@@ -52987,7 +54666,7 @@ function createHttpRouter(deps) {
           sendJson(res, 404, { code: "NOT_FOUND", message: `session ${sid} not found` });
           return true;
         }
-        absPath = import_node_path34.default.join(file.cwd, pathParam);
+        absPath = import_node_path35.default.join(file.cwd, pathParam);
       } else {
         sendJson(res, 501, withCtx(ctx, { code: "NOT_IMPLEMENTED", message: "sessionStore not wired" }));
         return true;
@@ -53089,7 +54768,7 @@ function streamFile(res, absPath, logger) {
     return;
   }
   const mime = lookupMime(absPath);
-  const basename = import_node_path34.default.basename(absPath);
+  const basename = import_node_path35.default.basename(absPath);
   res.writeHead(200, {
     "Content-Type": mime,
     "Content-Length": String(stat.size),
@@ -53107,7 +54786,7 @@ function streamFile(res, absPath, logger) {
 
 // src/attachment/gc.ts
 var import_node_fs32 = __toESM(require("fs"), 1);
-var import_node_path35 = __toESM(require("path"), 1);
+var import_node_path36 = __toESM(require("path"), 1);
 var DEFAULT_TTL_MS = 30 * 24 * 3600 * 1e3;
 function runAttachmentGc(args) {
   const now = (args.now ?? Date.now)();
@@ -53116,17 +54795,17 @@ function runAttachmentGc(args) {
   for (const { scope, sessionId } of args.sessionScopes) {
     for (const entry of args.groupFileStore.list(scope, sessionId)) {
       if (entry.stale) continue;
-      if (import_node_path35.default.isAbsolute(entry.relPath)) liveAbs.add(entry.relPath);
+      if (import_node_path36.default.isAbsolute(entry.relPath)) liveAbs.add(entry.relPath);
     }
   }
   for (const { scope, sessionId } of args.sessionScopes) {
-    const sessionDir = args.getSessionCwd?.(sessionId) ?? import_node_path35.default.join(
+    const sessionDir = args.getSessionCwd?.(sessionId) ?? import_node_path36.default.join(
       args.dataDir,
       "sessions",
       ...scopeSubPath(scope).map(safeFileName),
       safeFileName(sessionId)
     );
-    const attRoot = import_node_path35.default.join(sessionDir, ".attachments");
+    const attRoot = import_node_path36.default.join(sessionDir, ".attachments");
     let hashDirs;
     try {
       hashDirs = import_node_fs32.default.readdirSync(attRoot);
@@ -53136,7 +54815,7 @@ function runAttachmentGc(args) {
       continue;
     }
     for (const hashDir of hashDirs) {
-      const hashDirAbs = import_node_path35.default.join(attRoot, hashDir);
+      const hashDirAbs = import_node_path36.default.join(attRoot, hashDir);
       let files;
       try {
         files = import_node_fs32.default.readdirSync(hashDirAbs);
@@ -53144,7 +54823,7 @@ function runAttachmentGc(args) {
         continue;
       }
       for (const name of files) {
-        const file = import_node_path35.default.join(hashDirAbs, name);
+        const file = import_node_path36.default.join(hashDirAbs, name);
         let stat;
         try {
           stat = import_node_fs32.default.statSync(file);
@@ -53175,7 +54854,7 @@ function runAttachmentGc(args) {
 
 // src/attachment/group.ts
 var import_node_fs33 = __toESM(require("fs"), 1);
-var import_node_path36 = __toESM(require("path"), 1);
+var import_node_path37 = __toESM(require("path"), 1);
 var import_node_crypto9 = __toESM(require("crypto"), 1);
 init_protocol();
 var GroupFileStore = class {
@@ -53187,11 +54866,11 @@ var GroupFileStore = class {
     this.logger = opts.logger;
   }
   rootForScope(scope) {
-    return import_node_path36.default.join(this.dataDir, "sessions", ...scopeSubPath(scope).map(safeFileName));
+    return import_node_path37.default.join(this.dataDir, "sessions", ...scopeSubPath(scope).map(safeFileName));
   }
   /** 与 SessionStore.filePath 平级，扩展名 .group-files.json */
   filePath(scope, sessionId) {
-    return import_node_path36.default.join(this.rootForScope(scope), `${safeFileName(sessionId)}.group-files.json`);
+    return import_node_path37.default.join(this.rootForScope(scope), `${safeFileName(sessionId)}.group-files.json`);
   }
   cacheKey(scope, sessionId) {
     return scope.kind === "default" ? `default::${sessionId}` : `persona:${scope.personaId}:${scope.mode}::${sessionId}`;
@@ -53226,7 +54905,7 @@ var GroupFileStore = class {
   }
   writeFile(scope, sessionId, entries) {
     const file = this.filePath(scope, sessionId);
-    import_node_fs33.default.mkdirSync(import_node_path36.default.dirname(file), { recursive: true });
+    import_node_fs33.default.mkdirSync(import_node_path37.default.dirname(file), { recursive: true });
     const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
     import_node_fs33.default.writeFileSync(tmp, JSON.stringify(entries, null, 2), { mode: 384 });
     import_node_fs33.default.renameSync(tmp, file);
@@ -53316,9 +54995,9 @@ var GroupFileStore = class {
 
 // src/discovery/state-file.ts
 var import_node_fs34 = __toESM(require("fs"), 1);
-var import_node_path37 = __toESM(require("path"), 1);
+var import_node_path38 = __toESM(require("path"), 1);
 function defaultStateFilePath(dataDir) {
-  return import_node_path37.default.join(dataDir, "state.json");
+  return import_node_path38.default.join(dataDir, "state.json");
 }
 function isPidAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
@@ -53354,7 +55033,7 @@ var StateFileManager = class {
     return { status: "stale", existing };
   }
   write(state) {
-    import_node_fs34.default.mkdirSync(import_node_path37.default.dirname(this.file), { recursive: true });
+    import_node_fs34.default.mkdirSync(import_node_path38.default.dirname(this.file), { recursive: true });
     const tmp = `${this.file}.tmp.${process.pid}.${Date.now()}`;
     import_node_fs34.default.writeFileSync(tmp, JSON.stringify(state, null, 2), { mode: 384 });
     import_node_fs34.default.renameSync(tmp, this.file);
@@ -53382,13 +55061,13 @@ function readSpawnedByDesktopFromEnv(env = process.env) {
 
 // src/tunnel/tunnel-manager.ts
 var import_node_fs38 = __toESM(require("fs"), 1);
-var import_node_path41 = __toESM(require("path"), 1);
+var import_node_path42 = __toESM(require("path"), 1);
 var import_node_crypto10 = __toESM(require("crypto"), 1);
 var import_node_child_process10 = require("child_process");
 
 // src/tunnel/tunnel-store.ts
 var import_node_fs35 = __toESM(require("fs"), 1);
-var import_node_path38 = __toESM(require("path"), 1);
+var import_node_path39 = __toESM(require("path"), 1);
 var TunnelStore = class {
   constructor(filePath) {
     this.filePath = filePath;
@@ -53407,7 +55086,7 @@ var TunnelStore = class {
     }
   }
   async set(v2) {
-    const dir = import_node_path38.default.dirname(this.filePath);
+    const dir = import_node_path39.default.dirname(this.filePath);
     await import_node_fs35.default.promises.mkdir(dir, { recursive: true });
     const data = JSON.stringify(v2, null, 2);
     const tmp = `${this.filePath}.tmp.${process.pid}.${Date.now()}`;
@@ -53519,7 +55198,7 @@ function escape(v2) {
 // src/tunnel/frpc-binary.ts
 var import_node_fs36 = __toESM(require("fs"), 1);
 var import_node_os13 = __toESM(require("os"), 1);
-var import_node_path39 = __toESM(require("path"), 1);
+var import_node_path40 = __toESM(require("path"), 1);
 var import_node_child_process8 = require("child_process");
 var import_node_stream3 = require("stream");
 var import_promises5 = require("stream/promises");
@@ -53558,13 +55237,13 @@ async function ensureFrpcBinary(opts) {
   }
   const version2 = opts.version ?? FRPC_VERSION;
   const platform = opts.platform ?? detectPlatform();
-  const binDir = import_node_path39.default.join(opts.dataDir, "bin");
+  const binDir = import_node_path40.default.join(opts.dataDir, "bin");
   import_node_fs36.default.mkdirSync(binDir, { recursive: true });
   cleanupStaleArtifacts(binDir);
-  const stableBin = import_node_path39.default.join(binDir, "frpc");
+  const stableBin = import_node_path40.default.join(binDir, "frpc");
   if (import_node_fs36.default.existsSync(stableBin)) return stableBin;
   const partialBin = `${stableBin}.partial`;
-  const tarballPath = import_node_path39.default.join(binDir, `frp_${version2}_${platform.os}_${platform.arch}.tar.gz.partial`);
+  const tarballPath = import_node_path40.default.join(binDir, `frp_${version2}_${platform.os}_${platform.arch}.tar.gz.partial`);
   try {
     const url = frpcDownloadUrl(version2, platform);
     await downloadToFile(url, tarballPath, opts.fetchImpl);
@@ -53590,7 +55269,7 @@ function cleanupStaleArtifacts(binDir) {
   }
   for (const name of entries) {
     if (name.endsWith(".partial") || name.startsWith("extract-")) {
-      const full = import_node_path39.default.join(binDir, name);
+      const full = import_node_path40.default.join(binDir, name);
       try {
         import_node_fs36.default.rmSync(full, { recursive: true, force: true });
       } catch {
@@ -53616,7 +55295,7 @@ async function downloadToFile(url, dest, fetchImpl) {
   await (0, import_promises5.pipeline)(nodeStream, out);
 }
 async function extractFrpcFromTarball(tarball, binDir, version2, platform, destBin) {
-  const work = import_node_path39.default.join(binDir, `extract-${process.pid}-${Date.now()}`);
+  const work = import_node_path40.default.join(binDir, `extract-${process.pid}-${Date.now()}`);
   import_node_fs36.default.mkdirSync(work, { recursive: true });
   try {
     await new Promise((resolve6, reject) => {
@@ -53625,7 +55304,7 @@ async function extractFrpcFromTarball(tarball, binDir, version2, platform, destB
       proc.on("exit", (code) => code === 0 ? resolve6() : reject(new Error(`tar exited ${code}`)));
     });
     const dirName = `frp_${version2}_${platform.os}_${platform.arch}`;
-    const src = import_node_path39.default.join(work, dirName, "frpc");
+    const src = import_node_path40.default.join(work, dirName, "frpc");
     if (!import_node_fs36.default.existsSync(src)) {
       throw new Error(`frpc not found inside tarball at ${src}`);
     }
@@ -53637,10 +55316,10 @@ async function extractFrpcFromTarball(tarball, binDir, version2, platform, destB
 
 // src/tunnel/frpc-process.ts
 var import_node_fs37 = __toESM(require("fs"), 1);
-var import_node_path40 = __toESM(require("path"), 1);
+var import_node_path41 = __toESM(require("path"), 1);
 var import_node_child_process9 = require("child_process");
 function frpcPidFilePath(dataDir) {
-  return import_node_path40.default.join(dataDir, "frpc.pid");
+  return import_node_path41.default.join(dataDir, "frpc.pid");
 }
 function writeFrpcPid(dataDir, pid) {
   try {
@@ -53682,7 +55361,7 @@ function defaultSleep2(ms) {
 }
 async function killStaleFrpc(deps) {
   const pidFile = frpcPidFilePath(deps.dataDir);
-  const tomlPath = import_node_path40.default.join(deps.dataDir, "frpc.toml");
+  const tomlPath = import_node_path41.default.join(deps.dataDir, "frpc.toml");
   const readPidFile = deps.readPidFileImpl ?? defaultReadPidFile;
   const isAlive = deps.isPidAliveImpl ?? defaultIsPidAlive;
   const killPid = deps.killPidImpl ?? defaultKillPid;
@@ -53754,7 +55433,7 @@ var DEFAULT_TUNNEL_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var TunnelManager = class {
   constructor(deps) {
     this.deps = deps;
-    this.store = deps.store ?? new TunnelStore(import_node_path41.default.join(deps.dataDir, "tunnel.json"));
+    this.store = deps.store ?? new TunnelStore(import_node_path42.default.join(deps.dataDir, "tunnel.json"));
     this.ttlMs = deps.ttlMs ?? DEFAULT_TUNNEL_TTL_MS;
     this.startupTimeoutMs = deps.startupTimeoutMs ?? 15e3;
   }
@@ -53881,7 +55560,7 @@ var TunnelManager = class {
         dataDir: this.deps.dataDir,
         override: this.deps.frpcBinaryOverride ?? void 0
       });
-      const tomlPath = import_node_path41.default.join(this.deps.dataDir, "frpc.toml");
+      const tomlPath = import_node_path42.default.join(this.deps.dataDir, "frpc.toml");
       const proxyName = `clawd-${t.subdomain}-${localPort}-${import_node_crypto10.default.randomBytes(3).toString("hex")}`;
       const toml = buildFrpcToml({
         serverAddr: t.frpsHost,
@@ -53896,9 +55575,9 @@ var TunnelManager = class {
       const proc = (this.deps.spawnImpl ?? import_node_child_process10.spawn)(frpcBin, ["-c", tomlPath], {
         stdio: ["ignore", "pipe", "pipe"]
       });
-      const logDir = import_node_path41.default.join(this.deps.dataDir, "log");
+      const logDir = import_node_path42.default.join(this.deps.dataDir, "log");
       import_node_fs38.default.mkdirSync(logDir, { recursive: true });
-      const logFilePath = import_node_path41.default.join(logDir, "frpc.log");
+      const logFilePath = import_node_path42.default.join(logDir, "frpc.log");
       const logStream = import_node_fs38.default.createWriteStream(logFilePath, { flags: "a", mode: 384 });
       logStream.on("error", () => {
       });
@@ -53982,15 +55661,15 @@ async function waitForFrpcReady(proc, timeoutMs) {
 
 // src/tunnel/device-key.ts
 var import_node_os14 = __toESM(require("os"), 1);
-var import_node_path42 = __toESM(require("path"), 1);
+var import_node_path43 = __toESM(require("path"), 1);
 var import_node_crypto11 = __toESM(require("crypto"), 1);
 var DERIVE_SALT = "clawd-tunnel-device-v1";
 function deriveStableDeviceKey(opts = {}) {
   const hostname = opts.hostname ?? import_node_os14.default.hostname();
   const uid = opts.uid ?? (typeof import_node_os14.default.userInfo === "function" ? import_node_os14.default.userInfo().uid : 0);
   const home = opts.home ?? import_node_os14.default.homedir();
-  const defaultDataDir = import_node_path42.default.resolve(import_node_path42.default.join(home, ".clawd"));
-  const normalizedDataDir = opts.dataDir ? import_node_path42.default.resolve(opts.dataDir) : null;
+  const defaultDataDir = import_node_path43.default.resolve(import_node_path43.default.join(home, ".clawd"));
+  const normalizedDataDir = opts.dataDir ? import_node_path43.default.resolve(opts.dataDir) : null;
   const isDefaultDir = normalizedDataDir == null || normalizedDataDir === defaultDataDir;
   const input = isDefaultDir ? `${hostname}::${uid}` : `${hostname}::${uid}::${normalizedDataDir}`;
   return import_node_crypto11.default.createHmac("sha256", DERIVE_SALT).update(input).digest("hex").slice(0, 32);
@@ -53998,11 +55677,11 @@ function deriveStableDeviceKey(opts = {}) {
 
 // src/auth-store.ts
 var import_node_fs39 = __toESM(require("fs"), 1);
-var import_node_path43 = __toESM(require("path"), 1);
+var import_node_path44 = __toESM(require("path"), 1);
 var import_node_crypto12 = __toESM(require("crypto"), 1);
 var AUTH_FILE_NAME = "auth.json";
 function authFilePath(dataDir) {
-  return import_node_path43.default.join(dataDir, AUTH_FILE_NAME);
+  return import_node_path44.default.join(dataDir, AUTH_FILE_NAME);
 }
 function loadOrCreateAuthFile(opts) {
   const file = authFilePath(opts.dataDir);
@@ -54054,7 +55733,7 @@ function readAuthFile(file) {
   }
 }
 function writeAuthFile(file, content) {
-  import_node_fs39.default.mkdirSync(import_node_path43.default.dirname(file), { recursive: true });
+  import_node_fs39.default.mkdirSync(import_node_path44.default.dirname(file), { recursive: true });
   import_node_fs39.default.writeFileSync(file, JSON.stringify(content, null, 2), { mode: 384 });
   try {
     import_node_fs39.default.chmodSync(file, 384);
@@ -54065,11 +55744,11 @@ function writeAuthFile(file, content) {
 // src/owner-profile.ts
 var import_node_fs40 = __toESM(require("fs"), 1);
 var import_node_os15 = __toESM(require("os"), 1);
-var import_node_path44 = __toESM(require("path"), 1);
+var import_node_path45 = __toESM(require("path"), 1);
 var PROFILE_FILENAME = "profile.json";
 function loadOwnerDisplayName(dataDir) {
   const fallback = import_node_os15.default.userInfo().username;
-  const profilePath = import_node_path44.default.join(dataDir, PROFILE_FILENAME);
+  const profilePath = import_node_path45.default.join(dataDir, PROFILE_FILENAME);
   let raw;
   try {
     raw = import_node_fs40.default.readFileSync(profilePath, "utf8");
@@ -54096,12 +55775,12 @@ function loadOwnerDisplayName(dataDir) {
 
 // src/feishu-auth/owner-identity-store.ts
 var import_node_fs41 = __toESM(require("fs"), 1);
-var import_node_path45 = __toESM(require("path"), 1);
+var import_node_path46 = __toESM(require("path"), 1);
 var OWNER_IDENTITY_FILE_NAME = "owner-identity.json";
 var OwnerIdentityStore = class {
   file;
   constructor(dataDir) {
-    this.file = import_node_path45.default.join(dataDir, OWNER_IDENTITY_FILE_NAME);
+    this.file = import_node_path46.default.join(dataDir, OWNER_IDENTITY_FILE_NAME);
   }
   read() {
     let raw;
@@ -54134,7 +55813,7 @@ var OwnerIdentityStore = class {
     };
   }
   write(record) {
-    import_node_fs41.default.mkdirSync(import_node_path45.default.dirname(this.file), { recursive: true });
+    import_node_fs41.default.mkdirSync(import_node_path46.default.dirname(this.file), { recursive: true });
     import_node_fs41.default.writeFileSync(this.file, JSON.stringify(record, null, 2), { mode: 384 });
     try {
       import_node_fs41.default.chmodSync(this.file, 384);
@@ -54280,9 +55959,9 @@ var CentralClientError = class extends Error {
   code;
   cause;
 };
-async function centralRequest(opts, path76, init) {
+async function centralRequest(opts, path77, init) {
   const f = opts.fetchImpl ?? globalThis.fetch;
-  const url = `${opts.api.replace(/\/+$/, "")}${path76}`;
+  const url = `${opts.api.replace(/\/+$/, "")}${path77}`;
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), opts.timeoutMs ?? 15e3);
   let res;
@@ -54477,7 +56156,7 @@ function verifyConnectToken(args) {
 
 // src/feishu-auth/server-key.ts
 var fs51 = __toESM(require("fs"), 1);
-var path54 = __toESM(require("path"), 1);
+var path55 = __toESM(require("path"), 1);
 var FILE_NAME2 = "server-signing-key.json";
 var ServerKeyStore = class {
   constructor(dataDir) {
@@ -54485,7 +56164,7 @@ var ServerKeyStore = class {
   }
   dataDir;
   filePath() {
-    return path54.join(this.dataDir, FILE_NAME2);
+    return path55.join(this.dataDir, FILE_NAME2);
   }
   /** 读缓存的公钥；无缓存 / 损坏 → null（调用方决定是否触发拉取） */
   read() {
@@ -54525,7 +56204,7 @@ init_protocol();
 // src/session/fork.ts
 var import_node_fs42 = __toESM(require("fs"), 1);
 var import_node_os16 = __toESM(require("os"), 1);
-var import_node_path46 = __toESM(require("path"), 1);
+var import_node_path47 = __toESM(require("path"), 1);
 init_claude_history();
 function readJsonlEntries(file) {
   const raw = import_node_fs42.default.readFileSync(file, "utf8");
@@ -54541,19 +56220,19 @@ function readJsonlEntries(file) {
   return out;
 }
 function forkSession(input) {
-  const baseDir = input.baseDir ?? import_node_path46.default.join(import_node_os16.default.homedir(), ".claude");
-  let projectDir = import_node_path46.default.join(baseDir, "projects", cwdToHashDir(input.cwd));
-  let sourceFile = import_node_path46.default.join(projectDir, `${input.toolSessionId}.jsonl`);
+  const baseDir = input.baseDir ?? import_node_path47.default.join(import_node_os16.default.homedir(), ".claude");
+  let projectDir = import_node_path47.default.join(baseDir, "projects", cwdToHashDir(input.cwd));
+  let sourceFile = import_node_path47.default.join(projectDir, `${input.toolSessionId}.jsonl`);
   if (!import_node_fs42.default.existsSync(sourceFile)) {
     const found = findTranscriptByToolSessionId(
-      import_node_path46.default.join(baseDir, "projects"),
+      import_node_path47.default.join(baseDir, "projects"),
       input.toolSessionId
     );
     if (!found) {
       throw new Error(`fork: source transcript not found: ${sourceFile}`);
     }
     sourceFile = found;
-    projectDir = import_node_path46.default.dirname(found);
+    projectDir = import_node_path47.default.dirname(found);
   }
   const entries = readJsonlEntries(sourceFile);
   const mainEntries = entries.filter((e) => e.isSidechain !== true);
@@ -54582,7 +56261,7 @@ function forkSession(input) {
     }
     forkedLines.push(JSON.stringify(forked));
   }
-  const forkedFilePath = import_node_path46.default.join(projectDir, `${forkedToolSessionId}.jsonl`);
+  const forkedFilePath = import_node_path47.default.join(projectDir, `${forkedToolSessionId}.jsonl`);
   import_node_fs42.default.mkdirSync(projectDir, { recursive: true });
   import_node_fs42.default.writeFileSync(forkedFilePath, forkedLines.join("\n") + "\n", { mode: 384 });
   return { forkedToolSessionId, forkedFilePath };
@@ -55001,7 +56680,7 @@ function buildPermissionHandlers(deps) {
 }
 
 // src/handlers/history.ts
-var path57 = __toESM(require("path"), 1);
+var path58 = __toESM(require("path"), 1);
 init_protocol();
 
 // src/session/recent-dirs.ts
@@ -55019,7 +56698,7 @@ function listRecentDirs(store, limit = 50) {
 }
 
 // src/permission/persona-paths.ts
-var path56 = __toESM(require("path"), 1);
+var path57 = __toESM(require("path"), 1);
 function getAllowedPersonaIds(grants, action) {
   const ids = /* @__PURE__ */ new Set();
   for (const g2 of grants) {
@@ -55032,42 +56711,42 @@ function getAllowedPersonaIds(grants, action) {
   return ids;
 }
 function isGuestPathAllowed(grants, absPath, personaRoot, action = "read", userWorkDir) {
-  const target = path56.resolve(absPath);
+  const target = path57.resolve(absPath);
   if (userWorkDir) {
-    const u = path56.resolve(userWorkDir);
-    const usep = u.endsWith(path56.sep) ? "" : path56.sep;
+    const u = path57.resolve(userWorkDir);
+    const usep = u.endsWith(path57.sep) ? "" : path57.sep;
     if (target === u || target.startsWith(u + usep)) return true;
   }
-  const root = path56.resolve(personaRoot);
-  const sep3 = root.endsWith(path56.sep) ? "" : path56.sep;
+  const root = path57.resolve(personaRoot);
+  const sep3 = root.endsWith(path57.sep) ? "" : path57.sep;
   if (!target.startsWith(root + sep3)) return false;
-  const rel = path56.relative(root, target);
+  const rel = path57.relative(root, target);
   if (!rel || rel.startsWith("..")) return false;
-  const personaId2 = rel.split(path56.sep)[0];
+  const personaId2 = rel.split(path57.sep)[0];
   if (!personaId2) return false;
   const allowed = getAllowedPersonaIds(grants, action);
   if (allowed === "*") return true;
   return allowed.has(personaId2);
 }
 function personaIdFromPath(absPath, personaRoot) {
-  const root = path56.resolve(personaRoot);
-  const target = path56.resolve(absPath);
-  const sep3 = root.endsWith(path56.sep) ? "" : path56.sep;
+  const root = path57.resolve(personaRoot);
+  const target = path57.resolve(absPath);
+  const sep3 = root.endsWith(path57.sep) ? "" : path57.sep;
   if (!target.startsWith(root + sep3)) return null;
-  const rel = path56.relative(root, target);
+  const rel = path57.relative(root, target);
   if (!rel || rel.startsWith("..")) return null;
-  const id = rel.split(path56.sep)[0];
+  const id = rel.split(path57.sep)[0];
   return id || null;
 }
 function isPathWithin(dir, absPath) {
-  const d = path56.resolve(dir);
-  const t = path56.resolve(absPath);
-  const sep3 = d.endsWith(path56.sep) ? "" : path56.sep;
+  const d = path57.resolve(dir);
+  const t = path57.resolve(absPath);
+  const sep3 = d.endsWith(path57.sep) ? "" : path57.sep;
   return t === d || t.startsWith(d + sep3);
 }
 function isPathInGuestBoundary(personaRoot, personaId2, userWorkDir, absPath) {
   if (userWorkDir && isPathWithin(userWorkDir, absPath)) return true;
-  return personaIdFromPath(path56.resolve(absPath), personaRoot) === personaId2;
+  return personaIdFromPath(path57.resolve(absPath), personaRoot) === personaId2;
 }
 
 // src/handlers/history.ts
@@ -55119,7 +56798,7 @@ function buildHistoryHandlers(deps) {
         if (!pid) return false;
         return isGuestPathAllowed(
           ctx.grants,
-          path57.join(personaRoot, pid),
+          path58.join(personaRoot, pid),
           personaRoot,
           "read",
           userWorkDir
@@ -55131,7 +56810,7 @@ function buildHistoryHandlers(deps) {
   };
   const list = async (frame, _client, ctx) => {
     const args = HistoryListArgs.parse(frame);
-    assertGuestPath(ctx, path57.resolve(args.projectPath), personaRoot, "history:list", usersRoot);
+    assertGuestPath(ctx, path58.resolve(args.projectPath), personaRoot, "history:list", usersRoot);
     const sessions = await history.listSessions(args);
     return { response: { type: "history:list", sessions } };
   };
@@ -55164,13 +56843,13 @@ function buildHistoryHandlers(deps) {
   };
   const subagents = async (frame, _client, ctx) => {
     const args = HistorySubagentsArgs.parse(frame);
-    assertGuestPath(ctx, path57.resolve(args.cwd), personaRoot, "history:subagents", usersRoot);
+    assertGuestPath(ctx, path58.resolve(args.cwd), personaRoot, "history:subagents", usersRoot);
     const subs = await history.listSubagents(args);
     return { response: { type: "history:subagents", subagents: subs } };
   };
   const subagentRead = async (frame, _client, ctx) => {
     const args = HistorySubagentReadArgs.parse(frame);
-    assertGuestPath(ctx, path57.resolve(args.cwd), personaRoot, "history:subagent-read", usersRoot);
+    assertGuestPath(ctx, path58.resolve(args.cwd), personaRoot, "history:subagent-read", usersRoot);
     const res = await history.readSubagent(args);
     return { response: { type: "history:subagent-read", ...res } };
   };
@@ -55179,7 +56858,7 @@ function buildHistoryHandlers(deps) {
     if (ctx?.principal.kind === "guest" && personaRoot) {
       const userWorkDir = usersRoot ? deriveUserWorkDir(ctx.principal.id, usersRoot) : void 0;
       const filtered = dirs.filter(
-        (d) => isGuestPathAllowed(ctx.grants, path57.resolve(d.cwd), personaRoot, "read", userWorkDir)
+        (d) => isGuestPathAllowed(ctx.grants, path58.resolve(d.cwd), personaRoot, "read", userWorkDir)
       );
       return { response: { type: "history:recentDirs", dirs: filtered } };
     }
@@ -55196,7 +56875,7 @@ function buildHistoryHandlers(deps) {
 }
 
 // src/handlers/workspace.ts
-var path58 = __toESM(require("path"), 1);
+var path59 = __toESM(require("path"), 1);
 var os16 = __toESM(require("os"), 1);
 init_protocol();
 init_protocol();
@@ -55238,22 +56917,22 @@ function buildWorkspaceHandlers(deps) {
     const args = WorkspaceListArgs.parse(frame);
     const isGuest = ctx?.principal.kind === "guest";
     const fallbackCwd = isGuest && personaRoot ? personaRoot : os16.homedir();
-    const resolvedCwd = path58.resolve(args.cwd ?? fallbackCwd);
-    const target = args.path ? path58.resolve(resolvedCwd, args.path) : resolvedCwd;
+    const resolvedCwd = path59.resolve(args.cwd ?? fallbackCwd);
+    const target = args.path ? path59.resolve(resolvedCwd, args.path) : resolvedCwd;
     assertGuestPath2(ctx, target, personaRoot, "workspace:list", usersRoot);
     const res = workspace.list({ ...args, cwd: resolvedCwd });
     return { response: { type: "workspace:list", ...res } };
   };
   const read = async (frame, _client, ctx) => {
     const args = WorkspaceReadArgs.parse(frame);
-    const target = path58.isAbsolute(args.path) ? path58.resolve(args.path) : path58.resolve(args.cwd, args.path);
+    const target = path59.isAbsolute(args.path) ? path59.resolve(args.path) : path59.resolve(args.cwd, args.path);
     assertGuestPath2(ctx, target, personaRoot, "workspace:read", usersRoot);
     const res = workspace.read(args);
     return { response: { type: "workspace:read", ...res } };
   };
   const skillsList = async (frame, _client, ctx) => {
     const args = SkillsListArgs.parse(frame);
-    const cwdAbs = path58.resolve(args.cwd);
+    const cwdAbs = path59.resolve(args.cwd);
     assertGuestPath2(ctx, cwdAbs, personaRoot, "skills:list", usersRoot);
     const list2 = await getSkillsForTool(args.tool ?? "claude", cwdAbs);
     if (ctx?.principal.kind === "guest" && personaRoot) {
@@ -55265,7 +56944,7 @@ function buildWorkspaceHandlers(deps) {
   };
   const agentsList = async (frame, _client, ctx) => {
     const args = AgentsListArgs.parse(frame);
-    const cwdAbs = path58.resolve(args.cwd);
+    const cwdAbs = path59.resolve(args.cwd);
     assertGuestPath2(ctx, cwdAbs, personaRoot, "agents:list", usersRoot);
     if (args.tool === "codex") {
       return { response: { type: "agents:list", agents: [] } };
@@ -55287,18 +56966,18 @@ function buildWorkspaceHandlers(deps) {
 }
 
 // src/handlers/git.ts
-var path60 = __toESM(require("path"), 1);
+var path61 = __toESM(require("path"), 1);
 init_protocol();
 init_protocol();
 
 // src/workspace/git.ts
 var import_node_child_process11 = require("child_process");
 var import_node_fs43 = __toESM(require("fs"), 1);
-var import_node_path47 = __toESM(require("path"), 1);
+var import_node_path48 = __toESM(require("path"), 1);
 var import_node_util = require("util");
 var pexec = (0, import_node_util.promisify)(import_node_child_process11.execFile);
 function normalizePath(p2) {
-  const resolved = import_node_path47.default.resolve(p2);
+  const resolved = import_node_path48.default.resolve(p2);
   try {
     return import_node_fs43.default.realpathSync(resolved);
   } catch {
@@ -55374,7 +57053,7 @@ async function listGitBranches(cwd) {
 function assertGuestCwd(ctx, cwd, personaRoot, method, usersRoot) {
   if (!ctx || ctx.principal.kind !== "guest" || !personaRoot) return;
   const userWorkDir = usersRoot ? deriveUserWorkDir(ctx.principal.id, usersRoot) : void 0;
-  if (!isGuestPathAllowed(ctx.grants, path60.resolve(cwd), personaRoot, "read", userWorkDir)) {
+  if (!isGuestPathAllowed(ctx.grants, path61.resolve(cwd), personaRoot, "read", userWorkDir)) {
     throw new ClawdError(
       ERROR_CODES.UNAUTHORIZED,
       `guest ${ctx.principal.id} cannot ${method} cwd ${cwd}`
@@ -55978,9 +57657,20 @@ function buildDeviceHandlers(deps) {
       }
     }
   };
+  const connections = async (_frame, client, ctx) => {
+    ensureOwner3(ctx);
+    const entries = deps.listOwnerConnections();
+    return {
+      response: {
+        type: "device:connections:ok",
+        connections: entries.map((e) => ({ ...e, self: e.clientId === client.id }))
+      }
+    };
+  };
   return {
     "device:list": list,
-    "device:connect": connect
+    "device:connect": connect,
+    "device:connections": connections
   };
 }
 
@@ -56164,6 +57854,7 @@ var METHOD_GRANT_MAP = {
   // 设备目录 / 连接都是 owner 本机操作（用 owner 的 ttcJwt 找中心 server），guest 不可调
   "device:list": ADMIN_ANY,
   "device:connect": ADMIN_ANY,
+  "device:connections": ADMIN_ANY,
   // ---- app-builder Project picker（spec 2026-06-01-app-builder-project-picker-design） ----
   // owner-only：picker UI 给 owner 管理本机 build 中的 project（fs + 端口分配）。
   // 即使 persona-app-builder 是 PreinstalledPersona，project 管理也属本机 owner 行为，
@@ -56222,21 +57913,21 @@ function computeMethodAccess(args) {
 }
 
 // src/version.ts
-var version = "0.2.269".length > 0 ? "0.2.269" : "dev";
+var version = "0.2.271".length > 0 ? "0.2.271" : "dev";
 
 // src/cli-probe/probe.ts
 var fs54 = __toESM(require("fs"), 1);
-var path61 = __toESM(require("path"), 1);
+var path62 = __toESM(require("path"), 1);
 var PKG_NAME = "@clawos-dev/clawd";
 var BIN_NAME = "clawd";
 var MAX_PARENT_HOPS = 5;
 function probeGlobalCli(pathEnv) {
   if (!pathEnv) return null;
-  for (const dir of pathEnv.split(path61.delimiter)) {
+  for (const dir of pathEnv.split(path62.delimiter)) {
     if (!dir) continue;
     let real;
     try {
-      real = fs54.realpathSync(path61.join(dir, BIN_NAME));
+      real = fs54.realpathSync(path62.join(dir, BIN_NAME));
     } catch {
       continue;
     }
@@ -56246,15 +57937,15 @@ function probeGlobalCli(pathEnv) {
   return null;
 }
 function readOwnPackageVersion(entryPath) {
-  let dir = path61.dirname(entryPath);
+  let dir = path62.dirname(entryPath);
   for (let i = 0; i < MAX_PARENT_HOPS; i++) {
     try {
-      const raw = fs54.readFileSync(path61.join(dir, "package.json"), "utf8");
+      const raw = fs54.readFileSync(path62.join(dir, "package.json"), "utf8");
       const pkg = JSON.parse(raw);
       if (pkg.name !== PKG_NAME) return null;
       return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
     } catch {
-      const parent = path61.dirname(dir);
+      const parent = path62.dirname(dir);
       if (parent === dir) return null;
       dir = parent;
     }
@@ -56314,17 +58005,28 @@ function buildMetaHandlers(deps) {
   };
 }
 function buildMetaMethodsHandler(deps) {
-  return async (_frame, _client, ctx) => {
+  return async (frame, _client, ctx) => {
     const grants = ctx?.grants ?? [];
-    const methods = METHOD_NAMES.map(
-      (method) => computeMethodAccess({
-        method,
-        grants,
-        feishuActive: deps.feishuActive(),
-        isImplemented: deps.isImplemented
-      })
-    );
-    return { response: { type: "meta:methods", methods } };
+    const { method } = MetaMethodsArgs.parse(frame);
+    const compute = (m2) => computeMethodAccess({
+      method: m2,
+      grants,
+      feishuActive: deps.feishuActive(),
+      isImplemented: deps.isImplemented
+    });
+    if (method !== void 0) {
+      if (!isMethodName(method)) {
+        throw new ClawdError(ERROR_CODES.INVALID_PARAM, `unknown method: ${method}`);
+      }
+      const argsSchema = methodArgsSchema(method);
+      return {
+        response: {
+          type: "meta:methods",
+          methods: [{ ...compute(method), ...argsSchema ? { argsSchema } : {} }]
+        }
+      };
+    }
+    return { response: { type: "meta:methods", methods: METHOD_NAMES.map(compute) } };
   };
 }
 
@@ -56401,7 +58103,7 @@ function buildPersonaHandlers(deps) {
 }
 
 // src/handlers/attachment.ts
-var import_node_path48 = __toESM(require("path"), 1);
+var import_node_path49 = __toESM(require("path"), 1);
 init_protocol();
 init_protocol();
 var DEFAULT_TTL_SECONDS = 24 * 3600;
@@ -56481,12 +58183,12 @@ function buildAttachmentHandlers(deps) {
         `session ${args.sessionId} scope unresolved`
       );
     }
-    const cwdAbs = import_node_path48.default.resolve(sessionFile.cwd);
-    const candidateAbs = import_node_path48.default.isAbsolute(args.relPath) ? import_node_path48.default.resolve(args.relPath) : import_node_path48.default.resolve(cwdAbs, args.relPath);
+    const cwdAbs = import_node_path49.default.resolve(sessionFile.cwd);
+    const candidateAbs = import_node_path49.default.isAbsolute(args.relPath) ? import_node_path49.default.resolve(args.relPath) : import_node_path49.default.resolve(cwdAbs, args.relPath);
     guardAttachmentPath(ctx, args.sessionId, candidateAbs, "attachment.signUrl", "group-acl");
     const entries = deps.groupFileStore.list(scope, args.sessionId);
     const entry = entries.find((e) => {
-      const storedAbs = import_node_path48.default.isAbsolute(e.relPath) ? import_node_path48.default.resolve(e.relPath) : import_node_path48.default.resolve(cwdAbs, e.relPath);
+      const storedAbs = import_node_path49.default.isAbsolute(e.relPath) ? import_node_path49.default.resolve(e.relPath) : import_node_path49.default.resolve(cwdAbs, e.relPath);
       return storedAbs === candidateAbs && !e.stale;
     });
     if (!entry) {
@@ -56511,7 +58213,7 @@ function buildAttachmentHandlers(deps) {
     if (!ctx || ctx.principal.kind !== "guest" || !deps.personaRoot || !deps.sessionStore) return;
     const f = deps.sessionStore.read(sessionId);
     if (!f) return;
-    assertGuestAttachmentPath(ctx, import_node_path48.default.resolve(f.cwd), deps.personaRoot, method, deps.usersRoot);
+    assertGuestAttachmentPath(ctx, import_node_path49.default.resolve(f.cwd), deps.personaRoot, method, deps.usersRoot);
   }
   const groupAdd = async (frame, _client, ctx) => {
     if (!deps.groupFileStore || !deps.getSessionScope) {
@@ -56526,8 +58228,8 @@ function buildAttachmentHandlers(deps) {
     if (!scope) {
       throw new ClawdError(ERROR_CODES.VALIDATION_ERROR, `session ${args.sessionId} not found`);
     }
-    const cwdAbs = import_node_path48.default.resolve(deps.sessionStore?.read(args.sessionId)?.cwd ?? ".");
-    const candidateAbs = import_node_path48.default.isAbsolute(args.relPath) ? import_node_path48.default.resolve(args.relPath) : import_node_path48.default.resolve(cwdAbs, args.relPath);
+    const cwdAbs = import_node_path49.default.resolve(deps.sessionStore?.read(args.sessionId)?.cwd ?? ".");
+    const candidateAbs = import_node_path49.default.isAbsolute(args.relPath) ? import_node_path49.default.resolve(args.relPath) : import_node_path49.default.resolve(cwdAbs, args.relPath);
     guardAttachmentPath(ctx, args.sessionId, candidateAbs, "attachment.groupAdd", "cwd-subtree");
     const from = args.origin === "agent" ? "agent" : ctx?.principal.kind === "owner" ? "owner" : "agent";
     const size = 0;
@@ -56586,19 +58288,19 @@ function buildAttachmentHandlers(deps) {
 
 // src/handlers/extension.ts
 var import_promises9 = __toESM(require("fs/promises"), 1);
-var import_node_path53 = __toESM(require("path"), 1);
+var import_node_path54 = __toESM(require("path"), 1);
 init_protocol();
 
 // src/extension/bundle-zip.ts
 var import_promises6 = __toESM(require("fs/promises"), 1);
-var import_node_path49 = __toESM(require("path"), 1);
+var import_node_path50 = __toESM(require("path"), 1);
 var import_node_crypto14 = __toESM(require("crypto"), 1);
 var import_jszip2 = __toESM(require_lib3(), 1);
 async function bundleExtensionDir(dir) {
   const entries = await listFilesSorted(dir);
   const zip = new import_jszip2.default();
   for (const rel of entries) {
-    const abs = import_node_path49.default.join(dir, rel);
+    const abs = import_node_path50.default.join(dir, rel);
     const content = await import_promises6.default.readFile(abs);
     zip.file(rel, content, { date: FIXED_DATE });
   }
@@ -56619,7 +58321,7 @@ async function listFilesSorted(rootDir) {
   return out;
 }
 async function walk(absRoot, relPrefix, out) {
-  const dirAbs = import_node_path49.default.join(absRoot, relPrefix);
+  const dirAbs = import_node_path50.default.join(absRoot, relPrefix);
   const entries = await import_promises6.default.readdir(dirAbs, { withFileTypes: true });
   for (const e of entries) {
     if (IGNORE_BASENAMES.has(e.name)) continue;
@@ -56673,25 +58375,25 @@ function computePublishCheck(args) {
 
 // src/extension/install-flow.ts
 var import_promises7 = __toESM(require("fs/promises"), 1);
-var import_node_path51 = __toESM(require("path"), 1);
+var import_node_path52 = __toESM(require("path"), 1);
 var import_node_os19 = __toESM(require("os"), 1);
 var import_node_crypto15 = __toESM(require("crypto"), 1);
 var import_jszip3 = __toESM(require_lib3(), 1);
 
 // src/extension/paths.ts
 var import_node_os18 = __toESM(require("os"), 1);
-var import_node_path50 = __toESM(require("path"), 1);
+var import_node_path51 = __toESM(require("path"), 1);
 function clawdHomeRoot(override) {
-  return override ?? process.env.CLAWD_HOME ?? import_node_path50.default.join(import_node_os18.default.homedir(), ".clawd");
+  return override ?? process.env.CLAWD_HOME ?? import_node_path51.default.join(import_node_os18.default.homedir(), ".clawd");
 }
 function extensionsRoot(override) {
-  return import_node_path50.default.join(clawdHomeRoot(override), "extensions");
+  return import_node_path51.default.join(clawdHomeRoot(override), "extensions");
 }
 function publishedChannelsFile(override) {
-  return import_node_path50.default.join(clawdHomeRoot(override), "extensions-published.json");
+  return import_node_path51.default.join(clawdHomeRoot(override), "extensions-published.json");
 }
 function bundleCacheRoot(override) {
-  return import_node_path50.default.join(clawdHomeRoot(override), "extension-bundles");
+  return import_node_path51.default.join(clawdHomeRoot(override), "extension-bundles");
 }
 
 // src/extension/install-flow.ts
@@ -56718,7 +58420,7 @@ async function installFromChannel(args, deps) {
     throw new InstallError("ZIP_INVALID", `failed to load zip: ${e.message}`);
   }
   for (const name of Object.keys(zip.files)) {
-    if (name.includes("..") || name.startsWith("/") || import_node_path51.default.isAbsolute(name)) {
+    if (name.includes("..") || name.startsWith("/") || import_node_path52.default.isAbsolute(name)) {
       throw new InstallError("ZIP_INVALID", `unsafe zip entry: ${name}`);
     }
   }
@@ -56750,7 +58452,7 @@ async function installFromChannel(args, deps) {
     );
   }
   const localExtId = namespacedExtId(ownerSlug, channelRef.ownerPrincipalId);
-  const destDir = import_node_path51.default.join(deps.extensionsRoot, localExtId);
+  const destDir = import_node_path52.default.join(deps.extensionsRoot, localExtId);
   let destExists = false;
   try {
     await import_promises7.default.access(destDir);
@@ -56764,16 +58466,16 @@ async function installFromChannel(args, deps) {
     );
   }
   const stage = await import_promises7.default.mkdtemp(
-    import_node_path51.default.join(import_node_os19.default.tmpdir(), `clawd-ext-install-${localExtId}-`)
+    import_node_path52.default.join(import_node_os19.default.tmpdir(), `clawd-ext-install-${localExtId}-`)
   );
   try {
     for (const [name, entry] of Object.entries(zip.files)) {
-      const dest = import_node_path51.default.join(stage, name);
+      const dest = import_node_path52.default.join(stage, name);
       if (entry.dir) {
         await import_promises7.default.mkdir(dest, { recursive: true });
         continue;
       }
-      await import_promises7.default.mkdir(import_node_path51.default.dirname(dest), { recursive: true });
+      await import_promises7.default.mkdir(import_node_path52.default.dirname(dest), { recursive: true });
       if (name === "manifest.json") {
         const rewritten = { ...parsed.data, id: localExtId };
         await import_promises7.default.writeFile(dest, JSON.stringify(rewritten, null, 2));
@@ -56794,7 +58496,7 @@ async function installFromChannel(args, deps) {
 
 // src/extension/update-flow.ts
 var import_promises8 = __toESM(require("fs/promises"), 1);
-var import_node_path52 = __toESM(require("path"), 1);
+var import_node_path53 = __toESM(require("path"), 1);
 var import_node_os20 = __toESM(require("os"), 1);
 var import_node_crypto16 = __toESM(require("crypto"), 1);
 var import_jszip4 = __toESM(require_lib3(), 1);
@@ -56811,11 +58513,11 @@ async function updateFromChannel(args, deps) {
     channelRef.extId,
     channelRef.ownerPrincipalId
   );
-  const liveDir = import_node_path52.default.join(deps.extensionsRoot, localExtId);
+  const liveDir = import_node_path53.default.join(deps.extensionsRoot, localExtId);
   const prevDir = `${liveDir}.prev`;
   let existingVersion;
   try {
-    const raw = await import_promises8.default.readFile(import_node_path52.default.join(liveDir, "manifest.json"), "utf8");
+    const raw = await import_promises8.default.readFile(import_node_path53.default.join(liveDir, "manifest.json"), "utf8");
     const parsed2 = ExtensionManifestSchema.safeParse(JSON.parse(raw));
     if (!parsed2.success) {
       throw new UpdateError(
@@ -56848,7 +58550,7 @@ async function updateFromChannel(args, deps) {
     throw new UpdateError("ZIP_INVALID", `failed to load zip: ${e.message}`);
   }
   for (const name of Object.keys(zip.files)) {
-    if (name.includes("..") || name.startsWith("/") || import_node_path52.default.isAbsolute(name)) {
+    if (name.includes("..") || name.startsWith("/") || import_node_path53.default.isAbsolute(name)) {
       throw new UpdateError("ZIP_INVALID", `unsafe zip entry: ${name}`);
     }
   }
@@ -56883,16 +58585,16 @@ async function updateFromChannel(args, deps) {
   await import_promises8.default.rm(prevDir, { recursive: true, force: true });
   await import_promises8.default.rename(liveDir, prevDir);
   const stage = await import_promises8.default.mkdtemp(
-    import_node_path52.default.join(import_node_os20.default.tmpdir(), `clawd-ext-update-${localExtId}-`)
+    import_node_path53.default.join(import_node_os20.default.tmpdir(), `clawd-ext-update-${localExtId}-`)
   );
   try {
     for (const [name, entry] of Object.entries(zip.files)) {
-      const dest = import_node_path52.default.join(stage, name);
+      const dest = import_node_path53.default.join(stage, name);
       if (entry.dir) {
         await import_promises8.default.mkdir(dest, { recursive: true });
         continue;
       }
-      await import_promises8.default.mkdir(import_node_path52.default.dirname(dest), { recursive: true });
+      await import_promises8.default.mkdir(import_node_path53.default.dirname(dest), { recursive: true });
       if (name === "manifest.json") {
         const rewritten = { ...parsed.data, id: localExtId };
         await import_promises8.default.writeFile(dest, JSON.stringify(rewritten, null, 2));
@@ -56959,7 +58661,7 @@ async function rewriteManifestVersion(root, extId, newVersion, previousPublished
       );
     }
   }
-  const manifestPath = import_node_path53.default.join(root, extId, "manifest.json");
+  const manifestPath = import_node_path54.default.join(root, extId, "manifest.json");
   const manifest = await readManifest(root, extId);
   const next = { ...manifest, version: newVersion };
   const tmp = `${manifestPath}.tmp`;
@@ -56967,7 +58669,7 @@ async function rewriteManifestVersion(root, extId, newVersion, previousPublished
   await import_promises9.default.rename(tmp, manifestPath);
 }
 async function readManifest(root, extId) {
-  const file = import_node_path53.default.join(root, extId, "manifest.json");
+  const file = import_node_path54.default.join(root, extId, "manifest.json");
   let raw;
   try {
     raw = await import_promises9.default.readFile(file, "utf8");
@@ -57051,7 +58753,7 @@ function buildExtensionHandlers(deps) {
   };
   async function buildSnapshotMeta(extId) {
     const manifest = await readManifest(deps.root, extId);
-    const { sha256, buffer } = await bundleExtensionDir(import_node_path53.default.join(deps.root, extId));
+    const { sha256, buffer } = await bundleExtensionDir(import_node_path54.default.join(deps.root, extId));
     return { manifest, contentHash: sha256, buffer };
   }
   const publish = async (frame, _client, ctx) => {
@@ -57228,7 +58930,7 @@ function buildExtensionHandlers(deps) {
 // src/app-builder/project-store.ts
 var import_node_fs44 = require("fs");
 var import_node_child_process12 = require("child_process");
-var import_node_path54 = require("path");
+var import_node_path55 = require("path");
 init_protocol();
 var PROJECTS_DIR = "projects";
 var META_FILE = ".clawd-project.json";
@@ -57242,14 +58944,14 @@ var ProjectStore = class {
   root;
   /** projects/<name>/.clawd-project.json 路径 */
   metaPath(name) {
-    return (0, import_node_path54.join)(this.projectsRoot(), name, META_FILE);
+    return (0, import_node_path55.join)(this.projectsRoot(), name, META_FILE);
   }
   /** projects/<name>/ 目录路径（cwd 用） */
   projectDir(name) {
-    return (0, import_node_path54.join)(this.projectsRoot(), name);
+    return (0, import_node_path55.join)(this.projectsRoot(), name);
   }
   projectsRoot() {
-    return (0, import_node_path54.join)(this.root, PROJECTS_DIR);
+    return (0, import_node_path55.join)(this.root, PROJECTS_DIR);
   }
   async list() {
     let entries;
@@ -57552,7 +59254,7 @@ var PublishJobRegistry = class {
 // src/app-builder/publish-job-runner.ts
 var import_node_child_process14 = require("child_process");
 var import_node_fs45 = require("fs");
-var import_node_path55 = require("path");
+var import_node_path56 = require("path");
 
 // src/app-builder/publish-stage-parser.ts
 var STAGE_RE = /^\s*::stage::(build|deploy|verify)\s*$/;
@@ -57584,7 +59286,7 @@ async function startPublishJob(deps, args) {
     return { jobId: registry2.get(args.name).jobId, status: "already-publishing" };
   }
   const projDir = projectDir(args.name);
-  const logPath = (0, import_node_path55.join)(projDir, ".publish.log");
+  const logPath = (0, import_node_path56.join)(projDir, ".publish.log");
   let logStream = null;
   try {
     logStream = (0, import_node_fs45.createWriteStream)(logPath, { flags: "w" });
@@ -57844,7 +59546,7 @@ async function recoverInterruptedJobs(deps) {
 
 // src/handlers/app-builder.ts
 init_protocol();
-var import_node_path56 = require("path");
+var import_node_path57 = require("path");
 var import_node_fs46 = require("fs");
 var APP_BUILDER_PERSONAS = ["persona-app-builder", "persona-dataclaw-builder"];
 var DEV_SERVER_READY_TIMEOUT_MS = 3e4;
@@ -57995,8 +59697,8 @@ function buildAppBuilderHandlers(deps) {
     const project = await userStore.create(f.name, reservedPorts);
     try {
       const personaRoot = deps.resolvePersonaRoot ? deps.resolvePersonaRoot(session.ownerPersonaId ?? "") : deps.personaRoot;
-      const templateSrcDir = (0, import_node_path56.join)(personaRoot, "extension-kit", "examples", DEFAULT_TEMPLATE);
-      const scaffoldScript = (0, import_node_path56.join)(deps.deployKitRoot, "scripts", "new-extension.sh");
+      const templateSrcDir = (0, import_node_path57.join)(personaRoot, "extension-kit", "examples", DEFAULT_TEMPLATE);
+      const scaffoldScript = (0, import_node_path57.join)(deps.deployKitRoot, "scripts", "new-extension.sh");
       const scaffoldResult = await userStore.scaffold(project.name, templateSrcDir, scaffoldScript);
       deps.logger?.info("app-builder.scaffold.done", {
         name: project.name,
@@ -58200,7 +59902,7 @@ function buildAppBuilderHandlers(deps) {
       await userStore.clearPublishJob(args.name);
     }
     const personaRoot = deps.resolvePersonaRoot ? deps.resolvePersonaRoot(boundSession.ownerPersonaId ?? "") : deps.personaRoot;
-    const scriptPath = (0, import_node_path56.join)(deps.deployKitRoot, "scripts", "publish.sh");
+    const scriptPath = (0, import_node_path57.join)(deps.deployKitRoot, "scripts", "publish.sh");
     deps.logger?.info("app-builder.publish.start", {
       name: args.name,
       sessionId: boundSession.sessionId,
@@ -58376,7 +60078,7 @@ function buildVisitorHandlers(deps) {
 
 // src/extension/registry.ts
 var import_promises10 = __toESM(require("fs/promises"), 1);
-var import_node_path57 = __toESM(require("path"), 1);
+var import_node_path58 = __toESM(require("path"), 1);
 async function loadAll(root) {
   let entries;
   try {
@@ -58389,13 +60091,13 @@ async function loadAll(root) {
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
     if (ent.name.startsWith(".")) continue;
-    records.push(await loadOne(import_node_path57.default.join(root, ent.name), ent.name));
+    records.push(await loadOne(import_node_path58.default.join(root, ent.name), ent.name));
   }
   records.sort((a, b2) => a.extId < b2.extId ? -1 : a.extId > b2.extId ? 1 : 0);
   return records;
 }
 async function loadOne(dir, dirName) {
-  const manifestPath = import_node_path57.default.join(dir, "manifest.json");
+  const manifestPath = import_node_path58.default.join(dir, "manifest.json");
   let raw;
   try {
     raw = await import_promises10.default.readFile(manifestPath, "utf8");
@@ -58440,7 +60142,7 @@ async function loadOne(dir, dirName) {
 
 // src/extension/uninstall.ts
 var import_promises11 = __toESM(require("fs/promises"), 1);
-var import_node_path58 = __toESM(require("path"), 1);
+var import_node_path59 = __toESM(require("path"), 1);
 var UninstallError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -58449,7 +60151,7 @@ var UninstallError = class extends Error {
   code;
 };
 async function uninstall(deps) {
-  const dir = import_node_path58.default.join(deps.root, deps.extId);
+  const dir = import_node_path59.default.join(deps.root, deps.extId);
   try {
     await import_promises11.default.access(dir);
   } catch {
@@ -58979,7 +60681,7 @@ async function dispatchRpc(method, frame, client, ctx, deps) {
 
 // src/extension/runtime.ts
 var import_node_child_process17 = require("child_process");
-var import_node_path59 = __toESM(require("path"), 1);
+var import_node_path60 = __toESM(require("path"), 1);
 var import_promises12 = require("timers/promises");
 
 // src/extension/port-allocator.ts
@@ -59080,7 +60782,7 @@ var Runtime = class {
       /\$CLAWOS_EXT_PORT/g,
       String(port)
     );
-    const dir = import_node_path59.default.join(this.root, extId);
+    const dir = import_node_path60.default.join(this.root, extId);
     const env = {
       ...process.env,
       CLAWOS_EXT_PORT: String(port),
@@ -59192,7 +60894,7 @@ ${handle.stderrTail}`
 
 // src/extension/published-channels.ts
 var import_promises13 = __toESM(require("fs/promises"), 1);
-var import_node_path60 = __toESM(require("path"), 1);
+var import_node_path61 = __toESM(require("path"), 1);
 init_zod();
 var PublishedChannelsError = class extends Error {
   constructor(code, message) {
@@ -59291,7 +60993,7 @@ var PublishedChannelStore = class {
       )
     };
     const tmp = `${this.filePath}.tmp`;
-    await import_promises13.default.mkdir(import_node_path60.default.dirname(this.filePath), { recursive: true });
+    await import_promises13.default.mkdir(import_node_path61.default.dirname(this.filePath), { recursive: true });
     await import_promises13.default.writeFile(tmp, JSON.stringify(data, null, 2), { mode: 384 });
     await import_promises13.default.rename(tmp, this.filePath);
   }
@@ -59299,7 +61001,7 @@ var PublishedChannelStore = class {
 
 // src/extension/bundle-cache.ts
 var import_promises14 = __toESM(require("fs/promises"), 1);
-var import_node_path61 = __toESM(require("path"), 1);
+var import_node_path62 = __toESM(require("path"), 1);
 var BundleCache = class {
   constructor(rootDir) {
     this.rootDir = rootDir;
@@ -59308,14 +61010,14 @@ var BundleCache = class {
   /** Atomic write: stage tmp → rename. Caller passes the hex sha256. */
   async write(snapshotHash, buffer) {
     await import_promises14.default.mkdir(this.rootDir, { recursive: true });
-    const file = import_node_path61.default.join(this.rootDir, `${snapshotHash}.zip`);
+    const file = import_node_path62.default.join(this.rootDir, `${snapshotHash}.zip`);
     const tmp = `${file}.tmp`;
     await import_promises14.default.writeFile(tmp, buffer, { mode: 384 });
     await import_promises14.default.rename(tmp, file);
   }
   /** Returns the bundle bytes, or null when the file doesn't exist. */
   async read(snapshotHash) {
-    const file = import_node_path61.default.join(this.rootDir, `${snapshotHash}.zip`);
+    const file = import_node_path62.default.join(this.rootDir, `${snapshotHash}.zip`);
     try {
       return await import_promises14.default.readFile(file);
     } catch (e) {
@@ -59325,7 +61027,7 @@ var BundleCache = class {
   }
   /** Idempotent — missing file is not an error. */
   async delete(snapshotHash) {
-    const file = import_node_path61.default.join(this.rootDir, `${snapshotHash}.zip`);
+    const file = import_node_path62.default.join(this.rootDir, `${snapshotHash}.zip`);
     await import_promises14.default.rm(file, { force: true });
   }
 };
@@ -59348,24 +61050,24 @@ async function startDaemon(config) {
     sampling: logShippingCfg.sampling,
     homeDir: import_node_os22.default.homedir()
   });
-  const logDir = import_node_path62.default.join(config.dataDir, "log");
+  const logDir = import_node_path63.default.join(config.dataDir, "log");
   import_node_fs47.default.mkdirSync(logDir, { recursive: true });
   const logger = createLogger({
     level: config.logLevel,
-    file: import_node_path62.default.join(logDir, "clawd.log"),
+    file: import_node_path63.default.join(logDir, "clawd.log"),
     logClient
   });
   logger.info("starting clawd", { version, config: { port: config.port, host: config.host, dataDir: config.dataDir } });
   const screenIdleProbeLogger = createFileOnlyLogger({
-    file: import_node_path62.default.join(logDir, "screen-idle-probe.log"),
+    file: import_node_path63.default.join(logDir, "screen-idle-probe.log"),
     level: "debug"
   });
   logger.info("screen-idle probe logger enabled", {
-    file: import_node_path62.default.join(logDir, "screen-idle-probe.log")
+    file: import_node_path63.default.join(logDir, "screen-idle-probe.log")
   });
   const CAP_TARGETS = [
-    import_node_path62.default.join(logDir, "clawd.log"),
-    import_node_path62.default.join(logDir, "screen-idle-probe.log")
+    import_node_path63.default.join(logDir, "clawd.log"),
+    import_node_path63.default.join(logDir, "screen-idle-probe.log")
   ];
   const LOG_CAP_MAX_BYTES = 10 * 1024 * 1024;
   const LOG_CAP_KEEP_BYTES = 5 * 1024 * 1024;
@@ -59461,8 +61163,8 @@ async function startDaemon(config) {
   const agents = new AgentsScanner();
   const history = new ClaudeHistoryReader();
   let transport = null;
-  const personaStore = new PersonaStore(import_node_path62.default.join(config.dataDir, "personas"));
-  const usersRoot = import_node_path62.default.join(config.dataDir, "users");
+  const personaStore = new PersonaStore(import_node_path63.default.join(config.dataDir, "personas"));
+  const usersRoot = import_node_path63.default.join(config.dataDir, "users");
   const defaultsRoot = findDefaultsRoot(logger);
   if (defaultsRoot) {
     seedDefaultPersonas({ store: personaStore, defaultsRoot, logger });
@@ -59482,7 +61184,7 @@ async function startDaemon(config) {
   migrateCodexSandbox({ store: personaStore, logger });
   const groupFileStore = new GroupFileStore({ dataDir: config.dataDir, logger });
   const dispatchStore = createDispatchStore({
-    filePath: import_node_path62.default.join(config.dataDir, "dispatch.json"),
+    filePath: import_node_path63.default.join(config.dataDir, "dispatch.json"),
     now: () => Date.now(),
     onFlushError: (err) => logger.error("dispatch store flush failed", {
       reason: err instanceof Error ? err.message : String(err)
@@ -59497,18 +61199,18 @@ async function startDaemon(config) {
     now: () => Date.now(),
     onCompleted: (sid) => deliverPendingRef?.(sid)
   });
-  const here = typeof __dirname === "string" ? __dirname : import_node_path62.default.dirname((0, import_node_url4.fileURLToPath)(import_meta6.url));
+  const here = typeof __dirname === "string" ? __dirname : import_node_path63.default.dirname((0, import_node_url4.fileURLToPath)(import_meta6.url));
   const mcpConfigs = [];
   const mcpDaemonUrl = `http://127.0.0.1:${config.port}`;
   const dispatchServerCandidates = [
-    import_node_path62.default.join(here, "dispatch", "mcp-server.cjs"),
+    import_node_path63.default.join(here, "dispatch", "mcp-server.cjs"),
     // 生产 dist/index → dist/dispatch/mcp-server.cjs
-    import_node_path62.default.join(here, "..", "dist", "dispatch", "mcp-server.cjs")
+    import_node_path63.default.join(here, "..", "dist", "dispatch", "mcp-server.cjs")
     // dev tsx src/index → ../dist/dispatch/mcp-server.cjs
   ];
   const dispatchServerScriptPath = dispatchServerCandidates.find((p2) => import_node_fs47.default.existsSync(p2));
   if (dispatchServerScriptPath) {
-    const dispatchLogPath = import_node_path62.default.join(logDir, "dispatch-mcp-server.log");
+    const dispatchLogPath = import_node_path63.default.join(logDir, "dispatch-mcp-server.log");
     const dispatchCfgPath = writeDispatchMcpConfig({
       dataDir: config.dataDir,
       serverScriptPath: dispatchServerScriptPath,
@@ -59528,12 +61230,12 @@ async function startDaemon(config) {
     });
   }
   const ticketServerCandidates = [
-    import_node_path62.default.join(here, "ticket", "mcp-server.cjs"),
-    import_node_path62.default.join(here, "..", "dist", "ticket", "mcp-server.cjs")
+    import_node_path63.default.join(here, "ticket", "mcp-server.cjs"),
+    import_node_path63.default.join(here, "..", "dist", "ticket", "mcp-server.cjs")
   ];
   const ticketServerScriptPath = ticketServerCandidates.find((p2) => import_node_fs47.default.existsSync(p2));
   if (ticketServerScriptPath) {
-    const ticketLogPath = import_node_path62.default.join(logDir, "ticket-mcp-server.log");
+    const ticketLogPath = import_node_path63.default.join(logDir, "ticket-mcp-server.log");
     const ticketCfgPath = writeTicketMcpConfig({
       dataDir: config.dataDir,
       serverScriptPath: ticketServerScriptPath,
@@ -59555,12 +61257,12 @@ async function startDaemon(config) {
     });
   }
   const shiftServerCandidates = [
-    import_node_path62.default.join(here, "shift", "mcp-server.cjs"),
-    import_node_path62.default.join(here, "..", "dist", "shift", "mcp-server.cjs")
+    import_node_path63.default.join(here, "shift", "mcp-server.cjs"),
+    import_node_path63.default.join(here, "..", "dist", "shift", "mcp-server.cjs")
   ];
   const shiftServerScriptPath = shiftServerCandidates.find((p2) => import_node_fs47.default.existsSync(p2));
   if (shiftServerScriptPath) {
-    const shiftLogPath = import_node_path62.default.join(logDir, "shift-mcp-server.log");
+    const shiftLogPath = import_node_path63.default.join(logDir, "shift-mcp-server.log");
     const shiftCfgPath = await writeShiftMcpConfig({
       dataDir: config.dataDir,
       serverScriptPath: shiftServerScriptPath,
@@ -59581,12 +61283,12 @@ async function startDaemon(config) {
     );
   }
   const inboxServerCandidates = [
-    import_node_path62.default.join(here, "inbox", "mcp-server.cjs"),
-    import_node_path62.default.join(here, "..", "dist", "inbox", "mcp-server.cjs")
+    import_node_path63.default.join(here, "inbox", "mcp-server.cjs"),
+    import_node_path63.default.join(here, "..", "dist", "inbox", "mcp-server.cjs")
   ];
   const inboxServerScriptPath = inboxServerCandidates.find((p2) => import_node_fs47.default.existsSync(p2));
   if (inboxServerScriptPath) {
-    const inboxLogPath = import_node_path62.default.join(logDir, "inbox-mcp-server.log");
+    const inboxLogPath = import_node_path63.default.join(logDir, "inbox-mcp-server.log");
     const inboxCfgPath = await writeInboxMcpConfig({
       dataDir: config.dataDir,
       serverScriptPath: inboxServerScriptPath,
@@ -59607,8 +61309,8 @@ async function startDaemon(config) {
     );
   }
   const peerOpsServerCandidates = [
-    import_node_path62.default.join(here, "peer-ops", "mcp-server.cjs"),
-    import_node_path62.default.join(here, "..", "dist", "peer-ops", "mcp-server.cjs")
+    import_node_path63.default.join(here, "peer-ops", "mcp-server.cjs"),
+    import_node_path63.default.join(here, "..", "dist", "peer-ops", "mcp-server.cjs")
   ];
   const peerOpsServerScriptPath = peerOpsServerCandidates.find((p2) => import_node_fs47.default.existsSync(p2));
   if (peerOpsServerScriptPath) {
@@ -59630,12 +61332,12 @@ async function startDaemon(config) {
     );
   }
   const rpcToolServerCandidates = [
-    import_node_path62.default.join(here, "rpc-tool", "mcp-server.cjs"),
-    import_node_path62.default.join(here, "..", "dist", "rpc-tool", "mcp-server.cjs")
+    import_node_path63.default.join(here, "rpc-tool", "mcp-server.cjs"),
+    import_node_path63.default.join(here, "..", "dist", "rpc-tool", "mcp-server.cjs")
   ];
   const rpcToolServerScriptPath = rpcToolServerCandidates.find((p2) => import_node_fs47.default.existsSync(p2));
   if (rpcToolServerScriptPath) {
-    const rpcToolLogPath = import_node_path62.default.join(logDir, "rpc-tool-mcp-server.log");
+    const rpcToolLogPath = import_node_path63.default.join(logDir, "rpc-tool-mcp-server.log");
     const rpcToolCfgPath = writeRpcToolMcpConfig({
       dataDir: config.dataDir,
       serverScriptPath: rpcToolServerScriptPath,
@@ -59656,7 +61358,7 @@ async function startDaemon(config) {
     );
   }
   const shiftStore = createShiftStore({
-    filePath: import_node_path62.default.join(config.dataDir, "shift.json"),
+    filePath: import_node_path63.default.join(config.dataDir, "shift.json"),
     ownerIdProvider: () => ownerPrincipalId,
     now: () => Date.now()
   });
@@ -59678,7 +61380,7 @@ async function startDaemon(config) {
     getAdapter,
     historyReader: history,
     dataDir: config.dataDir,
-    personaRoot: import_node_path62.default.join(config.dataDir, "personas"),
+    personaRoot: import_node_path63.default.join(config.dataDir, "personas"),
     // dispatch / shift 自动化 spawn 按 persona 绑定 tool 起 B session（codex persona 用 codex）。
     // personaRegistry 声明在 manager 之后（同作用域 const，调用时机在启动完成后，无 TDZ 风险）。
     getPersonaTool: (personaId2) => personaRegistry.get(personaId2)?.tool,
@@ -59729,7 +61431,7 @@ async function startDaemon(config) {
     // 文件可能 agent 写完又被自己删（罕见），用 size=0 / fallback mime 兜底。
     attachmentGroup: {
       onFileEdit: (input) => {
-        const absPath = import_node_path62.default.isAbsolute(input.relPath) ? input.relPath : import_node_path62.default.join(input.cwd, input.relPath);
+        const absPath = import_node_path63.default.isAbsolute(input.relPath) ? input.relPath : import_node_path63.default.join(input.cwd, input.relPath);
         let size = 0;
         try {
           size = import_node_fs47.default.statSync(absPath).size;
@@ -59973,11 +61675,11 @@ async function startDaemon(config) {
         // 'persona/<pid>/owner'，default 走 'default'。
         getSessionScope: (sid) => manager.findOwnedSessionScope(sid),
         // guest path guard：candidate 必须在 personaRoot 子树或调用者自己的 user-dir 下
-        personaRoot: import_node_path62.default.join(config.dataDir, "personas"),
+        personaRoot: import_node_path63.default.join(config.dataDir, "personas"),
         usersRoot
       },
       // workspace/git/history/skills/agents handler 共用的 guest path guard 锚点
-      personaRoot: import_node_path62.default.join(config.dataDir, "personas"),
+      personaRoot: import_node_path63.default.join(config.dataDir, "personas"),
       // v2 多人 persona 隔离：handler 派生 guest user-dir 放行
       usersRoot,
       // v2 Phase 6: whoami handler 装在 owner principal.displayName + persona 解析
@@ -60078,7 +61780,9 @@ async function startDaemon(config) {
         // 自动反向（spec 决策 #11）：本机可达地址 = tunnel URL（公网），出站连接时
         // 透传让对方反向加我为联系人。无 tunnel（仅本机 ws）→ null，对方不自动反向（不造假数据）。
         // 决策 #16：身份不自报——本机 deviceId/ownerId/provider 由 exchange 签进 token 背书。
-        selfUrl: () => currentTunnelUrl
+        selfUrl: () => currentTunnelUrl,
+        // device:connections 数据源。惰性闭包：wsServer 晚于本 deps 赋值，请求时才解引用。
+        listOwnerConnections: () => wsServer?.listOwnerConnections() ?? []
       },
       // app-builder
       appBuilderStore,
@@ -60101,11 +61805,11 @@ async function startDaemon(config) {
       // 发布上线脚手架化 (spec 2026-06-03 §5.2):
       // appBuilderPersonaRoot 用于拼 publish.sh 绝对路径（persona-app-builder 安装在
       // dataDir/personas/persona-app-builder 之下，extension-kit/scripts/publish.sh 是相对路径）。
-      appBuilderPersonaRoot: import_node_path62.default.join(config.dataDir, "personas", "persona-app-builder"),
+      appBuilderPersonaRoot: import_node_path63.default.join(config.dataDir, "personas", "persona-app-builder"),
       // 共享 deploy-kit 根：scaffold/publish 脚本骨架 + 阿里云凭证单一真源。
-      deployKitRoot: import_node_path62.default.join(config.dataDir, "deploy-kit"),
+      deployKitRoot: import_node_path63.default.join(config.dataDir, "deploy-kit"),
       // scaffold/publish 按当前 session 的 persona 解析其安装根，让每个 persona 用自己的模板/注入配置。
-      resolvePersonaRoot: (personaId2) => import_node_path62.default.join(config.dataDir, "personas", personaId2),
+      resolvePersonaRoot: (personaId2) => import_node_path63.default.join(config.dataDir, "personas", personaId2),
       // 发布上线脚手架化 (spec 2026-06-03 §5.2.2):
       // 复用 SessionManagerDeps.broadcastFrame 同款 dispatch 逻辑 —— runner 调 manager.send
       // 取回 broadcast 帧后逐帧 push 到 transport，跟 manager 自身的 deps 一致。
@@ -60146,19 +61850,7 @@ async function startDaemon(config) {
         sourceSessionId: args.sourceSessionId
       });
       const sourceFile = manager.findOwnedSession(args.sourceSessionId);
-      if (!sourceFile && !args.guestPrincipalId) {
-        throw new Error(`personaDispatch:run source session not found: ${args.sourceSessionId}`);
-      }
-      let sourceJsonlPath = "(no transcript yet \u2014 operate from the task description alone)";
-      if (sourceFile && sourceFile.toolSessionId) {
-        sourceJsonlPath = import_node_path62.default.join(
-          import_node_os22.default.homedir(),
-          ".claude",
-          "projects",
-          cwdToHashDir(sourceFile.cwd),
-          `${sourceFile.toolSessionId}.jsonl`
-        );
-      }
+      const sourceJsonlPath = resolveSourceJsonlPath(sourceFile, import_node_os22.default.homedir());
       logger.info("dispatch.spawnB.source-resolved", {
         dispatchId: args.dispatchId,
         sourceJsonlPath,
@@ -60452,8 +62144,8 @@ async function startDaemon(config) {
       const lines = [
         `Tunnel:      ${r.url}`,
         ...resolvedAuthToken ? [`Connect:     ${connectUrl}`] : [],
-        `Frpc config: ${import_node_path62.default.join(config.dataDir, "frpc.toml")}`,
-        `Frpc log:    ${import_node_path62.default.join(logDir, "frpc.log")}`
+        `Frpc config: ${import_node_path63.default.join(config.dataDir, "frpc.toml")}`,
+        `Frpc log:    ${import_node_path63.default.join(logDir, "frpc.log")}`
       ];
       const width = Math.max(...lines.map((l) => l.length));
       const bar = "\u2550".repeat(width + 4);
@@ -60466,7 +62158,7 @@ ${bar}
 
 `);
       try {
-        const connectPath = import_node_path62.default.join(config.dataDir, "connect.txt");
+        const connectPath = import_node_path63.default.join(config.dataDir, "connect.txt");
         import_node_fs47.default.writeFileSync(connectPath, lines.join("\n") + "\n", { mode: 384 });
       } catch {
       }
@@ -60539,7 +62231,7 @@ ${bar}
   };
 }
 function migrateDropPersonsDir(dataDir) {
-  const dir = import_node_path62.default.join(dataDir, "persons");
+  const dir = import_node_path63.default.join(dataDir, "persons");
   try {
     import_node_fs47.default.rmSync(dir, { recursive: true, force: true });
   } catch {