nolo-cli 0.8.0-alpha.7 → 0.9.0

package/{chunk-A3X4Y7MO.js → chunk-KOCA5FCS.js}

@@ -1,3 +1,8 @@
+import {
+  createRunActivityTracker,
+  finalizeRunRecord,
+  spawnLocalBackgroundRun
+} from "./chunk-2FTTDCD4.js";
 import {
   buildLocalRunEnv,
   isFullstackCodingAgentRef,
@@ -7,50 +12,61 @@ import {
   resolveServerUrl,
   writeUsage
 } from "./chunk-DZ3XJVET.js";
+import {
+  createCliCallAgentToolExecutor,
+  createCliLocalRuntimeAdapter,
+  isBuiltinNoloAgentRef
+} from "./chunk-LARL2V6G.js";
 import {
   getReadableCliDb
 } from "./chunk-W4NVOSFF.js";
 import {
   readDbRecord,
   resolveAgentRecordFromHybridStore
-} from "./chunk-6PWWWMI7.js";
-import {
-  createCliCallAgentToolExecutor,
-  createCliLocalRuntimeAdapter,
-  isBuiltinNoloAgentRef
-} from "./chunk-V2F4OGYM.js";
+} from "./chunk-7OOXPE3N.js";
 import {
   normalizeAgentHandle
-} from "./chunk-364VYAX2.js";
+} from "./chunk-2PUGVR6E.js";
 import {
   NOLO_PROJECT_MANAGER_AGENT_KEY,
   isLocalCliAgentKey
 } 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 {
-  createRunActivityTracker,
-  finalizeRunRecord,
-  spawnLocalBackgroundRun
-} from "./chunk-2FTTDCD4.js";
+  resolveMachineId
+} from "./chunk-6HYVJV7B.js";
 import {
   isGatewayHttpStatus
 } from "./chunk-GAKEBQD6.js";
+import {
+  buildMemorySubjectsForAgent,
+  resolveAgentMemoryPolicy
+} from "./chunk-PG5PNA7Y.js";
 import {
   load,
   parseExternalSkillMarkdown,
   parseSkillDocProtocol
-} from "./chunk-NXZGF7F7.js";
+} from "./chunk-ZQ2UM4KG.js";
+import {
+  touchMemoryItemsInDb
+} from "./chunk-3TZDXYSF.js";
+import {
+  chooseMemoryOwners,
+  loadMemoryCandidatesFromDb
+} from "./chunk-Q2YZULBH.js";
 import {
   getModelContextWindow,
   parseUiAskChoiceContent
-} from "./chunk-KTI2WDDG.js";
+} from "./chunk-ZIG5LJ7X.js";
 import {
   readPipeText,
   spawnProcess
@@ -61,7 +77,7 @@ import {
 import {
   buildPlatformChatCompletionRequest,
   parsePlatformChatCompletionData
-} from "./chunk-5XH3NZ4T.js";
+} from "./chunk-5KLGBAAR.js";
 import {
   resolveAgentRuntimeConfigFromRecord
 } from "./chunk-TILFE6LV.js";
@@ -70,28 +86,31 @@ import {
   LOCAL_TURN_ABORTED_CODE,
   readActionGate,
   readCommandActionGatePayload
-} from "./chunk-NE3E3XJ2.js";
+} from "./chunk-XS466O7S.js";
 import {
   resolvePlatformChatCompletionsEndpoint
-} from "./chunk-XDVAYP26.js";
+} from "./chunk-JRKKFRAV.js";
 import {
   clipCompactText
 } from "./chunk-5MMAK75Q.js";
 import {
   findModelConfig
-} from "./chunk-572EKYLF.js";
+} from "./chunk-BBYVOSU2.js";
 import {
   compactWhitespace
 } from "./chunk-DWLEOOGR.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
+import {
+  getDefaultCliLocalRuntimeDb
+} from "./chunk-H33743XH.js";
 import {
   parsePositiveFiniteNumberOrFallback
 } from "./chunk-Y5GCAMGP.js";
 import {
   require_index_umd
-} from "./chunk-PN7AFLOK.js";
+} from "./chunk-SH2CFQOH.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
@@ -486,10 +505,35 @@ function themeText(text, token, colorEnabled = resolveCliColorEnabled(), env = p
   if (!colorEnabled) return text;
   return `${themeColorSequence(token, env)}${text}\x1B[39m`;
 }
