nolo-cli 0.1.41 → 0.1.43

package/ai/tools/prepareTools.ts

@@ -1,3 +1,4 @@
+import i18n from "../../app/i18n";
 import {
   toolRegistry,
   toolDefinitionsByName,
@@ -7,6 +8,167 @@ import {
 import { canonicalizeToolNames } from "./toolNameAliases";
 import { sanitizeToolForProvider } from "./toolSchemaCompatibility";
 
+function getTranslation(keys: string[], defaultVal: string): string {
+  for (const key of keys) {
+    if (i18n.exists(key)) {
+      return i18n.t(key);
+    }
+    const aiKey = key.startsWith("ai:") ? key : `ai:${key}`;
+    if (i18n.exists(aiKey)) {
+      return i18n.t(aiKey);
+    }
+  }
+  return defaultVal;
+}
+
+export function translateSchema(schema: any): any {
+  if (!schema || typeof schema !== "object") return schema;
+
+  const nextSchema = JSON.parse(JSON.stringify(schema));
+  const toolName = nextSchema.name;
+  if (!toolName) return nextSchema;
+
+  const walk = (node: any, path: string) => {
+    if (!node || typeof node !== "object") return;
+
+    if (typeof node.description === "string") {
+      const keysToTry = [
+        `${path}.description`,
+        `${path}.desc`,
+        path,
+        node.description,
+      ];
+      node.description = getTranslation(keysToTry, node.description);
+    }
+
+    if (node.parameters && typeof node.parameters === "object") {
+      walk(node.parameters, path);
+    }
+
+    if (node.properties && typeof node.properties === "object") {
+      for (const [key, child] of Object.entries(node.properties)) {
+        const nextPath = path.endsWith(".params") ? `${path}.${key}` : `${path}.params.${key}`;
+        walk(child, nextPath);
+      }
+    }
+
+    if (node.items && typeof node.items === "object") {
+      walk(node.items, path);
+    }
+
+    const compositions = ["anyOf", "oneOf", "allOf"] as const;
+    for (const comp of compositions) {
+      if (Array.isArray(node[comp])) {
+        node[comp].forEach((child: any, idx: number) => {
+          const suffix = child.type === "string" ? "stringDesc" : child.type === "object" ? "objectDesc" : `${idx}`;
+          walk(child, `${path}.${suffix}`);
+        });
+      }
+    }
+  };
+
+  walk(nextSchema, `tools.${toolName}`);
+  return nextSchema;
+}
+
+function buildActivitySchema() {
+  const refs = {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        type: { type: "string", enum: ["file", "terminal", "url"] },
+        path: { type: "string" },
+        id: { type: "string" },
+        label: { type: "string" },
+        url: { type: "string" },
+      },
+    },
+  };
+  const action = {
+    type: "object",
+    properties: {
+      title: { type: "string" },
+      kind: {
+        type: "string",
+        enum: ["read", "write", "edit", "search", "terminal", "version", "test", "build", "preview", "other"],
+      },
+      detail: { type: "string" },
+      refs,
+    },
+    required: ["title"],
+  };
+  const planPhase = {
+    type: "object",
+    properties: {
+      id: { type: "string" },
+      title: { type: "string" },
+      index: { type: "number" },
+      status: { type: "string", enum: ["pending", "running", "success", "failed"] },
+    },
+    required: ["id", "title"],
+  };
+  return {
+    type: "object",
+    description:
+      "Optional human-readable activity metadata for UI progress display only. Use plan for the visible task skeleton, phase for the current task step, and action for this specific tool call.",
+    properties: {
+      plan: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          phases: {
+            type: "array",
+            items: planPhase,
+          },
+        },
+        required: ["phases"],
+      },
+      phase: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          title: { type: "string" },
+          index: { type: "number" },
+          total: { type: "number" },
+          status: { type: "string", enum: ["pending", "running", "success", "failed"] },
+        },
+        required: ["id", "title"],
+      },
+      action,
+      title: { type: "string" },
+      kind: action.properties.kind,
+      detail: { type: "string" },
+      refs,
+    },
+  };
+}
+
+function addActivityMetadataToToolSchema(tool: any) {
+  if (!tool?.function?.parameters || typeof tool.function.parameters !== "object") {
+    return tool;
+  }
+  const parameters = tool.function.parameters;
+  if (parameters.type !== "object" || !parameters.properties || typeof parameters.properties !== "object") {
+    return tool;
+  }
+  if (parameters.properties._activity) return tool;
+
+  return {
+    ...tool,
+    function: {
+      ...tool.function,
+      parameters: {
+        ...parameters,
+        properties: {
+          ...parameters.properties,
+          _activity: buildActivitySchema(),
+        },
+      },
+    },
+  };
+}
+
 export const prepareTools = (
   toolNames: string[],
   options?: { provider?: string; disabledToolNames?: string[] }
@@ -17,7 +179,15 @@ export const prepareTools = (
   );
   return canonicalizeToolNames(toolNames)
     .filter((toolName) => !disabledToolNames.has(toolName))
-    .map((toolName: string) => toolRegistry[toolName])
+    .map((toolName: string) => {
+      const regTool = toolRegistry[toolName];
+      if (!regTool) return regTool;
+      return {
+        ...regTool,
+        function: translateSchema(regTool.function),
+      };
+    })
+    .map(addActivityMetadataToToolSchema)
     .map((tool) => sanitizeToolForProvider(tool, options?.provider))
     .filter(Boolean); // 过滤掉未找到的工具
 };

