@tansr/sdk 0.11.0 → 0.11.1

package/dist/index.js

@@ -16,20 +16,20 @@ var TOOL_EFFECTS = ["irreversible", "financial", "external", "affects-others"];
 // ../kernel/src/world/default-fs.ts
 import fs from "node:fs/promises";
 var defaultFs = {
-  stat(path28) {
-    return fs.stat(path28);
+  stat(path29) {
+    return fs.stat(path29);
   },
-  lstat(path28) {
-    return fs.lstat(path28);
+  lstat(path29) {
+    return fs.lstat(path29);
   },
-  realpath(path28) {
-    return fs.realpath(path28);
+  realpath(path29) {
+    return fs.realpath(path29);
   },
-  readFile(path28) {
-    return fs.readFile(path28);
+  readFile(path29) {
+    return fs.readFile(path29);
   },
-  async readFilePrefix(path28, bytes) {
-    const handle = await fs.open(path28, "r");
+  async readFilePrefix(path29, bytes) {
+    const handle = await fs.open(path29, "r");
     try {
       const prefix = Buffer.alloc(bytes);
       const { bytesRead } = await handle.read(prefix, 0, bytes, 0);
@@ -38,17 +38,17 @@ var defaultFs = {
       await handle.close();
     }
   },
-  async writeFile(path28, data) {
-    await fs.writeFile(path28, data);
+  async writeFile(path29, data) {
+    await fs.writeFile(path29, data);
   },
-  async appendFile(path28, data) {
-    await fs.appendFile(path28, data);
+  async appendFile(path29, data) {
+    await fs.appendFile(path29, data);
   },
-  async mkdir(path28, opts) {
-    await fs.mkdir(path28, opts);
+  async mkdir(path29, opts) {
+    await fs.mkdir(path29, opts);
   },
-  readdir(path28) {
-    return fs.readdir(path28, { withFileTypes: true });
+  readdir(path29) {
+    return fs.readdir(path29, { withFileTypes: true });
   }
 };
 
@@ -3456,29 +3456,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();
@@ -4342,63 +4342,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();
@@ -4602,74 +4602,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}):升级恒收窄`
     );
   }
@@ -11845,10 +11845,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",
@@ -11942,13 +11942,13 @@ function canonicalCwd(cwd) {
   const resolved = resolveForPermission(cwd, ".");
   return resolved.kind === "ok" ? resolved.path : null;
 }
-function canonicalPathEligible(cwdCanon, path28, policy, guard) {
-  if (hasWindowsDeviceSegment(path28)) return false;
-  if (path28 === cwdCanon) return !policy.strict;
-  if (!path28.startsWith(`${cwdCanon}/`)) return false;
-  if (guard.isProtectedContentPath(path28)) return false;
-  if (matchProtectedPath(path28, null) !== null) return false;
-  const segments = path28.slice(cwdCanon.length + 1).split("/");
+function canonicalPathEligible(cwdCanon, path29, policy, guard) {
+  if (hasWindowsDeviceSegment(path29)) return false;
+  if (path29 === cwdCanon) return !policy.strict;
+  if (!path29.startsWith(`${cwdCanon}/`)) return false;
+  if (guard.isProtectedContentPath(path29)) return false;
+  if (matchProtectedPath(path29, null) !== null) return false;
+  const segments = path29.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;
@@ -12132,9 +12132,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(path28, root) {
+function pathInsideRoot(path29, root) {
   if (root === null) return false;
-  return path28 === root || path28.startsWith(root.endsWith("/") ? root : `${root}/`);
+  return path29 === root || path29.startsWith(root.endsWith("/") ? root : `${root}/`);
 }
 function classifySoftenFace(input, base) {
   if (base.matchedRule?.startsWith(PROTECTED_PATH_RULE_PREFIX) === true) return "F6";
@@ -14096,14 +14096,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();
       }
@@ -14131,7 +14131,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);
@@ -14558,7 +14558,7 @@ var DispatchingToolExecutor = class _DispatchingToolExecutor {
     }
     try {
       yield* waitUntil(() => inFlight === 0);
-      yield* drain();
+      yield* drain2();
     } finally {
       ctx.signal.removeEventListener("abort", onCtxAbort);
     }
@@ -14838,10 +14838,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);
     }
   }
 }
@@ -15110,13 +15110,13 @@ async function externalizeOne(block, sessionDir) {
     const bytes = Buffer.from(block["data"], "base64");
     const hex = createHash6("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);
     }
@@ -15416,13 +15416,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;
 }
@@ -15699,9 +15699,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;
@@ -16343,8 +16343,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);
@@ -16827,9 +16827,881 @@ function createColdManifestStore(options) {
   };
 }
 
+// ../kernel/src/journal/segmented/fs-blob-store.ts
+import { createHash as createHash9, 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((resolve2) => {
+      release = resolve2;
+    });
+    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 = createHash9("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 createHash10 } 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 createHash10("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 = createHash10("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((resolve2) => setTimeout(resolve2, 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);
@@ -16861,8 +17733,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 {
@@ -17089,13 +17961,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");
@@ -17161,7 +18033,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() {
@@ -17187,7 +18059,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;
       }
@@ -17217,7 +18089,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;
       }
@@ -17244,7 +18116,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);
@@ -17256,7 +18128,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) {
@@ -17399,7 +18271,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) {
@@ -17458,11 +18330,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;
@@ -17477,7 +18349,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;
   }
   /** 全部存活条目(无序;调用方自行排序/截断) */
@@ -17541,14 +18413,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;
     }
@@ -17585,7 +18457,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;
@@ -17626,13 +18498,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 };
@@ -17652,7 +18524,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;
@@ -17683,9 +18555,9 @@ var SessionIndex = class {
 };
 
 // ../kernel/src/journal/checkpoints.ts
-import { createHash as createHash9, 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 createHash11, 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 z17 } from "zod";
 var ContextCheckpointTriggerSchema = z17.enum([
   "manual",
@@ -17739,7 +18611,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 = "";
@@ -17762,13 +18634,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})$/;
@@ -17800,7 +18672,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;
@@ -17812,7 +18684,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;
@@ -17829,7 +18701,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 };
@@ -17852,7 +18724,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;
@@ -17904,7 +18776,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;
@@ -17944,12 +18816,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;
 }
@@ -17967,7 +18839,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;
@@ -17977,10 +18849,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) {
@@ -18026,7 +18898,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 = createHash9("sha256").update(bytes).digest("hex");
+    const hex = createHash11("sha256").update(bytes).digest("hex");
     attachments[hex] = bytes.toString("base64");
     return { t: "image", mime: block["mime"], $ref: `sha256:${hex}` };
   }
@@ -18087,9 +18959,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 = createHash9("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 = createHash11("sha256").update(bytesOf2).digest("hex");
     if (digest !== hex) throw importInvalid(`附件 ${hex} 字节摘要不符(实为 ${digest})`);
   }
   const messages = [];
@@ -18120,11 +18992,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 {
@@ -18159,28 +19031,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;
@@ -18196,8 +19068,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;
@@ -18213,16 +19085,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 randomUUID7 } 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";
@@ -18258,13 +19130,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;
@@ -18359,27 +19231,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}` };
@@ -18407,7 +19279,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;
@@ -18422,7 +19294,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;
@@ -18433,7 +19305,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,
@@ -18443,7 +19315,7 @@ async function resolveSessionCwd(input) {
 }
 
 // ../kernel/src/tools/search/path-utils.ts
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 function toPosixPath(p) {
   return p.replaceAll("\\", "/");
 }
@@ -18451,10 +19323,10 @@ function normalizeDriveLetter(p) {
   return /^[A-Za-z]:/.test(p) ? p.charAt(0).toLowerCase() + p.slice(1) : p;
 }
 function isAbsolutePath(p) {
-  return path13.win32.isAbsolute(p) || path13.posix.isAbsolute(p);
+  return path14.win32.isAbsolute(p) || path14.posix.isAbsolute(p);
 }
 function canonicalize(p) {
-  return normalizeDriveLetter(toPosixPath(path13.resolve(p)));
+  return normalizeDriveLetter(toPosixPath(path14.resolve(p)));
 }
 function resolvePathArg(p, cwd) {
   const target = p ?? cwd;
@@ -18836,7 +19708,7 @@ var SESSION_EVENT_VOCABULARY = {
 var SESSION_EVENT_KINDS = Object.keys(SESSION_EVENT_VOCABULARY);
 
 // ../kernel/src/tools/files/read.ts
-import path14 from "node:path";
+import path15 from "node:path";
 import { z as z18 } from "zod";
 
 // ../kernel/src/tools/files/encoding.ts
@@ -18918,19 +19790,19 @@ function truncateLine(line) {
   return `${line.slice(0, cut)}…[line truncated: ${line.length} chars total; use Grep to inspect the rest]`;
 }
 async function findSimilarFiles(fs3, filePath) {
-  const dir = path14.dirname(filePath);
-  const targetBase = path14.basename(filePath);
-  const targetName = path14.parse(filePath).name.toLowerCase();
+  const dir = path15.dirname(filePath);
+  const targetBase = path15.basename(filePath);
+  const targetName = path15.parse(filePath).name.toLowerCase();
   try {
     const entries = await fs3.readdir(dir);
     return entries.filter((entry) => entry.isFile()).map((entry) => entry.name).filter(
-      (name) => name.toLowerCase() !== targetBase.toLowerCase() && path14.parse(name).name.toLowerCase() === targetName
-    ).slice(0, 3).map((name) => path14.join(dir, name));
+      (name) => name.toLowerCase() !== targetBase.toLowerCase() && path15.parse(name).name.toLowerCase() === targetName
+    ).slice(0, 3).map((name) => path15.join(dir, name));
   } catch {
     return [];
   }
 }
-async function executeImageRead(resolved, args, ctx, fs3, stat9, options) {
+async function executeImageRead(resolved, args, ctx, fs3, stat10, options) {
   let mode;
   try {
     mode = options.imageInput?.();
@@ -18949,9 +19821,9 @@ async function executeImageRead(resolved, args, ctx, fs3, stat9, options) {
       "offset/limit apply to text files only. Call Read again without offset/limit to read this image file."
     );
   }
-  if (stat9.size > READ_IMAGE_RAW_MAX_BYTES) {
+  if (stat10.size > READ_IMAGE_RAW_MAX_BYTES) {
     return errorResult(
-      `Image file is ${stat9.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 ${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.`
     );
   }
   let buf;
@@ -18966,10 +19838,10 @@ async function executeImageRead(resolved, args, ctx, fs3, stat9, 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): ${path14.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): ${path15.basename(resolved)}. If it is actually a text file, rename it; otherwise re-export the image and retry.`
     );
   }
-  registerFileRead(ctx, normalizeFileKey(resolved), stat9.mtimeMs);
+  registerFileRead(ctx, normalizeFileKey(resolved), stat10.mtimeMs);
   const data = {
     path: resolved,
     mime: probed.mime,
@@ -18977,7 +19849,7 @@ async function executeImageRead(resolved, args, ctx, fs3, stat9, options) {
     height: probed.height,
     bytes: buf.length
   };
-  const meta = `Image file: ${path14.basename(resolved)}
+  const meta = `Image file: ${path15.basename(resolved)}
 Format: ${probed.mime}
 Dimensions: ${probed.width}x${probed.height} px
 Size: ${buf.length} bytes`;
@@ -19000,8 +19872,8 @@ function createReadTool(options = {}) {
     isConcurrencySafe: true,
     touchedPathsOf(args) {
       const parsed = ReadArgsSchema.safeParse(args);
-      if (!parsed.success || !path14.isAbsolute(parsed.data.file_path)) return [];
-      return [path14.resolve(parsed.data.file_path)];
+      if (!parsed.success || !path15.isAbsolute(parsed.data.file_path)) return [];
+      return [path15.resolve(parsed.data.file_path)];
     },
     async execute(args, ctx) {
       if (ctx.signal.aborted) {
@@ -19015,15 +19887,15 @@ function createReadTool(options = {}) {
       if (invalid) {
         return invalid;
       }
-      const resolved = path14.resolve(args.file_path);
+      const resolved = path15.resolve(args.file_path);
       const fs3 = fsOf(ctx);
       const realTarget = await checkRealTarget("Read", resolved, { cwd: ctx.cwd, access: "read", fs: fs3 });
       if (!realTarget.ok) {
         return errorResult(realTarget.reason);
       }
-      let stat9;
+      let stat10;
       try {
-        stat9 = await fs3.stat(resolved);
+        stat10 = await fs3.stat(resolved);
       } catch (err) {
         if (fsErrorCode(err) === "ENOENT") {
           const similar = await findSimilarFiles(fs3, resolved);
@@ -19032,11 +19904,11 @@ function createReadTool(options = {}) {
         }
         return errorResult(`Failed to read file: ${errorMessageOf(err)}`);
       }
-      if (stat9.isDirectory()) {
+      if (stat10.isDirectory()) {
         return errorResult(`Path is a directory, not a file: ${resolved}.`);
       }
-      if (isImageFileExtension(path14.extname(resolved))) {
-        return executeImageRead(resolved, args, ctx, fs3, stat9, options);
+      if (isImageFileExtension(path15.extname(resolved))) {
+        return executeImageRead(resolved, args, ctx, fs3, stat10, options);
       }
       const fileKey = normalizeFileKey(resolved);
       const effectiveOffset = args.offset ?? 1;
@@ -19044,7 +19916,7 @@ function createReadTool(options = {}) {
       const dupWindow = takeDuplicateReadWindow(
         ctx,
         fileKey,
-        stat9.mtimeMs,
+        stat10.mtimeMs,
         effectiveOffset,
         effectiveLimit
       );
@@ -19061,9 +19933,9 @@ function createReadTool(options = {}) {
           data2
         );
       }
-      if (stat9.size > READ_MAX_FULL_BYTES && args.offset === void 0 && args.limit === void 0) {
+      if (stat10.size > READ_MAX_FULL_BYTES && args.offset === void 0 && args.limit === void 0) {
         return errorResult(
-          `File is ${stat9.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(stat9.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 ${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.`
         );
       }
       let buf;
@@ -19082,7 +19954,7 @@ function createReadTool(options = {}) {
         );
       }
       if (decoded.text.length === 0) {
-        registerFileRead(ctx, fileKey, stat9.mtimeMs, {
+        registerFileRead(ctx, fileKey, stat10.mtimeMs, {
           offset: effectiveOffset,
           limit: effectiveLimit,
           totalLines: 0,
@@ -19096,7 +19968,7 @@ function createReadTool(options = {}) {
       const startLine = effectiveOffset;
       const maxLines = effectiveLimit;
       if (startLine > totalLines) {
-        registerFileRead(ctx, fileKey, stat9.mtimeMs, {
+        registerFileRead(ctx, fileKey, stat10.mtimeMs, {
           offset: effectiveOffset,
           limit: effectiveLimit,
           totalLines,
@@ -19115,7 +19987,7 @@ function createReadTool(options = {}) {
         text += `
 … (showing lines ${startLine}-${endLine} of ${totalLines}; use offset=${endLine + 1} to continue)`;
       }
-      registerFileRead(ctx, fileKey, stat9.mtimeMs, {
+      registerFileRead(ctx, fileKey, stat10.mtimeMs, {
         offset: effectiveOffset,
         limit: effectiveLimit,
         totalLines,
@@ -19129,7 +20001,7 @@ function createReadTool(options = {}) {
 var ReadTool = createReadTool();
 
 // ../kernel/src/tools/files/write.ts
-import path15 from "node:path";
+import path16 from "node:path";
 import { z as z19 } from "zod";
 var WriteArgsSchema = z19.object({
   file_path: z19.string().describe("Absolute path to the file to write. Relative paths are rejected."),
@@ -19148,8 +20020,8 @@ var WriteTool = {
   isConcurrencySafe: false,
   mutatedPathsOf(args) {
     const parsed = WriteArgsSchema.safeParse(args);
-    if (!parsed.success || !path15.isAbsolute(parsed.data.file_path)) return [];
-    return [path15.resolve(parsed.data.file_path)];
+    if (!parsed.success || !path16.isAbsolute(parsed.data.file_path)) return [];
+    return [path16.resolve(parsed.data.file_path)];
   },
   async execute(args, ctx) {
     if (ctx.signal.aborted) {
@@ -19163,7 +20035,7 @@ var WriteTool = {
     if (invalid) {
       return invalid;
     }
-    const resolved = path15.resolve(args.file_path);
+    const resolved = path16.resolve(args.file_path);
     const key2 = normalizeFileKey(resolved);
     const fs3 = fsOf(ctx);
     const realTarget = await checkRealTarget("Write", resolved, {
@@ -19205,7 +20077,7 @@ var WriteTool = {
       }
     } else {
       try {
-        await fs3.mkdir(path15.dirname(resolved), { recursive: true });
+        await fs3.mkdir(path16.dirname(resolved), { recursive: true });
       } catch (err) {
         return errorResult(`Failed to create parent directories: ${errorMessageOf(err)}`);
       }
@@ -19261,7 +20133,7 @@ ${memoryNearLimitNote(health)}`, data);
 };
 
 // ../kernel/src/tools/files/edit.ts
-import path16 from "node:path";
+import path17 from "node:path";
 import { z as z20 } from "zod";
 var EditArgsSchema = z20.object({
   file_path: z20.string().describe("Absolute path to the file to edit. Relative paths are rejected."),
@@ -19304,8 +20176,8 @@ var EditTool = {
   isConcurrencySafe: false,
   mutatedPathsOf(args) {
     const parsed = EditArgsSchema.safeParse(args);
-    if (!parsed.success || !path16.isAbsolute(parsed.data.file_path)) return [];
-    return [path16.resolve(parsed.data.file_path)];
+    if (!parsed.success || !path17.isAbsolute(parsed.data.file_path)) return [];
+    return [path17.resolve(parsed.data.file_path)];
   },
   async execute(args, ctx) {
     if (ctx.signal.aborted) {
@@ -19319,7 +20191,7 @@ var EditTool = {
     if (invalid) {
       return invalid;
     }
-    const resolved = path16.resolve(args.file_path);
+    const resolved = path17.resolve(args.file_path);
     const key2 = normalizeFileKey(resolved);
     const fs3 = fsOf(ctx);
     const realTarget = await checkRealTarget("Edit", resolved, {
@@ -19330,19 +20202,19 @@ var EditTool = {
     if (!realTarget.ok) {
       return errorResult(realTarget.reason);
     }
-    let stat9;
+    let stat10;
     try {
-      stat9 = await fs3.stat(resolved);
+      stat10 = await fs3.stat(resolved);
     } catch (err) {
       if (fsErrorCode(err) === "ENOENT") {
         return errorResult(`File does not exist: ${resolved}. Use the Write tool to create a new file.`);
       }
       return errorResult(`Failed to access file: ${errorMessageOf(err)}`);
     }
-    if (stat9.isDirectory()) {
+    if (stat10.isDirectory()) {
       return errorResult(`Path is a directory, not a file: ${resolved}.`);
     }
-    const guard = checkStaleWriteGuard(ctx, key2, stat9.mtimeMs, "editing");
+    const guard = checkStaleWriteGuard(ctx, key2, stat10.mtimeMs, "editing");
     if (guard) {
       return guard;
     }
@@ -19447,7 +20319,7 @@ ${memoryNearLimitNote(health)}`, data);
 
 // ../kernel/src/tools/search/glob-tool.ts
 import { z as z21 } from "zod";
-import path17 from "node:path";
+import path18 from "node:path";
 
 // ../kernel/src/tools/search/walker.ts
 var DEFAULT_IGNORED_DIRS = /* @__PURE__ */ new Set([
@@ -19541,7 +20413,7 @@ var globTool = {
       return errorResult3(`path does not exist: ${root}`);
     }
     if (!rootStat.isDirectory()) return errorResult3(`path is not a directory: ${root}`);
-    const realRoot = await checkRealTarget("Glob", path17.resolve(root), { cwd: ctx.cwd, access: "read", fs: fs3 });
+    const realRoot = await checkRealTarget("Glob", path18.resolve(root), { cwd: ctx.cwd, access: "read", fs: fs3 });
     if (!realRoot.ok) return errorResult3(realRoot.reason);
     let matcher;
     try {
@@ -19580,7 +20452,7 @@ var globTool = {
 
 // ../kernel/src/tools/search/grep-tool.ts
 import { z as z22 } from "zod";
-import path18 from "node:path";
+import path19 from "node:path";
 
 // ../kernel/src/tools/search/js-engine.ts
 var GREP_MAX_FILE_SIZE = 4 * 1024 * 1024;
@@ -20054,7 +20926,7 @@ var grepTool = {
       return finish(errorResult4(`path does not exist: ${root}`));
     }
     if (!rootStat.isDirectory()) return finish(errorResult4(`path is not a directory: ${root}`));
-    const realRoot = await checkRealTarget("Grep", path18.resolve(root), { cwd: ctx.cwd, access: "read", fs: fs3 });
+    const realRoot = await checkRealTarget("Grep", path19.resolve(root), { cwd: ctx.cwd, access: "read", fs: fs3 });
     if (!realRoot.ok) return finish(errorResult4(realRoot.reason));
     try {
       new RegExp(args.pattern, args.case_insensitive ? "i" : "");
@@ -20139,7 +21011,7 @@ var grepTool = {
 
 // ../kernel/src/tools/search/list-tool.ts
 import { z as z23 } from "zod";
-import path19 from "node:path";
+import path20 from "node:path";
 var LIST_MAX_ENTRIES = 500;
 var ListArgsSchema = z23.object({
   path: z23.string().min(1),
@@ -20169,7 +21041,7 @@ var listTool = {
   touchedPathsOf(args) {
     const parsed = ListArgsSchema.safeParse(args);
     if (!parsed.success || !isAbsolutePath(parsed.data.path)) return [];
-    return [path19.resolve(parsed.data.path)];
+    return [path20.resolve(parsed.data.path)];
   },
   async execute(args, ctx) {
     if (ctx.signal.aborted) return errorResult5("aborted");
@@ -20183,7 +21055,7 @@ var listTool = {
       return errorResult5(`path does not exist: ${root}`);
     }
     if (!rootStat.isDirectory()) return errorResult5(`path is not a directory: ${root}`);
-    const realRoot = await checkRealTarget("List", path19.resolve(root), { cwd: ctx.cwd, access: "read", fs: fs3 });
+    const realRoot = await checkRealTarget("List", path20.resolve(root), { cwd: ctx.cwd, access: "read", fs: fs3 });
     if (!realRoot.ok) return errorResult5(realRoot.reason);
     let ignoreMatchers = [];
     try {
@@ -20713,8 +21585,8 @@ ${tail}`;
 };
 
 // ../kernel/src/tools/shell/output-file.ts
-import { createWriteStream as createWriteStream2, mkdirSync } from "node:fs";
-import * as path20 from "node:path";
+import { createWriteStream as createWriteStream3, mkdirSync } from "node:fs";
+import * as path21 from "node:path";
 var SHELL_OUTPUT_SPILL_THRESHOLD_CHARS = 5e4;
 var SHELL_OUTPUT_DIR_NAME = "shell-output";
 function sanitizeFileStem(stem) {
@@ -20723,7 +21595,7 @@ function sanitizeFileStem(stem) {
 }
 function shellOutputFilePath(sessionCwd, toolCallId) {
   const stem = toolCallId !== void 0 && toolCallId.trim().length > 0 ? sanitizeFileStem(toolCallId) : `shell-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-  return path20.join(sessionCwd, ".tansr", SHELL_OUTPUT_DIR_NAME, `${stem}.log`);
+  return path21.join(sessionCwd, ".tansr", SHELL_OUTPUT_DIR_NAME, `${stem}.log`);
 }
 var ShellOutputSink = class {
   filePath;
@@ -20759,8 +21631,8 @@ var ShellOutputSink = class {
   forceOpen() {
     if (this.#stream !== void 0 || this.#writeError !== void 0 || this.#closed) return;
     try {
-      mkdirSync(path20.dirname(this.filePath), { recursive: true });
-      const stream = createWriteStream2(this.filePath, { encoding: "utf8" });
+      mkdirSync(path21.dirname(this.filePath), { recursive: true });
+      const stream = createWriteStream3(this.filePath, { encoding: "utf8" });
       stream.on("error", (err) => {
         this.#writeError = err.message;
         this.#stream = void 0;
@@ -23188,7 +24060,7 @@ function applyToolOverrides(filtered, overrides) {
 }
 
 // ../kernel/src/agents/subagent-memory-fence.ts
-import path21 from "node:path";
+import path22 from "node:path";
 function subagentMemoryFenceOf(ctx) {
   if (ctx === void 0 || ctx.dirs.length === 0) return void 0;
   return {
@@ -23203,7 +24075,7 @@ function writeTargetOf(args, cwd) {
   if (args === null || typeof args !== "object") return null;
   const raw = args.file_path;
   if (typeof raw !== "string" || raw.length === 0) return null;
-  return path21.isAbsolute(raw) ? path21.resolve(raw) : path21.resolve(cwd, raw);
+  return path22.isAbsolute(raw) ? path22.resolve(raw) : path22.resolve(cwd, raw);
 }
 function fencedSubagentWriteTool(tool, fence) {
   return {
@@ -23507,10 +24379,10 @@ async function runSubagent(options) {
 }
 
 // ../kernel/src/tools/task/background.ts
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 var TASK_AGENT_OUTPUT_DIR_NAME = "agent-output";
 function taskAgentOutputFilePath(sessionCwd, agentId) {
-  return path22.join(sessionCwd, ".tansr", TASK_AGENT_OUTPUT_DIR_NAME, `${sanitizeFileStem(agentId)}.md`);
+  return path23.join(sessionCwd, ".tansr", TASK_AGENT_OUTPUT_DIR_NAME, `${sanitizeFileStem(agentId)}.md`);
 }
 function taskSettlementStopReason(reason, aborted) {
   if (aborted) return "aborted";
@@ -23646,35 +24518,35 @@ function resolveSubagentDispatch(input) {
   return { kind: "inherit", reason: "economy_unavailable" };
 }
 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 建制)`
       );
     }
@@ -25294,8 +26166,8 @@ function suggestedAudioName(audio) {
 async function sinkInlineAudio(sink, audio) {
   try {
     const bytes = new Uint8Array(Buffer.from(audio.b64, "base64"));
-    const path28 = await sink(bytes, audio.mime, suggestedAudioName(audio));
-    return { path: path28 };
+    const path29 = await sink(bytes, audio.mime, suggestedAudioName(audio));
+    return { path: path29 };
   } catch (err) {
     return { error: err instanceof Error ? err.message : String(err) };
   }
@@ -25407,7 +26279,7 @@ import { spawnSync as spawnSync2 } from "node:child_process";
 
 // ../kernel/src/tools/mcp/win32-spawn.ts
 import fs2 from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 var CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
 var SPAWNABLE_EXTS = [".COM", ".EXE", ".BAT", ".CMD"];
 function escapeCmdCommand(command) {
@@ -25446,7 +26318,7 @@ function defaultFileExists(filePath) {
   }
 }
 function resolveCommandFile(command, env, cwd, fileExists3) {
-  const w = path23.win32;
+  const w = path24.win32;
   const exts = spawnableExts(envLookup(env, "PATHEXT"));
   const bases = [];
   if (command.includes("/") || command.includes("\\")) {
@@ -25480,7 +26352,7 @@ function wrapWithComSpec(target, args, env) {
 function planStdioSpawn(command, args, options) {
   const platform = options.platform ?? process.platform;
   if (platform !== "win32") return { file: command, args };
-  const ext = path23.win32.extname(command).toUpperCase();
+  const ext = path24.win32.extname(command).toUpperCase();
   if (ext === ".EXE" || ext === ".COM") return { file: command, args };
   if (ext === ".CMD" || ext === ".BAT") return wrapWithComSpec(command, args, options.env);
   if (ext !== "") return { file: command, args };
@@ -25488,7 +26360,7 @@ function planStdioSpawn(command, args, options) {
   const fileExists3 = options.fileExists ?? defaultFileExists;
   const resolved = resolveCommandFile(command, options.env, cwd, fileExists3);
   if (resolved === void 0) return { file: command, args };
-  const resolvedExt = path23.win32.extname(resolved).toUpperCase();
+  const resolvedExt = path24.win32.extname(resolved).toUpperCase();
   if (resolvedExt === ".CMD" || resolvedExt === ".BAT") {
     return wrapWithComSpec(resolved, args, options.env);
   }
@@ -26827,7 +27699,7 @@ async function connectHttpMcpServer(config, options) {
 }
 
 // ../kernel/src/tools/mcp/bridge.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 import { z as z40 } from "zod";
 var MCP_TOOL_NAME_PREFIX = "mcp__";
 var MCP_REMOTE_TOOL_NAME_RE = /^[A-Za-z0-9_.-]{1,128}$/;
@@ -26835,7 +27707,7 @@ var MAX_LIST_PAGES = 64;
 function buildMcpToolName(serverName, toolName2) {
   const full = `${MCP_TOOL_NAME_PREFIX}${serverName}__${toolName2}`;
   if (full.length <= MCP_BRIDGED_TOOL_NAME_MAX_CHARS) return full;
-  const hash = createHash10("sha256").update(full, "utf8").digest("hex").slice(0, MCP_NAME_FOLD_HASH_CHARS);
+  const hash = createHash12("sha256").update(full, "utf8").digest("hex").slice(0, MCP_NAME_FOLD_HASH_CHARS);
   const prefix = `${MCP_TOOL_NAME_PREFIX}${serverName}__`;
   const tailBudget = MCP_BRIDGED_TOOL_NAME_MAX_CHARS - prefix.length;
   if (tailBudget >= MCP_NAME_FOLD_HASH_CHARS + 1) {
@@ -27724,15 +28596,15 @@ var McpConnectionPool = class {
    * `mcp.closed(server_exit|error)` → `mcp.reconnecting`(RFC-SC-3 R4:重连帧
    * 不携原因,原因在**前帧** closed / connect_failed;SC-45 直透卷钉住此序)。
    */
-  #observerFor(slot, link) {
+  #observerFor(slot, link2) {
     return (event) => {
       try {
         this.#onEvent?.(event);
       } finally {
         if (event.type === "mcp.closed" && event.server === this.serverName) {
-          link.dead = true;
-          if (event.reason !== "closed" && link.connection !== void 0) {
-            this.#memberDown(slot, link.connection);
+          link2.dead = true;
+          if (event.reason !== "closed" && link2.connection !== void 0) {
+            this.#memberDown(slot, link2.connection);
           }
         }
       }
@@ -27823,12 +28695,12 @@ var McpConnectionPool = class {
    */
   async #attempt(slot, reason, automatic) {
     const attemptStartedAt = this.#now();
-    const link = { connection: void 0, dead: false };
+    const link2 = { connection: void 0, dead: false };
     let connection;
     try {
-      connection = await this.#connectMember(slot.index, this.#observerFor(slot, link));
-      link.connection = connection;
-      if (link.dead || isClosedConnection(connection)) {
+      connection = await this.#connectMember(slot.index, this.#observerFor(slot, link2));
+      link2.connection = connection;
+      if (link2.dead || isClosedConnection(connection)) {
         throw new McpError("transport_closed", `MCP server "${this.serverName}" closed the connection during setup.`, {
           server: this.serverName
         });
@@ -27836,7 +28708,7 @@ var McpConnectionPool = class {
       if (this.#onMemberUp !== void 0) {
         await this.#onMemberUp({ slot: slot.index, connection, reason });
       }
-      if (link.dead || isClosedConnection(connection)) {
+      if (link2.dead || isClosedConnection(connection)) {
         throw new McpError("transport_closed", `MCP server "${this.serverName}" closed the connection during discovery.`, {
           server: this.serverName
         });
@@ -27847,7 +28719,7 @@ var McpConnectionPool = class {
         return { ok: false, error: this.#closedError() };
       }
       slot.connection = connection;
-      slot.link = link;
+      slot.link = link2;
       slot.generation += 1;
       slot.connectedAt = this.#now();
       slot.exhausted = false;
@@ -27980,7 +28852,7 @@ function resolveMcpServerGovernance(config, layers = {}) {
 }
 
 // ../kernel/src/tools/mcp/catalog-store.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 var MCP_CATALOG_STORE_VERSION = 1;
 function stableStringify2(value) {
   if (value === null || typeof value !== "object") {
@@ -27994,10 +28866,10 @@ function stableStringify2(value) {
   return `{${parts.join(",")}}`;
 }
 function computeMcpServerConfigFingerprint(config) {
-  return createHash11("sha256").update(stableStringify2(config), "utf8").digest("hex");
+  return createHash13("sha256").update(stableStringify2(config), "utf8").digest("hex");
 }
 function computeMcpToolDefinitionHash(tool) {
-  return createHash11("sha256").update(
+  return createHash13("sha256").update(
     stableStringify2({
       name: tool.name,
       description: tool.description,
@@ -28611,7 +29483,7 @@ async function initMcpLazyManager(toolset, servers, options = {}) {
 import os3 from "node:os";
 
 // ../kernel/src/hooks/config.ts
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 
 // ../kernel/src/config/merge.ts
 var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
@@ -28641,12 +29513,12 @@ function deepMergeRawLayers(rawsAscending) {
   }
   return structuredClone(acc);
 }
-function displayPath2(path28) {
-  return path28.map(String).join(".");
+function displayPath2(path29) {
+  return path29.map(String).join(".");
 }
-function getAtPath(root, path28) {
+function getAtPath(root, path29) {
   let cur = root;
-  for (const seg of path28) {
+  for (const seg of path29) {
     if (typeof seg === "number") {
       if (!Array.isArray(cur) || seg < 0 || seg >= cur.length) return void 0;
       cur = cur[seg];
@@ -28657,11 +29529,11 @@ function getAtPath(root, path28) {
   }
   return cur;
 }
-function hasPath(root, path28) {
-  if (path28.length === 0) return true;
+function hasPath(root, path29) {
+  if (path29.length === 0) return true;
   let cur = root;
-  for (let i = 0; i < path28.length; i++) {
-    const seg = path28[i];
+  for (let i = 0; i < path29.length; i++) {
+    const seg = path29[i];
     if (typeof seg === "number") {
       if (!Array.isArray(cur) || seg < 0 || seg >= cur.length) return false;
       cur = cur[seg];
@@ -28672,25 +29544,25 @@ function hasPath(root, path28) {
   }
   return true;
 }
-function sanitizeDropPath(root, path28) {
+function sanitizeDropPath(root, path29) {
   let cur = root;
-  for (let i = 0; i < path28.length; i++) {
-    const seg = path28[i];
+  for (let i = 0; i < path29.length; i++) {
+    const seg = path29[i];
     const next = getAtPath(cur, [seg]);
-    if (Array.isArray(next) && i < path28.length - 1) {
-      return path28.slice(0, i + 1);
+    if (Array.isArray(next) && i < path29.length - 1) {
+      return path29.slice(0, i + 1);
     }
-    if (typeof path28[i + 1] === "number") {
-      return path28.slice(0, i + 1);
+    if (typeof path29[i + 1] === "number") {
+      return path29.slice(0, i + 1);
     }
     cur = next;
   }
-  return path28;
+  return path29;
 }
-function deletePath(root, path28) {
-  if (path28.length === 0) return;
-  const parent = getAtPath(root, path28.slice(0, -1));
-  const leaf = path28[path28.length - 1];
+function deletePath(root, path29) {
+  if (path29.length === 0) return;
+  const parent = getAtPath(root, path29.slice(0, -1));
+  const leaf = path29[path29.length - 1];
   if (isPlainObject2(parent) && typeof leaf === "string") {
     delete parent[leaf];
   }
@@ -28780,16 +29652,16 @@ function canonicalJson(value) {
   return JSON.stringify(value) ?? "null";
 }
 function configHash8(dedupeKey) {
-  return createHash12("sha256").update(dedupeKey, "utf8").digest("hex").slice(0, 8);
+  return createHash14("sha256").update(dedupeKey, "utf8").digest("hex").slice(0, 8);
 }
-function parseExecutor(value, layer, path28, file, addDiagnostic) {
+function parseExecutor(value, layer, path29, file, addDiagnostic) {
   const fileRef = file !== void 0 ? { file } : {};
   const invalid = (params) => {
     addDiagnostic({
       severity: "error",
       code: "hook_invalid_value",
       layer,
-      path: path28,
+      path: path29,
       ...fileRef,
       params
     });
@@ -28837,7 +29709,7 @@ function parseExecutor(value, layer, path28, file, addDiagnostic) {
         severity: "error",
         code: "hook_url_invalid",
         layer,
-        path: `${path28}.url`,
+        path: `${path29}.url`,
         ...fileRef,
         params: { reason: "unparsable" }
       });
@@ -28848,7 +29720,7 @@ function parseExecutor(value, layer, path28, file, addDiagnostic) {
         severity: "error",
         code: "hook_url_invalid",
         layer,
-        path: `${path28}.url`,
+        path: `${path29}.url`,
         ...fileRef,
         params: { reason: "unsupported_protocol", protocol: parsed.protocol }
       });
@@ -29439,7 +30311,7 @@ function migrateLayerRaw(raw) {
 
 // ../kernel/src/config/paths.ts
 import { promises as fsPromises } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 var SETTINGS_FILE_NAME = "settings.json";
 var LOCAL_SETTINGS_FILE_NAME = "settings.local.json";
 var TANSR_DIR_NAME = ".tansr";
@@ -29466,27 +30338,27 @@ function normalizeForCompare(p, platform) {
 function defaultManagedPaths(platform, env) {
   if (platform === "win32") {
     const programData = readTrimmedEnv2(env, "PROGRAMDATA") ?? "C:\\ProgramData";
-    return [path24.join(programData, "tansr", MANAGED_SETTINGS_FILE_NAME)];
+    return [path25.join(programData, "tansr", MANAGED_SETTINGS_FILE_NAME)];
   }
-  return [path24.posix.join("/etc", "tansr", MANAGED_SETTINGS_FILE_NAME)];
+  return [path25.posix.join("/etc", "tansr", MANAGED_SETTINGS_FILE_NAME)];
 }
 async function discoverLayerFiles(options) {
   const { fs: fs3, env, platform } = options;
   const configDirOverride = readTrimmedEnv2(env, "TANSR_CONFIG_DIR");
-  const userDir = configDirOverride ?? path24.join(options.homedir, TANSR_DIR_NAME);
-  const userFile = path24.join(userDir, SETTINGS_FILE_NAME);
-  const homeKey = normalizeForCompare(path24.resolve(options.homedir), platform);
+  const userDir = configDirOverride ?? path25.join(options.homedir, TANSR_DIR_NAME);
+  const userFile = path25.join(userDir, SETTINGS_FILE_NAME);
+  const homeKey = normalizeForCompare(path25.resolve(options.homedir), platform);
   let projectRoot;
-  const boundary = options.boundary === void 0 ? void 0 : normalizeForCompare(path24.resolve(options.boundary), platform);
-  let cursor = path24.resolve(options.cwd);
+  const boundary = options.boundary === void 0 ? void 0 : normalizeForCompare(path25.resolve(options.boundary), platform);
+  let cursor = path25.resolve(options.cwd);
   for (let depth = 0; depth < 256; depth++) {
     const homeAnchorInvisible = normalizeForCompare(cursor, platform) === homeKey;
-    if (!homeAnchorInvisible && await fs3.directoryExists(path24.join(cursor, TANSR_DIR_NAME))) {
+    if (!homeAnchorInvisible && await fs3.directoryExists(path25.join(cursor, TANSR_DIR_NAME))) {
       projectRoot = cursor;
       break;
     }
     if (boundary !== void 0 && normalizeForCompare(cursor, platform) === boundary) break;
-    const parent = path24.dirname(cursor);
+    const parent = path25.dirname(cursor);
     if (parent === cursor) break;
     cursor = parent;
   }
@@ -29495,8 +30367,8 @@ async function discoverLayerFiles(options) {
     managedCandidates,
     ...projectRoot !== void 0 ? {
       projectRoot,
-      projectSharedFile: path24.join(projectRoot, TANSR_DIR_NAME, SETTINGS_FILE_NAME),
-      projectLocalFile: path24.join(projectRoot, TANSR_DIR_NAME, LOCAL_SETTINGS_FILE_NAME)
+      projectSharedFile: path25.join(projectRoot, TANSR_DIR_NAME, SETTINGS_FILE_NAME),
+      projectLocalFile: path25.join(projectRoot, TANSR_DIR_NAME, LOCAL_SETTINGS_FILE_NAME)
     } : {},
     userFile
   };
@@ -30083,8 +30955,8 @@ function issueExpected(issue) {
       return issue.code;
   }
 }
-function attributeLayer(layersDescending, path28) {
-  return layersDescending.find((entry) => hasPath(entry.raw, path28));
+function attributeLayer(layersDescending, path29) {
+  return layersDescending.find((entry) => hasPath(entry.raw, path29));
 }
 function scanUnknownKeys(raw, parsed, pathSoFar, layersDescending, addDiagnostic) {
   if (!isPlainObject2(raw) || !isPlainObject2(parsed)) return;
@@ -31182,7 +32054,7 @@ var HookEngine = class {
 // ../kernel/src/skills/discover.ts
 import { promises as fsPromises2 } from "node:fs";
 import os4 from "node:os";
-import path25 from "node:path";
+import path26 from "node:path";
 
 // ../kernel/src/skills/types.ts
 var SKILLS_DIR_NAME = "skills";
@@ -31402,8 +32274,8 @@ async function scanFileSource(source, skillsDir, fs3, diagnostics) {
   const seen = /* @__PURE__ */ new Set();
   for (const dirName of [...subdirs].sort()) {
     if (dirName.startsWith(".") || dirName.startsWith("_")) continue;
-    const dir = path25.join(skillsDir, dirName);
-    const file = path25.join(dir, SKILL_FILE_NAME);
+    const dir = path26.join(skillsDir, dirName);
+    const file = path26.join(dir, SKILL_FILE_NAME);
     if (!SKILL_NAME_RE.test(dirName)) {
       diagnostics.push({ severity: "warning", code: "name_invalid", source, skill: dirName, file });
       continue;
@@ -31452,7 +32324,7 @@ async function discoverSkills(options = {}) {
   const platform = options.platform ?? process.platform;
   const homedir = options.homedir ?? os4.homedir();
   const cwd = options.cwd ?? process.cwd();
-  const explicitRoot = options.projectRoot === void 0 ? void 0 : path25.resolve(options.projectRoot);
+  const explicitRoot = options.projectRoot === void 0 ? void 0 : path26.resolve(options.projectRoot);
   const discovered = await discoverLayerFiles({
     cwd: explicitRoot ?? cwd,
     homedir,
@@ -31463,13 +32335,13 @@ async function discoverSkills(options = {}) {
     ...explicitRoot !== void 0 ? { boundary: explicitRoot } : options.boundary !== void 0 ? { boundary: options.boundary } : {}
   });
   const builtinEntries = collectBuiltin(options.builtinSkills ?? [], diagnostics);
-  const userSkillsDir = path25.join(path25.dirname(discovered.userFile), SKILLS_DIR_NAME);
+  const userSkillsDir = path26.join(path26.dirname(discovered.userFile), SKILLS_DIR_NAME);
   const userOutcome = await scanFileSource("user", userSkillsDir, fs3, diagnostics);
   const projectRoot = explicitRoot ?? discovered.projectRoot;
   let projectSkillsDir;
   let projectOutcome = { status: "missing" };
   if (projectRoot !== void 0) {
-    projectSkillsDir = path25.join(projectRoot, TANSR_DIR_NAME, SKILLS_DIR_NAME);
+    projectSkillsDir = path26.join(projectRoot, TANSR_DIR_NAME, SKILLS_DIR_NAME);
     projectOutcome = await scanFileSource("project", projectSkillsDir, fs3, diagnostics);
   }
   const userEntries = userOutcome.status === "scanned" ? userOutcome.entries : [];
@@ -31543,7 +32415,7 @@ async function discoverSkills(options = {}) {
 }
 
 // ../kernel/src/skills/registry.ts
-import path26 from "node:path";
+import path27 from "node:path";
 function errCode2(err) {
   if (err !== null && typeof err === "object" && "code" in err) {
     const code = err.code;
@@ -31606,7 +32478,7 @@ var SkillRegistry = class {
   /** 技能目录绝对路径(正文相对引用锚点;builtin 无) */
   static baseDirOf(entry) {
     if (entry.dir !== void 0) return entry.dir;
-    if (entry.file !== void 0) return path26.dirname(entry.file);
+    if (entry.file !== void 0) return path27.dirname(entry.file);
     return void 0;
   }
 };
@@ -31787,7 +32659,7 @@ var TansrSdkError = class extends Error {
 };
 
 // src/define-tool.ts
-function specToZod(spec, path28) {
+function specToZod(spec, path29) {
   let schema;
   switch (spec.type) {
     case "string":
@@ -31800,24 +32672,24 @@ function specToZod(spec, path28) {
       schema = z46.boolean();
       break;
     case "array":
-      schema = z46.array(spec.items !== void 0 ? specToZod(spec.items, `${path28}.items`) : z46.unknown());
+      schema = z46.array(spec.items !== void 0 ? specToZod(spec.items, `${path29}.items`) : z46.unknown());
       break;
     case "object":
-      schema = spec.properties !== void 0 ? propertiesToZodObject(spec.properties, path28) : z46.record(z46.unknown());
+      schema = spec.properties !== void 0 ? propertiesToZodObject(spec.properties, path29) : z46.record(z46.unknown());
       break;
     default:
       throw new TansrSdkError(
         "invalid_options",
-        `defineTool: parameter "${path28}" has unknown type "${String(spec.type)}"; use one of 'string' | 'number' | 'boolean' | 'array' | 'object'.`
+        `defineTool: parameter "${path29}" has unknown type "${String(spec.type)}"; use one of 'string' | 'number' | 'boolean' | 'array' | 'object'.`
       );
   }
   if (spec.description !== void 0) schema = schema.describe(spec.description);
   return schema;
 }
-function propertiesToZodObject(properties, path28) {
+function propertiesToZodObject(properties, path29) {
   const shape = {};
   for (const [key2, spec] of Object.entries(properties)) {
-    const field = specToZod(spec, path28 === "" ? key2 : `${path28}.${key2}`);
+    const field = specToZod(spec, path29 === "" ? key2 : `${path29}.${key2}`);
     shape[key2] = spec.optional === true ? field.optional() : field;
   }
   return z46.object(shape);
@@ -31926,7 +32798,7 @@ function defineTool(options) {
 }
 
 // src/skills.ts
-import path27 from "node:path";
+import path28 from "node:path";
 function yamlQuote(value) {
   return '"' + value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r\n?/g, "\n").replace(/\n/g, "\\n").replace(/\t/g, "\\t") + '"';
 }
@@ -31960,9 +32832,9 @@ function defineSkill(options) {
   ];
   return { name: options.name, content: lines.join("\n") };
 }
-var NO_DISCOVERY_ROOT = path27.resolve(path27.sep, ".tansr-sdk-no-discovery");
+var NO_DISCOVERY_ROOT = path28.resolve(path28.sep, ".tansr-sdk-no-discovery");
 function noDiscoveryFs(inner) {
-  const inVoid = (target) => path27.resolve(target).startsWith(NO_DISCOVERY_ROOT);
+  const inVoid = (target) => path28.resolve(target).startsWith(NO_DISCOVERY_ROOT);
   const enoent = (target) => {
     const err = new Error(`ENOENT: no such file or directory ${target}`);
     err.code = "ENOENT";
@@ -31976,7 +32848,7 @@ function noDiscoveryFs(inner) {
 }
 async function assembleSdkSkills(options) {
   const fs3 = noDiscoveryFs(options.fs ?? defaultSkillsFileSystem());
-  const dirs = (options.dirs ?? []).map((dir) => path27.resolve(dir));
+  const dirs = (options.dirs ?? []).map((dir) => path28.resolve(dir));
   for (const dir of dirs) {
     if (!await fs3.directoryExists(dir)) {
       throw new TansrSdkError(
@@ -34175,7 +35047,7 @@ var OpenAIResponsesAdapter = class {
 };
 
 // ../providers/src/retry/attempt-observer.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 var PROVIDER_CALL_META_FIELD = "callMeta";
 function providerCallMetaOf(options) {
   if (options === void 0) return void 0;
@@ -34204,12 +35076,12 @@ function endpointKeyOf(baseUrl) {
   let normalized;
   try {
     const url = new URL(baseUrl);
-    const path28 = url.pathname.replace(/\/+$/, "");
-    normalized = `${url.protocol}//${url.host}${path28}`.toLowerCase();
+    const path29 = url.pathname.replace(/\/+$/, "");
+    normalized = `${url.protocol}//${url.host}${path29}`.toLowerCase();
   } catch {
     normalized = baseUrl.trim().replace(/\/+$/, "").toLowerCase();
   }
-  return createHash13("sha256").update(normalized, "utf8").digest("hex").slice(0, 16);
+  return createHash15("sha256").update(normalized, "utf8").digest("hex").slice(0, 16);
 }
 function safeAttemptCall(fn) {
   if (fn === void 0) return;
@@ -34362,16 +35234,16 @@ function sendableTwpReasoningContent(features) {
 }
 
 // ../providers/src/twp/signing.ts
-import { createHash as createHash14, createHmac, randomBytes as randomBytes3 } from "node:crypto";
+import { createHash as createHash16, createHmac, randomBytes as randomBytes4 } from "node:crypto";
 var TWP_SIGNING_ALGORITHM = "TWP1-HMAC-SHA256";
 var TWP_NONCE_LENGTH = 24;
 function deriveTwpSigningKey(secretKey) {
-  return createHash14("sha256").update(secretKey, "utf8").digest();
+  return createHash16("sha256").update(secretKey, "utf8").digest();
 }
 function sha256Hex2(data) {
-  return createHash14("sha256").update(typeof data === "string" ? Buffer.from(data, "utf8") : data).digest("hex");
+  return createHash16("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) {
@@ -35388,9 +36260,9 @@ var MissingApiKeyError = class extends ProviderRegistryError {
 var CyclicFallbackError = class extends ProviderRegistryError {
   /** 成环路径,末项为再次出现的别名,如 ['main','fast','main'] */
   path;
-  constructor(path28) {
-    super("cyclic_fallback", `Cyclic fallback chain: ${path28.join(" -> ")}`);
-    this.path = path28;
+  constructor(path29) {
+    super("cyclic_fallback", `Cyclic fallback chain: ${path29.join(" -> ")}`);
+    this.path = path29;
   }
 };
 
@@ -35878,9 +36750,9 @@ function pushUnique(out, seen, resolved) {
   seen.add(dedupeKey);
   out.push(resolved);
 }
-function expandInto(config, alias, path28, out, seen) {
-  if (path28.includes(alias)) throw new CyclicFallbackError([...path28, alias]);
-  const nextPath = [...path28, alias];
+function expandInto(config, alias, path29, out, seen) {
+  if (path29.includes(alias)) throw new CyclicFallbackError([...path29, alias]);
+  const nextPath = [...path29, alias];
   pushUnique(out, seen, resolveAliasOrRef(config, alias));
   for (const entry of config.fallbacks[alias] ?? []) {
     if (entry.includes("/")) {
@@ -37973,7 +38845,7 @@ async function assembleTooling(options) {
 }
 
 // src/adjudication/prompts.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 var STAGE1_MAX_TOKENS = 64;
 var STAGE2_MAX_TOKENS = 1024;
 var TWO_STAGE_TIMEOUT_MS = 15e3;
@@ -38070,7 +38942,7 @@ function serializeTimeoutPolicy(policy) {
   ].join(";");
 }
 function makeProtocolFingerprint(components) {
-  return createHash15("sha256").update(components.join("\n\0")).digest("hex").slice(0, 16);
+  return createHash17("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";
@@ -41137,7 +42009,7 @@ async function createSession(options = {}) {
 
 // src/sessions/file-store.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
-import { mkdir as mkdir8, readFile as readFile10, rm as rm9, stat as stat8 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile11, rm as rm10, stat as stat9 } from "node:fs/promises";
 var LOCAL_END_USER_KEY = "local";
 var MESSAGE_KINDS2 = /* @__PURE__ */ new Set([
   "user_prompt",
@@ -41160,7 +42032,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 {
@@ -41295,7 +42167,7 @@ function createFileSessionStore(options) {
     cursors.set(sessionId, 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) {
@@ -41364,20 +42236,20 @@ function createFileSessionStore(options) {
     if (await readRawMeta(sessionDir) !== null) return false;
     let existed = true;
     try {
-      await stat8(sessionDir);
+      await stat9(sessionDir);
     } catch {
       existed = false;
     }
-    await mkdir8(sessionDir, { recursive: true });
+    await mkdir9(sessionDir, { recursive: true });
     let restored;
     try {
       restored = await tier.restore({ sessionId, endUserKey: LOCAL_END_USER_KEY, 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;
@@ -41611,7 +42483,7 @@ function createFileSessionStore(options) {
           tier.unbind(sessionDir);
           await tier.remove({ sessionId, endUserKey: LOCAL_END_USER_KEY });
         }
-        await rm9(sessionDir, { recursive: true, force: true });
+        await rm10(sessionDir, { recursive: true, force: true });
         await index.remove(sessionId);
       });
     },
@@ -42670,7 +43542,7 @@ function createNarrator(source, options) {
 }
 
 // src/platform/bundle-cache.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash18 } from "node:crypto";
 var DEFAULT_BUNDLE_CACHE_TTL_MS = 6e4;
 var DEFAULT_MAX_BUNDLE_ENTRIES = 16;
 var DEFAULT_MAX_FEATURE_ENTRIES = 1e5;
@@ -42710,7 +43582,7 @@ var Lru = class {
   }
 };
 function tokenScope(token) {
-  return createHash16("sha256").update(token, "utf8").digest("hex");
+  return createHash18("sha256").update(token, "utf8").digest("hex");
 }
 function bundleKey(base, appId) {
   return `${base}\0${appId ?? ""}`;
@@ -42971,9 +43843,11 @@ export {
   createAppTokenFetch,
   createBlockListClassifier,
   createBundleCache,
+  createChaosBlobStore,
   createClassifierTranscriptRecorder,
   createFileCheckpointStore,
   createFileSessionStore,
+  createFsBlobStore,
   createImageGenTool2 as createImageGenTool,
   createMcpHost,
   createMemoryBlobStore,
@@ -43033,6 +43907,7 @@ export {
   resolveStageHandle,
   runAgent,
   runIdleCompaction,
+  runStorageConformance,
   serializeTimeoutPolicy,
   setSessionViewDelivery,
   singleStageProtocolFingerprintFor,