@tansr/serve 0.6.0 → 0.6.1

package/dist/index.js

@@ -227,9 +227,9 @@ var require_timers = __commonJS({
        * before the specified function or code is executed.
        * @param {*} arg
        */
-      constructor(callback, delay, arg) {
+      constructor(callback, delay2, arg) {
         this._onTimeout = callback;
-        this._idleTimeout = delay;
+        this._idleTimeout = delay2;
         this._timerArg = arg;
         this.refresh();
       }
@@ -274,8 +274,8 @@ var require_timers = __commonJS({
        * when the timer expires.
        * @returns {NodeJS.Timeout|FastTimer}
        */
-      setTimeout(callback, delay, arg) {
-        return delay <= RESOLUTION_MS ? setTimeout(callback, delay, arg) : new FastTimer(callback, delay, arg);
+      setTimeout(callback, delay2, arg) {
+        return delay2 <= RESOLUTION_MS ? setTimeout(callback, delay2, arg) : new FastTimer(callback, delay2, arg);
       },
       /**
        * The clearTimeout method cancels an instantiated Timer previously created
@@ -301,8 +301,8 @@ var require_timers = __commonJS({
        * when the timer expires.
        * @returns {FastTimer}
        */
-      setFastTimeout(callback, delay, arg) {
-        return new FastTimer(callback, delay, arg);
+      setFastTimeout(callback, delay2, arg) {
+        return new FastTimer(callback, delay2, arg);
       },
       /**
        * The clearTimeout method cancels an instantiated FastTimer previously
@@ -328,8 +328,8 @@ var require_timers = __commonJS({
        * @deprecated
        * @param {number} [delay=0] The delay in milliseconds to add to the now value.
        */
-      tick(delay = 0) {
-        fastNow += delay - RESOLUTION_MS + 1;
+      tick(delay2 = 0) {
+        fastNow += delay2 - RESOLUTION_MS + 1;
         onTick();
         onTick();
       },
@@ -1151,14 +1151,14 @@ var require_util = __commonJS({
         }
         const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
         let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`;
-        let path17 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
+        let path18 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
         if (origin[origin.length - 1] === "/") {
           origin = origin.slice(0, origin.length - 1);
         }
-        if (path17 && path17[0] !== "/") {
-          path17 = `/${path17}`;
+        if (path18 && path18[0] !== "/") {
+          path18 = `/${path18}`;
         }
-        return new URL(`${origin}${path17}`);
+        return new URL(`${origin}${path18}`);
       }
       if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
         throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
@@ -2029,9 +2029,9 @@ var require_diagnostics = __commonJS({
         "undici:client:sendHeaders",
         (evt) => {
           const {
-            request: { method, path: path17, origin }
+            request: { method, path: path18, origin }
           } = evt;
-          debugLog("sending request to %s %s%s", method, origin, path17);
+          debugLog("sending request to %s %s%s", method, origin, path18);
         }
       );
     }
@@ -2049,14 +2049,14 @@ var require_diagnostics = __commonJS({
         "undici:request:headers",
         (evt) => {
           const {
-            request: { method, path: path17, origin },
+            request: { method, path: path18, origin },
             response: { statusCode }
           } = evt;
           debugLog(
             "received response to %s %s%s - HTTP %d",
             method,
             origin,
-            path17,
+            path18,
             statusCode
           );
         }
@@ -2065,23 +2065,23 @@ var require_diagnostics = __commonJS({
         "undici:request:trailers",
         (evt) => {
           const {
-            request: { method, path: path17, origin }
+            request: { method, path: path18, origin }
           } = evt;
-          debugLog("trailers received from %s %s%s", method, origin, path17);
+          debugLog("trailers received from %s %s%s", method, origin, path18);
         }
       );
       diagnosticsChannel.subscribe(
         "undici:request:error",
         (evt) => {
           const {
-            request: { method, path: path17, origin },
+            request: { method, path: path18, origin },
             error
           } = evt;
           debugLog(
             "request to %s %s%s errored - %s",
             method,
             origin,
-            path17,
+            path18,
             error.message
           );
         }
@@ -2236,7 +2236,7 @@ var require_request = __commonJS({
     };
     var Request2 = class {
       constructor(origin, {
-        path: path17,
+        path: path18,
         method,
         body,
         headers,
@@ -2253,11 +2253,11 @@ var require_request = __commonJS({
         maxRedirections,
         typeOfService
       }, handler) {
-        if (typeof path17 !== "string") {
+        if (typeof path18 !== "string") {
           throw new InvalidArgumentError("path must be a string");
-        } else if (path17[0] !== "/" && !(path17.startsWith("http://") || path17.startsWith("https://")) && method !== "CONNECT") {
+        } else if (path18[0] !== "/" && !(path18.startsWith("http://") || path18.startsWith("https://")) && method !== "CONNECT") {
           throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.test(path17)) {
+        } else if (invalidPathRegex.test(path18)) {
           throw new InvalidArgumentError("invalid request path");
         }
         if (typeof method !== "string") {
@@ -2332,7 +2332,7 @@ var require_request = __commonJS({
         this.completed = false;
         this.aborted = false;
         this.upgrade = upgrade || null;
-        this.path = query2 ? serializePathWithQuery(path17, query2) : path17;
+        this.path = query2 ? serializePathWithQuery(path18, query2) : path18;
         this.origin = origin;
         this.protocol = getProtocolFromUrlString(origin);
         this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" || method === "QUERY" : idempotent;
@@ -4886,7 +4886,7 @@ var require_webidl = __commonJS({
 var require_util2 = __commonJS({
   "../../node_modules/.pnpm/undici@8.10.0/node_modules/undici/lib/web/fetch/util.js"(exports, module) {
     "use strict";
-    var { Transform: Transform2 } = __require("node:stream");
+    var { Transform: Transform3 } = __require("node:stream");
     var zlib2 = __require("node:zlib");
     var { redirectStatusSet, referrerPolicyTokens, badPortsSet } = require_constants3();
     var { getGlobalOrigin } = require_global();
@@ -5477,7 +5477,7 @@ var require_util2 = __commonJS({
       contentRange += isomorphicEncode(`${fullLength}`);
       return contentRange;
     }
-    var InflateStream = class extends Transform2 {
+    var InflateStream = class extends Transform3 {
       #zlibOptions;
       /** @param {zlib.ZlibOptions} [zlibOptions] */
       constructor(zlibOptions) {
@@ -6741,21 +6741,21 @@ var require_client_h1 = __commonJS({
         this.connectionKeepAlive = false;
         this.maxResponseSize = client[kMaxResponseSize];
       }
-      setTimeout(delay, type) {
-        if (delay !== this.timeoutValue || type & USE_FAST_TIMER ^ this.timeoutType & USE_FAST_TIMER) {
+      setTimeout(delay2, type) {
+        if (delay2 !== this.timeoutValue || type & USE_FAST_TIMER ^ this.timeoutType & USE_FAST_TIMER) {
           if (this.timeout) {
             timers.clearTimeout(this.timeout);
             this.timeout = null;
           }
-          if (delay) {
+          if (delay2) {
             if (type & USE_FAST_TIMER) {
-              this.timeout = timers.setFastTimeout(onParserTimeout, delay, this.timeoutWeakRef);
+              this.timeout = timers.setFastTimeout(onParserTimeout, delay2, this.timeoutWeakRef);
             } else {
-              this.timeout = setTimeout(onParserTimeout, delay, this.timeoutWeakRef);
+              this.timeout = setTimeout(onParserTimeout, delay2, this.timeoutWeakRef);
               this.timeout?.unref();
             }
           }
-          this.timeoutValue = delay;
+          this.timeoutValue = delay2;
         } else if (this.timeout) {
           if (this.timeout.refresh) {
             this.timeout.refresh();
@@ -7418,7 +7418,7 @@ var require_client_h1 = __commonJS({
       }
     }
     function writeH1(client, request) {
-      const { method, path: path17, host, upgrade, blocking, reset } = request;
+      const { method, path: path18, host, upgrade, blocking, reset } = request;
       let { body, headers, contentLength } = request;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       if (util.isFormDataLike(body)) {
@@ -7494,7 +7494,7 @@ var require_client_h1 = __commonJS({
         socket[kBlocking] = true;
       }
       setTypeOfService(socket, request);
-      let header = `${method} ${path17} HTTP/1.1\r
+      let header = `${method} ${path18} HTTP/1.1\r
 `;
       if (typeof host === "string") {
         header += `host: ${host}\r
@@ -7844,7 +7844,7 @@ var require_client_h2 = __commonJS({
   "../../node_modules/.pnpm/undici@8.10.0/node_modules/undici/lib/dispatcher/client-h2.js"(exports, module) {
     "use strict";
     var assert = __require("node:assert");
-    var { pipeline: pipeline2 } = __require("node:stream");
+    var { pipeline: pipeline3 } = __require("node:stream");
     var util = require_util();
     var {
       RequestContentLengthMismatchError,
@@ -8575,7 +8575,7 @@ var require_client_h2 = __commonJS({
       const headersTimeout = request.headersTimeout ?? client[kHeadersTimeout];
       const bodyTimeout = request.bodyTimeout ?? client[kBodyTimeout];
       const session = client[kHTTP2Session];
-      const { method, path: path17, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request;
+      const { method, path: path18, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request;
       if (upgrade != null && upgrade !== "websocket") {
         util.errorRequest(client, request, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
         return false;
@@ -8638,7 +8638,7 @@ var require_client_h2 = __commonJS({
           }
           headers[HTTP2_HEADER_METHOD] = "CONNECT";
           headers[HTTP2_HEADER_PROTOCOL] = "websocket";
-          headers[HTTP2_HEADER_PATH] = path17;
+          headers[HTTP2_HEADER_PATH] = path18;
           if (protocol === "ws:" || protocol === "wss:") {
             headers[HTTP2_HEADER_SCHEME] = protocol === "ws:" ? "http" : "https";
           } else {
@@ -8660,7 +8660,7 @@ var require_client_h2 = __commonJS({
         setupUpgradeStream(stream, state);
         return true;
       }
-      headers[HTTP2_HEADER_PATH] = path17;
+      headers[HTTP2_HEADER_PATH] = path18;
       headers[HTTP2_HEADER_SCHEME] = protocol === "http:" ? "http" : "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       let body = state.body;
@@ -8991,7 +8991,7 @@ var require_client_h2 = __commonJS({
     }
     function writeStream(abort, socket, expectsPayload, h2stream, body, client, request, contentLength) {
       assert(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
-      const pipe = pipeline2(
+      const pipe = pipeline3(
         body,
         h2stream,
         (err) => {
@@ -11330,10 +11330,10 @@ var require_proxy_agent = __commonJS({
         };
         const {
           origin,
-          path: path17 = "/",
+          path: path18 = "/",
           headers = {}
         } = opts;
-        opts.path = origin + path17;
+        opts.path = origin + path18;
         if (!("host" in headers) && !("Host" in headers)) {
           const { host } = new URL(origin);
           headers.host = host;
@@ -13210,7 +13210,7 @@ var require_api_pipeline = __commonJS({
         util.destroy(ret, err);
       }
     };
-    function pipeline2(opts, handler) {
+    function pipeline3(opts, handler) {
       try {
         const pipelineHandler = new PipelineHandler(opts, handler);
         this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler);
@@ -13219,7 +13219,7 @@ var require_api_pipeline = __commonJS({
         return new PassThrough().destroy(err);
       }
     }
-    module.exports = pipeline2;
+    module.exports = pipeline3;
   }
 });
 
@@ -13598,20 +13598,20 @@ var require_mock_utils = __commonJS({
       }
       return normalizedQp;
     }
-    function safeUrl(path17) {
-      if (typeof path17 !== "string") {
-        return path17;
+    function safeUrl(path18) {
+      if (typeof path18 !== "string") {
+        return path18;
       }
-      const pathSegments = path17.split("?", 3);
+      const pathSegments = path18.split("?", 3);
       if (pathSegments.length !== 2) {
-        return path17;
+        return path18;
       }
       const qp = new URLSearchParams(pathSegments.pop());
       qp.sort();
       return [...pathSegments, qp.toString()].join("?");
     }
-    function matchKey(mockDispatch2, { path: path17, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path17);
+    function matchKey(mockDispatch2, { path: path18, method, body, headers }) {
+      const pathMatch = matchValue(mockDispatch2.path, path18);
       const methodMatch = matchValue(mockDispatch2.method, method);
       const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
       const headersMatch = matchHeaders(mockDispatch2, headers);
@@ -13638,8 +13638,8 @@ var require_mock_utils = __commonJS({
       const basePath = key2.query ? serializePathWithQuery(key2.path, key2.query) : key2.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
       const resolvedPathWithoutTrailingSlash = removeTrailingSlash(resolvedPath);
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path17, ignoreTrailingSlash }) => {
-        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path17)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path17), resolvedPath);
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path18, ignoreTrailingSlash }) => {
+        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path18)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path18), resolvedPath);
       });
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
@@ -13678,22 +13678,22 @@ var require_mock_utils = __commonJS({
         mockDispatches.splice(index, 1);
       }
     }
-    function removeTrailingSlash(path17) {
-      if (typeof path17 !== "string") {
-        return path17;
+    function removeTrailingSlash(path18) {
+      if (typeof path18 !== "string") {
+        return path18;
       }
-      while (path17.endsWith("/")) {
-        path17 = path17.slice(0, -1);
+      while (path18.endsWith("/")) {
+        path18 = path18.slice(0, -1);
       }
-      if (path17.length === 0) {
-        path17 = "/";
+      if (path18.length === 0) {
+        path18 = "/";
       }
-      return path17;
+      return path18;
     }
     function buildKey(opts) {
-      const { path: path17, method, body, headers, query: query2 } = opts;
+      const { path: path18, method, body, headers, query: query2 } = opts;
       return {
-        path: path17,
+        path: path18,
         method,
         body,
         headers,
@@ -13763,7 +13763,7 @@ var require_mock_utils = __commonJS({
       return dispatchMockReply(mockDispatches, mockDispatch2, key2, opts, handler);
     }
     function dispatchMockReply(mockDispatches, mockDispatch2, key2, opts, handler) {
-      const { data: response, delay } = mockDispatch2;
+      const { data: response, delay: delay2 } = mockDispatch2;
       if (response.error !== null) {
         deleteMockDispatch(mockDispatches, key2);
         handler.onResponseError(null, response.error);
@@ -13853,11 +13853,11 @@ var require_mock_utils = __commonJS({
           handleReply(dispatches, mockDispatch2.data);
           return;
         }
-        if (typeof delay === "number" && delay > 0) {
+        if (typeof delay2 === "number" && delay2 > 0) {
           timer = setTimeout(() => {
             timer = null;
             handleReply(dispatches);
-          }, delay);
+          }, delay2);
         } else {
           handleReply(dispatches);
         }
@@ -14544,13 +14544,13 @@ var require_mock_pool = __commonJS({
 var require_pending_interceptors_formatter = __commonJS({
   "../../node_modules/.pnpm/undici@8.10.0/node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports, module) {
     "use strict";
-    var { Transform: Transform2 } = __require("node:stream");
+    var { Transform: Transform3 } = __require("node:stream");
     var { Console } = __require("node:console");
     var PERSISTENT = process.versions.icu ? "✅" : "Y ";
     var NOT_PERSISTENT = process.versions.icu ? "❌" : "N ";
     module.exports = class PendingInterceptorsFormatter {
       constructor({ disableColors } = {}) {
-        this.transform = new Transform2({
+        this.transform = new Transform3({
           transform(chunk, _enc, cb) {
             cb(null, chunk);
           }
@@ -14564,10 +14564,10 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path17, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+          ({ method, path: path18, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
-            Path: path17,
+            Path: path18,
             "Status code": statusCode,
             Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
             Invocations: timesInvoked,
@@ -14649,9 +14649,9 @@ var require_mock_agent = __commonJS({
         const acceptNonStandardSearchParameters = this[kMockAgentAcceptsNonStandardSearchParameters];
         const dispatchOpts = { ...opts };
         if (acceptNonStandardSearchParameters && dispatchOpts.path) {
-          const [path17, searchParams] = dispatchOpts.path.split("?");
+          const [path18, searchParams] = dispatchOpts.path.split("?");
           const normalizedSearchParams = normalizeSearchParams(searchParams, acceptNonStandardSearchParameters);
-          dispatchOpts.path = `${path17}?${normalizedSearchParams}`;
+          dispatchOpts.path = `${path18}?${normalizedSearchParams}`;
         }
         return this[kAgent].dispatch(dispatchOpts, handler);
       }
@@ -14855,7 +14855,7 @@ var require_snapshot_utils = __commonJS({
 var require_snapshot_recorder = __commonJS({
   "../../node_modules/.pnpm/undici@8.10.0/node_modules/undici/lib/mock/snapshot-recorder.js"(exports, module) {
     "use strict";
-    var { writeFile, readFile: readFile11, mkdir: mkdir9 } = __require("node:fs/promises");
+    var { writeFile, readFile: readFile12, mkdir: mkdir10 } = __require("node:fs/promises");
     var { dirname, resolve } = __require("node:path");
     var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = __require("node:timers");
     var { InvalidArgumentError, UndiciError } = require_errors();
@@ -15067,12 +15067,12 @@ var require_snapshot_recorder = __commonJS({
        * @return {Promise<void>} - Resolves when snapshots are loaded
        */
       async loadSnapshots(filePath) {
-        const path17 = filePath || this.#snapshotPath;
-        if (!path17) {
+        const path18 = filePath || this.#snapshotPath;
+        if (!path18) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile11(resolve(path17), "utf8");
+          const data = await readFile12(resolve(path18), "utf8");
           const parsed = JSON.parse(data);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -15086,7 +15086,7 @@ var require_snapshot_recorder = __commonJS({
           if (error.code === "ENOENT") {
             this.#snapshots.clear();
           } else {
-            throw new UndiciError(`Failed to load snapshots from ${path17}`, { cause: error });
+            throw new UndiciError(`Failed to load snapshots from ${path18}`, { cause: error });
           }
         }
       }
@@ -15097,12 +15097,12 @@ var require_snapshot_recorder = __commonJS({
        * @returns {Promise<void>} - Resolves when snapshots are saved
        */
       async saveSnapshots(filePath) {
-        const path17 = filePath || this.#snapshotPath;
-        if (!path17) {
+        const path18 = filePath || this.#snapshotPath;
+        if (!path18) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
-        const resolvedPath = resolve(path17);
-        await mkdir9(dirname(resolvedPath), { recursive: true });
+        const resolvedPath = resolve(path18);
+        await mkdir10(dirname(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
           hash,
           snapshot
@@ -15738,15 +15738,15 @@ var require_redirect_handler = __commonJS({
           return;
         }
         const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
-        const path17 = search ? `${pathname}${search}` : pathname;
-        const redirectUrlString = `${origin}${path17}`;
+        const path18 = search ? `${pathname}${search}` : pathname;
+        const redirectUrlString = `${origin}${path18}`;
         for (const historyUrl of this.history) {
           if (historyUrl.toString() === redirectUrlString) {
             throw new InvalidArgumentError(`Redirect loop detected. Cannot redirect to ${origin}. This typically happens when using a Client or Pool with cross-origin redirects. Use an Agent for cross-origin redirects.`);
           }
         }
         this.opts.headers = cleanRequestHeaders(this.opts.headers, removeContentHeaders, this.opts.origin !== origin, this.stripHeadersOnRedirect, this.stripHeadersOnCrossOriginRedirect);
-        this.opts.path = path17;
+        this.opts.path = path18;
         this.opts.origin = origin;
         this.opts.query = null;
       }
@@ -17574,10 +17574,10 @@ var require_cache_handler = __commonJS({
       }
       return locationUrl.pathname + locationUrl.search;
     }
-    function deleteCachedUri(store, cacheKey, path17) {
+    function deleteCachedUri(store, cacheKey, path18) {
       deleteCachedValue(store, {
         ...cacheKey,
-        path: path17
+        path: path18
       });
       for (let i = 0; i < util.safeHTTPMethods.length; i++) {
         const method = util.safeHTTPMethods[i];
@@ -17585,7 +17585,7 @@ var require_cache_handler = __commonJS({
           deleteCachedValue(store, {
             ...cacheKey,
             method,
-            path: path17
+            path: path18
           });
         }
       }
@@ -17596,9 +17596,9 @@ var require_cache_handler = __commonJS({
       }
       const values = Array.isArray(headerValue) ? headerValue : [headerValue];
       for (let i = 0; i < values.length; i++) {
-        const path17 = getSameOriginPath(cacheKey, values[i]);
-        if (path17 !== void 0) {
-          deleteCachedUri(store, cacheKey, path17);
+        const path18 = getSameOriginPath(cacheKey, values[i]);
+        if (path18 !== void 0) {
+          deleteCachedUri(store, cacheKey, path18);
         }
       }
     }
@@ -18758,7 +18758,7 @@ var require_decompress = __commonJS({
   "../../node_modules/.pnpm/undici@8.10.0/node_modules/undici/lib/interceptor/decompress.js"(exports, module) {
     "use strict";
     var { createInflate, createGunzip: createGunzip2, createBrotliDecompress, createZstdDecompress } = __require("node:zlib");
-    var { pipeline: pipeline2 } = __require("node:stream");
+    var { pipeline: pipeline3 } = __require("node:stream");
     var DecoratorHandler = require_decorator_handler();
     var supportedEncodings = {
       gzip: createGunzip2,
@@ -18868,7 +18868,7 @@ var require_decompress = __commonJS({
       #setupMultipleDecompressors(controller) {
         const lastDecompressor = this.#decompressors[this.#decompressors.length - 1];
         this.#setupDecompressorEvents(lastDecompressor, controller);
-        pipeline2(this.#decompressors, (err) => {
+        pipeline3(this.#decompressors, (err) => {
           if (err) {
             super.onResponseError(controller, err);
             return;
@@ -19765,17 +19765,17 @@ var require_sqlite_cache_store = __commonJS({
           if (now >= value.deleteAt && !canBeExpired) {
             continue;
           }
-          let matches = true;
+          let matches2 = true;
           if (value.vary) {
             const vary = JSON.parse(value.vary);
             for (const header in vary) {
               if (!headerValueEquals(headers[header], vary[header])) {
-                matches = false;
+                matches2 = false;
                 break;
               }
             }
           }
-          if (matches) {
+          if (matches2) {
             return value;
           }
         }
@@ -19940,12 +19940,12 @@ var require_headers = __commonJS({
       append(name, value, isLowerCase) {
         this.sortedMap = null;
         const lowercaseName = isLowerCase ? name : name.toLowerCase();
-        const exists = this.headersMap.get(lowercaseName);
-        if (exists) {
+        const exists2 = this.headersMap.get(lowercaseName);
+        if (exists2) {
           const delimiter = lowercaseName === "cookie" ? "; " : ", ";
           this.headersMap.set(lowercaseName, {
-            name: exists.name,
-            value: `${exists.value}${delimiter}${value}`
+            name: exists2.name,
+            value: `${exists2.value}${delimiter}${value}`
           });
         } else {
           this.headersMap.set(lowercaseName, { name, value });
@@ -21662,7 +21662,7 @@ var require_fetch = __commonJS({
       subresourceSet
     } = require_constants3();
     var EE = __require("node:events");
-    var { Readable: Readable2, pipeline: pipeline2, finished, isErrored, isReadable } = __require("node:stream");
+    var { Readable: Readable2, pipeline: pipeline3, finished, isErrored, isReadable } = __require("node:stream");
     var { addAbortListener, bufferToLowerCasedHeaderName } = require_util();
     var { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require_data_url();
     var { getGlobalDispatcher } = require_global2();
@@ -22595,13 +22595,13 @@ var require_fetch = __commonJS({
       function dispatch({ body }) {
         const url = requestCurrentURL(request);
         const agent = fetchParams.controller.dispatcher;
-        const path17 = url.pathname + url.search;
+        const path18 = url.pathname + url.search;
         const hasTrailingQuestionMark = url.search.length === 0 && url.href[url.href.length - url.hash.length - 1] === "?";
         return dispatchWithProtocolPreference(body);
         function dispatchWithProtocolPreference(body2, allowH2) {
           return new Promise((resolve, reject3) => agent.dispatch(
             {
-              path: hasTrailingQuestionMark ? `${path17}?` : path17,
+              path: hasTrailingQuestionMark ? `${path18}?` : path18,
               origin: url.origin,
               method: request.method,
               body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body2,
@@ -22686,7 +22686,7 @@ var require_fetch = __commonJS({
                   status,
                   statusText,
                   headersList,
-                  body: decoders.length ? pipeline2(this.body, ...decoders, (err) => {
+                  body: decoders.length ? pipeline3(this.body, ...decoders, (err) => {
                     if (err) {
                       this.onResponseError(controller, err);
                     }
@@ -23513,9 +23513,9 @@ var require_util4 = __commonJS({
         }
       }
     }
-    function validateCookiePath(path17) {
-      for (let i = 0; i < path17.length; ++i) {
-        const code = path17.charCodeAt(i);
+    function validateCookiePath(path18) {
+      for (let i = 0; i < path18.length; ++i) {
+        const code = path18.charCodeAt(i);
         if (code < 32 || // exclude CTLs (0-31)
         code > 126 || // exclude non-ascii and DEL
         code === 59) {
@@ -26157,7 +26157,7 @@ var require_util6 = __commonJS({
 var require_eventsource_stream = __commonJS({
   "../../node_modules/.pnpm/undici@8.10.0/node_modules/undici/lib/web/eventsource/eventsource-stream.js"(exports, module) {
     "use strict";
-    var { Transform: Transform2 } = __require("node:stream");
+    var { Transform: Transform3 } = __require("node:stream");
     var { isASCIINumber, isValidLastEventId } = require_util6();
     var BOM = [239, 187, 191];
     var LF = 10;
@@ -26198,7 +26198,7 @@ var require_eventsource_stream = __commonJS({
       }
       return true;
     }
-    var EventSourceStream = class extends Transform2 {
+    var EventSourceStream = class extends Transform3 {
       /**
        * @type {eventSourceSettings}
        */
@@ -26498,7 +26498,7 @@ ${value}`;
 var require_eventsource = __commonJS({
   "../../node_modules/.pnpm/undici@8.10.0/node_modules/undici/lib/web/eventsource/eventsource.js"(exports, module) {
     "use strict";
-    var { pipeline: pipeline2 } = __require("node:stream");
+    var { pipeline: pipeline3 } = __require("node:stream");
     var { fetching } = require_fetch();
     var { webidl } = require_webidl();
     var { EventSourceStream } = require_eventsource_stream();
@@ -26648,7 +26648,7 @@ var require_eventsource = __commonJS({
               ));
             }
           });
-          pipeline2(
+          pipeline3(
             response.body.stream,
             eventSourceStream,
             (error) => {
@@ -26887,11 +26887,11 @@ var require_undici = __commonJS({
           if (typeof opts.path !== "string") {
             throw new InvalidArgumentError("invalid opts.path");
           }
-          let path17 = opts.path;
+          let path18 = opts.path;
           if (!opts.path.startsWith("/")) {
-            path17 = `/${path17}`;
+            path18 = `/${path18}`;
           }
-          url = new URL(util.parseOrigin(url).origin + path17);
+          url = new URL(util.parseOrigin(url).origin + path18);
         } else {
           if (!opts) {
             opts = typeof url === "object" ? url : {};
@@ -39796,20 +39796,20 @@ import { monitorEventLoopDelay as monitorEventLoopDelay2 } from "node:perf_hooks
 // ../kernel/src/world/default-fs.ts
 import fs from "node:fs/promises";
 var defaultFs = {
-  stat(path17) {
-    return fs.stat(path17);
+  stat(path18) {
+    return fs.stat(path18);
   },
-  lstat(path17) {
-    return fs.lstat(path17);
+  lstat(path18) {
+    return fs.lstat(path18);
   },
-  realpath(path17) {
-    return fs.realpath(path17);
+  realpath(path18) {
+    return fs.realpath(path18);
   },
-  readFile(path17) {
-    return fs.readFile(path17);
+  readFile(path18) {
+    return fs.readFile(path18);
   },
-  async readFilePrefix(path17, bytes) {
-    const handle = await fs.open(path17, "r");
+  async readFilePrefix(path18, bytes) {
+    const handle = await fs.open(path18, "r");
     try {
       const prefix = Buffer.alloc(bytes);
       const { bytesRead } = await handle.read(prefix, 0, bytes, 0);
@@ -39818,17 +39818,17 @@ var defaultFs = {
       await handle.close();
     }
   },
-  async writeFile(path17, data) {
-    await fs.writeFile(path17, data);
+  async writeFile(path18, data) {
+    await fs.writeFile(path18, data);
   },
-  async appendFile(path17, data) {
-    await fs.appendFile(path17, data);
+  async appendFile(path18, data) {
+    await fs.appendFile(path18, data);
   },
-  async mkdir(path17, opts) {
-    await fs.mkdir(path17, opts);
+  async mkdir(path18, opts) {
+    await fs.mkdir(path18, opts);
   },
-  readdir(path17) {
-    return fs.readdir(path17, { withFileTypes: true });
+  readdir(path18) {
+    return fs.readdir(path18, { withFileTypes: true });
   }
 };
 
@@ -41157,29 +41157,29 @@ function buildSpillStubText(input) {
   ].join("\n");
 }
 function assertSpillStoreInvariants() {
-  const fail = (detail) => {
+  const fail2 = (detail) => {
     throw new Error(`spill-store 不变式违约(装载期 fail-fast):${detail}`);
   };
   const nameRe = /^[A-Za-z0-9._-]+$/;
   if (!nameRe.test(SPILL_DIR_NAME)) {
-    fail(`SPILL_DIR_NAME 必须为安全文件名词形,得到 ${JSON.stringify(SPILL_DIR_NAME)}`);
+    fail2(`SPILL_DIR_NAME 必须为安全文件名词形,得到 ${JSON.stringify(SPILL_DIR_NAME)}`);
   }
   if (!nameRe.test(SPILL_PRUNE_FILE_PREFIX)) {
-    fail(`SPILL_PRUNE_FILE_PREFIX 必须为安全文件名词形,得到 ${JSON.stringify(SPILL_PRUNE_FILE_PREFIX)}`);
+    fail2(`SPILL_PRUNE_FILE_PREFIX 必须为安全文件名词形,得到 ${JSON.stringify(SPILL_PRUNE_FILE_PREFIX)}`);
   }
   if (!Number.isInteger(SPILL_HASH_HEX_CHARS) || SPILL_HASH_HEX_CHARS < 16 || SPILL_HASH_HEX_CHARS > 64) {
-    fail(`SPILL_HASH_HEX_CHARS 必须在 [16, 64](sha256 hex 截断域),得到 ${SPILL_HASH_HEX_CHARS}`);
+    fail2(`SPILL_HASH_HEX_CHARS 必须在 [16, 64](sha256 hex 截断域),得到 ${SPILL_HASH_HEX_CHARS}`);
   }
   const emptyHash = hashSpillContent("");
   if (emptyHash !== "e3b0c44298fc1c149afbf4c8996fb924".slice(0, SPILL_HASH_HEX_CHARS)) {
-    fail(`hashSpillContent 算法漂移:sha256('') 截断应为公知值,得到 ${emptyHash}`);
+    fail2(`hashSpillContent 算法漂移:sha256('') 截断应为公知值,得到 ${emptyHash}`);
   }
   if (spillFileName("content", emptyHash) === spillFileName("prune", emptyHash)) {
-    fail("content 与 prune 命名空间的文件名必须互异");
+    fail2("content 与 prune 命名空间的文件名必须互异");
   }
   const sample = buildSpillStubText({ path: "X:/s/spill/abc.txt", totalChars: 12345 });
   if (!sample.includes("12345") || !sample.includes("X:/s/spill/abc.txt") || !sample.includes("Read")) {
-    fail("buildSpillStubText 必须恒含原始规模、真实路径与 Read 指引");
+    fail2("buildSpillStubText 必须恒含原始规模、真实路径与 Read 指引");
   }
 }
 assertSpillStoreInvariants();
@@ -42043,63 +42043,63 @@ var CONTEXT_BUDGET_REMINDER_CRITICAL_FRACTION = 0.1;
 var CONTEXT_BUDGET_REMINDER_ROUND_TOKENS = 1e3;
 var CONTEXT_BUDGET_REMINDER_MIN_BUDGET_TOKENS = 2e4;
 function assertEntryBudgetInvariants() {
-  const fail = (detail) => {
+  const fail2 = (detail) => {
     throw new Error(`entry-budgets 不变式违约(装载期 fail-fast):${detail}`);
   };
   if (DEFAULT_TOOL_RESULT_BUDGET_CHARS !== 5e4) {
-    fail(
+    fail2(
       `DEFAULT_TOOL_RESULT_BUDGET_CHARS 必须为 50000(用户拍板 2026-08-21 维持不动),得到 ${DEFAULT_TOOL_RESULT_BUDGET_CHARS}`
     );
   }
   if (PERSISTED_PREVIEW_HEAD_CHARS + PERSISTED_PREVIEW_TAIL_CHARS >= DEFAULT_TOOL_RESULT_BUDGET_CHARS) {
-    fail("clamp 存根预览(head+tail)必须严格小于工具结果预算");
+    fail2("clamp 存根预览(head+tail)必须严格小于工具结果预算");
   }
   for (const [name, value] of [
     ["READ_MAX_LINES", READ_MAX_LINES],
     ["READ_MAX_LINE_CHARS", READ_MAX_LINE_CHARS],
     ["READ_MAX_FULL_BYTES", READ_MAX_FULL_BYTES]
   ]) {
-    if (!Number.isInteger(value) || value <= 0) fail(`${name} 必须为正整数,得到 ${value}`);
+    if (!Number.isInteger(value) || value <= 0) fail2(`${name} 必须为正整数,得到 ${value}`);
   }
   if (!Number.isInteger(PRUNE_MIN_RESULT_CHARS) || !Number.isInteger(PRUNE_HEAD_CHARS) || !Number.isInteger(PRUNE_TAIL_CHARS) || PRUNE_HEAD_CHARS < 0 || PRUNE_TAIL_CHARS < 0 || PRUNE_MIN_RESULT_CHARS <= 0) {
-    fail("剪枝常量必须为非负整数且门槛为正");
+    fail2("剪枝常量必须为非负整数且门槛为正");
   }
   if (PRUNE_HEAD_CHARS + PRUNE_TAIL_CHARS + PRUNE_MARKER_MAX_CHARS >= PRUNE_MIN_RESULT_CHARS) {
-    fail(
+    fail2(
       `剪后产物上界(head ${PRUNE_HEAD_CHARS} + tail ${PRUNE_TAIL_CHARS} + 标记 ≤${PRUNE_MARKER_MAX_CHARS})必须严格小于剪枝门槛 ${PRUNE_MIN_RESULT_CHARS}——否则剪后仍是候选,重复触发字节漂移`
     );
   }
   if (PRUNE_MIN_RESULT_CHARS >= DEFAULT_TOOL_RESULT_BUDGET_CHARS) {
-    fail("剪枝门槛必须低于工具结果 clamp 预算(50K 之上无剪枝对象)");
+    fail2("剪枝门槛必须低于工具结果 clamp 预算(50K 之上无剪枝对象)");
   }
   if (!Number.isInteger(SUBAGENT_SUMMARY_MAX_TOKENS) || SUBAGENT_SUMMARY_MAX_TOKENS <= 0) {
-    fail(`SUBAGENT_SUMMARY_MAX_TOKENS 必须为正整数,得到 ${SUBAGENT_SUMMARY_MAX_TOKENS}`);
+    fail2(`SUBAGENT_SUMMARY_MAX_TOKENS 必须为正整数,得到 ${SUBAGENT_SUMMARY_MAX_TOKENS}`);
   }
   if (!Number.isInteger(DEFAULT_OUTPUT_CAP_TOKENS) || DEFAULT_OUTPUT_CAP_TOKENS < 1024) {
-    fail(`DEFAULT_OUTPUT_CAP_TOKENS 必须为 ≥1024 的整数(输出预算地板),得到 ${DEFAULT_OUTPUT_CAP_TOKENS}`);
+    fail2(`DEFAULT_OUTPUT_CAP_TOKENS 必须为 ≥1024 的整数(输出预算地板),得到 ${DEFAULT_OUTPUT_CAP_TOKENS}`);
   }
   if (!Number.isInteger(OUTPUT_CAP_ESCALATION_TOKENS) || OUTPUT_CAP_ESCALATION_TOKENS <= DEFAULT_OUTPUT_CAP_TOKENS) {
-    fail(
+    fail2(
       `OUTPUT_CAP_ESCALATION_TOKENS(${OUTPUT_CAP_ESCALATION_TOKENS})必须为严格大于缺省输出帽 ${DEFAULT_OUTPUT_CAP_TOKENS} 的整数——否则触帽升档恒无增益`
     );
   }
   if (!(CONTEXT_BUDGET_REMINDER_CRITICAL_FRACTION > 0) || !(CONTEXT_BUDGET_REMINDER_CRITICAL_FRACTION < CONTEXT_BUDGET_REMINDER_LOW_FRACTION) || !(CONTEXT_BUDGET_REMINDER_LOW_FRACTION < 1)) {
-    fail(
+    fail2(
       `预算提醒档位必须满足 0 < critical(${CONTEXT_BUDGET_REMINDER_CRITICAL_FRACTION}) < low(${CONTEXT_BUDGET_REMINDER_LOW_FRACTION}) < 1`
     );
   }
   if (!Number.isInteger(CONTEXT_BUDGET_REMINDER_ROUND_TOKENS) || CONTEXT_BUDGET_REMINDER_ROUND_TOKENS <= 0) {
-    fail(
+    fail2(
       `CONTEXT_BUDGET_REMINDER_ROUND_TOKENS 必须为正整数,得到 ${CONTEXT_BUDGET_REMINDER_ROUND_TOKENS}`
     );
   }
   if (!Number.isInteger(CONTEXT_BUDGET_REMINDER_MIN_BUDGET_TOKENS) || CONTEXT_BUDGET_REMINDER_MIN_BUDGET_TOKENS < CONTEXT_BUDGET_REMINDER_ROUND_TOKENS) {
-    fail(
+    fail2(
       `CONTEXT_BUDGET_REMINDER_MIN_BUDGET_TOKENS(${CONTEXT_BUDGET_REMINDER_MIN_BUDGET_TOKENS})必须为 ≥ 取整粒度 ${CONTEXT_BUDGET_REMINDER_ROUND_TOKENS} 的整数`
     );
   }
   if (EMPTY_TOOL_RESULT_TEXT.length === 0 || EMPTY_TOOL_ERROR_TEXT.length === 0) {
-    fail("空结果短桩短语不得为空串");
+    fail2("空结果短桩短语不得为空串");
   }
 }
 assertEntryBudgetInvariants();
@@ -42303,74 +42303,74 @@ var LIFECYCLE_REPLAY_ORDER = [
   "evict"
 ];
 function assertHistoryLifecycleInvariants() {
-  const fail = (detail) => {
+  const fail2 = (detail) => {
     throw new Error(`历史生命周期状态机不变式违约(装载期 fail-fast):${detail}`);
   };
   if (new Set(HISTORY_LIFECYCLE_STATES).size !== HISTORY_LIFECYCLE_STATES.length) {
-    fail("态集成员必须互异");
+    fail2("态集成员必须互异");
   }
   if (!PRUNE_MARKER_PREFIX.startsWith("[") || PRUNE_MARKER_PREFIX.length < 8) {
-    fail(`PRUNE_MARKER_PREFIX 词形异常(冻结字节被改动):${JSON.stringify(PRUNE_MARKER_PREFIX)}`);
+    fail2(`PRUNE_MARKER_PREFIX 词形异常(冻结字节被改动):${JSON.stringify(PRUNE_MARKER_PREFIX)}`);
   }
   const ids = /* @__PURE__ */ new Set();
   let lastStage = -1;
   const stateIndex = (s) => HISTORY_LIFECYCLE_STATES.indexOf(s);
   for (const transition of LIFECYCLE_TRANSITIONS) {
-    if (ids.has(transition.id)) fail(`迁移 id 重复:${transition.id}`);
+    if (ids.has(transition.id)) fail2(`迁移 id 重复:${transition.id}`);
     ids.add(transition.id);
     if (transition.stage <= lastStage) {
-      fail(`迁移 stage 必须严格递增(全序仲裁的根):${transition.id} stage=${transition.stage}`);
+      fail2(`迁移 stage 必须严格递增(全序仲裁的根):${transition.id} stage=${transition.stage}`);
     }
     lastStage = transition.stage;
     const toIndex = stateIndex(transition.to);
-    if (toIndex < 0) fail(`迁移 ${transition.id} 目标态不在态集:${transition.to}`);
+    if (toIndex < 0) fail2(`迁移 ${transition.id} 目标态不在态集:${transition.to}`);
     if (transition.from !== "ingestion") {
       for (const from of transition.from) {
-        if (stateIndex(from) < 0) fail(`迁移 ${transition.id} 源态不在态集:${from}`);
+        if (stateIndex(from) < 0) fail2(`迁移 ${transition.id} 源态不在态集:${from}`);
         if (stateIndex(from) >= toIndex) {
-          fail(`迁移 ${transition.id} 违反单向前进(${from} → ${transition.to}):恒无复活迁移`);
+          fail2(`迁移 ${transition.id} 违反单向前进(${from} → ${transition.to}):恒无复活迁移`);
         }
       }
     }
   }
   for (const id of [...LIFECYCLE_BARRIER_ORDER, ...LIFECYCLE_REPLAY_ORDER]) {
-    if (!ids.has(id)) fail(`仲裁/重演序引用未登记迁移:${id}`);
+    if (!ids.has(id)) fail2(`仲裁/重演序引用未登记迁移:${id}`);
   }
   if (!Number.isInteger(DEFAULT_KEEP_RECENT_ROUNDS) || DEFAULT_KEEP_RECENT_ROUNDS < 1) {
-    fail(`DEFAULT_KEEP_RECENT_ROUNDS 必须为 ≥1 整数,得到 ${DEFAULT_KEEP_RECENT_ROUNDS}`);
+    fail2(`DEFAULT_KEEP_RECENT_ROUNDS 必须为 ≥1 整数,得到 ${DEFAULT_KEEP_RECENT_ROUNDS}`);
   }
   if (!Number.isInteger(DEFAULT_MICROCOMPACT_KEEP_RECENT_TOOL_RESULTS) || DEFAULT_MICROCOMPACT_KEEP_RECENT_TOOL_RESULTS < 1) {
-    fail(
+    fail2(
       `DEFAULT_MICROCOMPACT_KEEP_RECENT_TOOL_RESULTS 必须为 ≥1 整数,得到 ${DEFAULT_MICROCOMPACT_KEEP_RECENT_TOOL_RESULTS}`
     );
   }
   if (!Number.isInteger(DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS) || DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS <= 0) {
-    fail(
+    fail2(
       `DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS 必须为正整数,得到 ${DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS}`
     );
   }
   if (PRUNE_MIN_RESULT_CHARS <= DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS) {
-    fail(
+    fail2(
       `剪枝门槛(${PRUNE_MIN_RESULT_CHARS})必须严格大于淘汰门槛(${DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS}):prune 是 evict 的前置温和档`
     );
   }
   if (PRUNE_HEAD_CHARS + PRUNE_TAIL_CHARS < DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS) {
-    fail(
+    fail2(
       `剪后产物下界(head ${PRUNE_HEAD_CHARS} + tail ${PRUNE_TAIL_CHARS})必须 ≥ 淘汰门槛 ${DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS}——否则 pruned 态脱离 evict 候选域,两档接力断链`
     );
   }
   if (DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS >= DEFAULT_TOOL_RESULT_BUDGET_CHARS) {
-    fail(
+    fail2(
       `淘汰门槛(${DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS})必须小于入史 clamp 预算(${DEFAULT_TOOL_RESULT_BUDGET_CHARS}):淘汰重演的文件在场性判据依赖两带不重叠`
     );
   }
   if (DEGRADED_ESCALATED_KEEP_RECENT_TOOL_RESULTS > DEFAULT_MICROCOMPACT_KEEP_RECENT_TOOL_RESULTS) {
-    fail(
+    fail2(
       `劣化升级保护窗(${DEGRADED_ESCALATED_KEEP_RECENT_TOOL_RESULTS})不得大于默认窗(${DEFAULT_MICROCOMPACT_KEEP_RECENT_TOOL_RESULTS}):升级恒收窄`
     );
   }
   if (DEGRADED_ESCALATED_MIN_RESULT_CHARS > DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS) {
-    fail(
+    fail2(
       `劣化升级淘汰门槛(${DEGRADED_ESCALATED_MIN_RESULT_CHARS})不得大于默认门槛(${DEFAULT_MICROCOMPACT_MIN_RESULT_CHARS}):升级恒收窄`
     );
   }
@@ -47485,18 +47485,18 @@ function postCompactReminderInvalidation(provider) {
   if (typeof reset !== "function") return void 0;
   return { id: "reminders.firstScreenBaselines", run: () => reset() };
 }
-function defaultStatMtimeMs(path17) {
+function defaultStatMtimeMs(path18) {
   try {
-    return statSync(path17).mtimeMs;
+    return statSync(path18).mtimeMs;
   } catch {
     return void 0;
   }
 }
 function createReminderProvider(options = {}) {
-  const stat10 = options.statMtimeMs ?? defaultStatMtimeMs;
+  const stat11 = options.statMtimeMs ?? defaultStatMtimeMs;
   const memoryPaths = options.memoryPaths ?? [];
   const mtimes = /* @__PURE__ */ new Map();
-  for (const path17 of memoryPaths) mtimes.set(path17, stat10(path17));
+  for (const path18 of memoryPaths) mtimes.set(path18, stat11(path18));
   let lastTodoSerialized;
   let securityNotePending = memoryPaths.length > 0;
   let lastSeenModelTurns = Number.POSITIVE_INFINITY;
@@ -47509,12 +47509,12 @@ function createReminderProvider(options = {}) {
       out.push(makeReminder("security_note", { sources: [...memoryPaths] }));
     }
     const changes = [];
-    for (const path17 of memoryPaths) {
-      const prev = mtimes.get(path17);
-      const current = stat10(path17);
+    for (const path18 of memoryPaths) {
+      const prev = mtimes.get(path18);
+      const current = stat11(path18);
       if (current === prev) continue;
-      mtimes.set(path17, current);
-      changes.push({ path: path17, change: current === void 0 ? "removed" : "modified" });
+      mtimes.set(path18, current);
+      changes.push({ path: path18, change: current === void 0 ? "removed" : "modified" });
     }
     if (changes.length > 0) {
       out.push(makeReminder("memory_change", { changes }));
@@ -49557,10 +49557,10 @@ function matchHardSafety(input, config = {}) {
   if (typeof command !== "string") return null;
   const structure = parseCommandStructure(command);
   if (!structure.ok) return null;
-  for (const pipeline2 of structure.pipelines) {
-    const hasEgress = pipeline2.commands.some((c) => isEgressCommand(c, extraEgress));
+  for (const pipeline3 of structure.pipelines) {
+    const hasEgress = pipeline3.commands.some((c) => isEgressCommand(c, extraEgress));
     if (!hasEgress) continue;
-    const refsSecret = pipeline2.commands.some((c) => nodeReferencesSecret(c, input.cwd));
+    const refsSecret = pipeline3.commands.some((c) => nodeReferencesSecret(c, input.cwd));
     if (refsSecret) {
       return {
         label: "secret-egress",
@@ -49654,13 +49654,13 @@ function canonicalCwd(cwd) {
   const resolved = resolveForPermission(cwd, ".");
   return resolved.kind === "ok" ? resolved.path : null;
 }
-function canonicalPathEligible(cwdCanon, path17, policy, guard) {
-  if (hasWindowsDeviceSegment(path17)) return false;
-  if (path17 === cwdCanon) return !policy.strict;
-  if (!path17.startsWith(`${cwdCanon}/`)) return false;
-  if (guard.isProtectedContentPath(path17)) return false;
-  if (matchProtectedPath(path17, null) !== null) return false;
-  const segments = path17.slice(cwdCanon.length + 1).split("/");
+function canonicalPathEligible(cwdCanon, path18, policy, guard) {
+  if (hasWindowsDeviceSegment(path18)) return false;
+  if (path18 === cwdCanon) return !policy.strict;
+  if (!path18.startsWith(`${cwdCanon}/`)) return false;
+  if (guard.isProtectedContentPath(path18)) return false;
+  if (matchProtectedPath(path18, null) !== null) return false;
+  const segments = path18.slice(cwdCanon.length + 1).split("/");
   for (const [index, seg] of segments.entries()) {
     const hasGlob = GLOB_CHAR_RE.test(seg);
     if (hasGlob && seg.startsWith(".")) return false;
@@ -49844,9 +49844,9 @@ function verifyBundle(bundle, opts = {}) {
 // ../kernel/src/permissions/soften-radius.ts
 var PROTECTED_PATH_RULE_PREFIX = "protected-path(";
 var MCP_TOOL_PREFIX = "mcp__";
-function pathInsideRoot(path17, root) {
+function pathInsideRoot(path18, root) {
   if (root === null) return false;
-  return path17 === root || path17.startsWith(root.endsWith("/") ? root : `${root}/`);
+  return path18 === root || path18.startsWith(root.endsWith("/") ? root : `${root}/`);
 }
 function classifySoftenFace(input, base) {
   if (base.matchedRule?.startsWith(PROTECTED_PATH_RULE_PREFIX) === true) return "F6";
@@ -51796,14 +51796,14 @@ var DispatchingToolExecutor = class _DispatchingToolExecutor {
     let internalError;
     const onCtxAbort = () => wake.wake();
     ctx.signal.addEventListener("abort", onCtxAbort, { once: true });
-    const drain = function* () {
+    const drain2 = function* () {
       while (queued.length > 0) {
         yield { t: "event", body: queued.shift() };
       }
     };
     const waitUntil = async function* (cond) {
       for (; ; ) {
-        yield* drain();
+        yield* drain2();
         if (cond()) return;
         await wake.wait();
       }
@@ -51831,7 +51831,7 @@ var DispatchingToolExecutor = class _DispatchingToolExecutor {
     };
     for (let i = 0; i < calls.length; i++) {
       let call = calls[i];
-      yield* drain();
+      yield* drain2();
       if (ctx.signal.aborted) {
         sawAbort = true;
         fillSyntheticFrom(i);
@@ -52258,7 +52258,7 @@ var DispatchingToolExecutor = class _DispatchingToolExecutor {
     }
     try {
       yield* waitUntil(() => inFlight === 0);
-      yield* drain();
+      yield* drain2();
     } finally {
       ctx.signal.removeEventListener("abort", onCtxAbort);
     }
@@ -52538,10 +52538,10 @@ async function renameWithRetry(from, to, deps = defaultRenameDeps) {
       await deps.rename(from, to);
       return;
     } catch (err) {
-      const delay = RENAME_RETRY_DELAYS_MS[attempt];
+      const delay2 = RENAME_RETRY_DELAYS_MS[attempt];
       const transient = deps.platform === "win32" && isErrnoException(err) && err.code !== void 0 && RENAME_TRANSIENT_CODES.has(err.code);
-      if (!transient || delay === void 0) throw err;
-      await deps.sleep(delay);
+      if (!transient || delay2 === void 0) throw err;
+      await deps.sleep(delay2);
     }
   }
 }
@@ -52810,13 +52810,13 @@ async function externalizeOne(block, sessionDir) {
     const bytes = Buffer.from(block["data"], "base64");
     const hex = createHash8("sha256").update(bytes).digest("hex");
     const file = attachmentFilePath(sessionDir, hex);
-    let exists = true;
+    let exists2 = true;
     try {
       await access(file);
     } catch {
-      exists = false;
+      exists2 = false;
     }
-    if (!exists) {
+    if (!exists2) {
       await mkdir2(attachmentsDirPath(sessionDir), { recursive: true });
       await writeFileDurable(file, bytes);
     }
@@ -53116,13 +53116,13 @@ async function effectiveSegments(sessionDir, manifest) {
       out.push(segment);
       continue;
     }
-    let exists = true;
+    let exists2 = true;
     try {
       await stat2(segmentFilePath(sessionDir, segment.n));
     } catch {
-      exists = false;
+      exists2 = false;
     }
-    if (isSegmentEffective(segment, exists)) out.push(segment);
+    if (isSegmentEffective(segment, exists2)) out.push(segment);
   }
   return out;
 }
@@ -53399,9 +53399,9 @@ async function settleManifest(sessionDir) {
       segments.push(segment);
       continue;
     }
-    const exists = await fileExists(segmentFilePath(sessionDir, segment.n));
+    const exists2 = await fileExists(segmentFilePath(sessionDir, segment.n));
     changed = true;
-    if (isSegmentEffective(segment, exists)) segments.push({ ...segment, status: "sealed" });
+    if (isSegmentEffective(segment, exists2)) segments.push({ ...segment, status: "sealed" });
   }
   const last = segments[segments.length - 1];
   const liveFirstSeq = last === void 0 ? 0 : last.lastSeq + 1;
@@ -54043,8 +54043,8 @@ var VERSIONED_MANIFEST = /\/manifest\.g\d{9}-[0-9a-f]+\.json$/;
 function isManifestObjectKey(key2) {
   return key2.endsWith(`/${MANIFEST_OBJECT_NAME}`) || VERSIONED_MANIFEST.test(key2);
 }
-function segmentKey(ref, segment, codec, sha256) {
-  return `${volumePrefix(ref)}seg-${String(segment.n).padStart(6, "0")}-${segment.firstSeq}-${segment.lastSeq}-${sha256.slice(0, 12)}.${codecFileExtension(codec)}`;
+function segmentKey(ref, segment, codec, sha2562) {
+  return `${volumePrefix(ref)}seg-${String(segment.n).padStart(6, "0")}-${segment.firstSeq}-${segment.lastSeq}-${sha2562.slice(0, 12)}.${codecFileExtension(codec)}`;
 }
 function deriveVolumeId(segments) {
   const first = segments.find((s) => s.n === 1);
@@ -54527,9 +54527,881 @@ function createColdManifestStore(options) {
   };
 }
 
+// ../kernel/src/journal/segmented/fs-blob-store.ts
+import { createHash as createHash11, randomBytes as randomBytes2 } from "node:crypto";
+import { createReadStream as createReadStream2, createWriteStream as createWriteStream2 } from "node:fs";
+import { link, mkdir as mkdir4, readdir, readFile as readFile6, rm as rm5, stat as stat3 } from "node:fs/promises";
+import path8 from "node:path";
+import { Transform as Transform2 } from "node:stream";
+import { pipeline as pipeline2 } from "node:stream/promises";
+var KEY_PART2 = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function fsKeyParts(key2) {
+  if (key2.length === 0 || key2.includes("\\") || key2.startsWith("/") || key2.endsWith("/")) {
+    throw new StoreError("permanent", `非法对象键 ${JSON.stringify(key2)}:禁空键 / 反斜杠 / 首尾分隔符`);
+  }
+  const parts = key2.split("/");
+  for (const part of parts) {
+    if (!KEY_PART2.test(part) || part === "." || part === "..") {
+      throw new StoreError("permanent", `非法对象键段 ${JSON.stringify(part)}(键 ${JSON.stringify(key2)}):仅允许字母数字与 . _ -,且须以字母数字开头`);
+    }
+  }
+  return parts;
+}
+async function exists(p) {
+  try {
+    await stat3(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var KeyLocks = class {
+  #tails = /* @__PURE__ */ new Map();
+  async run(key2, op) {
+    const prev = this.#tails.get(key2) ?? Promise.resolve();
+    let release;
+    const mine = new Promise((resolve) => {
+      release = resolve;
+    });
+    const tail = prev.then(() => mine);
+    this.#tails.set(key2, tail);
+    await prev;
+    try {
+      return await op();
+    } finally {
+      release();
+      if (this.#tails.get(key2) === tail) this.#tails.delete(key2);
+    }
+  }
+};
+function createFsBlobStore(options) {
+  const root = path8.resolve(options.dir);
+  const objectsDir = path8.join(root, "objects");
+  const metaDir = path8.join(root, "meta");
+  const tmpDir = path8.join(root, "tmp");
+  const capabilities = {
+    consistency: "strong",
+    conditionalPut: true,
+    rangeGet: true,
+    maxObjectBytes: Number.MAX_SAFE_INTEGER,
+    list: "prefix",
+    batchDelete: 1e3,
+    ...options.capabilities
+  };
+  const locks = new KeyLocks();
+  let prepared = null;
+  const prepare = () => {
+    prepared ??= (async () => {
+      await mkdir4(objectsDir, { recursive: true });
+      await mkdir4(metaDir, { recursive: true });
+      await rm5(tmpDir, { recursive: true, force: true }).catch(() => void 0);
+      await mkdir4(tmpDir, { recursive: true });
+    })();
+    return prepared;
+  };
+  const objectPath = (key2) => path8.join(objectsDir, ...fsKeyParts(key2));
+  const metaPath = (key2) => `${path8.join(metaDir, ...fsKeyParts(key2))}.json`;
+  async function readMeta(key2) {
+    let raw;
+    try {
+      raw = await readFile6(metaPath(key2), "utf8");
+    } catch (err) {
+      if (isErrnoException(err) && err.code === "ENOENT") return null;
+      throw toStoreError(err);
+    }
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new StoreError("permanent", `对象 meta 损坏:${key2}`);
+    }
+  }
+  async function spool(body, signal) {
+    const tmp = path8.join(tmpDir, `${process.pid.toString(36)}-${randomBytes2(8).toString("hex")}`);
+    const hash = createHash11("sha256");
+    let bytes = 0;
+    const counter = new Transform2({
+      transform(chunk, _enc, callback) {
+        hash.update(chunk);
+        bytes += chunk.length;
+        callback(null, chunk);
+      }
+    });
+    try {
+      await pipeline2(webToNode(body), counter, createWriteStream2(tmp), signal === void 0 ? {} : { signal });
+    } catch (err) {
+      await rm5(tmp, { force: true }).catch(() => void 0);
+      if (signal?.aborted === true || err instanceof Error && err.name === "AbortError") {
+        throw new StoreError("transient", "aborted", { cause: err });
+      }
+      throw toStoreError(err);
+    }
+    return { tmp, sha256: hash.digest("hex"), bytes };
+  }
+  async function writeMeta(key2, meta) {
+    const p = metaPath(key2);
+    await mkdir4(path8.dirname(p), { recursive: true });
+    await writeFileDurable(p, `${JSON.stringify(meta)}
+`);
+  }
+  async function placeExclusive(tmp, target) {
+    try {
+      await link(tmp, target);
+      await rm5(tmp, { force: true }).catch(() => void 0);
+      return "created";
+    } catch (err) {
+      if (isErrnoException(err)) {
+        if (err.code === "EEXIST") return "exists";
+        if (err.code === "EPERM" || err.code === "ENOSYS" || err.code === "ENOTSUP" || err.code === "EXDEV") {
+          if (await exists(target)) return "exists";
+          await renameWithRetry(tmp, target);
+          return "created";
+        }
+      }
+      throw err;
+    }
+  }
+  const store = {
+    capabilities,
+    async put(key2, body, meta, opts = {}) {
+      const target = objectPath(key2);
+      await prepare();
+      if (opts.signal?.aborted === true) {
+        await body.cancel().catch(() => void 0);
+        throw new StoreError("transient", "aborted", { cause: opts.signal.reason });
+      }
+      const spooled = await spool(body, opts.signal);
+      try {
+        if (spooled.sha256 !== meta.sha256) {
+          throw new StoreError("permanent", `sha256 不符:体 ${spooled.sha256} ≠ meta ${meta.sha256}(${key2})`);
+        }
+        const etag = spooled.sha256;
+        const stored = { ...meta, bytes: spooled.bytes, etag };
+        return await locks.run(key2, async () => {
+          await mkdir4(path8.dirname(target), { recursive: true });
+          if (opts.ifNoneMatch === "*") {
+            const outcome = await placeExclusive(spooled.tmp, target);
+            if (outcome === "exists") {
+              const current = await readMeta(key2);
+              if (current === null || current.etag !== etag) {
+                throw new StoreError("precondition_failed", `ifNoneMatch:* 但对象已存在:${key2}`);
+              }
+              return { etag };
+            }
+            await writeMeta(key2, stored);
+            return { etag };
+          }
+          if (opts.ifMatch !== void 0) {
+            const current = await readMeta(key2);
+            if (current === null || current.etag !== opts.ifMatch) {
+              throw new StoreError("precondition_failed", `ifMatch ${opts.ifMatch} 但现行 etag ${current?.etag ?? "(absent)"}:${key2}`);
+            }
+          }
+          await renameWithRetry(spooled.tmp, target);
+          await writeMeta(key2, stored);
+          return { etag };
+        });
+      } catch (err) {
+        throw toStoreError(err);
+      } finally {
+        await rm5(spooled.tmp, { force: true }).catch(() => void 0);
+      }
+    },
+    async get(key2, range, signal) {
+      const target = objectPath(key2);
+      await prepare();
+      if (signal?.aborted === true) throw new StoreError("transient", "aborted", { cause: signal.reason });
+      const meta = await readMeta(key2);
+      if (meta === null || !await exists(target)) throw new StoreError("not_found", `对象不存在:${key2}`);
+      const streamOptions = { highWaterMark: 256 * 1024 };
+      if (range !== void 0) {
+        if (range.start >= meta.bytes) return new ReadableStream({ start: (c) => c.close() });
+        streamOptions.start = range.start;
+        if (range.end !== void 0) streamOptions.end = Math.min(range.end, meta.bytes - 1);
+      }
+      const source = createReadStream2(target, streamOptions);
+      if (signal !== void 0) {
+        const abort = () => {
+          source.destroy(new StoreError("transient", "aborted", { cause: signal.reason }));
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        source.once("close", () => signal.removeEventListener("abort", abort));
+      }
+      return nodeToWeb(source);
+    },
+    async head(key2) {
+      await prepare();
+      const meta = await readMeta(key2);
+      if (meta === null || !await exists(objectPath(key2))) return null;
+      return { ...meta };
+    },
+    async *list(prefix, cursor, signal) {
+      await prepare();
+      const slash = prefix.lastIndexOf("/");
+      const dirPart = slash === -1 ? "" : prefix.slice(0, slash);
+      const dirParts = dirPart === "" ? [] : fsKeyParts(dirPart);
+      const startDir = path8.join(objectsDir, ...dirParts);
+      if (!await exists(startDir)) return;
+      const keys = [];
+      const walk = async (dir, keyPrefix) => {
+        let entries;
+        try {
+          entries = await readdir(dir, { withFileTypes: true });
+        } catch (err) {
+          if (isErrnoException(err) && err.code === "ENOENT") return;
+          throw toStoreError(err);
+        }
+        for (const entry of entries) {
+          const key2 = keyPrefix === "" ? entry.name : `${keyPrefix}/${entry.name}`;
+          if (entry.isDirectory()) await walk(path8.join(dir, entry.name), key2);
+          else if (entry.isFile() && key2.startsWith(prefix)) keys.push(key2);
+        }
+      };
+      await walk(startDir, dirPart);
+      keys.sort();
+      for (const key2 of keys) {
+        if (signal?.aborted === true) throw new StoreError("transient", "aborted", { cause: signal.reason });
+        if (cursor !== void 0 && key2 <= cursor) continue;
+        const meta = await readMeta(key2);
+        if (meta === null) continue;
+        yield { key: key2, meta: { ...meta } };
+      }
+    },
+    async delete(keys) {
+      await prepare();
+      for (const key2 of keys) {
+        await rm5(objectPath(key2), { force: true }).catch((err) => {
+          throw toStoreError(err);
+        });
+        await rm5(metaPath(key2), { force: true }).catch((err) => {
+          throw toStoreError(err);
+        });
+      }
+    }
+  };
+  return store;
+}
+
 // ../kernel/src/journal/segmented/conformance.ts
+import { createHash as createHash12 } from "node:crypto";
 var CHUNK = 256 * 1024;
 var MIB = 1024 * 1024;
+function bytesOf(size, seed) {
+  const out = new Uint8Array(size);
+  let x = seed * 2654435761 + 1 >>> 0;
+  for (let i = 0; i < size; i++) {
+    x = x * 1664525 + 1013904223 >>> 0;
+    out[i] = x >>> 24;
+  }
+  return out;
+}
+function sha256(bytes) {
+  return createHash12("sha256").update(bytes).digest("hex");
+}
+function toStream(bytes, chunk = CHUNK) {
+  let offset = 0;
+  return new ReadableStream({
+    pull(controller) {
+      if (offset >= bytes.byteLength) {
+        controller.close();
+        return;
+      }
+      const end = Math.min(bytes.byteLength, offset + chunk);
+      controller.enqueue(bytes.subarray(offset, end));
+      offset = end;
+    }
+  });
+}
+async function collect(body) {
+  const chunks = [];
+  let total = 0;
+  const reader = body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const out = new Uint8Array(total);
+  let o = 0;
+  for (const c of chunks) {
+    out.set(c, o);
+    o += c.byteLength;
+  }
+  return out;
+}
+async function drain(body) {
+  let total = 0;
+  const reader = body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return total;
+}
+function equalBytes(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function metaFor(bytes, contentType = "application/octet-stream") {
+  return { bytes: bytes.byteLength, contentType, sha256: sha256(bytes) };
+}
+function largeStream(total, seed) {
+  let produced = 0;
+  let x = seed * 2654435761 + 1 >>> 0;
+  return new ReadableStream({
+    pull(controller) {
+      if (produced >= total) {
+        controller.close();
+        return;
+      }
+      const size = Math.min(CHUNK, total - produced);
+      const chunk = new Uint8Array(size);
+      for (let i = 0; i < size; i++) {
+        x = x * 1664525 + 1013904223 >>> 0;
+        chunk[i] = x >>> 24;
+      }
+      produced += size;
+      controller.enqueue(chunk);
+    }
+  });
+}
+async function largeSha256(total, seed) {
+  const hash = createHash12("sha256");
+  const reader = largeStream(total, seed).getReader();
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    hash.update(value);
+  }
+  return hash.digest("hex");
+}
+function sampleRss() {
+  const base = process.memoryUsage().rss;
+  let peak = base;
+  const timer = setInterval(() => {
+    peak = Math.max(peak, process.memoryUsage().rss);
+  }, 20);
+  return {
+    stop() {
+      clearInterval(timer);
+      return Math.max(peak, process.memoryUsage().rss) - base;
+    }
+  };
+}
+var fmtMiB = (n) => `${(n / MIB).toFixed(1)} MiB`;
+var CaseFailure = class extends Error {
+};
+var fail = (detail) => {
+  throw new CaseFailure(detail);
+};
+var ensure = (cond, detail) => {
+  if (!cond) fail(detail);
+};
+var isStoreErrorOf = (err, kind) => err instanceof StoreError && err.kind === kind;
+async function runStorageConformance(store, options = {}) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const t0 = performance.now();
+  const caps = store.capabilities;
+  const largeBytes = options.largeObjectBytes ?? 16 * MIB;
+  const rssBudget = options.rssBudgetBytes ?? 64 * MIB;
+  const eventualMs = options.eventualConsistencyMs ?? 0;
+  const prefix = options.keyPrefix ?? `conformance-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+  const concurrency = Math.max(2, options.concurrency ?? 16);
+  const created = /* @__PURE__ */ new Set();
+  const key2 = (name) => {
+    const k = `${prefix}/${name}`;
+    created.add(k);
+    return k;
+  };
+  async function waitVisible(listPrefix, expected) {
+    const deadline = performance.now() + eventualMs;
+    for (; ; ) {
+      for await (const entry of store.list(listPrefix, void 0, options.signal)) {
+        if (entry.key === expected) return true;
+      }
+      if (performance.now() >= deadline) return false;
+      await new Promise((r) => setTimeout(r, Math.min(50, Math.max(5, eventualMs / 20))));
+    }
+  }
+  const cases = [];
+  async function run(id, fn) {
+    const start = performance.now();
+    try {
+      const detail = await fn();
+      const skipped = detail.startsWith("skipped:");
+      cases.push({ id, passed: true, detail, ...skipped ? { skipped: true } : {}, durationMs: Math.round(performance.now() - start) });
+    } catch (err) {
+      const detail = err instanceof CaseFailure ? err.message : `异常:${err instanceof Error ? `${err.name}: ${err.message}` : String(err)}`;
+      cases.push({ id, passed: false, detail, durationMs: Math.round(performance.now() - start) });
+    }
+  }
+  await run("idempotent_put", async () => {
+    const k = key2("idempotent");
+    const bytes = bytesOf(7e4, 1);
+    const meta = metaFor(bytes);
+    const r1 = await store.put(k, toStream(bytes), meta);
+    const r2 = await store.put(k, toStream(bytes), meta);
+    ensure(r1.etag === void 0 || r2.etag === void 0 || r1.etag === r2.etag, `同内容重复 put 的 etag 不同:${r1.etag} / ${r2.etag}`);
+    const head = await store.head(k);
+    ensure(head !== null, "put 后 head 为 null");
+    ensure(head.bytes === bytes.byteLength, `head.bytes ${head.bytes} ≠ ${bytes.byteLength}`);
+    ensure(head.sha256 === meta.sha256, "head.sha256 与 meta 不符");
+    ensure(head.contentType === meta.contentType, "head.contentType 与 meta 不符");
+    const back = await collect(await store.get(k));
+    ensure(equalBytes(back, bytes), "get 回读与 put 体不同");
+    return `2 次 put 成功,head/get 一致(${bytes.byteLength} B)`;
+  });
+  await run("range_get", async () => {
+    if (!caps.rangeGet) return "skipped: capabilities.rangeGet:false";
+    const k = key2("range");
+    const bytes = bytesOf(1e5, 2);
+    await store.put(k, toStream(bytes), metaFor(bytes));
+    const mid = await collect(await store.get(k, { start: 10, end: 19 }));
+    ensure(equalBytes(mid, bytes.subarray(10, 20)), `Range [10,19] 回读 ${mid.byteLength} B 与切片不同`);
+    const tail = await collect(await store.get(k, { start: bytes.byteLength - 5 }));
+    ensure(equalBytes(tail, bytes.subarray(bytes.byteLength - 5)), "Range 缺省 end 到尾不符");
+    const clamped = await collect(await store.get(k, { start: bytes.byteLength - 3, end: bytes.byteLength + 1e3 }));
+    ensure(equalBytes(clamped, bytes.subarray(bytes.byteLength - 3)), "Range end 越界未钳到尾");
+    const first = await collect(await store.get(k, { start: 0, end: 0 }));
+    ensure(first.byteLength === 1 && first[0] === bytes[0], "Range [0,0] 应回 1 字节");
+    return "中段 / 到尾 / 越界钳 / 单字节 Range 皆正确";
+  });
+  await run("concurrent_put", async () => {
+    const items = Array.from({ length: concurrency }, (_, i) => ({ k: key2(`concurrent/${String(i).padStart(3, "0")}`), bytes: bytesOf(2e4 + i * 7, 100 + i) }));
+    await Promise.all(items.map((it) => store.put(it.k, toStream(it.bytes), metaFor(it.bytes))));
+    for (const it of items) {
+      const head = await store.head(it.k);
+      ensure(head !== null && head.sha256 === sha256(it.bytes), `并发 put 后 ${it.k} head 缺失或哈希不符`);
+      ensure(equalBytes(await collect(await store.get(it.k)), it.bytes), `并发 put 后 ${it.k} 内容不符`);
+    }
+    return `${concurrency} 键并发 put 全部一致`;
+  });
+  await run("partial_put_invisible", async () => {
+    const k = key2("partial");
+    const bytes = bytesOf(3e5, 4);
+    const meta = metaFor(bytes);
+    let sent = 0;
+    const broken = new ReadableStream({
+      pull(controller) {
+        if (sent >= 2) {
+          controller.error(new Error("conformance: connection dropped"));
+          return;
+        }
+        controller.enqueue(bytes.subarray(sent * CHUNK, Math.min(bytes.byteLength, (sent + 1) * CHUNK)));
+        sent++;
+      }
+    });
+    let threw = false;
+    try {
+      await store.put(k, broken, meta);
+    } catch {
+      threw = true;
+    }
+    ensure(threw, "体流中断的 put 未失败");
+    ensure(await store.head(k) === null, "体流中断后留下半对象(head 非 null)");
+    let threw2 = null;
+    try {
+      await store.put(k, toStream(bytes), { ...meta, sha256: "f".repeat(64) });
+    } catch (err) {
+      threw2 = err;
+    }
+    ensure(threw2 !== null, "sha256 不符的 put 未失败");
+    ensure(await store.head(k) === null, "sha256 不符后留下对象");
+    return `体流中断 / sha256 不符均失败且无半对象${isStoreErrorOf(threw2, "permanent") ? "(sha256 不符归 permanent)" : ""}`;
+  });
+  await run("list_prefix_cursor", async () => {
+    if (caps.list === "none") return "skipped: capabilities.list:'none'";
+    const names = ["a-000", "a-001", "a-002", "b-000", "b-001"];
+    const keys = names.map((n) => key2(`listing/${n}`));
+    for (const [i, k] of keys.entries()) {
+      const bytes = bytesOf(1e3 + i, 200 + i);
+      await store.put(k, toStream(bytes), metaFor(bytes));
+    }
+    const listPrefix = `${prefix}/listing/`;
+    for (const k of keys) ensure(await waitVisible(listPrefix, k), `${k} 在 ${eventualMs} ms 内未经 list 可见`);
+    const all = [];
+    for await (const e of store.list(listPrefix)) {
+      all.push(e.key);
+      ensure(e.meta.sha256.length === 64, `list 条目 meta.sha256 形状不对:${e.key}`);
+    }
+    ensure(all.length === keys.length, `list 返回 ${all.length} 项 ≠ ${keys.length}`);
+    for (let i = 1; i < all.length; i++) ensure(all[i - 1] < all[i], "list 非字典升序");
+    const sub = [];
+    for await (const e of store.list(`${prefix}/listing/a-`)) sub.push(e.key);
+    ensure(sub.length === 3 && sub.every((k) => k.includes("/a-")), `名前缀 list 应 3 项,得 ${sub.length}`);
+    const rest = [];
+    for await (const e of store.list(listPrefix, all[1])) rest.push(e.key);
+    ensure(rest.length === all.length - 2 && rest[0] === all[2], `cursor 分页不正确:${rest.join(",")}`);
+    const none = [];
+    for await (const e of store.list(`${prefix}/nothing-here/`)) none.push(e.key);
+    ensure(none.length === 0, "空前缀 list 应无项");
+    return `${keys.length} 键前缀 / 名前缀 / cursor 分页 / 空前缀正确(可见窗口 ${eventualMs} ms)`;
+  });
+  await run("large_object_streaming", async () => {
+    const k = key2("large");
+    const digest = await largeSha256(largeBytes, 6);
+    const meta = { bytes: largeBytes, contentType: "application/octet-stream", sha256: digest };
+    const putSampler = sampleRss();
+    await store.put(k, largeStream(largeBytes, 6), meta);
+    const putDelta = putSampler.stop();
+    const head = await store.head(k);
+    ensure(head !== null && head.bytes === largeBytes, "large head 缺失或字节数不符");
+    const getSampler = sampleRss();
+    const drained = await drain(await store.get(k));
+    const getDelta = getSampler.stop();
+    ensure(drained === largeBytes, `get 回读 ${drained} B ≠ ${largeBytes}`);
+    ensure(putDelta < rssBudget, `put RSS 峰值增量 ${fmtMiB(putDelta)} ≥ 预算 ${fmtMiB(rssBudget)}`);
+    ensure(getDelta < rssBudget, `get RSS 峰值增量 ${fmtMiB(getDelta)} ≥ 预算 ${fmtMiB(rssBudget)}`);
+    return `${fmtMiB(largeBytes)}:put RSS Δ ${fmtMiB(putDelta)} / get RSS Δ ${fmtMiB(getDelta)} < ${fmtMiB(rssBudget)}`;
+  });
+  await run("abort_signal", async () => {
+    const k = key2("abort");
+    const bytes = bytesOf(4e5, 7);
+    const meta = metaFor(bytes);
+    const pre = new AbortController();
+    pre.abort(new Error("conformance: pre-aborted"));
+    let threw = false;
+    try {
+      await store.put(k, toStream(bytes), meta, { signal: pre.signal });
+    } catch {
+      threw = true;
+    }
+    ensure(threw, "预中止 signal 的 put 未失败");
+    ensure(await store.head(k) === null, "预中止 put 留下对象");
+    const mid = new AbortController();
+    let pulls = 0;
+    const midBody = new ReadableStream({
+      pull(controller) {
+        if (pulls === 1) mid.abort(new Error("conformance: mid abort"));
+        if (pulls * CHUNK >= bytes.byteLength) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(bytes.subarray(pulls * CHUNK, Math.min(bytes.byteLength, (pulls + 1) * CHUNK)));
+        pulls++;
+      }
+    });
+    let threwMid = false;
+    try {
+      await store.put(k, midBody, meta, { signal: mid.signal });
+    } catch {
+      threwMid = true;
+    }
+    ensure(threwMid, "中途中止的 put 未失败");
+    ensure(await store.head(k) === null, "中途中止 put 留下半对象");
+    await store.put(k, toStream(bytes), meta);
+    const getAbort = new AbortController();
+    getAbort.abort(new Error("conformance: get aborted"));
+    let getThrew = false;
+    try {
+      const body = await store.get(k, void 0, getAbort.signal);
+      await drain(body);
+    } catch {
+      getThrew = true;
+    }
+    ensure(getThrew, "预中止 signal 的 get 未失败(既未拒绝也未以流出错)");
+    return "预中止 / 中途中止 put 干净失败无半对象;预中止 get 失败";
+  });
+  await run("manifest_cas", async () => {
+    if (!caps.conditionalPut) return "skipped: capabilities.conditionalPut:false(须挂 SessionIndexStore)";
+    const k = key2("manifest.json");
+    const v1 = new TextEncoder().encode('{"generation":1}\n');
+    const v2 = new TextEncoder().encode('{"generation":2}\n');
+    const v3 = new TextEncoder().encode('{"generation":3}\n');
+    const r1 = await store.put(k, toStream(v1), metaFor(v1, "application/json"), { ifNoneMatch: "*" });
+    ensure(r1.etag !== void 0, "conditionalPut:true 的 put 须返回 etag");
+    let conflict = null;
+    try {
+      await store.put(k, toStream(v2), metaFor(v2, "application/json"), { ifNoneMatch: "*" });
+    } catch (err) {
+      conflict = err;
+    }
+    ensure(isStoreErrorOf(conflict, "precondition_failed"), `ifNoneMatch:* 对已存在键应 precondition_failed,实为 ${String(conflict)}`);
+    ensure(equalBytes(await collect(await store.get(k)), v1), "ifNoneMatch 冲突后内容被改");
+    const head1 = await store.head(k);
+    ensure(head1 !== null && head1.etag === r1.etag, `head.etag(${head1?.etag})应等于 put 返回 etag(${r1.etag})`);
+    const r2 = await store.put(k, toStream(v2), metaFor(v2, "application/json"), { ifMatch: r1.etag });
+    ensure(r2.etag !== void 0 && r2.etag !== r1.etag, "ifMatch 改写后 etag 应变化");
+    let stale = null;
+    try {
+      await store.put(k, toStream(v3), metaFor(v3, "application/json"), { ifMatch: r1.etag });
+    } catch (err) {
+      stale = err;
+    }
+    ensure(isStoreErrorOf(stale, "precondition_failed"), `过期 etag 的 ifMatch 应 precondition_failed,实为 ${String(stale)}`);
+    ensure(equalBytes(await collect(await store.get(k)), v2), "过期 ifMatch 冲突后内容被改");
+    let missing = null;
+    try {
+      await store.put(key2("manifest-missing.json"), toStream(v1), metaFor(v1, "application/json"), { ifMatch: "nope" });
+    } catch (err) {
+      missing = err;
+    }
+    ensure(isStoreErrorOf(missing, "precondition_failed"), "ifMatch 对不存在键应 precondition_failed");
+    return "ifNoneMatch:* 首写 / 冲突 412;ifMatch etag 改写 / 过期 412 / 缺席 412;head 回带 etag";
+  });
+  await run("delete_idempotent", async () => {
+    const k = key2("delete");
+    const bytes = bytesOf(1234, 9);
+    await store.put(k, toStream(bytes), metaFor(bytes));
+    await store.delete([k]);
+    ensure(await store.head(k) === null, "delete 后 head 仍非 null");
+    let notFound = null;
+    try {
+      await drain(await store.get(k));
+    } catch (err) {
+      notFound = err;
+    }
+    ensure(notFound !== null, "delete 后 get 未失败");
+    await store.delete([k]);
+    await store.delete([key2("never-existed")]);
+    const batch = Math.max(1, Math.min(caps.batchDelete ?? 1, 8));
+    const many = Array.from({ length: batch }, (_, i) => key2(`delete-batch/${i}`));
+    for (const [i, mk] of many.entries()) {
+      const b = bytesOf(100 + i, 300 + i);
+      await store.put(mk, toStream(b), metaFor(b));
+    }
+    await store.delete(many);
+    for (const mk of many) ensure(await store.head(mk) === null, `批删后 ${mk} 仍在`);
+    return `在场 / 重复 / 不存在 / 批量 ${batch} 键删除皆幂等`;
+  });
+  await run("capabilities_truthful", async () => {
+    const notes = [];
+    const missing = key2("missing");
+    ensure(await store.head(missing) === null, "head 不存在键应返 null 而非抛");
+    let getErr = null;
+    try {
+      await drain(await store.get(missing));
+    } catch (err) {
+      getErr = err;
+    }
+    ensure(getErr !== null, "get 不存在键应失败");
+    notes.push(isStoreErrorOf(getErr, "not_found") ? "get 缺席 → not_found" : `get 缺席 → ${toStoreError(getErr).kind}(建议 not_found)`);
+    ensure(caps.consistency === "strong" || caps.consistency === "eventual", `consistency 值非法:${String(caps.consistency)}`);
+    ensure(Number.isFinite(caps.maxObjectBytes) && caps.maxObjectBytes > 0, "maxObjectBytes 须为正有限数");
+    ensure(caps.list === "prefix" || caps.list === "none", `list 值非法:${String(caps.list)}`);
+    ensure(caps.batchDelete === void 0 || Number.isInteger(caps.batchDelete) && caps.batchDelete >= 1, "batchDelete 须为 ≥1 整数");
+    const bytes = bytesOf(5e4, 10);
+    const k = key2("truthful");
+    const r = await store.put(k, toStream(bytes), metaFor(bytes));
+    if (caps.rangeGet) {
+      const part = await collect(await store.get(k, { start: 100, end: 199 }));
+      ensure(equalBytes(part, bytes.subarray(100, 200)), "声明 rangeGet:true 但 Range 读不正确");
+      notes.push("rangeGet 属实");
+    }
+    if (caps.conditionalPut) {
+      ensure(r.etag !== void 0, "声明 conditionalPut:true 但 put 未返回 etag");
+      const head = await store.head(k);
+      ensure(head?.etag === r.etag, "声明 conditionalPut:true 但 head 未回带 etag");
+      let conflict = null;
+      try {
+        const other = bytesOf(5e4, 11);
+        await store.put(k, toStream(other), metaFor(other), { ifNoneMatch: "*" });
+      } catch (err) {
+        conflict = err;
+      }
+      ensure(isStoreErrorOf(conflict, "precondition_failed"), "声明 conditionalPut:true 但 ifNoneMatch:* 未拒绝");
+      notes.push("conditionalPut 属实");
+    }
+    if (caps.list === "prefix") {
+      ensure(await waitVisible(`${prefix}/truthful`, k), "声明 list:prefix 但 put 后 list 不见");
+      notes.push("list:prefix 属实");
+    }
+    if (caps.consistency === "strong") {
+      ensure(await store.head(k) !== null, "声明 strong 但写后 head 不可见");
+      notes.push("strong 写后即读属实");
+    }
+    return notes.join(";");
+  });
+  if (options.keepObjects !== true) {
+    const keys = [...created];
+    const batch = Math.max(1, caps.batchDelete ?? 1);
+    for (let i = 0; i < keys.length; i += batch) {
+      await store.delete(keys.slice(i, i + batch)).catch(() => void 0);
+    }
+  }
+  return {
+    cases,
+    passed: cases.every((c) => c.passed),
+    capabilities: { ...caps },
+    startedAt,
+    durationMs: Math.round(performance.now() - t0)
+  };
+}
+
+// ../kernel/src/journal/segmented/chaos-blob-store.ts
+function matches(pred, key2) {
+  if (pred === void 0) return false;
+  return typeof pred === "boolean" ? pred : pred(key2);
+}
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function createChaosBlobStore(inner, faults = {}, now = Date.now) {
+  const putAt = /* @__PURE__ */ new Map();
+  let putsSeen = 0;
+  const stats = {
+    putFailures: 0,
+    putTruncated: 0,
+    listHidden: 0,
+    listDropped: 0,
+    corruptedGets: 0,
+    abortedGets: 0,
+    calls: { put: 0, get: 0, head: 0, list: 0, delete: 0 }
+  };
+  const latency = async () => {
+    const l = faults.latencyMs;
+    if (l === void 0) return;
+    const ms = typeof l === "number" ? l : l.min + Math.random() * Math.max(0, l.max - l.min);
+    if (ms > 0) await delay(ms);
+  };
+  const injectedPutError = (key2, detail) => {
+    const kind = faults.putErrorKind ?? "transient";
+    return new StoreError(kind, `chaos: ${detail} (${key2})`, kind === "transient" && faults.retryAfterMs !== void 0 ? { retryAfterMs: faults.retryAfterMs } : {});
+  };
+  const shouldFailPut = (key2) => {
+    const f = faults.failPut;
+    if (f === void 0) return false;
+    if (typeof f === "number") return putsSeen <= f;
+    return matches(f, key2);
+  };
+  const truncateBody = (body, afterBytes, key2) => {
+    let seen = 0;
+    return body.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          if (seen >= afterBytes) {
+            controller.error(injectedPutError(key2, `connection dropped after ${afterBytes} bytes`));
+            return;
+          }
+          const take = Math.min(chunk.byteLength, afterBytes - seen);
+          seen += take;
+          controller.enqueue(chunk.subarray(0, take));
+          if (seen >= afterBytes) controller.error(injectedPutError(key2, `connection dropped after ${afterBytes} bytes`));
+        }
+      })
+    );
+  };
+  const capabilities = {
+    ...inner.capabilities,
+    get consistency() {
+      return (faults.eventualListLagMs ?? 0) > 0 || faults.dropListEntries !== void 0 ? "eventual" : inner.capabilities.consistency;
+    }
+  };
+  return {
+    faults,
+    stats,
+    inner,
+    capabilities,
+    async put(key2, body, meta, opts) {
+      stats.calls.put++;
+      putsSeen++;
+      await latency();
+      if (shouldFailPut(key2)) {
+        stats.putFailures++;
+        await body.cancel().catch(() => void 0);
+        throw injectedPutError(key2, "put rejected");
+      }
+      const after = faults.failPutAfterBytes;
+      if (after !== void 0) {
+        stats.putTruncated++;
+        try {
+          return await inner.put(key2, truncateBody(body, after, key2), meta, opts);
+        } catch (err) {
+          if (err instanceof StoreError && err.kind === faults.putErrorKind) throw err;
+          throw injectedPutError(key2, `connection dropped after ${after} bytes`);
+        }
+      }
+      const result = await inner.put(key2, body, meta, opts);
+      putAt.set(key2, now());
+      return result;
+    },
+    async get(key2, range, signal) {
+      stats.calls.get++;
+      await latency();
+      const body = await inner.get(key2, range, signal);
+      if (matches(faults.corruptSegmentKeys, key2)) {
+        stats.corruptedGets++;
+        let flipped = false;
+        return body.pipeThrough(
+          new TransformStream({
+            transform(chunk, controller) {
+              if (!flipped && chunk.byteLength > 0) {
+                const copy = new Uint8Array(chunk);
+                copy[0] = copy[0] ^ 255;
+                flipped = true;
+                controller.enqueue(copy);
+                return;
+              }
+              controller.enqueue(chunk);
+            }
+          })
+        );
+      }
+      if (matches(faults.abortMidStream, key2)) {
+        stats.abortedGets++;
+        let passed = 0;
+        return body.pipeThrough(
+          new TransformStream({
+            transform(chunk, controller) {
+              if (passed === 0) {
+                controller.enqueue(chunk);
+                passed++;
+                return;
+              }
+              controller.error(new StoreError("transient", `chaos: download aborted mid-stream (${key2})`));
+            },
+            flush(controller) {
+              if (passed <= 1) controller.error(new StoreError("transient", `chaos: download aborted mid-stream (${key2})`));
+            }
+          })
+        );
+      }
+      return body;
+    },
+    async head(key2, signal) {
+      stats.calls.head++;
+      await latency();
+      return inner.head(key2, signal);
+    },
+    async *list(prefix, cursor, signal) {
+      stats.calls.list++;
+      await latency();
+      const lag = faults.eventualListLagMs ?? 0;
+      const drop = faults.dropListEntries;
+      for await (const entry of inner.list(prefix, cursor, signal)) {
+        if (lag > 0) {
+          const at = putAt.get(entry.key);
+          if (at !== void 0 && now() - at < lag) {
+            stats.listHidden++;
+            continue;
+          }
+        }
+        if (drop !== void 0) {
+          const dropped = typeof drop === "number" ? Math.random() < drop : matches(drop, entry.key);
+          if (dropped) {
+            stats.listDropped++;
+            continue;
+          }
+        }
+        yield entry;
+      }
+    },
+    async delete(keys, signal) {
+      stats.calls.delete++;
+      await latency();
+      await inner.delete(keys, signal);
+      for (const key2 of keys) putAt.delete(key2);
+    }
+  };
+}
 
 // ../kernel/src/journal/segmented/store-metrics.ts
 var STORE_BUCKETS_MS = DURATION_BUCKETS_MS.filter((b) => b >= 5);
@@ -54561,8 +55433,8 @@ function storeMetricsFor(registry = defaultMetrics) {
 }
 
 // ../kernel/src/journal/segmented/cold-tier.ts
-import { mkdir as mkdir4, rm as rm5, stat as stat3 } from "node:fs/promises";
-import path8 from "node:path";
+import { mkdir as mkdir5, rm as rm6, stat as stat4 } from "node:fs/promises";
+import path9 from "node:path";
 async function observed(metrics, op, fn, bytes) {
   const t0 = performance.now();
   try {
@@ -54789,13 +55661,13 @@ function createColdTier(options) {
     return state.sessionMeta;
   }
   async function uploadOne(state, segment) {
-    const filePath = path8.join(state.ref.sessionDir, segment.file);
+    const filePath = path9.join(state.ref.sessionDir, segment.file);
     const volume = await currentVolume(state);
     const stillHot = volume?.manifest.segments.find((s) => s.n === segment.n && s.lastHash === segment.lastHash);
     if (volume === null || stillHot === void 0) return;
     let rawBytes;
     try {
-      rawBytes = (await stat3(filePath)).size;
+      rawBytes = (await stat4(filePath)).size;
     } catch (err) {
       if (isErrnoException(err) && err.code === "ENOENT") {
         const laterHot = volume.manifest.segments.some((s) => s.n > segment.n && s.status === "sealed");
@@ -54861,7 +55733,7 @@ function createColdTier(options) {
       emit({ type: "store.segment_committed", session: state.ref, segment, key: key2, bytes: entry.bytes, generation: snapshot.manifest.generation });
     } finally {
       state.inflight.delete(key2);
-      await rm5(spoolPath, { force: true }).catch(() => void 0);
+      await rm6(spoolPath, { force: true }).catch(() => void 0);
     }
   }
   async function evictIfNeeded() {
@@ -54887,7 +55759,7 @@ function createColdTier(options) {
         continue;
       }
       try {
-        await rm5(path8.join(c.state.ref.sessionDir, segment.file), { force: true });
+        await rm6(path9.join(c.state.ref.sessionDir, segment.file), { force: true });
       } catch {
         continue;
       }
@@ -54917,7 +55789,7 @@ function createColdTier(options) {
       if (segment.status !== "sealed") continue;
       let size;
       try {
-        size = (await stat3(path8.join(state.ref.sessionDir, segment.file))).size;
+        size = (await stat4(path9.join(state.ref.sessionDir, segment.file))).size;
       } catch {
         continue;
       }
@@ -54944,7 +55816,7 @@ function createColdTier(options) {
     while (active < upload.concurrency && runQueue.length > 0) {
       const state = runQueue.shift();
       active++;
-      void drain(state).finally(() => {
+      void drain2(state).finally(() => {
         active--;
         state.scheduled = false;
         if (!closed && state.pending.length > 0 && !state.stopped && !state.paused && states.has(state.ref.sessionDir)) schedule(state);
@@ -54956,7 +55828,7 @@ function createColdTier(options) {
       });
     }
   }
-  async function drain(state) {
+  async function drain2(state) {
     try {
       if (!state.reconciled) await reconcile(state);
       while (state.pending.length > 0 && !state.stopped && !closed) {
@@ -55099,7 +55971,7 @@ function createColdTier(options) {
       const last = manifest.segments[manifest.segments.length - 1];
       const base = { meta, segments: manifest.segments.length, lastSeq: last?.lastSeq ?? -1, volumeId: manifest.volumeId, generation: manifest.generation };
       if (hot !== null) return { ...base, restored: false };
-      await mkdir4(session.sessionDir, { recursive: true });
+      await mkdir5(session.sessionDir, { recursive: true });
       await writeManifest(session.sessionDir, coldManifestToHot(manifest));
       const state = states.get(session.sessionDir);
       if (state !== void 0) {
@@ -55158,11 +56030,11 @@ function createColdTier(options) {
 }
 
 // ../kernel/src/journal/session-index.ts
-import { appendFile as appendFile2, readFile as readFile6, readdir, rm as rm6, stat as stat4 } from "node:fs/promises";
-import path9 from "node:path";
+import { appendFile as appendFile2, readFile as readFile7, readdir as readdir2, rm as rm7, stat as stat5 } from "node:fs/promises";
+import path10 from "node:path";
 var SESSION_INDEX_FILE_NAME = "index.jsonl";
 function sessionIndexFilePath(storageRoot) {
-  return path9.join(storageRoot, SESSION_INDEX_FILE_NAME);
+  return path10.join(storageRoot, SESSION_INDEX_FILE_NAME);
 }
 var COMPACT_SLACK_ROWS = 256;
 var COMPACT_RATIO = 4;
@@ -55177,7 +56049,7 @@ var SessionIndex = class {
   constructor(options) {
     this.#root = options.storageRoot;
     this.#file = sessionIndexFilePath(options.storageRoot);
-    this.#sessionsDir = path9.join(options.storageRoot, "sessions");
+    this.#sessionsDir = path10.join(options.storageRoot, "sessions");
     this.#readMeta = options.readMeta;
   }
   /** 全部存活条目(无序;调用方自行排序/截断) */
@@ -55241,14 +56113,14 @@ var SessionIndex = class {
   }
   async #dirMtime() {
     try {
-      return (await stat4(this.#sessionsDir)).mtimeMs;
+      return (await stat5(this.#sessionsDir)).mtimeMs;
     } catch {
       return -1;
     }
   }
   async #fileSize() {
     try {
-      return (await stat4(this.#file)).size;
+      return (await stat5(this.#file)).size;
     } catch {
       return -1;
     }
@@ -55285,7 +56157,7 @@ var SessionIndex = class {
   async #loadFile() {
     let raw;
     try {
-      raw = await readFile6(this.#file, "utf8");
+      raw = await readFile7(this.#file, "utf8");
     } catch (err) {
       if (isErrnoException(err) && err.code === "ENOENT") return null;
       throw err;
@@ -55326,13 +56198,13 @@ var SessionIndex = class {
     const entries = /* @__PURE__ */ new Map();
     let names = [];
     try {
-      names = await readdir(this.#sessionsDir, { withFileTypes: true });
+      names = await readdir2(this.#sessionsDir, { withFileTypes: true });
     } catch {
       names = [];
     }
     for (const entry of names) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const meta = await this.#readMeta(path9.join(this.#sessionsDir, entry.name), entry.name);
+      const meta = await this.#readMeta(path10.join(this.#sessionsDir, entry.name), entry.name);
       if (meta !== null) entries.set(meta.sessionId, meta);
     }
     const state = { entries, fileSize: -1, dirMtimeMs, rows: 0 };
@@ -55352,7 +56224,7 @@ var SessionIndex = class {
 ` : "";
     try {
       if (state.entries.size === 0 && state.dirMtimeMs === -1) {
-        await rm6(this.#file, { force: true }).catch(() => void 0);
+        await rm7(this.#file, { force: true }).catch(() => void 0);
         state.fileSize = -1;
         state.rows = 0;
         return;
@@ -55383,9 +56255,9 @@ var SessionIndex = class {
 };
 
 // ../kernel/src/journal/checkpoints.ts
-import { createHash as createHash11, randomBytes as randomBytes2 } from "node:crypto";
-import { access as access3, mkdir as mkdir5, readdir as readdir2, readFile as readFile7, rm as rm7 } from "node:fs/promises";
-import path10 from "node:path";
+import { createHash as createHash13, randomBytes as randomBytes3 } from "node:crypto";
+import { access as access3, mkdir as mkdir6, readdir as readdir3, readFile as readFile8, rm as rm8 } from "node:fs/promises";
+import path11 from "node:path";
 import { z as z18 } from "zod";
 var ContextCheckpointTriggerSchema = z18.enum([
   "manual",
@@ -55439,7 +56311,7 @@ function newCheckpointId(now = Date.now()) {
       ulidLastRandom[i] = 0;
     }
   } else {
-    ulidLastRandom = Array.from(randomBytes2(16), (b) => b & 31);
+    ulidLastRandom = Array.from(randomBytes3(16), (b) => b & 31);
     ulidLastTime = now;
   }
   let timePart = "";
@@ -55462,13 +56334,13 @@ var META_SUFFIX = ".meta.json";
 var BODY_SUFFIX = ".json";
 function checkpointsDirPath(root, sessionId) {
   assertValidSessionId(sessionId);
-  return path10.join(root, sessionId);
+  return path11.join(root, sessionId);
 }
 function bodyFilePath(dir, checkpointId) {
-  return path10.join(dir, `${checkpointId}${BODY_SUFFIX}`);
+  return path11.join(dir, `${checkpointId}${BODY_SUFFIX}`);
 }
 function metaFilePath2(dir, checkpointId) {
-  return path10.join(dir, `${checkpointId}${META_SUFFIX}`);
+  return path11.join(dir, `${checkpointId}${META_SUFFIX}`);
 }
 var isRecord3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var REF_PATTERN2 = /^sha256:([0-9a-f]{64})$/;
@@ -55500,7 +56372,7 @@ async function storeImages(messages, cpDir, attachmentsFrom) {
         `messages 含 ${refs.length} 个已外置($ref)image 块,须以 opts.attachmentsFrom 指明附件来源会话目录`
       );
     }
-    await mkdir5(attachmentsDirPath(cpDir), { recursive: true });
+    await mkdir6(attachmentsDirPath(cpDir), { recursive: true });
     for (const hex of refs) {
       const target = attachmentFilePath(cpDir, hex);
       let targetExists = true;
@@ -55512,7 +56384,7 @@ async function storeImages(messages, cpDir, attachmentsFrom) {
       if (targetExists) continue;
       let bytes;
       try {
-        bytes = await readFile7(attachmentFilePath(attachmentsFrom, hex));
+        bytes = await readFile8(attachmentFilePath(attachmentsFrom, hex));
       } catch (err) {
         if (isErrnoException(err) && err.code === "ENOENT") continue;
         throw err;
@@ -55529,7 +56401,7 @@ async function storeImages(messages, cpDir, attachmentsFrom) {
 async function writeCheckpoint(root, cp, opts = {}) {
   assertValidCheckpointId(cp.checkpointId);
   const dir = checkpointsDirPath(root, cp.sessionId);
-  await mkdir5(dir, { recursive: true });
+  await mkdir6(dir, { recursive: true });
   const { messages } = repairHistoryPairing(cp.messages);
   const { messages: _ignored, ...head } = cp;
   const metaCandidate = { ...head, schemaVersion: 1, messageCount: messages.length };
@@ -55552,7 +56424,7 @@ async function writeCheckpoint(root, cp, opts = {}) {
 async function readJsonFile(filePath) {
   let raw;
   try {
-    raw = await readFile7(filePath, "utf8");
+    raw = await readFile8(filePath, "utf8");
   } catch (err) {
     if (isErrnoException(err) && err.code === "ENOENT") return null;
     throw err;
@@ -55604,7 +56476,7 @@ async function listCheckpoints(root, sessionId) {
   const dir = checkpointsDirPath(root, sessionId);
   let names;
   try {
-    names = await readdir2(dir);
+    names = await readdir3(dir);
   } catch (err) {
     if (isErrnoException(err) && err.code === "ENOENT") return [];
     throw err;
@@ -55644,12 +56516,12 @@ async function deleteCheckpoint(root, sessionId, checkpointId, opts = {}) {
   const refs = opts.gcAttachments === false ? [] : await collectBodyRefs(bodyFilePath(dir, checkpointId));
   let existed = true;
   try {
-    await rm7(bodyFilePath(dir, checkpointId));
+    await rm8(bodyFilePath(dir, checkpointId));
   } catch (err) {
     if (!isErrnoException(err) || err.code !== "ENOENT") throw err;
     existed = false;
   }
-  await rm7(metaFilePath2(dir, checkpointId), { force: true });
+  await rm8(metaFilePath2(dir, checkpointId), { force: true });
   if (refs.length > 0) await gcAttachments(dir, refs);
   return existed;
 }
@@ -55667,7 +56539,7 @@ async function gcAttachments(dir, candidates) {
   const pending = new Set(candidates);
   let names;
   try {
-    names = await readdir2(dir);
+    names = await readdir3(dir);
   } catch (err) {
     if (isErrnoException(err) && err.code === "ENOENT") return;
     throw err;
@@ -55677,10 +56549,10 @@ async function gcAttachments(dir, candidates) {
     if (!name.endsWith(BODY_SUFFIX) || name.endsWith(META_SUFFIX)) continue;
     const id = name.slice(0, -BODY_SUFFIX.length);
     if (!CHECKPOINT_ID_PATTERN.test(id)) continue;
-    for (const hex of await collectBodyRefs(path10.join(dir, name))) pending.delete(hex);
+    for (const hex of await collectBodyRefs(path11.join(dir, name))) pending.delete(hex);
   }
   for (const hex of pending) {
-    await rm7(attachmentFilePath(dir, hex), { force: true });
+    await rm8(attachmentFilePath(dir, hex), { force: true });
   }
 }
 async function applyRetention(root, sessionId, reference, retention) {
@@ -55726,7 +56598,7 @@ function detachInlineImage(block, attachments) {
   if (!isRecord3(block)) return block;
   if (block["t"] === "image" && typeof block["data"] === "string" && block["$ref"] === void 0) {
     const bytes = Buffer.from(block["data"], "base64");
-    const hex = createHash11("sha256").update(bytes).digest("hex");
+    const hex = createHash13("sha256").update(bytes).digest("hex");
     attachments[hex] = bytes.toString("base64");
     return { t: "image", mime: block["mime"], $ref: `sha256:${hex}` };
   }
@@ -55787,9 +56659,9 @@ function decodeCheckpointImport(bytes, target) {
     );
   }
   for (const [hex, b64] of Object.entries(bundle.attachments)) {
-    const bytesOf = Buffer.from(b64, "base64");
-    if (bytesOf.toString("base64") !== b64.replace(/\s+/g, "")) throw importInvalid(`附件 ${hex} 不是合法 base64`);
-    const digest = createHash11("sha256").update(bytesOf).digest("hex");
+    const bytesOf2 = Buffer.from(b64, "base64");
+    if (bytesOf2.toString("base64") !== b64.replace(/\s+/g, "")) throw importInvalid(`附件 ${hex} 不是合法 base64`);
+    const digest = createHash13("sha256").update(bytesOf2).digest("hex");
     if (digest !== hex) throw importInvalid(`附件 ${hex} 字节摘要不符(实为 ${digest})`);
   }
   const messages = [];
@@ -55820,11 +56692,11 @@ function decodeCheckpointImport(bytes, target) {
 }
 
 // ../kernel/src/journal/rotate.ts
-import { access as access4, mkdir as mkdir6, readdir as readdir3, readFile as readFile8, rm as rm8, stat as stat5 } from "node:fs/promises";
-import path11 from "node:path";
+import { access as access4, mkdir as mkdir7, readdir as readdir4, readFile as readFile9, rm as rm9, stat as stat6 } from "node:fs/promises";
+import path12 from "node:path";
 var ROTATION_NEXT_FILE_NAME = "journal.next.jsonl";
 function rotationNextPath(sessionDir) {
-  return path11.join(sessionDir, ROTATION_NEXT_FILE_NAME);
+  return path12.join(sessionDir, ROTATION_NEXT_FILE_NAME);
 }
 async function fileExists2(filePath) {
   try {
@@ -55859,28 +56731,28 @@ async function moveTempAttachments(tempDir, sessionDir) {
   const tempAttachments = attachmentsDirPath(tempDir);
   let names = [];
   try {
-    names = await readdir3(tempAttachments);
+    names = await readdir4(tempAttachments);
   } catch {
     names = [];
   }
   if (names.length === 0) return;
   const target = attachmentsDirPath(sessionDir);
-  await mkdir6(target, { recursive: true });
+  await mkdir7(target, { recursive: true });
   for (const name of names) {
-    await renameWithRetry(path11.join(tempAttachments, name), path11.join(target, name));
+    await renameWithRetry(path12.join(tempAttachments, name), path12.join(target, name));
   }
 }
 async function copyReferencedAttachments(tempDir, sessionDir, from) {
   const { records } = await readAll(tempDir, { rehydrateImages: false });
   const refs = collectImageRefs2(records.map((r) => r.payload));
   if (refs.length === 0) return;
-  await mkdir6(attachmentsDirPath(sessionDir), { recursive: true });
+  await mkdir7(attachmentsDirPath(sessionDir), { recursive: true });
   for (const hex of refs) {
     const target = attachmentFilePath(sessionDir, hex);
     if (await fileExists2(target)) continue;
     let bytes;
     try {
-      bytes = await readFile8(attachmentFilePath(from, hex));
+      bytes = await readFile9(attachmentFilePath(from, hex));
     } catch (err) {
       if (isErrnoException(err) && err.code === "ENOENT") continue;
       throw err;
@@ -55896,8 +56768,8 @@ async function settleVolume(sessionDir) {
   return true;
 }
 async function rotateVolume(sessionDir, build, opts = {}) {
-  const tempDir = path11.join(sessionDir, `.rotate-${process.pid}-${Date.now().toString(36)}`);
-  await mkdir6(tempDir, { recursive: true });
+  const tempDir = path12.join(sessionDir, `.rotate-${process.pid}-${Date.now().toString(36)}`);
+  await mkdir7(tempDir, { recursive: true });
   try {
     const writer = await JournalWriter.open(tempDir);
     let cursor;
@@ -55913,16 +56785,16 @@ async function rotateVolume(sessionDir, build, opts = {}) {
     }
     await renameWithRetry(journalFilePath(tempDir), rotationNextPath(sessionDir));
     await settleVolume(sessionDir);
-    const { mtimeMs } = await stat5(journalFilePath(sessionDir));
+    const { mtimeMs } = await stat6(journalFilePath(sessionDir));
     return { ...cursor, mtimeMs };
   } finally {
-    await rm8(tempDir, { recursive: true, force: true }).catch(() => void 0);
+    await rm9(tempDir, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 
 // ../kernel/src/journal/fork.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { access as access5, mkdir as mkdir7, readFile as readFile9, stat as stat6 } from "node:fs/promises";
+import { access as access5, mkdir as mkdir8, readFile as readFile10, stat as stat7 } from "node:fs/promises";
 var FORK_DEFAULT_PRODUCER = "kernel";
 function journalKindOf(message) {
   if (message.role === "assistant") return "assistant_message";
@@ -55958,13 +56830,13 @@ async function pathExists(filePath) {
 }
 async function copyRefAttachments(refs, from, sessionDir) {
   if (refs.length === 0) return;
-  await mkdir7(attachmentsDirPath(sessionDir), { recursive: true });
+  await mkdir8(attachmentsDirPath(sessionDir), { recursive: true });
   for (const hex of refs) {
     const target = attachmentFilePath(sessionDir, hex);
     if (await pathExists(target)) continue;
     let bytes;
     try {
-      bytes = await readFile9(attachmentFilePath(from, hex));
+      bytes = await readFile10(attachmentFilePath(from, hex));
     } catch (err) {
       if (isErrnoException(err) && err.code === "ENOENT") continue;
       throw err;
@@ -56059,27 +56931,27 @@ async function forkSessionFromCheckpoint(input) {
   } finally {
     await lock.release();
   }
-  const { mtimeMs } = await stat6(journalFilePath(sessionDir));
+  const { mtimeMs } = await stat7(journalFilePath(sessionDir));
   return { sessionId, sessionDir, cursor: { ...cursor, mtimeMs } };
 }
 
 // ../kernel/src/session/cwd.ts
-import { realpath, stat as stat7 } from "node:fs/promises";
-import path12 from "node:path";
+import { realpath, stat as stat8 } from "node:fs/promises";
+import path13 from "node:path";
 var CASE_INSENSITIVE = process.platform === "win32";
 function insideRealSubtree(child, base) {
   const c = CASE_INSENSITIVE ? child.toLowerCase() : child;
   const b = CASE_INSENSITIVE ? base.toLowerCase() : base;
-  const rel = path12.relative(b, c);
-  return rel === "" || !rel.startsWith("..") && !path12.isAbsolute(rel);
+  const rel = path13.relative(b, c);
+  return rel === "" || !rel.startsWith("..") && !path13.isAbsolute(rel);
 }
 async function probeDirectory(candidate) {
-  if (!path12.isAbsolute(candidate)) {
+  if (!path13.isAbsolute(candidate)) {
     return { ok: false, reason: "not_absolute", detail: `cwd 须为绝对路径(不展开 ~):${candidate}` };
   }
   let isDirectory;
   try {
-    isDirectory = (await stat7(candidate)).isDirectory();
+    isDirectory = (await stat8(candidate)).isDirectory();
   } catch (err) {
     const code = isErrnoException(err) ? err.code : void 0;
     return { ok: false, reason: "not_found", detail: `cwd 不可访问(${code ?? "io error"}):${candidate}` };
@@ -56107,7 +56979,7 @@ async function resolveSessionCwd(input) {
     };
   }
   if ("resolve" in policy) {
-    if (!path12.isAbsolute(requested)) {
+    if (!path13.isAbsolute(requested)) {
       return { ok: false, reason: "not_absolute", detail: `cwd 须为绝对路径(不展开 ~):${requested}` };
     }
     let resolved;
@@ -56122,7 +56994,7 @@ async function resolveSessionCwd(input) {
     }
     const probed2 = await probeDirectory(resolved);
     if (!probed2.ok) return probed2;
-    return { ok: true, cwd: path12.resolve(resolved) };
+    return { ok: true, cwd: path13.resolve(resolved) };
   }
   const probed = await probeDirectory(requested);
   if (!probed.ok) return probed;
@@ -56133,7 +57005,7 @@ async function resolveSessionCwd(input) {
     } catch {
       continue;
     }
-    if (insideRealSubtree(probed.real, realRoot)) return { ok: true, cwd: path12.resolve(requested) };
+    if (insideRealSubtree(probed.real, realRoot)) return { ok: true, cwd: path13.resolve(requested) };
   }
   return {
     ok: false,
@@ -56516,7 +57388,7 @@ var SESSION_EVENT_VOCABULARY = {
 var SESSION_EVENT_KINDS = Object.keys(SESSION_EVENT_VOCABULARY);
 
 // ../kernel/src/tools/files/read.ts
-import path13 from "node:path";
+import path14 from "node:path";
 import { z as z19 } from "zod";
 
 // ../kernel/src/tools/files/encoding.ts
@@ -56583,19 +57455,19 @@ function truncateLine(line) {
   return `${line.slice(0, cut)}…[line truncated: ${line.length} chars total; use Grep to inspect the rest]`;
 }
 async function findSimilarFiles(fs2, filePath) {
-  const dir = path13.dirname(filePath);
-  const targetBase = path13.basename(filePath);
-  const targetName = path13.parse(filePath).name.toLowerCase();
+  const dir = path14.dirname(filePath);
+  const targetBase = path14.basename(filePath);
+  const targetName = path14.parse(filePath).name.toLowerCase();
   try {
     const entries = await fs2.readdir(dir);
     return entries.filter((entry) => entry.isFile()).map((entry) => entry.name).filter(
-      (name) => name.toLowerCase() !== targetBase.toLowerCase() && path13.parse(name).name.toLowerCase() === targetName
-    ).slice(0, 3).map((name) => path13.join(dir, name));
+      (name) => name.toLowerCase() !== targetBase.toLowerCase() && path14.parse(name).name.toLowerCase() === targetName
+    ).slice(0, 3).map((name) => path14.join(dir, name));
   } catch {
     return [];
   }
 }
-async function executeImageRead(resolved, args, ctx, fs2, stat10, options) {
+async function executeImageRead(resolved, args, ctx, fs2, stat11, options) {
   let mode;
   try {
     mode = options.imageInput?.();
@@ -56614,9 +57486,9 @@ async function executeImageRead(resolved, args, ctx, fs2, stat10, options) {
       "offset/limit apply to text files only. Call Read again without offset/limit to read this image file."
     );
   }
-  if (stat10.size > READ_IMAGE_RAW_MAX_BYTES) {
+  if (stat11.size > READ_IMAGE_RAW_MAX_BYTES) {
     return errorResult(
-      `Image file is ${stat10.size} bytes, which exceeds the per-image limit of ${READ_IMAGE_RAW_MAX_BYTES} bytes (5 MiB base64-encoded, aligned with the platform cap). Downscale or compress the image, then retry.`
+      `Image file is ${stat11.size} bytes, which exceeds the per-image limit of ${READ_IMAGE_RAW_MAX_BYTES} bytes (5 MiB base64-encoded, aligned with the platform cap). Downscale or compress the image, then retry.`
     );
   }
   let buf;
@@ -56631,10 +57503,10 @@ async function executeImageRead(resolved, args, ctx, fs2, stat10, options) {
   const probed = probeImage(buf);
   if (probed === null) {
     return errorResult(
-      `File has an image extension but its content is not a readable PNG/JPEG/GIF/WebP image (bad or truncated header): ${path13.basename(resolved)}. If it is actually a text file, rename it; otherwise re-export the image and retry.`
+      `File has an image extension but its content is not a readable PNG/JPEG/GIF/WebP image (bad or truncated header): ${path14.basename(resolved)}. If it is actually a text file, rename it; otherwise re-export the image and retry.`
     );
   }
-  registerFileRead(ctx, normalizeFileKey(resolved), stat10.mtimeMs);
+  registerFileRead(ctx, normalizeFileKey(resolved), stat11.mtimeMs);
   const data = {
     path: resolved,
     mime: probed.mime,
@@ -56642,7 +57514,7 @@ async function executeImageRead(resolved, args, ctx, fs2, stat10, options) {
     height: probed.height,
     bytes: buf.length
   };
-  const meta = `Image file: ${path13.basename(resolved)}
+  const meta = `Image file: ${path14.basename(resolved)}
 Format: ${probed.mime}
 Dimensions: ${probed.width}x${probed.height} px
 Size: ${buf.length} bytes`;
@@ -56665,8 +57537,8 @@ function createReadTool(options = {}) {
     isConcurrencySafe: true,
     touchedPathsOf(args) {
       const parsed = ReadArgsSchema.safeParse(args);
-      if (!parsed.success || !path13.isAbsolute(parsed.data.file_path)) return [];
-      return [path13.resolve(parsed.data.file_path)];
+      if (!parsed.success || !path14.isAbsolute(parsed.data.file_path)) return [];
+      return [path14.resolve(parsed.data.file_path)];
     },
     async execute(args, ctx) {
       if (ctx.signal.aborted) {
@@ -56680,15 +57552,15 @@ function createReadTool(options = {}) {
       if (invalid) {
         return invalid;
       }
-      const resolved = path13.resolve(args.file_path);
+      const resolved = path14.resolve(args.file_path);
       const fs2 = fsOf(ctx);
       const realTarget = await checkRealTarget("Read", resolved, { cwd: ctx.cwd, access: "read", fs: fs2 });
       if (!realTarget.ok) {
         return errorResult(realTarget.reason);
       }
-      let stat10;
+      let stat11;
       try {
-        stat10 = await fs2.stat(resolved);
+        stat11 = await fs2.stat(resolved);
       } catch (err) {
         if (fsErrorCode(err) === "ENOENT") {
           const similar = await findSimilarFiles(fs2, resolved);
@@ -56697,11 +57569,11 @@ function createReadTool(options = {}) {
         }
         return errorResult(`Failed to read file: ${errorMessageOf2(err)}`);
       }
-      if (stat10.isDirectory()) {
+      if (stat11.isDirectory()) {
         return errorResult(`Path is a directory, not a file: ${resolved}.`);
       }
-      if (isImageFileExtension(path13.extname(resolved))) {
-        return executeImageRead(resolved, args, ctx, fs2, stat10, options);
+      if (isImageFileExtension(path14.extname(resolved))) {
+        return executeImageRead(resolved, args, ctx, fs2, stat11, options);
       }
       const fileKey = normalizeFileKey(resolved);
       const effectiveOffset = args.offset ?? 1;
@@ -56709,7 +57581,7 @@ function createReadTool(options = {}) {
       const dupWindow = takeDuplicateReadWindow(
         ctx,
         fileKey,
-        stat10.mtimeMs,
+        stat11.mtimeMs,
         effectiveOffset,
         effectiveLimit
       );
@@ -56726,9 +57598,9 @@ function createReadTool(options = {}) {
           data2
         );
       }
-      if (stat10.size > READ_MAX_FULL_BYTES && args.offset === void 0 && args.limit === void 0) {
+      if (stat11.size > READ_MAX_FULL_BYTES && args.offset === void 0 && args.limit === void 0) {
         return errorResult(
-          `File is ${stat10.size} bytes, which exceeds the ${READ_MAX_FULL_BYTES}-byte limit for reading the whole file at once (large files inflate context: this one would be roughly ${Math.ceil(stat10.size / 4)}+ tokens). Use the offset and limit parameters to read it in pages, or use Grep to locate the relevant sections first.`
+          `File is ${stat11.size} bytes, which exceeds the ${READ_MAX_FULL_BYTES}-byte limit for reading the whole file at once (large files inflate context: this one would be roughly ${Math.ceil(stat11.size / 4)}+ tokens). Use the offset and limit parameters to read it in pages, or use Grep to locate the relevant sections first.`
         );
       }
       let buf;
@@ -56747,7 +57619,7 @@ function createReadTool(options = {}) {
         );
       }
       if (decoded.text.length === 0) {
-        registerFileRead(ctx, fileKey, stat10.mtimeMs, {
+        registerFileRead(ctx, fileKey, stat11.mtimeMs, {
           offset: effectiveOffset,
           limit: effectiveLimit,
           totalLines: 0,
@@ -56761,7 +57633,7 @@ function createReadTool(options = {}) {
       const startLine = effectiveOffset;
       const maxLines = effectiveLimit;
       if (startLine > totalLines) {
-        registerFileRead(ctx, fileKey, stat10.mtimeMs, {
+        registerFileRead(ctx, fileKey, stat11.mtimeMs, {
           offset: effectiveOffset,
           limit: effectiveLimit,
           totalLines,
@@ -56780,7 +57652,7 @@ function createReadTool(options = {}) {
         text += `
 … (showing lines ${startLine}-${endLine} of ${totalLines}; use offset=${endLine + 1} to continue)`;
       }
-      registerFileRead(ctx, fileKey, stat10.mtimeMs, {
+      registerFileRead(ctx, fileKey, stat11.mtimeMs, {
         offset: effectiveOffset,
         limit: effectiveLimit,
         totalLines,
@@ -58056,35 +58928,35 @@ var SUBAGENT_TYPE_TIER_MAP = {
   "test-runner": "inherit"
 };
 function assertDispatchPolicyInvariants() {
-  const fail = (detail) => {
+  const fail2 = (detail) => {
     throw new Error(`dispatch-policy 不变式违约(装载期 fail-fast):${detail}`);
   };
   const tierList = SUBAGENT_DISPATCH_TIERS;
   const defaultTier = DEFAULT_SUBAGENT_DISPATCH_TIER;
-  if (tierList.length === 0) fail("档位词表不得为空");
+  if (tierList.length === 0) fail2("档位词表不得为空");
   if (new Set(tierList).size !== tierList.length) {
-    fail("档位词表存在重复项");
+    fail2("档位词表存在重复项");
   }
   if (!tierList.includes("inherit")) {
-    fail("档位词表必含 'inherit'(fail-safe 锚:未知类型/回落链尽头的现状档)");
+    fail2("档位词表必含 'inherit'(fail-safe 锚:未知类型/回落链尽头的现状档)");
   }
   if (defaultTier !== "inherit") {
-    fail(
+    fail2(
       `缺省档位必须为 'inherit'(新增/未知类型恒不降档的 fail-safe 语义),得到 '${defaultTier}'`
     );
   }
   const tiers = new Set(SUBAGENT_DISPATCH_TIERS);
   for (const [name, tier] of Object.entries(SUBAGENT_TYPE_TIER_MAP)) {
     if (!AGENT_NAME_RE.test(name)) {
-      fail(`映射表键 '${name}' 不符合代理名约束(${String(AGENT_NAME_RE)})`);
+      fail2(`映射表键 '${name}' 不符合代理名约束(${String(AGENT_NAME_RE)})`);
     }
     if (!tiers.has(tier)) {
-      fail(`映射表值 '${tier}'(键 '${name}')不在档位词表内`);
+      fail2(`映射表值 '${tier}'(键 '${name}')不在档位词表内`);
     }
   }
   for (const template of BUILTIN_AGENT_TEMPLATES) {
     if (SUBAGENT_TYPE_TIER_MAP[template.name] === void 0) {
-      fail(
+      fail2(
         `内置模板 '${template.name}' 未在 SUBAGENT_TYPE_TIER_MAP 显式登记档位——新增内置类型必须做一次显式档位决策(fail-safe 建制)`
       );
     }
@@ -58741,8 +59613,8 @@ function suggestedAudioName(audio) {
 async function sinkInlineAudio(sink, audio) {
   try {
     const bytes = new Uint8Array(Buffer.from(audio.b64, "base64"));
-    const path17 = await sink(bytes, audio.mime, suggestedAudioName(audio));
-    return { path: path17 };
+    const path18 = await sink(bytes, audio.mime, suggestedAudioName(audio));
+    return { path: path18 };
   } catch (err) {
     return { error: err instanceof Error ? err.message : String(err) };
   }
@@ -60130,7 +61002,7 @@ function createServeObservability(deps) {
   let requestsTotal = 0;
   let closed = false;
   const eventLoopDelay = () => eld.sample();
-  const collect = () => {
+  const collect2 = () => {
     const v1 = deps.v1Active();
     const v2 = deps.v2();
     metrics.sessionsActive.set(v1, { face: "v1" });
@@ -60138,10 +61010,10 @@ function createServeObservability(deps) {
     if (v2?.pending !== void 0) metrics.sessionsPending.set(v2.pending);
     if (v2?.retainedEnded !== void 0) metrics.sessionsRetainedEnded.set(v2.retainedEnded);
     metrics.sseConnectionsActive.set(sseOpen);
-    const delay = eventLoopDelay();
-    metrics.eventLoopDelayMs.set(delay.p50, { stat: "p50" });
-    metrics.eventLoopDelayMs.set(delay.p99, { stat: "p99" });
-    metrics.eventLoopDelayMs.set(delay.max, { stat: "max" });
+    const delay2 = eventLoopDelay();
+    metrics.eventLoopDelayMs.set(delay2.p50, { stat: "p50" });
+    metrics.eventLoopDelayMs.set(delay2.p99, { stat: "p99" });
+    metrics.eventLoopDelayMs.set(delay2.max, { stat: "max" });
     metrics.residentMemoryBytes.set(process.memoryUsage.rss());
     const notifier = deps.notifierStats();
     if (notifier !== void 0) {
@@ -60176,7 +61048,7 @@ function createServeObservability(deps) {
       return void 0;
     }
   };
-  const offCollect = registry.onCollect(collect);
+  const offCollect = registry.onCollect(collect2);
   const readiness = () => {
     const reasons = [];
     if (deps.closing()) reasons.push("closing");
@@ -61351,8 +62223,8 @@ var TansrSdkError = class extends Error {
 };
 
 // ../sdk/src/skills.ts
-import path14 from "node:path";
-var NO_DISCOVERY_ROOT = path14.resolve(path14.sep, ".tansr-sdk-no-discovery");
+import path15 from "node:path";
+var NO_DISCOVERY_ROOT = path15.resolve(path15.sep, ".tansr-sdk-no-discovery");
 
 // ../providers/src/anthropic/wire.ts
 function asRecord(v) {
@@ -63429,7 +64301,7 @@ var OpenAIResponsesAdapter = class {
 };
 
 // ../providers/src/retry/attempt-observer.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 var PROVIDER_CALL_META_FIELD = "callMeta";
 function providerCallMetaOf(options) {
   if (options === void 0) return void 0;
@@ -63458,12 +64330,12 @@ function endpointKeyOf(baseUrl) {
   let normalized;
   try {
     const url = new URL(baseUrl);
-    const path17 = url.pathname.replace(/\/+$/, "");
-    normalized = `${url.protocol}//${url.host}${path17}`.toLowerCase();
+    const path18 = url.pathname.replace(/\/+$/, "");
+    normalized = `${url.protocol}//${url.host}${path18}`.toLowerCase();
   } catch {
     normalized = baseUrl.trim().replace(/\/+$/, "").toLowerCase();
   }
-  return createHash12("sha256").update(normalized, "utf8").digest("hex").slice(0, 16);
+  return createHash14("sha256").update(normalized, "utf8").digest("hex").slice(0, 16);
 }
 function safeAttemptCall(fn) {
   if (fn === void 0) return;
@@ -63616,16 +64488,16 @@ function sendableTwpReasoningContent(features) {
 }
 
 // ../providers/src/twp/signing.ts
-import { createHash as createHash13, createHmac as createHmac2, randomBytes as randomBytes3 } from "node:crypto";
+import { createHash as createHash15, createHmac as createHmac2, randomBytes as randomBytes4 } from "node:crypto";
 var TWP_SIGNING_ALGORITHM = "TWP1-HMAC-SHA256";
 var TWP_NONCE_LENGTH = 24;
 function deriveTwpSigningKey(secretKey) {
-  return createHash13("sha256").update(secretKey, "utf8").digest();
+  return createHash15("sha256").update(secretKey, "utf8").digest();
 }
 function sha256Hex2(data) {
-  return createHash13("sha256").update(typeof data === "string" ? Buffer.from(data, "utf8") : data).digest("hex");
+  return createHash15("sha256").update(typeof data === "string" ? Buffer.from(data, "utf8") : data).digest("hex");
 }
-function generateTwpNonce(random = randomBytes3) {
+function generateTwpNonce(random = randomBytes4) {
   return random(TWP_NONCE_LENGTH / 2).toString("hex");
 }
 function buildTwpSigningString(input) {
@@ -64642,9 +65514,9 @@ var MissingApiKeyError = class extends ProviderRegistryError {
 var CyclicFallbackError = class extends ProviderRegistryError {
   /** 成环路径,末项为再次出现的别名,如 ['main','fast','main'] */
   path;
-  constructor(path17) {
-    super("cyclic_fallback", `Cyclic fallback chain: ${path17.join(" -> ")}`);
-    this.path = path17;
+  constructor(path18) {
+    super("cyclic_fallback", `Cyclic fallback chain: ${path18.join(" -> ")}`);
+    this.path = path18;
   }
 };
 
@@ -65132,9 +66004,9 @@ function pushUnique(out, seen, resolved) {
   seen.add(dedupeKey);
   out.push(resolved);
 }
-function expandInto(config, alias, path17, out, seen) {
-  if (path17.includes(alias)) throw new CyclicFallbackError([...path17, alias]);
-  const nextPath = [...path17, alias];
+function expandInto(config, alias, path18, out, seen) {
+  if (path18.includes(alias)) throw new CyclicFallbackError([...path18, alias]);
+  const nextPath = [...path18, alias];
   pushUnique(out, seen, resolveAliasOrRef(config, alias));
   for (const entry of config.fallbacks[alias] ?? []) {
     if (entry.includes("/")) {
@@ -66068,7 +66940,7 @@ function createTokenBucket(origin, options) {
       waiter.signal.removeEventListener("abort", waiter.onAbort);
     }
   };
-  const drain = () => {
+  const drain2 = () => {
     refill();
     while (queue.length > 0 && tokens >= 1) {
       const waiter = queue.shift();
@@ -66085,7 +66957,7 @@ function createTokenBucket(origin, options) {
     const waitMs = Math.max(1, Math.ceil(needed / ratePerMs));
     refillTimer = clock.setTimeout(() => {
       refillTimer = void 0;
-      drain();
+      drain2();
     }, waitMs);
   };
   const detail = () => `tokens ${tokens.toFixed(2)}/${burst} @ ${ratePerMinute}/min, queued ${queue.length}/${maxQueue}`;
@@ -68653,7 +69525,7 @@ function buildClientFromRegistry(registry, aliasOrRef, onProviderSelected) {
 }
 
 // ../sdk/src/adjudication/prompts.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 var STAGE1_MAX_TOKENS = 64;
 var STAGE2_MAX_TOKENS = 1024;
 var TWO_STAGE_TIMEOUT_MS = 15e3;
@@ -68750,7 +69622,7 @@ function serializeTimeoutPolicy(policy) {
   ].join(";");
 }
 function makeProtocolFingerprint(components) {
-  return createHash14("sha256").update(components.join("\n\0")).digest("hex").slice(0, 16);
+  return createHash16("sha256").update(components.join("\n\0")).digest("hex").slice(0, 16);
 }
 var PAYLOAD_VERSION_COMPONENT = "payload:v4-engine-facts-shell";
 var SETTLE_COMPONENT = "settle:verdict-first";
@@ -69928,7 +70800,7 @@ function platformErrorOf(body, status) {
 }
 
 // ../sdk/src/platform/bundle-cache.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 var DEFAULT_BUNDLE_CACHE_TTL_MS = 6e4;
 var DEFAULT_MAX_BUNDLE_ENTRIES = 16;
 var DEFAULT_MAX_FEATURE_ENTRIES = 1e5;
@@ -69968,7 +70840,7 @@ var Lru = class {
   }
 };
 function tokenScope(token) {
-  return createHash15("sha256").update(token, "utf8").digest("hex");
+  return createHash17("sha256").update(token, "utf8").digest("hex");
 }
 function bundleKey(base, appId) {
   return `${base}\0${appId ?? ""}`;
@@ -70237,9 +71109,9 @@ function stripReminderBlocks(messages) {
 }
 
 // src/v2/agent-session-store.ts
-import { createHash as createHash16, randomUUID as randomUUID10 } from "node:crypto";
-import { access as access6, mkdir as mkdir8, readFile as readFile10, rm as rm9, stat as stat8 } from "node:fs/promises";
-import path15 from "node:path";
+import { createHash as createHash18, randomUUID as randomUUID10 } from "node:crypto";
+import { access as access6, mkdir as mkdir9, readFile as readFile11, rm as rm10, stat as stat9 } from "node:fs/promises";
+import path16 from "node:path";
 var AgentSessionStoreError = class extends Error {
   code = "session_store_corrupted";
   constructor(sessionId, detail, cause) {
@@ -70251,7 +71123,7 @@ var AgentSessionStoreError = class extends Error {
   }
 };
 function endUserKeyOf(endUserId) {
-  return createHash16("sha256").update(endUserId, "utf8").digest("hex").slice(0, 16);
+  return createHash18("sha256").update(endUserId, "utf8").digest("hex").slice(0, 16);
 }
 async function fileExists3(filePath) {
   try {
@@ -70285,7 +71157,7 @@ function sessionTitleOf(messages) {
 }
 async function readRawMeta(sessionDir) {
   try {
-    const parsed = JSON.parse(await readFile10(metaFilePath(sessionDir), "utf8"));
+    const parsed = JSON.parse(await readFile11(metaFilePath(sessionDir), "utf8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -70444,7 +71316,7 @@ function createServeAgentSessionStore(options) {
     });
     return task;
   }
-  const domainRootOfKey = (endUserKey) => path15.join(options.dir, "agent-sessions", endUserKey);
+  const domainRootOfKey = (endUserKey) => path16.join(options.dir, "agent-sessions", endUserKey);
   const domainRoot = (endUserId) => domainRootOfKey(endUserKeyOf(endUserId));
   const hooksOf = (sessionId, endUserKey, sessionDir) => tier?.bind({ sessionId, endUserKey, sessionDir });
   const writerOptionsFor = (hooks) => hooks === void 0 ? writerOptions : { ...writerOptions, onSegmentSealed: hooks.onSegmentSealed };
@@ -70473,7 +71345,7 @@ function createServeAgentSessionStore(options) {
     cursors.set(key2, tail);
   }
   async function withMtime(sessionDir, cursor) {
-    const { mtimeMs } = await stat8(journalFilePath(sessionDir));
+    const { mtimeMs } = await stat9(journalFilePath(sessionDir));
     return { ...cursor, mtimeMs };
   }
   async function patchRawMeta(sessionDir, mutate) {
@@ -70544,16 +71416,16 @@ function createServeAgentSessionStore(options) {
     }
     if (await readRawMeta(sessionDir) !== null) return false;
     const existed = await fileExists3(sessionDir);
-    await mkdir8(sessionDir, { recursive: true });
+    await mkdir9(sessionDir, { recursive: true });
     let restored;
     try {
       restored = await tier.restore({ sessionId, endUserKey, sessionDir });
     } catch (err) {
-      if (!existed) await rm9(sessionDir, { recursive: true, force: true }).catch(() => void 0);
+      if (!existed) await rm10(sessionDir, { recursive: true, force: true }).catch(() => void 0);
       throw readError(sessionId, err);
     }
     if (restored === null) {
-      if (!existed) await rm9(sessionDir, { recursive: true, force: true }).catch(() => void 0);
+      if (!existed) await rm10(sessionDir, { recursive: true, force: true }).catch(() => void 0);
       return false;
     }
     const cold = restored.meta;
@@ -70767,7 +71639,7 @@ function createServeAgentSessionStore(options) {
           tier.unbind(sessionDir);
           await tier.remove({ sessionId, endUserKey });
         }
-        await rm9(sessionDir, { recursive: true, force: true });
+        await rm10(sessionDir, { recursive: true, force: true });
         await indexOf(storageRoot).remove(sessionId);
       });
     },
@@ -73566,7 +74438,7 @@ async function startServer(options) {
   };
   let closed = false;
   let draining;
-  const drain = async (drainOptions = {}) => {
+  const drain2 = async (drainOptions = {}) => {
     const timeoutMs = drainOptions.timeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
     const startedAt2 = Date.now();
     closing = true;
@@ -73623,7 +74495,7 @@ async function startServer(options) {
     readiness: () => admission.readiness(),
     drain: (drainOptions) => {
       if (draining === void 0) {
-        draining = closed ? Promise.resolve({ completedTurns: 0, abortedTurns: 0, flushedCommits: 0, durationMs: 0 }) : drain(drainOptions);
+        draining = closed ? Promise.resolve({ completedTurns: 0, abortedTurns: 0, flushedCommits: 0, durationMs: 0 }) : drain2(drainOptions);
       }
       return draining;
     },
@@ -73842,7 +74714,7 @@ function appliedRuntimeEnvByGroup(resolved, ...groups) {
 
 // src/v2/agent-session-factory.ts
 import { randomUUID as randomUUID15 } from "node:crypto";
-import { stat as stat9 } from "node:fs/promises";
+import { stat as stat10 } from "node:fs/promises";
 
 // src/v2/agent-bridges.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
@@ -74246,7 +75118,7 @@ function buildRemoteTool(decl, bridge, now = Date.now) {
 }
 
 // src/v2/checkpoints.ts
-import path16 from "node:path";
+import path17 from "node:path";
 function isInvalidIdError(err) {
   return err instanceof JournalError && err.code === "INVALID_CHECKPOINT_ID";
 }
@@ -74256,7 +75128,7 @@ function createServeCheckpointStore(options) {
       'createServeCheckpointStore requires exactly one of "dir" (standalone root) or "rootOf" (co-located root resolver)'
     );
   }
-  const rootOf = options.rootOf ?? ((endUserId) => path16.join(options.dir, "agent-checkpoints", endUserKeyOf(endUserId)));
+  const rootOf = options.rootOf ?? ((endUserId) => path17.join(options.dir, "agent-checkpoints", endUserKeyOf(endUserId)));
   const writeOptions = options.max !== void 0 ? { max: options.max } : {};
   return {
     put(endUserId, checkpoint, putOptions) {
@@ -76047,7 +76919,7 @@ async function reconcileResumeCwd(storedCwd, currentCwd, mode) {
   }
   let isDirectory = false;
   try {
-    isDirectory = (await stat9(storedCwd)).isDirectory();
+    isDirectory = (await stat10(storedCwd)).isDirectory();
   } catch {
     isDirectory = false;
   }
@@ -76226,6 +77098,8 @@ export {
   createAgentSessionFactory,
   createAppTokenMinter,
   createBundleCache,
+  createChaosBlobStore,
+  createFsBlobStore,
   createMemoryBlobStore,
   createMetricsRegistry,
   createPlatformServeSessionFactory,
@@ -76260,6 +77134,7 @@ export {
   resolveUpstreamFetch,
   routeTemplateOf,
   runIdleCompaction2 as runIdleCompaction,
+  runStorageConformance,
   serveMetricsFor,
   sessionIdShardOf,
   sessionIdShardPrefix,