package/ai/tools/readXhsProfileTool.ts

@@ -2,13 +2,14 @@
  * read_xhs_profile Tool
  *
  * Read-only tool for collecting XHS (Xiaohongshu) profile data:
- * profile info, public notes, note details, and top-level comments.
+ * anonymous public profile info and public notes visible without login.
  *
- * Desktop-first: uses Playwright persistent context for login state reuse.
+ * Anonymous-only: does not use XHS login state, cookies, or persistent profile.
  * No write actions (no like/comment/follow/collect/post/delete).
  * Cookies and xsecToken are never exposed in output.
  * Conservative by default: reads the initially loaded profile state only.
- * Extra scrolling, detail enrichment, and comments require explicit user intent.
+ * Extra scrolling requires explicit user intent. Direct detail/comment API
+ * enrichment is disabled so reads stay close to visible desktop browsing.
  * The tool clamps extended collection unless extendedCollectionConsent is true.
  */
 
@@ -17,21 +18,23 @@ import type {
   XhsReadResult,
   XhsProfileCollection,
   XhsCollectionStatus,
+  XhsParsedProfileUrl,
 } from "../../integrations/xhs-reader/types";
+import { redactXhsSensitiveValue } from "../../integrations/xhs-reader/redaction";
 import { parseXhsProfileUrl } from "../../integrations/xhs-reader/url";
 import { getRequestConfig, ToolApiError } from "./toolApiClient";
 
 export const readXhsProfileFunctionSchema = {
   name: "read_xhs_profile",
   description:
-    "读取小红书用户主页的公开信息。默认只读取页面初始加载出的资料和笔记列表，不自动翻页、不默认抓评论或批量详情。只有当用户明确要求更多笔记、评论或互动明细时，才应显式设置对应参数。默认通过桌面本地 Playwright 持久 profile 读取，不要求用户粘贴 cookie。",
+    "以未登录匿名访客身份读取小红书用户主页的公开可见信息。默认只读取页面初始加载出的资料和笔记列表，不自动翻页，不抓评论或批量详情。只有当用户明确要求更多笔记/翻页时，才可显式请求一次可见页面滚动。不会使用账号、cookie 或持久浏览器 profile。",
   parameters: {
     type: "object",
     properties: {
       url: {
         type: "string",
         description:
-          "小红书用户主页 URL，例如 https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556。",
+          "小红书用户主页 URL，例如 https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556。用户从首页/feed 复制的 profile 链接可以带 xsec_token/xsec_source；token 只用于匿名桌面导航，输出会脱敏。",
       },
       maxScrollPages: {
         type: "number",
@@ -42,29 +45,29 @@ export const readXhsProfileFunctionSchema = {
       includeComments: {
         type: "boolean",
         description:
-          "是否收集笔记的顶层评论。默认 false；只有用户明确要求评论且 extendedCollectionConsent=true 时才设为 true。",
+          "是否读取匿名公开笔记详情页首屏可见评论。只有 extendedCollectionConsent=true、collectionMode=\"assisted\"、assistedAction=\"read_visible_details\" 时才会生效；不会通过直接 API 收集评论。",
         default: false,
       },
       maxCommentPagesPerNote: {
         type: "number",
         description:
-          "每篇笔记最多收集几页评论（仅当 includeComments=true 时生效）。默认 1。",
+          "保留兼容字段，当前固定为 1 且不会触发评论采集。",
         default: 1,
       },
       minLikesForDetail: {
         type: "number",
         description:
-          "仅收集点赞数 >= 此值的笔记详情（可选）。只有 extendedCollectionConsent=true 时生效。",
+          "已停用：不再通过直接 API 收集笔记详情。",
       },
       minCommentsForCollect: {
         type: "number",
         description:
-          "仅收集评论数 >= 此值的笔记的评论（可选，仅当 includeComments=true 且 extendedCollectionConsent=true 时生效）。",
+          "已停用：不再通过直接 API 收集评论。",
       },
       extendedCollectionConsent: {
         type: "boolean",
         description:
-          "扩展采集确认开关。只有用户在本轮明确要求更多笔记、翻页、评论或互动明细时才可设为 true；否则必须省略或为 false。",
+          "扩展采集确认开关。只有用户在本轮明确要求更多笔记、翻页、公开笔记详情或首屏评论时才可设为 true；否则必须省略或为 false。匿名模式不会采集登录后内容。",
         default: false,
       },
       collectionMode: {
@@ -76,34 +79,29 @@ export const readXhsProfileFunctionSchema = {
       },
       assistedAction: {
         type: "string",
-        enum: ["snapshot", "read_more_notes", "read_comments"],
+        enum: ["snapshot", "read_more_notes", "read_visible_details", "discover_indexed_notes"],
         description:
-          "assisted 模式下的具体动作：snapshot 只读快照，read_more_notes 翻页读更多笔记，read_comments 读评论。",
+          "assisted 模式下的具体动作：snapshot 只读快照，read_more_notes 最多做一次可见页面滚动，read_visible_details 匿名打开最多 3 条公开笔记页读取页面可见详情和首屏评论，discover_indexed_notes 读取外部搜索索引发现的公开笔记 URL。",
         default: "snapshot",
       },
+      indexedNoteUrls: {
+        type: "array",
+        items: { type: "string" },
+        description:
+          "外部搜索索引发现的公开小红书笔记 URL（xiaohongshu.com/explore/...）。仅当 assistedAction=\"discover_indexed_notes\" 且 extendedCollectionConsent=true 时生效，最多读取 3 条；不要填搜索页 URL。",
+      },
       maxAssistedSteps: {
         type: "number",
         description:
-          "assisted 模式最大步数（1..3）。默认 1，用于约束滚动页数或评论翻页数。",
+          "assisted 模式最大步数。当前固定为 1，只允许一次可见页面滚动。",
         default: 1,
         minimum: 1,
-        maximum: 3,
-      },
-      profileDir: {
-        type: "string",
-        description:
-          "桌面端本地 Playwright 持久 profile 目录，用于复用小红书登录态。不要传入用户日常 Chrome profile。默认使用专用缓存目录。",
+        maximum: 1,
       },
       headless: {
         type: "boolean",
         description:
-          "是否用 headless 模式启动浏览器。首次登录小红书时需设为 false 并配合 keepOpen。",
-        default: true,
-      },
-      keepOpen: {
-        type: "boolean",
-        description:
-          "调试时是否保持浏览器上下文打开（方便手动登录）。默认 false。",
+          "是否用 headless 模式启动匿名浏览器。默认 false，优先打开可见桌面浏览器。",
         default: false,
       },
     },
@@ -125,12 +123,11 @@ export interface ReadXhsProfileArgs {
   minLikesForDetail?: number;
   minCommentsForCollect?: number;
   extendedCollectionConsent?: boolean;
-  profileDir?: string;
   headless?: boolean;
-  keepOpen?: boolean;
   collectionMode?: "conservative" | "assisted";
-  assistedAction?: "snapshot" | "read_more_notes" | "read_comments";
+  assistedAction?: "snapshot" | "read_more_notes" | "read_visible_details" | "discover_indexed_notes";
   maxAssistedSteps?: number;
+  indexedNoteUrls?: string[];
 }
 
 export function normalizeXhsProfileReadArgs(
@@ -157,7 +154,7 @@ export function normalizeXhsProfileReadArgs(
   // Consent granted → determine mode
   const mode = args.collectionMode === "assisted" ? "assisted" : "conservative";
   const action = args.assistedAction ?? "snapshot";
-  const steps = clamp(args.maxAssistedSteps ?? 1, 1, 3);
+  const steps = 1;
 
   if (mode === "conservative") {
     // Consent alone is not enough for extended collection. The model must
@@ -184,10 +181,14 @@ export function normalizeXhsProfileReadArgs(
   if (action === "read_more_notes") {
     maxScrollPages = clamp(maxScrollPages ?? steps, 1, steps);
     includeComments = false;
-  } else if (action === "read_comments") {
+  } else if (action === "read_visible_details") {
+    maxScrollPages = 0;
     includeComments = true;
-    maxCommentPagesPerNote = clamp(maxCommentPagesPerNote ?? steps, 1, steps);
+    maxCommentPagesPerNote = 3;
+  } else if (action === "discover_indexed_notes") {
     maxScrollPages = 0;
+    includeComments = true;
+    maxCommentPagesPerNote = 3;
   } else {
     // snapshot: no scrolling, no comments
     maxScrollPages = 0;
@@ -200,12 +201,15 @@ export function normalizeXhsProfileReadArgs(
     maxScrollPages,
     includeComments,
     maxCommentPagesPerNote,
-    minLikesForDetail: args.minLikesForDetail,
-    minCommentsForCollect: args.minCommentsForCollect,
+    minLikesForDetail: undefined,
+    minCommentsForCollect: undefined,
     extendedCollectionConsent: true,
     collectionMode: mode,
     assistedAction: action,
     maxAssistedSteps: steps,
+    indexedNoteUrls: action === "discover_indexed_notes"
+      ? (args.indexedNoteUrls ?? []).slice(0, 3)
+      : undefined,
   };
 }
 
@@ -213,10 +217,10 @@ function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
 
-function assertXhsProfileUrl(url: string) {
+function assertXhsProfileUrl(url: string): XhsParsedProfileUrl {
   // Reuse parseXhsProfileUrl for validation
   try {
-    parseXhsProfileUrl(url);
+    return parseXhsProfileUrl(url);
   } catch {
     throw new Error(
       "read_xhs_profile 需要一个有效的小红书用户主页 URL（xiaohongshu.com/user/profile/<24位hexID>）。",
@@ -370,15 +374,15 @@ function formatDisplay(result: XhsReadResult<XhsProfileCollection>) {
     const hints: string[] = [];
     if (result.code === "login_required") {
       hints.push(
-        "需要先登录小红书。请在桌面端用 headless=false + keepOpen=true 运行一次，手动完成登录后再次调用即可。",
+        "匿名公开访问遇到登录墙：当前用户主页对未登录访客不可见，read_xhs_profile 不会请求登录或复用账号。",
       );
     } else if (result.code === "blocked") {
       hints.push(
-        "页面被验证码或安全检查拦截。请稍后重试或在桌面端手动处理验证后重试。",
+        "匿名公开访问被安全检查拦截。请稍后重试，或接受匿名模式下无法读取该页面。",
       );
     } else if (result.code === "empty_profile_state") {
       hints.push(
-        "页面加载但未获取到笔记数据。建议：确认该用户有公开笔记；用本地持久 profile 重试；增加 timeoutMs。",
+        "页面加载但未获取到笔记数据。建议：确认该用户有公开笔记；如果页面需要登录，匿名模式会停止而不是切换账号。",
       );
     }
     return [
@@ -387,8 +391,8 @@ function formatDisplay(result: XhsReadResult<XhsProfileCollection>) {
       "",
       "可能的解决步骤：",
       "- 确认 URL 是有效的小红书用户主页链接",
-      "- 如果是登录问题，请用 headless=false + keepOpen=true 手动登录一次",
-      "- 如果是服务端(headless)环境，确保有有效的已登录 profile 目录",
+      "- 如果页面只对登录用户可见，接受匿名模式无法读取该内容",
+      "- 如果是临时网络或页面加载问题，可以稍后重试或增加 timeoutMs",
       "- 检查 Playwright chromium 是否已安装",
       ...hints,
     ]
@@ -424,6 +428,11 @@ function formatDisplay(result: XhsReadResult<XhsProfileCollection>) {
   if (noteDetails.length > 0) {
     parts.push(`已获取详情: ${noteDetails.length} 篇`);
   }
+  if (result.data.indexedDiscovery) {
+    parts.push(
+      `外部索引公开笔记: ${result.data.indexedDiscovery.verifiedNoteUrls.length}/${result.data.indexedDiscovery.acceptedNoteUrls.length} 已校验（${result.data.indexedDiscovery.requestedNoteUrls.length} 个候选）`,
+    );
+  }
 
   // Top notes
   if (analysis.highestLikedNote) {
@@ -477,7 +486,8 @@ function formatDisplay(result: XhsReadResult<XhsProfileCollection>) {
     const actionLabels: Record<string, string> = {
       snapshot: "快照",
       read_more_notes: "读取更多笔记",
-      read_comments: "读取评论",
+      read_visible_details: "读取公开详情与首屏评论",
+      discover_indexed_notes: "读取外部索引公开笔记",
     };
     parts.push(`采集模式: ${modeLabel}`);
     parts.push(`采集动作: ${actionLabels[cs.action] ?? cs.action}`);
@@ -505,27 +515,27 @@ export async function readXhsProfileFunc(
   displayData: string;
 }> {
   const url = String(args?.url ?? "").trim();
-  assertXhsProfileUrl(url);
+  const parsedUrl = assertXhsProfileUrl(url);
 
   const readerArgs: ReadXhsProfileArgs = normalizeXhsProfileReadArgs({
-    url,
+    url: parsedUrl.navigationUrl,
     maxScrollPages: args.maxScrollPages,
     includeComments: args.includeComments,
     maxCommentPagesPerNote: args.maxCommentPagesPerNote,
     minLikesForDetail: args.minLikesForDetail,
     minCommentsForCollect: args.minCommentsForCollect,
     extendedCollectionConsent: args.extendedCollectionConsent,
-    profileDir: args.profileDir?.trim() || undefined,
     headless: args.headless,
-    keepOpen: args.keepOpen,
     collectionMode: args.collectionMode,
     assistedAction: args.assistedAction,
     maxAssistedSteps: args.maxAssistedSteps,
+    indexedNoteUrls: args.indexedNoteUrls,
   });
 
-  const rawData =
+  const rawDataUnredacted =
     (await context.reader?.(readerArgs)) ??
     (await readWithDefaultBridge(readerArgs, thunkApi));
+  const rawData = redactXhsSensitiveValue(rawDataUnredacted) as XhsReadResult<XhsProfileCollection>;
 
   // Build and attach collectionStatus
   if (rawData.ok) {
@@ -573,15 +583,28 @@ function computeNextSuggestedAction(
   args: ReadXhsProfileArgs,
   data: XhsProfileCollection,
 ): XhsCollectionStatus["nextSuggestedAction"] {
-  const { diagnostic, notes, analysis, commentsByNote } = data;
+  const { diagnostic, notes, analysis } = data;
   const action = args.assistedAction ?? "snapshot";
 
-  // Login wall or empty state → suggest manual login
+  if (
+    (diagnostic?.loginDetected ||
+      diagnostic?.code === "login_required" ||
+      (diagnostic?.code === "empty_profile_state" && notes.length === 0)) &&
+    action !== "discover_indexed_notes"
+  ) {
+    return {
+      action: "discover_indexed_notes",
+      label: "外部索引找公开笔记",
+      reason: "站内匿名搜索不可用；可用 Google 等外部索引查找公开 note URL 后再读取可见页面",
+    };
+  }
+
+  // Login wall or empty state after indexed discovery → stop; anonymous mode must not request login.
   if (diagnostic?.loginDetected || diagnostic?.code === "login_required") {
     return {
-      action: "manual_login",
-      label: "手动登录",
-      reason: "检测到登录提示，请先手动登录小红书",
+      action: "stop_anonymous_unavailable",
+      label: "匿名不可见",
+      reason: "检测到登录提示；匿名公开模式不会登录或复用账号",
     };
   }
 
@@ -594,28 +617,16 @@ function computeNextSuggestedAction(
     };
   }
 
-  // Notes with high comment counts but no comments collected
-  const hasHighCommentNotes = notes.some((n) => {
-    // Check noteDetails for comment counts
-    const detail = data.noteDetails.find((d) => d.noteId === n.noteId);
-    return detail && detail.metrics.commentCount > 5;
-  });
-  const hasComments = Object.keys(commentsByNote).length > 0;
-
-  if (
-    (action === "snapshot" || action === "read_more_notes") &&
-    hasHighCommentNotes &&
-    !hasComments
-  ) {
+  if (notes.length > 0 && action === "snapshot") {
     return {
-      action: "read_comments",
-      label: "读取评论",
-      reason: "部分笔记评论较多，可以读取评论内容",
+      action: "read_visible_details",
+      label: "读取公开详情与首屏评论",
+      reason: "当前已有公开笔记列表，可匿名打开公开笔记页读取页面可见详情",
     };
   }
 
   // Analysis exists and has data → suggest saving to table
-  if (analysis.totalNotes > 0 && (action === "read_comments" || action === "read_more_notes")) {
+  if (analysis.totalNotes > 0 && action === "read_more_notes") {
     return {
       action: "save_to_table",
       label: "保存到表格",

package/ai/tools/table/createTableTool.ts

@@ -24,6 +24,7 @@ interface ToolTableColumnInput {
 type CreateTableToolArgs = {
     spaceId?: string;
     title?: string;
+    purpose?: string;
     description?: string;
     tags?: string[];
     categoryId?: string;
@@ -83,6 +84,11 @@ export const createTableFunctionSchema = {
                 description:
                     "表的显示名称，可以使用中文，例如「任务清单」「客户管理」。",
             },
+            purpose: {
+                type: "string",
+                description:
+                    "可选：机器可读用途，用于之后在当前用户/Space 范围内查找这类表，例如 agent_eval_workbench。不要用它写自然语言说明。",
+            },
             description: {
                 type: "string",
                 description:
@@ -184,6 +190,10 @@ export async function createTableFunc(
         typeof args?.title === "string" && args.title.trim()
             ? args.title.trim()
             : undefined;
+    const purpose =
+        typeof args?.purpose === "string" && args.purpose.trim()
+            ? args.purpose.trim()
+            : undefined;
     const description =
         typeof args?.description === "string" && args.description.trim()
             ? args.description.trim()
@@ -254,6 +264,7 @@ export async function createTableFunc(
     const createArgs: any = {
         spaceId,
         title,
+        purpose,
         description,
         tags,
         categoryId,

package/ai/tools/toolPacks.ts

@@ -0,0 +1,19 @@
+/**
+ * 能力分级定义 (Capability Tiers)
+ */
+export const TOOL_PACKS = {
+  // L1 - 核心：交互 + 记忆读写 + 自我更新，所有 Agent 必有
+  CORE: ["ui_ask_choice", "rememberMemory", "read", "searchDialogMessages", "createDoc", "updateDoc", "search_workspace", "search_all_spaces", "updateSelf", "queryModelUsage", "createDialogGoal", "getDialogGoal", "completeDialogGoal", "createScheduledTask", "notifyUser"],
+  // L2 - 联网搜索：配置了 web-capable tools 的 Agent 默认加，纯 QA bot 不加
+  LIGHT_WEB: ["exa_search", "read_x_post", "read_xhs_profile"],
+  // L3 - 深度浏览器：全套复杂网页交互
+  FULL_BROWSER: [
+    "browser_openSession",
+    "browser_closeSession",
+    "browser_click",
+    "browser_typeText",
+    "browser_readContent",
+    "browser_selectOption",
+    "fetchWebpage",
+  ],
+} as const;

package/ai/types.ts

@@ -44,6 +44,9 @@ export interface Contexts {
   /** 用户偏好与自动化边界（tone / capture / read policy） */
   userPolicyContext?: string | null;
 
+  /** 长期记忆召回层，由服务端 memory API 基于当前用户、space、agent 和输入生成 */
+  memoryOverlay?: string | null;
+
   /** 对话增量摘要：已压缩的历史消息概要 */
   dialogSummary?: string | null;
 

package/app/favorite/deletedFavoriteProjection.ts

@@ -0,0 +1,31 @@
+import {
+  isAgentKey,
+  isFileKey,
+  isPageKey,
+  isTableMetaKey,
+} from "../../database/keys";
+
+type DeletedFavoriteProjectionRemoval = {
+  targetType: "agent" | "content";
+  id: string;
+};
+
+export const resolveDeletedFavoriteProjectionRemoval = (
+  contentKey: string
+): DeletedFavoriteProjectionRemoval | null => {
+  if (!contentKey) return null;
+
+  if (isAgentKey(contentKey)) {
+    return { targetType: "agent", id: contentKey };
+  }
+
+  if (
+    isPageKey(contentKey) ||
+    isTableMetaKey(contentKey) ||
+    isFileKey(contentKey)
+  ) {
+    return { targetType: "content", id: contentKey };
+  }
+
+  return null;
+};