oasis_test_v2 2.2.45 → 2.2.46

package/dist/index.js

@@ -109,22 +109,27 @@ var init_manifest = __esm({
 });
 
 // ../contract/src/file-limits.ts
+function fileUploadRequestMaxBytes(limits) {
+  return Math.min(Number.MAX_SAFE_INTEGER, Math.max(
+    4 * Math.ceil(Math.max(limits.attachmentBytes, limits.knowledgeBytes, limits.cliBytes) / 3),
+    6 * Math.max(limits.skillFileBytes, limits.textEditBytes)
+  ) + MIB);
+}
 function validateFileLimits(input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("\u6587\u4EF6\u9650\u5236\u5FC5\u987B\u662F\u5BF9\u8C61");
   const raw = input;
-  if (Object.keys(raw).some((key2) => !Object.hasOwn(DEFAULT_FILE_LIMITS, key2))) throw new Error("\u5B58\u5728\u672A\u77E5\u7684\u6587\u4EF6\u9650\u5236\u5B57\u6BB5");
+  if (Object.keys(raw).some((key2) => !Object.hasOwn(DEFAULT_FILE_LIMITS, key2) && key2 !== "skillBundleBytes" && key2 !== "skillFileCount")) throw new Error("\u5B58\u5728\u672A\u77E5\u7684\u6587\u4EF6\u9650\u5236\u5B57\u6BB5");
   const result = { ...DEFAULT_FILE_LIMITS };
   for (const key2 of Object.keys(result)) {
     const value2 = raw[key2];
-    if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 <= 0 || value2 > FILE_LIMIT_CAPACITY[key2]) {
-      throw new Error(`${key2} \u5FC5\u987B\u662F 1 \u5230 ${FILE_LIMIT_CAPACITY[key2]} \u7684\u6574\u6570`);
+    if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 <= 0) {
+      throw new Error(`${key2} \u5FC5\u987B\u662F\u6B63\u6574\u6570\uFF08\u5B57\u8282\uFF09`);
     }
     result[key2] = value2;
   }
-  if (result.skillFileBytes > result.skillBundleBytes) throw new Error("\u6280\u80FD\u5355\u6587\u4EF6\u4E0A\u9650\u4E0D\u80FD\u8D85\u8FC7\u6574\u5305\u4E0A\u9650");
   return result;
 }
-var MIB, DEFAULT_FILE_LIMITS, FILE_LIMIT_CAPACITY, FILE_UPLOAD_REQUEST_MAX_BYTES, FILE_TRANSFER_INPUT_MAX_BYTES, FILE_TRANSFER_MAX_BYTES;
+var MIB, DEFAULT_FILE_LIMITS, FILE_TRANSFER_MAX_BYTES;
 var init_file_limits = __esm({
   "../contract/src/file-limits.ts"() {
     "use strict";
@@ -133,16 +138,11 @@ var init_file_limits = __esm({
       attachmentBytes: 200 * MIB,
       knowledgeBytes: 200 * MIB,
       cliBytes: 200 * MIB,
-      skillFileBytes: 20 * MIB,
-      skillBundleBytes: 200 * MIB,
-      skillFileCount: 128,
+      skillFileBytes: 200 * MIB,
       textEditBytes: 20 * MIB,
       officePreviewBytes: 200 * MIB
     });
-    FILE_LIMIT_CAPACITY = DEFAULT_FILE_LIMITS;
-    FILE_UPLOAD_REQUEST_MAX_BYTES = 4 * Math.ceil(200 * MIB / 3) + MIB;
-    FILE_TRANSFER_INPUT_MAX_BYTES = DEFAULT_FILE_LIMITS.attachmentBytes;
-    FILE_TRANSFER_MAX_BYTES = 4 * Math.ceil((FILE_TRANSFER_INPUT_MAX_BYTES + 32 * MIB) / 3) + MIB;
+    FILE_TRANSFER_MAX_BYTES = 4 * Math.ceil((200 * MIB + 32 * MIB) / 3) + MIB;
   }
 });
 
@@ -1749,6 +1749,130 @@ var init_file_preview = __esm({
   }
 });
 
