aipou-mcp-server 0.5.0 → 0.6.0

package/dist/index.js

@@ -3105,9 +3105,28 @@ var require_utils = __commonJS({
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isPort = RegExp.prototype.test.bind(/^\d*$/u);
     var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
     var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+    var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+    var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+    var BYTE_HEX = new Array(256);
+    {
+      const HEX_DIGITS = "0123456789ABCDEF";
+      for (let i = 0; i < 256; i++) {
+        BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+      }
+    }
+    function percentEncodeNonAscii(cp) {
+      if (cp < 2048) {
+        return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+      }
+      if (cp < 65536) {
+        return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+      }
+      return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+    }
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -3132,91 +3151,105 @@ var require_utils = __commonJS({
       }
       return acc;
     }
+    var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+    var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+    var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
     var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-    function consumeIsZone(buffer) {
-      buffer.length = 0;
-      return true;
-    }
-    function consumeHextets(buffer, address, output) {
-      if (buffer.length) {
-        const hex = stringArrayToHexStripped(buffer);
-        if (hex !== "") {
-          address.push(hex);
-        } else {
-          output.error = true;
-          return false;
+    function isZoneIdentifier(zone) {
+      if (zone.length === 0) return false;
+      for (let i = 0; i < zone.length; i++) {
+        if (isZoneCharacter(zone[i])) continue;
+        if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+          i += 2;
+          continue;
         }
-        buffer.length = 0;
+        return false;
       }
       return true;
     }
-    function getIPV6(input) {
-      let tokenCount = 0;
-      const output = { error: false, address: "", zone: "" };
-      const address = [];
-      const buffer = [];
-      let endipv6Encountered = false;
-      let endIpv6 = false;
-      let consume = consumeHextets;
-      for (let i = 0; i < input.length; i++) {
-        const cursor = input[i];
-        if (cursor === "[" || cursor === "]") {
-          continue;
-        }
-        if (cursor === ":") {
-          if (endipv6Encountered === true) {
-            endIpv6 = true;
-          }
-          if (!consume(buffer, address, output)) {
-            break;
-          }
-          if (++tokenCount > 7) {
-            output.error = true;
-            break;
-          }
-          if (i > 0 && input[i - 1] === ":") {
-            endipv6Encountered = true;
+    function compressIPv6ZeroRun(hextets) {
+      let bestStart = -1;
+      let bestLength = 0;
+      let runStart = -1;
+      let runLength = 0;
+      for (let i = 0; i < hextets.length; i++) {
+        if (hextets[i] === "0") {
+          if (runStart === -1) runStart = i;
+          runLength++;
+          if (runLength > bestLength) {
+            bestLength = runLength;
+            bestStart = runStart;
           }
-          address.push(":");
-          continue;
-        } else if (cursor === "%") {
-          if (!consume(buffer, address, output)) {
-            break;
-          }
-          consume = consumeIsZone;
         } else {
-          buffer.push(cursor);
+          runStart = -1;
+          runLength = 0;
+        }
+      }
+      if (bestLength < 2) return hextets.join(":");
+      const head = hextets.slice(0, bestStart).join(":");
+      const tail = hextets.slice(bestStart + bestLength).join(":");
+      return head + "::" + tail;
+    }
+    function normalizeIPv6Address(input) {
+      const compression = input.indexOf("::");
+      if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
+      const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+      const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+      if (compression !== -1) {
+        if (left.length === 1 && left[0] === "") left.length = 0;
+        if (right.length === 1 && right[0] === "") right.length = 0;
+      }
+      const parts = left.concat(right);
+      let hextetCount = 0;
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part === "") return void 0;
+        if (part.indexOf(".") !== -1) {
+          if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
+          hextetCount += 2;
           continue;
         }
+        if (!isHextet(part)) return void 0;
+        parts[i] = parseInt(part, 16).toString(16);
+        hextetCount++;
       }
-      if (buffer.length) {
-        if (consume === consumeIsZone) {
-          output.zone = buffer.join("");
-        } else if (endIpv6) {
-          address.push(buffer.join(""));
-        } else {
-          address.push(stringArrayToHexStripped(buffer));
-        }
+      if (compression === -1) {
+        if (hextetCount !== 8) return void 0;
+        return compressIPv6ZeroRun(parts);
       }
-      output.address = address.join("");
-      return output;
+      if (hextetCount >= 8) return void 0;
+      const expanded = parts.slice(0, left.length);
+      for (let i = hextetCount; i < 8; i++) expanded.push("0");
+      for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
+      return compressIPv6ZeroRun(expanded);
     }
     function normalizeIPv6(host) {
-      if (findToken(host, ":") < 2) {
-        return { host, isIPV6: false };
-      }
-      const ipv6 = getIPV6(host);
-      if (!ipv6.error) {
-        let newHost = ipv6.address;
-        let escapedHost = ipv6.address;
-        if (ipv6.zone) {
-          newHost += "%" + ipv6.zone;
-          escapedHost += "%25" + ipv6.zone;
-        }
-        return { host: newHost, isIPV6: true, escapedHost };
-      } else {
-        return { host, isIPV6: false };
-      }
+      const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+      const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+      if (hasBracket && !bracketed) return { host, isIPV6: false, error: true };
+      let input = bracketed ? host.slice(1, -1) : host;
+      if (bracketed && isIPvFuture(input)) {
+        input = input.toLowerCase();
+        return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+      }
+      if (findToken(input, ":") < 2) {
+        return { host, isIPV6: false, error: bracketed };
+      }
+      let zoneIdentifier = "";
+      const zoneSeparator = input.indexOf("%");
+      if (zoneSeparator !== -1) {
+        const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+        zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+        if (!isZoneIdentifier(zoneIdentifier)) return { host, isIPV6: false, error: true };
+        input = input.slice(0, zoneSeparator);
+      }
+      const address = normalizeIPv6Address(input);
+      if (address === void 0) return { host, isIPV6: false, error: true };
+      return {
+        host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+        escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+        isIPV6: true
+      };
     }
     function findToken(str, token) {
       let ind = 0;
@@ -3225,8 +3258,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path10) {
-      let input = path10;
+    function removeDotSegments(path12) {
+      let input = path12;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3300,6 +3333,37 @@ var require_utils = __commonJS({
       }
       return output.join("");
     }
+    function removeDotSegmentsRelative(path12) {
+      if (path12 === "" || path12[0] === "/") {
+        return removeDotSegments(path12);
+      }
+      const segments = path12.split("/");
+      const last = segments.length - 1;
+      const output = [];
+      let trailingDirectory = false;
+      for (let i = 0; i <= last; i++) {
+        const segment = segments[i];
+        if (segment === "." || segment === "..") {
+          if (segment === "..") {
+            if (output.length !== 0 && output[output.length - 1] !== "..") {
+              output.pop();
+            } else {
+              output.push("..");
+            }
+          }
+          trailingDirectory = i === last;
+        } else {
+          output.push(segment);
+        }
+      }
+      if (trailingDirectory && output[output.length - 1] !== "..") {
+        output.push("");
+      }
+      if (output.length === 0 || output[0] === "" || output[0].includes(":")) {
+        output.unshift(".");
+      }
+      return output.join("/");
+    }
     var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
     var HOST_DELIM_RE = /[@/?#:]/g;
     var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
@@ -3335,7 +3399,8 @@ var require_utils = __commonJS({
     function normalizePathEncoding(input) {
       let output = "";
       for (let i = 0; i < input.length; i++) {
-        if (input[i] === "%" && i + 2 < input.length) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
           const hex = input.slice(i + 1, i + 3);
           if (isHexPair(hex)) {
             const normalizedHex = hex.toUpperCase();
@@ -3349,10 +3414,152 @@ var require_utils = __commonJS({
             continue;
           }
         }
-        if (isPathCharacter(input[i])) {
-          output += input[i];
+        if (isPathCharacter(ch)) {
+          output += ch;
+        } else {
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function serializePathEncoding(input, pathNoScheme = false) {
+      let output = "";
+      let firstSegment = pathNoScheme && input[0] !== "/";
+      for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
+          const hex = input.slice(i + 1, i + 3);
+          if (isHexPair(hex)) {
+            output += "%" + hex.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        if (ch === "/") {
+          firstSegment = false;
+        }
+        if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
+          output += ch;
+        } else {
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function encodeComponent(input, isAllowed) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
+          const hex = input.slice(i + 1, i + 3);
+          if (isHexPair(hex)) {
+            output += "%" + hex.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        if (isAllowed(ch)) {
+          output += ch;
+        } else {
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function encodeUserinfo(input) {
+      return encodeComponent(input, isUserinfoCharacter);
+    }
+    function encodeQuery(input) {
+      return encodeComponent(input, isQueryFragmentCharacter);
+    }
+    function encodeFragment(input) {
+      return encodeComponent(input, isQueryFragmentCharacter);
+    }
+    function isEscapeSafe(cp) {
+      return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+    }
+    function normalizeQueryFragmentEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
+          const hex = input.slice(i + 1, i + 3);
+          if (isHexPair(hex)) {
+            const normalizedHex = hex.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isQueryFragmentCharacter(ch)) {
+          output += ch;
         } else {
-          output += escape(input[i]);
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
         }
       }
       return output;
@@ -3375,14 +3582,18 @@ var require_utils = __commonJS({
     function recomposeAuthority(component) {
       const uriTokens = [];
       if (component.userinfo !== void 0) {
-        uriTokens.push(component.userinfo);
+        uriTokens.push(encodeUserinfo(component.userinfo));
         uriTokens.push("@");
       }
       if (component.host !== void 0) {
-        let host = unescape(component.host);
+        let host = component.host;
         if (!isIPv4(host)) {
-          const ipV6res = normalizeIPv6(host);
-          if (ipV6res.isIPV6 === true) {
+          let ipV6res = normalizeIPv6(host);
+          if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+            host = normalizePercentEncoding(host, true);
+            ipV6res = normalizeIPv6(host);
+          }
+          if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
             host = reescapeHostDelimiters(host, false);
@@ -3391,8 +3602,12 @@ var require_utils = __commonJS({
         uriTokens.push(host);
       }
       if (typeof component.port === "number" || typeof component.port === "string") {
+        const port = String(component.port);
+        if (!isPort(port)) {
+          throw new TypeError("URI port is malformed.");
+        }
         uriTokens.push(":");
-        uriTokens.push(String(component.port));
+        uriTokens.push(port);
       }
       return uriTokens.length ? uriTokens.join("") : void 0;
     }
@@ -3402,8 +3617,14 @@ var require_utils = __commonJS({
       reescapeHostDelimiters,
       normalizePercentEncoding,
       normalizePathEncoding,
+      serializePathEncoding,
+      normalizeQueryFragmentEncoding,
+      encodeUserinfo,
+      encodeQuery,
+      encodeFragment,
       escapePreservingEscapes,
       removeDotSegments,
+      removeDotSegmentsRelative,
       isIPv4,
       isUUID,
       normalizeIPv6,
@@ -3417,7 +3638,7 @@ var require_schemes = __commonJS({
   "../node_modules/fast-uri/lib/schemes.js"(exports, module) {
     "use strict";
     var { isUUID } = require_utils();
-    var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+    var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
     var supportedSchemeNames = (
       /** @type {const} */
       [
@@ -3478,9 +3699,10 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path10, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path10 && path10 !== "/" ? path10 : void 0;
-        wsComponent.query = query;
+        const queryIndex = wsComponent.resourceName.indexOf("?");
+        const path12 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
+        wsComponent.path = path12 && path12 !== "/" ? path12 : void 0;
+        wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
         wsComponent.resourceName = void 0;
       }
       wsComponent.fragment = void 0;
@@ -3492,7 +3714,7 @@ var require_schemes = __commonJS({
         return urnComponent;
       }
       const matches = urnComponent.path.match(URN_REG);
-      if (matches) {
+      if (matches && matches[0] === urnComponent.path) {
         const scheme = options.scheme || urnComponent.scheme || "urn";
         urnComponent.nid = matches[1].toLowerCase();
         urnComponent.nss = matches[2];
@@ -3626,8 +3848,19 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "../node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, removeDotSegmentsRelative, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
+    var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+    var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+    var MALFORMED_HOST_ERROR = "URI host is malformed.";
+    var FORBIDDEN_DOMAIN_HOST_CHARACTER = /[\0-\x20"#/:<>?@[\\\]^`{|}\x7F]/u;
+    function validateScheme(scheme) {
+      const stringScheme = String(scheme);
+      if (!VALID_SCHEME.test(stringScheme)) {
+        throw new TypeError(MALFORMED_SCHEME_ERROR);
+      }
+      return stringScheme;
+    }
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
@@ -3640,7 +3873,37 @@ var require_fast_uri = __commonJS({
     }
     function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+      const {
+        parsed: baseParsed,
+        malformedAuthorityOrPort: baseMalformed,
+        malformedPercentEncoding: baseMalformedPercentEncoding,
+        malformedSchemeSpecific: baseMalformedSchemeSpecific,
+        malformedHost: baseMalformedHost,
+        malformedScheme: baseMalformedScheme
+      } = parseWithStatus(baseURI, schemelessOptions);
+      const {
+        parsed: relativeParsed,
+        malformedAuthorityOrPort: relativeMalformed,
+        malformedPercentEncoding: relativeMalformedPercentEncoding,
+        malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+        malformedHost: relativeMalformedHost,
+        malformedScheme: relativeMalformedScheme
+      } = parseWithStatus(relativeURI, schemelessOptions);
+      if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
+        throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+      }
+      const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+      const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+      const resolvedHost = resolved.host;
+      const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+      if (hasForbiddenDomainHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP)) {
+        throw new Error(MALFORMED_HOST_ERROR);
+      }
+      canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+      const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !new RegExp("\\P{ASCII}", "u").test(resolvedHost);
+      if (resolved.error && !encodedASCIIHost) {
+        throw new Error(resolved.error);
+      }
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
@@ -3677,14 +3940,15 @@ var require_fast_uri = __commonJS({
             if (relative.path[0] === "/") {
               target.path = removeDotSegments(relative.path);
             } else {
-              if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
+              const baseHasAuthority = base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0;
+              if (baseHasAuthority && !base.path) {
                 target.path = "/" + relative.path;
               } else if (!base.path) {
                 target.path = relative.path;
               } else {
                 target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
               }
-              target.path = removeDotSegments(target.path);
+              target.path = base.scheme === void 0 && !baseHasAuthority && target.path[0] !== "/" ? removeDotSegmentsRelative(target.path) : removeDotSegments(target.path);
             }
             target.query = relative.query;
           }
@@ -3700,7 +3964,7 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       const normalizedA = normalizeComparableURI(uriA, options);
       const normalizedB = normalizeComparableURI(uriB, options);
-      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -3721,19 +3985,23 @@ var require_fast_uri = __commonJS({
       };
       const options = Object.assign({}, opts);
       const uriTokens = [];
+      if (component.scheme) {
+        component.scheme = validateScheme(component.scheme);
+      }
       const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+      const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
+      const schemelessReference = (component.scheme === void 0 || options.reference === "suffix") && !hasAuthority;
+      const pathNoScheme = !options.skipEscape && schemelessReference;
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escapePreservingEscapes(component.path);
-          if (component.scheme !== void 0) {
-            component.path = component.path.split("%3A").join(":");
-          }
+          component.path = serializePathEncoding(component.path, pathNoScheme);
         } else {
           component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
+        component.scheme = validateScheme(component.scheme);
         uriTokens.push(component.scheme, ":");
       }
       const authority = recomposeAuthority(component);
@@ -3749,7 +4017,10 @@ var require_fast_uri = __commonJS({
       if (component.path !== void 0) {
         let s = component.path;
         if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
-          s = removeDotSegments(s);
+          s = schemelessReference && s[0] !== "/" ? removeDotSegmentsRelative(s) : removeDotSegments(s);
+        }
+        if (schemelessReference) {
+          s = serializePathEncoding(s, true);
         }
         if (authority === void 0 && s[0] === "/" && s[1] === "/") {
           s = "/%2F" + s.slice(2);
@@ -3757,15 +4028,16 @@ var require_fast_uri = __commonJS({
         uriTokens.push(s);
       }
       if (component.query !== void 0) {
-        uriTokens.push("?", component.query);
+        uriTokens.push("?", encodeQuery(component.query));
       }
       if (component.fragment !== void 0) {
-        uriTokens.push("#", component.fragment);
+        uriTokens.push("#", encodeFragment(component.fragment));
       }
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
     var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+    var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
     function getParseError(parsed, matches) {
       if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
@@ -3775,6 +4047,53 @@ var require_fast_uri = __commonJS({
       }
       return void 0;
     }
+    function hasMalformedPercentEncoding(component) {
+      if (component === void 0) return false;
+      let percent = component.indexOf("%");
+      while (percent !== -1) {
+        if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+          return true;
+        }
+        percent = component.indexOf("%", percent + 3);
+      }
+      return false;
+    }
+    function isIPLiteral(host) {
+      return host[0] === "[" && host[host.length - 1] === "]";
+    }
+    function hasMalformedComponentPercentEncoding(matches) {
+      const host = matches[4];
+      return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+    }
+    function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+      if (hasForbiddenDomainHost(parsed, options, schemeHandler, isIP)) {
+        parsed.error = parsed.error || MALFORMED_HOST_ERROR;
+        return true;
+      }
+      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+        let url;
+        try {
+          url = new URL("http://" + parsed.host);
+        } catch (e) {
+          parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+          return true;
+        }
+        if (!isHostOnlyURL(url)) {
+          parsed.error = parsed.error || MALFORMED_HOST_ERROR;
+          return true;
+        }
+        parsed.host = url.hostname;
+      }
+      return false;
+    }
+    function hasForbiddenDomainHost(parsed, options, schemeHandler, isIP) {
+      return Boolean(
+        parsed.host && isIP === false && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && FORBIDDEN_DOMAIN_HOST_CHARACTER.test(parsed.host)
+      );
+    }
+    function isHostOnlyURL(url) {
+      return url.username === "" && url.password === "" && url.port === "" && url.pathname === "/" && url.search === "" && url.hash === "" && url.hostname !== "";
+    }
     function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
@@ -3787,6 +4106,11 @@ var require_fast_uri = __commonJS({
         fragment: void 0
       };
       let malformedAuthorityOrPort = false;
+      let malformedPercentEncoding = false;
+      let malformedSchemeSpecific = false;
+      let malformedHost = false;
+      let malformedIPLiteral = false;
+      let malformedScheme = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -3800,6 +4124,20 @@ var require_fast_uri = __commonJS({
         parsed.error = "URI authority must not contain a literal backslash.";
         malformedAuthorityOrPort = true;
       }
+      const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+      if (introducerMatch !== null) {
+        const region = introducerMatch[1];
+        const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+        if (normalizedRegion.length >= 2) {
+          if (normalizedRegion.slice(0, 2) !== "//") {
+            parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+            malformedAuthorityOrPort = true;
+          } else if (region.length !== normalizedRegion.length) {
+            parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+            malformedAuthorityOrPort = true;
+          }
+        }
+      }
       const matches = uri.match(URI_PARSE);
       if (matches) {
         parsed.scheme = matches[1];
@@ -3809,6 +4147,18 @@ var require_fast_uri = __commonJS({
         parsed.path = matches[6] || "";
         parsed.query = matches[7];
         parsed.fragment = matches[8];
+        if (parsed.scheme !== void 0) {
+          if (VALID_SCHEME.test(parsed.scheme)) {
+            parsed.scheme = parsed.scheme.toLowerCase();
+          } else {
+            parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+            malformedScheme = true;
+          }
+        }
+        malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+        if (malformedPercentEncoding) {
+          parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+        }
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
@@ -3820,9 +4170,16 @@ var require_fast_uri = __commonJS({
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
+            const bracketedIPLiteral = isIPLiteral(parsed.host);
+            const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
             const ipv6result = normalizeIPv6(parsed.host);
-            parsed.host = ipv6result.host.toLowerCase();
-            isIP = ipv6result.isIPV6;
+            isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+            malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+            parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+            if (malformedIPLiteral) {
+              parsed.error = parsed.error || MALFORMED_HOST_ERROR;
+              malformedAuthorityOrPort = true;
+            }
           } else {
             isIP = true;
           }
@@ -3840,42 +4197,37 @@ var require_fast_uri = __commonJS({
           parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
         }
         const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-          if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-            try {
-              parsed.host = new URL("http://" + parsed.host).hostname;
-            } catch (e) {
-              parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-            }
+        if (!malformedIPLiteral) {
+          malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
+        }
+        if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+          let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+          if (!isIP) {
+            host = normalizePercentEncoding(host.toLowerCase());
           }
+          parsed.host = isIP || options.scheme !== "null" ? reescapeHostDelimiters(host, isIP) : host;
         }
         if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-          if (uri.indexOf("%") !== -1) {
-            if (parsed.scheme !== void 0) {
-              parsed.scheme = unescape(parsed.scheme);
-            }
-            if (parsed.host !== void 0) {
-              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
-            }
-          }
           if (parsed.path) {
             parsed.path = normalizePathEncoding(parsed.path);
           }
+          if (parsed.query) {
+            parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+          }
           if (parsed.fragment) {
-            try {
-              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-            } catch {
-              parsed.error = parsed.error || "URI malformed";
-            }
+            parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
           }
         }
         if (schemeHandler && schemeHandler.parse) {
           schemeHandler.parse(parsed, options);
+          if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) {
+            malformedSchemeSpecific = true;
+          }
         }
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return { parsed, malformedAuthorityOrPort };
+      return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
     }
     function parse(uri, opts) {
       return parseWithStatus(uri, opts).parsed;
@@ -3884,20 +4236,28 @@ var require_fast_uri = __commonJS({
       return normalizeStringWithStatus(uri, opts).normalized;
     }
     function normalizeStringWithStatus(uri, opts) {
-      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
       return {
-        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-        malformedAuthorityOrPort
+        normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort,
+        malformedPercentEncoding,
+        malformedSchemeSpecific,
+        malformedHost,
+        malformedScheme
       };
     }
     function normalizeComparableURI(uri, opts) {
-      if (typeof uri === "string") {
-        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-        return malformedAuthorityOrPort ? void 0 : normalized;
+      if (typeof uri !== "string" && typeof uri !== "object") {
+        return void 0;
       }
-      if (typeof uri === "object") {
-        return serialize(uri, opts);
+      let value;
+      try {
+        value = typeof uri === "string" ? uri : serialize(uri, opts);
+      } catch {
+        return void 0;
       }
+      const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+      return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
     }
     var fastUri = {
       SCHEMES,
@@ -6980,17 +7340,33 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
+function getDotPath(path12) {
+  if (path12.length === 0) {
+    return "object root";
+  }
+  return path12.reduce((acc, seg, index) => {
+    if (index === 0) {
+      return String(seg);
+    }
+    if (typeof seg === "number") {
+      return `${acc}[${seg}]`;
+    }
+    return `${acc}.${seg}`;
+  }, "");
+}
 function getParseErrorMessage(error) {
   if (error && typeof error === "object") {
+    if ("issues" in error && Array.isArray(error.issues) && error.issues.length > 0) {
+      return error.issues.map((i) => {
+        if (!i.path?.length) {
+          return i.message;
+        }
+        return `${i.message} at ${getDotPath(i.path)}`;
+      }).join("\n");
+    }
     if ("message" in error && typeof error.message === "string") {
       return error.message;
     }
-    if ("issues" in error && Array.isArray(error.issues) && error.issues.length > 0) {
-      const firstIssue = error.issues[0];
-      if (firstIssue && typeof firstIssue === "object" && "message" in firstIssue) {
-        return String(firstIssue.message);
-      }
-    }
     try {
       return JSON.stringify(error);
     } catch {
@@ -9954,6 +10330,9 @@ var Protocol = class {
       this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
         const handleTaskResult = async () => {
           const taskId = request.params.taskId;
+          if (!await this._taskStore.getTask(taskId, extra.sessionId)) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+          }
           if (this._taskMessageQueue) {
             let queuedMessage;
             while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
@@ -9984,12 +10363,12 @@ var Protocol = class {
             throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
           }
           if (!isTerminal(task.status)) {
-            await this._waitForTaskUpdate(taskId, extra.signal);
+            await this._waitForTaskUpdate(taskId, extra.signal, extra.sessionId);
             return await handleTaskResult();
           }
           if (isTerminal(task.status)) {
             const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
-            this._clearTaskQueue(taskId);
+            this._clearTaskQueue(taskId, extra.sessionId);
             return {
               ...result,
               _meta: {
@@ -10026,7 +10405,7 @@ var Protocol = class {
             throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
           }
           await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-          this._clearTaskQueue(request.params.taskId);
+          this._clearTaskQueue(request.params.taskId, extra.sessionId);
           const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
           if (!cancelledTask) {
             throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
@@ -10154,6 +10533,19 @@ var Protocol = class {
     const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
     const capturedTransport = this._transport;
     const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+    const sessionId = capturedTransport?.sessionId;
+    const store = this._taskStore;
+    let relatedTaskFound = true;
+    let relatedTaskLookup;
+    if (relatedTaskId && store && this._taskMessageQueue && sessionId !== void 0) {
+      relatedTaskFound = false;
+      relatedTaskLookup = (async () => {
+        if (!await store.getTask(relatedTaskId, sessionId)) {
+          throw new McpError(ErrorCode.InvalidParams, `Task not found: ${relatedTaskId}`);
+        }
+        relatedTaskFound = true;
+      })();
+    }
     if (handler === void 0) {
       const errorResponse = {
         jsonrpc: "2.0",
@@ -10163,7 +10555,10 @@ var Protocol = class {
           message: "Method not found"
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && relatedTaskLookup) {
+        const queuedError = { type: "error", message: errorResponse, timestamp: Date.now() };
+        relatedTaskLookup.then(() => this._enqueueTaskMessage(relatedTaskId, queuedError, sessionId), () => capturedTransport?.send(errorResponse)).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
+      } else if (relatedTaskId && this._taskMessageQueue) {
         this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -10214,7 +10609,10 @@ var Protocol = class {
       closeSSEStream: extra?.closeSSEStream,
       closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
     };
-    Promise.resolve().then(() => {
+    (relatedTaskLookup ?? Promise.resolve()).then(() => {
+      if (relatedTaskLookup && abortController.signal.aborted) {
+        throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
+      }
       if (taskCreationParams) {
         this.assertTaskHandlerCapability(request.method);
       }
@@ -10249,7 +10647,7 @@ var Protocol = class {
           ...error["data"] !== void 0 && { data: error["data"] }
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && this._taskMessageQueue && relatedTaskFound) {
         await this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -10729,7 +11127,7 @@ var Protocol = class {
       throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
     }
     const maxQueueSize = this._options?.maxTaskQueueSize;
-    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+    await this._taskMessageQueue.enqueue(taskId, message, sessionId ?? this._transport?.sessionId, maxQueueSize);
   }
   /**
    * Clears the message queue for a task and rejects any pending request resolvers.
@@ -10758,12 +11156,13 @@ var Protocol = class {
    * Uses polling to check for updates at the task's configured poll interval.
    * @param taskId The task ID to wait for
    * @param signal Abort signal to cancel the wait
+   * @param sessionId Session of the request that waits, passed to the task store
    * @returns Promise that resolves when an update occurs or rejects if aborted
    */
-  async _waitForTaskUpdate(taskId, signal) {
+  async _waitForTaskUpdate(taskId, signal, sessionId) {
     let interval = this._options?.defaultTaskPollInterval ?? 1e3;
     try {
-      const task = await this._taskStore?.getTask(taskId);
+      const task = await this._taskStore?.getTask(taskId, sessionId);
       if (task?.pollInterval) {
         interval = task.pollInterval;
       }
@@ -11249,16 +11648,7 @@ var Server = class extends Protocol {
     if (!methodSchema) {
       throw new Error("Schema is missing a method literal");
     }
-    let methodValue;
-    if (isZ4Schema(methodSchema)) {
-      const v4Schema = methodSchema;
-      const v4Def = v4Schema._zod?.def;
-      methodValue = v4Def?.value ?? v4Schema.value;
-    } else {
-      const v3Schema = methodSchema;
-      const legacyDef = v3Schema._def;
-      methodValue = legacyDef?.value ?? v3Schema.value;
-    }
+    const methodValue = getLiteralValue(methodSchema);
     if (typeof methodValue !== "string") {
       throw new Error("Schema method literal must be a string");
     }
@@ -11652,6 +12042,42 @@ var ExperimentalMcpServerTasks = class {
 
 // ../node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
 import { ZodOptional } from "zod";
+function toolInputElementCount(value, max) {
+  let count = 0;
+  const stack = [value];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === null || typeof node !== "object")
+      continue;
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        if (++count > max)
+          return count;
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    } else {
+      for (const key in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, key))
+          continue;
+        if (++count > max)
+          return count;
+        const child = node[key];
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    }
+  }
+  return count;
+}
+function resolveMaxToolInputElements(value) {
+  if (value === void 0 || value === Infinity)
+    return void 0;
+  if (typeof value !== "number" || Number.isNaN(value) || value < 1) {
+    throw new RangeError(`maxToolInputElements must be a number of at least 1, or Infinity, got ${String(value)}`);
+  }
+  return value;
+}
 var McpServer = class {
   constructor(serverInfo, options) {
     this._registeredResources = {};
@@ -11663,6 +12089,16 @@ var McpServer = class {
     this._resourceHandlersInitialized = false;
     this._promptHandlersInitialized = false;
     this.server = new Server(serverInfo, options);
+    this._maxToolInputElements = resolveMaxToolInputElements(options?.maxToolInputElements);
+    if (options?.capabilities?.tools) {
+      this.setToolRequestHandlers();
+    }
+    if (options?.capabilities?.resources) {
+      this.setResourceRequestHandlers();
+    }
+    if (options?.capabilities?.prompts) {
+      this.setPromptRequestHandlers();
+    }
   }
   /**
    * Access experimental features.
@@ -11793,12 +12229,15 @@ var McpServer = class {
    * Validates tool input arguments against the tool's input schema.
    */
   async validateToolInput(tool, args, toolName) {
+    if (this._maxToolInputElements !== void 0 && toolInputElementCount(args, this._maxToolInputElements) > this._maxToolInputElements) {
+      throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${toolName}: arguments contain more than the maximum of ${this._maxToolInputElements} elements`);
+    }
     if (!tool.inputSchema) {
       return void 0;
     }
     const inputObj = normalizeObjectSchema(tool.inputSchema);
     const schemaToParse = inputObj ?? tool.inputSchema;
-    const parseResult = await safeParseAsync2(schemaToParse, args);
+    const parseResult = await safeParseAsync2(schemaToParse, args ?? {});
     if (!parseResult.success) {
       const error = "error" in parseResult ? parseResult.error : "Unknown error";
       const errorMessage = getParseErrorMessage(error);
@@ -12036,7 +12475,7 @@ var McpServer = class {
       }
       if (prompt.argsSchema) {
         const argsObj = normalizeObjectSchema(prompt.argsSchema);
-        const parseResult = await safeParseAsync2(argsObj, request.params.arguments);
+        const parseResult = await safeParseAsync2(argsObj, request.params.arguments ?? {});
         if (!parseResult.success) {
           const error = "error" in parseResult ? parseResult.error : "Unknown error";
           const errorMessage = getParseErrorMessage(error);
@@ -12447,8 +12886,17 @@ var EMPTY_COMPLETION_RESULT = {
 import process2 from "node:process";
 
 // ../node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+var STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 var ReadBuffer = class {
+  constructor(options) {
+    this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
+  }
   append(chunk) {
+    const newSize = (this._buffer?.length ?? 0) + chunk.length;
+    if (newSize > this._maxBufferSize) {
+      this.clear();
+      throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
+    }
     this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
   }
   readMessage() {
@@ -12476,18 +12924,24 @@ function serializeMessage(message) {
 
 // ../node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var StdioServerTransport = class {
-  constructor(_stdin = process2.stdin, _stdout = process2.stdout) {
+  constructor(_stdin = process2.stdin, _stdout = process2.stdout, options) {
     this._stdin = _stdin;
     this._stdout = _stdout;
-    this._readBuffer = new ReadBuffer();
     this._started = false;
     this._ondata = (chunk) => {
-      this._readBuffer.append(chunk);
-      this.processReadBuffer();
+      try {
+        this._readBuffer.append(chunk);
+        this.processReadBuffer();
+      } catch (error) {
+        this.onerror?.(error);
+        this.close().catch(() => {
+        });
+      }
     };
     this._onerror = (error) => {
       this.onerror?.(error);
     };
+    this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
   }
   /**
    * Starts listening for messages on stdin.
@@ -12538,98 +12992,119 @@ var StdioServerTransport = class {
 // src/index.ts
 import { z as z2 } from "zod";
 
-// src/claims.ts
-import { MerkleTree } from "merkletreejs";
-import { AbiCoder, Contract, JsonRpcProvider, Wallet as Wallet2, concat, getAddress as getAddress2, getBytes, keccak256, parseUnits } from "ethers";
-import { readFile as readFile4 } from "node:fs/promises";
-import path5 from "node:path";
-
-// src/collector.ts
-import { createHash as createHash2, createPublicKey, generateKeyPairSync, sign, verify } from "node:crypto";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-
-// src/canonical.ts
-import { createHash } from "node:crypto";
-function canonicalJson(value) {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map(canonicalJson).join(",")}]`;
+// src/bounded-input.ts
+import { Transform } from "node:stream";
+var BoundedStdioInput = class extends Transform {
+  constructor(maxLineBytes = 1024 * 1024) {
+    super();
+    this.maxLineBytes = maxLineBytes;
+  }
+  maxLineBytes;
+  bytes = 0;
+  _transform(chunk, _encoding, callback) {
+    for (const byte of chunk) {
+      if (byte === 10) this.bytes = 0;
+      else if (++this.bytes > this.maxLineBytes) {
+        callback(
+          new Error("AIPOU_INPUT_TOO_LARGE: JSON-RPC line exceeds 1 MiB")
+        );
+        return;
+      }
+    }
+    callback(null, chunk);
   }
-  const record2 = value;
-  return `{${Object.keys(record2).filter((key) => record2[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record2[key])}`).join(",")}}`;
-}
-function sha256Hex(value) {
-  return `0x${createHash("sha256").update(value).digest("hex")}`;
-}
+};
 
-// src/secure-file.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
-async function restrictToCurrentUser(filePath) {
-  if (process.platform !== "win32") return true;
-  const user = process.env.USERNAME;
-  if (!user) return false;
-  const principal = process.env.USERDOMAIN ? `${process.env.USERDOMAIN}\\${user}` : user;
-  try {
-    await execFileAsync("icacls", [filePath, "/inheritance:r", "/grant:r", `${principal}:F`]);
-    return true;
-  } catch {
-    return false;
+// src/version.ts
+import { readFile } from "node:fs/promises";
+var SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+async function getPackageVersion() {
+  const packageUrl = new URL("../package.json", import.meta.url);
+  const metadata = JSON.parse(await readFile(packageUrl, "utf8"));
+  if (typeof metadata.version !== "string" || !SEMVER.test(metadata.version)) {
+    throw new Error("mcp-server/package.json must contain a valid semantic version");
   }
+  return metadata.version;
 }
 
-// src/collector.ts
-function dataDir() {
-  return path.resolve(process.env.AIPOU_DATA_DIR || ".aipou");
-}
-function privateKeyPath() {
-  return path.join(dataDir(), "collector-ed25519-private.pem");
-}
-function publicKeyPath() {
-  return path.join(dataDir(), "collector-ed25519-public.pem");
-}
-async function ensureCollectorKeys() {
-  await mkdir(dataDir(), { recursive: true });
+// src/store.ts
+import { mkdir as mkdir2, readFile as readFile4, readdir } from "node:fs/promises";
+import path3 from "node:path";
+
+// src/lock.ts
+import { readFile as readFile2, rm, stat, writeFile } from "node:fs/promises";
+var STALE_LOCK_MS = 15e3;
+var ACQUIRE_TIMEOUT_MS = 1e4;
+async function reclaimDeadLock(lockPath2) {
+  const gate = `${lockPath2}.reclaim`;
   try {
-    const [privateKey2, publicKey2] = await Promise.all([
-      readFile(privateKeyPath(), "utf8"),
-      readFile(publicKeyPath(), "utf8")
-    ]);
-    return { privateKey: privateKey2, publicKey: publicKey2 };
+    await writeFile(gate, `${process.pid}
+`, { flag: "wx", mode: 384 });
+  } catch (error) {
+    if (error.code === "EEXIST") return;
+    throw error;
+  }
+  try {
+    const info = await stat(lockPath2);
+    if (Date.now() - info.mtimeMs <= STALE_LOCK_MS) return;
+    const pid = Number((await readFile2(lockPath2, "utf8")).trim());
+    if (!Number.isSafeInteger(pid) || pid <= 0) return;
+    try {
+      process.kill(pid, 0);
+    } catch (error) {
+      if (error.code === "ESRCH") await rm(lockPath2);
+    }
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
+  } finally {
+    await rm(gate, { force: true });
   }
-  const pair = generateKeyPairSync("ed25519");
-  const privateKey = pair.privateKey.export({ format: "pem", type: "pkcs8" }).toString();
-  const publicKey = pair.publicKey.export({ format: "pem", type: "spki" }).toString();
-  await writeFile(privateKeyPath(), privateKey, { encoding: "utf8", mode: 384, flag: "wx" });
-  await restrictToCurrentUser(privateKeyPath());
-  await writeFile(publicKeyPath(), publicKey, { encoding: "utf8", flag: "wx" });
-  return { privateKey, publicKey };
 }
-async function getCollectorPublicKey() {
-  return (await ensureCollectorKeys()).publicKey;
-}
-function collectorFingerprint(publicKey) {
-  const der = createPublicKey(publicKey).export({ format: "der", type: "spki" });
-  return `sha256:${createHash2("sha256").update(der).digest("hex")}`;
-}
-async function signCollectorPayload(payload) {
-  const { privateKey } = await ensureCollectorKeys();
-  return sign(null, Buffer.from(canonicalJson(payload)), privateKey).toString("base64");
+async function acquire(lockPath2) {
+  const deadline = Date.now() + ACQUIRE_TIMEOUT_MS;
+  for (; ; ) {
+    try {
+      await writeFile(lockPath2, `${process.pid}
+`, {
+        encoding: "utf8",
+        flag: "wx"
+      });
+      return;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    try {
+      const info = await stat(lockPath2);
+      if (Date.now() - info.mtimeMs > STALE_LOCK_MS) {
+        await reclaimDeadLock(lockPath2);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    if (Date.now() > deadline) {
+      throw new Error(
+        "AIPOU operation is busy; retry when the other process finishes. Never remove an active lock."
+      );
+    }
+    await new Promise(
+      (resolve) => setTimeout(resolve, 25 + Math.floor(Math.random() * 75))
+    );
+  }
 }
-function verifyCollectorPayload(payload, signature, publicKey) {
-  return verify(null, Buffer.from(canonicalJson(payload)), publicKey, Buffer.from(signature, "base64"));
+async function withFileLock(lockPath2, operation) {
+  await acquire(lockPath2);
+  try {
+    return await operation();
+  } finally {
+    await rm(lockPath2, { force: true });
+  }
 }
 
 // src/identity.ts
 import { randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
-import path2 from "node:path";
+import path from "node:path";
 import { Wallet, getAddress, hexlify, isAddress, verifyTypedData } from "ethers";
 var authorizationTypes = {
   TaskAuthorization: [
@@ -12641,9 +13116,25 @@ var authorizationTypes = {
     { name: "issuedAt", type: "uint256" }
   ]
 };
+var DEFAULT_TASK_SESSION_TTL_SECONDS = 24 * 60 * 60;
+function taskSessionTtlSeconds() {
+  const configured = process.env.AIPOU_TASK_SESSION_TTL_SECONDS;
+  if (!configured) return DEFAULT_TASK_SESSION_TTL_SECONDS;
+  const value = Number.parseInt(configured, 10);
+  if (!Number.isInteger(value) || value < 60 || value > 7 * DEFAULT_TASK_SESSION_TTL_SECONDS) {
+    throw new Error("AIPOU_TASK_SESSION_TTL_SECONDS must be an integer from 60 through 604800");
+  }
+  return value;
+}
+function taskSessionExpiry(session) {
+  return session.expiresAt ?? session.issuedAt + taskSessionTtlSeconds();
+}
+function isTaskSessionExpired(session, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  return nowSeconds >= taskSessionExpiry(session);
+}
 function readKeyFile(keyFile) {
   try {
-    return readFileSync(path2.resolve(keyFile), "utf8").trim();
+    return readFileSync(path.resolve(keyFile), "utf8").trim();
   } catch {
     throw new Error(
       `AIPOU_AGENT_KEY_FILE could not be read (${keyFile}); run aipou-mcp --init to create a dedicated wallet key`
@@ -12681,7 +13172,14 @@ async function createTaskSession(input) {
     issuedAt
   };
   const walletAuthorization = await wallet.signTypedData(domain, authorizationTypes, value);
-  return { ...input, wallet: wallet.address, nonce, issuedAt, walletAuthorization };
+  return {
+    ...input,
+    wallet: wallet.address,
+    nonce,
+    issuedAt,
+    expiresAt: issuedAt + taskSessionTtlSeconds(),
+    walletAuthorization
+  };
 }
 function verifyTaskAuthorization(session) {
   const domain = {
@@ -12701,6 +13199,315 @@ function verifyTaskAuthorization(session) {
   return verifyTypedData(domain, authorizationTypes, value, session.walletAuthorization) === session.wallet;
 }
 
+// src/canonical.ts
+import { createHash } from "node:crypto";
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJson).join(",")}]`;
+  }
+  const record2 = value;
+  return `{${Object.keys(record2).filter((key) => record2[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record2[key])}`).join(",")}}`;
+}
+function sha256Hex(value) {
+  return `0x${createHash("sha256").update(value).digest("hex")}`;
+}
+
+// src/private-json.ts
+import { mkdir, open, rename, readFile as readFile3 } from "node:fs/promises";
+import path2 from "node:path";
+
+// src/secure-file.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function restrictToCurrentUser(filePath) {
+  if (process.platform !== "win32") return true;
+  const user = process.env.USERNAME;
+  if (!user) return false;
+  const principal = process.env.USERDOMAIN ? `${process.env.USERDOMAIN}\\${user}` : user;
+  try {
+    await execFileAsync("icacls", [filePath, "/inheritance:r", "/grant:r", `${principal}:F`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/private-json.ts
+async function writePrivateJson(file, value) {
+  await mkdir(path2.dirname(file), { recursive: true, mode: 448 });
+  const temp = `${file}.${process.pid}.tmp`;
+  const handle = await open(temp, "w", 384);
+  try {
+    if (process.platform !== "win32") await handle.chmod(384);
+    await handle.writeFile(JSON.stringify(value, null, 2) + "\n");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  if (!await restrictToCurrentUser(temp))
+    throw new Error(
+      "Could not restrict private state file access; update was not committed"
+    );
+  await rename(temp, file);
+  if (process.platform !== "win32") {
+    const directory = await open(path2.dirname(file), "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  }
+}
+async function readOptionalJson(file) {
+  try {
+    return JSON.parse(await readFile3(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+// src/store.ts
+var emptyState = () => ({ sessions: {}, receipts: [], completedEvidence: {}, batches: [] });
+var mutationQueue = Promise.resolve();
+function dataDir() {
+  return path3.resolve(process.env.AIPOU_DATA_DIR || ".aipou");
+}
+function statePath() {
+  return path3.join(dataDir(), "state.json");
+}
+function lockPath() {
+  return `${statePath()}.lock`;
+}
+function archiveDir() {
+  return path3.join(dataDir(), "settled");
+}
+async function readState() {
+  try {
+    return JSON.parse(await readFile4(statePath(), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return emptyState();
+    throw error;
+  }
+}
+async function writeState(state) {
+  await writePrivateJson(statePath(), state);
+}
+async function mutate(operation) {
+  const next = mutationQueue.then(async () => {
+    await mkdir2(dataDir(), { recursive: true });
+    return withFileLock(lockPath(), async () => {
+      const state = await readState();
+      const result = await operation(state);
+      await writeState(state);
+      return result;
+    });
+  });
+  mutationQueue = next.catch(() => void 0);
+  return next;
+}
+async function saveSession(session) {
+  await mutate((state) => {
+    if (state.sessions[session.nonce]) throw new Error("Task nonce already exists");
+    state.sessions[session.nonce] = session;
+  });
+}
+async function getSession(nonce) {
+  return (await readState()).sessions[nonce] || null;
+}
+async function saveCompletedReceipt(evidenceKey, receipt) {
+  await mutate((state) => {
+    const session = state.sessions[receipt.nonce];
+    if (!session) throw new Error("Unknown task nonce");
+    if (session.completedAt) throw new Error("Task nonce has already been completed; recover its stored receipt with export_ai_receipts and match the nonce.");
+    if (state.completedEvidence[evidenceKey]) {
+      throw new Error(`Duplicate task/output evidence already recorded as ${state.completedEvidence[evidenceKey]}`);
+    }
+    if (state.receipts.some((item) => item.receiptId === receipt.receiptId)) {
+      throw new Error("Receipt id has already been recorded");
+    }
+    if ((state.settledReceiptIds ?? []).includes(receipt.receiptId)) {
+      throw new Error("Receipt id has already been settled and archived");
+    }
+    session.completedAt = receipt.recordedAt;
+    state.completedEvidence[evidenceKey] = receipt.receiptId;
+    state.receipts.push(receipt);
+  });
+}
+async function readArchivedReceipts() {
+  let files;
+  try {
+    files = await readdir(archiveDir());
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const receipts = [];
+  for (const file of files.filter((name) => name.endsWith(".json")).sort()) {
+    receipts.push(...JSON.parse(await readFile4(path3.join(archiveDir(), file), "utf8")));
+  }
+  return receipts;
+}
+async function exportStoredReceipts(wallet) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const receipt of [...(await readState()).receipts, ...await readArchivedReceipts()]) {
+    const prior = unique.get(receipt.receiptId);
+    if (!prior?.claimTransaction) unique.set(receipt.receiptId, receipt);
+  }
+  const receipts = [...unique.values()];
+  if (!wallet) return receipts;
+  return receipts.filter((receipt) => receipt.wallet.toLowerCase() === wallet.toLowerCase());
+}
+async function unsettledReceipts(limit) {
+  return (await readState()).receipts.filter((receipt) => !receipt.claimTransaction).slice(0, limit);
+}
+async function protocolStateCounts() {
+  const state = await readState();
+  const sessions = Object.values(state.sessions);
+  return {
+    sessions: sessions.length,
+    completedSessions: sessions.filter((session) => session.completedAt).length,
+    incompleteSessions: sessions.filter((session) => !session.completedAt).length,
+    activeSessions: sessions.filter((session) => !session.completedAt && !isTaskSessionExpired(session)).length,
+    expiredSessions: sessions.filter((session) => !session.completedAt && isTaskSessionExpired(session)).length,
+    batches: state.batches.length
+  };
+}
+async function settledReceiptsSince(sinceMs) {
+  const receipts = await exportStoredReceipts();
+  return receipts.filter(
+    (receipt) => receipt.claimTransaction && Date.parse(receipt.recordedAt) >= sinceMs
+  );
+}
+async function markBatchSettled(batch) {
+  await mutate(async (state) => {
+    const existing = state.batches.find((item) => item.root === batch.root);
+    if (existing) {
+      if (existing.claimTransaction !== batch.claimTransaction) throw new Error("Settlement archive transaction mismatch");
+      return;
+    }
+    const included = new Set(batch.receiptIds);
+    const settled = [];
+    for (const receipt of state.receipts) {
+      if (included.has(receipt.receiptId)) {
+        if (receipt.claimTransaction) throw new Error(`Receipt ${receipt.receiptId} is already settled`);
+        receipt.batchRoot = batch.root;
+        receipt.claimTransaction = batch.claimTransaction;
+        settled.push(receipt);
+      }
+    }
+    await mkdir2(archiveDir(), { recursive: true });
+    const archivePath = path3.join(archiveDir(), `batch-${batch.root.slice(2)}.json`);
+    try {
+      const prior = JSON.parse(await readFile4(archivePath, "utf8"));
+      if (canonicalJson(prior) !== canonicalJson(settled)) throw new Error("Settlement archive does not match saved batch");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      await writePrivateJson(archivePath, settled);
+    }
+    state.receipts = state.receipts.filter((receipt) => !included.has(receipt.receiptId));
+    state.settledReceiptIds = [...state.settledReceiptIds ?? [], ...batch.receiptIds];
+    state.batches.push(batch);
+  });
+}
+
+// src/feedback.ts
+async function localFeedbackSummary() {
+  const receipts = await exportStoredReceipts();
+  const counts = await protocolStateCounts();
+  const activeDays = new Set(receipts.map((r) => r.recordedAt.slice(0, 10)));
+  return {
+    schema: "aipou-local-feedback-v1",
+    version: await getPackageVersion(),
+    platform: process.platform,
+    node: process.versions.node,
+    localReceiptCount: receipts.length,
+    localActiveDays: activeDays.size,
+    completedSessions: counts.completedSessions,
+    activeSessions: counts.activeSessions,
+    expiredSessions: counts.expiredSessions,
+    measuredUsageReceipts: receipts.filter(
+      (r) => r.tokenUsageMeasurement === "measured"
+    ).length,
+    unmeasuredUsageReceipts: receipts.filter(
+      (r) => r.tokenUsageMeasurement === "unmeasured"
+    ).length,
+    unspecifiedUsageReceipts: receipts.filter(
+      (r) => !r.tokenUsageMeasurement || r.tokenUsageMeasurement === "unspecified"
+    ).length,
+    transmission: "none; review before sharing voluntarily",
+    interpretation: "one local installation; not unique-user, organic-adoption or revenue metrics"
+  };
+}
+
+// src/claims.ts
+import { MerkleTree } from "merkletreejs";
+import {
+  AbiCoder,
+  Contract as Contract2,
+  JsonRpcProvider as JsonRpcProvider2,
+  Transaction as Transaction2,
+  Wallet as Wallet3,
+  concat,
+  getAddress as getAddress2,
+  getBytes,
+  keccak256,
+  parseUnits
+} from "ethers";
+import { mkdir as mkdir4, readFile as readFile7, rm as rm2 } from "node:fs/promises";
+import path6 from "node:path";
+
+// src/collector.ts
+import { createHash as createHash2, createPublicKey, generateKeyPairSync, sign, verify } from "node:crypto";
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile2 } from "node:fs/promises";
+import path4 from "node:path";
+function dataDir2() {
+  return path4.resolve(process.env.AIPOU_DATA_DIR || ".aipou");
+}
+function privateKeyPath() {
+  return path4.join(dataDir2(), "collector-ed25519-private.pem");
+}
+function publicKeyPath() {
+  return path4.join(dataDir2(), "collector-ed25519-public.pem");
+}
+async function ensureCollectorKeys() {
+  await mkdir3(dataDir2(), { recursive: true });
+  try {
+    const [privateKey2, publicKey2] = await Promise.all([
+      readFile5(privateKeyPath(), "utf8"),
+      readFile5(publicKeyPath(), "utf8")
+    ]);
+    return { privateKey: privateKey2, publicKey: publicKey2 };
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const pair = generateKeyPairSync("ed25519");
+  const privateKey = pair.privateKey.export({ format: "pem", type: "pkcs8" }).toString();
+  const publicKey = pair.publicKey.export({ format: "pem", type: "spki" }).toString();
+  await writeFile2(privateKeyPath(), privateKey, { encoding: "utf8", mode: 384, flag: "wx" });
+  await restrictToCurrentUser(privateKeyPath());
+  await writeFile2(publicKeyPath(), publicKey, { encoding: "utf8", flag: "wx" });
+  return { privateKey, publicKey };
+}
+async function getCollectorPublicKey() {
+  return (await ensureCollectorKeys()).publicKey;
+}
+function collectorFingerprint(publicKey) {
+  const der = createPublicKey(publicKey).export({ format: "der", type: "spki" });
+  return `sha256:${createHash2("sha256").update(der).digest("hex")}`;
+}
+async function signCollectorPayload(payload) {
+  const { privateKey } = await ensureCollectorKeys();
+  return sign(null, Buffer.from(canonicalJson(payload)), privateKey).toString("base64");
+}
+function verifyCollectorPayload(payload, signature, publicKey) {
+  return verify(null, Buffer.from(canonicalJson(payload)), publicKey, Buffer.from(signature, "base64"));
+}
+
 // src/policy.ts
 var DAY_MS = 24 * 60 * 60 * 1e3;
 function positiveIntFromEnv(name, fallback) {
@@ -12755,12 +13562,12 @@ function filterEligibleReceipts(candidates, recentlySettled, policy, now = Date.
 
 // src/providers.ts
 import { verify as verify2 } from "node:crypto";
-import { readFile as readFile2 } from "node:fs/promises";
-import path3 from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import path5 from "node:path";
 async function configuredKeys() {
   const file = process.env.AIPOU_PROVIDER_KEYS_FILE;
   if (!file) return {};
-  return JSON.parse(await readFile2(path3.resolve(file), "utf8"));
+  return JSON.parse(await readFile6(path5.resolve(file), "utf8"));
 }
 function providerAssertion(session, input) {
   return {
@@ -12787,196 +13594,303 @@ async function deriveTrustTier(session, input, evidence) {
   return "provider_signed";
 }
 
-// src/store.ts
-import { mkdir as mkdir2, readFile as readFile3, readdir, rename, writeFile as writeFile3 } from "node:fs/promises";
-import path4 from "node:path";
-
-// src/lock.ts
-import { rm, stat, writeFile as writeFile2 } from "node:fs/promises";
-var STALE_LOCK_MS = 15e3;
-var ACQUIRE_TIMEOUT_MS = 1e4;
-async function acquire(lockPath2) {
-  const deadline = Date.now() + ACQUIRE_TIMEOUT_MS;
-  for (; ; ) {
-    try {
-      await writeFile2(lockPath2, `${process.pid}
-`, { encoding: "utf8", flag: "wx" });
-      return;
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-    }
-    try {
-      const info = await stat(lockPath2);
-      if (Date.now() - info.mtimeMs > STALE_LOCK_MS) {
-        await rm(lockPath2, { force: true });
-        continue;
-      }
-    } catch {
-      continue;
-    }
-    if (Date.now() > deadline) {
-      throw new Error(`Timed out waiting for lock ${lockPath2}; remove it manually if no other AIPOU process is running`);
-    }
-    await new Promise((resolve) => setTimeout(resolve, 25 + Math.floor(Math.random() * 75)));
-  }
-}
-async function withFileLock(lockPath2, operation) {
-  await acquire(lockPath2);
-  try {
-    return await operation();
-  } finally {
-    await rm(lockPath2, { force: true });
-  }
-}
-
-// src/store.ts
-var emptyState = () => ({ sessions: {}, receipts: [], completedEvidence: {}, batches: [] });
-var mutationQueue = Promise.resolve();
-function dataDir2() {
-  return path4.resolve(process.env.AIPOU_DATA_DIR || ".aipou");
-}
-function statePath() {
-  return path4.join(dataDir2(), "state.json");
-}
-function lockPath() {
-  return `${statePath()}.lock`;
-}
-function archiveDir() {
-  return path4.join(dataDir2(), "settled");
-}
-async function readState() {
-  try {
-    return JSON.parse(await readFile3(statePath(), "utf8"));
-  } catch (error) {
-    if (error.code === "ENOENT") return emptyState();
-    throw error;
+// src/settlement-runner.ts
+async function executeSettlementPlan(plan, driver, persist) {
+  const execute = async (kind, indices2) => {
+    let tx = plan[kind];
+    if (!tx) {
+      tx = await driver.prepare(kind, plan, indices2);
+      plan[kind] = tx;
+      await persist(plan);
+    }
+    let result = await driver.receipt(tx.hash);
+    if (!result) {
+      await driver.broadcast(tx);
+      result = await driver.wait(tx.hash);
+    }
+    if (!result)
+      throw new Error(
+        "SETTLEMENT_UNCONFIRMED: rerun to reconcile the saved transaction; do not replace it."
+      );
+    if (result.hash.toLowerCase() !== tx.hash.toLowerCase() || result.status !== 1) {
+      throw new Error(
+        "SETTLEMENT_REVERTED: inspect the saved hash before an operator resets the journal."
+      );
+    }
+    return result.hash;
+  };
+  if (plan.claim) {
+    const claimTransaction2 = await execute("claim", []);
+    return { publishTransaction: plan.publish?.hash ?? "", claimTransaction: claimTransaction2 };
   }
-}
-async function writeState(state) {
-  const temporary = `${statePath()}.${process.pid}.tmp`;
-  await writeFile3(temporary, `${JSON.stringify(state, null, 2)}
-`, { encoding: "utf8", mode: 384 });
-  await rename(temporary, statePath());
-}
-async function mutate(operation) {
-  const next = mutationQueue.then(async () => {
-    await mkdir2(dataDir2(), { recursive: true });
-    return withFileLock(lockPath(), async () => {
-      const state = await readState();
-      const result = await operation(state);
-      await writeState(state);
-      return result;
-    });
-  });
-  mutationQueue = next.catch(() => void 0);
-  return next;
-}
-async function saveSession(session) {
-  await mutate((state) => {
-    if (state.sessions[session.nonce]) throw new Error("Task nonce already exists");
-    state.sessions[session.nonce] = session;
-  });
-}
-async function getSession(nonce) {
-  return (await readState()).sessions[nonce] || null;
-}
-async function saveCompletedReceipt(evidenceKey, receipt) {
-  await mutate((state) => {
-    const session = state.sessions[receipt.nonce];
-    if (!session) throw new Error("Unknown task nonce");
-    if (session.completedAt) throw new Error("Task nonce has already been completed");
-    if (state.completedEvidence[evidenceKey]) {
-      throw new Error(`Duplicate task/output evidence already recorded as ${state.completedEvidence[evidenceKey]}`);
-    }
-    if (state.receipts.some((item) => item.receiptId === receipt.receiptId)) {
-      throw new Error("Receipt id has already been recorded");
+  const claimed = await Promise.all(
+    plan.receiptIds.map((id) => driver.claimed(id))
+  );
+  if (claimed.some(Boolean))
+    throw new Error(
+      "SETTLEMENT_RECONCILIATION_REQUIRED: onchain claims exist without a saved transaction; inspect events before changing local state."
+    );
+  const indices = plan.receiptIds.map((_, i) => i);
+  const rootApproved = await driver.approved(plan.root);
+  await driver.preflight(plan, !rootApproved, indices);
+  const publishTransaction = rootApproved ? plan.publish?.hash ?? "" : await execute("publish", []);
+  if (!await driver.approved(plan.root))
+    throw new Error("SETTLEMENT_ROOT_UNCONFIRMED: rerun to reconcile.");
+  const claimTransaction = await execute("claim", indices);
+  return { publishTransaction, claimTransaction };
+}
+
+// src/settlement-driver.ts
+import { Contract, Transaction } from "ethers";
+var abi = [
+  "function approvedRoots(bytes32) view returns(bool)",
+  "function claimedReceipts(bytes32) view returns(bool)",
+  "function publishRoot(bytes32)",
+  "function claimBatch(bytes32,address[],uint256[],bytes32[],bytes32[][])"
+];
+function createSettlementDriver(signer, contract) {
+  const provider = signer.provider;
+  const claims = new Contract(contract, abi, signer);
+  const data = (kind, plan) => kind === "publish" ? claims.interface.encodeFunctionData("publishRoot", [plan.root]) : claims.interface.encodeFunctionData("claimBatch", [
+    plan.root,
+    plan.accounts,
+    plan.amounts,
+    plan.receiptIds,
+    plan.proofs
+  ]);
+  const fees = async () => {
+    const fee = await provider.getFeeData();
+    const gasPrice = fee.maxFeePerGas ?? fee.gasPrice;
+    if (gasPrice === null || gasPrice <= 0n)
+      throw new Error(
+        "SETTLEMENT_FEE_UNAVAILABLE: RPC did not supply a gas price."
+      );
+    return fee.maxFeePerGas !== null && fee.maxPriorityFeePerGas !== null ? {
+      maxFeePerGas: fee.maxFeePerGas,
+      maxPriorityFeePerGas: fee.maxPriorityFeePerGas
+    } : { gasPrice };
+  };
+  const budget = async (cost) => {
+    const cap = process.env.AIPOU_MAX_SETTLEMENT_FEE_WEI;
+    if (cap && (!/^\d+$/.test(cap) || cost > BigInt(cap)))
+      throw new Error(
+        "SETTLEMENT_FEE_CAP: required fee exceeds AIPOU_MAX_SETTLEMENT_FEE_WEI."
+      );
+    if (await provider.getBalance(signer.address) < cost) {
+      throw new Error(
+        `SETTLEMENT_INSUFFICIENT_GAS: validator needs up to ${cost} wei for this batch including a conservative Base data-fee allowance. Fund the validator on Base and retry; no automatic transfer is performed.`
+      );
     }
-    if ((state.settledReceiptIds ?? []).includes(receipt.receiptId)) {
-      throw new Error("Receipt id has already been settled and archived");
+  };
+  return {
+    approved: (root) => claims.approvedRoots(root),
+    claimed: (id) => claims.claimedReceipts(id),
+    preflight: async (plan, publishNeeded) => {
+      const fee = await fees();
+      const price = "gasPrice" in fee ? fee.gasPrice : fee.maxFeePerGas;
+      const claimGas = publishNeeded ? 120000n + BigInt(plan.receiptIds.length) * 100000n : await provider.estimateGas({
+        from: signer.address,
+        to: contract,
+        data: data("claim", plan)
+      });
+      const pubGas = publishNeeded ? await provider.estimateGas({
+        from: signer.address,
+        to: contract,
+        data: data("publish", plan)
+      }) : 0n;
+      await budget(
+        (claimGas + pubGas) * price * 120n / 100n + 20000000000000n
+      );
+    },
+    prepare: async (kind, plan) => {
+      const request = {
+        to: contract,
+        data: data(kind, plan),
+        value: 0n,
+        ...await fees()
+      };
+      const gasLimit = await provider.estimateGas({ ...request, from: signer.address }) * 120n / 100n;
+      const price = "gasPrice" in request ? request.gasPrice : request.maxFeePerGas;
+      await budget(gasLimit * price + 20000000000000n);
+      const populated = await signer.populateTransaction({
+        ...request,
+        gasLimit
+      });
+      const raw = await signer.signTransaction(populated);
+      const hash = Transaction.from(raw).hash;
+      return { hash, raw };
+    },
+    receipt: async (hash) => {
+      const result = await provider.getTransactionReceipt(hash);
+      return result ? { hash: result.hash, status: result.status } : null;
+    },
+    broadcast: async (tx) => {
+      const decoded = Transaction.from(tx.raw);
+      if (decoded.hash !== tx.hash || decoded.from !== signer.address || decoded.to?.toLowerCase() !== contract.toLowerCase() || decoded.chainId !== 8453n || decoded.value !== 0n) {
+        throw new Error(
+          "SETTLEMENT_JOURNAL_INVALID: saved transaction identity does not match this validator and contract."
+        );
+      }
+      if (await provider.getTransaction(tx.hash)) return;
+      try {
+        await provider.broadcastTransaction(tx.raw);
+      } catch {
+        if (await provider.getTransaction(tx.hash)) return;
+        throw new Error(
+          "SETTLEMENT_BROADCAST_UNCONFIRMED: saved transaction retained; retry to reconcile. No replacement transaction was signed."
+        );
+      }
+    },
+    wait: async (hash) => {
+      try {
+        const result = await provider.waitForTransaction(hash, 1, 9e4);
+        return result ? { hash: result.hash, status: result.status } : null;
+      } catch {
+        throw new Error(
+          "SETTLEMENT_CONFIRMATION_UNAVAILABLE: saved transaction retained; retry to reconcile."
+        );
+      }
     }
-    session.completedAt = receipt.recordedAt;
-    state.completedEvidence[evidenceKey] = receipt.receiptId;
-    state.receipts.push(receipt);
-  });
+  };
 }
-async function readArchivedReceipts() {
-  let files;
-  try {
-    files = await readdir(archiveDir());
-  } catch (error) {
-    if (error.code === "ENOENT") return [];
-    throw error;
-  }
-  const receipts = [];
-  for (const file of files.filter((name) => name.endsWith(".json")).sort()) {
-    receipts.push(...JSON.parse(await readFile3(path4.join(archiveDir(), file), "utf8")));
-  }
-  return receipts;
+
+// src/evidence.ts
+function receiptEvidenceReport(input) {
+  return {
+    receiptIntegrity: input.receiptIntegrity ? "VERIFIED" : "UNKNOWN",
+    walletAuthorization: input.walletAuthorization ? "VERIFIED" : "UNKNOWN",
+    collectorSignature: input.collectorSignature ? "VERIFIED" : "UNKNOWN",
+    hostExecution: input.hostExecution ?? "UNKNOWN",
+    // These require their own artifacts and verifiers. AIPOU receipts do not
+    // infer them from a completed local task.
+    delivery: "UNKNOWN",
+    businessAcceptance: "ABSENT",
+    settlement: "ABSENT",
+    externalEffect: "UNKNOWN"
+  };
 }
-async function exportStoredReceipts(wallet) {
-  const receipts = [...await readArchivedReceipts(), ...(await readState()).receipts];
-  if (!wallet) return receipts;
-  return receipts.filter((receipt) => receipt.wallet.toLowerCase() === wallet.toLowerCase());
+
+// src/receipt-verifier.ts
+function isBytes32(value) {
+  return typeof value === "string" && /^0x[0-9a-f]{64}$/i.test(value);
 }
-async function unsettledReceipts(limit) {
-  return (await readState()).receipts.filter((receipt) => !receipt.claimTransaction).slice(0, limit);
+function assertReceiptShape(receipt) {
+  const errors = [];
+  const fields = /* @__PURE__ */ new Set(["receiptId", "nonce", "wallet", "provider", "model", "inputTokens", "outputTokens", "durationSeconds", "taskHash", "outputHash", "client", "trustTier", "walletAuthorization", "authorizationIssuedAt", "authorizationChainId", "authorizationContract", "providerEvidence", "collectorPublicKey", "collectorSignature", "recordedAt", "estimatedReward", "batchRoot", "claimTransaction", "tokenUsageMeasurement"]);
+  if (Object.keys(receipt).some((key) => !fields.has(key))) return ["receipt contains unsupported fields"];
+  for (const [key, value] of Object.entries(receipt)) {
+    if (key === "providerEvidence") {
+      if (value !== void 0 && (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((k) => !["keyId", "signature"].includes(k)) || typeof value.keyId !== "string" || typeof value.signature !== "string" || value.keyId.length > 128 || value.signature.length > 2048)) return ["providerEvidence must contain bounded keyId and signature strings"];
+    } else if (value !== void 0 && typeof value !== "string" && typeof value !== "number") return ["receipt fields must be scalar values"];
+    if (typeof value === "string" && value.length > 8192) return ["receipt field exceeds length limit"];
+  }
+  for (const field of ["receiptId", "nonce", "taskHash", "outputHash"]) {
+    if (!isBytes32(receipt[field])) errors.push(`${field} must be a bytes32 hex value`);
+  }
+  if (typeof receipt.walletAuthorization !== "string" || !/^0x[0-9a-f]+$/i.test(receipt.walletAuthorization)) {
+    errors.push("walletAuthorization must be a hex EIP-712 signature");
+  }
+  if (typeof receipt.wallet !== "string" || !/^0x[0-9a-f]{40}$/i.test(receipt.wallet)) errors.push("wallet must be an address");
+  if (typeof receipt.authorizationContract !== "string" || !/^0x[0-9a-f]{40}$/i.test(receipt.authorizationContract)) {
+    errors.push("authorizationContract must be an address");
+  }
+  for (const field of ["provider", "model", "client", "collectorPublicKey", "collectorSignature", "recordedAt", "estimatedReward"]) {
+    if (typeof receipt[field] !== "string" || receipt[field].length === 0) errors.push(`${field} must be a non-empty string`);
+  }
+  for (const field of ["inputTokens", "outputTokens", "durationSeconds", "authorizationIssuedAt", "authorizationChainId"]) {
+    if (!Number.isSafeInteger(receipt[field]) || Number(receipt[field]) < 0) errors.push(`${field} must be a non-negative safe integer`);
+  }
+  if (receipt.trustTier !== "client_signed" && receipt.trustTier !== "provider_signed") errors.push("trustTier is unsupported");
+  if (receipt.tokenUsageMeasurement !== void 0 && !["measured", "unmeasured", "unspecified"].includes(receipt.tokenUsageMeasurement)) errors.push("tokenUsageMeasurement is unsupported");
+  if (receipt.tokenUsageMeasurement === "unmeasured" && (receipt.inputTokens !== 0 || receipt.outputTokens !== 0)) errors.push("unmeasured token usage must have zero counts");
+  if (Number.isNaN(Date.parse(String(receipt.recordedAt)))) errors.push("recordedAt must be an ISO date");
+  return errors;
 }
-async function protocolStateCounts() {
-  const state = await readState();
-  const sessions = Object.values(state.sessions);
+function verifyAipouReceipt(candidate) {
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+    return {
+      valid: false,
+      errors: ["receipt must be an object"],
+      workReceiptId: null,
+      claimedWorkReceiptId: null,
+      evidence: receiptEvidenceReport({ receiptIntegrity: false, walletAuthorization: false, collectorSignature: false })
+    };
+  }
+  const receipt = candidate;
+  const errors = assertReceiptShape(receipt);
+  if (errors.length > 0) {
+    return {
+      valid: false,
+      errors,
+      workReceiptId: null,
+      claimedWorkReceiptId: isBytes32(receipt.receiptId) ? receipt.receiptId.toLowerCase() : null,
+      evidence: receiptEvidenceReport({ receiptIntegrity: false, walletAuthorization: false, collectorSignature: false })
+    };
+  }
+  const { receiptId, collectorSignature: signature, batchRoot: _batchRoot, claimTransaction: _claimTransaction, ...unsigned } = receipt;
+  const receiptIntegrity = sha256Hex(canonicalJson(unsigned)).toLowerCase() === receiptId.toLowerCase();
+  if (!receiptIntegrity) errors.push("receiptId does not match canonical unsigned receipt payload");
+  let collectorSignatureValid = false;
+  try {
+    collectorSignatureValid = verifyCollectorPayload({ receiptId, ...unsigned }, signature, receipt.collectorPublicKey);
+  } catch {
+    collectorSignatureValid = false;
+  }
+  if (!collectorSignatureValid) errors.push("collector signature is invalid");
+  const session = {
+    nonce: receipt.nonce,
+    wallet: receipt.wallet,
+    provider: receipt.provider,
+    model: receipt.model,
+    taskHash: receipt.taskHash,
+    client: receipt.client,
+    issuedAt: receipt.authorizationIssuedAt,
+    chainId: receipt.authorizationChainId,
+    verifyingContract: receipt.authorizationContract,
+    walletAuthorization: receipt.walletAuthorization,
+    completedAt: receipt.recordedAt
+  };
+  let walletAuthorization = false;
+  try {
+    walletAuthorization = verifyTaskAuthorization(session);
+  } catch {
+    walletAuthorization = false;
+  }
+  if (!walletAuthorization) errors.push("wallet authorization is invalid");
   return {
-    sessions: sessions.length,
-    completedSessions: sessions.filter((session) => session.completedAt).length,
-    incompleteSessions: sessions.filter((session) => !session.completedAt).length,
-    batches: state.batches.length
+    valid: errors.length === 0,
+    errors,
+    workReceiptId: errors.length === 0 ? receiptId.toLowerCase() : null,
+    claimedWorkReceiptId: errors.length === 0 ? null : receiptId.toLowerCase(),
+    evidence: receiptEvidenceReport({
+      receiptIntegrity,
+      walletAuthorization,
+      collectorSignature: collectorSignatureValid,
+      hostExecution: receiptIntegrity && collectorSignatureValid ? "OBSERVED" : "UNKNOWN"
+    })
   };
 }
-async function settledReceiptsSince(sinceMs) {
-  const receipts = [...await readArchivedReceipts(), ...(await readState()).receipts];
-  return receipts.filter(
-    (receipt) => receipt.claimTransaction && Date.parse(receipt.recordedAt) >= sinceMs
-  );
-}
-async function markBatchSettled(batch) {
-  await mutate(async (state) => {
-    const included = new Set(batch.receiptIds);
-    const settled = [];
-    for (const receipt of state.receipts) {
-      if (included.has(receipt.receiptId)) {
-        if (receipt.claimTransaction) throw new Error(`Receipt ${receipt.receiptId} is already settled`);
-        receipt.batchRoot = batch.root;
-        receipt.claimTransaction = batch.claimTransaction;
-        settled.push(receipt);
-      }
-    }
-    await mkdir2(archiveDir(), { recursive: true });
-    const archivePath = path4.join(archiveDir(), `batch-${batch.root.slice(2, 18)}.json`);
-    await writeFile3(archivePath, `${JSON.stringify(settled, null, 2)}
-`, { encoding: "utf8", flag: "wx" });
-    state.receipts = state.receipts.filter((receipt) => !included.has(receipt.receiptId));
-    state.settledReceiptIds = [...state.settledReceiptIds ?? [], ...batch.receiptIds];
-    state.batches.push(batch);
-  });
-}
 
 // src/claims.ts
 var claimsAbi = [
   "function token() view returns (address)",
   "function validator() view returns (address)",
   "function approvedRoots(bytes32 root) view returns (bool)",
+  "function claimedReceipts(bytes32 receiptId) view returns (bool)",
   "function publishRoot(bytes32 root)",
   "function claimBatch(bytes32 root, address[] accounts, uint256[] amounts, bytes32[] receiptIds, bytes32[][] proofs)"
 ];
 var tokenAbi = ["function emissionController() view returns (address)"];
 function claimsAddress() {
   const value = process.env.AIPOU_CLAIMS_ADDRESS;
-  if (!value) throw new Error("AIPOU_CLAIMS_ADDRESS is required to settle rewards");
+  if (!value)
+    throw new Error("AIPOU_CLAIMS_ADDRESS is required to settle rewards");
   return getAddress2(value);
 }
 async function validatorPrivateKey() {
   const keyFile = process.env.AIPOU_VALIDATOR_KEY_FILE;
   if (keyFile) {
-    const key = (await readFile4(path5.resolve(keyFile), "utf8")).trim();
+    const key = (await readFile7(path6.resolve(keyFile), "utf8")).trim();
     if (!key) throw new Error(`AIPOU_VALIDATOR_KEY_FILE ${keyFile} is empty`);
     return key;
   }
@@ -12987,26 +13901,46 @@ async function validatorPrivateKey() {
     );
     return envKey;
   }
-  throw new Error("AIPOU_VALIDATOR_KEY_FILE (or legacy AIPOU_VALIDATOR_PRIVATE_KEY) is required only on the protocol validator server");
+  throw new Error(
+    "AIPOU_VALIDATOR_KEY_FILE (or legacy AIPOU_VALIDATOR_PRIVATE_KEY) is required only on the protocol validator server"
+  );
 }
 async function validatorWallet() {
-  const provider = new JsonRpcProvider(process.env.AIPOU_RPC_URL || "https://mainnet.base.org");
-  return new Wallet2(await validatorPrivateKey(), provider);
+  const provider = new JsonRpcProvider2(
+    process.env.AIPOU_RPC_URL || "https://mainnet.base.org"
+  );
+  return new Wallet3(await validatorPrivateKey(), provider);
 }
 async function trustedCollectorFingerprints() {
   const file = process.env.AIPOU_TRUSTED_COLLECTORS_FILE;
-  if (!file) throw new Error("AIPOU_TRUSTED_COLLECTORS_FILE is required on the protocol validator server");
-  const content = JSON.parse(await readFile4(path5.resolve(file), "utf8"));
-  if (!Array.isArray(content.fingerprints)) throw new Error("Trusted collectors file must contain a fingerprints array");
+  if (!file)
+    throw new Error(
+      "AIPOU_TRUSTED_COLLECTORS_FILE is required on the protocol validator server"
+    );
+  const content = JSON.parse(await readFile7(path6.resolve(file), "utf8"));
+  if (!Array.isArray(content.fingerprints))
+    throw new Error(
+      "Trusted collectors file must contain a fingerprints array"
+    );
   return new Set(content.fingerprints);
 }
 async function verifyReceipt(receipt, trustedCollectors) {
+  if (!verifyAipouReceipt(receipt).valid)
+    throw new Error(
+      "Invalid receipt integrity or signature; settlement stopped before submission"
+    );
   const fingerprint = collectorFingerprint(receipt.collectorPublicKey);
   if (!trustedCollectors.has(fingerprint)) {
-    throw new Error(`Untrusted collector ${fingerprint} for ${receipt.receiptId}`);
+    throw new Error(
+      `Untrusted collector ${fingerprint} for ${receipt.receiptId}`
+    );
   }
   const { collectorSignature, batchRoot, claimTransaction, ...signedPayload } = receipt;
-  if (!verifyCollectorPayload(signedPayload, collectorSignature, receipt.collectorPublicKey)) {
+  if (!verifyCollectorPayload(
+    signedPayload,
+    collectorSignature,
+    receipt.collectorPublicKey
+  )) {
     throw new Error(`Invalid collector signature for ${receipt.receiptId}`);
   }
   const session = {
@@ -13022,7 +13956,8 @@ async function verifyReceipt(receipt, trustedCollectors) {
     walletAuthorization: receipt.walletAuthorization,
     completedAt: receipt.recordedAt
   };
-  if (!verifyTaskAuthorization(session)) throw new Error(`Invalid wallet authorization for ${receipt.receiptId}`);
+  if (!verifyTaskAuthorization(session))
+    throw new Error(`Invalid wallet authorization for ${receipt.receiptId}`);
   const derivedTier = await deriveTrustTier(
     session,
     {
@@ -13031,31 +13966,81 @@ async function verifyReceipt(receipt, trustedCollectors) {
       outputTokens: receipt.outputTokens,
       durationSeconds: receipt.durationSeconds,
       outputHash: receipt.outputHash,
+      tokenUsageMeasurement: receipt.tokenUsageMeasurement,
       providerEvidence: receipt.providerEvidence
     },
     receipt.providerEvidence
   );
-  if (derivedTier !== receipt.trustTier) throw new Error(`Invalid trust tier for ${receipt.receiptId}`);
+  if (derivedTier !== receipt.trustTier)
+    throw new Error(`Invalid trust tier for ${receipt.receiptId}`);
 }
 async function settleRewards(maxReceipts = 25) {
+  if (!Number.isInteger(maxReceipts) || maxReceipts < 1 || maxReceipts > 100)
+    throw new Error("Batch size must be 1 through 100");
+  const directory = path6.resolve(process.env.AIPOU_DATA_DIR || ".aipou");
+  await mkdir4(directory, { recursive: true, mode: 448 });
+  try {
+    return await withFileLock(
+      path6.join(directory, "settlement.lock"),
+      () => settleRewardsLocked(maxReceipts, directory)
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "";
+    if (message.startsWith("SETTLEMENT_") || message === "There are no unsettled receipts" || message.startsWith("No receipts pass the settlement policy"))
+      throw error;
+    throw new Error(
+      "SETTLEMENT_FAILED: inspect local configuration and saved settlement state before retrying; private RPC and transaction details are withheld."
+    );
+  }
+}
+async function settleRewardsLocked(maxReceipts, directory) {
+  const journalPath = path6.join(directory, "settlement-pending.json");
+  const pending = await readOptionalJson(journalPath);
   const candidates = await unsettledReceipts(Number.MAX_SAFE_INTEGER);
-  if (candidates.length === 0) throw new Error("There are no unsettled receipts");
+  if (candidates.length === 0 && !pending)
+    throw new Error("There are no unsettled receipts");
   const policy = settlementPolicyFromEnv();
   const recentlySettled = await settledReceiptsSince(Date.now() - DAY_MS);
-  const { eligible, skipped } = filterEligibleReceipts(candidates, recentlySettled, policy);
-  if (eligible.length === 0) {
+  const { eligible, skipped } = filterEligibleReceipts(
+    candidates,
+    recentlySettled,
+    policy
+  );
+  if (eligible.length === 0 && !pending) {
     const reasons = skipped.map((item) => `${item.receiptId.slice(0, 10)}\u2026: ${item.reason}`).join("; ");
-    throw new Error(`No receipts pass the settlement policy. Skipped: ${reasons}`);
+    throw new Error(
+      `No receipts pass the settlement policy. Skipped: ${reasons}`
+    );
+  }
+  let receipts = eligible.slice(0, maxReceipts);
+  if (pending) {
+    if (pending.version !== 1 || pending.chainId !== 8453 || !Array.isArray(pending.receiptIds) || pending.receiptIds.length < 1 || pending.receiptIds.length > 100) {
+      throw new Error("SETTLEMENT_JOURNAL_INVALID: invalid saved batch");
+    }
+    const stored = await exportStoredReceipts();
+    receipts = pending.receiptIds.map((id) => {
+      const receipt = stored.find((item) => item.receiptId === id);
+      if (!receipt)
+        throw new Error("SETTLEMENT_JOURNAL_INVALID: saved receipt is missing");
+      return receipt;
+    });
   }
-  const receipts = eligible.slice(0, maxReceipts);
   const trustedCollectors = await trustedCollectorFingerprints();
-  for (const receipt of receipts) await verifyReceipt(receipt, trustedCollectors);
+  for (const receipt of receipts)
+    await verifyReceipt(receipt, trustedCollectors);
   const accounts = receipts.map((receipt) => receipt.wallet);
-  const amounts = receipts.map((receipt) => parseUnits(receipt.estimatedReward, 18));
+  const amounts = receipts.map(
+    (receipt) => parseUnits(receipt.estimatedReward, 18)
+  );
   const receiptIds = receipts.map((receipt) => receipt.receiptId);
   const coder = AbiCoder.defaultAbiCoder();
   const leaves = receipts.map((receipt, index) => {
-    const inner = keccak256(coder.encode(["address", "uint256", "bytes32"], [receipt.wallet, amounts[index], receipt.receiptId]));
+    const inner = keccak256(
+      coder.encode(
+        ["address", "uint256", "bytes32"],
+        [receipt.wallet, amounts[index], receipt.receiptId]
+      )
+    );
     return Buffer.from(getBytes(keccak256(concat([inner]))));
   });
   const tree = new MerkleTree(
@@ -13067,35 +14052,77 @@ async function settleRewards(maxReceipts = 25) {
   const proofs = leaves.map((leaf) => tree.getHexProof(leaf));
   const signer = await validatorWallet();
   const address = claimsAddress();
-  const claims = new Contract(address, claimsAbi, signer);
+  if ((await signer.provider.getNetwork()).chainId !== 8453n)
+    throw new Error("Settlement requires Base mainnet (8453)");
+  const claims = new Contract2(address, claimsAbi, signer);
   const configuredValidator = getAddress2(await claims.validator());
   if (configuredValidator !== signer.address) {
-    throw new Error(`Validator mismatch: contract expects ${configuredValidator}, server uses ${signer.address}`);
+    throw new Error(
+      `Validator mismatch: contract expects ${configuredValidator}, server uses ${signer.address}`
+    );
   }
   const tokenAddress = await claims.token();
-  const token = new Contract(tokenAddress, tokenAbi, signer.provider);
+  const token = new Contract2(tokenAddress, tokenAbi, signer.provider);
   if (getAddress2(await token.emissionController()) !== address) {
     throw new Error("AIPOUClaims is not the token emission controller");
   }
-  const publish = await claims.publishRoot(root);
-  const publishReceipt = await publish.wait();
-  let rootApproved = false;
-  for (let attempt = 0; attempt < 10 && !rootApproved; attempt += 1) {
-    rootApproved = await claims.approvedRoots(root);
-    if (!rootApproved) await new Promise((resolve) => setTimeout(resolve, 3e3));
-  }
-  if (!rootApproved) throw new Error("Published Merkle root was not visible through the RPC after 30 seconds");
-  const claim = await claims.claimBatch(root, accounts, amounts, receiptIds, proofs);
-  const claimReceipt = await claim.wait();
-  if (!publishReceipt || !claimReceipt) throw new Error("Settlement transaction receipt is unavailable");
+  const expected = {
+    version: 1,
+    chainId: 8453,
+    contract: address,
+    root,
+    accounts,
+    amounts: amounts.map(String),
+    receiptIds,
+    proofs
+  };
+  if (pending) {
+    const { publish: _publish, claim: _claim, ...saved } = pending;
+    if (canonicalJson(saved) !== canonicalJson(expected))
+      throw new Error(
+        "SETTLEMENT_JOURNAL_INVALID: batch does not match verified receipts and configured contract"
+      );
+  }
+  const plan = pending ?? expected;
+  for (const kind of ["publish", "claim"]) {
+    const saved = plan[kind];
+    if (!saved) continue;
+    const transaction = Transaction2.from(saved.raw);
+    const expectedData = kind === "publish" ? claims.interface.encodeFunctionData("publishRoot", [root]) : claims.interface.encodeFunctionData("claimBatch", [
+      root,
+      accounts,
+      amounts,
+      receiptIds,
+      proofs
+    ]);
+    if (transaction.hash !== saved.hash || transaction.from !== signer.address || transaction.chainId !== 8453n || transaction.to?.toLowerCase() !== address.toLowerCase() || transaction.value !== 0n || transaction.data !== expectedData) {
+      throw new Error(
+        "SETTLEMENT_JOURNAL_INVALID: saved transaction does not match the verified batch"
+      );
+    }
+  }
+  const persist = (value) => writePrivateJson(journalPath, value);
+  await persist(plan);
+  const transactions = await executeSettlementPlan(
+    plan,
+    createSettlementDriver(signer, address),
+    persist
+  );
+  const confirmations = await Promise.all(
+    receiptIds.map((id) => claims.claimedReceipts(id))
+  );
+  if (!confirmations.every(Boolean))
+    throw new Error(
+      "SETTLEMENT_CLAIMS_UNCONFIRMED: receipt flags are not visible; journal retained for reconciliation"
+    );
   const batch = {
     root,
     receiptIds,
-    publishTransaction: publishReceipt.hash,
-    claimTransaction: claimReceipt.hash,
+    ...transactions,
     settledAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await markBatchSettled(batch);
+  await rm2(journalPath, { force: true });
   return { ...batch, skippedReceipts: skipped };
 }
 async function settleAllRewards(batchSize = 100, maxBatches = 20) {
@@ -13110,7 +14137,8 @@ async function settleAllRewards(batchSize = 100, maxBatches = 20) {
         skippedByReceiptId.set(skipped.receiptId, skipped);
       }
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
+      const raw = error instanceof Error ? error.message : "Settlement failed";
+      const message = raw.startsWith("SETTLEMENT_") || raw === "There are no unsettled receipts" ? raw.slice(0, 400) : "SETTLEMENT_FAILED: inspect local diagnostics and saved settlement state before retrying; no private transaction payload is returned.";
       if (message === "There are no unsettled receipts") break;
       stoppedReason = message;
       break;
@@ -13124,10 +14152,13 @@ async function settleAllRewards(batchSize = 100, maxBatches = 20) {
   return {
     batches,
     batchCount: batches.length,
-    settledReceiptCount: batches.reduce((total, batch) => total + batch.receiptIds.length, 0),
+    settledReceiptCount: batches.reduce(
+      (total, batch) => total + batch.receiptIds.length,
+      0
+    ),
     skippedReceipts,
     pendingReceiptCount,
-    publishTransactions: batches.map((batch) => batch.publishTransaction),
+    publishTransactions: batches.map((batch) => batch.publishTransaction).filter(Boolean),
     claimTransactions: batches.map((batch) => batch.claimTransaction),
     stoppedReason,
     settledAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -13135,8 +14166,8 @@ async function settleAllRewards(batchSize = 100, maxBatches = 20) {
 }
 
 // src/contract.ts
-import { readFile as readFile5 } from "node:fs/promises";
-import path6 from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import path7 from "node:path";
 var DEFAULT_LOGO_URI = "https://raw.githubusercontent.com/0xddneto/AI-Proof-of-Us/main/assets/token/aipou.png";
 var aipouTokenAbi = [
   "function name() view returns (string)",
@@ -13155,9 +14186,9 @@ var aipouClaimsAbi = [
 ];
 async function configuredClaimsAddress() {
   if (process.env.AIPOU_CLAIMS_ADDRESS) return process.env.AIPOU_CLAIMS_ADDRESS;
-  const claimsPath = path6.resolve(process.env.AIPOU_CLAIMS_DEPLOYMENT_FILE || "deployments/base-claims.json");
+  const claimsPath = path7.resolve(process.env.AIPOU_CLAIMS_DEPLOYMENT_FILE || "deployments/base-claims.json");
   try {
-    const deployment = JSON.parse(await readFile5(claimsPath, "utf8"));
+    const deployment = JSON.parse(await readFile8(claimsPath, "utf8"));
     return deployment.address || null;
   } catch (error) {
     if (error.code === "ENOENT") return null;
@@ -13185,9 +14216,9 @@ function envConfig() {
   };
 }
 async function deploymentFileConfig() {
-  const deploymentPath = path6.resolve(process.env.AIPOU_DEPLOYMENT_FILE || "deployments/base.json");
+  const deploymentPath = path7.resolve(process.env.AIPOU_DEPLOYMENT_FILE || "deployments/base.json");
   try {
-    const deployment = JSON.parse(await readFile5(deploymentPath, "utf8"));
+    const deployment = JSON.parse(await readFile8(deploymentPath, "utf8"));
     const address = deployment.token?.address;
     if (!address) {
       return null;
@@ -13244,10 +14275,10 @@ async function getTokenContractConfig() {
 
 // src/demo.ts
 import { createHash as createHash3 } from "node:crypto";
-import { mkdtemp, rm as rm2 } from "node:fs/promises";
+import { mkdtemp, rm as rm3 } from "node:fs/promises";
 import os from "node:os";
-import path7 from "node:path";
-import { Wallet as Wallet3 } from "ethers";
+import path8 from "node:path";
+import { Wallet as Wallet4 } from "ethers";
 
 // src/rewards.ts
 var tierMultiplier = {
@@ -13272,12 +14303,20 @@ async function beginTask(input) {
 async function completeTask(input) {
   const session = await getSession(input.nonce);
   if (!session) throw new Error("Unknown task nonce");
-  if (session.completedAt) throw new Error("Task nonce has already been completed");
+  if (session.completedAt) throw new Error("Task nonce has already been completed; use export_ai_receipts and find this nonce to recover its stored receipt. Do not rerun the work or begin a new task to recover a lost response.");
+  if (isTaskSessionExpired(session)) throw new Error("Task session has expired; begin a new task instead of completing stale authority");
   if (!verifyTaskAuthorization(session)) throw new Error("Invalid EIP-712 wallet authorization");
+  if (input.tokenUsageMeasurement !== void 0 && !["measured", "unmeasured", "unspecified"].includes(input.tokenUsageMeasurement)) {
+    throw new Error("Unsupported tokenUsageMeasurement");
+  }
+  if (input.tokenUsageMeasurement === "unmeasured" && (input.inputTokens !== 0 || input.outputTokens !== 0)) {
+    throw new Error("Unmeasured token usage must use zero counts");
+  }
   const trustTier = await deriveTrustTier(session, input, input.providerEvidence);
   const recordedAt = (/* @__PURE__ */ new Date()).toISOString();
   const collectorPublicKey = await getCollectorPublicKey();
   const unsigned = {
+    tokenUsageMeasurement: input.tokenUsageMeasurement ?? "unspecified",
     nonce: session.nonce,
     wallet: session.wallet,
     provider: session.provider,
@@ -13330,8 +14369,8 @@ async function runLocalReceiptDemo() {
   const previousEnvironment = new Map(
     DEMO_ENVIRONMENT_KEYS.map((key) => [key, process.env[key]])
   );
-  const dataDir3 = await mkdtemp(path7.join(os.tmpdir(), "aipou-one-command-demo-"));
-  const wallet = Wallet3.createRandom();
+  const dataDir3 = await mkdtemp(path8.join(os.tmpdir(), "aipou-one-command-demo-"));
+  const wallet = Wallet4.createRandom();
   process.env.AIPOU_AGENT_PRIVATE_KEY = wallet.privateKey;
   process.env.AIPOU_CONTRACT_ADDRESS = TOKEN_ADDRESS;
   process.env.AIPOU_CLAIMS_ADDRESS = CLAIMS_ADDRESS;
@@ -13395,7 +14434,7 @@ async function runLocalReceiptDemo() {
       }
     };
   } finally {
-    await rm2(dataDir3, { recursive: true, force: true });
+    await rm3(dataDir3, { recursive: true, force: true });
     for (const key of DEMO_ENVIRONMENT_KEYS) {
       const previous = previousEnvironment.get(key);
       if (previous === void 0) delete process.env[key];
@@ -13404,25 +14443,92 @@ async function runLocalReceiptDemo() {
   }
 }
 
+// src/observed-outcome-pilot.ts
+import { mkdtemp as mkdtemp2, rm as rm4 } from "node:fs/promises";
+import os2 from "node:os";
+import path9 from "node:path";
+import { Wallet as Wallet5 } from "ethers";
+var CLAIMS_ADDRESS2 = "0x4ca4C98fB784D20EdC8E2A7F531dAab4c6e53058";
+var ENVIRONMENT_KEYS = ["AIPOU_AGENT_PRIVATE_KEY", "AIPOU_DATA_DIR"];
+async function runObservedOutcomePilot() {
+  const previous = new Map(ENVIRONMENT_KEYS.map((key) => [key, process.env[key]]));
+  const dataDir3 = await mkdtemp2(path9.join(os2.tmpdir(), "aipou-observed-outcome-pilot-"));
+  process.env.AIPOU_DATA_DIR = dataDir3;
+  process.env.AIPOU_AGENT_PRIVATE_KEY = Wallet5.createRandom().privateKey;
+  try {
+    const session = await beginTask({
+      provider: "local-pilot",
+      model: "observed-outcome-pilot",
+      client: "aipou-cli",
+      taskHash: sha256Hex(canonicalJson({ kind: "pilot", action: "bounded_local_execution" })),
+      chainId: 8453,
+      verifyingContract: CLAIMS_ADDRESS2
+    });
+    const receipt = await completeTask({
+      nonce: session.nonce,
+      inputTokens: 24,
+      outputTokens: 16,
+      durationSeconds: 1,
+      outputHash: sha256Hex(canonicalJson({ artifact: "pilot-output-reference", status: "host-observed" }))
+    });
+    const verification = verifyAipouReceipt(receipt);
+    if (!verification.valid) throw new Error(`Pilot receipt verification failed: ${verification.errors.join("; ")}`);
+    return {
+      mode: "observed_outcome_pilot",
+      storage: "removed_after_pilot",
+      workReceiptId: receipt.receiptId,
+      evidence: verification.evidence,
+      safety: {
+        networkRequired: false,
+        fundsMoved: false,
+        claimSubmitted: false,
+        deliveryClaimed: false,
+        acceptanceClaimed: false
+      }
+    };
+  } finally {
+    await rm4(dataDir3, { recursive: true, force: true });
+    for (const key of ENVIRONMENT_KEYS) {
+      const value = previous.get(key);
+      if (value === void 0) delete process.env[key];
+      else process.env[key] = value;
+    }
+  }
+}
+
 // src/doctor.ts
 import { constants } from "node:fs";
-import { access, readFile as readFile8, stat as stat2 } from "node:fs/promises";
-import os3 from "node:os";
-import path9 from "node:path";
-import { Wallet as Wallet5, isAddress as isAddress2 } from "ethers";
+import { access, readFile as readFile10, stat as stat2 } from "node:fs/promises";
+import os4 from "node:os";
+import path11 from "node:path";
+import { Wallet as Wallet7, isAddress as isAddress2 } from "ethers";
 
 // src/init.ts
-import { mkdir as mkdir3, readFile as readFile6, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
-import os2 from "node:os";
-import path8 from "node:path";
-import { Wallet as Wallet4 } from "ethers";
+import { mkdir as mkdir5, readFile as readFile9, rm as rm5, writeFile as writeFile3 } from "node:fs/promises";
+import os3 from "node:os";
+import path10 from "node:path";
+import { fileURLToPath } from "node:url";
+import { Wallet as Wallet6 } from "ethers";
 var AIPOU_TOKEN_ADDRESS = "0x55f0Cc5e51A1284D20337d6cbb18938C8A1ABCbB";
 var AIPOU_CLAIMS_ADDRESS = "0x4ca4C98fB784D20EdC8E2A7F531dAab4c6e53058";
 function identityPaths(dataDirInput) {
-  const dataDir3 = path8.resolve(dataDirInput || path8.join(os2.homedir(), ".aipou"));
-  return { dataDir: dataDir3, keyFile: path8.join(dataDir3, "agent-wallet.key") };
+  const dataDir3 = path10.resolve(dataDirInput || path10.join(os3.homedir(), ".aipou"));
+  return { dataDir: dataDir3, keyFile: path10.join(dataDir3, "agent-wallet.key") };
+}
+async function installationCommand(moduleUrl = import.meta.url) {
+  const directory = path10.dirname(fileURLToPath(moduleUrl));
+  try {
+    const workspace = JSON.parse(await readFile9(path10.resolve(directory, "../../package.json"), "utf8"));
+    if (workspace.name === "ai-proof-of-us" && workspace.workspaces?.includes("mcp-server")) {
+      return { command: process.execPath, args: [path10.join(directory, "index.js")] };
+    }
+  } catch {
+  }
+  const pkg = JSON.parse(await readFile9(path10.resolve(directory, "../package.json"), "utf8"));
+  return { command: "npx", args: ["-y", `aipou-mcp-server@${pkg.version}`] };
 }
-function buildResult(mode, walletAddress, dataDir3, keyFile) {
+async function buildResult(mode, walletAddress, dataDir3, keyFile) {
+  const launch = await installationCommand();
   return {
     mode,
     wallet: walletAddress,
@@ -13432,8 +14538,7 @@ function buildResult(mode, walletAddress, dataDir3, keyFile) {
     mcpConfig: {
       mcpServers: {
         aipou: {
-          command: "npx",
-          args: ["-y", "aipou-mcp-server"],
+          ...launch,
           env: {
             AIPOU_AGENT_KEY_FILE: keyFile,
             AIPOU_DATA_DIR: dataDir3,
@@ -13454,9 +14559,9 @@ function buildResult(mode, walletAddress, dataDir3, keyFile) {
 }
 async function initializePersistentIdentity(dataDirInput) {
   const { dataDir: dataDir3, keyFile } = identityPaths(dataDirInput);
-  const wallet = Wallet4.createRandom();
-  await mkdir3(dataDir3, { recursive: true, mode: 448 });
-  await writeFile4(keyFile, `${wallet.privateKey}
+  const wallet = Wallet6.createRandom();
+  await mkdir5(dataDir3, { recursive: true, mode: 448 });
+  await writeFile3(keyFile, `${wallet.privateKey}
 `, {
     encoding: "utf8",
     mode: 384,
@@ -13464,15 +14569,15 @@ async function initializePersistentIdentity(dataDirInput) {
   });
   const platformAccessRestricted = await restrictToCurrentUser(keyFile);
   if (!platformAccessRestricted) {
-    await rm3(keyFile, { force: true });
+    await rm5(keyFile, { force: true });
     throw new Error("Could not restrict dedicated-wallet key access to the current user");
   }
   return buildResult("persistent_identity_initialized", wallet.address, dataDir3, keyFile);
 }
 async function describeExistingIdentity(dataDirInput) {
   const { dataDir: dataDir3, keyFile } = identityPaths(dataDirInput);
-  const privateKey = (await readFile6(keyFile, "utf8")).trim();
-  const wallet = new Wallet4(privateKey);
+  const privateKey = (await readFile9(keyFile, "utf8")).trim();
+  const wallet = new Wallet6(privateKey);
   const platformAccessRestricted = await restrictToCurrentUser(keyFile);
   if (!platformAccessRestricted) {
     throw new Error("Existing dedicated-wallet key found, but its access could not be restricted to the current user");
@@ -13480,18 +14585,6 @@ async function describeExistingIdentity(dataDirInput) {
   return buildResult("persistent_identity_already_initialized", wallet.address, dataDir3, keyFile);
 }
 
-// src/version.ts
-import { readFile as readFile7 } from "node:fs/promises";
-var SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
-async function getPackageVersion() {
-  const packageUrl = new URL("../package.json", import.meta.url);
-  const metadata = JSON.parse(await readFile7(packageUrl, "utf8"));
-  if (typeof metadata.version !== "string" || !SEMVER.test(metadata.version)) {
-    throw new Error("mcp-server/package.json must contain a valid semantic version");
-  }
-  return metadata.version;
-}
-
 // src/doctor.ts
 function pass(detail) {
   return { status: "pass", detail };
@@ -13503,10 +14596,10 @@ function warning(detail) {
   return { status: "warning", detail };
 }
 async function runInstallationDoctor(dataDirInput) {
-  const dataDir3 = path9.resolve(dataDirInput || process.env.AIPOU_DATA_DIR || path9.join(os3.homedir(), ".aipou"));
+  const dataDir3 = path11.resolve(dataDirInput || process.env.AIPOU_DATA_DIR || path11.join(os4.homedir(), ".aipou"));
   const configuredKeyFile = dataDirInput ? void 0 : process.env.AIPOU_AGENT_KEY_FILE?.trim();
   const inlinePrivateKey = dataDirInput ? void 0 : process.env.AIPOU_AGENT_PRIVATE_KEY?.trim();
-  const keyFile = inlinePrivateKey ? null : path9.resolve(configuredKeyFile || path9.join(dataDir3, "agent-wallet.key"));
+  const keyFile = inlinePrivateKey ? null : path11.resolve(configuredKeyFile || path11.join(dataDir3, "agent-wallet.key"));
   const nodeMajor = Number(process.versions.node.split(".")[0]);
   const tokenAddress = process.env.AIPOU_CONTRACT_ADDRESS?.trim() || AIPOU_TOKEN_ADDRESS;
   const claimsAddress2 = process.env.AIPOU_CLAIMS_ADDRESS?.trim() || AIPOU_CLAIMS_ADDRESS;
@@ -13521,9 +14614,9 @@ async function runInstallationDoctor(dataDirInput) {
   let identity;
   let keySource;
   try {
-    const privateKey = inlinePrivateKey || (keyFile ? (await readFile8(keyFile, "utf8")).trim() : "");
+    const privateKey = inlinePrivateKey || (keyFile ? (await readFile10(keyFile, "utf8")).trim() : "");
     if (!privateKey) throw new Error("missing");
-    wallet = new Wallet5(privateKey).address;
+    wallet = new Wallet7(privateKey).address;
     keySource = inlinePrivateKey ? "inline_private_key" : "key_file";
     identity = inlinePrivateKey ? warning("Dedicated wallet key is valid, but a protected key file is safer than an inline environment variable.") : pass("Dedicated-wallet key file is readable and valid; its secret was not returned.");
   } catch {
@@ -13539,7 +14632,7 @@ async function runInstallationDoctor(dataDirInput) {
     try {
       const keyStat = await stat2(keyFile);
       if (process.platform === "win32") {
-        keyPermissions = warning("Key file exists; Windows ACLs were not changed or re-applied by this read-only diagnostic.");
+        keyPermissions = { status: "not_checked", detail: "Windows ACLs are not inspected by this read-only doctor. This is not a detected permission failure; init reports whether it successfully applied access restrictions." };
       } else if ((keyStat.mode & 63) === 0) {
         keyPermissions = pass("Key file has no group or other permission bits.");
       } else {
@@ -13594,8 +14687,103 @@ function buildReceiptResultMeta(receipt) {
   };
 }
 
+// src/paybox-link.ts
+var PAYBOX_OPERATION_SCHEME = "paybox-operation-v1";
+var EXTERNAL_EVIDENCE_LINK_SCHEME = "external-evidence-link-v1";
+var receiptIdPattern = /^0x[0-9a-f]{64}$/;
+var sha256Pattern = /^sha256:[0-9a-f]{64}$/;
+function assertValidInput(input) {
+  if (!receiptIdPattern.test(input.workReceiptId)) {
+    throw new Error("workReceiptId must be a lowercase 0x-prefixed SHA-256 identifier");
+  }
+  if (!sha256Pattern.test(input.payboxOperationDigest)) {
+    throw new Error("payboxOperationDigest must be a lowercase sha256 digest");
+  }
+  if (input.payboxOperationId.length < 1 || input.payboxOperationId.length > 256) {
+    throw new Error("payboxOperationId must be an opaque reference between 1 and 256 characters");
+  }
+  if (!Number.isFinite(Date.parse(input.issuedAt))) {
+    throw new Error("issuedAt must be an ISO-8601 timestamp");
+  }
+}
+function createPayboxWorkLink(input) {
+  assertValidInput(input);
+  const identity = {
+    scheme: EXTERNAL_EVIDENCE_LINK_SCHEME,
+    relation: "supports",
+    source: {
+      kind: "receipt",
+      scheme: "aipou-receipt-v1",
+      id: input.workReceiptId,
+      digest: `sha256:${input.workReceiptId.slice(2)}`
+    },
+    target: {
+      kind: "payment-operation",
+      scheme: PAYBOX_OPERATION_SCHEME,
+      id: input.payboxOperationId,
+      digest: input.payboxOperationDigest
+    },
+    privacy: "digest_only"
+  };
+  const payload = {
+    ...identity,
+    issuedAt: input.issuedAt
+  };
+  return {
+    ...payload,
+    linkId: `sha256:${sha256Hex(canonicalJson(identity)).slice(2)}`,
+    linkDigest: `sha256:${sha256Hex(canonicalJson(payload)).slice(2)}`
+  };
+}
+
+// src/technocore-link.ts
+var TECHNOCORE_TRANSPORT_SCHEME = "technocore-room-receipt-v1";
+var EXTERNAL_EVIDENCE_LINK_SCHEME2 = "external-evidence-link-v1";
+var receiptIdPattern2 = /^0x[0-9a-f]{64}$/;
+var sha256Pattern2 = /^sha256:[0-9a-f]{64}$/;
+function assertValidInput2(input) {
+  if (!receiptIdPattern2.test(input.workReceiptId)) {
+    throw new Error("workReceiptId must be a lowercase 0x-prefixed SHA-256 identifier");
+  }
+  if (!sha256Pattern2.test(input.transportArtifactDigest)) {
+    throw new Error("transportArtifactDigest must be a lowercase sha256 digest");
+  }
+  if (input.transportArtifactId.length < 1 || input.transportArtifactId.length > 256) {
+    throw new Error("transportArtifactId must be an opaque reference between 1 and 256 characters");
+  }
+  if (!Number.isFinite(Date.parse(input.issuedAt))) {
+    throw new Error("issuedAt must be an ISO-8601 timestamp");
+  }
+}
+function createTechnocoreWorkLink(input) {
+  assertValidInput2(input);
+  const identity = {
+    scheme: EXTERNAL_EVIDENCE_LINK_SCHEME2,
+    relation: "supports",
+    source: {
+      kind: "receipt",
+      scheme: "aipou-receipt-v1",
+      id: input.workReceiptId,
+      digest: `sha256:${input.workReceiptId.slice(2)}`
+    },
+    target: {
+      kind: "transport-record",
+      scheme: TECHNOCORE_TRANSPORT_SCHEME,
+      id: input.transportArtifactId,
+      digest: input.transportArtifactDigest
+    },
+    privacy: "digest_only"
+  };
+  const payload = { ...identity, issuedAt: input.issuedAt };
+  return {
+    ...payload,
+    linkId: `sha256:${sha256Hex(canonicalJson(identity)).slice(2)}`,
+    linkDigest: `sha256:${sha256Hex(canonicalJson(payload)).slice(2)}`
+  };
+}
+
 // src/status.ts
-import { Contract as Contract2, JsonRpcProvider as JsonRpcProvider2, formatUnits } from "ethers";
+import { Contract as Contract3, JsonRpcProvider as JsonRpcProvider3, formatUnits } from "ethers";
 function sumRewards(receipts) {
   const total = receipts.reduce((sum, receipt) => sum + Number(receipt.estimatedReward), 0);
   return Number.isInteger(total) ? total.toFixed(0) : total.toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
@@ -13611,8 +14799,8 @@ async function getAipouStatus() {
   let onchain = { available: false };
   if (contract.address) {
     try {
-      const provider = new JsonRpcProvider2(contract.rpcUrl);
-      const token = new Contract2(contract.address, aipouTokenAbi, provider);
+      const provider = new JsonRpcProvider3(contract.rpcUrl);
+      const token = new Contract3(contract.address, aipouTokenAbi, provider);
       const [decimals, balance, totalSupply] = await Promise.all([
         token.decimals(),
         token.balanceOf(wallet),
@@ -13643,6 +14831,8 @@ async function getAipouStatus() {
       claimed: claimedReceipts.length,
       pending: walletPendingReceipts.length,
       incompleteSessions: counts.incompleteSessions,
+      activeSessions: counts.activeSessions,
+      expiredSessions: counts.expiredSessions,
       batches: counts.batches
     },
     rewards: {
@@ -13664,9 +14854,9 @@ async function getAipouStatus() {
 // src/index.ts
 var bytes32 = z2.string().regex(/^0x[a-fA-F0-9]{64}$/);
 var usageCounts = {
-  inputTokens: z2.number().int().min(0).max(1e7),
-  outputTokens: z2.number().int().min(0).max(1e7),
-  durationSeconds: z2.number().int().min(0).max(86400)
+  inputTokens: z2.number().int().min(0).max(1e7).describe("Non-negative input-token count for this task, capped at 10,000,000."),
+  outputTokens: z2.number().int().min(0).max(1e7).describe("Non-negative output-token count for this task, capped at 10,000,000."),
+  durationSeconds: z2.number().int().min(0).max(86400).describe("Task duration in whole seconds from 0 through 86,400.")
 };
 var server = new McpServer(
   { name: "aipou-mcp", version: await getPackageVersion() },
@@ -13676,8 +14866,14 @@ var server = new McpServer(
 );
 server.tool(
   "get_aipou_contract",
-  "Return the configured AIPOU token contract address, Base network details, explorer URL, and minimal ABI.",
+  "Read the configured AIPOU token and claims contract details for display or client setup. Returns Base chain metadata, explorer URLs, and minimal ABIs; it does not contact a wallet, submit a transaction, or change local state.",
   {},
+  {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
   async () => {
     const contract = await getTokenContractConfig();
     return {
@@ -13687,8 +14883,14 @@ server.tool(
 );
 server.tool(
   "get_aipou_identity",
-  "Return the dedicated farming wallet address and public Ed25519 collector key. Private keys are never returned.",
+  "Read the public identity used by this MCP installation when a client needs to display or verify its farming wallet and collector. Returns the wallet address, Ed25519 public key, and fingerprint; it never returns private keys, submits transactions, or changes state.",
   {},
+  {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
   async () => {
     const wallet = agentWallet();
     const collectorPublicKey = await getCollectorPublicKey();
@@ -13702,8 +14904,14 @@ server.tool(
 );
 server.tool(
   "get_aipou_status",
-  "Show recorded, pending, and already claimed AIPOU receipts plus the farming wallet's on-chain AIPOU balance. Does not reveal private keys or full receipt payloads.",
+  "Use this first when the user asks for pending, claimed, or wallet-balance information; use a settlement tool only after an explicit claim request. Returns a read-only JSON summary of receipt counts, estimated pending AIPOU, prior settlement state, and the farming wallet's on-chain AIPOU balance. It may read Base through the configured RPC, but it never signs or submits a transaction, changes receipts, reveals private keys, or returns full receipt payloads.",
   {},
+  {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
   async () => {
     const status = await getAipouStatus();
     return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
@@ -13711,8 +14919,14 @@ server.tool(
 );
 server.tool(
   "estimate_ai_reward",
-  "Estimate the client-signed AIPOU reward before a task is completed. The final tier is derived by the validator.",
+  "Use before complete_ai_task only when a preview is useful. Provide non-negative inputTokens, outputTokens, and durationSeconds for one task; it returns JSON with estimatedReward and unit for a client-signed estimate. It creates no task or receipt, changes no state, and submits no transaction. The result is informational: complete_ai_task derives the receipt evidence, and the validator determines final eligibility and trust tier.",
   usageCounts,
+  {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
   async (input) => ({
     content: [{
       type: "text",
@@ -13722,12 +14936,18 @@ server.tool(
 );
 server.tool(
   "begin_ai_task",
-  "Create a unique task nonce and EIP-712 authorization signed by the dedicated farming wallet.",
+  "Use once before meaningful AI work to create a task session. Provide the provider, model, client, and a 32-byte hash of the task description; returns a unique nonce and EIP-712 authorization signed by the dedicated farming wallet. This writes a pending local task session but does not publish, mint, or submit an on-chain transaction. Pass the returned nonce to complete_ai_task; do not reuse it for another task.",
+  {
+    provider: z2.string().min(1).max(64).describe("AI provider name for this task session, from 1 through 64 characters."),
+    model: z2.string().min(1).max(128).describe("Provider model identifier used for this task, from 1 through 128 characters."),
+    taskHash: bytes32.describe("32-byte hash of the task description; never send the raw prompt or task text."),
+    client: z2.string().min(1).max(64).describe("Host client or agent identifier that starts this task session, from 1 through 64 characters.")
+  },
   {
-    provider: z2.string().min(1).max(64),
-    model: z2.string().min(1).max(128),
-    taskHash: bytes32,
-    client: z2.string().min(1).max(64)
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
   },
   async (input) => {
     const contract = await getTokenContractConfig();
@@ -13743,15 +14963,22 @@ server.tool(
 );
 server.tool(
   "complete_ai_task",
-  "Complete a unique task, derive its trust tier, reject duplicate evidence, and create an Ed25519-signed receipt.",
+  "Use exactly once after begin_ai_task finishes meaningful work. Supply that session's nonce, non-negative inputTokens and outputTokens, whole-second durationSeconds, and a 32-byte outputHash; providerEvidence is optional and only for a configured provider key. It validates the nonce and bounded usage, derives the evidence tier, rejects replay, then writes the local receipt store and returns an Ed25519-signed receipt plus compact workReceiptId metadata. It does not publish a Merkle root, mint tokens, or submit a blockchain transaction. Use get_aipou_status to inspect recorded work; repeating a nonce or evidence fails closed instead of creating another receipt.",
   {
-    nonce: bytes32,
+    nonce: bytes32.describe("Unique 32-byte nonce returned by begin_ai_task for this exact task."),
     ...usageCounts,
-    outputHash: bytes32,
+    tokenUsageMeasurement: z2.enum(["measured", "unmeasured", "unspecified"]).describe("Whether token counts were measured. Use unmeasured with zero counts when usage is unavailable; omitted means unspecified, including legacy clients.").optional(),
+    outputHash: bytes32.describe("SHA-256-style 32-byte hash of the task output; never send the raw output."),
     providerEvidence: z2.object({
-      keyId: z2.string().min(1).max(128),
-      signature: z2.string().min(32)
-    }).optional()
+      keyId: z2.string().min(1).max(128).describe("Configured provider-verification key identifier, between 1 and 128 characters."),
+      signature: z2.string().min(32).describe("Provider signature over the canonical evidence payload; invalid evidence fails closed.")
+    }).describe("Optional provider-signed evidence. Omit it for a client-signed receipt.").optional()
+  },
+  {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
   },
   async (input) => {
     const receipt = await completeTask(input);
@@ -13763,17 +14990,87 @@ server.tool(
 );
 server.tool(
   "export_ai_receipts",
-  "Export stored signed AI task receipts, optionally filtered by wallet.",
-  { wallet: z2.string().regex(/^0x[a-fA-F0-9]{40}$/).optional() },
+  "Export signed receipts already stored in this MCP installation, optionally limited to one farming wallet address. Returns JSON with count and receipt payloads, so use it only where local receipt data is appropriate to expose. It does not create a receipt, validate a claim, contact Base, or submit a transaction; use get_aipou_status instead for a compact private summary.",
+  {
+    wallet: z2.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Optional 20-byte farming wallet address filter. Omit it to export every locally stored receipt.").optional()
+  },
+  {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
   async ({ wallet }) => {
     const receipts = await exportReceipts(wallet);
     return { content: [{ type: "text", text: JSON.stringify({ count: receipts.length, receipts }, null, 2) }] };
   }
 );
+server.tool(
+  "verify_aipou_receipt",
+  "Verify the self-contained integrity, wallet authorization, and collector signature of one supplied AIPOU receipt. Returns separately typed evidence states; it does not trust a collector, query a registry, submit a claim, prove delivery, business acceptance, settlement, or external effect.",
+  {
+    receipt: z2.record(z2.string(), z2.unknown()).describe("A receipt object containing hashes and signatures only. Do not include raw prompts, outputs, private keys, or customer data.")
+  },
+  {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  async ({ receipt }) => ({
+    content: [{ type: "text", text: JSON.stringify(verifyAipouReceipt(receipt), null, 2) }]
+  })
+);
+server.tool(
+  "create_paybox_work_link",
+  "Derive and return a digest-only external evidence link between an existing AIPOU workReceiptId and an opaque Paybox operation artifact. It is a pure local calculation: it does not persist the link, call Paybox, unlock a wallet, create a payment, sign a transaction, or change AIPOU claim eligibility. Use it for portable correlation only, and verify both artifacts with their native systems before relying on the returned link.",
+  {
+    workReceiptId: z2.string().regex(/^0x[a-f0-9]{64}$/).describe("Existing lowercase AIPOU workReceiptId."),
+    payboxOperationId: z2.string().min(1).max(256).describe("Opaque Paybox operation reference. Never send a credential, wallet address, payment token, or secret."),
+    payboxOperationDigest: z2.string().regex(/^sha256:[a-f0-9]{64}$/).describe("Lowercase SHA-256 digest of the Paybox operation artifact bytes."),
+    issuedAt: z2.string().datetime().describe("ISO-8601 time at which this correlation artifact is issued.")
+  },
+  {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  async (input) => ({
+    content: [{ type: "text", text: JSON.stringify(createPayboxWorkLink(input), null, 2) }]
+  })
+);
+server.tool(
+  "create_technocore_work_link",
+  "Derive and return a digest-only external evidence link between an existing AIPOU workReceiptId and a Technocore transport artifact. It is a pure local calculation: it does not persist the link, call Technocore, sign a message, read a key, verify a transport signature, change AIPOU claim eligibility, or establish delivery. Use it for portable correlation only, and verify the Technocore artifact with its native verifier before relying on the returned link.",
+  {
+    workReceiptId: z2.string().regex(/^0x[a-f0-9]{64}$/).describe("Existing lowercase AIPOU workReceiptId."),
+    transportArtifactId: z2.string().min(1).max(256).describe("Opaque Technocore transport artifact reference. Never send a DID private key, seed, passphrase, wallet, or secret."),
+    transportArtifactDigest: z2.string().regex(/^sha256:[a-f0-9]{64}$/).describe("Lowercase SHA-256 digest of the canonical Technocore transport artifact bytes."),
+    issuedAt: z2.string().datetime().describe("ISO-8601 time at which this correlation artifact is issued.")
+  },
+  {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  async (input) => ({
+    content: [{ type: "text", text: JSON.stringify(createTechnocoreWorkLink(input), null, 2) }]
+  })
+);
 server.tool(
   "settle_ai_rewards",
-  "After an explicit user claim request for one limited batch, validate eligible receipts against the settlement policy, publish a Merkle root, and mint the included rewards. Submits two on-chain transactions; the host's own confirmation policy applies.",
-  { maxReceipts: z2.number().int().min(1).max(100).default(25) },
+  "Use only after an explicit user request to claim one limited batch, not for status or reward previews. maxReceipts defaults to 25 and is capped at 100; the tool validates eligible local receipts against settlement policy, publishes one Merkle root, and mints the included rewards. It submits two Base transactions, so the host client and user must apply their own confirmation policy. Use settle_all_ai_rewards instead for an explicit request to claim all pending eligible receipts.",
+  {
+    maxReceipts: z2.number().int().min(1).max(100).default(25).describe("Maximum eligible receipts to include in this one settlement batch, from 1 through 100; defaults to 25.")
+  },
+  {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
+  },
   async ({ maxReceipts }) => {
     const batch = await settleRewards(maxReceipts);
     return { content: [{ type: "text", text: JSON.stringify(batch, null, 2) }] };
@@ -13781,10 +15078,16 @@ server.tool(
 );
 server.tool(
   "settle_all_ai_rewards",
-  "After an explicit broad claim request, settle all currently pending eligible receipts from the shared AIPOU data directory by submitting as many bounded batches as needed. Each batch publishes one Merkle root and submits one claim transaction.",
+  "Use only after an explicit broad request such as 'claim my AIPOU' or 'settle all pending AIPOU'; do not use it for a status check. batchSize defaults to 100 and maxBatches to 20, with bounds of 1-100 and 1-50, so large queues remain bounded. It validates all currently eligible local receipts and submits Base transactions for each batch: one Merkle-root publication and one claim transaction per batch. The host client and user must apply their own confirmation policy; use settle_ai_rewards when the user asks for one limited batch.",
+  {
+    batchSize: z2.number().int().min(1).max(100).default(100).describe("Eligible receipts per settlement batch, from 1 through 100; defaults to 100."),
+    maxBatches: z2.number().int().min(1).max(50).default(20).describe("Maximum settlement batches to submit in this call, from 1 through 50; defaults to 20.")
+  },
   {
-    batchSize: z2.number().int().min(1).max(100).default(100),
-    maxBatches: z2.number().int().min(1).max(50).default(20)
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: true
   },
   async ({ batchSize, maxBatches }) => {
     const result = await settleAllRewards(batchSize, maxBatches);
@@ -13803,6 +15106,10 @@ function cliValue(name) {
 }
 if (cliArguments.has("--demo")) {
   console.log(JSON.stringify(await runLocalReceiptDemo(), null, 2));
+} else if (cliArguments.has("--pilot")) {
+  console.log(JSON.stringify(await runObservedOutcomePilot(), null, 2));
+} else if (cliArguments.has("--feedback")) {
+  console.log(JSON.stringify(await localFeedbackSummary(), null, 2));
 } else if (cliArguments.has("--doctor")) {
   const result = await runInstallationDoctor(cliValue("--data-dir"));
   console.log(JSON.stringify(result, null, 2));
@@ -13825,10 +15132,12 @@ if (cliArguments.has("--demo")) {
 Usage:
   aipou-mcp                 Start the MCP stdio server
   aipou-mcp --demo          Create and verify one disposable local receipt
+  aipou-mcp --pilot         Rehearse a bounded lifecycle and report typed evidence states
   aipou-mcp --init          Create a protected persistent farming identity
   aipou-mcp --init --data-dir <path>
                             Initialize in a specific directory
   aipou-mcp --doctor        Validate a persistent installation without changes
+  aipou-mcp --feedback      Print local usage counts without identifiers or uploads
   aipou-mcp --doctor --data-dir <path>
                             Diagnose a specific identity directory
   aipou-mcp --help          Show this help
@@ -13838,8 +15147,18 @@ wallet, collector key, and receipt state are removed before the command exits.
 Init writes a new dedicated-wallet key with restricted access and never prints
 the secret. Re-running init reports the existing identity instead of
 overwriting it. Doctor reads configuration without writing files, making
-network requests, moving funds, or submitting claims.`);
+network requests, moving funds, or submitting claims. The pilot is also
+offline and disposable: it does not claim delivery, acceptance, settlement,
+or external effect.`);
 } else {
-  const transport = new StdioServerTransport();
+  const input = new BoundedStdioInput();
+  input.on("error", () => {
+    console.error("AIPOU_INPUT_TOO_LARGE: input connection closed; limit each JSON-RPC message to 1 MiB.");
+    process.exitCode = 1;
+    void server.close();
+    process.stdin.destroy();
+  });
+  process.stdin.pipe(input);
+  const transport = new StdioServerTransport(input, process.stdout);
   await server.connect(transport);
 }