@tool-bridge/server 0.16.0 → 0.17.0

package/dist/{chunk-YB2FLNWI.js → chunk-RVWZN3CI.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-MLKGABMK.js";
+} from "./chunk-U67V476Y.js";
 
 // ../core/src/errors.ts
 var TB_ERROR_CODES = [
@@ -11851,29 +11851,29 @@ var formatMap = {
   // do not set
 };
 var stringProcessor = (schema, ctx, _json, _params) => {
-  const json2 = _json;
-  json2.type = "string";
+  const json3 = _json;
+  json3.type = "string";
   const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
   if (typeof minimum === "number")
-    json2.minLength = minimum;
+    json3.minLength = minimum;
   if (typeof maximum === "number")
-    json2.maxLength = maximum;
+    json3.maxLength = maximum;
   if (format) {
-    json2.format = formatMap[format] ?? format;
-    if (json2.format === "")
-      delete json2.format;
+    json3.format = formatMap[format] ?? format;
+    if (json3.format === "")
+      delete json3.format;
     if (format === "time") {
-      delete json2.format;
+      delete json3.format;
     }
   }
   if (contentEncoding)
-    json2.contentEncoding = contentEncoding;
+    json3.contentEncoding = contentEncoding;
   if (patterns && patterns.size > 0) {
     const regexes = [...patterns];
     if (regexes.length === 1)
-      json2.pattern = regexes[0].source;
+      json3.pattern = regexes[0].source;
     else if (regexes.length > 1) {
-      json2.allOf = [
+      json3.allOf = [
         ...regexes.map((regex) => ({
           ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
           pattern: regex.source
@@ -11883,40 +11883,40 @@ var stringProcessor = (schema, ctx, _json, _params) => {
   }
 };
 var numberProcessor = (schema, ctx, _json, _params) => {
-  const json2 = _json;
+  const json3 = _json;
   const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
   if (typeof format === "string" && format.includes("int"))
-    json2.type = "integer";
+    json3.type = "integer";
   else
-    json2.type = "number";
+    json3.type = "number";
   const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
   const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
   const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
   if (exMin) {
     if (legacy) {
-      json2.minimum = exclusiveMinimum;
-      json2.exclusiveMinimum = true;
+      json3.minimum = exclusiveMinimum;
+      json3.exclusiveMinimum = true;
     } else {
-      json2.exclusiveMinimum = exclusiveMinimum;
+      json3.exclusiveMinimum = exclusiveMinimum;
     }
   } else if (typeof minimum === "number") {
-    json2.minimum = minimum;
+    json3.minimum = minimum;
   }
   if (exMax) {
     if (legacy) {
-      json2.maximum = exclusiveMaximum;
-      json2.exclusiveMaximum = true;
+      json3.maximum = exclusiveMaximum;
+      json3.exclusiveMaximum = true;
     } else {
-      json2.exclusiveMaximum = exclusiveMaximum;
+      json3.exclusiveMaximum = exclusiveMaximum;
     }
   } else if (typeof maximum === "number") {
-    json2.maximum = maximum;
+    json3.maximum = maximum;
   }
   if (typeof multipleOf === "number")
-    json2.multipleOf = multipleOf;
+    json3.multipleOf = multipleOf;
 };
-var booleanProcessor = (_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var booleanProcessor = (_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 };
 var bigintProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
@@ -11928,13 +11928,13 @@ var symbolProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Symbols cannot be represented in JSON Schema");
   }
 };
-var nullProcessor = (_schema, ctx, json2, _params) => {
+var nullProcessor = (_schema, ctx, json3, _params) => {
   if (ctx.target === "openapi-3.0") {
-    json2.type = "string";
-    json2.nullable = true;
-    json2.enum = [null];
+    json3.type = "string";
+    json3.nullable = true;
+    json3.enum = [null];
   } else {
-    json2.type = "null";
+    json3.type = "null";
   }
 };
 var undefinedProcessor = (_schema, ctx, _json, _params) => {
@@ -11947,8 +11947,8 @@ var voidProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Void cannot be represented in JSON Schema");
   }
 };
-var neverProcessor = (_schema, _ctx, json2, _params) => {
-  json2.not = {};
+var neverProcessor = (_schema, _ctx, json3, _params) => {
+  json3.not = {};
 };
 var anyProcessor = (_schema, _ctx, _json, _params) => {
 };
@@ -11959,16 +11959,16 @@ var dateProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("Date cannot be represented in JSON Schema");
   }
 };
-var enumProcessor = (schema, _ctx, json2, _params) => {
+var enumProcessor = (schema, _ctx, json3, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
   if (values.every((v) => typeof v === "number"))
-    json2.type = "number";
+    json3.type = "number";
   if (values.every((v) => typeof v === "string"))
-    json2.type = "string";
-  json2.enum = values;
+    json3.type = "string";
+  json3.enum = values;
 };
-var literalProcessor = (schema, ctx, json2, _params) => {
+var literalProcessor = (schema, ctx, json3, _params) => {
   const def = schema._zod.def;
   const vals = [];
   for (const val of def.values) {
@@ -11990,22 +11990,22 @@ var literalProcessor = (schema, ctx, json2, _params) => {
   if (vals.length === 0) {
   } else if (vals.length === 1) {
     const val = vals[0];
-    json2.type = val === null ? "null" : typeof val;
+    json3.type = val === null ? "null" : typeof val;
     if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
-      json2.enum = [val];
+      json3.enum = [val];
     } else {
-      json2.const = val;
+      json3.const = val;
     }
   } else {
     if (vals.every((v) => typeof v === "number"))
-      json2.type = "number";
+      json3.type = "number";
     if (vals.every((v) => typeof v === "string"))
-      json2.type = "string";
+      json3.type = "string";
     if (vals.every((v) => typeof v === "boolean"))
-      json2.type = "boolean";
+      json3.type = "boolean";
     if (vals.every((v) => v === null))
-      json2.type = "null";
-    json2.enum = vals;
+      json3.type = "null";
+    json3.enum = vals;
   }
 };
 var nanProcessor = (_schema, ctx, _json, _params) => {
@@ -12013,16 +12013,16 @@ var nanProcessor = (_schema, ctx, _json, _params) => {
     throw new Error("NaN cannot be represented in JSON Schema");
   }
 };
-var templateLiteralProcessor = (schema, _ctx, json2, _params) => {
-  const _json = json2;
+var templateLiteralProcessor = (schema, _ctx, json3, _params) => {
+  const _json = json3;
   const pattern = schema._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-var fileProcessor = (schema, _ctx, json2, _params) => {
-  const _json = json2;
+var fileProcessor = (schema, _ctx, json3, _params) => {
+  const _json = json3;
   const file2 = {
     type: "string",
     format: "binary",
@@ -12045,8 +12045,8 @@ var fileProcessor = (schema, _ctx, json2, _params) => {
     Object.assign(_json, file2);
   }
 };
-var successProcessor = (_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var successProcessor = (_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 };
 var customProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
@@ -12074,27 +12074,27 @@ var setProcessor = (_schema, ctx, _json, _params) => {
   }
 };
 var arrayProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
   const { minimum, maximum } = schema._zod.bag;
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
-  json2.type = "array";
-  json2.items = process(def.element, ctx, {
+    json3.maxItems = maximum;
+  json3.type = "array";
+  json3.items = process(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
 };
 var objectProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "object";
-  json2.properties = {};
+  json3.type = "object";
+  json3.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json2.properties[key] = process(shape[key], ctx, {
+    json3.properties[key] = process(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -12109,21 +12109,21 @@ var objectProcessor = (schema, ctx, _json, params) => {
     }
   }));
   if (requiredKeys.size > 0) {
-    json2.required = Array.from(requiredKeys);
+    json3.required = Array.from(requiredKeys);
   }
   if (def.catchall?._zod.def.type === "never") {
-    json2.additionalProperties = false;
+    json3.additionalProperties = false;
   } else if (!def.catchall) {
     if (ctx.io === "output")
-      json2.additionalProperties = false;
+      json3.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = process(def.catchall, ctx, {
+    json3.additionalProperties = process(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
   }
 };
-var unionProcessor = (schema, ctx, json2, params) => {
+var unionProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) => process(x, ctx, {
@@ -12131,12 +12131,12 @@ var unionProcessor = (schema, ctx, json2, params) => {
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
   if (isExclusive) {
-    json2.oneOf = options;
+    json3.oneOf = options;
   } else {
-    json2.anyOf = options;
+    json3.anyOf = options;
   }
 };
-var intersectionProcessor = (schema, ctx, json2, params) => {
+var intersectionProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const a = process(def.left, ctx, {
     ...params,
@@ -12151,12 +12151,12 @@ var intersectionProcessor = (schema, ctx, json2, params) => {
     ...isSimpleIntersection(a) ? a.allOf : [a],
     ...isSimpleIntersection(b) ? b.allOf : [b]
   ];
-  json2.allOf = allOf;
+  json3.allOf = allOf;
 };
 var tupleProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "array";
+  json3.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
   const prefixItems = def.items.map((x, i) => process(x, ctx, {
@@ -12168,37 +12168,37 @@ var tupleProcessor = (schema, ctx, _json, params) => {
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
   if (ctx.target === "draft-2020-12") {
-    json2.prefixItems = prefixItems;
+    json3.prefixItems = prefixItems;
     if (rest) {
-      json2.items = rest;
+      json3.items = rest;
     }
   } else if (ctx.target === "openapi-3.0") {
-    json2.items = {
+    json3.items = {
       anyOf: prefixItems
     };
     if (rest) {
-      json2.items.anyOf.push(rest);
+      json3.items.anyOf.push(rest);
     }
-    json2.minItems = prefixItems.length;
+    json3.minItems = prefixItems.length;
     if (!rest) {
-      json2.maxItems = prefixItems.length;
+      json3.maxItems = prefixItems.length;
     }
   } else {
-    json2.items = prefixItems;
+    json3.items = prefixItems;
     if (rest) {
-      json2.additionalItems = rest;
+      json3.additionalItems = rest;
     }
   }
   const { minimum, maximum } = schema._zod.bag;
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
+    json3.maxItems = maximum;
 };
 var recordProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "object";
+  json3.type = "object";
   const keyType = def.keyType;
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
@@ -12207,18 +12207,18 @@ var recordProcessor = (schema, ctx, _json, params) => {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
-    json2.patternProperties = {};
+    json3.patternProperties = {};
     for (const pattern of patterns) {
-      json2.patternProperties[pattern.source] = valueSchema;
+      json3.patternProperties[pattern.source] = valueSchema;
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = process(def.keyType, ctx, {
+      json3.propertyNames = process(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json2.additionalProperties = process(def.valueType, ctx, {
+    json3.additionalProperties = process(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -12227,19 +12227,19 @@ var recordProcessor = (schema, ctx, _json, params) => {
   if (keyValues) {
     const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
     if (validKeyValues.length > 0) {
-      json2.required = validKeyValues;
+      json3.required = validKeyValues;
     }
   }
 };
-var nullableProcessor = (schema, ctx, json2, params) => {
+var nullableProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const inner = process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
-    json2.nullable = true;
+    json3.nullable = true;
   } else {
-    json2.anyOf = [inner, { type: "null" }];
+    json3.anyOf = [inner, { type: "null" }];
   }
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
@@ -12248,22 +12248,22 @@ var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
-var defaultProcessor = (schema, ctx, json2, params) => {
+var defaultProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json2.default = JSON.parse(JSON.stringify(def.defaultValue));
+  json3.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
-var prefaultProcessor = (schema, ctx, json2, params) => {
+var prefaultProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
-    json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
+    json3._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
-var catchProcessor = (schema, ctx, json2, params) => {
+var catchProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
@@ -12274,7 +12274,7 @@ var catchProcessor = (schema, ctx, json2, params) => {
   } catch {
     throw new Error("Dynamic catch values are not supported in JSON Schema");
   }
-  json2.default = catchValue;
+  json3.default = catchValue;
 };
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -12284,12 +12284,12 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
-var readonlyProcessor = (schema, ctx, json2, params) => {
+var readonlyProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   process(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json2.readOnly = true;
+  json3.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -12933,7 +12933,7 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
 var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
   $ZodString.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => stringProcessor(inst, ctx, json3, params);
   const bag = inst._zod.bag;
   inst.format = bag.format ?? null;
   inst.minLength = bag.minimum ?? null;
@@ -13204,7 +13204,7 @@ function hash(alg, params) {
 var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
   $ZodNumber.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => numberProcessor(inst, ctx, json3, params);
   _installLazyMethods(inst, "ZodNumber", {
     gt(value, params) {
       return this.check(_gt(value, params));
@@ -13284,7 +13284,7 @@ function uint32(params) {
 var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => booleanProcessor(inst, ctx, json3, params);
 });
 function boolean2(params) {
   return _boolean(ZodBoolean, params);
@@ -13292,7 +13292,7 @@ function boolean2(params) {
 var ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
   $ZodBigInt.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => bigintProcessor(inst, ctx, json3, params);
   inst.gte = (value, params) => inst.check(_gte(value, params));
   inst.min = (value, params) => inst.check(_gte(value, params));
   inst.gt = (value, params) => inst.check(_gt(value, params));
@@ -13327,7 +13327,7 @@ function uint64(params) {
 var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
   $ZodSymbol.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => symbolProcessor(inst, ctx, json3, params);
 });
 function symbol(params) {
   return _symbol(ZodSymbol, params);
@@ -13335,7 +13335,7 @@ function symbol(params) {
 var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
   $ZodUndefined.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => undefinedProcessor(inst, ctx, json3, params);
 });
 function _undefined3(params) {
   return _undefined2(ZodUndefined, params);
@@ -13343,7 +13343,7 @@ function _undefined3(params) {
 var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
   $ZodNull.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullProcessor(inst, ctx, json3, params);
 });
 function _null3(params) {
   return _null2(ZodNull, params);
@@ -13351,7 +13351,7 @@ function _null3(params) {
 var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
   $ZodAny.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => anyProcessor(inst, ctx, json3, params);
 });
 function any() {
   return _any(ZodAny);
@@ -13359,7 +13359,7 @@ function any() {
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unknownProcessor(inst, ctx, json3, params);
 });
 function unknown() {
   return _unknown(ZodUnknown);
@@ -13367,7 +13367,7 @@ function unknown() {
 var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
   $ZodNever.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => neverProcessor(inst, ctx, json3, params);
 });
 function never(params) {
   return _never(ZodNever, params);
@@ -13375,7 +13375,7 @@ function never(params) {
 var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
   $ZodVoid.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => voidProcessor(inst, ctx, json3, params);
 });
 function _void2(params) {
   return _void(ZodVoid, params);
@@ -13383,7 +13383,7 @@ function _void2(params) {
 var ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
   $ZodDate.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => dateProcessor(inst, ctx, json3, params);
   inst.min = (value, params) => inst.check(_gte(value, params));
   inst.max = (value, params) => inst.check(_lte(value, params));
   const c = inst._zod.bag;
@@ -13396,7 +13396,7 @@ function date3(params) {
 var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   $ZodArray.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => arrayProcessor(inst, ctx, json3, params);
   inst.element = def.element;
   _installLazyMethods(inst, "ZodArray", {
     min(n, params) {
@@ -13426,7 +13426,7 @@ function keyof(schema) {
 var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   $ZodObjectJIT.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => objectProcessor(inst, ctx, json3, params);
   util_exports.defineLazy(inst, "shape", () => {
     return def.shape;
   });
@@ -13499,7 +13499,7 @@ function looseObject(shape, params) {
 var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function union(options, params) {
@@ -13512,7 +13512,7 @@ function union(options, params) {
 var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
   ZodUnion.init(inst, def);
   $ZodXor.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function xor(options, params) {
@@ -13538,7 +13538,7 @@ function discriminatedUnion(discriminator, options, params) {
 var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
   $ZodIntersection.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => intersectionProcessor(inst, ctx, json3, params);
 });
 function intersection(left, right) {
   return new ZodIntersection({
@@ -13550,7 +13550,7 @@ function intersection(left, right) {
 var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
   $ZodTuple.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => tupleProcessor(inst, ctx, json3, params);
   inst.rest = (rest) => inst.clone({
     ...inst._zod.def,
     rest
@@ -13570,7 +13570,7 @@ function tuple(items, _paramsOrRest, _params) {
 var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   $ZodRecord.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => recordProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
 });
@@ -13612,7 +13612,7 @@ function looseRecord(keyType, valueType, params) {
 var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
   $ZodMap.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => mapProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
   inst.min = (...args) => inst.check(_minSize(...args));
@@ -13631,7 +13631,7 @@ function map(keyType, valueType, params) {
 var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
   $ZodSet.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => setProcessor(inst, ctx, json3, params);
   inst.min = (...args) => inst.check(_minSize(...args));
   inst.nonempty = (params) => inst.check(_minSize(1, params));
   inst.max = (...args) => inst.check(_maxSize(...args));
@@ -13647,7 +13647,7 @@ function set(valueType, params) {
 var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => enumProcessor(inst, ctx, json3, params);
   inst.enum = def.entries;
   inst.options = Object.values(def.entries);
   const keys = new Set(Object.keys(def.entries));
@@ -13700,7 +13700,7 @@ function nativeEnum(entries, params) {
 var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
   $ZodLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => literalProcessor(inst, ctx, json3, params);
   inst.values = new Set(def.values);
   Object.defineProperty(inst, "value", {
     get() {
@@ -13721,7 +13721,7 @@ function literal(value, params) {
 var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   $ZodFile.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => fileProcessor(inst, ctx, json3, params);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
   inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
@@ -13732,7 +13732,7 @@ function file(params) {
 var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => transformProcessor(inst, ctx, json3, params);
   inst._zod.parse = (payload, _ctx) => {
     if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
@@ -13772,7 +13772,7 @@ function transform(fn) {
 var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
   $ZodOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -13784,7 +13784,7 @@ function optional(innerType) {
 var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
   $ZodExactOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function exactOptional(innerType) {
@@ -13796,7 +13796,7 @@ function exactOptional(innerType) {
 var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
   $ZodNullable.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullableProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -13811,7 +13811,7 @@ function nullish2(innerType) {
 var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
   $ZodDefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => defaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeDefault = inst.unwrap;
 });
@@ -13827,7 +13827,7 @@ function _default2(innerType, defaultValue) {
 var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
   $ZodPrefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => prefaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -13842,7 +13842,7 @@ function prefault(innerType, defaultValue) {
 var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
   $ZodNonOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nonoptionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -13855,7 +13855,7 @@ function nonoptional(innerType, params) {
 var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
   $ZodSuccess.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => successProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function success(innerType) {
@@ -13867,7 +13867,7 @@ function success(innerType) {
 var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
   $ZodCatch.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => catchProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeCatch = inst.unwrap;
 });
@@ -13881,7 +13881,7 @@ function _catch2(innerType, catchValue) {
 var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
   $ZodNaN.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nanProcessor(inst, ctx, json3, params);
 });
 function nan(params) {
   return _nan(ZodNaN, params);
@@ -13889,7 +13889,7 @@ function nan(params) {
 var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
   $ZodPipe.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => pipeProcessor(inst, ctx, json3, params);
   inst.in = def.in;
   inst.out = def.out;
 });
@@ -13931,7 +13931,7 @@ var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) =>
 var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
   $ZodReadonly.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => readonlyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -13943,7 +13943,7 @@ function readonly(innerType) {
 var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
   $ZodTemplateLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => templateLiteralProcessor(inst, ctx, json3, params);
 });
 function templateLiteral(parts, params) {
   return new ZodTemplateLiteral({
@@ -13955,7 +13955,7 @@ function templateLiteral(parts, params) {
 var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
   $ZodLazy.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => lazyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.getter();
 });
 function lazy(getter) {
@@ -13967,7 +13967,7 @@ function lazy(getter) {
 var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
   $ZodPromise.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => promiseProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function promise(innerType) {
@@ -13979,7 +13979,7 @@ function promise(innerType) {
 var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
   $ZodFunction.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => functionProcessor(inst, ctx, json3, params);
 });
 function _function(params) {
   return new ZodFunction({
@@ -13991,7 +13991,7 @@ function _function(params) {
 var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   $ZodCustom.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => customProcessor(inst, ctx, json3, params);
 });
 function check(fn) {
   const ch = new $ZodCheck({
@@ -15069,51 +15069,221 @@ async function identify(store, bearer, now) {
   };
 }
 
-// ../core/src/builtin/util.ts
-var VOID_ACK = { ok: true };
-function withCommandPaths(nodePath, cmds) {
-  return cmds.map((cmd) => ({ ...cmd, path: `/${nodePath}/${cmd.name}` }));
+// ../core/src/operation/registry.ts
+function normalizeSchema(input) {
+  return input instanceof external_exports.ZodType ? input : external_exports.strictObject(input);
 }
-var LIST_OPTS_SCHEMA = {
-  type: "object",
-  description: "pagination options",
-  properties: {
-    cursor: { type: "string", description: "opaque cursor returned by the previous page" },
-    limit: { type: "number", description: "page size (default 50, max 200)" }
-  }
-};
-function cmdPath(nodePath) {
-  return `/${nodePath}`;
+function toJsonSchema(schema) {
+  const json3 = external_exports.toJSONSchema(schema);
+  return omit2(json3, "$schema");
 }
-function requireString(args, field) {
-  const v = args[field];
-  if (typeof v !== "string" || v.length === 0) {
-    throw new TBError("invalid_argument", `field '${field}' must be a non-empty string`);
-  }
-  return v;
+function invalidArgument(name, error51) {
+  const detail = error51.issues.map((issue2) => {
+    const path = issue2.path.join(".");
+    return path.length > 0 ? `${path}: ${issue2.message}` : issue2.message;
+  }).join("; ");
+  return new TBError("invalid_argument", `invalid arguments for '${name}': ${detail}`);
 }
-function optString(args, field) {
-  const v = args[field];
-  if (v === void 0) return void 0;
-  if (typeof v !== "string") {
-    throw new TBError("invalid_argument", `field '${field}' must be a string`);
+var TOOL_RESULT_KEYS = /* @__PURE__ */ new Set(["content", "contentBlocks", "isError", "structuredContent"]);
+function toToolResult(value) {
+  if (typeof value === "object" && value !== null && "content" in value) {
+    const keys = Object.keys(value);
+    if (keys.every((key) => TOOL_RESULT_KEYS.has(key))) return value;
   }
-  return v;
+  return { content: value };
 }
-function optListOptions(args) {
-  const opts = args.opts;
-  if (opts === void 0) return void 0;
-  if (typeof opts !== "object" || opts === null) {
-    throw new TBError("invalid_argument", "field 'opts' must be an object");
+var OperationRegistry = class {
+  ops = /* @__PURE__ */ new Map();
+  /** 注册一个操作。同名重复注册 → invalid_argument(配置错误,快速失败)。 */
+  register(name, spec, handler) {
+    if (name.length === 0) {
+      throw new TBError("invalid_argument", "operation name must be non-empty");
+    }
+    if (this.ops.has(name)) {
+      throw new TBError("invalid_argument", `operation '${name}' is already registered`);
+    }
+    if (spec.inputSchema !== void 0 && spec.rawInputSchema !== void 0) {
+      throw new TBError(
+        "invalid_argument",
+        `operation '${name}': inputSchema and rawInputSchema are mutually exclusive`
+      );
+    }
+    const schema = spec.inputSchema !== void 0 ? normalizeSchema(spec.inputSchema) : void 0;
+    const toolSpec = { name };
+    if (spec.description !== void 0) toolSpec.description = spec.description;
+    if (spec.effect !== void 0) toolSpec.effect = spec.effect;
+    if (spec.confirm !== void 0) toolSpec.confirm = spec.confirm;
+    if (schema !== void 0) toolSpec.inputSchema = toJsonSchema(schema);
+    else if (spec.rawInputSchema !== void 0) toolSpec.inputSchema = spec.rawInputSchema;
+    if (spec.outputSchema !== void 0) toolSpec.outputSchema = spec.outputSchema;
+    this.ops.set(name, {
+      schema,
+      spec: toolSpec,
+      handler
+    });
+    return this;
   }
-  return opts;
-}
-function requireObject(args, field) {
-  const v = args[field];
-  if (typeof v !== "object" || v === null) {
-    throw new TBError("invalid_argument", `field '${field}' must be an object`);
+  /** 已注册的操作名(注册顺序)。 */
+  names() {
+    return [...this.ops.keys()];
+  }
+  has(name) {
+    return this.ops.has(name);
+  }
+  /** 全部 ToolSpec(工具源天然小,豁免分页)。 */
+  list() {
+    return [...this.ops.values()].map((op) => op.spec);
+  }
+  /** 单个 ToolSpec;不存在 → not_found。 */
+  get(name) {
+    const op = this.ops.get(name);
+    if (op === void 0) throw TBError.notFound(`unknown operation: '${name}'`);
+    return op.spec;
+  }
+  /**
+   * 只执行入参解析，不调用 handler。
+   *
+   * 少数 HTBP 命令由宿主转发到另一执行通道（例如设备 context）；它们仍需复用注册
+   * 真源的 strict schema，但不能在当前进程执行 provider handler。
+   */
+  parse(name, args) {
+    const op = this.ops.get(name);
+    if (op === void 0) throw TBError.notFound(`unknown operation: '${name}'`);
+    if (op.schema === void 0) return args;
+    const parsed = op.schema.safeParse(args);
+    if (!parsed.success) throw invalidArgument(name, parsed.error);
+    return parsed.data;
+  }
+  /**
+   * 校验后调用 handler，保留 handler 的原始返回值。
+   *
+   * builtin 等内部适配层已有自己的 wire 形状，不应被套上 ToolResult；
+   * 它们复用本方法的 Zod 校验和 handler 调度。工具源继续用 {@link call}。
+   */
+  async invoke(name, args, ctx) {
+    const op = this.ops.get(name);
+    if (op === void 0) throw TBError.notFound(`unknown operation: '${name}'`);
+    return await op.handler(this.parse(name, args), ctx);
+  }
+  /**
+   * 调用:safeParse 入参(失败 → invalid_argument)、执行 handler、把裸返回值包成 ToolResult。
+   * 未声明 schema 的操作原样透传 args。
+   */
+  async call(name, args, ctx) {
+    return toToolResult(await this.invoke(name, args, ctx));
+  }
+};
+
+// ../core/src/operation/htbpCommandRegistry.ts
+var HTBP_LIST_OPTIONS_SCHEMA = external_exports.strictObject({
+  cursor: external_exports.string().optional().describe("opaque cursor returned by the previous page"),
+  limit: external_exports.number().optional().describe("page size (default 50, max 200)")
+}).describe("pagination options");
+var HtbpCommandRegistry = class {
+  metadata = /* @__PURE__ */ new Map();
+  operations = new OperationRegistry();
+  register(name, spec, handler) {
+    const { h, returns, scope, ...operationSpec } = spec;
+    this.operations.register(
+      name,
+      { ...operationSpec, description: h },
+      handler
+    );
+    this.metadata.set(name, {
+      scope,
+      ...returns !== void 0 ? { returns } : {}
+    });
+    return this;
+  }
+  names() {
+    return this.operations.names();
+  }
+  has(name) {
+    return this.operations.has(name);
+  }
+  scopeFor(name) {
+    return this.metadata.get(name)?.scope;
+  }
+  commandSpecs(nodePath) {
+    return this.operations.list().map((operation) => {
+      const metadata = this.metadata.get(operation.name);
+      if (metadata === void 0) {
+        throw new TBError("internal", `HTBP command metadata missing: '${operation.name}'`);
+      }
+      return {
+        name: operation.name,
+        method: "POST",
+        path: `/${nodePath}/${operation.name}`,
+        scope: metadata.scope,
+        ...operation.description !== void 0 ? { h: operation.description } : {},
+        ...operation.inputSchema !== void 0 ? { inputSchema: operation.inputSchema } : {},
+        ...operation.outputSchema !== void 0 ? { outputSchema: operation.outputSchema } : {},
+        ...operation.effect !== void 0 ? { effect: operation.effect } : {},
+        ...operation.confirm !== void 0 ? { confirm: operation.confirm } : {},
+        ...metadata.returns !== void 0 ? { returns: metadata.returns } : {}
+      };
+    });
+  }
+  command(name, nodePath) {
+    return this.commandSpecs(nodePath).find((command) => command.name === name);
+  }
+  helpModel(node, include = () => true) {
+    return {
+      node,
+      cmds: this.commandSpecs(node.path).filter(include)
+    };
+  }
+  async invoke(name, args, context) {
+    return await this.operations.invoke(name, args, context);
   }
-  return v;
+  /** 校验/规范化宿主将转发到另一执行通道的命令入参。 */
+  parse(name, args) {
+    return this.operations.parse(name, args);
+  }
+};
+
+// ../core/src/builtin/commandRegistry.ts
+var BuiltinCommandRegistry = class extends HtbpCommandRegistry {
+  constructor(moduleName, moduleDescription) {
+    super();
+    this.moduleName = moduleName;
+    this.moduleDescription = moduleDescription;
+  }
+  moduleName;
+  moduleDescription;
+  help(nodePath) {
+    return this.helpModel({
+      path: nodePath,
+      kind: "builtin",
+      description: this.moduleDescription
+    });
+  }
+  /** 绑定依赖后生成现有 BuiltinModule 接口。 */
+  module(deps) {
+    return {
+      module: this.moduleName,
+      description: this.moduleDescription,
+      help: (nodePath) => this.help(nodePath),
+      dispatch: async (cmd, args, call, runtime) => {
+        if (!this.has(cmd)) {
+          throw new TBError(
+            "invalid_argument",
+            `unknown cmd '${cmd}' on system/${this.moduleName}`
+          );
+        }
+        return await this.invoke(cmd, args, { deps, call, runtime });
+      }
+    };
+  }
+};
+
+// ../core/src/builtin/util.ts
+var VOID_ACK = { ok: true };
+function withCommandPaths(nodePath, cmds) {
+  return cmds.map((cmd) => ({ ...cmd, path: `/${nodePath}/${cmd.name}` }));
+}
+function cmdPath(nodePath) {
+  return `/${nodePath}`;
 }
 
 // ../core/src/builtin/catalog.ts
@@ -15172,94 +15342,59 @@ function matches2(item, query) {
   const q = query.toLowerCase();
   return item.id.toLowerCase().includes(q) || (item.description?.toLowerCase().includes(q) ?? false);
 }
-function catalogCmds(nodePath) {
-  const path = cmdPath(nodePath);
-  const cmds = [
-    {
-      name: "list",
-      method: "POST",
-      path,
-      h: "list built-in integrations available on this host (no credentials, read scope)",
-      inputSchema: { type: "object", properties: { opts: LIST_OPTS_SCHEMA } },
-      returns: "Page<CatalogListItem> \u2014 id, exports, nodeKinds, exportDetails",
-      scope: "read"
-    },
-    {
-      name: "get",
-      method: "POST",
-      path,
-      h: "fetch one catalog entry including its full /~describe descriptor",
-      inputSchema: {
-        type: "object",
-        properties: { id: { type: "string", description: "catalog entry id (= provider id)" } },
-        required: ["id"]
-      },
-      returns: "CatalogEntry \u2014 id, endpoint, digest, describe",
-      scope: "read"
-    },
-    {
-      name: "search",
-      method: "POST",
-      path,
-      h: "substring search over catalog id and description",
-      inputSchema: {
-        type: "object",
-        properties: {
-          q: { type: "string", description: "case-insensitive substring" },
-          opts: LIST_OPTS_SCHEMA
-        },
-        required: ["q"]
-      },
-      returns: "Page<CatalogListItem>",
-      scope: "read"
-    }
-  ];
-  return withCommandPaths(nodePath, cmds);
-}
 function paginate(items, opts) {
-  const o = typeof opts === "object" && opts !== null ? opts : {};
-  const limit = typeof o.limit === "number" && o.limit > 0 ? Math.min(o.limit, LIST_LIMIT_MAX) : 50;
+  const limit = typeof opts?.limit === "number" && opts.limit > 0 ? Math.min(opts.limit, LIST_LIMIT_MAX) : 50;
   let start = 0;
-  if (typeof o.cursor === "string" && o.cursor !== "") {
-    const idx = items.findIndex((i) => i.id === o.cursor);
+  if (opts?.cursor !== void 0 && opts.cursor !== "") {
+    const idx = items.findIndex((i) => i.id === opts.cursor);
     start = idx >= 0 ? idx : 0;
   }
   const page = items.slice(start, start + limit);
   const next = items[start + limit];
   return { items: page, ...next !== void 0 ? { cursor: next.id } : {} };
 }
+function sortedItems(deps) {
+  return Object.values(deps.catalog()).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).map(projectListItem);
+}
+var COMMANDS = new BuiltinCommandRegistry("catalog", DESCRIPTION).register(
+  "list",
+  {
+    h: "list built-in integrations available on this host (no credentials, read scope)",
+    inputSchema: external_exports.strictObject({ opts: HTBP_LIST_OPTIONS_SCHEMA.optional() }),
+    returns: "Page<CatalogListItem> \u2014 id, exports, nodeKinds, exportDetails",
+    scope: "read"
+  },
+  ({ opts }, { deps }) => paginate(sortedItems(deps), opts)
+).register(
+  "get",
+  {
+    h: "fetch one catalog entry including its full /~describe descriptor",
+    inputSchema: external_exports.strictObject({
+      id: external_exports.string().min(1).describe("catalog entry id (= provider id)")
+    }),
+    returns: "CatalogEntry \u2014 id, endpoint, digest, describe",
+    scope: "read"
+  },
+  ({ id }, { deps }) => {
+    const entry = deps.catalog()[id];
+    if (entry === void 0) throw new TBError("not_found", `no catalog entry '${id}'`);
+    return entry;
+  }
+).register(
+  "search",
+  {
+    h: "substring search over catalog id and description",
+    inputSchema: external_exports.strictObject({
+      q: external_exports.string().min(1).describe("case-insensitive substring"),
+      opts: HTBP_LIST_OPTIONS_SCHEMA.optional()
+    }),
+    returns: "Page<CatalogListItem>",
+    scope: "read"
+  },
+  ({ opts, q }, { deps }) => paginate(sortedItems(deps).filter((i) => matches2(i, q)), opts)
+);
 function createCatalogModule(deps) {
-  const sortedItems = () => Object.values(deps.catalog()).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).map(projectListItem);
-  return {
-    module: "catalog",
-    description: DESCRIPTION,
-    help(nodePath) {
-      return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION },
-        cmds: catalogCmds(nodePath)
-      };
-    },
-    async dispatch(cmd, args) {
-      switch (cmd) {
-        case "list":
-          return paginate(sortedItems(), args.opts);
-        case "get": {
-          const id = requireString(args, "id");
-          const entry = deps.catalog()[id];
-          if (entry === void 0) {
-            throw new TBError("not_found", `no catalog entry '${id}'`);
-          }
-          return entry;
-        }
-        case "search": {
-          const q = requireString(args, "q");
-          return paginate(sortedItems().filter((i) => matches2(i, q)), args.opts);
-        }
-        default:
-          throw new TBError("invalid_argument", `unknown cmd '${cmd}' on system/catalog`);
-      }
-    }
-  };
+  return COMMANDS.module(deps);
 }
 
 // ../core/src/plugin/oauth.ts
@@ -15423,9 +15558,156 @@ function parseTokenResponse(payload, config2, now) {
   };
 }
 
+// ../core/src/context/commands.ts
+var metadataSchema = external_exports.record(external_exports.string(), external_exports.string()).optional().describe(
+  "string-to-string metadata map"
+);
+var entrySchema = external_exports.strictObject({
+  contentType: external_exports.string().optional().describe(
+    "required when content is a string; defaults to application/json for non-string content"
+  ),
+  content: external_exports.unknown().describe("entry body: string, or any JSON value"),
+  metadata: metadataSchema,
+  ifVersion: external_exports.string().optional().describe("optimistic concurrency: expected current version")
+});
+var patchSchema = external_exports.strictObject({
+  content: external_exports.unknown().optional().describe("replacement content"),
+  metadata: metadataSchema,
+  ifVersion: external_exports.string().optional().describe("optimistic concurrency: expected current version")
+}).describe("partial update; omitted fields keep their current value");
+var searchOptionsSchema = external_exports.strictObject({
+  cursor: external_exports.string().optional().describe("opaque cursor returned by the previous page"),
+  limit: external_exports.number().optional().describe("page size (default 50, max 200)"),
+  mode: external_exports.enum(["keyword", "semantic"]).optional().describe('default "keyword"')
+}).describe("pagination + search mode");
+var contextCommands = new HtbpCommandRegistry().register(
+  "list",
+  {
+    h: "list entries directly under a path (shallow, paginated)",
+    inputSchema: external_exports.strictObject({
+      path: external_exports.string().optional().describe("entry path prefix inside the namespace"),
+      opts: HTBP_LIST_OPTIONS_SCHEMA.optional()
+    }),
+    returns: "Page<ContextEntryMeta>",
+    scope: "read"
+  },
+  ({ opts, path }, { provider }) => provider.list(path ?? "", opts)
+).register(
+  "get",
+  {
+    h: "read one entry with content (oversized content comes back as { $ref: <download URL> })",
+    inputSchema: external_exports.strictObject({
+      path: external_exports.string().describe("entry path inside the namespace")
+    }),
+    returns: "ContextEntry",
+    scope: "read"
+  },
+  ({ path }, { provider }) => provider.get(path)
+).register(
+  "write",
+  {
+    h: "create or fully replace an entry (idempotent upsert)",
+    inputSchema: external_exports.strictObject({
+      path: external_exports.string().describe("entry path inside the namespace"),
+      entry: entrySchema
+    }),
+    returns: "ContextEntryMeta",
+    scope: "write"
+  },
+  ({ entry, path }, { provider }) => provider.write(path, entry)
+).register(
+  "update",
+  {
+    h: "partially update content and/or metadata (shallow merge); not_found if the entry does not exist",
+    inputSchema: external_exports.strictObject({
+      path: external_exports.string().describe("entry path inside the namespace"),
+      patch: patchSchema
+    }),
+    returns: "ContextEntryMeta",
+    scope: "write"
+  },
+  ({ patch, path }, { provider }) => provider.update(path, patch)
+).register(
+  "delete",
+  {
+    h: "delete an entry (idempotent)",
+    inputSchema: external_exports.strictObject({
+      path: external_exports.string().describe("entry path inside the namespace")
+    }),
+    scope: "write",
+    effect: "destructive"
+  },
+  ({ path }, { provider }) => provider.delete(path)
+).register(
+  "search",
+  {
+    h: "keyword search: substring match on entry paths and metadata values",
+    inputSchema: external_exports.strictObject({
+      query: external_exports.string().describe("substring to match"),
+      opts: searchOptionsSchema.optional()
+    }),
+    returns: "Page<ContextEntryMeta>",
+    scope: "read"
+  },
+  ({ opts, query }, { provider }) => provider.search(query, opts)
+).register(
+  "create_upload",
+  {
+    h: "create a short-lived, path-scoped direct-upload grant; persist the returned uri, not url",
+    inputSchema: external_exports.strictObject({
+      path: external_exports.string().describe("target entry path inside the namespace"),
+      contentType: external_exports.string().describe("media type signed into the PUT request"),
+      overwrite: external_exports.boolean().optional().describe(
+        "allow replacing an existing object; default false"
+      )
+    }),
+    returns: "ContextUploadGrant",
+    scope: "write",
+    effect: "write"
+  },
+  ({ contentType, overwrite, path }, { upload }) => upload({
+    path,
+    contentType,
+    ...overwrite !== void 0 ? { overwrite } : {}
+  })
+);
+function contextScopeForCmd(command) {
+  const scope = contextCommands.scopeFor(command);
+  return scope === "read" || scope === "write" ? scope : null;
+}
+function parseContextCmdArgs(command, args) {
+  const normalized = command.toLowerCase();
+  if (!contextCommands.has(normalized) || normalized === "create_upload") {
+    throw new TBError("invalid_argument", `unknown cmd '${command}'`);
+  }
+  return contextCommands.parse(normalized, args);
+}
+async function dispatchContextCmd(provider, command, args) {
+  const normalized = command.toLowerCase();
+  if (!contextCommands.has(normalized) || normalized === "create_upload") {
+    throw new TBError("invalid_argument", `unknown cmd '${command}'`);
+  }
+  const method = normalized;
+  if (typeof provider[method] !== "function") {
+    throw new TBError("invalid_argument", `unknown cmd '${command}'(provider \u672A\u5B9E\u73B0)`);
+  }
+  if (normalized === "write" && (typeof args.entry !== "object" || args.entry === null)) {
+    throw new TBError("invalid_argument", "write \u9700\u8981\u5BF9\u8C61 'entry'");
+  }
+  if (normalized === "update" && (typeof args.patch !== "object" || args.patch === null)) {
+    throw new TBError("invalid_argument", "update \u9700\u8981\u5BF9\u8C61 'patch'");
+  }
+  return await contextCommands.invoke(normalized, args, { provider });
+}
+async function dispatchContextUploadCmd(args, upload) {
+  return await contextCommands.invoke("create_upload", args, {
+    upload
+  });
+}
+
 // ../core/src/context/capabilities.ts
-var CONTEXT_METHODS = ["list", "get", "search", "write", "update", "delete"];
-var CONTEXT_WRITE_METHODS = ["write", "update", "delete"];
+var CONTEXT_METHODS = contextCommands.names().filter((name) => name !== "create_upload");
+var CONTEXT_WRITE_METHODS = CONTEXT_METHODS.filter((method) => contextCommands.scopeFor(method) === "write");
 function contextMethodsOf(provider) {
   const methods = /* @__PURE__ */ new Set();
   for (const method of CONTEXT_METHODS) {
@@ -15750,99 +16032,93 @@ function pluginTokenSecretName(id) {
 function projectManifest(record2) {
   return omit2(record2, "tokenSkId");
 }
-function pluginCmds(nodePath) {
-  const path = cmdPath(nodePath);
-  const idSchema2 = {
-    type: "object",
-    properties: { id: { type: "string", description: "plugin id" } },
-    required: ["id"]
-  };
-  const cmds = [
-    {
-      name: "list",
-      method: "POST",
-      path,
-      h: "list registered plugins (pluginToken never returned)",
-      inputSchema: { type: "object", properties: { opts: LIST_OPTS_SCHEMA } },
-      returns: "Page<PluginView> \u2014 manifest + the exports declared by its /~describe",
-      scope: "admin"
-    },
-    {
-      name: "get",
-      method: "POST",
-      path,
-      h: "fetch one plugin manifest by id",
-      inputSchema: idSchema2,
-      returns: "PluginView \u2014 manifest + the exports declared by its /~describe",
-      scope: "admin"
-    },
-    {
-      name: "write",
-      method: "POST",
-      path,
-      h: "register a plugin: probes health and validates its /~describe exports before accepting; then mount an export via system/registry (config.provider = plugin id, config.export = export id)",
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "unique plugin id" },
-          protocolVersion: {
-            type: "string",
-            enum: ["plugin/v2"],
-            description: "transport protocol version; what the plugin provides is declared by its /~describe exports"
-          },
-          endpoint: { type: "string", description: "https base URL of the plugin service" },
-          auth: {
-            type: "object",
-            description: '{ kind: "platform-token" } \u2014 gateway mints the token (shown once in the response); or { kind: "bearer", secretRef }'
-          },
-          healthPath: { type: "string", description: 'GET probe path, e.g. "/healthz"' },
-          enabled: { type: "boolean" }
-        },
-        required: ["id", "endpoint", "auth", "healthPath", "enabled"]
-      },
-      returns: "PluginView + pluginToken shown once (platform-token only)",
-      scope: "admin"
-    },
-    {
-      name: "update",
-      method: "POST",
-      path,
-      h: "patch a registration; endpoint changes re-probe and re-validate the exports before applying",
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "plugin id" },
-          patch: {
-            type: "object",
-            description: "fields to change; same shape as write, all optional"
-          }
-        },
-        required: ["id", "patch"]
-      },
-      returns: "PluginView \u2014 pluginToken shown once if auth switched to platform-token",
-      scope: "admin"
-    },
-    {
-      name: "delete",
-      method: "POST",
-      path,
-      h: "unregister a plugin and revoke its platform token; mounted nodes referencing it stop working",
-      inputSchema: idSchema2,
-      returns: "void",
-      scope: "admin"
-    },
-    {
-      name: "health",
-      method: "POST",
-      path,
-      h: "probe the plugin health endpoint now",
-      inputSchema: idSchema2,
-      returns: "{ id, healthy, checkedAt }",
-      scope: "admin"
-    }
-  ];
-  return withCommandPaths(nodePath, cmds);
-}
+var pluginAuthSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.strictObject({ kind: external_exports.literal("platform-token") }),
+  external_exports.strictObject({ kind: external_exports.literal("bearer"), secretRef: external_exports.string().min(1) })
+]).describe(
+  '{ kind: "platform-token" } \u2014 gateway mints the token (shown once in the response); or { kind: "bearer", secretRef }'
+);
+var pluginIdSchema = external_exports.string().min(1).describe("plugin id");
+var manifestFields = {
+  id: external_exports.string().min(1).describe("unique plugin id"),
+  protocolVersion: external_exports.literal("plugin/v2").describe(
+    "transport protocol version; what the plugin provides is declared by its /~describe exports"
+  ),
+  endpoint: external_exports.string().min(1).describe("https base URL of the plugin service"),
+  auth: pluginAuthSchema,
+  healthPath: external_exports.string().min(1).describe('GET probe path, e.g. "/healthz"'),
+  enabled: external_exports.boolean()
+};
+var pluginWriteSchema = external_exports.strictObject(manifestFields);
+var pluginPatchSchema = external_exports.strictObject({
+  id: manifestFields.id.optional(),
+  protocolVersion: manifestFields.protocolVersion.optional(),
+  endpoint: manifestFields.endpoint.optional(),
+  auth: manifestFields.auth.optional(),
+  healthPath: manifestFields.healthPath.optional(),
+  enabled: manifestFields.enabled.optional()
+}).describe("fields to change; same shape as write, all optional");
+var COMMANDS2 = new BuiltinCommandRegistry("plugin", DESCRIPTION2).register(
+  "list",
+  {
+    h: "list registered plugins (pluginToken never returned)",
+    inputSchema: external_exports.strictObject({ opts: HTBP_LIST_OPTIONS_SCHEMA.optional() }),
+    returns: "Page<PluginView> \u2014 manifest + the exports declared by its /~describe",
+    scope: "admin"
+  },
+  ({ opts }, { deps }) => deps.list(opts)
+).register(
+  "get",
+  {
+    h: "fetch one plugin manifest by id",
+    inputSchema: external_exports.strictObject({ id: pluginIdSchema }),
+    returns: "PluginView \u2014 manifest + the exports declared by its /~describe",
+    scope: "admin"
+  },
+  ({ id }, { deps }) => deps.get(id)
+).register(
+  "write",
+  {
+    h: "register a plugin: probes health and validates its /~describe exports before accepting; then mount an export via system/registry (config.provider = plugin id, config.export = export id)",
+    inputSchema: pluginWriteSchema,
+    returns: "PluginView + pluginToken shown once (platform-token only)",
+    scope: "admin"
+  },
+  (input, { deps }) => deps.write(input)
+).register(
+  "update",
+  {
+    h: "patch a registration; endpoint changes re-probe and re-validate the exports before applying",
+    inputSchema: external_exports.strictObject({
+      id: pluginIdSchema,
+      patch: pluginPatchSchema
+    }),
+    returns: "PluginView \u2014 pluginToken shown once if auth switched to platform-token",
+    scope: "admin"
+  },
+  ({ id, patch }, { deps }) => deps.update(id, patch)
+).register(
+  "delete",
+  {
+    h: "unregister a plugin and revoke its platform token; mounted nodes referencing it stop working",
+    inputSchema: external_exports.strictObject({ id: pluginIdSchema }),
+    returns: "void",
+    scope: "admin"
+  },
+  async ({ id }, { deps }) => {
+    await deps.remove(id);
+    return VOID_ACK;
+  }
+).register(
+  "health",
+  {
+    h: "probe the plugin health endpoint now",
+    inputSchema: external_exports.strictObject({ id: pluginIdSchema }),
+    returns: "{ id, healthy, checkedAt }",
+    scope: "admin"
+  },
+  ({ id }, { deps }) => deps.health(id)
+);
 function clampLimit2(limit) {
   if (limit === void 0 || limit < 1) return LIST_LIMIT_DEFAULT;
   return limit > LIST_LIMIT_MAX ? LIST_LIMIT_MAX : limit;
@@ -15988,394 +16264,216 @@ function createPluginModule(deps) {
     await store.delete(KEY_PLUGIN_HEALTH + id);
     await store.delete(KEY_PLUGIN_META + id);
   }
-  return {
-    module: "plugin",
-    description: DESCRIPTION2,
-    help(nodePath) {
-      return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION2 },
-        cmds: pluginCmds(nodePath)
-      };
+  return COMMANDS2.module({
+    async list(opts) {
+      const listOpts = { limit: clampLimit2(opts?.limit) };
+      if (opts?.cursor !== void 0) listOpts.cursor = opts.cursor;
+      const page = await store.list(KEY_PLUGIN, listOpts);
+      const items = await Promise.all(
+        page.items.map(({ value }) => view(value))
+      );
+      return page.cursor !== void 0 ? { items, cursor: page.cursor } : { items };
     },
-    async dispatch(cmd, args) {
-      switch (cmd) {
-        case "list": {
-          const opts = optListOptions(args);
-          const listOpts = { limit: clampLimit2(opts?.limit) };
-          if (opts?.cursor !== void 0) listOpts.cursor = opts.cursor;
-          const page = await store.list(KEY_PLUGIN, listOpts);
-          const items = await Promise.all(
-            page.items.map(({ value }) => view(value))
-          );
-          return page.cursor !== void 0 ? { items, cursor: page.cursor } : { items };
-        }
-        case "get":
-          return await view(await require2(requireString(args, "id")));
-        case "write":
-          return write(args);
-        case "update": {
-          const id = requireString(args, "id");
-          const patch = args.patch;
-          if (typeof patch !== "object" || patch === null) {
-            throw new TBError("invalid_argument", "field 'patch' must be an object");
-          }
-          return update(id, patch);
-        }
-        case "delete":
-          await remove(requireString(args, "id"));
-          return VOID_ACK;
-        case "health": {
-          const id = requireString(args, "id");
-          const manifest = projectManifest(await require2(id));
-          const record2 = await probeAndRecord(manifest);
-          return { id, healthy: record2.healthy, checkedAt: record2.checkedAt };
-        }
-        default:
-          throw new TBError("invalid_argument", `unknown cmd '${cmd}' on system/plugin`);
-      }
+    async get(id) {
+      return await view(await require2(id));
+    },
+    write,
+    update,
+    remove,
+    async health(id) {
+      const manifest = projectManifest(await require2(id));
+      const record2 = await probeAndRecord(manifest);
+      return { id, healthy: record2.healthy, checkedAt: record2.checkedAt };
     }
-  };
+  });
 }
 
 // ../core/src/builtin/store.ts
-var STORE_SCOPE_BY_CMD = {
-  create_upload: "write",
-  complete_upload: "write",
-  abort_upload: "write",
-  stat: "read",
-  read: "read",
-  share: "write",
-  revoke_share: "write",
-  delete: "write",
-  list: "read"
-};
 var DESCRIPTION3 = "Deployment-level private object Store for uploads, reads and short-lived sharing";
-function storeCmds(nodePath) {
-  const path = cmdPath(nodePath);
-  const objectFields = {
-    contentType: { type: "string", description: "object MIME type" },
-    filename: { type: "string", description: "display-only filename; never used as a storage key" },
-    size: { type: "number", description: "expected byte size" },
-    checksum: {
-      type: "object",
-      description: "optional sha256 checksum declaration",
-      properties: {
-        algorithm: { type: "string", enum: ["sha256"] },
-        value: { type: "string" }
-      }
-    },
-    idempotencyKey: { type: "string", description: "owner-scoped create retry key" }
-  };
-  const uriField = { uri: { type: "string", description: "store://default/<objectId>" } };
-  const specs = [
-    {
-      name: "create_upload",
-      method: "POST",
-      path,
-      h: "create a new opaque Store object and bounded upload session",
-      inputSchema: {
-        type: "object",
-        properties: objectFields,
-        required: ["contentType"]
-      },
-      returns: "StoreUploadGrant"
-    },
-    {
-      name: "complete_upload",
-      method: "POST",
-      path,
-      h: "verify a direct upload and atomically mark its object ready; idempotent",
-      inputSchema: {
-        type: "object",
-        properties: {
-          uploadId: { type: "string" }
-        },
-        required: ["uploadId"]
-      },
-      returns: "StoreObject"
-    },
-    {
-      name: "abort_upload",
-      method: "POST",
-      path,
-      h: "abandon an unfinished upload; idempotent until the object is ready",
-      inputSchema: {
-        type: "object",
-        properties: {
-          uploadId: { type: "string" }
-        },
-        required: ["uploadId"]
-      },
-      returns: "void"
-    },
-    {
-      name: "stat",
-      method: "POST",
-      path,
-      h: "return metadata for a ready object owned by the current principal",
-      inputSchema: {
-        type: "object",
-        properties: uriField,
-        required: ["uri"]
-      },
-      returns: "StoreObject"
-    },
-    {
-      name: "read",
-      method: "POST",
-      path,
-      h: "authorize an object read and return a short-lived $ref",
-      inputSchema: {
-        type: "object",
-        properties: uriField,
-        required: ["uri"]
-      },
-      returns: "{ $ref, contentType, size, expiresAt }"
-    },
-    {
-      name: "share",
-      method: "POST",
-      path,
-      h: "create a short-lived, revocable read share for an owned object",
-      inputSchema: {
-        type: "object",
-        properties: { ...uriField, ttlSec: { type: "number" } },
-        required: ["uri"]
-      },
-      returns: "StoreShare"
-    },
-    {
-      name: "revoke_share",
-      method: "POST",
-      path,
-      h: "revoke a Store share grant",
-      inputSchema: {
-        type: "object",
-        properties: { shareId: { type: "string" } },
-        required: ["shareId"]
-      },
-      returns: "void"
-    },
-    {
-      name: "delete",
-      method: "POST",
-      path,
-      h: "make an owned Store object immediately unreadable and delete its bytes",
-      inputSchema: { type: "object", properties: uriField, required: ["uri"] },
-      returns: "void"
-    },
-    {
-      name: "list",
-      method: "POST",
-      path,
-      h: "list ready Store objects owned by the current principal",
-      inputSchema: { type: "object", properties: { opts: LIST_OPTS_SCHEMA } },
-      returns: "Page<StoreObject>"
-    }
-  ];
-  return withCommandPaths(nodePath, specs.map((spec) => ({
-    ...spec,
-    scope: STORE_SCOPE_BY_CMD[spec.name]
-  })));
-}
-function optionalPositiveInt(args, field) {
-  const value = args[field];
-  if (value === void 0) return void 0;
-  if (!Number.isSafeInteger(value) || value < 1) {
-    throw new TBError("invalid_argument", `${field} \u5FC5\u987B\u662F\u6B63\u6574\u6570`);
+var contentTypeSchema = external_exports.string().min(1).describe("object MIME type");
+var filenameSchema = external_exports.string().optional().describe(
+  "display-only filename; never used as a storage key"
+);
+var checksumSchema = external_exports.strictObject({
+  algorithm: external_exports.literal("sha256"),
+  value: external_exports.string()
+}).optional().describe("optional sha256 checksum declaration");
+var uriSchema = external_exports.string().describe("store://default/<objectId>");
+var COMMANDS3 = new BuiltinCommandRegistry("store", DESCRIPTION3).register(
+  "create_upload",
+  {
+    h: "create a new opaque Store object and bounded upload session",
+    inputSchema: external_exports.strictObject({
+      contentType: contentTypeSchema,
+      filename: filenameSchema,
+      size: external_exports.number().optional().describe("expected byte size"),
+      checksum: checksumSchema,
+      idempotencyKey: external_exports.string().optional().describe("owner-scoped create retry key")
+    }),
+    returns: "StoreUploadGrant",
+    scope: "write"
+  },
+  async ({ checksum, contentType, filename, idempotencyKey, size }, { call, deps, runtime }) => {
+    const input = {
+      contentType,
+      ...filename !== void 0 ? { filename } : {},
+      ...size !== void 0 ? { size } : {},
+      ...checksum !== void 0 ? { checksum } : {},
+      ...idempotencyKey !== void 0 ? { idempotencyKey } : {}
+    };
+    const start = await deps.service.beginUpload(input, {
+      owner: call.owner,
+      producer: call.owner
+    });
+    return deps.callbacks.createUpload(start, runtime);
   }
-  return value;
-}
-function rejectUnknown(args, allowed) {
-  const unknown2 = Object.keys(args).filter((key) => !allowed.includes(key));
-  if (unknown2.length > 0) {
-    throw new TBError("invalid_argument", `\u672A\u77E5\u5B57\u6BB5:${unknown2.join(",")}`);
+).register(
+  "complete_upload",
+  {
+    h: "verify a direct upload and atomically mark its object ready; idempotent",
+    inputSchema: external_exports.strictObject({ uploadId: external_exports.string().min(1) }),
+    returns: "StoreObject",
+    scope: "write"
+  },
+  ({ uploadId }, { call, deps }) => deps.service.completeUpload(uploadId, call.owner)
+).register(
+  "abort_upload",
+  {
+    h: "abandon an unfinished upload; idempotent until the object is ready",
+    inputSchema: external_exports.strictObject({ uploadId: external_exports.string().min(1) }),
+    returns: "void",
+    scope: "write"
+  },
+  ({ uploadId }, { call, deps }) => deps.service.abortUpload(uploadId, call.owner)
+).register(
+  "stat",
+  {
+    h: "return metadata for a ready object owned by the current principal",
+    inputSchema: external_exports.strictObject({ uri: uriSchema }),
+    returns: "StoreObject",
+    scope: "read"
+  },
+  ({ uri }, { call, deps }) => deps.service.stat(uri, { owner: call.owner })
+).register(
+  "read",
+  {
+    h: "authorize an object read and return a short-lived $ref",
+    inputSchema: external_exports.strictObject({ uri: uriSchema }),
+    returns: "{ $ref, contentType, size, expiresAt }",
+    scope: "read"
+  },
+  async ({ uri }, { call, deps, runtime }) => {
+    const object2 = await deps.service.authorizeRead(uri, { owner: call.owner });
+    return deps.callbacks.read(object2, runtime);
   }
-}
+).register(
+  "share",
+  {
+    h: "create a short-lived, revocable read share for an owned object",
+    inputSchema: external_exports.strictObject({
+      uri: uriSchema,
+      ttlSec: external_exports.number().int().positive().optional()
+    }),
+    returns: "StoreShare",
+    scope: "write"
+  },
+  async ({ ttlSec, uri }, { call, deps, runtime }) => {
+    const result = ttlSec === void 0 ? await deps.service.share(uri, call.owner) : await deps.service.share(uri, call.owner, ttlSec);
+    return deps.callbacks.share(result, runtime);
+  }
+).register(
+  "revoke_share",
+  {
+    h: "revoke a Store share grant",
+    inputSchema: external_exports.strictObject({ shareId: external_exports.string().min(1) }),
+    returns: "void",
+    scope: "write"
+  },
+  ({ shareId }, { call, deps }) => deps.service.revokeShare(shareId, call.owner)
+).register(
+  "delete",
+  {
+    h: "make an owned Store object immediately unreadable and delete its bytes",
+    inputSchema: external_exports.strictObject({ uri: uriSchema }),
+    returns: "void",
+    scope: "write"
+  },
+  ({ uri }, { call, deps }) => deps.service.delete(uri, { owner: call.owner })
+).register(
+  "list",
+  {
+    h: "list ready Store objects owned by the current principal",
+    inputSchema: external_exports.strictObject({ opts: HTBP_LIST_OPTIONS_SCHEMA.optional() }),
+    returns: "Page<StoreObject>",
+    scope: "read"
+  },
+  ({ opts }, { call, deps }) => deps.service.list(call.owner, opts ?? {})
+);
 function createStoreModule(deps) {
-  return {
-    module: "store",
-    description: DESCRIPTION3,
-    help(nodePath) {
-      return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION3 },
-        cmds: storeCmds(nodePath)
-      };
-    },
-    async dispatch(cmd, args, ctx, runtime) {
-      switch (cmd) {
-        case "create_upload": {
-          rejectUnknown(args, ["contentType", "filename", "size", "checksum", "idempotencyKey"]);
-          const input = {
-            contentType: requireString(args, "contentType"),
-            ...args.filename !== void 0 ? { filename: args.filename } : {},
-            ...args.size !== void 0 ? { size: args.size } : {},
-            ...args.checksum !== void 0 ? { checksum: args.checksum } : {},
-            ...args.idempotencyKey !== void 0 ? { idempotencyKey: args.idempotencyKey } : {}
-          };
-          const start = await deps.service.beginUpload(input, {
-            owner: ctx.owner,
-            producer: ctx.owner
-          });
-          return deps.callbacks.createUpload(start, runtime);
-        }
-        case "complete_upload":
-          rejectUnknown(args, ["uploadId"]);
-          return deps.service.completeUpload(requireString(args, "uploadId"), ctx.owner);
-        case "abort_upload":
-          rejectUnknown(args, ["uploadId"]);
-          return deps.service.abortUpload(requireString(args, "uploadId"), ctx.owner);
-        case "stat":
-          rejectUnknown(args, ["uri"]);
-          return deps.service.stat(requireString(args, "uri"), { owner: ctx.owner });
-        case "read": {
-          rejectUnknown(args, ["uri"]);
-          const object2 = await deps.service.authorizeRead(requireString(args, "uri"), {
-            owner: ctx.owner
-          });
-          return deps.callbacks.read(object2, runtime);
-        }
-        case "share": {
-          rejectUnknown(args, ["uri", "ttlSec"]);
-          const ttlSec = optionalPositiveInt(args, "ttlSec");
-          const result = ttlSec === void 0 ? await deps.service.share(requireString(args, "uri"), ctx.owner) : await deps.service.share(requireString(args, "uri"), ctx.owner, ttlSec);
-          return deps.callbacks.share(result, runtime);
-        }
-        case "revoke_share":
-          rejectUnknown(args, ["shareId"]);
-          return deps.service.revokeShare(requireString(args, "shareId"), ctx.owner);
-        case "delete":
-          rejectUnknown(args, ["uri"]);
-          return deps.service.delete(requireString(args, "uri"), { owner: ctx.owner });
-        case "list": {
-          rejectUnknown(args, ["opts"]);
-          const raw = args.opts;
-          if (raw !== void 0 && (typeof raw !== "object" || raw === null || Array.isArray(raw))) {
-            throw new TBError("invalid_argument", "opts \u5FC5\u987B\u662F\u5BF9\u8C61");
-          }
-          return deps.service.list(ctx.owner, raw ?? {});
-        }
-        default:
-          throw new TBError("invalid_argument", `unknown cmd '${cmd}' on system/store`);
-      }
-    }
-  };
+  return COMMANDS3.module(deps);
 }
 
 // ../core/src/builtin/annotation.ts
 var DESCRIPTION4 = "Path annotations: admin-curated notes shown in ~help of the annotated path (set / get / remove / list)";
-function annotationCmds(nodePath) {
-  const path = cmdPath(nodePath);
-  const cmds = [
-    {
-      name: "set",
-      method: "POST",
-      path,
-      h: "upsert the note shown in ~help of <path>; empty path = tree-wide notice",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: 'tree path (tool sub-paths like "feishu/create-doc" work); "" = tree-wide'
-          },
-          text: { type: "string", maxLength: 2e3, description: "the note (max 2000 chars)" }
-        },
-        required: ["path", "text"]
-      },
-      returns: "{ path, text, updatedAt, updatedBy }",
-      scope: "admin"
-    },
-    {
-      name: "get",
-      method: "POST",
-      path,
-      h: "read the note of one path (not_found if none)",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: 'tree path; "" = tree-wide notice' } },
-        required: ["path"]
-      },
-      returns: "{ path, text, updatedAt, updatedBy }",
-      scope: "read"
-    },
-    {
-      name: "remove",
-      method: "POST",
-      path,
-      h: "remove the note of a path (idempotent)",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: 'tree path; "" = tree-wide notice' } },
-        required: ["path"]
-      },
-      returns: "void",
-      scope: "admin"
-    },
-    {
-      name: "list",
-      method: "POST",
-      path,
-      h: "all annotated paths (optionally under a prefix)",
-      inputSchema: {
-        type: "object",
-        properties: {
-          prefix: { type: "string", description: "only paths under this prefix" }
-        }
-      },
-      returns: "{ items: Array<{ path, text, updatedAt, updatedBy }> }",
-      scope: "read"
+var rootablePathSchema = external_exports.string().describe('tree path; "" = tree-wide notice');
+var COMMANDS4 = new BuiltinCommandRegistry("annotation", DESCRIPTION4).register(
+  "set",
+  {
+    h: "upsert the note shown in ~help of <path>; empty path = tree-wide notice",
+    inputSchema: external_exports.strictObject({
+      path: external_exports.string().describe(
+        'tree path (tool sub-paths like "feishu/create-doc" work); "" = tree-wide'
+      ),
+      text: external_exports.string().min(1).max(ANNOTATION_TEXT_MAX).describe("the note (max 2000 chars)")
+    }),
+    returns: "{ path, text, updatedAt, updatedBy }",
+    scope: "admin"
+  },
+  async ({ path, text }, { call, deps }) => {
+    if (normalizePath(path) !== "") await deps.registry.resolve(path);
+    return await deps.store.set(path, text, call.keyId, deps.now());
+  }
+).register(
+  "get",
+  {
+    h: "read the note of one path (not_found if none)",
+    inputSchema: external_exports.strictObject({ path: rootablePathSchema }),
+    returns: "{ path, text, updatedAt, updatedBy }",
+    scope: "read"
+  },
+  async ({ path }, { deps }) => {
+    const got = await deps.store.get(path);
+    if (got === null) {
+      throw TBError.notFound(`\u8DEF\u5F84\u65E0\u8865\u5145\u8BF4\u660E:'${path === "" ? "/" : path}'`);
     }
-  ];
-  return withCommandPaths(nodePath, cmds);
-}
-function requireRootablePath(args) {
-  const v = args.path;
-  if (typeof v !== "string") {
-    throw new TBError("invalid_argument", "field 'path' must be a string");
+    return got;
   }
-  return v;
-}
+).register(
+  "remove",
+  {
+    h: "remove the note of a path (idempotent)",
+    inputSchema: external_exports.strictObject({ path: rootablePathSchema }),
+    returns: "void",
+    scope: "admin"
+  },
+  async ({ path }, { deps }) => {
+    await deps.store.remove(path);
+    return VOID_ACK;
+  }
+).register(
+  "list",
+  {
+    h: "all annotated paths (optionally under a prefix)",
+    inputSchema: external_exports.strictObject({
+      prefix: external_exports.string().optional().describe("only paths under this prefix")
+    }),
+    returns: "{ items: Array<{ path, text, updatedAt, updatedBy }> }",
+    scope: "read"
+  },
+  async ({ prefix }, { deps }) => ({ items: await deps.store.list(prefix) })
+);
 function createAnnotationModule(deps) {
-  return {
-    module: "annotation",
-    description: DESCRIPTION4,
-    help(nodePath) {
-      return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION4 },
-        cmds: annotationCmds(nodePath)
-      };
-    },
-    async dispatch(cmd, args, ctx) {
-      switch (cmd) {
-        case "set": {
-          const path = requireRootablePath(args);
-          if (normalizePath(path) !== "") {
-            await deps.registry.resolve(path);
-          }
-          return await deps.store.set(path, requireString(args, "text"), ctx.keyId, deps.now());
-        }
-        case "get": {
-          const path = requireRootablePath(args);
-          const got = await deps.store.get(path);
-          if (got === null) {
-            throw TBError.notFound(`\u8DEF\u5F84\u65E0\u8865\u5145\u8BF4\u660E:'${path === "" ? "/" : path}'`);
-          }
-          return got;
-        }
-        case "remove": {
-          await deps.store.remove(requireRootablePath(args));
-          return VOID_ACK;
-        }
-        case "list": {
-          const prefix = optString(args, "prefix");
-          return { items: await deps.store.list(prefix) };
-        }
-        default:
-          throw new TBError("invalid_argument", `unknown cmd '${cmd}' on system/annotation`);
-      }
-    }
-  };
+  return COMMANDS4.module(deps);
 }
 
 // ../core/src/tool/allowlist.ts
@@ -16443,52 +16541,6 @@ var RemoteAllowlistStore = class {
 
 // ../core/src/builtin/federation.ts
 var DESCRIPTION5 = "Remote federation host allowlist: which hosts kind=remote nodes may connect to (env baseline is read-only; admin only)";
-function federationCmds(nodePath) {
-  const path = cmdPath(nodePath);
-  const cmds = [
-    {
-      name: "list",
-      method: "POST",
-      path,
-      h: "merged allowlist view: env baseline entries (removable=false) plus runtime entries",
-      inputSchema: { type: "object", properties: {} },
-      returns: 'Page<{ host, source: "env"|"store", removable, updatedAt? }>',
-      scope: "admin"
-    },
-    {
-      name: "add",
-      method: "POST",
-      path,
-      h: "allow a host (suffix match covers subdomains); takes effect immediately",
-      inputSchema: {
-        type: "object",
-        properties: {
-          host: {
-            type: "string",
-            description: 'bare host suffix, e.g. "example.com" \u2014 no scheme/port/path'
-          }
-        },
-        required: ["host"]
-      },
-      returns: "{ host, updatedAt } \u2014 bare host suffix; no scheme/port/path",
-      scope: "admin"
-    },
-    {
-      name: "remove",
-      method: "POST",
-      path,
-      h: "remove a runtime-added host; env baseline entries cannot be removed here",
-      inputSchema: {
-        type: "object",
-        properties: { host: { type: "string", description: "bare host suffix as listed" } },
-        required: ["host"]
-      },
-      returns: "void \u2014 env baseline entries are not removable",
-      scope: "admin"
-    }
-  ];
-  return withCommandPaths(nodePath, cmds);
-}
 function mergedView(base, entries) {
   const byHost = /* @__PURE__ */ new Map();
   for (const raw of base) {
@@ -16502,202 +16554,317 @@ function mergedView(base, entries) {
   }
   return [...byHost.values()].sort((a, b) => a.host.localeCompare(b.host));
 }
-function createFederationModule(deps) {
-  return {
-    module: "federation",
-    description: DESCRIPTION5,
-    help(nodePath) {
-      return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION5 },
-        cmds: federationCmds(nodePath)
-      };
-    },
-    async dispatch(cmd, args) {
-      switch (cmd) {
-        case "list": {
-          const items = mergedView(deps.base, await deps.store.list());
-          return { items };
-        }
-        case "add": {
-          const host = normalizeAllowHost(requireString(args, "host"));
-          if (deps.base.some((b) => b.trim().toLowerCase() === host)) {
-            throw new TBError("invalid_argument", `host \u5DF2\u5728\u90E8\u7F72\u57FA\u7EBF(env)\u4E2D,\u65E0\u9700\u6DFB\u52A0:'${host}'`);
-          }
-          return await deps.store.add(host, deps.now());
-        }
-        case "remove": {
-          const host = normalizeAllowHost(requireString(args, "host"));
-          if (deps.base.some((b) => b.trim().toLowerCase() === host)) {
-            throw new TBError(
-              "invalid_argument",
-              `env \u57FA\u7EBF\u6761\u76EE\u4E0D\u53EF\u5220\u9664:'${host}'(\u6539 TB_REMOTE_ALLOWLIST \u5E76\u91CD\u65B0\u90E8\u7F72)`
-            );
-          }
-          await deps.store.remove(host);
-          return VOID_ACK;
-        }
-        default:
-          throw new TBError("invalid_argument", `unknown cmd '${cmd}' on system/federation`);
-      }
-    }
-  };
-}
-
-// ../core/src/builtin/registry.ts
-var DESCRIPTION6 = "Node registry: the single mount surface \u2014 everything on the tree (mcp/http/context/device/remote nodes) is mounted, listed and unmounted here";
-var NODE_FIELD_SCHEMAS = {
-  path: { type: "string", description: 'tree path to mount at, e.g. "docs/context7"' },
-  kind: {
-    type: "string",
-    enum: [...NODE_KINDS],
-    description: "node kind; determines the config shape"
+var COMMANDS5 = new BuiltinCommandRegistry("federation", DESCRIPTION5).register(
+  "list",
+  {
+    h: "merged allowlist view: env baseline entries (removable=false) plus runtime entries",
+    inputSchema: external_exports.strictObject({}),
+    returns: 'Page<{ host, source: "env"|"store", removable, updatedAt? }>',
+    scope: "admin"
   },
-  description: { type: "string", description: "one-line description shown in parent ~help" },
-  config: {
-    type: "object",
-    description: "kind-specific config, e.g. mcp: { url, auth?, authRef? } / http: { endpoint, tools } / context: { provider, bucket, \u2026 } / remote: { baseUrl, skRef }; credentials go by authRef/skRef name, never inline"
+  async (_input, { deps }) => ({ items: mergedView(deps.base, await deps.store.list()) })
+).register(
+  "add",
+  {
+    h: "allow a host (suffix match covers subdomains); takes effect immediately",
+    inputSchema: external_exports.strictObject({
+      host: external_exports.string().min(1).describe(
+        'bare host suffix, e.g. "example.com" \u2014 no scheme/port/path'
+      )
+    }),
+    returns: "{ host, updatedAt } \u2014 bare host suffix; no scheme/port/path",
+    scope: "admin"
   },
-  virtualize: {
-    type: "object",
-    description: "optional tool virtualization: { prefix?, rename?: {from:to}, hide?: [name], describe?: {name:text} }"
+  async ({ host }, { deps }) => {
+    const normalized = normalizeAllowHost(host);
+    if (deps.base.some((b) => b.trim().toLowerCase() === normalized)) {
+      throw new TBError("invalid_argument", `host \u5DF2\u5728\u90E8\u7F72\u57FA\u7EBF(env)\u4E2D,\u65E0\u9700\u6DFB\u52A0:'${normalized}'`);
+    }
+    return await deps.store.add(normalized, deps.now());
   }
-};
-function registryCmds(nodePath) {
-  const path = cmdPath(nodePath);
-  const cmds = [
-    {
-      name: "list",
-      method: "POST",
-      path,
-      h: "list registered nodes, optionally under a path prefix",
-      inputSchema: {
-        type: "object",
-        properties: {
-          prefix: { type: "string", description: "only nodes under this path prefix" },
-          opts: LIST_OPTS_SCHEMA
-        }
-      },
-      returns: "Page<Node>",
-      scope: "read"
-    },
-    {
-      name: "get",
-      method: "POST",
-      path,
-      h: "fetch one node registration (kind, description, config) by path",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: "exact tree path" } },
-        required: ["path"]
-      },
-      returns: "Node",
-      scope: "read"
-    },
-    {
-      name: "write",
-      method: "POST",
-      path,
-      h: "mount (or replace) a node at a path; idempotent upsert, intermediate directories auto-created",
-      inputSchema: {
-        type: "object",
-        properties: NODE_FIELD_SCHEMAS,
-        required: ["path", "kind", "description"]
-      },
-      returns: "Node",
-      scope: "register"
-    },
-    {
-      name: "update",
-      method: "POST",
-      path,
-      h: "patch fields of a mounted node (description, config, virtualize, \u2026) without remounting",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "exact tree path" },
-          patch: {
-            type: "object",
-            description: "fields to change; same shape as write, all optional",
-            properties: NODE_FIELD_SCHEMAS
-          }
-        },
-        required: ["path", "patch"]
-      },
-      returns: "Node",
-      scope: "register"
-    },
-    {
-      name: "delete",
-      method: "POST",
-      path,
-      h: "unmount a node (and reclaim empty auto-created parents); a node registered by another key can only be removed by its registrar or by a key holding the 'admin' scope on that path",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: "exact tree path" } },
-        required: ["path"]
-      },
-      returns: "void",
-      scope: "register"
+).register(
+  "remove",
+  {
+    h: "remove a runtime-added host; env baseline entries cannot be removed here",
+    inputSchema: external_exports.strictObject({
+      host: external_exports.string().min(1).describe("bare host suffix as listed")
+    }),
+    returns: "void \u2014 env baseline entries are not removable",
+    scope: "admin"
+  },
+  async ({ host }, { deps }) => {
+    const normalized = normalizeAllowHost(host);
+    if (deps.base.some((b) => b.trim().toLowerCase() === normalized)) {
+      throw new TBError(
+        "invalid_argument",
+        `env \u57FA\u7EBF\u6761\u76EE\u4E0D\u53EF\u5220\u9664:'${normalized}'(\u6539 TB_REMOTE_ALLOWLIST \u5E76\u91CD\u65B0\u90E8\u7F72)`
+      );
     }
-  ];
-  return withCommandPaths(nodePath, cmds);
+    await deps.store.remove(normalized);
+    return VOID_ACK;
+  }
+);
+function createFederationModule(deps) {
+  return COMMANDS5.module(deps);
+}
+
+// ../core/src/protocol/errorWire.ts
+var tbErrorCodeSchema = external_exports.enum(TB_ERROR_CODES);
+var tbErrorBodySchema = external_exports.object({
+  code: tbErrorCodeSchema,
+  message: external_exports.string(),
+  retryable: external_exports.boolean()
+});
+
+// ../core/src/protocol/wire.ts
+var actionSchema = external_exports.enum(ACTIONS);
+var nodeKindSchema = external_exports.enum(NODE_KINDS);
+var nodeInputConfigSchema = external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe(
+  "kind-specific config, e.g. mcp: { url, auth?, authRef? } / http: { endpoint, tools } / context: { provider, bucket, \u2026 } / remote: { baseUrl, skRef }; credentials go by authRef/skRef name, never inline"
+);
+var nodeInputVirtualizeSchema = external_exports.strictObject({
+  prefix: external_exports.string().optional(),
+  rename: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+  hide: external_exports.array(external_exports.string()).optional(),
+  describe: external_exports.record(external_exports.string(), external_exports.string()).optional()
+}).optional().describe(
+  "optional tool virtualization: { prefix?, rename?: {from:to}, hide?: [name], describe?: {name:text} }"
+);
+var nodeInputSchema = external_exports.strictObject({
+  path: external_exports.string().min(1).describe('tree path to mount at, e.g. "docs/context7"'),
+  kind: nodeKindSchema.describe("node kind; determines the config shape"),
+  description: external_exports.string().min(1).describe("one-line description shown in parent ~help"),
+  config: nodeInputConfigSchema,
+  virtualize: nodeInputVirtualizeSchema
+});
+var presenceStateSchema = external_exports.enum(["online", "stale", "offline"]);
+var presenceSchema = external_exports.object({
+  lastSeenAt: external_exports.string().optional(),
+  state: presenceStateSchema
+});
+var helpFeedbackItemSchema = external_exports.object({
+  id: external_exports.string(),
+  score: external_exports.number(),
+  title: external_exports.string()
+});
+var helpChildSchema = external_exports.object({
+  description: external_exports.string(),
+  kind: nodeKindSchema,
+  path: external_exports.string()
+});
+var helpCommandSchema = external_exports.object({
+  confirm: external_exports.boolean().optional(),
+  effect: external_exports.string().optional(),
+  h: external_exports.string().optional(),
+  inputSchema: external_exports.unknown().optional(),
+  method: external_exports.literal("POST"),
+  name: external_exports.string(),
+  outputSchema: external_exports.unknown().optional(),
+  path: external_exports.string(),
+  returns: external_exports.string().optional(),
+  scope: actionSchema
+});
+var helpJsonSchema = external_exports.object({
+  children: external_exports.array(helpChildSchema).optional(),
+  cmds: external_exports.array(helpCommandSchema),
+  feedback: external_exports.array(helpFeedbackItemSchema).optional(),
+  hint: external_exports.string().optional(),
+  htbp: external_exports.string(),
+  node: external_exports.object({
+    description: external_exports.string(),
+    kind: nodeKindSchema,
+    path: external_exports.string()
+  }),
+  note: external_exports.string().optional()
+});
+var treeJsonSchema = external_exports.lazy(() => external_exports.object({
+  children: external_exports.array(treeJsonSchema).optional(),
+  description: external_exports.string(),
+  kind: nodeKindSchema,
+  path: external_exports.string(),
+  presence: presenceSchema.optional(),
+  truncated: external_exports.boolean().optional()
+}));
+var toolSpecSchema = external_exports.object({
+  confirm: external_exports.boolean().optional(),
+  description: external_exports.string().optional(),
+  effect: external_exports.string().optional(),
+  inputSchema: external_exports.unknown().optional(),
+  name: external_exports.string(),
+  outputSchema: external_exports.unknown().optional()
+});
+var toolSearchItemSchema = external_exports.object({
+  path: external_exports.string(),
+  tool: toolSpecSchema
+});
+function pageSchema(itemSchema) {
+  return external_exports.object({
+    cursor: external_exports.string().optional(),
+    items: external_exports.array(itemSchema)
+  });
 }
+var toolSearchPageSchema = pageSchema(toolSearchItemSchema);
+var toolSearchRequestSchema = external_exports.strictObject({
+  opts: external_exports.strictObject({
+    cursor: external_exports.string().optional(),
+    limit: external_exports.number().int().optional(),
+    mode: external_exports.enum(["keyword", "semantic"]).optional()
+  }).optional(),
+  query: external_exports.string().trim().min(1)
+});
+var registryNodeSchema = external_exports.object({
+  config: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+  createdAt: external_exports.string().optional(),
+  description: external_exports.string(),
+  kind: nodeKindSchema,
+  lastSeenAt: external_exports.string().optional(),
+  online: external_exports.boolean().optional(),
+  path: external_exports.string(),
+  registeredBy: external_exports.string().optional(),
+  updatedAt: external_exports.string().optional(),
+  virtualize: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+});
+var feedbackViewShape = {
+  at: external_exports.string(),
+  by: external_exports.string(),
+  down: external_exports.number().int().nonnegative(),
+  id: external_exports.string(),
+  score: external_exports.number().int(),
+  title: external_exports.string(),
+  up: external_exports.number().int().nonnegative()
+};
+var feedbackViewSchema = external_exports.object(feedbackViewShape);
+var feedbackDetailSchema = external_exports.object({
+  ...feedbackViewShape,
+  detail: external_exports.string(),
+  path: external_exports.string()
+});
+var feedbackListSchema = external_exports.object({ items: external_exports.array(feedbackViewSchema) });
+var feedbackSubmitRequestSchema = external_exports.strictObject({
+  detail: external_exports.string(),
+  title: external_exports.string()
+});
+var feedbackSubmitResponseSchema = external_exports.object({
+  at: external_exports.string().optional(),
+  id: external_exports.string(),
+  path: external_exports.string(),
+  title: external_exports.string()
+});
+var feedbackVoteRequestSchema = external_exports.strictObject({
+  vote: external_exports.enum(["up", "down", "clear"])
+});
+var feedbackRemoveResponseSchema = external_exports.object({ ok: external_exports.literal(true) });
+var oauthAuthorizeRequestSchema = external_exports.strictObject({
+  redirectUri: external_exports.string().optional()
+});
+var oauthAuthorizeResponseSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({ status: external_exports.literal("authorized") }),
+  external_exports.object({ authorizationUrl: external_exports.url(), status: external_exports.literal("redirect") })
+]);
+var healthResponseSchema = external_exports.object({
+  catalog: external_exports.object({
+    count: external_exports.number().int().nonnegative(),
+    digest: external_exports.string()
+  }).optional(),
+  healthy: external_exports.boolean(),
+  version: external_exports.string()
+});
+var livenessResponseSchema = external_exports.object({ live: external_exports.boolean() });
+var readinessResponseSchema = external_exports.object({
+  checks: external_exports.record(external_exports.string(), external_exports.object({
+    detail: external_exports.string().optional(),
+    ok: external_exports.boolean()
+  })),
+  ready: external_exports.boolean()
+});
+
+// ../core/src/builtin/registry.ts
+var DESCRIPTION6 = "Node registry: the single mount surface \u2014 everything on the tree (mcp/http/context/device/remote nodes) is mounted, listed and unmounted here";
+var nodePatchSchema = nodeInputSchema.partial().describe(
+  "fields to change; same shape as write, all optional"
+);
 function parseNodeInput(args) {
-  const path = requireString(args, "path");
-  const kind = requireString(args, "kind");
-  if (!NODE_KINDS.includes(kind)) {
-    throw new TBError("invalid_argument", `invalid kind '${kind}'`);
+  const parsed = nodeInputSchema.safeParse(args);
+  if (!parsed.success) {
+    const issue2 = parsed.error.issues[0];
+    throw new TBError(
+      "invalid_argument",
+      `invalid NodeInput${issue2?.path.length ? ` at '${issue2.path.join(".")}'` : ""}: ${issue2?.message ?? "unknown validation error"}`
+    );
   }
-  const description = requireString(args, "description");
-  const node = { path, kind, description };
-  if (args.config !== void 0) node.config = args.config;
-  if (args.virtualize !== void 0) node.virtualize = args.virtualize;
-  return node;
+  return parsed.data;
 }
-function createRegistryModule(store, now, visibility) {
-  return {
-    module: "registry",
-    description: DESCRIPTION6,
-    help(nodePath) {
-      return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION6 },
-        cmds: registryCmds(nodePath)
-      };
-    },
-    async dispatch(cmd, args, ctx) {
-      switch (cmd) {
-        case "list": {
-          const page = await store.list(
-            optString(args, "prefix"),
-            optListOptions(args)
-          );
-          if (!visibility) return page;
-          const items = page.items.filter((n) => visibility(ctx.scopes, n.path, "read"));
-          return page.cursor !== void 0 ? { items, cursor: page.cursor } : { items };
-        }
-        case "get": {
-          const path = requireString(args, "path");
-          if (visibility && !visibility(ctx.scopes, path, "read")) {
-            throw new TBError("not_found", `\u8282\u70B9\u4E0D\u5B58\u5728:'${path}'`);
-          }
-          return store.get(path);
-        }
-        case "write":
-          return await store.write(parseNodeInput(args), ctx.keyId, now());
-        case "update":
-          return await store.update(
-            requireString(args, "path"),
-            requireObject(args, "patch"),
-            now()
-          );
-        case "delete":
-          await store.delete(requireString(args, "path"));
-          return VOID_ACK;
-        default:
-          throw new TBError("invalid_argument", `unknown cmd '${cmd}' on system/registry`);
-      }
+var COMMANDS6 = new BuiltinCommandRegistry("registry", DESCRIPTION6).register(
+  "list",
+  {
+    h: "list registered nodes, optionally under a path prefix",
+    inputSchema: external_exports.strictObject({
+      prefix: external_exports.string().optional().describe("only nodes under this path prefix"),
+      opts: HTBP_LIST_OPTIONS_SCHEMA.optional()
+    }),
+    returns: "Page<Node>",
+    scope: "read"
+  },
+  async ({ opts, prefix }, { call, deps }) => {
+    const page = await deps.store.list(prefix, opts);
+    if (!deps.visibility) return page;
+    const items = page.items.filter((n) => deps.visibility?.(call.scopes, n.path, "read") === true);
+    return page.cursor !== void 0 ? { items, cursor: page.cursor } : { items };
+  }
+).register(
+  "get",
+  {
+    h: "fetch one node registration (kind, description, config) by path",
+    inputSchema: external_exports.strictObject({
+      path: external_exports.string().min(1).describe("exact tree path")
+    }),
+    returns: "Node",
+    scope: "read"
+  },
+  ({ path }, { call, deps }) => {
+    if (deps.visibility && !deps.visibility(call.scopes, path, "read")) {
+      throw new TBError("not_found", `\u8282\u70B9\u4E0D\u5B58\u5728:'${path}'`);
     }
-  };
+    return deps.store.get(path);
+  }
+).register(
+  "write",
+  {
+    h: "mount (or replace) a node at a path; idempotent upsert, intermediate directories auto-created",
+    inputSchema: nodeInputSchema,
+    returns: "Node",
+    scope: "register"
+  },
+  (input, { call, deps }) => deps.store.write(input, call.keyId, deps.now())
+).register(
+  "update",
+  {
+    h: "patch fields of a mounted node (description, config, virtualize, \u2026) without remounting",
+    inputSchema: external_exports.strictObject({
+      path: external_exports.string().min(1).describe("exact tree path"),
+      patch: nodePatchSchema
+    }),
+    returns: "Node",
+    scope: "register"
+  },
+  ({ patch, path }, { deps }) => deps.store.update(path, patch, deps.now())
+).register(
+  "delete",
+  {
+    h: "unmount a node (and reclaim empty auto-created parents); a node registered by another key can only be removed by its registrar or by a key holding the 'admin' scope on that path",
+    inputSchema: external_exports.strictObject({
+      path: external_exports.string().min(1).describe("exact tree path")
+    }),
+    returns: "void",
+    scope: "register"
+  },
+  async ({ path }, { deps }) => {
+    await deps.store.delete(path);
+    return VOID_ACK;
+  }
+);
+function createRegistryModule(store, now, visibility) {
+  return COMMANDS6.module({ store, now, ...visibility !== void 0 ? { visibility } : {} });
 }
 
 // ../core/src/builtin/secret.ts
@@ -16710,291 +16877,189 @@ function assertUserSecretName(name) {
     );
   }
 }
-function secretCmds(nodePath) {
-  const path = cmdPath(nodePath);
-  const cmds = [
-    {
-      name: "set",
-      method: "POST",
-      path,
-      h: "store or rotate a credential under a name; mount configs reference it as authRef",
-      inputSchema: {
-        type: "object",
-        properties: {
-          name: {
-            type: "string",
-            description: 'reference name used as authRef in mount configs (":" is reserved)'
-          },
-          value: {
-            type: "string",
-            description: "the credential (token / key / JSON); encrypted at rest, never echoed"
-          }
-        },
-        required: ["name", "value"]
-      },
-      returns: "void \u2014 value never echoed",
-      scope: "admin"
-    },
-    {
-      name: "list",
-      method: "POST",
-      path,
-      h: "list stored credential names (names and timestamps only, never values)",
-      inputSchema: { type: "object", properties: { opts: LIST_OPTS_SCHEMA } },
-      returns: "Page<{ name, updatedAt }>",
-      scope: "admin"
-    },
-    {
-      name: "delete",
-      method: "POST",
-      path,
-      h: "delete a credential; mounts still referencing it will fail to resolve",
-      inputSchema: {
-        type: "object",
-        properties: { name: { type: "string", description: "reference name" } },
-        required: ["name"]
-      },
-      returns: "void",
-      scope: "admin"
-    }
-  ];
-  return withCommandPaths(nodePath, cmds);
-}
+var COMMANDS7 = new BuiltinCommandRegistry("secret", DESCRIPTION7).register(
+  "set",
+  {
+    h: "store or rotate a credential under a name; mount configs reference it as authRef",
+    inputSchema: external_exports.strictObject({
+      name: external_exports.string().min(1).describe(
+        'reference name used as authRef in mount configs (":" is reserved)'
+      ),
+      value: external_exports.string().min(1).describe(
+        "the credential (token / key / JSON); encrypted at rest, never echoed"
+      )
+    }),
+    returns: "void \u2014 value never echoed",
+    scope: "admin"
+  },
+  async ({ name, value }, { deps }) => {
+    assertUserSecretName(name);
+    await deps.store.set(name, value, deps.now());
+    return VOID_ACK;
+  }
+).register(
+  "list",
+  {
+    h: "list stored credential names (names and timestamps only, never values)",
+    inputSchema: external_exports.strictObject({ opts: HTBP_LIST_OPTIONS_SCHEMA.optional() }),
+    returns: "Page<{ name, updatedAt }>",
+    scope: "admin"
+  },
+  ({ opts }, { deps }) => deps.store.list(opts)
+).register(
+  "delete",
+  {
+    h: "delete a credential; mounts still referencing it will fail to resolve",
+    inputSchema: external_exports.strictObject({
+      name: external_exports.string().min(1).describe("reference name")
+    }),
+    returns: "void",
+    scope: "admin"
+  },
+  async ({ name }, { deps }) => {
+    assertUserSecretName(name);
+    await deps.store.delete(name);
+    return VOID_ACK;
+  }
+);
 function createSecretModule(store, now) {
-  return {
-    module: "secret",
-    description: DESCRIPTION7,
-    help(nodePath) {
-      return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION7 },
-        cmds: secretCmds(nodePath)
-      };
-    },
-    async dispatch(cmd, args) {
-      switch (cmd) {
-        case "set": {
-          const name = requireString(args, "name");
-          assertUserSecretName(name);
-          await store.set(name, requireString(args, "value"), now());
-          return VOID_ACK;
-        }
-        case "list":
-          return store.list(optListOptions(args));
-        case "delete": {
-          const name = requireString(args, "name");
-          assertUserSecretName(name);
-          await store.delete(name);
-          return VOID_ACK;
-        }
-        default:
-          throw new TBError("invalid_argument", `unknown cmd '${cmd}' on system/secret`);
-      }
-    }
-  };
+  return COMMANDS7.module({ store, now });
 }
 
 // ../core/src/builtin/status.ts
 var DESCRIPTION8 = "Gateway health and summary (readable without admin)";
-function statusCmds(nodePath) {
-  return withCommandPaths(nodePath, [
-    {
-      name: "get",
-      method: "POST",
-      path: cmdPath(nodePath),
-      h: "health summary: gateway version and node count; no arguments",
-      inputSchema: { type: "object", properties: {} },
-      returns: "{ healthy, version, nodeCount }",
-      scope: "read"
-    }
-  ]);
-}
+var COMMANDS8 = new BuiltinCommandRegistry("status", DESCRIPTION8).register(
+  "get",
+  {
+    h: "health summary: gateway version and node count; no arguments",
+    inputSchema: external_exports.strictObject({}),
+    returns: "{ healthy, version, nodeCount }",
+    scope: "read"
+  },
+  async (_input, { deps }) => {
+    const summary = {
+      healthy: true,
+      version: deps.version(),
+      nodeCount: await deps.nodeCount()
+    };
+    return summary;
+  }
+);
 function createStatusModule(deps) {
-  return {
-    module: "status",
-    description: DESCRIPTION8,
-    help(nodePath) {
-      return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION8 },
-        cmds: statusCmds(nodePath)
-      };
-    },
-    async dispatch(cmd) {
-      if (cmd !== "get") {
-        throw new TBError("invalid_argument", `unknown cmd '${cmd}' on system/status`);
-      }
-      const summary = {
-        healthy: true,
-        version: deps.version(),
-        nodeCount: await deps.nodeCount()
-      };
-      return summary;
-    }
-  };
+  return COMMANDS8.module(deps);
 }
 
 // ../core/src/builtin/sk.ts
 var DESCRIPTION9 = "Secret Key registry: issue / list / update / revoke access keys (the only credential form; admin only)";
-var SK_FIELD_SCHEMAS = {
-  owner: {
-    type: "string",
-    description: 'owner ref: "user:<name>" | "agent:<name>" | "device:<id>"'
+var actionSchema2 = external_exports.enum(["read", "write", "call", "register", "admin"]);
+var scopeSchema = external_exports.strictObject({
+  pattern: external_exports.string().describe('tree path glob, e.g. "**" (everything) or "docs/**"'),
+  actions: external_exports.array(actionSchema2),
+  effect: external_exports.enum(["allow", "deny"]).optional().describe('default "allow"')
+});
+var ownerSchema = external_exports.string().min(1).describe(
+  'owner ref: "user:<name>" | "agent:<name>" | "device:<id>"'
+);
+var descriptionSchema = external_exports.string().optional().describe("what this key is for (shown in list)");
+var scopesSchema = external_exports.array(scopeSchema).describe(
+  "permission grants; deny wins over allow, no match = denied"
+);
+var registerPathsSchema = external_exports.array(external_exports.string()).optional().describe(
+  "path prefixes this key may self-register nodes under (via ~register)"
+);
+var expiresAtSchema = external_exports.string().optional().describe(
+  "expiry, ISO 8601 timestamp with timezone; omit = never"
+);
+var writeSchema = external_exports.strictObject({
+  owner: ownerSchema,
+  description: descriptionSchema,
+  scopes: scopesSchema,
+  registerPaths: registerPathsSchema,
+  expiresAt: expiresAtSchema
+});
+var patchSchema2 = external_exports.strictObject({
+  owner: ownerSchema.optional(),
+  description: descriptionSchema,
+  scopes: scopesSchema.optional(),
+  registerPaths: registerPathsSchema,
+  expiresAt: expiresAtSchema,
+  disabled: external_exports.boolean().optional().describe("true = key rejected until re-enabled")
+}).describe("fields to change; same shape as write (all optional) plus disabled");
+function toSecretKeyInput(input) {
+  return {
+    owner: input.owner,
+    scopes: input.scopes,
+    ...input.description !== void 0 ? { description: input.description } : {},
+    ...input.registerPaths !== void 0 ? { registerPaths: input.registerPaths } : {},
+    ...input.expiresAt !== void 0 ? { expiresAt: normalizeExpiresAt(input.expiresAt) } : {}
+  };
+}
+function toUpdatePatch(input) {
+  return {
+    ...input.owner !== void 0 ? { owner: input.owner } : {},
+    ...input.description !== void 0 ? { description: input.description } : {},
+    ...input.scopes !== void 0 ? { scopes: input.scopes } : {},
+    ...input.registerPaths !== void 0 ? { registerPaths: input.registerPaths } : {},
+    ...input.expiresAt !== void 0 ? { expiresAt: normalizeExpiresAt(input.expiresAt) } : {},
+    ...input.disabled !== void 0 ? { disabled: input.disabled } : {}
+  };
+}
+var COMMANDS9 = new BuiltinCommandRegistry("sk", DESCRIPTION9).register(
+  "list",
+  {
+    h: "list issued keys (id, owner, scopes; the secret itself is never returned)",
+    inputSchema: external_exports.strictObject({ opts: HTBP_LIST_OPTIONS_SCHEMA.optional() }),
+    returns: "Page<SecretKey without hash>",
+    scope: "admin"
   },
-  description: { type: "string", description: "what this key is for (shown in list)" },
-  scopes: {
-    type: "array",
-    description: "permission grants; deny wins over allow, no match = denied",
-    items: {
-      type: "object",
-      properties: {
-        pattern: {
-          type: "string",
-          description: 'tree path glob, e.g. "**" (everything) or "docs/**"'
-        },
-        actions: {
-          type: "array",
-          items: { type: "string", enum: ["read", "write", "call", "register", "admin"] }
-        },
-        effect: { type: "string", enum: ["allow", "deny"], description: 'default "allow"' }
-      },
-      required: ["pattern", "actions"]
-    }
+  ({ opts }, { deps }) => deps.store.list(opts)
+).register(
+  "get",
+  {
+    h: "fetch one key by id",
+    inputSchema: external_exports.strictObject({
+      id: external_exports.string().min(1).describe("key id (from list or the issue response)")
+    }),
+    returns: "SecretKey without hash",
+    scope: "admin"
   },
-  registerPaths: {
-    type: "array",
-    items: { type: "string" },
-    description: "path prefixes this key may self-register nodes under (via ~register)"
+  ({ id }, { deps }) => deps.store.get(id)
+).register(
+  "write",
+  {
+    h: "issue a new key \u2014 the response carries the plaintext secret exactly once, store it immediately",
+    inputSchema: writeSchema,
+    returns: "{ key: SecretKey without hash, secret } \u2014 secret shown once",
+    scope: "admin"
   },
-  expiresAt: {
-    type: "string",
-    description: "expiry, ISO 8601 timestamp with timezone; omit = never"
-  }
-};
-function skCmds(nodePath) {
-  const path = cmdPath(nodePath);
-  const cmds = [
-    {
-      name: "list",
-      method: "POST",
-      path,
-      h: "list issued keys (id, owner, scopes; the secret itself is never returned)",
-      inputSchema: { type: "object", properties: { opts: LIST_OPTS_SCHEMA } },
-      returns: "Page<SecretKey without hash>",
-      scope: "admin"
-    },
-    {
-      name: "get",
-      method: "POST",
-      path,
-      h: "fetch one key by id",
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "key id (from list or the issue response)" }
-        },
-        required: ["id"]
-      },
-      returns: "SecretKey without hash",
-      scope: "admin"
-    },
-    {
-      name: "write",
-      method: "POST",
-      path,
-      h: "issue a new key \u2014 the response carries the plaintext secret exactly once, store it immediately",
-      inputSchema: {
-        type: "object",
-        properties: SK_FIELD_SCHEMAS,
-        required: ["owner", "scopes"]
-      },
-      returns: "{ key: SecretKey without hash, secret } \u2014 secret shown once",
-      scope: "admin"
-    },
-    {
-      name: "update",
-      method: "POST",
-      path,
-      h: "patch fields of an issued key (scopes, expiresAt, disabled, \u2026); takes effect immediately",
-      inputSchema: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "key id" },
-          patch: {
-            type: "object",
-            description: "fields to change; same shape as write (all optional) plus disabled",
-            properties: {
-              ...SK_FIELD_SCHEMAS,
-              disabled: { type: "boolean", description: "true = key rejected until re-enabled" }
-            }
-          }
-        },
-        required: ["id", "patch"]
-      },
-      returns: "SecretKey without hash",
-      scope: "admin"
-    },
-    {
-      name: "delete",
-      method: "POST",
-      path,
-      h: "revoke a key permanently; takes effect immediately",
-      inputSchema: {
-        type: "object",
-        properties: { id: { type: "string", description: "key id" } },
-        required: ["id"]
-      },
-      returns: "void",
-      scope: "admin"
-    }
-  ];
-  return withCommandPaths(nodePath, cmds);
-}
-function asSecretKeyInput(args) {
-  const owner = requireString(args, "owner");
-  if (!Array.isArray(args.scopes)) {
-    throw new TBError("invalid_argument", "field 'scopes' must be an array");
+  (input, { deps }) => deps.store.write(toSecretKeyInput(input), deps.now())
+).register(
+  "update",
+  {
+    h: "patch fields of an issued key (scopes, expiresAt, disabled, \u2026); takes effect immediately",
+    inputSchema: external_exports.strictObject({
+      id: external_exports.string().min(1).describe("key id"),
+      patch: patchSchema2
+    }),
+    returns: "SecretKey without hash",
+    scope: "admin"
+  },
+  ({ id, patch }, { deps }) => deps.store.update(id, toUpdatePatch(patch))
+).register(
+  "delete",
+  {
+    h: "revoke a key permanently; takes effect immediately",
+    inputSchema: external_exports.strictObject({ id: external_exports.string().min(1).describe("key id") }),
+    returns: "void",
+    scope: "admin"
+  },
+  async ({ id }, { deps }) => {
+    await deps.store.delete(id);
+    return VOID_ACK;
   }
-  const input = { owner, scopes: args.scopes };
-  if (typeof args.description === "string") input.description = args.description;
-  if (Array.isArray(args.registerPaths)) input.registerPaths = args.registerPaths;
-  if ("expiresAt" in args) input.expiresAt = normalizeExpiresAt(args.expiresAt);
-  return input;
-}
-function asSkUpdatePatch(args) {
-  const patch = { ...args };
-  if ("expiresAt" in args) patch.expiresAt = normalizeExpiresAt(args.expiresAt);
-  return patch;
-}
+);
 function createSkModule(store, now) {
-  return {
-    module: "sk",
-    description: DESCRIPTION9,
-    help(nodePath) {
-      return {
-        node: { path: nodePath, kind: "builtin", description: DESCRIPTION9 },
-        cmds: skCmds(nodePath)
-      };
-    },
-    async dispatch(cmd, args) {
-      switch (cmd) {
-        case "list":
-          return store.list(optListOptions(args));
-        case "get":
-          return store.get(requireString(args, "id"));
-        case "write":
-          return store.write(asSecretKeyInput(args), now());
-        case "update":
-          return store.update(
-            requireString(args, "id"),
-            asSkUpdatePatch(requireObject(args, "patch"))
-          );
-        case "delete":
-          await store.delete(requireString(args, "id"));
-          return VOID_ACK;
-        default:
-          throw new TBError("invalid_argument", `unknown cmd '${cmd}' on system/sk`);
-      }
-    }
-  };
+  return COMMANDS9.module({ store, now });
 }
 
 // ../core/src/builtin/index.ts
@@ -17051,191 +17116,18 @@ function createBuiltins(deps) {
 // ../core/src/context/help.ts
 var CONTEXT_CAPABILITIES = ["search", "delete"];
 var CONTEXT_DIRECT_UPLOAD_CAPABILITY = "direct-upload";
-var SCOPE_BY_CMD = {
-  list: "read",
-  get: "read",
-  search: "read",
-  write: "write",
-  update: "write",
-  delete: "write",
-  create_upload: "write"
-};
-function contextScopeForCmd(command) {
-  return SCOPE_BY_CMD[command] ?? null;
-}
-var OPTS_SCHEMA = {
-  type: "object",
-  description: "pagination options",
-  properties: {
-    cursor: { type: "string", description: "opaque cursor returned by the previous page" },
-    limit: { type: "number", description: "page size (default 50, max 200)" }
-  }
-};
-var SEARCH_OPTS_SCHEMA = {
-  type: "object",
-  description: "pagination + search mode",
-  properties: {
-    cursor: { type: "string", description: "opaque cursor returned by the previous page" },
-    limit: { type: "number", description: "page size (default 50, max 200)" },
-    mode: { type: "string", enum: ["keyword", "semantic"], description: 'default "keyword"' }
-  }
-};
-var METADATA_SCHEMA = {
-  type: "object",
-  description: "string-to-string metadata map",
-  additionalProperties: { type: "string" }
-};
-var ENTRY_SCHEMA = {
-  type: "object",
-  required: ["content"],
-  properties: {
-    contentType: {
-      type: "string",
-      description: "required when content is a string; defaults to application/json for non-string content"
-    },
-    content: { description: "entry body: string, or any JSON value" },
-    metadata: METADATA_SCHEMA,
-    ifVersion: { type: "string", description: "optimistic concurrency: expected current version" }
-  }
-};
-var PATCH_SCHEMA = {
-  type: "object",
-  description: "partial update; omitted fields keep their current value",
-  properties: {
-    content: { description: "replacement content" },
-    metadata: METADATA_SCHEMA,
-    ifVersion: { type: "string", description: "optimistic concurrency: expected current version" }
-  }
-};
-function contextCmds(nodePath) {
-  const path = cmdPath(nodePath);
-  const cmds = [
-    {
-      name: "list",
-      method: "POST",
-      path,
-      h: "list entries directly under a path (shallow, paginated)",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "entry path prefix inside the namespace" },
-          opts: OPTS_SCHEMA
-        }
-      },
-      returns: "Page<ContextEntryMeta>",
-      scope: "read"
-    },
-    {
-      name: "get",
-      method: "POST",
-      path,
-      h: "read one entry with content (oversized content comes back as { $ref: <download URL> })",
-      inputSchema: {
-        type: "object",
-        required: ["path"],
-        properties: {
-          path: { type: "string", description: "entry path inside the namespace" }
-        }
-      },
-      returns: "ContextEntry",
-      scope: "read"
-    },
-    {
-      name: "write",
-      method: "POST",
-      path,
-      h: "create or fully replace an entry (idempotent upsert)",
-      inputSchema: {
-        type: "object",
-        required: ["path", "entry"],
-        properties: {
-          path: { type: "string", description: "entry path inside the namespace" },
-          entry: ENTRY_SCHEMA
-        }
-      },
-      returns: "ContextEntryMeta",
-      scope: "write"
-    },
-    {
-      name: "update",
-      method: "POST",
-      path,
-      h: "partially update content and/or metadata (shallow merge); not_found if the entry does not exist",
-      inputSchema: {
-        type: "object",
-        required: ["path", "patch"],
-        properties: {
-          path: { type: "string", description: "entry path inside the namespace" },
-          patch: PATCH_SCHEMA
-        }
-      },
-      returns: "ContextEntryMeta",
-      scope: "write"
-    },
-    {
-      name: "delete",
-      method: "POST",
-      path,
-      h: "delete an entry (idempotent)",
-      inputSchema: {
-        type: "object",
-        required: ["path"],
-        properties: {
-          path: { type: "string", description: "entry path inside the namespace" }
-        }
-      },
-      scope: "write",
-      effect: "destructive"
-    },
-    {
-      name: "search",
-      method: "POST",
-      path,
-      h: "keyword search: substring match on entry paths and metadata values",
-      inputSchema: {
-        type: "object",
-        required: ["query"],
-        properties: {
-          query: { type: "string", description: "substring to match" },
-          opts: SEARCH_OPTS_SCHEMA
-        }
-      },
-      returns: "Page<ContextEntryMeta>",
-      scope: "read"
-    }
-  ];
-  return withCommandPaths(nodePath, cmds);
-}
 function contextUploadCmd(nodePath) {
-  return withCommandPaths(nodePath, [{
-    name: "create_upload",
-    method: "POST",
-    path: cmdPath(nodePath),
-    h: "create a short-lived, path-scoped direct-upload grant; persist the returned uri, not url",
-    inputSchema: {
-      type: "object",
-      required: ["path", "contentType"],
-      properties: {
-        path: { type: "string", description: "target entry path inside the namespace" },
-        contentType: { type: "string", description: "media type signed into the PUT request" },
-        overwrite: {
-          type: "boolean",
-          description: "allow replacing an existing object; default false"
-        }
-      }
-    },
-    returns: "ContextUploadGrant",
-    scope: "write",
-    effect: "write"
-  }])[0];
+  return contextCommands.command("create_upload", nodePath);
 }
 function contextHelpModel(node, opts = {}) {
-  const all = contextCmds(node.path);
-  const present = opts.methods === void 0 ? all : all.filter((c) => opts.methods?.has(c.name));
-  return {
-    node: { path: node.path, kind: "context", description: node.description },
-    cmds: opts.readOnly ? present.filter((c) => c.scope === "read") : present
-  };
+  return contextCommands.helpModel(
+    { path: node.path, kind: "context", description: node.description },
+    (command) => {
+      if (command.name === "create_upload") return false;
+      if (opts.methods !== void 0 && !opts.methods.has(command.name)) return false;
+      return opts.readOnly !== true || command.scope === "read";
+    }
+  );
 }
 
 // ../core/src/context/objectStore.ts
@@ -17644,11 +17536,6 @@ function isContextExpired(createdAt, ttlSec, now) {
 }
 
 // ../core/src/device/frames.ts
-var tbErrorBodySchema = external_exports.object({
-  code: external_exports.enum(TB_ERROR_CODES),
-  message: external_exports.string(),
-  retryable: external_exports.boolean()
-});
 var deviceNodeCmdSchema = external_exports.object({
   name: external_exports.string().min(1),
   description: external_exports.string().optional(),
@@ -17657,7 +17544,7 @@ var deviceNodeCmdSchema = external_exports.object({
   effect: external_exports.string().optional(),
   confirm: external_exports.boolean().optional()
 }).passthrough();
-var nodeInputSchema = external_exports.object({
+var nodeInputSchema2 = external_exports.object({
   path: external_exports.string().min(1),
   kind: external_exports.enum(NODE_KINDS),
   description: external_exports.string(),
@@ -17672,7 +17559,7 @@ var deviceExposeSchema = external_exports.object({
     roots: external_exports.array(external_exports.string().min(1)).min(1),
     readOnly: external_exports.boolean().optional()
   }).optional(),
-  nodes: external_exports.array(nodeInputSchema).optional()
+  nodes: external_exports.array(nodeInputSchema2).optional()
 });
 var idSchema = external_exports.string().min(1);
 var deviceCallContextSchema = external_exports.object({
@@ -18076,12 +17963,12 @@ function requireShort(value, field, max) {
   return trimmed;
 }
 var FeedbackStore = class {
+  onMutation;
+  store;
   constructor(store, onMutation) {
-    this.store = store;
     this.onMutation = onMutation;
+    this.store = store;
   }
-  store;
-  onMutation;
   keyOf(path) {
     return KEY_FEEDBACK + path;
   }
@@ -18243,24 +18130,24 @@ function renderHelpJson(model) {
     if (cmd.confirm) out.confirm = cmd.confirm;
     return out;
   });
-  const json2 = {
+  const json3 = {
     htbp: HTBP_VERSION,
     node: { path: model.node.path, kind: model.node.kind, description: model.node.description },
     cmds
   };
-  if (model.hint !== void 0) json2.hint = model.hint;
-  if (model.note !== void 0) json2.note = model.note;
+  if (model.hint !== void 0) json3.hint = model.hint;
+  if (model.note !== void 0) json3.note = model.note;
   if (model.feedback !== void 0 && model.feedback.length > 0) {
-    json2.feedback = model.feedback.map((f) => ({ id: f.id, title: f.title, score: f.score }));
+    json3.feedback = model.feedback.map((f) => ({ id: f.id, title: f.title, score: f.score }));
   }
   if (model.children) {
-    json2.children = model.children.map((child) => ({
+    json3.children = model.children.map((child) => ({
       path: child.path,
       kind: child.kind,
       description: child.description
     }));
   }
-  return json2;
+  return json3;
 }
 
 // ../core/src/htbp/helpMarkdown.ts
@@ -18505,43 +18392,116 @@ var TOKEN_PREFIX = {
 function stateCorrupt(kind) {
   return new TBError("internal", `Store ${kind} \u72B6\u6001\u635F\u574F`, { retryable: false });
 }
-function asRecord2(value, kind) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw stateCorrupt(kind);
-  }
-  return value;
-}
-function assertRevisioned(value, kind) {
-  const record2 = asRecord2(value, kind);
-  if (!Number.isInteger(record2.revision) || record2.revision < 1) {
-    throw stateCorrupt(kind);
-  }
-  return record2;
-}
-function parseObject(value) {
-  const record2 = assertRevisioned(value, "object");
-  if (typeof record2.id !== "string" || record2.store !== DEFAULT_STORE_NAME || typeof record2.driverKey !== "string" || typeof record2.owner !== "string" || typeof record2.contentType !== "string" || typeof record2.uploadId !== "string" || typeof record2.status !== "string") throw stateCorrupt("object");
-  return value;
-}
+var persistedId = external_exports.string().min(1);
+var persistedOwner = external_exports.string().min(1).refine((value) => !/[\r\n\0]/.test(value));
+var persistedTimestamp = external_exports.string().refine((value) => Number.isFinite(Date.parse(value)));
+var persistedNonNegativeInt = external_exports.number().int().nonnegative().refine(Number.isSafeInteger);
+var persistedPositiveInt = persistedNonNegativeInt.refine((value) => value > 0);
+var persistedHash = external_exports.string().regex(/^[0-9a-f]{64}$/);
+var persistedChecksum = external_exports.looseObject({
+  algorithm: external_exports.literal("sha256"),
+  value: external_exports.string().min(1)
+});
+function stateParser(kind, shape) {
+  const schema = external_exports.looseObject({ revision: persistedPositiveInt, ...shape });
+  return (value) => {
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) throw stateCorrupt(kind);
+    return parsed.data;
+  };
+}
+var parseObject = stateParser("object", {
+  bytesDeletedAt: persistedTimestamp.optional(),
+  checksum: persistedChecksum.optional(),
+  contentType: external_exports.string().min(1),
+  createdAt: persistedTimestamp,
+  driverKey: persistedId,
+  etag: external_exports.string().optional(),
+  expectedChecksum: persistedChecksum.optional(),
+  expectedSize: persistedNonNegativeInt.optional(),
+  expiresAt: persistedTimestamp.optional(),
+  filename: external_exports.string().optional(),
+  id: persistedId,
+  originCallId: persistedId.optional(),
+  owner: persistedOwner,
+  producer: persistedOwner.optional(),
+  readyAt: persistedTimestamp.optional(),
+  size: persistedNonNegativeInt.optional(),
+  status: external_exports.enum(["pending", "ready", "failed", "abandoned", "deleted"]),
+  store: external_exports.literal(DEFAULT_STORE_NAME),
+  updatedAt: persistedTimestamp,
+  uploadId: persistedId
+});
+var parseSessionRecord = stateParser("upload session", {
+  capabilityHash: persistedHash,
+  completedAt: persistedTimestamp.optional(),
+  contentType: external_exports.string().min(1),
+  createdAt: persistedTimestamp,
+  expectedChecksum: persistedChecksum.optional(),
+  expectedSize: persistedNonNegativeInt.optional(),
+  expiresAt: persistedTimestamp,
+  id: persistedId,
+  maxBytes: persistedPositiveInt,
+  objectId: persistedId,
+  status: external_exports.enum(["created", "completed", "aborted", "expired", "failed"]),
+  terminalAt: persistedTimestamp.optional(),
+  transport: external_exports.enum(["relay", "presigned-put"])
+});
+var parseCallCapabilityRecord = stateParser("call capability", {
+  allowedContentTypes: external_exports.array(external_exports.string().min(1)).min(1),
+  callId: persistedId,
+  createdAt: persistedTimestamp,
+  expiresAt: persistedTimestamp,
+  id: persistedId,
+  maxBytes: persistedPositiveInt,
+  maxObjectBytes: persistedPositiveInt,
+  maxObjects: persistedPositiveInt,
+  owner: persistedOwner,
+  producer: persistedOwner,
+  reservations: external_exports.array(external_exports.looseObject({
+    maxBytes: persistedPositiveInt,
+    objectId: persistedId
+  })),
+  reservedBytes: persistedNonNegativeInt,
+  status: external_exports.enum(["active", "exhausted", "revoked", "expired"]),
+  terminalAt: persistedTimestamp.optional(),
+  tokenHash: persistedHash
+});
+var parseShare = stateParser("share grant", {
+  createdAt: persistedTimestamp,
+  createdBy: persistedOwner,
+  expiresAt: persistedTimestamp,
+  id: persistedId,
+  objectId: persistedId,
+  status: external_exports.enum(["active", "revoked", "expired"]),
+  terminalAt: persistedTimestamp.optional(),
+  tokenHash: persistedHash
+});
+var parseIdempotencyBinding = stateParser("idempotency binding", {
+  createdAt: persistedTimestamp,
+  domain: external_exports.enum(["owner", "call"]),
+  expiresAt: persistedTimestamp,
+  fingerprint: persistedHash,
+  objectId: persistedId,
+  originCallId: persistedId.optional(),
+  owner: persistedOwner,
+  producer: persistedOwner,
+  uploadId: persistedId
+});
 function parseSession(value) {
-  const record2 = assertRevisioned(value, "upload session");
-  if (typeof record2.id !== "string" || typeof record2.objectId !== "string" || typeof record2.capabilityHash !== "string" || typeof record2.status !== "string") throw stateCorrupt("upload session");
-  return value;
+  const session = parseSessionRecord(value);
+  if (session.expectedSize !== void 0 && session.expectedSize > session.maxBytes || session.transport === "presigned-put" && session.expectedSize === void 0) throw stateCorrupt("upload session");
+  return session;
 }
 function parseCallCapability(value) {
-  const record2 = assertRevisioned(value, "call capability");
-  if (typeof record2.id !== "string" || typeof record2.tokenHash !== "string" || typeof record2.owner !== "string" || typeof record2.producer !== "string" || typeof record2.callId !== "string" || !Array.isArray(record2.reservations)) throw stateCorrupt("call capability");
-  return value;
-}
-function parseShare(value) {
-  const record2 = assertRevisioned(value, "share grant");
-  if (typeof record2.id !== "string" || typeof record2.objectId !== "string" || typeof record2.tokenHash !== "string" || typeof record2.createdBy !== "string") throw stateCorrupt("share grant");
-  return value;
-}
-function parseIdempotencyBinding(value) {
-  const record2 = assertRevisioned(value, "idempotency binding");
-  if (typeof record2.owner !== "string" || record2.domain !== "owner" && record2.domain !== "call" || typeof record2.producer !== "string" || typeof record2.fingerprint !== "string" || typeof record2.objectId !== "string" || typeof record2.uploadId !== "string") throw stateCorrupt("idempotency binding");
-  return value;
+  const capability = parseCallCapabilityRecord(value);
+  const reservedBytes = capability.reservations.reduce(
+    (total, reservation) => total + reservation.maxBytes,
+    0
+  );
+  const ids = new Set(capability.reservations.map((reservation) => reservation.objectId));
+  if (capability.maxObjectBytes > capability.maxBytes || capability.reservations.length > capability.maxObjects || ids.size !== capability.reservations.length || capability.reservations.some((reservation) => reservation.maxBytes > capability.maxObjectBytes) || !Number.isSafeInteger(reservedBytes) || reservedBytes !== capability.reservedBytes || reservedBytes > capability.maxBytes) throw stateCorrupt("call capability");
+  return capability;
 }
 function requireOwner(owner, field = "owner") {
   if (typeof owner !== "string" || owner.trim() === "" || /[\r\n\0]/.test(owner)) {
@@ -18580,7 +18540,10 @@ function normalizeContentType(value) {
 }
 function normalizeChecksum(value) {
   if (value === void 0) return void 0;
-  const record2 = asRecord2(value, "checksum");
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TBError("invalid_argument", "checksum \u4EC5\u652F\u6301 sha256");
+  }
+  const record2 = value;
   if (record2.algorithm !== "sha256" || typeof record2.value !== "string") {
     throw new TBError("invalid_argument", "checksum \u4EC5\u652F\u6301 sha256");
   }
@@ -18702,6 +18665,12 @@ var StoreService = class {
   tokenSecret;
   uploadTtlSec;
   cas;
+  /** 所有已存在记录的 CAS 共用 revision 期望，并拒绝错误的版本跃迁。 */
+  async compareRecord(key, current, next) {
+    if (next !== null && next.revision !== current.revision + 1)
+      throw stateCorrupt("revision transition");
+    return await this.cas(key, current.revision, next);
+  }
   async issueCallUploadCapability(input) {
     const now = this.nowIso();
     const expiresAt = normalizeTimestamp(input.expiresAt, "expiresAt");
@@ -18775,7 +18744,7 @@ var StoreService = class {
         terminalAt: this.nowIso(),
         revision: capability.revision + 1
       };
-      if (await this.cas(`${KEY_STORE_CALL_CAPABILITY}${capability.id}`, capability.revision, next)) {
+      if (await this.compareRecord(`${KEY_STORE_CALL_CAPABILITY}${capability.id}`, capability, next)) {
         return;
       }
     }
@@ -18813,7 +18782,7 @@ var StoreService = class {
   /** relay PUT 成功即在同一调用内把对象推进 ready；后续 complete 仅作幂等确认。 */
   async commitRelayUpload(input) {
     const session = await this.verifyUploadToken(input.uploadToken);
-    if (session.status === "completed") return this.readyDescriptor(session.objectId);
+    if (session.status === "completed") return descriptorOf(await this.requireObject(session.objectId));
     if (session.transport !== "relay") {
       throw new TBError("invalid_argument", "\u8BE5 upload session \u4E0D\u662F relay transport");
     }
@@ -18851,7 +18820,7 @@ var StoreService = class {
       await this.failUpload(session, object2);
       throw error51;
     }
-    return this.markReady(session, object2, meta3);
+    return this.markReady(session, meta3);
   }
   /** 普通管理面 complete：只接受稳定 owner，不接受 capability body 字段。 */
   async completeUpload(uploadId, actor) {
@@ -18868,7 +18837,7 @@ var StoreService = class {
   }
   async completeAuthorizedUpload(session, object2) {
     if (session.status === "completed" || object2.status === "ready") {
-      if (object2.status !== "ready") return this.readyDescriptor(object2.id);
+      if (object2.status !== "ready") return descriptorOf(await this.requireObject(object2.id));
       await this.completeSessionBestEffort(session);
       return descriptorOf(object2);
     }
@@ -18891,7 +18860,7 @@ var StoreService = class {
       await this.failUpload(session, object2);
       throw error51;
     }
-    return this.markReady(session, object2, meta3);
+    return this.markReady(session, meta3);
   }
   /** 普通管理面 abort：owner 路径。 */
   async abortUpload(uploadId, actor) {
@@ -18900,9 +18869,7 @@ var StoreService = class {
   }
   /** capability-only abort：token 只应来自 Authorization header。 */
   async abortUploadWithToken(uploadId, uploadToken) {
-    const id = this.tokenId(uploadToken, "upload");
-    const session = await this.requireSession(id);
-    await this.assertTokenHash(uploadToken, session.capabilityHash, "upload capability \u65E0\u6548");
+    const session = await this.verifyUploadToken(uploadToken);
     if (session.id !== uploadId) {
       throw new TBError("permission_denied", "upload capability \u4E0E session \u4E0D\u5339\u914D");
     }
@@ -18921,7 +18888,7 @@ var StoreService = class {
         updatedAt: this.nowIso(),
         revision: object2.revision + 1
       };
-      if (await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, next)) object2 = next;
+      if (await this.compareRecord(`${KEY_STORE_OBJECT}${object2.id}`, object2, next)) object2 = next;
       else object2 = await this.requireObject(object2.id);
     }
     if (object2.status === "ready") throw new TBError("conflict", "ready \u5BF9\u8C61\u4E0D\u80FD abort");
@@ -18933,7 +18900,7 @@ var StoreService = class {
         terminalAt,
         revision: session.revision + 1
       };
-      if (await this.cas(`${KEY_STORE_UPLOAD}${session.id}`, session.revision, next)) session = next;
+      if (await this.compareRecord(`${KEY_STORE_UPLOAD}${session.id}`, session, next)) session = next;
       else session = await this.requireSession(session.id);
     }
     if (session.status === "completed") throw new TBError("conflict", "ready \u5BF9\u8C61\u4E0D\u80FD abort");
@@ -18991,7 +18958,7 @@ var StoreService = class {
         updatedAt: this.nowIso(),
         revision: object2.revision + 1
       };
-      if (!await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, next)) continue;
+      if (!await this.compareRecord(`${KEY_STORE_OBJECT}${object2.id}`, object2, next)) continue;
       await this.objects.delete(object2.driverKey);
       await this.markBytesDeleted(object2.id, object2.driverKey);
       return { ok: true };
@@ -19056,7 +19023,7 @@ var StoreService = class {
         terminalAt: this.nowIso(),
         revision: grant.revision + 1
       };
-      if (await this.cas(`${KEY_STORE_SHARE}${grant.id}`, grant.revision, next)) {
+      if (await this.compareRecord(`${KEY_STORE_SHARE}${grant.id}`, grant, next)) {
         return { ok: true };
       }
     }
@@ -19073,7 +19040,6 @@ var StoreService = class {
       expiredUploads: 0,
       abandonedObjects: 0,
       deletedBytes: 0,
-      deletedOrphans: 0,
       deletedStaging: 0,
       expiredCallCapabilities: 0,
       expiredIdempotencyBindings: 0,
@@ -19102,7 +19068,7 @@ var StoreService = class {
         if (session.status === "expired") result.expiredUploads++;
       }
       if (this.uploadSessionIsTerminal(session) && this.retentionElapsed(this.uploadSessionTerminalAt(session), this.uploadTtlSec, nowMs)) {
-        await this.cas(item.key, session.revision, null);
+        await this.compareRecord(item.key, session, null);
       }
     }
     const shares = opts.cursors?.shares === null ? { items: [] } : await this.state.list(KEY_STORE_SHARE, {
@@ -19119,7 +19085,7 @@ var StoreService = class {
         if (grant.status === "expired") result.expiredShares++;
       }
       if (grant.status !== "active" && this.retentionElapsed(grant.terminalAt ?? grant.expiresAt, this.shareTtlSec, nowMs)) {
-        await this.cas(item.key, grant.revision, null);
+        await this.compareRecord(item.key, grant, null);
       }
     }
     const capabilities = opts.cursors?.callCapabilities === null ? { items: [] } : await this.state.list(KEY_STORE_CALL_CAPABILITY, {
@@ -19140,7 +19106,7 @@ var StoreService = class {
         this.uploadTtlSec,
         nowMs
       )) {
-        await this.cas(item.key, capability.revision, null);
+        await this.compareRecord(item.key, capability, null);
       }
     }
     const idempotencyBindings = opts.cursors?.idempotencyBindings === null ? { items: [] } : await this.state.list(KEY_STORE_IDEMPOTENCY, {
@@ -19150,7 +19116,7 @@ var StoreService = class {
     for (const item of idempotencyBindings.items) {
       const binding = parseIdempotencyBinding(item.value);
       if (Date.parse(binding.expiresAt) > nowMs) continue;
-      if (await this.cas(item.key, binding.revision, null)) {
+      if (await this.compareRecord(item.key, binding, null)) {
         result.expiredIdempotencyBindings++;
       }
     }
@@ -19167,7 +19133,7 @@ var StoreService = class {
           updatedAt: now,
           revision: object2.revision + 1
         };
-        if (await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, deleted)) {
+        if (await this.compareRecord(`${KEY_STORE_OBJECT}${object2.id}`, object2, deleted)) {
           object2 = deleted;
         } else {
           const currentRaw = await this.state.get(item.key);
@@ -19185,7 +19151,7 @@ var StoreService = class {
             updatedAt: now,
             revision: object2.revision + 1
           };
-          if (await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, abandoned)) {
+          if (await this.compareRecord(`${KEY_STORE_OBJECT}${object2.id}`, object2, abandoned)) {
             object2 = abandoned;
             result.abandonedObjects++;
           } else {
@@ -19204,7 +19170,7 @@ var StoreService = class {
         object2 = parseObject(currentRaw);
       }
       if (this.objectIsTerminal(object2) && object2.bytesDeletedAt !== void 0 && this.retentionElapsed(object2.bytesDeletedAt, this.uploadTtlSec, nowMs)) {
-        await this.cas(item.key, object2.revision, null);
+        await this.compareRecord(item.key, object2, null);
       }
     }
     const cursors = {
@@ -19212,8 +19178,7 @@ var StoreService = class {
       shares: shares.cursor ?? null,
       callCapabilities: capabilities.cursor ?? null,
       idempotencyBindings: idempotencyBindings.cursor ?? null,
-      objects: objectRecords.cursor ?? null,
-      driverObjects: null
+      objects: objectRecords.cursor ?? null
     };
     return Object.values(cursors).some((cursor) => cursor !== null) ? { ...result, cursors } : result;
   }
@@ -19292,12 +19257,10 @@ var StoreService = class {
       contentType: input.contentType,
       maxBytes,
       expiresAt: this.afterSeconds(now, this.uploadTtlSec),
-      attempts: 0,
       createdAt: now,
       revision: 1,
       ...input.size !== void 0 ? { expectedSize: input.size } : {},
-      ...input.checksum !== void 0 ? { expectedChecksum: input.checksum } : {},
-      ...input.idempotencyKey !== void 0 ? { idempotencyKeyHash: await sha256Hex(input.idempotencyKey) } : {}
+      ...input.checksum !== void 0 ? { expectedChecksum: input.checksum } : {}
     };
     const objectCreated = await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, null, object2);
     if (!objectCreated) {
@@ -19368,13 +19331,22 @@ var StoreService = class {
   async releaseFreshBinding(resolved) {
     if (!resolved.created || resolved.key === void 0) return;
     if (await this.state.get(`${KEY_STORE_UPLOAD}${resolved.binding.uploadId}`) !== null) return;
-    await this.cas(resolved.key, resolved.binding.revision, null);
+    await this.compareRecord(resolved.key, resolved.binding, null);
   }
   async reserveCallCapability(token, objectId, input, transportMaxBytes) {
     for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
       const capability = await this.verifyCallUploadCapability(token);
       const previous = capability.reservations.find((r) => r.objectId === objectId);
-      if (previous !== void 0) return previous.maxBytes;
+      if (previous !== void 0) {
+        const replayMaxBytes = Math.min(previous.maxBytes, transportMaxBytes);
+        if (input.size !== void 0 && input.size > replayMaxBytes) {
+          throw new TBError(
+            "rate_limited",
+            `\u5BF9\u8C61\u8D85\u8FC7\u672C\u6B21\u4E0A\u4F20\u4E0A\u9650 ${replayMaxBytes} bytes`
+          );
+        }
+        return replayMaxBytes;
+      }
       if (capability.status !== "active") {
         throw new TBError("rate_limited", "call upload capability \u914D\u989D\u5DF2\u8017\u5C3D");
       }
@@ -19404,18 +19376,16 @@ var StoreService = class {
         status: exhausted ? "exhausted" : "active",
         revision: capability.revision + 1
       };
-      if (await this.cas(
-        `${KEY_STORE_CALL_CAPABILITY}${capability.id}`,
-        capability.revision,
-        next
-      )) return maxBytes;
+      if (await this.compareRecord(`${KEY_STORE_CALL_CAPABILITY}${capability.id}`, capability, next))
+        return maxBytes;
     }
     throw new TBError("conflict", "call upload capability \u5E76\u53D1\u6D88\u8D39\u51B2\u7A81");
   }
   async startFor(session) {
     const object2 = await this.requireObject(session.objectId);
     const uploadToken = await this.tokenFor("upload", session.id);
-    if (session.status === "completed" && object2.status === "ready") {
+    if (object2.status === "ready") {
+      await this.completeSessionBestEffort(session);
       return {
         uploadId: session.id,
         objectUri: storeUri(object2.id),
@@ -19436,7 +19406,11 @@ var StoreService = class {
       throw new TBError("conflict", "upload session \u5DF2\u8FC7\u671F");
     }
     let signedRequest;
-    if (session.transport === "presigned-put" && session.expectedSize !== void 0 && this.objects.presignPutExact !== void 0) {
+    if (session.transport === "presigned-put") {
+      if (session.expectedSize === void 0) throw stateCorrupt("direct upload size");
+      if (this.objects.presignPutExact === void 0) {
+        throw new TBError("unavailable", "direct upload signer \u5F53\u524D\u4E0D\u53EF\u7528", { retryable: true });
+      }
       signedRequest = await this.objects.presignPutExact(
         object2.driverKey,
         Math.max(1, Math.floor(remainingMs / 1e3)),
@@ -19493,7 +19467,7 @@ var StoreService = class {
         bytesDeletedAt: this.nowIso(),
         revision: object2.revision + 1
       };
-      if (await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, next)) return;
+      if (await this.compareRecord(`${KEY_STORE_OBJECT}${object2.id}`, object2, next)) return;
     }
     throw new TBError("conflict", "Store \u5BF9\u8C61\u5B57\u8282\u5220\u9664\u72B6\u6001\u5E76\u53D1\u66F4\u65B0\u51B2\u7A81");
   }
@@ -19580,56 +19554,51 @@ var StoreService = class {
     };
     return bounded;
   }
-  async markReady(sessionInput, objectInput, meta3) {
-    let object2 = await this.requireObject(objectInput.id);
-    if (object2.status === "ready") {
-      const currentSession = await this.requireSession(sessionInput.id);
-      await this.completeSessionBestEffort(currentSession);
-      return descriptorOf(object2);
-    }
-    if (object2.status !== "pending") {
-      await this.objects.delete(object2.driverKey);
-      await this.markBytesDeleted(object2.id, object2.driverKey);
-      throw new TBError("conflict", `\u5BF9\u8C61\u72B6\u6001\u4E0D\u5141\u8BB8 ready:${object2.status}`);
-    }
-    const now = this.nowIso();
+  async markReady(sessionInput, meta3) {
     const actualChecksum = sessionInput.expectedChecksum !== void 0 && meta3.metadata?.["checksum-sha256"]?.toLowerCase() === sessionInput.expectedChecksum.value ? sessionInput.expectedChecksum : void 0;
-    const ready = {
-      ...object2,
-      status: "ready",
-      size: meta3.size,
-      etag: meta3.etag,
-      readyAt: now,
-      updatedAt: now,
-      revision: object2.revision + 1,
-      ...actualChecksum !== void 0 ? { checksum: actualChecksum } : {}
-    };
-    if (!await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, ready)) {
-      object2 = await this.requireObject(object2.id);
-      if (object2.status !== "ready") {
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+      const object2 = await this.requireObject(sessionInput.objectId);
+      if (object2.status === "ready") {
+        await this.completeSessionBestEffort(await this.requireSession(sessionInput.id));
+        return descriptorOf(object2);
+      }
+      if (object2.status !== "pending") {
         await this.objects.delete(object2.driverKey);
         await this.markBytesDeleted(object2.id, object2.driverKey);
-        throw new TBError("conflict", `\u5BF9\u8C61\u5E76\u53D1\u72B6\u6001\u51B2\u7A81:${object2.status}`);
+        const detail = attempt === 0 ? "\u72B6\u6001\u4E0D\u5141\u8BB8 ready" : "\u5E76\u53D1\u72B6\u6001\u51B2\u7A81";
+        throw new TBError("conflict", `\u5BF9\u8C61${detail}:${object2.status}`);
       }
-    } else {
-      object2 = ready;
+      const now = this.nowIso();
+      const ready = {
+        ...object2,
+        status: "ready",
+        size: meta3.size,
+        etag: meta3.etag,
+        readyAt: now,
+        updatedAt: now,
+        revision: object2.revision + 1,
+        ...actualChecksum !== void 0 ? { checksum: actualChecksum } : {}
+      };
+      if (!await this.compareRecord(`${KEY_STORE_OBJECT}${object2.id}`, object2, ready)) continue;
+      await this.completeSessionBestEffort(await this.requireSession(sessionInput.id));
+      return descriptorOf(ready);
     }
-    const session = await this.requireSession(sessionInput.id);
-    await this.completeSessionBestEffort(session);
-    return descriptorOf(object2);
+    throw new TBError("conflict", "\u5BF9\u8C61\u5E76\u53D1\u72B6\u6001\u51B2\u7A81:pending");
   }
-  async completeSessionBestEffort(session) {
-    if (session.status === "completed") return;
-    if (session.status !== "created") return;
-    const completedAt = this.nowIso();
-    const next = {
-      ...session,
-      status: "completed",
-      completedAt,
-      terminalAt: completedAt,
-      revision: session.revision + 1
-    };
-    await this.cas(`${KEY_STORE_UPLOAD}${session.id}`, session.revision, next);
+  async completeSessionBestEffort(sessionInput) {
+    for (let attempt = 0; attempt < MAX_CAS_ATTEMPTS; attempt++) {
+      const session = await this.requireSession(sessionInput.id);
+      if (session.status === "completed" || session.status !== "created") return;
+      const completedAt = this.nowIso();
+      const next = {
+        ...session,
+        status: "completed",
+        completedAt,
+        terminalAt: completedAt,
+        revision: session.revision + 1
+      };
+      if (await this.compareRecord(`${KEY_STORE_UPLOAD}${session.id}`, session, next)) return;
+    }
   }
   async failUpload(session, object2) {
     const terminalAt = this.nowIso();
@@ -19641,7 +19610,7 @@ var StoreService = class {
         updatedAt: terminalAt,
         revision: object2.revision + 1
       };
-      await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, failed);
+      await this.compareRecord(`${KEY_STORE_OBJECT}${object2.id}`, object2, failed);
     }
     if (session.status === "created") {
       const failed = {
@@ -19650,20 +19619,13 @@ var StoreService = class {
         terminalAt,
         revision: session.revision + 1
       };
-      await this.cas(`${KEY_STORE_UPLOAD}${session.id}`, session.revision, failed);
+      await this.compareRecord(`${KEY_STORE_UPLOAD}${session.id}`, session, failed);
     }
     await this.markBytesDeleted(object2.id, object2.driverKey);
   }
   async expireUpload(session) {
     if (session.status !== "created") return;
-    const next = {
-      ...session,
-      status: "expired",
-      terminalAt: this.nowIso(),
-      revision: session.revision + 1
-    };
-    if (!await this.cas(`${KEY_STORE_UPLOAD}${session.id}`, session.revision, next)) return;
-    const object2 = await this.requireObject(session.objectId);
+    let object2 = await this.requireObject(session.objectId);
     if (object2.status === "pending") {
       const abandoned = {
         ...object2,
@@ -19671,8 +19633,26 @@ var StoreService = class {
         updatedAt: this.nowIso(),
         revision: object2.revision + 1
       };
-      await this.cas(`${KEY_STORE_OBJECT}${object2.id}`, object2.revision, abandoned);
+      if (await this.compareRecord(`${KEY_STORE_OBJECT}${object2.id}`, object2, abandoned)) {
+        object2 = abandoned;
+      } else {
+        object2 = await this.requireObject(object2.id);
+      }
+    }
+    if (object2.status === "ready") {
+      await this.completeSessionBestEffort(session);
+      return;
     }
+    if (object2.status === "pending") return;
+    const current = await this.requireSession(session.id);
+    if (current.status !== "created") return;
+    const next = {
+      ...current,
+      status: "expired",
+      terminalAt: this.nowIso(),
+      revision: current.revision + 1
+    };
+    await this.compareRecord(`${KEY_STORE_UPLOAD}${current.id}`, current, next);
   }
   async expireCallCapability(capability) {
     if (capability.status === "expired" || capability.status === "revoked") return;
@@ -19682,7 +19662,7 @@ var StoreService = class {
       terminalAt: this.nowIso(),
       revision: capability.revision + 1
     };
-    await this.cas(`${KEY_STORE_CALL_CAPABILITY}${capability.id}`, capability.revision, next);
+    await this.compareRecord(`${KEY_STORE_CALL_CAPABILITY}${capability.id}`, capability, next);
   }
   async expireShare(grant) {
     if (grant.status !== "active") return;
@@ -19692,10 +19672,7 @@ var StoreService = class {
       terminalAt: this.nowIso(),
       revision: grant.revision + 1
     };
-    await this.cas(`${KEY_STORE_SHARE}${grant.id}`, grant.revision, next);
-  }
-  async readyDescriptor(objectId) {
-    return descriptorOf(await this.requireObject(objectId));
+    await this.compareRecord(`${KEY_STORE_SHARE}${grant.id}`, grant, next);
   }
   async requireObject(id) {
     const raw = await this.state.get(`${KEY_STORE_OBJECT}${id}`);
@@ -19747,94 +19724,6 @@ var StoreService = class {
   }
 };
 
-// ../core/src/operation/registry.ts
-function normalizeSchema(input) {
-  return input instanceof external_exports.ZodType ? input : external_exports.object(input);
-}
-function toJsonSchema(schema) {
-  const json2 = external_exports.toJSONSchema(schema);
-  return omit2(json2, "$schema");
-}
-function invalidArgument(name, error51) {
-  const detail = error51.issues.map((issue2) => {
-    const path = issue2.path.join(".");
-    return path.length > 0 ? `${path}: ${issue2.message}` : issue2.message;
-  }).join("; ");
-  return new TBError("invalid_argument", `invalid arguments for '${name}': ${detail}`);
-}
-var TOOL_RESULT_KEYS = /* @__PURE__ */ new Set(["content", "contentBlocks", "isError", "structuredContent"]);
-function toToolResult(value) {
-  if (typeof value === "object" && value !== null && "content" in value) {
-    const keys = Object.keys(value);
-    if (keys.every((key) => TOOL_RESULT_KEYS.has(key))) return value;
-  }
-  return { content: value };
-}
-var OperationRegistry = class {
-  ops = /* @__PURE__ */ new Map();
-  /** 注册一个操作。同名重复注册 → invalid_argument(配置错误,快速失败)。 */
-  register(name, spec, handler) {
-    if (name.length === 0) {
-      throw new TBError("invalid_argument", "operation name must be non-empty");
-    }
-    if (this.ops.has(name)) {
-      throw new TBError("invalid_argument", `operation '${name}' is already registered`);
-    }
-    if (spec.inputSchema !== void 0 && spec.rawInputSchema !== void 0) {
-      throw new TBError(
-        "invalid_argument",
-        `operation '${name}': inputSchema and rawInputSchema are mutually exclusive`
-      );
-    }
-    const schema = spec.inputSchema !== void 0 ? normalizeSchema(spec.inputSchema) : void 0;
-    const toolSpec = { name };
-    if (spec.description !== void 0) toolSpec.description = spec.description;
-    if (spec.effect !== void 0) toolSpec.effect = spec.effect;
-    if (spec.confirm !== void 0) toolSpec.confirm = spec.confirm;
-    if (schema !== void 0) toolSpec.inputSchema = toJsonSchema(schema);
-    else if (spec.rawInputSchema !== void 0) toolSpec.inputSchema = spec.rawInputSchema;
-    if (spec.outputSchema !== void 0) toolSpec.outputSchema = spec.outputSchema;
-    this.ops.set(name, {
-      schema,
-      spec: toolSpec,
-      handler
-    });
-    return this;
-  }
-  /** 已注册的操作名(注册顺序)。 */
-  names() {
-    return [...this.ops.keys()];
-  }
-  has(name) {
-    return this.ops.has(name);
-  }
-  /** 全部 ToolSpec(工具源天然小,豁免分页)。 */
-  list() {
-    return [...this.ops.values()].map((op) => op.spec);
-  }
-  /** 单个 ToolSpec;不存在 → not_found。 */
-  get(name) {
-    const op = this.ops.get(name);
-    if (op === void 0) throw TBError.notFound(`unknown operation: '${name}'`);
-    return op.spec;
-  }
-  /**
-   * 调用:safeParse 入参(失败 → invalid_argument)、执行 handler、把裸返回值包成 ToolResult。
-   * 未声明 schema 的操作原样透传 args。
-   */
-  async call(name, args, ctx) {
-    const op = this.ops.get(name);
-    if (op === void 0) throw TBError.notFound(`unknown operation: '${name}'`);
-    let input = args;
-    if (op.schema !== void 0) {
-      const parsed = op.schema.safeParse(args);
-      if (!parsed.success) throw invalidArgument(name, parsed.error);
-      input = parsed.data;
-    }
-    return toToolResult(await op.handler(input, ctx));
-  }
-};
-
 // ../core/src/origin.ts
 function normalizeCanonicalOrigin(value) {
   if (value === void 0) return void 0;
@@ -20100,6 +19989,94 @@ function decodePluginCall(body) {
   return parsed.data;
 }
 
+// ../core/src/runtimeEnv.ts
+var DEFAULT_MAX_HOPS = 4;
+var optionalPositiveIntSchema = external_exports.string().min(1).transform(Number).pipe(external_exports.number().finite().positive()).transform(Math.floor).optional().catch(void 0);
+var optionalNonNegativeIntSchema = external_exports.string().min(1).transform(Number).pipe(external_exports.number().finite().int().nonnegative()).optional().catch(void 0);
+var optionalPortSchema = external_exports.string().min(1).transform(Number).pipe(external_exports.number().int().min(0).max(65535)).optional().catch(void 0);
+var optionalStringSchema = external_exports.string().optional();
+var positiveEnvKeys = [
+  "TB_DEVICE_RECLAIM_SEC",
+  "TB_MAX_HOPS",
+  "TB_REF_THRESHOLD_BYTES",
+  "TB_REF_TTL_SEC",
+  "TB_STORE_CALL_MAX_BYTES",
+  "TB_STORE_CALL_MAX_OBJECT_BYTES",
+  "TB_STORE_CALL_MAX_OBJECTS",
+  "TB_STORE_CLEANUP_INTERVAL_SEC",
+  "TB_STORE_MAX_OBJECT_BYTES",
+  "TB_STORE_READ_TTL_SEC",
+  "TB_STORE_RELAY_MAX_BYTES",
+  "TB_STORE_SHARE_TTL_SEC",
+  "TB_STORE_UPLOAD_TTL_SEC",
+  "TB_TOOL_CACHE_TTL",
+  "TB_UPLOAD_GRANT_TTL_SEC"
+];
+var positiveEnvShape = Object.fromEntries(
+  positiveEnvKeys.map((key) => [key, optionalPositiveIntSchema])
+);
+var runtimeEnvSchema = external_exports.object({
+  ...positiveEnvShape,
+  TB_ALLOW_INSECURE_HTTP: optionalStringSchema,
+  TB_CANONICAL_ORIGIN: optionalStringSchema,
+  TB_INSTANCE_ID: optionalStringSchema,
+  TB_REMOTE_ALLOWLIST: optionalStringSchema,
+  TB_STORE_CALL_ALLOWED_CONTENT_TYPES: optionalStringSchema,
+  TB_STORE_TOKEN_SECRET: external_exports.union([
+    external_exports.literal("").transform(() => void 0),
+    external_exports.string().min(16, "TB_STORE_TOKEN_SECRET \u81F3\u5C11\u9700\u8981 16 \u4E2A\u5B57\u7B26")
+  ]).optional()
+});
+function setDefined(target, key, value) {
+  if (value !== void 0) target[key] = value;
+}
+function parseNonNegativeIntEnv(value) {
+  return optionalNonNegativeIntSchema.parse(value);
+}
+function parsePortEnv(value) {
+  return optionalPortSchema.parse(value);
+}
+function parseRuntimeEnv(env) {
+  const parsed = runtimeEnvSchema.parse(env);
+  const allowInsecureHttp = parsed.TB_ALLOW_INSECURE_HTTP === "true";
+  const allowlist = (parsed.TB_REMOTE_ALLOWLIST ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+  const allowedContentTypes = (parsed.TB_STORE_CALL_ALLOWED_CONTENT_TYPES ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+  const presignTtl = (value) => value === void 0 ? void 0 : Math.min(value, PRESIGN_TTL_SEC_MAX);
+  const result = {
+    allowInsecureHttp,
+    remote: {
+      allowInsecure: allowInsecureHttp,
+      allowlist,
+      maxHops: parsed.TB_MAX_HOPS ?? DEFAULT_MAX_HOPS,
+      ...parsed.TB_INSTANCE_ID ? { instanceId: parsed.TB_INSTANCE_ID } : {}
+    }
+  };
+  setDefined(result, "canonicalOrigin", normalizeCanonicalOrigin(parsed.TB_CANONICAL_ORIGIN));
+  const directNumbers = [
+    ["deviceReclaimSec", "TB_DEVICE_RECLAIM_SEC"],
+    ["toolCacheTtlSec", "TB_TOOL_CACHE_TTL"],
+    ["refThresholdBytes", "TB_REF_THRESHOLD_BYTES"],
+    ["storeMaxObjectBytes", "TB_STORE_MAX_OBJECT_BYTES"],
+    ["storeRelayMaxBytes", "TB_STORE_RELAY_MAX_BYTES"],
+    ["storeCallMaxBytes", "TB_STORE_CALL_MAX_BYTES"],
+    ["storeCallMaxObjectBytes", "TB_STORE_CALL_MAX_OBJECT_BYTES"],
+    ["storeCallMaxObjects", "TB_STORE_CALL_MAX_OBJECTS"],
+    ["storeCleanupIntervalSec", "TB_STORE_CLEANUP_INTERVAL_SEC"]
+  ];
+  for (const [output, input] of directNumbers) setDefined(result, output, parsed[input]);
+  const presignTtls = [
+    ["refTtlSec", "TB_REF_TTL_SEC"],
+    ["uploadGrantTtlSec", "TB_UPLOAD_GRANT_TTL_SEC"],
+    ["storeUploadTtlSec", "TB_STORE_UPLOAD_TTL_SEC"],
+    ["storeShareTtlSec", "TB_STORE_SHARE_TTL_SEC"],
+    ["storeReadTtlSec", "TB_STORE_READ_TTL_SEC"]
+  ];
+  for (const [output, input] of presignTtls) setDefined(result, output, presignTtl(parsed[input]));
+  setDefined(result, "storeTokenSecret", parsed.TB_STORE_TOKEN_SECRET);
+  if (allowedContentTypes.length > 0) result.storeCallAllowedContentTypes = allowedContentTypes;
+  return result;
+}
+
 // ../core/src/search/types.ts
 var TOOL_SEARCH_BATCH_LIMIT = 100;
 var TOOL_SEARCH_WORK_LIMIT = 400;
@@ -20999,133 +20976,103 @@ function parseFrontmatter(text) {
   return { meta: meta3, body };
 }
 
-// ../core/src/skillhub/help.ts
-var SKILLHUB_CAPABILITIES = ["search"];
-var SCOPE_BY_CMD2 = {
-  list: "read",
-  get: "read",
-  search: "read",
-  publish: "write",
-  remove: "write"
-};
+// ../core/src/skillhub/commands.ts
+var publishFileSchema = external_exports.strictObject({
+  path: external_exports.string().describe(
+    "file path relative to the skill root, e.g. 'SKILL.md', 'scripts/run.sh'"
+  ),
+  content: external_exports.string().describe("UTF-8 text content"),
+  contentType: external_exports.string().optional().describe("optional; inferred from extension when omitted")
+});
+var skillhubCommands = new HtbpCommandRegistry().register(
+  "list",
+  {
+    h: "list published skills (id / name / description from SKILL.md frontmatter, paginated)",
+    inputSchema: external_exports.strictObject({ opts: HTBP_LIST_OPTIONS_SCHEMA.optional() }),
+    returns: "Page<SkillSummary>",
+    scope: "read"
+  },
+  ({ opts }, provider) => provider.list(opts)
+).register(
+  "get",
+  {
+    h: "read a skill: SKILL.md body + file manifest; pass 'file' to fetch one bundled file (oversized/binary as { $ref })",
+    inputSchema: external_exports.strictObject({
+      id: external_exports.string().describe("skill id"),
+      file: external_exports.string().optional().describe(
+        "optional: path of one bundled file to fetch instead of the manifest"
+      )
+    }),
+    returns: "SkillDetail | SkillFile",
+    scope: "read"
+  },
+  ({ file: file2, id }, provider) => file2 === void 0 ? provider.get(id) : provider.get_file(id, file2)
+).register(
+  "search",
+  {
+    h: "keyword search over skill id / name / description",
+    inputSchema: external_exports.strictObject({
+      query: external_exports.string().describe("substring to match"),
+      opts: HTBP_LIST_OPTIONS_SCHEMA.optional()
+    }),
+    returns: "Page<SkillSummary>",
+    scope: "read"
+  },
+  ({ opts, query }, provider) => provider.search(query, opts)
+).register(
+  "publish",
+  {
+    h: "publish/replace a skill from a set of text files (must include SKILL.md with name+description frontmatter)",
+    inputSchema: external_exports.strictObject({
+      id: external_exports.string().optional().describe(
+        "skill id; defaults to a slug derived from the frontmatter name"
+      ),
+      files: external_exports.array(publishFileSchema).describe(
+        "the skill files; whole-skill replace (files not listed are removed)"
+      )
+    }),
+    returns: "{ id, name, description, fileCount }",
+    scope: "write"
+  },
+  ({ files, id }, provider) => {
+    const input = {
+      files,
+      ...id !== void 0 ? { id } : {}
+    };
+    return provider.publish(input);
+  }
+).register(
+  "remove",
+  {
+    h: "delete a skill and all its files (not_found if it does not exist)",
+    inputSchema: external_exports.strictObject({ id: external_exports.string().describe("skill id") }),
+    scope: "write",
+    effect: "destructive"
+  },
+  ({ id }, provider) => provider.remove(id)
+);
 function skillhubScopeForCmd(command) {
-  return SCOPE_BY_CMD2[command] ?? null;
+  const scope = skillhubCommands.scopeFor(command);
+  return scope === "read" || scope === "write" ? scope : null;
 }
-var OPTS_SCHEMA2 = {
-  type: "object",
-  description: "pagination options",
-  properties: {
-    cursor: { type: "string", description: "opaque cursor returned by the previous page" },
-    limit: { type: "number", description: "page size (default 50, max 200)" }
+async function dispatchSkillhubCmd(provider, command, args) {
+  const normalized = command.toLowerCase();
+  if (!skillhubCommands.has(normalized)) {
+    throw new TBError("invalid_argument", `unknown cmd '${command}'`);
   }
-};
-var PUBLISH_FILE_SCHEMA = {
-  type: "object",
-  required: ["path", "content"],
-  properties: {
-    path: {
-      type: "string",
-      description: "file path relative to the skill root, e.g. 'SKILL.md', 'scripts/run.sh'"
-    },
-    content: { type: "string", description: "UTF-8 text content" },
-    contentType: { type: "string", description: "optional; inferred from extension when omitted" }
+  if (normalized === "publish" && !Array.isArray(args.files)) {
+    throw new TBError("invalid_argument", "publish \u9700\u8981\u6570\u7EC4 'files'");
   }
-};
-function skillhubCmds(nodePath) {
-  const path = cmdPath(nodePath);
-  const cmds = [
-    {
-      name: "list",
-      method: "POST",
-      path,
-      h: "list published skills (id / name / description from SKILL.md frontmatter, paginated)",
-      inputSchema: {
-        type: "object",
-        properties: { opts: OPTS_SCHEMA2 }
-      },
-      returns: "Page<SkillSummary>",
-      scope: "read"
-    },
-    {
-      name: "get",
-      method: "POST",
-      path,
-      h: "read a skill: SKILL.md body + file manifest; pass 'file' to fetch one bundled file (oversized/binary as { $ref })",
-      inputSchema: {
-        type: "object",
-        required: ["id"],
-        properties: {
-          id: { type: "string", description: "skill id" },
-          file: {
-            type: "string",
-            description: "optional: path of one bundled file to fetch instead of the manifest"
-          }
-        }
-      },
-      returns: "SkillDetail | SkillFile",
-      scope: "read"
-    },
-    {
-      name: "search",
-      method: "POST",
-      path,
-      h: "keyword search over skill id / name / description",
-      inputSchema: {
-        type: "object",
-        required: ["query"],
-        properties: {
-          query: { type: "string", description: "substring to match" },
-          opts: OPTS_SCHEMA2
-        }
-      },
-      returns: "Page<SkillSummary>",
-      scope: "read"
-    },
-    {
-      name: "publish",
-      method: "POST",
-      path,
-      h: "publish/replace a skill from a set of text files (must include SKILL.md with name+description frontmatter)",
-      inputSchema: {
-        type: "object",
-        required: ["files"],
-        properties: {
-          id: {
-            type: "string",
-            description: "skill id; defaults to a slug derived from the frontmatter name"
-          },
-          files: {
-            type: "array",
-            description: "the skill files; whole-skill replace (files not listed are removed)",
-            items: PUBLISH_FILE_SCHEMA
-          }
-        }
-      },
-      returns: "{ id, name, description, fileCount }",
-      scope: "write"
-    },
-    {
-      name: "remove",
-      method: "POST",
-      path,
-      h: "delete a skill and all its files (not_found if it does not exist)",
-      inputSchema: {
-        type: "object",
-        required: ["id"],
-        properties: { id: { type: "string", description: "skill id" } }
-      },
-      scope: "write",
-      effect: "destructive"
-    }
-  ];
-  return withCommandPaths(nodePath, cmds);
+  return await skillhubCommands.invoke(normalized, args, provider);
 }
+
+// ../core/src/skillhub/help.ts
+var SKILLHUB_CAPABILITIES = ["search"];
 function skillhubHelpModel(node, opts = {}) {
-  const cmds = skillhubCmds(node.path);
-  return {
-    node: { path: node.path, kind: "skillhub", description: node.description },
-    cmds: opts.readOnly ? cmds.filter((c) => c.scope === "read") : cmds
-  };
+  return skillhubCommands.helpModel(
+    { path: node.path, kind: "skillhub", description: node.description },
+    (command) => opts.readOnly !== true || command.scope === "read"
+  );
 }
 
 // ../core/src/skillhub/provider.ts
@@ -21871,6 +21818,367 @@ var NodeRegistryStore = class {
   }
 };
 
+// ../plugin-sdk/src/index.ts
+var CONTEXT_HANDLER_VERBS = ["list", "get", "write", "update", "delete", "search"];
+var CAPABILITY_BY_VERB = { search: "search", delete: "delete" };
+var PROTOCOL_VERSION = "plugin/v2";
+function json2(value, status = 200) {
+  return new Response(JSON.stringify(value), {
+    status,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  });
+}
+function errorResponse(err) {
+  if (isTBError(err)) return json2(err.toJSON(), err.httpStatus);
+  return json2(new TBError("internal", "internal plugin error").toJSON(), 500);
+}
+function contextVerbs(handlers) {
+  const verbs = [];
+  for (const verb of CONTEXT_HANDLER_VERBS) {
+    if (typeof handlers[verb] === "function") verbs.push(verb);
+  }
+  return verbs;
+}
+function helpCmds(state) {
+  if (state.kind === "tools") return state.registry.list();
+  if (state.kind === "proxyTools") return [];
+  return contextVerbs(state.handlers).map((name) => ({ name }));
+}
+function createPlugin(opts = {}) {
+  const healthPath = opts.healthPath ?? "/healthz";
+  const exports = /* @__PURE__ */ new Map();
+  const dedupe = new RequestDedupe();
+  const assertFreshId = (id) => {
+    if (id.length === 0) throw new TBError("invalid_argument", "export id must be non-empty");
+    if (exports.has(id)) {
+      throw new TBError("invalid_argument", `export '${id}' is already declared`);
+    }
+  };
+  function describe3() {
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      exports: [...exports.values()].map((state) => {
+        if (state.kind === "tools" || state.kind === "proxyTools") {
+          return {
+            id: state.id,
+            profile: "tools/v1",
+            ...state.description !== void 0 ? { description: state.description } : {},
+            ...state.auth !== void 0 ? { auth: state.auth } : {},
+            ...state.kind === "tools" && state.credentialProbe !== void 0 ? { credentialProbe: state.credentialProbe } : {},
+            ...state.credentialFields !== void 0 ? { credentialFields: state.credentialFields } : {},
+            ...state.kind === "tools" && state.mountConfigFields !== void 0 ? { mountConfigFields: state.mountConfigFields } : {},
+            ...state.kind === "tools" && state.oauth !== void 0 ? { oauth: state.oauth } : {}
+          };
+        }
+        const methods = contextVerbs(state.handlers);
+        const capabilities = methods.map((verb) => CAPABILITY_BY_VERB[verb]).filter((c) => c !== void 0);
+        return {
+          id: state.id,
+          profile: "context/v1",
+          ...state.description !== void 0 ? { description: state.description } : {},
+          ...state.auth !== void 0 ? { auth: state.auth } : {},
+          methods,
+          ...capabilities.length > 0 ? { capabilities } : {},
+          ...state.mountConfigFields !== void 0 ? { mountConfigFields: state.mountConfigFields } : {}
+        };
+      })
+    };
+  }
+  function help() {
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      exports: [...exports.values()].map((state) => ({
+        id: state.id,
+        ...state.kind === "proxyTools" ? { dynamic: true } : {},
+        cmds: helpCmds(state)
+      }))
+    };
+  }
+  function assertAuthorized(request, env) {
+    if (env?.TB_PLUGIN_IN_PROCESS === true) {
+      return;
+    }
+    const header = request.headers.get("authorization") ?? "";
+    const presented = header.startsWith("Bearer ") ? header.slice("Bearer ".length) : "";
+    const expected = opts.token?.(env);
+    if (expected === void 0) {
+      const devBypass = env?.TB_PLUGIN_ALLOW_ANY_TOKEN;
+      if (devBypass !== "true") {
+        throw new TBError(
+          "unavailable",
+          "plugin \u672A\u914D\u7F6E PLUGIN_TOKEN:\u751F\u4EA7\u90E8\u7F72\u5FC5\u987B\u914D\u7F6E;\u672C\u5730\u5F00\u53D1\u53EF\u8BBE TB_PLUGIN_ALLOW_ANY_TOKEN=true",
+          { retryable: false }
+        );
+      }
+      if (presented.length === 0) throw TBError.unauthenticated();
+      return;
+    }
+    if (presented !== expected) throw TBError.unauthenticated();
+  }
+  function decodeUpstreamAuth(request) {
+    const raw = request.headers.get(HEADER_TB_UPSTREAM_AUTH);
+    if (raw === null || raw.length === 0) return void 0;
+    const b64 = raw.replaceAll("-", "+").replaceAll("_", "/");
+    const padded = b64.padEnd(b64.length + (4 - b64.length % 4) % 4, "=");
+    try {
+      const bytes = Uint8Array.from(atob(padded), (c) => c.charCodeAt(0));
+      return new TextDecoder().decode(bytes);
+    } catch {
+      throw new TBError("invalid_argument", `${HEADER_TB_UPSTREAM_AUTH} is not valid base64url`);
+    }
+  }
+  async function dispatchTools(state, method, args, ctx) {
+    switch (method.toLowerCase()) {
+      case "list":
+        return state.registry.list();
+      case "call": {
+        const name = args.name;
+        if (typeof name !== "string") {
+          throw new TBError("invalid_argument", "call requires a string 'name'");
+        }
+        const callArgs = args.args ?? {};
+        return await state.registry.call(name, callArgs, ctx);
+      }
+      default:
+        throw new TBError("invalid_argument", `unknown method '${method}' on a tools export`);
+    }
+  }
+  async function dispatchProxyTools(state, method, args, ctx) {
+    switch (method.toLowerCase()) {
+      case "list":
+        return await state.handlers.list(ctx);
+      case "call": {
+        const name = args.name;
+        if (typeof name !== "string" || name === "") {
+          throw new TBError("invalid_argument", "call requires a non-empty string 'name'");
+        }
+        const callArgs = typeof args.args === "object" && args.args !== null ? args.args : {};
+        return toToolResult(await state.handlers.call({ name, args: callArgs }, ctx));
+      }
+      default:
+        throw new TBError("invalid_argument", `unknown method '${method}' on a tools export`);
+    }
+  }
+  async function dispatchContext(state, method, args, ctx) {
+    const handlers = state.handlers;
+    switch (method.toLowerCase()) {
+      case "list":
+        if (handlers.list === void 0) break;
+        return await handlers.list(
+          { path: String(args.path ?? ""), ...args.opts !== void 0 ? { opts: args.opts } : {} },
+          ctx
+        );
+      case "get":
+        if (handlers.get === void 0) break;
+        return await handlers.get({ path: String(args.path ?? "") }, ctx);
+      case "write":
+        if (handlers.write === void 0) break;
+        return await handlers.write(
+          { path: String(args.path ?? ""), entry: args.entry ?? {} },
+          ctx
+        );
+      case "update":
+        if (handlers.update === void 0) break;
+        return await handlers.update(
+          { path: String(args.path ?? ""), patch: args.patch ?? {} },
+          ctx
+        );
+      case "delete":
+        if (handlers.delete === void 0) break;
+        return await handlers.delete({ path: String(args.path ?? "") }, ctx);
+      case "search":
+        if (handlers.search === void 0) break;
+        return await handlers.search(
+          { query: String(args.query ?? ""), ...args.opts !== void 0 ? { opts: args.opts } : {} },
+          ctx
+        );
+      default:
+        throw new TBError("invalid_argument", `unknown method '${method}' on a context export`);
+    }
+    throw new TBError("invalid_argument", `method '${method}' is not implemented by export '${state.id}'`);
+  }
+  async function handleEnvelope(request, env) {
+    assertAuthorized(request, env);
+    const ctxHeader = request.headers.get(HEADER_TB_CONTEXT);
+    if (ctxHeader === null) {
+      throw new TBError("invalid_argument", `missing ${HEADER_TB_CONTEXT}`);
+    }
+    const caller = decodeCallContext(ctxHeader);
+    const call = decodePluginCall(await request.text());
+    const exportId = caller.exportId ?? (exports.size === 1 ? [...exports.keys()][0] : void 0);
+    if (exportId === void 0) {
+      throw new TBError("invalid_argument", "call context carries no exportId and this plugin declares multiple exports");
+    }
+    const state = exports.get(exportId);
+    if (state === void 0) throw new TBError("invalid_argument", `unknown export '${exportId}'`);
+    const upstreamAuth = decodeUpstreamAuth(request);
+    const credentialFields = state.kind === "context" ? void 0 : state.credentialFields;
+    const ctx = {
+      env,
+      caller,
+      exportId,
+      mountPath: caller.mountPath,
+      mountConfig: caller.mountConfig,
+      upstreamAuth,
+      credentials: credentialFields !== void 0 && upstreamAuth !== void 0 ? parseCredentialValues(upstreamAuth, credentialFields) : void 0
+    };
+    const requestId = request.headers.get(HEADER_TB_REQUEST_ID);
+    const run = async () => {
+      if (state.kind === "tools") return await dispatchTools(state, call.tool, call.arguments, ctx);
+      if (state.kind === "proxyTools") {
+        return await dispatchProxyTools(state, call.tool, call.arguments, ctx);
+      }
+      return await dispatchContext(state, call.tool, call.arguments, ctx);
+    };
+    const value = requestId === null ? await run() : await dedupe.run(requestId, run);
+    return json2(value ?? null);
+  }
+  const plugin = {
+    tools(id, meta3) {
+      assertFreshId(id);
+      const state = {
+        auth: void 0,
+        kind: "tools",
+        id,
+        description: meta3?.description,
+        credentialProbe: void 0,
+        credentialFields: void 0,
+        mountConfigFields: void 0,
+        oauth: void 0,
+        registry: new OperationRegistry()
+      };
+      exports.set(id, state);
+      const surface = {
+        auth(config2) {
+          if (state.oauth !== void 0 || state.credentialFields !== void 0) {
+            throw new TBError(
+              "invalid_argument",
+              `export '${id}' \u5DF2\u58F0\u660E oauth/credentials(),\u4E0D\u80FD\u518D\u58F0\u660E auth`
+            );
+          }
+          if (config2.kind === "none" && state.credentialProbe !== void 0) {
+            throw new TBError(
+              "invalid_argument",
+              `export '${id}' \u5DF2\u58F0\u660E credentialProbe,\u4E0D\u80FD\u518D\u58F0\u660E auth:none`
+            );
+          }
+          state.auth = config2;
+          return surface;
+        },
+        register(name, spec, handler) {
+          state.registry.register(name, spec, handler);
+          return surface;
+        },
+        credentials(fields) {
+          if (fields.length === 0) {
+            throw new TBError("invalid_argument", "credentials() \u81F3\u5C11\u8981\u58F0\u660E\u4E00\u4E2A\u5B57\u6BB5");
+          }
+          if (state.oauth !== void 0) {
+            throw new TBError(
+              "invalid_argument",
+              `export '${id}' \u5DF2\u58F0\u660E oauth,\u4E0D\u80FD\u518D\u58F0\u660E credentials()(oauth \u6A21\u5F0F\u4E0B authRef \u6307\u5411\u7684 secret \u56FA\u5B9A\u5B58 clientId/clientSecret)`
+            );
+          }
+          if (state.auth !== void 0) {
+            throw new TBError("invalid_argument", `export '${id}' \u5DF2\u58F0\u660E auth,\u4E0D\u80FD\u518D\u58F0\u660E credentials()`);
+          }
+          state.credentialFields = fields;
+          return surface;
+        },
+        mountConfig(fields) {
+          if (fields.length === 0) {
+            throw new TBError("invalid_argument", "mountConfig() \u81F3\u5C11\u8981\u58F0\u660E\u4E00\u4E2A\u5B57\u6BB5");
+          }
+          state.mountConfigFields = fields;
+          return surface;
+        },
+        oauth(config2) {
+          if (state.credentialFields !== void 0) {
+            throw new TBError(
+              "invalid_argument",
+              `export '${id}' \u5DF2\u58F0\u660E credentials(),\u4E0D\u80FD\u518D\u58F0\u660E oauth(oauth \u6A21\u5F0F\u4E0B authRef \u6307\u5411\u7684 secret \u56FA\u5B9A\u5B58 clientId/clientSecret)`
+            );
+          }
+          if (state.auth !== void 0) {
+            throw new TBError("invalid_argument", `export '${id}' \u5DF2\u58F0\u660E auth,\u4E0D\u80FD\u518D\u58F0\u660E oauth`);
+          }
+          if (state.credentialProbe !== void 0) {
+            throw new TBError(
+              "invalid_argument",
+              `export '${id}' \u5DF2\u58F0\u660E credentialProbe,\u4E0D\u80FD\u518D\u58F0\u660E oauth(\u51ED\u8BC1\u53EF\u7528\u6027\u7531\u6388\u6743\u6D41\u7A0B\u672C\u8EAB\u8BC1\u660E;\u62FF client \u51ED\u8BC1\u53BB\u8C03\u63A2\u9488\u65E2\u8BC1\u660E\u4E0D\u4E86\u4EC0\u4E48,\u53C8\u4F1A\u628A clientSecret \u9001\u8FDB\u63D2\u4EF6)`
+            );
+          }
+          state.oauth = config2;
+          return surface;
+        },
+        probeCredentialWith(name) {
+          if (!state.registry.list().some((tool) => tool.name === name)) {
+            throw new TBError(
+              "invalid_argument",
+              `credentialProbe '${name}' \u4E0D\u662F export '${id}' \u5DF2\u6CE8\u518C\u7684\u5DE5\u5177`
+            );
+          }
+          if (state.oauth !== void 0) {
+            throw new TBError(
+              "invalid_argument",
+              `export '${id}' \u5DF2\u58F0\u660E oauth,\u4E0D\u80FD\u518D\u58F0\u660E credentialProbe(\u51ED\u8BC1\u53EF\u7528\u6027\u7531\u6388\u6743\u6D41\u7A0B\u672C\u8EAB\u8BC1\u660E;\u62FF client \u51ED\u8BC1\u53BB\u8C03\u63A2\u9488\u65E2\u8BC1\u660E\u4E0D\u4E86\u4EC0\u4E48,\u53C8\u4F1A\u628A clientSecret \u9001\u8FDB\u63D2\u4EF6)`
+            );
+          }
+          if (state.auth?.kind === "none") {
+            throw new TBError("invalid_argument", `export '${id}' \u58F0\u660E auth:none,\u4E0D\u80FD\u518D\u58F0\u660E credentialProbe`);
+          }
+          state.credentialProbe = name;
+          return surface;
+        }
+      };
+      return surface;
+    },
+    proxyTools(id, handlers) {
+      assertFreshId(id);
+      if (handlers.auth !== void 0 && handlers.credentialFields !== void 0) {
+        throw new TBError("invalid_argument", `export '${id}' \u7684 auth \u4E0D\u80FD\u4E0E credentialFields \u540C\u65F6\u58F0\u660E`);
+      }
+      exports.set(id, {
+        auth: handlers.auth,
+        kind: "proxyTools",
+        id,
+        description: handlers.description,
+        credentialFields: handlers.credentialFields,
+        handlers
+      });
+      return plugin;
+    },
+    context(id, handlers) {
+      assertFreshId(id);
+      exports.set(id, {
+        auth: handlers.auth,
+        kind: "context",
+        id,
+        description: handlers.description,
+        handlers,
+        mountConfigFields: handlers.mountConfigFields
+      });
+      return plugin;
+    },
+    async fetch(request, env) {
+      try {
+        const url2 = new URL(request.url);
+        if (request.method === "GET") {
+          if (url2.pathname === healthPath) return json2({ healthy: true });
+          if (url2.pathname === "/~describe") return json2(describe3());
+          if (url2.pathname === "/~help") return json2(help());
+          throw TBError.notFound("no such path");
+        }
+        if (request.method !== "POST") throw TBError.notFound("no such path");
+        return await handleEnvelope(request, env);
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  };
+  return plugin;
+}
+
 export {
   TB_ERROR_CODES,
   TBError,
@@ -21927,6 +22235,10 @@ export {
   buildAuthorizationUrl,
   buildTokenRequest,
   parseTokenResponse,
+  contextScopeForCmd,
+  parseContextCmdArgs,
+  dispatchContextCmd,
+  dispatchContextUploadCmd,
   contextMethodsOf,
   isReadOnlyProvider,
   contextCapabilitiesOf,
@@ -21936,11 +22248,29 @@ export {
   pluginTokenSecretName,
   createStoreModule,
   RemoteAllowlistStore,
+  tbErrorBodySchema,
+  nodeInputSchema,
+  helpJsonSchema,
+  treeJsonSchema,
+  toolSearchPageSchema,
+  toolSearchRequestSchema,
+  registryNodeSchema,
+  feedbackViewSchema,
+  feedbackDetailSchema,
+  feedbackListSchema,
+  feedbackSubmitRequestSchema,
+  feedbackSubmitResponseSchema,
+  feedbackVoteRequestSchema,
+  feedbackRemoveResponseSchema,
+  oauthAuthorizeRequestSchema,
+  oauthAuthorizeResponseSchema,
+  healthResponseSchema,
+  livenessResponseSchema,
+  readinessResponseSchema,
   parseNodeInput,
   createBuiltins,
   CONTEXT_CAPABILITIES,
   CONTEXT_DIRECT_UPLOAD_CAPABILITY,
-  contextScopeForCmd,
   contextUploadCmd,
   contextHelpModel,
   objectBodyToBytes,
@@ -21948,7 +22278,6 @@ export {
   DEFAULT_STORE_DRIVER_KEY_ROOT,
   normalizeEntryPath,
   PRESIGN_TTL_SEC_DEFAULT,
-  PRESIGN_TTL_SEC_MAX,
   assertPresignTtlSec,
   createObjectContextUploadGrant,
   createObjectContextProvider,
@@ -21976,21 +22305,18 @@ export {
   buildTree,
   storeUri,
   StoreService,
-  toToolResult,
-  OperationRegistry,
-  normalizeCanonicalOrigin,
   catalogSetDigest,
   resolveIntegration,
   parseCredentialValues,
-  RequestDedupe,
   HEADER_TB_CONTEXT,
   HEADER_TB_REQUEST_ID,
   HEADER_TB_UPSTREAM_AUTH,
   encodeCallContext,
-  decodeCallContext,
   assertPluginPayloadSize,
   encodePluginCall,
-  decodePluginCall,
+  parseNonNegativeIntEnv,
+  parsePortEnv,
+  parseRuntimeEnv,
   TOOL_SEARCH_BATCH_LIMIT,
   TOOL_SEARCH_WORK_LIMIT,
   TOOL_SEARCH_AUDIT_NODE_LIMIT,
@@ -22012,8 +22338,9 @@ export {
   PG_SEARCH_INSERT_ROWS_MAX,
   pgSearchDialect,
   SecretStoreImpl,
-  SKILLHUB_CAPABILITIES,
   skillhubScopeForCmd,
+  dispatchSkillhubCmd,
+  SKILLHUB_CAPABILITIES,
   skillhubHelpModel,
   createSkillhubProvider,
   buildHttpRequest,
@@ -22028,5 +22355,6 @@ export {
   appendVia,
   virtualizeTools,
   resolveUpstreamTool,
-  NodeRegistryStore
+  NodeRegistryStore,
+  createPlugin
 };