+// ../contract/src/chunked-message.ts
+function* tokens(value2, key2 = null, strings2 = /* @__PURE__ */ new Map()) {
+  if (value2 && typeof value2 === "object" && "toJSON" in value2 && typeof value2.toJSON === "function") value2 = value2.toJSON();
+  if (typeof value2 === "string") {
+    if (strings2.has(value2)) {
+      yield ["ref", key2, strings2.get(value2)];
+      return;
+    }
+    strings2.set(value2, strings2.size);
+    yield ["string", key2];
+    for (let i = 0; i < value2.length; i += STRING_CHARS) yield ["part", value2.slice(i, i + STRING_CHARS)];
+    yield ["end"];
+  } else if (value2 && typeof value2 === "object") {
+    yield [Array.isArray(value2) ? "array" : "object", key2];
+    if (Array.isArray(value2)) {
+      for (const child of value2) yield* tokens(child, null, strings2);
+    } else {
+      for (const [name, child] of Object.entries(value2)) {
+        if (child !== void 0 && typeof child !== "function" && typeof child !== "symbol") yield* tokens(child, name, strings2);
+      }
+    }
+    yield ["end"];
+  } else {
+    if (typeof value2 === "bigint") throw new Error("BigInt is not JSON serializable");
+    yield ["value", key2, value2 ?? null];
+  }
+}
+function* encodeChunkedMessage(value2) {
+  let parts = [], length = 0, start = true;
+  const frame = (done) => `{"type":"chunked_message","start":${start},"done":${done},"tokens":[${parts.join(",")}]}`;
+  for (const token of tokens(value2)) {
+    const part = JSON.stringify(token);
+    if (length + part.length > FRAME_CHARS && parts.length) {
+      yield frame(false);
+      start = false;
+      parts = [];
+      length = 0;
+    }
+    parts.push(part);
+    length += part.length + 1;
+  }
+  yield frame(true);
+}
+var FRAME_CHARS, STRING_CHARS, ChunkedMessageDecoder;
+var init_chunked_message = __esm({
+  "../contract/src/chunked-message.ts"() {
+    "use strict";
+    FRAME_CHARS = 512 * 1024;
+    STRING_CHARS = 64 * 1024;
+    ChunkedMessageDecoder = class {
+      stack = [];
+      strings = [];
+      active = false;
+      hasRoot = false;
+      root;
+      attach(key2, value2) {
+        const parent = this.stack.at(-1);
+        if (!parent) {
+          if (this.hasRoot || key2 !== null) throw new Error("Invalid chunked message root");
+          this.root = value2;
+          this.hasRoot = true;
+        } else if (parent.kind === "array") {
+          if (key2 !== null) throw new Error("Invalid array key");
+          parent.value.push(value2);
+        } else if (parent.kind === "object") {
+          if (typeof key2 !== "string" || Object.hasOwn(parent.value, key2)) throw new Error("Invalid object key");
+          Object.defineProperty(parent.value, key2, { value: value2, enumerable: true, writable: true, configurable: true });
+        } else throw new Error("Unclosed string");
+      }
+      /** undefined means that more frames are needed; plain legacy JSON passes through. */
+      accept(input) {
+        if (!input || typeof input !== "object" || !("type" in input) || input.type !== "chunked_message") return input;
+        const frame = input;
+        if (typeof frame.start !== "boolean" || typeof frame.done !== "boolean" || !Array.isArray(frame.tokens)) throw new Error("Invalid chunked frame");
+        if (frame.start) {
+          if (this.active) throw new Error("Overlapping chunked messages");
+          this.active = true;
+          this.hasRoot = false;
+          this.root = void 0;
+          this.stack = [];
+          this.strings = [];
+        }
+        if (!this.active) throw new Error("Missing chunked message start");
+        for (const token of frame.tokens) {
+          if (!Array.isArray(token)) throw new Error("Invalid chunked token");
+          const [kind, key2, value2] = token;
+          if (kind === "object" || kind === "array") {
+            const child = kind === "array" ? [] : {};
+            this.attach(key2, child);
+            this.stack.push({ kind, value: child });
+          } else if (kind === "string") {
+            if (key2 !== null && typeof key2 !== "string") throw new Error("Invalid string key");
+            this.stack.push({ kind, key: key2, parts: [] });
+          } else if (kind === "part") {
+            const parent = this.stack.at(-1);
+            if (parent?.kind !== "string" || typeof key2 !== "string") throw new Error("Invalid string part");
+            parent.parts.push(key2);
+          } else if (kind === "ref") {
+            if (!Number.isInteger(value2) || value2 < 0 || value2 >= this.strings.length) throw new Error("Invalid string reference");
+            this.attach(key2, this.strings[value2]);
+          } else if (kind === "value") this.attach(key2, value2);
+          else if (kind === "end") {
+            const parent = this.stack.pop();
+            if (!parent) throw new Error("Unexpected end");
+            if (parent.kind === "string") {
+              const text6 = parent.parts.join("");
+              this.strings.push(text6);
+              this.attach(parent.key, text6);
+            }
+          } else throw new Error("Unknown chunked token");
+        }
+        if (!frame.done) return void 0;
+        if (!this.hasRoot || this.stack.length) throw new Error("Incomplete chunked message");
+        const result = this.root;
+        this.root = void 0;
+        this.active = false;
+        this.hasRoot = false;
+        this.strings = [];
+        return result;
+      }
+    };
+  }
+});
+
 // ../contract/src/index.ts
 var init_src = __esm({
   "../contract/src/index.ts"() {
@@ -1814,6 +1938,7 @@ var init_src = __esm({
     init_http_api();
     init_file_preview();
     init_file_limits();
+    init_chunked_message();
   }
 });
 
@@ -1884,17 +2009,16 @@ function withFileLimits(limits, fn) {
 }
 function assertSkillFileLimits(files) {
   const limits = currentFileLimits();
-  if (files.length > limits.skillFileCount) throw new ApiError(413, "SKILL_TOO_LARGE", `\u6280\u80FD\u6587\u4EF6\u6570\u8D85\u8FC7 ${limits.skillFileCount} \u4E2A`);
-  let total = 0;
   for (const file of files) {
     if (file.size > limits.skillFileBytes) throw new ApiError(413, "SKILL_TOO_LARGE", `\u6280\u80FD\u6587\u4EF6\u8D85\u8FC7 ${limits.skillFileBytes / 1024 / 1024} MiB\uFF1A${file.path}`);
-    total += file.size;
   }
-  if (total > limits.skillBundleBytes) throw new ApiError(413, "SKILL_TOO_LARGE", `\u6280\u80FD\u6574\u5305\u8D85\u8FC7 ${limits.skillBundleBytes / 1024 / 1024} MiB`);
 }
 function assertFileBytes(bytes2, maxBytes = currentFileLimits().attachmentBytes) {
   if (bytes2.byteLength > maxBytes) throw new ApiError(413, "FILE_TOO_LARGE", `\u6587\u4EF6\u8D85\u8FC7 ${maxBytes / 1024 / 1024} MiB \u4E0A\u9650`);
 }
+function currentFileReadMaxBytes() {
+  return Math.max(DEFAULT_FILE_LIMITS.attachmentBytes, ...Object.values(currentFileLimits()));
+}
 function assertEditableBytes(bytes2) {
   assertFileBytes(bytes2, currentFileLimits().textEditBytes);
   if (bytes2.includes(0)) throw new ApiError(400, "INVALID_TEXT", "\u4EC5\u652F\u6301 UTF-8 \u6587\u672C");
@@ -2061,12 +2185,12 @@ async function readArtifactFile(kernel, blobs, artifactId, path40, expectedRef,
     if (!entry) throw new ApiError(404, "NOT_FOUND", "\u5305\u5185\u6587\u4EF6\u4E0D\u5B58\u5728");
     hash3 = entry.hash;
     name = entry.path;
-    if (entry.size !== void 0 && entry.size > FILE_CONTENT_MAX_BYTES) throw new ApiError(413, "FILE_TOO_LARGE", `\u6587\u4EF6\u8D85\u8FC7 ${FILE_CONTENT_MAX_BYTES / 1024 / 1024} MiB \u8BFB\u53D6\u9650\u5236`);
+    if (entry.size !== void 0 && entry.size > currentFileReadMaxBytes()) throw new ApiError(413, "FILE_TOO_LARGE", `\u6587\u4EF6\u8D85\u8FC7 ${currentFileReadMaxBytes() / 1024 / 1024} MiB \u8BFB\u53D6\u9650\u5236`);
   } else if (output.contentKind !== "inline-blob") {
     throw new ApiError(404, "NOT_FOUND", "\u6B64\u4EA7\u7269\u6CA1\u6709\u53EF\u4E0B\u8F7D\u7684\u539F\u6587\u4EF6");
   }
   const meta = await blobs.meta?.(hash3);
-  if (meta && meta.size > FILE_CONTENT_MAX_BYTES) throw new ApiError(413, "FILE_TOO_LARGE", `\u6587\u4EF6\u8D85\u8FC7 ${FILE_CONTENT_MAX_BYTES / 1024 / 1024} MiB \u8BFB\u53D6\u9650\u5236`);
+  if (meta && meta.size > currentFileReadMaxBytes()) throw new ApiError(413, "FILE_TOO_LARGE", `\u6587\u4EF6\u8D85\u8FC7 ${currentFileReadMaxBytes() / 1024 / 1024} MiB \u8BFB\u53D6\u9650\u5236`);
   try {
     return { bytes: await blobs.get(hash3), name, contentType: meta?.contentType };
   } catch {
@@ -2094,7 +2218,7 @@ async function serveFileRequest(req, res, url, engine) {
       url.searchParams.get("ref"),
       url.searchParams.get("revisionId")
     );
-    if (bytes2.length > FILE_CONTENT_MAX_BYTES) throw new ApiError(413, "FILE_TOO_LARGE", `\u6587\u4EF6\u8D85\u8FC7 ${FILE_CONTENT_MAX_BYTES / 1024 / 1024} MiB \u8BFB\u53D6\u9650\u5236`);
+    if (bytes2.length > currentFileReadMaxBytes()) throw new ApiError(413, "FILE_TOO_LARGE", `\u6587\u4EF6\u8D85\u8FC7 ${currentFileReadMaxBytes() / 1024 / 1024} MiB \u8BFB\u53D6\u9650\u5236`);
     res.writeHead(200, {
       "content-type": contentType ?? sniffContentType(bytes2) ?? "application/octet-stream",
       "content-length": String(bytes2.length),
@@ -2123,6 +2247,7 @@ var init_file_http = __esm({
     init_src();
     init_artifact_content2();
     init_router();
+    init_file_limits2();
   }
 });
 
@@ -3256,12 +3381,12 @@ function recordSubagentCall(calls, id, call) {
 }
 function byModelOf(calls) {
   const out = {};
-  for (const { model, tokens } of calls.values()) {
+  for (const { model, tokens: tokens2 } of calls.values()) {
     const acc = out[model] ?? (out[model] = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 });
-    acc.inputTokens += tokens.inputTokens;
-    acc.outputTokens += tokens.outputTokens;
-    acc.cacheReadTokens += tokens.cacheReadTokens;
-    acc.cacheCreationTokens += tokens.cacheCreationTokens;
+    acc.inputTokens += tokens2.inputTokens;
+    acc.outputTokens += tokens2.outputTokens;
+    acc.cacheReadTokens += tokens2.cacheReadTokens;
+    acc.cacheCreationTokens += tokens2.cacheCreationTokens;
   }
   return out;
 }
@@ -10140,14 +10265,14 @@ function accountUsage(model, usage) {
   const input = nonNegative(usage.inputTokens);
   const output = nonNegative(usage.outputTokens);
   const cache = nonNegative(usage.cacheReadTokens) + nonNegative(usage.cacheCreationTokens);
-  const tokens = { input, cache, output, total: input + cache + output };
+  const tokens2 = { input, cache, output, total: input + cache + output };
   const estimated = estimateUsageCostBreakdown(resolved, usage);
   const weights = estimated ? { input: estimated.inputMicros, cache: estimated.cacheMicros, output: estimated.outputMicros } : null;
   const reported = Math.max(usage.costUsdMicros ?? 0, 0);
   if (reported > 0) {
     const parts = weights && estimated?.currency === "USD" ? splitByWeight(reported, weights) : { input: 0, cache: 0, output: reported };
     return {
-      tokens,
+      tokens: tokens2,
       currency: "USD",
       amountMicros: reported,
       parts,
@@ -10160,7 +10285,7 @@ function accountUsage(model, usage) {
     const amount = weights.input + weights.cache + weights.output;
     const displayUsdMicros = toDisplayUsd(estimated.currency, amount);
     return {
-      tokens,
+      tokens: tokens2,
       currency: estimated.currency,
       amountMicros: amount,
       parts: weights,
@@ -10170,7 +10295,7 @@ function accountUsage(model, usage) {
     };
   }
   return {
-    tokens,
+    tokens: tokens2,
     currency: "USD",
     amountMicros: 0,
     parts: { input: 0, cache: 0, output: 0 },
@@ -10195,8 +10320,8 @@ function estimateSubagentCostUsdMicros(usage) {
   const models = Object.entries(usage.byModel);
   if (models.length === 0) return void 0;
   let total = 0;
-  for (const [model, tokens] of models) {
-    const account = accountUsage(model, { ...tokens, costUsdMicros: null });
+  for (const [model, tokens2] of models) {
+    const account = accountUsage(model, { ...tokens2, costUsdMicros: null });
     if (!account || account.source !== "estimated") return void 0;
     total += account.displayUsdMicros;
   }
@@ -24975,13 +25100,13 @@ var require_axios = __commonJS({
       return utils$1.isArray(value2) ? value2.map(normalizeValue) : String(value2);
     }
     function parseTokens(str5) {
-      const tokens = /* @__PURE__ */ Object.create(null);
+      const tokens2 = /* @__PURE__ */ Object.create(null);
       const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
       let match;
       while (match = tokensRE.exec(str5)) {
-        tokens[match[1]] = match[2];
+        tokens2[match[1]] = match[2];
       }
-      return tokens;
+      return tokens2;
     }
     var isValidHeaderName = (str5) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str5.trim());
     function matchHeaderValue(context2, value2, header, filter, isHeaderNameFilter) {
@@ -166604,8 +166729,6 @@ async function prepareSessionFileRestore(input) {
   }
   if (input.fresh) issues.push(...saveIssues.map((i) => ({ ...i, phase: "restore", message: `\u539F\u6587\u4EF6\u5C1A\u672A\u4FDD\u5B58\uFF1A${i.message}` })));
   const lines = ["# \u4F1A\u8BDD\u6587\u4EF6", "", "\u4EE5\u4E0B\u6587\u4EF6\u6765\u81EA\u672C\u4F1A\u8BDD\u7684\u6301\u4E45\u8BB0\u5F55\u3002\u5386\u53F2\u8F93\u5165\u6309\u7248\u672C\u4FDD\u7559\uFF1Boutputs \u662F\u6700\u8FD1\u4FDD\u5B58\u7684\u4EA7\u51FA\u3002", ""];
-  let total = 0;
-  const inlineMax = input.inlineMaxBytes ?? RESTORE_INLINE_MAX_BYTES;
   const seen = /* @__PURE__ */ new Set();
   const add = async (name, ref2, path40, replace2) => {
     if (seen.has(path40)) return;
@@ -166615,12 +166738,9 @@ async function prepareSessionFileRestore(input) {
       return;
     }
     try {
-      if (Object.keys(restoreFiles).length >= RESTORE_MAX_FILES) throw new Error("\u8FD9\u4E00\u8F6E\u8981\u968F\u4EFB\u52A1\u5E26\u8FC7\u53BB\u7684\u6587\u4EF6\u592A\u591A\uFF0C\u5B83\u6CA1\u6392\u4E0A\uFF1B\u539F\u4EF6\u5728\u670D\u52A1\u7AEF\u5B8C\u597D\uFF0C\u53EF\u5728\u9879\u76EE\u300C\u76F8\u5173\u6587\u4EF6\u300D\u91CC\u6253\u5F00");
       const bytes2 = await input.readBlob(ref2);
-      if (total + bytes2.byteLength > inlineMax) throw new Error(`\u8FD9\u4E00\u8F6E\u968F\u4EFB\u52A1\u9001\u5230\u8FD0\u884C\u673A\u5668\u7684\u6587\u4EF6\u603B\u91CF\u5DF2\u6EE1 ${Math.round(inlineMax / 1024 / 1024)} MiB\uFF0C\u5B83\u8FD9\u6B21\u6CA1\u9001\u8FC7\u53BB\uFF1B\u539F\u4EF6\u5728\u670D\u52A1\u7AEF\u5B8C\u597D\uFF0C\u53EF\u5728\u9879\u76EE\u300C\u76F8\u5173\u6587\u4EF6\u300D\u91CC\u6253\u5F00`);
       const hash3 = (0, import_node_crypto24.createHash)("sha256").update(bytes2).digest("hex");
       if (hash3 !== ref2.replace(/^blob:/, "")) throw new Error("\u539F\u4EF6\u5185\u5BB9\u6821\u9A8C\u5931\u8D25");
-      total += bytes2.byteLength;
       restoreFiles[path40] = { contentBase64: Buffer.from(bytes2).toString("base64"), sha256: hash3, overwrite: replace2 };
       lines.push(`- ${JSON.stringify(name)} \u2192 ${JSON.stringify(path40)}`);
     } catch (error2) {
@@ -166652,17 +166772,14 @@ async function prepareSessionFileRestore(input) {
   if (blocking.length) throw new ApiError(409, "CHAT_FILE_RESTORE_FAILED", `\u6587\u4EF6\u6062\u590D\u672A\u5B8C\u6210\uFF1A${blocking.map((i) => i.message).join("\uFF1B")}`);
   return { restoreFiles, index: lines.join("\n") };
 }
-var import_node_crypto24, RESTORE_INLINE_MAX_BYTES, RESTORE_MAX_FILES;
+var import_node_crypto24;
 var init_file_restore = __esm({
   "../server/src/domains/chat-sessions/file-restore.ts"() {
     "use strict";
     import_node_crypto24 = require("node:crypto");
-    init_src();
     init_chat_attachment_files();
     init_router();
     init_persistent_files();
-    RESTORE_INLINE_MAX_BYTES = FILE_TRANSFER_INPUT_MAX_BYTES;
-    RESTORE_MAX_FILES = 500;
   }
 });
 
@@ -179356,20 +179473,20 @@ function knowledgeSearchTokenStream(value2) {
       raw.push(token);
     }
   }
-  const tokens = [];
+  const tokens2 = [];
   for (let index2 = 0; index2 < raw.length; index2++) {
     const token = raw[index2];
     const next = raw[index2 + 1];
     const merged = new RegExp("^\\p{Script=Han}$", "u").test(token) && next && new RegExp("^\\p{Script=Han}$", "u").test(next) ? `${token}${next}` : token;
     if (merged !== token) index2++;
     if (LEXICAL_STOPWORDS.has(merged)) continue;
-    tokens.push(merged);
+    tokens2.push(merged);
     const chars = [...merged];
     if (new RegExp("^\\p{Script=Han}+$", "u").test(merged) && chars.length > 2) {
-      for (let index3 = 0; index3 < chars.length - 1; index3++) tokens.push(`${chars[index3]}${chars[index3 + 1]}`);
+      for (let index3 = 0; index3 < chars.length - 1; index3++) tokens2.push(`${chars[index3]}${chars[index3 + 1]}`);
     }
   }
-  return tokens;
+  return tokens2;
 }
 function knowledgeSearchTerms(value2) {
   return [...new Set(knowledgeSearchTokenStream(value2))];
@@ -179381,20 +179498,20 @@ function documentSearchTokens(chunk) {
     [chunk.logicalPath, 2]
   ];
   return fields.flatMap(([value2, repeats]) => {
-    const tokens = knowledgeSearchTokenStream(value2);
-    return Array.from({ length: repeats }, () => tokens).flat();
+    const tokens2 = knowledgeSearchTokenStream(value2);
+    return Array.from({ length: repeats }, () => tokens2).flat();
   });
 }
 function layeredSearchTokens(chunk, lexicalLayer) {
   return lexicalLayer === "document" ? documentSearchTokens(chunk) : knowledgeSearchTokenStream(chunk.text);
 }
 function knowledgeSearchIndexFields(chunk, lexicalLayer) {
-  const tokens = layeredSearchTokens(chunk, lexicalLayer);
+  const tokens2 = layeredSearchTokens(chunk, lexicalLayer);
   return {
-    terms: [...new Set(tokens)],
+    terms: [...new Set(tokens2)],
     lexicalIndexVersion: KNOWLEDGE_LEXICAL_INDEX_VERSION,
     lexicalLayer,
-    tokenCount: tokens.length
+    tokenCount: tokens2.length
   };
 }
 function knowledgeSearchIndexEntries(input) {
@@ -179478,10 +179595,10 @@ function splitKnowledgeChunks(content3, maxChars = 1600) {
 function scoreKnowledgeChunk(query, chunk, corpus) {
   const queryTerms = knowledgeSearchTerms(query);
   if (queryTerms.length === 0) return 0;
-  const tokens = layeredSearchTokens(chunk, chunk.lexicalLayer ?? "chunk");
+  const tokens2 = layeredSearchTokens(chunk, chunk.lexicalLayer ?? "chunk");
   const frequencies2 = /* @__PURE__ */ new Map();
-  for (const token of tokens) frequencies2.set(token, (frequencies2.get(token) ?? 0) + 1);
-  const documentLength = chunk.tokenCount ?? tokens.length;
+  for (const token of tokens2) frequencies2.set(token, (frequencies2.get(token) ?? 0) + 1);
+  const documentLength = chunk.tokenCount ?? tokens2.length;
   const averageLength = Math.max(1, corpus.averageTokenCount);
   const documentCount = Math.max(1, corpus.size);
   const k1 = 1.2;
@@ -183308,7 +183425,7 @@ ${pointer}
 var require_resolve_props = __commonJS({
   "../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/dist/compose/resolve-props.js"(exports2) {
     "use strict";
-    function resolveProps(tokens, { flow: flow3, indicator, next, offset, onError, parentIndent, startOnNewline }) {
+    function resolveProps(tokens2, { flow: flow3, indicator, next, offset, onError, parentIndent, startOnNewline }) {
       let spaceBefore = false;
       let atNewline = startOnNewline;
       let hasSpace = startOnNewline;
@@ -183323,7 +183440,7 @@ var require_resolve_props = __commonJS({
       let comma = null;
       let found2 = null;
       let start = null;
-      for (const token of tokens) {
+      for (const token of tokens2) {
         if (reqSpace) {
           if (token.type !== "space" && token.type !== "newline" && token.type !== "comma")
             onError(token.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
@@ -183414,7 +183531,7 @@ var require_resolve_props = __commonJS({
             hasSpace = false;
         }
       }
-      const last = tokens[tokens.length - 1];
+      const last = tokens2[tokens2.length - 1];
       const end = last ? last.offset + last.source.length : offset;
       if (reqSpace && next && next.type !== "space" && next.type !== "newline" && next.type !== "comma" && (next.type !== "scalar" || next.source !== "")) {
         onError(next.offset, "MISSING_CHAR", "Tags and anchors must be separated from the next token by white space");
@@ -184753,8 +184870,8 @@ ${cb}` : comment;
        * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
        * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
        */
-      *compose(tokens, forceDoc = false, endOffset = -1) {
-        for (const token of tokens)
+      *compose(tokens2, forceDoc = false, endOffset = -1) {
+        for (const token of tokens2)
           yield* this.next(token);
         yield* this.end(forceDoc, endOffset);
       }
@@ -192924,8 +193041,8 @@ var init_governance_service = __esm({
           return false;
         };
         const addFragment = (source, content3) => {
-          const tokens = estimateKnowledgeTokens(content3);
-          if (usedTokens + tokens > selectedPolicy.tokenBudget) return false;
+          const tokens2 = estimateKnowledgeTokens(content3);
+          if (usedTokens + tokens2 > selectedPolicy.tokenBudget) return false;
           const fragment = this.snapshot(ctx, "context_pack", content3, trustedProjectId, void 0);
           snapshots2.push(fragment);
           entries.push({
@@ -192941,12 +193058,12 @@ var init_governance_service = __esm({
             ...source.score !== void 0 ? { relevanceScore: source.score } : {},
             ...source.evidenceRole ? { evidenceRole: source.evidenceRole } : {},
             contentHash: fragment.contentHash,
-            tokenCount: tokens,
+            tokenCount: tokens2,
             ordinal: entries.length,
             renderedFragmentRef: fragment.ref
           });
           fragments.push(content3);
-          usedTokens += tokens;
+          usedTokens += tokens2;
           return true;
         };
         const taskFacts = [...request2.facts];
@@ -203190,9 +203307,9 @@ function lexicalMatchRatio(query, value2) {
   const actual = new Set(lexicalTerms(value2));
   return expected.filter((term) => actual.has(term)).length / expected.length;
 }
-function frequencies(tokens) {
+function frequencies(tokens2) {
   const values = /* @__PURE__ */ new Map();
-  for (const token of tokens) values.set(token, (values.get(token) ?? 0) + 1);
+  for (const token of tokens2) values.set(token, (values.get(token) ?? 0) + 1);
   return values;
 }
 function bm25Scores(query, documents, options = {}) {
@@ -203200,21 +203317,21 @@ function bm25Scores(query, documents, options = {}) {
   const queryTokens = [...new Set(typeof query === "string" ? lexicalTerms(query) : query)];
   if (queryTokens.length === 0) return documents.map(() => 0);
   const tokenized = documents.map((document4) => lexicalTerms(document4));
-  const averageLength = tokenized.reduce((total, tokens) => total + tokens.length, 0) / Math.max(1, tokenized.length);
+  const averageLength = tokenized.reduce((total, tokens2) => total + tokens2.length, 0) / Math.max(1, tokenized.length);
   const documentFrequencies = /* @__PURE__ */ new Map();
   for (const term of queryTokens) {
-    documentFrequencies.set(term, tokenized.filter((tokens) => tokens.includes(term)).length);
+    documentFrequencies.set(term, tokenized.filter((tokens2) => tokens2.includes(term)).length);
   }
   const k1 = options.k1 ?? 1.2;
   const b2 = options.b ?? 0.75;
-  const raw = tokenized.map((tokens) => {
-    const counts2 = frequencies(tokens);
+  const raw = tokenized.map((tokens2) => {
+    const counts2 = frequencies(tokens2);
     return queryTokens.reduce((score, term) => {
       const tf = counts2.get(term) ?? 0;
       if (tf === 0) return score;
       const df = documentFrequencies.get(term) ?? 0;
       const idf = Math.log(1 + (documents.length - df + 0.5) / (df + 0.5));
-      const lengthNormalization = 1 - b2 + b2 * tokens.length / Math.max(1, averageLength);
+      const lengthNormalization = 1 - b2 + b2 * tokens2.length / Math.max(1, averageLength);
       return score + idf * tf * (k1 + 1) / (tf + k1 * lengthNormalization);
     }, 0);
   });
@@ -207589,12 +207706,9 @@ async function startOasisServer(opts) {
             }));
             return;
           }
-          await serveFileRequest(
-            req,
-            res,
-            url,
-            await resolveEngine(company?.kind === "ok" ? company.companyId : void 0)
-          );
+          const companyId = company?.kind === "ok" ? company.companyId : void 0;
+          const limits = await opts.fileLimits?.get(companyId) ?? DEFAULT_FILE_LIMITS;
+          await withFileLimits(limits, async () => serveFileRequest(req, res, url, await resolveEngine(companyId)));
           return;
         }
         if (url.pathname === "/api/whoami" && req.method === "GET") {
@@ -207621,17 +207735,18 @@ async function startOasisServer(opts) {
         const companyCtx = opts.resolveCompanyContext ? await opts.resolveCompanyContext(actor, req.headers, url.pathname) : void 0;
         const currentCompanyId = companyCtx?.kind === "ok" ? companyCtx.companyId : void 0;
         const fileLimits = await opts.fileLimits?.get(currentCompanyId) ?? { ...DEFAULT_FILE_LIMITS };
+        const requestMaxBytes = fileUploadRequestMaxBytes(fileLimits);
         const chunks = [];
         let requestBytes = 0;
         const declared = Number(req.headers["content-length"] ?? 0);
-        if (declared > FILE_UPLOAD_REQUEST_MAX_BYTES) {
+        if (declared > requestMaxBytes) {
           req.resume();
           res.writeHead(413, { "content-type": "application/json" }).end(JSON.stringify({ error: { code: "UPLOAD_TOO_LARGE", message: "\u4E0A\u4F20\u8BF7\u6C42\u8D85\u8FC7\u901A\u9053\u5BB9\u91CF" } }));
           return;
         }
         for await (const chunk of req) {
           requestBytes += chunk.length;
-          if (requestBytes > FILE_UPLOAD_REQUEST_MAX_BYTES) {
+          if (requestBytes > requestMaxBytes) {
             res.writeHead(413, { "content-type": "application/json" }).end(JSON.stringify({ error: { code: "UPLOAD_TOO_LARGE", message: "\u4E0A\u4F20\u8BF7\u6C42\u8D85\u8FC7\u901A\u9053\u5BB9\u91CF" } }));
             return;
           }
@@ -207658,9 +207773,9 @@ async function startOasisServer(opts) {
                 return;
               }
               await opts.fileLimits.put(currentCompanyId, limits);
-              res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ limits, capacity: FILE_LIMIT_CAPACITY, canManage }));
+              res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ limits, canManage }));
             } else {
-              res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ limits: fileLimits, capacity: FILE_LIMIT_CAPACITY, canManage }));
+              res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ limits: fileLimits, canManage }));
             }
             return;
           }
@@ -221679,6 +221794,15 @@ var init_handshake_throttle = __esm({
 });
 
 // ../server/src/daemon-hub.ts
+function legacyMessage(msg, maxBytes = FILE_TRANSFER_MAX_BYTES) {
+  try {
+    const json = JSON.stringify(msg);
+    if (Buffer.byteLength(json) <= maxBytes) return json;
+  } catch (error2) {
+    if (!(error2 instanceof RangeError)) throw error2;
+  }
+  throw new Error("\u5F53\u524D\u6267\u884C\u8282\u70B9\u6216\u4F1A\u8BDD\u4E0D\u652F\u6301\u5927\u6587\u4EF6\u5206\u5757\u4F20\u8F93\uFF0C\u8BF7\u5347\u7EA7\u8282\u70B9\u5E76\u91CD\u65B0\u5F00\u59CB\u672C\u8F6E\u5BF9\u8BDD");
+}
 function clientIpOf(req) {
   const fwd = req.headers["x-forwarded-for"];
   const raw = Array.isArray(fwd) ? fwd[0] : fwd;
@@ -221941,11 +222065,15 @@ var init_daemon_hub = __esm({
       handleSessionConnection(ws, auth) {
         const { nodeId, dispatchId } = auth;
         let registered = false;
+        const decoder = new ChunkedMessageDecoder();
         ws.on("message", (raw) => {
           let msg;
           try {
-            msg = JSON.parse(raw.toString());
+            const decoded = decoder.accept(JSON.parse(raw.toString()));
+            if (decoded === void 0) return;
+            msg = decoded;
           } catch {
+            ws.close(1007, "Invalid message framing");
             return;
           }
           if (msg.type === "session_hello") {
@@ -221962,6 +222090,7 @@ var init_daemon_hub = __esm({
                 sessionId: msg.sessionId,
                 connectedAt: Date.now(),
                 supportsInputConsumptionReceipts: msg.supportsInputConsumptionReceipts === true,
+                supportsChunkedMessages: msg.supportsChunkedMessages === true,
                 ...msg.jobArtifactId ? { jobArtifactId: msg.jobArtifactId } : {}
               });
               for (const l of this.sessionConnectListeners) l({ dispatchId, sessionId: msg.sessionId, nodeId });
@@ -222158,7 +222287,7 @@ var init_daemon_hub = __esm({
       sendToSession(dispatchId, msg) {
         const ws = this.sessionSockets.get(dispatchId);
         if (!ws || ws.readyState !== import_websocket.default.OPEN) return false;
-        ws.send(JSON.stringify(msg));
+        for (const frame of this.sessionMeta.get(dispatchId)?.supportsChunkedMessages ? encodeChunkedMessage(msg) : [legacyMessage(msg, 100 * MIB)]) ws.send(frame);
         return true;
       }
       /**
@@ -222219,16 +222348,20 @@ var init_daemon_hub = __esm({
           sourceIp: clientIpOf(req),
           send: (msg) => {
             if (ws.readyState !== import_websocket.default.OPEN) return false;
-            ws.send(JSON.stringify(msg));
+            for (const frame of daemon.meta.supportsChunkedMessages ? encodeChunkedMessage(msg) : [legacyMessage(msg)]) ws.send(frame);
             return true;
           },
           close: () => ws.close()
         };
+        const decoder = new ChunkedMessageDecoder();
         ws.on("message", (raw) => {
           let msg;
           try {
-            msg = JSON.parse(raw.toString());
+            const decoded = decoder.accept(JSON.parse(raw.toString()));
+            if (decoded === void 0) return;
+            msg = decoded;
           } catch {
+            ws.close(1007, "Invalid message framing");
             return;
           }
           this.lastSeen.set(daemonId, Date.now());
@@ -222266,7 +222399,7 @@ var init_daemon_hub = __esm({
         ws.on("error", (err) => {
           console.error(`[hub] daemon ${daemonId} error:`, err.message);
         });
-        daemon.send({ type: "ping" });
+        daemon.send({ type: "ping", supportsChunkedMessages: true });
       }
       /**
        * 周期性活性 sweep：
@@ -222289,7 +222422,7 @@ var init_daemon_hub = __esm({
             this.sockets.get(id)?.terminate();
             continue;
           }
-          daemon.send({ type: "ping" });
+          daemon.send({ type: "ping", supportsChunkedMessages: true });
         }
       }
       /** 关闭 hub：停 liveness 定时器并断开所有 daemon。serve 关停时调用。 */
@@ -222547,17 +222680,11 @@ var init_skill_fetcher = __esm({
     SKILL_DESCRIPTION_MAX = 600;
     Bundle = class {
       files = {};
-      totalBytes = 0;
-      fileCount = 0;
       add(path40, content3) {
         const bytes2 = new TextEncoder().encode(content3).length;
-        if (this.fileCount >= currentFileLimits().skillFileCount)
-          throw new Error(`Import bundle exceeds ${currentFileLimits().skillFileCount} file limit`);
-        if (this.totalBytes + bytes2 > currentFileLimits().skillBundleBytes)
-          throw new Error(`Import bundle exceeds ${currentFileLimits().skillBundleBytes} byte limit`);
+        if (bytes2 > currentFileLimits().skillFileBytes)
+          throw new Error(`Skill file exceeds ${currentFileLimits().skillFileBytes} byte limit: ${path40}`);
         this.files[path40] = content3;
-        this.totalBytes += bytes2;
-        this.fileCount++;
       }
     };
   }
@@ -223330,7 +223457,7 @@ ${input.description}
         const file = this.buildSkillFile(skillId, path40, content3, now);
         const existing = await this.opts.store.listSkillFiles(skillId);
         const next = [...existing.filter((f2) => f2.path !== path40), file];
-        assertSkillFileLimits(next);
+        assertSkillFileLimits([file]);
         await this.opts.store.putSkillFiles(skillId, next);
         if (path40 === "SKILL.md") {
           const { name, description } = parseSkillFrontmatter(content3);
@@ -224379,17 +224506,14 @@ function unpackSkillBundle(bytes2) {
     throw new SkillPackageInvalidError("\u6280\u80FD\u5305\u7F3A\u5C11 files \u5BF9\u8C61");
   }
   const out = [];
-  let total = 0;
   for (const [path40, content3] of Object.entries(files)) {
     if (typeof content3 !== "string") throw new SkillPackageInvalidError(`\u6587\u4EF6 ${path40} \u4E0D\u662F\u6587\u672C`);
     if (!isCanonicalRelativePath(path40)) throw new SkillPackageInvalidError(`\u975E\u6CD5\u6280\u80FD\u6587\u4EF6\u8DEF\u5F84\uFF1A${path40}`);
     const size = Buffer.byteLength(content3, "utf8");
     if (size > currentFileLimits().skillFileBytes) throw new SkillPackageInvalidError(`\u6587\u4EF6\u8FC7\u5927\uFF1A${path40}`);
-    total += size;
-    if (total > currentFileLimits().skillBundleBytes) throw new SkillPackageInvalidError("\u6280\u80FD\u5305\u603B\u5927\u5C0F\u8D85\u9650");
     out.push({ path: path40, content: content3 });
   }
-  if (out.length === 0 || out.length > currentFileLimits().skillFileCount) {
+  if (out.length === 0) {
     throw new SkillPackageInvalidError("\u6280\u80FD\u5305\u6587\u4EF6\u6570\u91CF\u975E\u6CD5");
   }
   if (!out.some((f2) => f2.path === "SKILL.md")) {
@@ -240049,7 +240173,7 @@ function createChatSessionsDomain(opts) {
       const outcome = await bridge.read(
         loc.nodeId,
         { workdirKey: loc.workdirKey, runtimeKind: loc.runtimeKind, rtId: loc.rtId, path: req.query?.get("path") ?? "" },
-        FILE_CONTENT_MAX_BYTES
+        currentFileReadMaxBytes()
       );
       if (outcome.ok) {
         const buf = Buffer.from(outcome.contentBase64, "base64");
@@ -244477,7 +244601,13 @@ var init_daemon_adapter = __esm({
         };
         this.pending.set(dispatchId, entry);
         const sessionAuth = this.sessionAuth ? { ...this.sessionAuth.issue({ nodeId, dispatchId }), gatewayUrl: this.sessionAuth.gatewayUrl } : void 0;
-        const sent = this.hub.dispatch(nodeId, { type: "dispatch", dispatchId, job, ...sessionAuth ? { sessionAuth } : {} });
+        let sent;
+        try {
+          sent = this.hub.dispatch(nodeId, { type: "dispatch", dispatchId, job, ...sessionAuth ? { sessionAuth } : {} });
+        } catch (error2) {
+          this.pending.delete(dispatchId);
+          throw error2;
+        }
         if (!sent) {
           queueMicrotask(() => this.settle(dispatchId, { code: null, reason: "server-unreachable", errorMessage: `\u6D3E\u53D1\u65F6\u8282\u70B9 ${nodeId} \u4E0D\u5728\u7EBF\uFF08socket \u975E OPEN\uFF09\uFF0C\u5E27\u672A\u9001\u8FBE` }));
         } else if (this.ackTimeoutMs > 0) {
@@ -263233,6 +263363,7 @@ var init_trajectory = __esm({
 
 // src/index.ts
 var fs44 = __toESM(require("node:fs"));
+init_src();
 var os14 = __toESM(require("node:os"));
 var path39 = __toESM(require("node:path"));
 var import_node_child_process22 = require("node:child_process");
@@ -271572,6 +271703,7 @@ var SessionManager = class {
 // ../cli/src/daemon/session-process.ts
 var fs35 = __toESM(require("node:fs"), 1);
 var path30 = __toESM(require("node:path"), 1);
+var import_node_readline = require("node:readline");
 init_wrapper();
 init_src();
 
@@ -271754,7 +271886,7 @@ var OUTBOX_MAX_FRAMES = 8e3;
 var isKeyFrame = (m2) => m2.type === "session_started" || m2.type === "session_exited";
 async function runSessionProcess(specFile, adapter) {
   process.env["OASIS_BIND_RUNTIME_PDEATHSIG"] = "1";
-  const spec = readSpec(specFile);
+  const spec = await readSpec(specFile);
   const { dispatchId, job, auth, sessionDir } = spec;
   const lock = acquireSessionLock(path30.join(sessionDir, "lock"));
   if (!lock && hasFlock()) {
@@ -271767,13 +271899,24 @@ async function runSessionProcess(specFile, adapter) {
   const state = new SessionProcessState(spec, adapter, lock);
   await state.run();
 }
-function readSpec(specFile) {
-  const spec = JSON.parse(fs35.readFileSync(specFile, "utf8"));
+async function readSpec(specFile) {
+  const decoder = new ChunkedMessageDecoder();
+  const source = fs35.createReadStream(specFile, { encoding: "utf8" });
+  const lines = (0, import_node_readline.createInterface)({ input: source, crlfDelay: Infinity });
   try {
-    fs35.unlinkSync(specFile);
-  } catch {
+    for await (const line of lines) {
+      const spec = decoder.accept(JSON.parse(line));
+      if (spec !== void 0) return spec;
+    }
+    throw new Error("Incomplete session specification");
+  } finally {
+    lines.close();
+    source.destroy();
+    try {
+      fs35.unlinkSync(specFile);
+    } catch {
+    }
   }
-  return spec;
 }
 var SessionProcessState = class {
   constructor(spec, adapter, lock) {
@@ -271880,16 +272023,21 @@ var SessionProcessState = class {
         ...this.spec.job.artifactId ? { jobArtifactId: this.spec.job.artifactId } : {},
         // ADR 0300 D2：自报支持帧号；新服务端据此回带 ackSeq 的 hello-ack，届时才把 serverSupportsDedup 置真。
         supportsFrameSeq: true,
+        supportsChunkedMessages: true,
         supportsInputConsumptionReceipts: true
       });
       const toResend = this.serverSupportsDedup ? this.outbox : this.outbox.filter(isKeyFrame);
       for (const m2 of toResend) this.rawSend(m2);
     });
+    const decoder = new ChunkedMessageDecoder();
     ws.on("message", (raw) => {
       let msg;
       try {
-        msg = JSON.parse(raw.toString());
+        const decoded = decoder.accept(JSON.parse(raw.toString()));
+        if (decoded === void 0) return;
+        msg = decoded;
       } catch {
+        ws.close(1007, "Invalid message framing");
         return;
       }
       void this.onServerMessage(msg);
@@ -272576,6 +272724,7 @@ var DaemonWsClient = class {
     else log2("[node-cli]", "\u505C\u673A\u6392\u7A7A\u5B8C\u6210\uFF1A\u5728\u9014\u4F1A\u8BDD\u7684\u9000\u51FA\u5E27\u5747\u5DF2\u786E\u8BA4\u9001\u8FBE");
     this.stop();
   }
+  serverSupportsChunkedMessages = false;
   connect() {
     if (this.stopped) return;
     const ws = new import_websocket.default(this.serverUrl, {
@@ -272589,6 +272738,7 @@ var DaemonWsClient = class {
       handshakeTimeout: this.handshakeTimeoutMs
     });
     this.ws = ws;
+    this.serverSupportsChunkedMessages = false;
     ws.on("open", () => {
       log2("[node-cli]", `connected  id=${this.daemonId}`);
       this.authRejectStreak = 0;
@@ -272606,12 +272756,16 @@ var DaemonWsClient = class {
         }
       }, this.pingIntervalMs);
     });
+    const decoder = new ChunkedMessageDecoder();
     ws.on("message", (raw) => {
       this.lastReceivedAt = Date.now();
       let msg;
       try {
-        msg = JSON.parse(raw.toString());
+        const decoded = decoder.accept(JSON.parse(raw.toString()));
+        if (decoded === void 0) return;
+        msg = decoded;
       } catch {
+        ws.close(1007, "Invalid message framing");
         return;
       }
       void this.handleMessage(msg);
@@ -272728,6 +272882,7 @@ var DaemonWsClient = class {
         break;
       }
       case "ping":
+        this.serverSupportsChunkedMessages = msg.supportsChunkedMessages === true;
         this.send({ type: "pong" });
         break;
       case "ack":
@@ -272833,7 +272988,9 @@ var DaemonWsClient = class {
     });
   }
   send(msg) {
-    if (this.ws?.readyState === import_websocket.default.OPEN) this.ws.send(JSON.stringify(msg));
+    if (this.ws?.readyState === import_websocket.default.OPEN) {
+      for (const frame of this.serverSupportsChunkedMessages && msg.type === "workdir_read_result" ? encodeChunkedMessage(msg) : [JSON.stringify(msg)]) this.ws.send(frame);
+    }
   }
   /**
    * 待补发流帧数（观测/测试用）。
@@ -272958,6 +273115,7 @@ var DaemonWsClient = class {
       // ADR 0554：本 daemon 认 `workdir_walk`。恒 true——handler 随包发，装了这版就一定有。
       supportsWorkdirWalk: true,
       supportsFileRestore: true,
+      supportsChunkedMessages: true,
       ...activeSessions.length > 0 ? { activeSessions } : {},
       // 始终带字段（空数组也带）作为新协议能力标志；服务端仅对支持该字段的节点做缺席确认。
       pendingDispatchIds: [...this.pendingDispatchIds]
@@ -277580,8 +277738,6 @@ ${res.warning}`);
         const SKIP2 = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store"]);
         const limits = await loadFileLimits();
         const MAX_FILE_BYTES3 = limits.skillFileBytes;
-        const MAX_FILE_COUNT = limits.skillFileCount;
-        let totalBytes = 0;
         const local = {};
         const binary = [];
         const walk = (abs, rel) => {
@@ -277595,8 +277751,6 @@ ${res.warning}`);
             }
             const size = fs39.statSync(childAbs).size;
             if (size > MAX_FILE_BYTES3) throw new Error(`\u6280\u80FD\u6587\u4EF6\u8D85\u8FC7 ${MAX_FILE_BYTES3 / 1024 / 1024} MiB\uFF1A${childRel}`);
-            totalBytes += size;
-            if (totalBytes > limits.skillBundleBytes) throw new Error(`\u6280\u80FD\u6574\u5305\u8D85\u8FC7 ${limits.skillBundleBytes / 1024 / 1024} MiB`);
             const buf = fs39.readFileSync(childAbs);
             if (buf.includes(0)) {
               binary.push(childRel);
@@ -277612,7 +277766,6 @@ ${res.warning}`);
         }
         const paths = Object.keys(local);
         if (paths.length === 0) throw new Error(`\u76EE\u5F55\u91CC\u6CA1\u6709\u53EF\u4E0A\u4F20\u7684\u6587\u4EF6\uFF1A${dir2}`);
-        if (paths.length > MAX_FILE_COUNT) throw new Error(`\u6280\u80FD\u6587\u4EF6\u6570\u8D85\u8FC7 ${MAX_FILE_COUNT} \u4E2A\uFF1A${paths.length}`);
         const skillMd = local["SKILL.md"];
         if (skillMd === void 0) {
           throw new Error(`${dir2} \u6839\u76EE\u5F55\u4E0B\u6CA1\u6709 SKILL.md\u2014\u2014\u6280\u80FD\u5FC5\u987B\u6709\u5B83\uFF08frontmatter \u5199 name \u548C description\uFF0C\u6B63\u6587\u5199\u505A\u6CD5\uFF09\u3002`);
@@ -278883,7 +279036,7 @@ function shimScript() {
 }
 
 // src/index.ts
-var PKG_VERSION = true ? "2.2.45" : "dev";
+var PKG_VERSION = true ? "2.2.46" : "dev";
 var LOCAL_BIN = localBin();
 var NPM_PREFIX = npmPrefix();
 var INSTANCE = DEFAULT_INSTANCE;
@@ -279294,13 +279447,19 @@ function spawnSessionProcess(spec) {
     fs44.mkdirSync(dir, { recursive: true, mode: 448 });
     const specFile = path39.join(dir, "spec.json");
     const cfg = readConfig();
-    fs44.writeFileSync(specFile, JSON.stringify({
-      ...spec,
-      sessionDir: dir,
-      nodeId: cfg?.nodeId ?? INSTANCE,
-      daemonVersion: PKG_VERSION,
-      daemonPkg: PKG_NAME
-    }), { mode: 384 });
+    const fd = fs44.openSync(specFile, "w", 384);
+    try {
+      for (const frame of encodeChunkedMessage({
+        ...spec,
+        sessionDir: dir,
+        nodeId: cfg?.nodeId ?? INSTANCE,
+        daemonVersion: PKG_VERSION,
+        daemonPkg: PKG_NAME
+      })) fs44.writeFileSync(fd, `${frame}
+`);
+    } finally {
+      fs44.closeSync(fd);
+    }
     let pinnedDir = INST.currentLink;
     try {
       pinnedDir = fs44.realpathSync(INST.currentLink);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oasis_test_v2",
-  "version": "2.2.45",
+  "version": "2.2.46",
   "description": "Oasis node daemon + CLI — background daemon, auto-start, full server CLI",
   "bin": {
     "oasis": "./dist/index.js"
@@ -26,6 +26,6 @@
     "node": ">=20"
   },
   "oasisRelease": {
-    "sourceHead": "c27918782543065f65990ee2acc32b3da89bba06"
+    "sourceHead": "71593b93fa3ef6950c616a185e2ed7b0ee7b88e7"
   }
 }