nolo-cli 0.1.41 → 0.1.42

package/ai/memory/remember.ts

@@ -1,8 +1,15 @@
 import serverDb from "../../database/server/db";
+import { resolveScopedMemoryTargets, type MemoryScope } from "./scope";
 import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./store";
-import type { MemoryKind, MemoryOwnerType, MemorySubjectType, MemoryVisibility } from "./types";
-
-export type RememberMemoryScope = "auto" | "user" | "space";
+import type {
+  MemoryItem,
+  MemoryKind,
+  MemoryOwnerType,
+  MemorySubjectType,
+  MemoryVisibility,
+} from "./types";
+
+export type RememberMemoryScope = MemoryScope;
 
 export interface RememberMemoryInput {
   db?: any;
@@ -15,10 +22,11 @@ export interface RememberMemoryInput {
 }
 
 export interface RememberMemoryResult {
-  success: true;
-  content: string;
-  requestedScope: RememberMemoryScope;
-  resolvedScopes: Array<{
+  success: true;
+  content: string;
+  requestedScope: RememberMemoryScope;
+  savedItems: MemoryItem[];
+  resolvedScopes: Array<{
     ownerType: MemoryOwnerType;
     ownerId: string;
     subjectType: MemorySubjectType;
@@ -29,85 +37,6 @@ export interface RememberMemoryResult {
 
 const MEMORY_KINDS = new Set<MemoryKind>(["episodic", "semantic", "procedural"]);
 
-const buildRememberTargets = (input: {
-  userId?: string | null;
-  spaceId?: string | null;
-  scope: RememberMemoryScope;
-}): Array<{
-  ownerType: MemoryOwnerType;
-  ownerId: string;
-  visibility: MemoryVisibility;
-  subjectType: MemorySubjectType;
-  subjectId: string;
-}> => {
-  if (input.scope === "user") {
-    if (!input.userId) {
-      throw new Error("rememberMemory: user scope requires userId");
-    }
-    return [
-      {
-        ownerType: "user",
-        ownerId: input.userId,
-        visibility: "private",
-        subjectType: "user",
-        subjectId: input.userId,
-      },
-    ];
-  }
-
-  if (input.scope === "space") {
-    if (input.spaceId) {
-      return [
-        {
-          ownerType: "space",
-          ownerId: input.spaceId,
-          visibility: "shared",
-          subjectType: "space",
-          subjectId: input.spaceId,
-        },
-      ];
-    }
-    if (input.userId) {
-      return [
-        {
-          ownerType: "user",
-          ownerId: input.userId,
-          visibility: "private",
-          subjectType: "user",
-          subjectId: input.userId,
-        },
-      ];
-    }
-    throw new Error("rememberMemory: space scope requires spaceId");
-  }
-
-  if (input.userId) {
-    return [
-      {
-        ownerType: "user",
-        ownerId: input.userId,
-        visibility: "private",
-        subjectType: "user",
-        subjectId: input.userId,
-      },
-    ];
-  }
-
-  if (input.spaceId) {
-    return [
-      {
-        ownerType: "space",
-        ownerId: input.spaceId,
-        visibility: "shared",
-        subjectType: "space",
-        subjectId: input.spaceId,
-      },
-    ];
-  }
-
-  return [];
-};
-
 export const rememberMemory = async (
   input: RememberMemoryInput
 ): Promise<RememberMemoryResult> => {
@@ -116,21 +45,34 @@ export const rememberMemory = async (
     throw new Error("rememberMemory: content is required");
   }
 
-  const scope = input.scope ?? "auto";
-  const targets = buildRememberTargets({
-    userId: input.userId,
-    spaceId: input.spaceId,
-    scope,
-  });
-  if (targets.length === 0) {
-    throw new Error("rememberMemory: no valid owner scope found");
-  }
+  const scope = input.scope ?? "auto";
+  let targets: ReturnType<typeof resolveScopedMemoryTargets>;
+  try {
+    targets = resolveScopedMemoryTargets({
+      userId: input.userId,
+      spaceId: input.spaceId,
+      scope,
+      fallbackToUserForMissingSpace: true,
+    });
+  } catch (error) {
+    if (scope === "user") {
+      throw new Error("rememberMemory: user scope requires userId");
+    }
+    if (scope === "space") {
+      throw new Error("rememberMemory: space scope requires spaceId");
+    }
+    throw error;
+  }
+  if (targets.length === 0) {
+    throw new Error("rememberMemory: no valid owner scope found");
+  }
 
   const db = input.db ?? serverDb;
   const kind = input.kind ?? "episodic";
   if (!MEMORY_KINDS.has(kind)) {
     throw new Error("rememberMemory: kind must be episodic, semantic, or procedural");
   }
+  const savedItems: MemoryItem[] = [];
   for (const target of targets) {
     const item = createMemoryItem({
       ownerType: target.ownerType,
@@ -149,14 +91,16 @@ export const rememberMemory = async (
       patternKey: kind === "procedural" ? "procedural-runbook" : "agent-remember",
       sourceDialogId: input.dialogId ?? undefined,
     });
-    await writeMemoryItemWithIndexesToDb(db, item);
-  }
-
-  return {
-    success: true,
-    content,
-    requestedScope: scope,
-    resolvedScopes: targets.map((target) => ({
+    await writeMemoryItemWithIndexesToDb(db, item);
+    savedItems.push(item);
+  }
+
+  return {
+    success: true,
+    content,
+    requestedScope: scope,
+    savedItems,
+    resolvedScopes: targets.map((target) => ({
       ownerType: target.ownerType,
       ownerId: target.ownerId,
       subjectType: target.subjectType,
@@ -164,4 +108,4 @@ export const rememberMemory = async (
       visibility: target.visibility,
     })),
   };
-};
+};

package/ai/memory/scope.ts

@@ -0,0 +1,74 @@
+import type {
+  MemoryOwnerType,
+  MemorySubjectType,
+  MemoryVisibility,
+} from "./types";
+
+export type MemoryScope = "auto" | "user" | "space";
+
+export interface MemoryScopeTarget {
+  ownerType: MemoryOwnerType;
+  ownerId: string;
+  visibility: MemoryVisibility;
+  subjectType: MemorySubjectType;
+  subjectId: string;
+}
+
+export const buildUserMemoryTarget = (userId: string): MemoryScopeTarget => ({
+  ownerType: "user",
+  ownerId: userId,
+  visibility: "private",
+  subjectType: "user",
+  subjectId: userId,
+});
+
+export const buildSpaceMemoryTarget = (spaceId: string): MemoryScopeTarget => ({
+  ownerType: "space",
+  ownerId: spaceId,
+  visibility: "shared",
+  subjectType: "space",
+  subjectId: spaceId,
+});
+
+export const resolveUserOrSpaceMemoryTarget = (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+}): MemoryScopeTarget | null => {
+  if (input.userId) return buildUserMemoryTarget(input.userId);
+  if (input.spaceId) return buildSpaceMemoryTarget(input.spaceId);
+  return null;
+};
+
+export const resolveScopedMemoryTargets = (input: {
+  userId?: string | null;
+  spaceId?: string | null;
+  scope?: MemoryScope;
+  fallbackToUserForMissingSpace?: boolean;
+}): MemoryScopeTarget[] => {
+  const scope = input.scope ?? "auto";
+  if (scope === "user") {
+    if (!input.userId) throw new Error("memory scope requires userId");
+    return [buildUserMemoryTarget(input.userId)];
+  }
+
+  if (scope === "space") {
+    if (input.spaceId) return [buildSpaceMemoryTarget(input.spaceId)];
+    if (input.fallbackToUserForMissingSpace && input.userId) {
+      return [buildUserMemoryTarget(input.userId)];
+    }
+    throw new Error("memory space scope requires spaceId");
+  }
+
+  const target = resolveUserOrSpaceMemoryTarget(input);
+  return target ? [target] : [];
+};
+
+export const buildAgentSubjectTarget = (
+  target: Pick<MemoryScopeTarget, "ownerType" | "ownerId" | "visibility">,
+  agentKey: string
+) => ({
+  owner: { ownerType: target.ownerType, ownerId: target.ownerId },
+  visibility: target.visibility,
+  subjectType: "agent" as const,
+  subjectId: agentKey,
+});

package/ai/memory/types.ts

@@ -9,6 +9,11 @@ export type MemoryFacet =
   | "goal"
   | "style";
 
+export type MemorySourceKind =
+  | "explicit-user-directive"
+  | "agent-tool"
+  | "inferred-understanding";
+
 export interface MemoryItem {
   id: string;
   ownerType: MemoryOwnerType;
@@ -26,6 +31,7 @@ export interface MemoryItem {
   tags?: string[];
   facet?: MemoryFacet;
   patternKey?: string;
+  sourceKind?: MemorySourceKind;
   sourceDialogId?: string;
   sourceMessageId?: string;
 }

package/ai/memory/understanding.ts

@@ -1,6 +1,7 @@
 import type { ChatMessage } from "../../server/handlers/agentRun/types";
 import { createMemoryItem, writeMemoryItemWithIndexesToDb } from "./storeShared";
 import { loadMemoryCandidatesFromDb } from "./queryShared";
+import { buildAgentSubjectTarget, resolveUserOrSpaceMemoryTarget } from "./scope";
 import type {
   MemoryFacet,
   MemoryItem,
@@ -247,20 +248,11 @@ const buildUnderstandingTarget = (input: {
 }): {
   owner: MemoryOwnerRef;
   visibility: MemoryVisibility;
+  subjectType: "agent";
+  subjectId: string;
 } | null => {
-  if (input.userId) {
-    return {
-      owner: { ownerType: "user", ownerId: input.userId },
-      visibility: "private",
-    };
-  }
-  if (input.spaceId) {
-    return {
-      owner: { ownerType: "space", ownerId: input.spaceId },
-      visibility: "shared",
-    };
-  }
-  return null;
+  const target = resolveUserOrSpaceMemoryTarget(input);
+  return target ? buildAgentSubjectTarget(target, input.agentKey) : null;
 };
 
 const sameUnderstanding = (item: MemoryItem, candidate: UnderstandingMemoryCandidate, agentKey: string) =>
@@ -288,7 +280,7 @@ export const captureUnderstandingMemoryFromDialog = async (input: {
 
   const existing = await loadMemoryCandidatesFromDb(input.db, {
     owners: [target.owner],
-    subjects: [{ subjectType: "agent", subjectId: input.agentKey }],
+    subjects: [{ subjectType: target.subjectType, subjectId: target.subjectId }],
     kinds: ["episodic", "semantic"],
     ownerLimit: 100,
   });
@@ -308,8 +300,8 @@ export const captureUnderstandingMemoryFromDialog = async (input: {
         ownerType: target.owner.ownerType,
         ownerId: target.owner.ownerId,
         visibility: target.visibility,
-        subjectType: "agent",
-        subjectId: input.agentKey,
+        subjectType: target.subjectType,
+        subjectId: target.subjectId,
         kind: "semantic",
         content: candidate.content,
         facet: candidate.facet,
@@ -332,8 +324,8 @@ export const captureUnderstandingMemoryFromDialog = async (input: {
       ownerType: target.owner.ownerType,
       ownerId: target.owner.ownerId,
       visibility: target.visibility,
-      subjectType: "agent",
-      subjectId: input.agentKey,
+      subjectType: target.subjectType,
+      subjectId: target.subjectId,
       kind: "episodic",
       content: candidate.content,
       facet: candidate.facet,

package/ai/policy/runtimePolicy.ts

@@ -14,8 +14,8 @@ import {
   DEFAULT_USER_PREFERENCE_PROFILE,
 } from "./types";
 
-export type CaptureIntent = "none" | "possible" | "strong";
-export type SpaceNeed = "none" | "light" | "deep";
+export type CaptureIntent = "none" | "possible" | "strong";
+export type SpaceNeed = "none" | "light" | "deep";
 export type KnowledgeCaptureMode = "blocked" | "ask" | "suggest" | "auto";
 
 export interface ResolvedRuntimePolicy {
@@ -152,8 +152,31 @@ export const resolveUserPreferenceProfile = (
   };
 };
 
-const containsAny = (text: string, patterns: string[]): boolean =>
-  patterns.some((pattern) => text.includes(pattern));
+const containsAny = (text: string, patterns: string[]): boolean =>
+  patterns.some((pattern) => text.includes(pattern));
+
+const spaceNeedRank: Record<SpaceNeed, number> = {
+  none: 0,
+  light: 1,
+  deep: 2,
+};
+
+const maxSpaceNeed = (left: SpaceNeed, right: SpaceNeed): SpaceNeed =>
+  spaceNeedRank[left] >= spaceNeedRank[right] ? left : right;
+
+const normalizeReferenceText = (value: unknown): string => {
+  if (!value || typeof value !== "object") return "";
+  const record = value as Record<string, unknown>;
+  return [
+    record.title,
+    record.name,
+    record.type,
+    record.dbKey,
+    record.key,
+  ]
+    .filter((item): item is string => typeof item === "string")
+    .join("\n");
+};
 
 export const inferCaptureIntent = (userInput: string): CaptureIntent => {
   const normalized = userInput.toLowerCase();
@@ -177,12 +200,16 @@ export const inferCaptureIntent = (userInput: string): CaptureIntent => {
       "创建这个 skill",
       "skill 文档",
       "创建表格",
+      "createtable",
+      "addtablerow",
+      "addtablerows",
       "建表",
       "建个表",
       "做个表",
       "做一张表",
       "写表",
       "写入表",
+      "写入一行",
       "写入 table",
       "放到 table",
       "存到 table",
@@ -237,7 +264,7 @@ export const inferCaptureIntent = (userInput: string): CaptureIntent => {
   return "none";
 };
 
-export const inferSpaceNeed = (userInput: string): SpaceNeed => {
+export const inferSpaceNeed = (userInput: string): SpaceNeed => {
   const normalized = userInput.toLowerCase();
 
   if (
@@ -270,9 +297,52 @@ export const inferSpaceNeed = (userInput: string): SpaceNeed => {
   ) {
     return "light";
   }
-
-  return "none";
-};
+
+  return "none";
+};
+
+export const inferAgentSpaceNeed = (agentConfig?: Agent | any): SpaceNeed => {
+  const references = Array.isArray(agentConfig?.references)
+    ? agentConfig.references
+    : [];
+  if (!references.length) return "none";
+
+  const combined = [
+    agentConfig?.prompt,
+    agentConfig?.systemPrompt,
+    agentConfig?.instructions,
+    agentConfig?.introduction,
+    ...references.map(normalizeReferenceText),
+  ]
+    .filter((item): item is string => typeof item === "string")
+    .join("\n")
+    .toLowerCase();
+
+  if (
+    containsAny(combined, [
+      "readDoc",
+      "readdoc",
+      "读取总索引",
+      "读取对应 doc",
+      "先读取",
+      "课程资料",
+      "挂载资料",
+      "资料索引",
+      "知识库",
+      "总索引",
+      "docs index",
+      "doc index",
+      "knowledge",
+      "references",
+      "source docs",
+      "based on the docs",
+    ])
+  ) {
+    return "deep";
+  }
+
+  return "light";
+};
 
 const resolveTonePreset = (
   agentTone: TonePreset,
@@ -291,24 +361,24 @@ const resolveTonePreset = (
 
 const maxReadCallsPerTurnByLevel = (
   level: SpaceContextLevel,
-  need: SpaceNeed,
-): number => {
-  if (need === "deep") {
-    return { 1: 2, 2: 3, 3: 4, 4: 6 }[level];
-  }
+  need: SpaceNeed,
+): number => {
+  if (need === "deep") {
+    return { 1: 3, 2: 4, 3: 6, 4: 8 }[level];
+  }
   if (need === "light") {
     return { 1: 1, 2: 2, 3: 3, 4: 4 }[level];
   }
   return { 1: 0, 2: 0, 3: 1, 4: 2 }[level];
 };
 
-const maxReadCallsPerDialogByLevel = (
-  level: SpaceContextLevel,
-  need: SpaceNeed,
-): number => {
-  if (need === "deep") {
-    return { 1: 3, 2: 4, 3: 6, 4: 8 }[level];
-  }
+const maxReadCallsPerDialogByLevel = (
+  level: SpaceContextLevel,
+  need: SpaceNeed,
+): number => {
+  if (need === "deep") {
+    return { 1: 6, 2: 10, 3: 16, 4: 24 }[level];
+  }
   if (need === "light") {
     return { 1: 2, 2: 3, 3: 4, 4: 6 }[level];
   }
@@ -342,9 +412,11 @@ export const resolveRuntimePolicy = (params: {
   ) as SpaceContextLevel;
 
   const captureIntent = inferCaptureIntent(userInput);
-  const spaceNeed = inferSpaceNeed(userInput);
-  const explicitCaptureRequest = captureIntent === "strong";
-  const explicitSpaceRequest = spaceNeed !== "none";
+  const userSpaceNeed = inferSpaceNeed(userInput);
+  const agentSpaceNeed = inferAgentSpaceNeed(agentConfig);
+  const spaceNeed = maxSpaceNeed(userSpaceNeed, agentSpaceNeed);
+  const explicitCaptureRequest = captureIntent === "strong";
+  const explicitSpaceRequest = userSpaceNeed !== "none";
 
   const currentAutoCreates = Math.max(
     0,

package/ai/tools/agent/agentTools.ts

@@ -44,10 +44,6 @@ import {
     runLlmFunctionSchema,
     runLlmToolFunc,
 } from "./runLlmTool";
-import {
-    taskRunFunctionSchema,
-    taskRunFunc,
-} from "./taskRunTool";
 
 import type { ToolDefinition } from "../index";
 
@@ -215,21 +211,4 @@ export const agentToolDefinitions: ToolDefinition[] = [
         behavior: "action",
         uiGroup: "agent",
     },
-    {
-        id: "taskRun",
-        schema: taskRunFunctionSchema,
-        executor: taskRunFunc,
-        description: {
-            name: "taskRun",
-            description:
-                "读写任务卡里的轻量 task-run 上下文，让 PM、实现 agent、reviewer 共享工作项、交接物、阻塞和 review 状态。",
-            category: "计划与编排",
-        },
-        behavior: "action",
-        uiGroup: "agent",
-        capability: "general",
-        riskLevel: "medium",
-        costLevel: "low",
-        defaultConsent: "auto",
-    },
 ];

package/ai/tools/agent/startAgentDialogTool.ts

@@ -19,7 +19,8 @@ export const startAgentDialogFunctionSchema = {
       },
       subjectRefs: {
         type: "array",
-        description: "可选。与本次子 dialog 相关的业务对象引用，保持行业中立。",
+        description:
+          "可选。与本次子 dialog 相关的业务对象引用，保持行业中立。交接任务行时传 {kind:\"table-row\", id: rowDbKey, role:\"task\"}；服务端会继承父 dialog/runtimeContext 已有的 subjectRefs。",
         items: {
           type: "object",
           properties: {

package/ai/tools/index.ts

@@ -197,6 +197,8 @@ import {
   readXhsProfileFunctionSchema,
   readXhsProfileFunc,
 } from "./readXhsProfileTool";
+export { TOOL_PACKS } from "./toolPacks";
+import { TOOL_PACKS } from "./toolPacks";
 import {
   surfWeatherFunctionSchema,
   surfWeatherFunc,
@@ -506,26 +508,6 @@ export interface ToolDefinition {
   };
 }
 
-/**
- * 能力分级定义 (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 - 联网搜索：配置了 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",
-  ],
-};
-
 /* ==================================================================
  *  2.1 toolquery 工具：帮助模型发现可用工具
  * ================================================================== */