+function renderDiffCodeBlock(code, env = process.env) {
+  const border = themeText("\u2502", "chrome", true, env);
+  const addedColor = themeColorSequence("success", env);
+  const deletedColor = themeColorSequence("danger", env);
+  const hunkColor = themeColorSequence("info", env);
+  const contextColor = themeColorSequence("chrome", env);
+  const reset = "\x1B[0m";
+  const lines = code.split("\n").map((line) => {
+    let color = contextColor;
+    if (line.startsWith("@@")) {
+      color = hunkColor;
+    } else if (line.startsWith("+") && !line.startsWith("+++")) {
+      color = addedColor;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      color = deletedColor;
+    }
+    return ` ${border}  ${color}${line}${reset}`;
+  });
+  return ` ${themeText("\u250C\u2500\u2500\u2500", "chrome", true, env)}
+${lines.join("\n")}
+ ${themeText("\u2514\u2500\u2500\u2500", "chrome", true, env)}`;
+}
 function highlightMarkdown(text, colorEnabled = resolveCliColorEnabled(), env = process.env) {
   if (!colorEnabled) return text;
   let result = text;
-  result = result.replace(/```[a-zA-Z-]*\n([\s\S]*?)\n```/g, (match, code) => {
+  result = result.replace(/```([a-zA-Z-]*)\n([\s\S]*?)\n```/g, (match, lang, code) => {
+    if (lang.toLowerCase() === "diff") {
+      return renderDiffCodeBlock(code, env);
+    }
     const infoColor = themeColorSequence("info", env);
     const reset2 = "\x1B[39m\x1B[22m";
     const border = themeText("\u2502", "chrome", true, env);
@@ -580,6 +624,8 @@ function normalizeCodeLang(raw) {
       return "sh";
     case "json":
       return "json";
+    case "diff":
+      return "diff";
     default:
       return "unknown";
   }
@@ -652,7 +698,8 @@ var KEYWORDS = {
     "echo",
     "cd"
   ]),
-  json: /* @__PURE__ */ new Set(["true", "false", "null"])
+  json: /* @__PURE__ */ new Set(["true", "false", "null"]),
+  diff: /* @__PURE__ */ new Set([])
 };
 function scanStringCommentRegions(line, lang) {
   const regions = [];
@@ -698,6 +745,22 @@ function highlightCodeLine(line, lang, brightness) {
   if (lang === "unknown") {
     return `${info}${line}${STYLE.reset}`;
   }
+  if (lang === "diff") {
+    const added = colorSeq("success", brightness);
+    const deleted = colorSeq("danger", brightness);
+    const hunk = colorSeq("info", brightness);
+    const context = colorSeq("chrome", brightness);
+    const reset2 = STYLE.reset;
+    let color = context;
+    if (line.startsWith("@@")) {
+      color = hunk;
+    } else if (line.startsWith("+") && !line.startsWith("+++")) {
+      color = added;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      color = deleted;
+    }
+    return `${color}${line}${reset2}`;
+  }
   const regions = scanStringCommentRegions(line, lang);
   const keywords = KEYWORDS[lang];
   const accent = colorSeq("accent", brightness);
@@ -2732,7 +2795,7 @@ function isKnownServerPlatformAgent(options) {
 // packages/cli/client/agentRun.ts
 var import_ulid = __toESM(require_index_umd(), 1);
 async function loadRunLocalAgentTurn() {
-  const { runLocalAgentTurn } = await import("./agentRuntimeLocal-JNQQC2WG.js");
+  const { runLocalAgentTurn } = await import("./agentRuntimeLocal-SKHJUWSS.js");
   return runLocalAgentTurn;
 }
 async function resolveCurrentMachineId(options) {
@@ -3130,7 +3193,7 @@ async function runLocalAgentTurnForCli(options, settings) {
   } : void 0;
   const currentDialogId = options.continueDialogId ?? (0, import_ulid.ulid)();
   const runChildTurn = async (input) => {
-    const { runLocalAgentTurn } = await import("./agentRuntimeLocal-JNQQC2WG.js");
+    const { runLocalAgentTurn } = await import("./agentRuntimeLocal-SKHJUWSS.js");
     return runLocalAgentTurn(input);
   };
   const createFreshChildBaseAdapter = () => {
@@ -3199,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) => {
@@ -3233,7 +3297,12 @@ async function runLocalAgentTurnForCli(options, settings) {
   } catch (error) {
     turnOutput.spinner.stop();
     if (error?.code === LOCAL_TURN_ABORTED_CODE || options.abortSignal?.aborted) {
-      return { exitCode: 0, streamInterrupted: true };
+      const stoppedDialogId = error?.dialogId;
+      return {
+        exitCode: 0,
+        streamInterrupted: true,
+        ...stoppedDialogId ? { dialogId: stoppedDialogId } : {}
+      };
     }
     if (settings.reportFailure) {
       options.output.write(
@@ -3260,7 +3329,8 @@ async function runAgentTurn(options) {
         return {
           exitCode: localResult.exitCode,
           ...localResult.dialogId ? { dialogId: localResult.dialogId } : {},
-          ...localResult.turnTokens ? { turnTokens: localResult.turnTokens } : {}
+          ...localResult.turnTokens ? { turnTokens: localResult.turnTokens } : {},
+          ...localResult.streamInterrupted ? { streamInterrupted: localResult.streamInterrupted } : {}
         };
       }
       if (isMissingLocalAgentConfigError(localResult.localError, options.agentKey)) {
@@ -3820,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);
@@ -4102,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,
@@ -4142,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({

package/{chunk-IYQV26RA.js → chunk-KTVVPRJS.js}

@@ -1,9 +1,9 @@
 import {
   selectCurrentServer
-} from "./chunk-VEJLAVTC.js";
+} from "./chunk-TSS3XJY4.js";
 import {
   patch
-} from "./chunk-G5H7RNFL.js";
+} from "./chunk-COMXDWNM.js";
 import {
   selectIdentityToken
 } from "./chunk-EYEEHCU4.js";