nolo-cli 0.8.0-alpha.13 → 0.8.0-alpha.15

package/{chunk-7U4TQSWU.js → chunk-AWCQ2SK4.js}

@@ -1,6 +1,6 @@
 import {
   updateContentTitle
-} from "./chunk-ZRS4MX3R.js";
+} from "./chunk-HBY2MXIN.js";
 import {
   require_date_fns
 } from "./chunk-M76ECQRD.js";
@@ -13,7 +13,7 @@ import {
 import {
   patch,
   readAndWait
-} from "./chunk-V2AISYMA.js";
+} from "./chunk-COMXDWNM.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
@@ -367,7 +367,7 @@ async function saveDocState(arg, { dispatch, getState }) {
   }
 }
 async function createDocState(args, thunkApi) {
-  const { createPageAction } = await import("./createPageAction-7YCAZPK3.js");
+  const { createPageAction } = await import("./createPageAction-GDQVH2DC.js");
   return createPageAction(args, thunkApi);
 }
 function subscribe(listener) {

package/{chunk-DAB7DRXD.js → chunk-BZMZUAFJ.js}

@@ -8,7 +8,7 @@ import {
   patch,
   remove,
   write
-} from "./chunk-V2AISYMA.js";
+} from "./chunk-COMXDWNM.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
@@ -289,7 +289,7 @@ var slice = createSliceWithThunks({
       const overrides = {};
       if (args.systemPromptOverride !== void 0) overrides.prompt = args.systemPromptOverride;
       if (args.toolsOverride !== void 0) overrides.tools = args.toolsOverride;
-      const { _executeModel } = await import("./_executeModel-EBU7YBDV.js");
+      const { _executeModel } = await import("./_executeModel-KUP2WVMT.js");
       return _executeModel(
         {
           isStreaming: args.isStreaming ?? false,
@@ -310,7 +310,7 @@ var slice = createSliceWithThunks({
      * - 循环直到无工具调用或触发其他运行时停止条件
      */
     runAgent: create.asyncThunk(async (args, thunkApi) => {
-      const { runAgentClientLoop } = await import("./runAgentClientLoop-UEQEP3XG.js");
+      const { runAgentClientLoop } = await import("./runAgentClientLoop-Y2LTIWEU.js");
       const { content: loopContent, toolCallCount } = await runAgentClientLoop(
         {
           agentKey: args.agentKey,
@@ -326,7 +326,7 @@ var slice = createSliceWithThunks({
      * 聊天轮次流式 Agent 调用
      */
     streamAgentChatTurn: create.asyncThunk(async (args, thunkApi) => {
-      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-REWDBIL3.js");
+      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-J4YW33EM.js");
       return streamAgentChatTurnHandler(args, thunkApi);
     }),
     /**

package/{chunk-V2AISYMA.js → chunk-COMXDWNM.js}

@@ -748,7 +748,7 @@ var dbSlice = createSliceWithThunks({
     // 这里改成动态 import，运行期才解析，彻底断开这条边。
     share: create.asyncThunk(
       async (config, thunkApi) => {
-        const { shareResourceAction } = await import("./action-SQGI5JY5.js");
+        const { shareResourceAction } = await import("./action-ZJWE3Y5S.js");
         return shareResourceAction(config, thunkApi);
       }
     ),

package/{chunk-YDESHYQC.js → chunk-E7LCFMW5.js}

@@ -16,7 +16,7 @@ import {
   createCliCallAgentToolExecutor,
   createCliLocalRuntimeAdapter,
   isBuiltinNoloAgentRef
-} from "./chunk-3N55DSXH.js";
+} from "./chunk-MTAJCUIC.js";
 import {
   getReadableCliDb
 } from "./chunk-W4NVOSFF.js";
@@ -33,24 +33,40 @@ import {
 } from "./chunk-VHBWHNVT.js";
 import {
   applyModelLayerOverride,
+  buildMemoryOverlayLayer,
+  buildMemoryUseGuidanceLayer,
   buildModelLayerOverride,
   buildSkillDiscoveryLayer
-} from "./chunk-CM54RSSA.js";
+} from "./chunk-SL35K7AH.js";
 import {
   CliProviderQuotaError
 } from "./chunk-X7W4TNB4.js";
+import {
+  resolveMachineId
+} from "./chunk-6HYVJV7B.js";
 import {
   isGatewayHttpStatus
 } from "./chunk-GAKEBQD6.js";
+import {
+  buildMemorySubjectsForAgent,
+  resolveAgentMemoryPolicy
+} from "./chunk-ZJDUYY3D.js";
 import {
   load,
   parseExternalSkillMarkdown,
   parseSkillDocProtocol
 } from "./chunk-ZQ2UM4KG.js";
+import {
+  touchMemoryItemsInDb
+} from "./chunk-3TZDXYSF.js";
+import {
+  chooseMemoryOwners,
+  loadMemoryCandidatesFromDb
+} from "./chunk-Q2YZULBH.js";
 import {
   getModelContextWindow,
   parseUiAskChoiceContent
-} from "./chunk-ZRS4MX3R.js";
+} from "./chunk-HBY2MXIN.js";
 import {
   readPipeText,
   spawnProcess
@@ -86,6 +102,9 @@ import {
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
+import {
+  getDefaultCliLocalRuntimeDb
+} from "./chunk-H33743XH.js";
 import {
   parsePositiveFiniteNumberOrFallback
 } from "./chunk-Y5GCAMGP.js";
@@ -3243,6 +3262,7 @@ async function runLocalAgentTurnForCli(options, settings) {
       noStream: options.noStream,
       ...runtimeContext ? { runtimeContext } : {},
       ...options.extraContextBlocks?.length ? { contextBlocks: options.extraContextBlocks } : {},
+      ...options.contextBlockScopes?.length ? { contextBlockScopes: options.contextBlockScopes } : {},
       ...typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {},
       ...options.actionGateHandler ? { onActionGate: options.actionGateHandler } : {},
       onLoopEvent: (event) => {
@@ -3870,6 +3890,327 @@ ${args.inspection.status.trim()}`] : [],
   ].join("\n");
 }
 
+// packages/ai/memory/overlay.ts
+var KIND_TITLES = {
+  episodic: "Episodic",
+  semantic: "Semantic",
+  procedural: "Procedural"
+};
+var normalizeDisplayContent = (item) => {
+  const normalized = item.content.trim().replace(/^(你要记住|请记住|以后记住|记住)[，,。.\s:：]*/u, "").replace(/[。！？!?]+$/u, "").trim();
+  const stripPrefix = (prefix) => normalized.startsWith(prefix) ? normalized.slice(prefix.length).trim() : normalized;
+  if (item.kind === "semantic") {
+    if (item.tags?.includes("understanding-memory")) {
+      switch (item.facet) {
+        case "unfinished":
+          return `\u7528\u6237\u4ECD\u672A\u5B9A\u4E0B\uFF1A${stripPrefix("\u8FD8\u6CA1\u51B3\u5B9A")}`;
+        case "tension":
+          return `\u7528\u6237\u5F53\u524D\u5728\u6743\u8861\uFF1A${stripPrefix("\u5728\u6743\u8861")}`;
+        case "preference":
+          return `\u7528\u6237\u5F53\u524D\u66F4\u5728\u610F\uFF1A${stripPrefix("\u66F4\u5728\u610F")}`;
+        case "style":
+          return `\u7528\u6237\u4E92\u52A8\u504F\u597D\uFF1A${stripPrefix("\u66F4\u559C\u6B22")}`;
+        case "goal":
+          return `\u7528\u6237\u5F53\u524D\u76EE\u6807\uFF1A${stripPrefix("\u60F3\u63A8\u8FDB")}`;
+      }
+    }
+    return `\u7528\u6237\u957F\u671F\u504F\u597D/\u4E8B\u5B9E\uFF1A${normalized}`;
+  }
+  if (item.kind === "episodic" && (item.patternKey === "explicit-remember" || item.patternKey === "agent-remember")) {
+    return `\u7528\u6237\u660E\u786E\u8981\u6C42\u4F60\u8BB0\u4F4F\uFF1A${normalized}`;
+  }
+  if (item.kind === "episodic" && item.tags?.includes("understanding-memory")) {
+    switch (item.facet) {
+      case "unfinished":
+        return `\u6700\u8FD1\u4E00\u6B21\u5BF9\u8BDD\u663E\u793A\uFF1A\u7528\u6237\u8FD8\u6CA1\u5B9A\u4E0B ${stripPrefix("\u8FD8\u6CA1\u51B3\u5B9A")}`;
+      case "tension":
+        return `\u6700\u8FD1\u4E00\u6B21\u5BF9\u8BDD\u663E\u793A\uFF1A\u7528\u6237\u8FD8\u5728\u6743\u8861 ${stripPrefix("\u5728\u6743\u8861")}`;
+      case "preference":
+        return `\u6700\u8FD1\u4E00\u6B21\u5BF9\u8BDD\u663E\u793A\uFF1A\u7528\u6237\u66F4\u5728\u610F ${stripPrefix("\u66F4\u5728\u610F")}`;
+      case "style":
+        return `\u6700\u8FD1\u4E00\u6B21\u5BF9\u8BDD\u663E\u793A\uFF1A\u7528\u6237\u66F4\u504F\u597D ${stripPrefix("\u66F4\u559C\u6B22")}`;
+      case "goal":
+        return `\u6700\u8FD1\u4E00\u6B21\u5BF9\u8BDD\u663E\u793A\uFF1A\u7528\u6237\u60F3\u63A8\u8FDB ${stripPrefix("\u60F3\u63A8\u8FDB")}`;
+    }
+  }
+  return normalized;
+};
+var buildMemoryOverlay = (items) => {
+  if (items.length === 0) return null;
+  const byKind = {
+    episodic: [],
+    semantic: [],
+    procedural: []
+  };
+  for (const item of items) {
+    byKind[item.kind].push(item);
+  }
+  const sections = Object.entries(byKind).filter(([, list]) => list.length > 0).map(([kind, list]) => {
+    const lines = list.slice(0, 3).map((item) => `- ${normalizeDisplayContent(item)}`);
+    return [`[${KIND_TITLES[kind]}]`, ...lines].join("\n");
+  });
+  return [
+    "--- Memory Overlay ---",
+    "\u4EE5\u4E0B\u662F\u5F53\u524D\u8BF7\u6C42\u53EF\u7528\u7684\u8BB0\u5FC6\u4E8B\u5B9E\uFF1B\u76F8\u5173\u65F6\u76F4\u63A5\u57FA\u4E8E\u8FD9\u4E9B\u8BB0\u5FC6\u56DE\u7B54\u3002",
+    "\u7528\u6237\u5F53\u524D\u8F93\u5165\u4F18\u5148\u4E8E\u8BB0\u5FC6\uFF1B\u8BB0\u5FC6\u53EA\u8F85\u52A9\u7406\u89E3\uFF0C\u4E0D\u8981\u6C42\u8FCE\u5408\u3002",
+    "",
+    ...sections
+  ].join("\n");
+};
+
+// packages/ai/memory/rank.ts
+var CJK_SEQUENCE_REGEX = /[\u3400-\u4dbf\u4e00-\u9fff]+/g;
+var MEMORY_IDENTIFIER_REGEX = /\b(?:memory|noise)-[a-z0-9][a-z0-9-]*/gi;
+var buildCjkTokens = (text) => {
+  const sequences = text.match(CJK_SEQUENCE_REGEX) ?? [];
+  const tokens = [];
+  for (const sequence of sequences) {
+    if (sequence.length >= 2) {
+      tokens.push(sequence);
+    }
+    for (let index = 0; index < sequence.length - 1; index += 1) {
+      tokens.push(sequence.slice(index, index + 2));
+    }
+  }
+  return tokens;
+};
+var tokenize = (text) => {
+  const normalized = text.toLowerCase();
+  const wordTokens = normalized.split(/[\s,.;:!?()[\]{}"'`，。！？：；、]+/).map((token) => token.trim()).filter((token) => token.length >= 2);
+  return [...wordTokens, ...buildCjkTokens(normalized)];
+};
+var keywordScore = (query, item) => {
+  const queryTokens = new Set(tokenize(query));
+  if (queryTokens.size === 0) return 0;
+  const haystack = /* @__PURE__ */ new Set([
+    ...tokenize(item.content),
+    ...(item.tags ?? []).map((tag) => tag.toLowerCase()),
+    item.patternKey?.toLowerCase() ?? ""
+  ]);
+  let matches = 0;
+  for (const token of queryTokens) {
+    if (haystack.has(token)) matches += 1;
+  }
+  return Math.min(1, matches / Math.max(2, queryTokens.size));
+};
+var identifierScore = (query, item) => {
+  const identifiers = query.match(MEMORY_IDENTIFIER_REGEX) ?? [];
+  if (identifiers.length === 0) return 0;
+  const content = item.content.toLowerCase();
+  const matches = identifiers.filter(
+    (identifier) => content.includes(identifier.toLowerCase())
+  ).length;
+  return matches / identifiers.length;
+};
+var activationScore = (item, nowMs) => {
+  const lastActivatedMs = Date.parse(item.lastActivatedAt || item.createdAt);
+  const ageDays = Math.max(0, (nowMs - lastActivatedMs) / 864e5);
+  const recency = 1 / (1 + ageDays / 7);
+  const reinforcement = Math.min(1, Math.log1p(item.activationCount ?? 0) / 3);
+  return 0.7 * recency + 0.3 * reinforcement;
+};
+var creationRecencyScore = (item, nowMs) => {
+  const createdMs = Date.parse(item.createdAt);
+  const ageDays = Math.max(0, (nowMs - createdMs) / 864e5);
+  return 1 / (1 + ageDays / 7);
+};
+var typeFitScore = (item) => {
+  if (item.kind === "episodic") return 0.75;
+  if (item.kind === "semantic") return 0.9;
+  return 0.85;
+};
+var understandingScore = (item) => {
+  if (!item.tags?.includes("understanding-memory")) return 0;
+  if (item.facet === "unfinished") return 1;
+  if (item.facet === "tension") return 0.95;
+  if (item.facet === "preference") return 0.85;
+  if (item.facet === "style") return 0.75;
+  return 0.8;
+};
+var pathScore = (item, context) => {
+  let score = 0;
+  if (context?.currentOwner && item.ownerType === context.currentOwner.ownerType && item.ownerId === context.currentOwner.ownerId) {
+    score += 0.65;
+  }
+  if (context?.currentSubject && item.subjectType === context.currentSubject.subjectType && item.subjectId === context.currentSubject.subjectId) {
+    score += 0.85;
+  }
+  return Math.min(1, score);
+};
+var scoreMemoryItem = (item, query, nowMs = Date.now(), context) => {
+  const queryMatch = keywordScore(query, item);
+  const identifierMatch = identifierScore(query, item);
+  const activation = activationScore(item, nowMs);
+  const createdRecency = creationRecencyScore(item, nowMs);
+  const importance = item.importance ?? 0;
+  const confidence = item.confidence ?? 0;
+  const typeFit = typeFitScore(item);
+  const understanding = understandingScore(item);
+  const path = pathScore(item, context);
+  return 0.25 * queryMatch + 0.2 * identifierMatch + 0.2 * path + 0.09 * activation + 0.16 * createdRecency + 0.06 * importance + 0.03 * confidence + 0.02 * typeFit + 0.01 * understanding;
+};
+var rankMemoryCandidates = (items, query, context) => {
+  const nowMs = Date.now();
+  return [...items].sort((a, b) => {
+    const aExplicit = a.sourceKind === "explicit-user-directive";
+    const bExplicit = b.sourceKind === "explicit-user-directive";
+    if (aExplicit !== bExplicit) return bExplicit ? 1 : -1;
+    if (aExplicit) {
+      return Date.parse(b.createdAt) - Date.parse(a.createdAt);
+    }
+    return scoreMemoryItem(b, query, nowMs, context) - scoreMemoryItem(a, query, nowMs, context);
+  });
+};
+
+// packages/ai/memory/runtime.ts
+var COLD_STORAGE_CONFIDENCE = 0.3;
+var normalizeSelectedContent = (text) => text.trim().replace(/^(你要记住|请记住|以后记住|记住)[，,。.\s:：]*/u, "").replace(/[。！？!?]+$/u, "").trim();
+var STACK_TERMS = [
+  "typescript",
+  "javascript",
+  "python",
+  "rust",
+  "go",
+  "golang",
+  "java",
+  "kotlin",
+  "swift",
+  "ruby",
+  "php"
+];
+var stackAliases = {
+  golang: "go"
+};
+var normalizeStackTerm = (term) => stackAliases[term] ?? term;
+var stackTermsIn = (text) => {
+  const lower = text.toLowerCase();
+  const terms = /* @__PURE__ */ new Set();
+  for (const term of STACK_TERMS) {
+    const pattern = term.length <= 2 ? new RegExp(`\\b${term}\\b`, "i") : new RegExp(term, "i");
+    if (pattern.test(lower)) {
+      terms.add(normalizeStackTerm(term));
+    }
+  }
+  return terms;
+};
+var conflictsWithCurrentStack = (item, userInput) => {
+  const currentStacks = stackTermsIn(userInput);
+  if (currentStacks.size === 0) return false;
+  const memoryStacks = stackTermsIn(item.content);
+  if (memoryStacks.size === 0) return false;
+  for (const stack of memoryStacks) {
+    if (!currentStacks.has(stack)) return true;
+  }
+  return false;
+};
+var INTERACTION_PREFERENCE_TERMS = [
+  "\u56DE\u7B54\u504F\u597D",
+  "\u8F93\u51FA\u504F\u597D",
+  "\u56DE\u590D\u504F\u597D",
+  "\u56DE\u7B54\u7ED3\u6784",
+  "\u8F93\u51FA\u7ED3\u6784",
+  "\u56DE\u590D\u7ED3\u6784",
+  "\u5148\u7ED9\u7ED3\u8BBA",
+  "\u518D\u5217\u98CE\u9669",
+  "\u6700\u540E\u7ED9\u8BC1\u636E",
+  "\u8BED\u6C14",
+  "\u98CE\u683C",
+  "\u79F0\u547C",
+  "\u53EB\u6211"
+];
+var isInteractionPreferenceMemory = (item) => {
+  if (item.facet === "style") return true;
+  const content = normalizeSelectedContent(item.content);
+  return INTERACTION_PREFERENCE_TERMS.some((term) => content.includes(term));
+};
+var isOffCurrentPath = (item, context) => {
+  const currentOwner = context?.currentOwner;
+  const currentSubject = context?.currentSubject;
+  if (currentSubject && (item.subjectType === "project" || item.subjectType === "space") && item.subjectType === currentSubject.subjectType && item.subjectId !== currentSubject.subjectId) {
+    return true;
+  }
+  if (currentOwner?.ownerType === "space" && item.ownerType === "user" && (item.subjectType === "project" || item.subjectType === "space") && item.subjectId !== currentOwner.ownerId) {
+    return true;
+  }
+  return false;
+};
+var selectRuntimeMemoryItems = (items, context, userInput = "") => {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = items.filter((item) => {
+    if ((item.confidence ?? 0) < COLD_STORAGE_CONFIDENCE) return false;
+    if (isOffCurrentPath(item, context)) return false;
+    if (conflictsWithCurrentStack(item, userInput)) return false;
+    const key = `${item.kind}:${normalizeSelectedContent(item.content).toLowerCase()}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const selected = [];
+  const selectedIds = /* @__PURE__ */ new Set();
+  const add = (item) => {
+    if (!item || selectedIds.has(item.id) || selected.length >= 4) return;
+    selected.push(item);
+    selectedIds.add(item.id);
+  };
+  add(
+    unique.find(
+      (item) => context?.currentSubject && item.subjectType === context.currentSubject.subjectType && item.subjectId === context.currentSubject.subjectId
+    )
+  );
+  add(unique.find(isInteractionPreferenceMemory));
+  add(
+    unique.find(
+      (item) => context?.currentOwner && item.ownerType === context.currentOwner.ownerType && item.ownerId === context.currentOwner.ownerId
+    )
+  );
+  add(unique.find((item) => item.ownerType === "user"));
+  add(unique.find((item) => item.ownerType === "space"));
+  add(unique.find((item) => item.kind === "procedural"));
+  for (const item of unique) {
+    add(item);
+  }
+  return selected;
+};
+var resolveMemoryRuntime = async (input) => {
+  const owners = chooseMemoryOwners({
+    userId: input.userId,
+    spaceId: input.spaceId
+  });
+  if (owners.length === 0) {
+    return { selectedItems: [], promptBlock: null };
+  }
+  const policy = resolveAgentMemoryPolicy({ agentKey: input.agentKey });
+  const candidates = await loadMemoryCandidatesFromDb(input.db, {
+    owners,
+    subjects: buildMemorySubjectsForAgent({
+      userId: input.userId,
+      spaceId: input.spaceId,
+      agentKey: input.agentKey,
+      policy
+    }),
+    kinds: ["episodic", "semantic", "procedural"],
+    ownerLimit: 20,
+    ownerFallback: policy.ownerFallback
+  });
+  const rankContext = {
+    currentOwner: input.spaceId ? { ownerType: "space", ownerId: input.spaceId } : input.userId ? { ownerType: "user", ownerId: input.userId } : null,
+    currentSubject: input.spaceId ? { subjectType: "space", subjectId: input.spaceId } : input.userId ? { subjectType: "user", subjectId: input.userId } : null
+  };
+  const ranked = selectRuntimeMemoryItems(
+    rankMemoryCandidates(candidates, input.userInput, rankContext),
+    rankContext,
+    input.userInput
+  );
+  if (ranked.length === 0) {
+    return { selectedItems: [], promptBlock: null };
+  }
+  await touchMemoryItemsInDb(input.db, ranked);
+  return {
+    selectedItems: ranked,
+    promptBlock: buildMemoryOverlay(ranked)
+  };
+};
+
 // packages/cli/agentRunCommand.ts
 function resolvePositiveMs(value, fallback) {
   return parsePositiveFiniteNumberOrFallback(value, fallback);
@@ -4152,6 +4493,70 @@ ${mdContent}`);
   if (skillDiscoveryBlock) {
     extraContextBlocks.push(skillDiscoveryBlock);
   }
+  let memoryPromptBlock = null;
+  if (!deps.memoryRecallDisabled) {
+    const memoryServerUrl = resolveServerUrl(env);
+    const memoryAuthToken = resolveAuthToken(args, env);
+    const memoryAgentKey = effectiveAgentKey;
+    const memorySpaceId = parsed.spaceId ?? void 0;
+    try {
+      if (memoryAuthToken && memoryServerUrl) {
+        const memoryResponse = await fetch(`${memoryServerUrl}/api/memory/query`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${memoryAuthToken}`
+          },
+          body: JSON.stringify({
+            agentKey: memoryAgentKey,
+            userInput: effectiveMessage,
+            ...memorySpaceId ? { spaceId: memorySpaceId } : {}
+          }),
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (memoryResponse.ok) {
+          const memoryPayload = await memoryResponse.json().catch(() => null);
+          const block = typeof memoryPayload?.promptBlock === "string" ? memoryPayload.promptBlock.trim() : "";
+          memoryPromptBlock = block || null;
+        } else {
+          console.warn("[cli-memory] memory query returned non-ok status:", memoryResponse.status);
+        }
+      } else {
+        const localDb = await getDefaultCliLocalRuntimeDb({ env });
+        const machineId = resolveMachineId();
+        const resolution = await resolveMemoryRuntime({
+          db: localDb,
+          userId: machineId,
+          agentKey: memoryAgentKey,
+          userInput: effectiveMessage,
+          ...memorySpaceId ? { spaceId: memorySpaceId } : {}
+        });
+        memoryPromptBlock = resolution.promptBlock;
+      }
+    } catch (memoryError) {
+      console.warn("[cli-memory] memory recall failed, omitting memory layer:", memoryError);
+    }
+  }
+  const memoryOverlayLayer = buildMemoryOverlayLayer({ promptBlock: memoryPromptBlock });
+  const memoryUseGuidanceLayer = buildMemoryUseGuidanceLayer({ promptBlock: memoryPromptBlock });
+  const contextBlockScopes = [];
+  const agentsMdMarker = "--- \u9879\u76EE\u6307\u4EE4\uFF08";
+  for (const block of extraContextBlocks) {
+    if (block.startsWith(agentsMdMarker)) {
+      contextBlockScopes.push({ content: block, cacheScope: "session" });
+    }
+  }
+  if (memoryUseGuidanceLayer?.content?.trim()) {
+    contextBlockScopes.push({ content: memoryUseGuidanceLayer.content, cacheScope: "session" });
+  }
+  for (const block of extraContextBlocks) {
+    if (!block.startsWith(agentsMdMarker)) {
+      contextBlockScopes.push({ content: block, cacheScope: "turn" });
+    }
+  }
+  if (memoryOverlayLayer?.content?.trim()) {
+    contextBlockScopes.push({ content: memoryOverlayLayer.content, cacheScope: "turn" });
+  }
   const buildRunOptions = (targetAgentKey) => ({
     agentName: targetAgentKey,
     agentKey: targetAgentKey,
@@ -4192,7 +4597,8 @@ ${mdContent}`);
     traceTools: parsed.traceTools,
     ...parsed.eventsMode ? { eventsMode: parsed.eventsMode } : {},
     ...parsed.taskEvidence ? { taskEvidence: parsed.taskEvidence } : {},
-    ...extraContextBlocks.length > 0 ? { extraContextBlocks } : {}
+    ...extraContextBlocks.length > 0 ? { extraContextBlocks } : {},
+    ...contextBlockScopes.length > 0 ? { contextBlockScopes } : {}
   });
   let result = await raceWithWatchdog(
     runner({