nolo-cli 0.1.19 → 0.1.20

package/client/localRuntimeDryRun.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { runLocalAgentTurn } from "../agent-runtime/localLoop";
+import { buildLocalWorkspaceToolset } from "../agent-runtime/localWorkspaceTools";
+import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
+
+describe("CLI local runtime dry run", () => {
+  test("lets a declared workspace file tool write a file and save the tool trace", async () => {
+    const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-local-runtime-dry-run-"));
+    try {
+      const records = new Map<string, any>([
+        ["agent-user-1-frontend", {
+          dbKey: "agent-user-1-frontend",
+          id: "frontend",
+          name: "Frontend Implementer",
+          prompt: "Use workspace file tools to edit files.",
+          model: "qwen-coder",
+          tools: [
+            { type: "function", function: { name: "writeWorkspaceFile" } },
+          ],
+        }],
+      ]);
+      const batchOps: any[] = [];
+      let completeCount = 0;
+      const adapter = createCliLocalRuntimeAdapter({
+        env: {
+          NOLO_LOCAL_USER_ID: "user-1",
+          NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        },
+        db: {
+          get: async (key) => {
+            if (!records.has(key)) throw new Error(`not found: ${key}`);
+            return records.get(key);
+          },
+          put: async (key, value) => {
+            records.set(key, value);
+          },
+          batch: async (ops) => {
+            batchOps.push(...ops);
+            for (const op of ops) {
+              if (op.type === "put") records.set(op.key, op.value);
+            }
+          },
+          iterator: () => (async function* () {})(),
+        },
+        cwd: workspaceRoot,
+        now: () => 1710000000000,
+        createId: () => "dialog-dry-run",
+        fetchImpl: async (_url, init) => {
+          const body = JSON.parse(String(init?.body));
+          completeCount += 1;
+          if (completeCount === 1) {
+            expect(body.tools.map((tool: any) => tool.function.name)).toEqual([
+              ...buildLocalWorkspaceToolset({}).toolNames,
+            ]);
+            return Response.json({
+              model: "qwen-coder",
+              choices: [{
+                message: {
+                  content: "",
+                  tool_calls: [{
+                    id: "call-1",
+                    type: "function",
+                    function: {
+                      name: "writeWorkspaceFile",
+                      arguments: JSON.stringify({
+                        path: "src/notification.css",
+                        content: ".notification { border-radius: 8px; }\n",
+                      }),
+                    },
+                  }],
+                },
+              }],
+            });
+          }
+          expect(body.messages.at(-1)).toMatchObject({
+            role: "tool",
+            content: "wrote src/notification.css",
+            tool_call_id: "call-1",
+          });
+          return Response.json({
+            model: "qwen-coder",
+            choices: [{ message: { content: "updated" } }],
+          });
+        },
+      });
+
+      const result = await runLocalAgentTurn({
+        adapter,
+        agentRef: "frontend",
+        input: "fix notification UI",
+      });
+
+      expect(result).toMatchObject({
+        dialogId: "dialog-dry-run",
+        content: "updated",
+        toolCallCount: 1,
+      });
+      expect(readFileSync(join(workspaceRoot, "src/notification.css"), "utf8")).toBe(
+        ".notification { border-radius: 8px; }\n"
+      );
+      expect(batchOps.map((op) => op.key)).toEqual([
+        "dialog-user-1-dialog-dry-run",
+        "dialog-dialog-dry-run-msg-1710000000000-001",
+        "dialog-dialog-dry-run-msg-1710000000000-002",
+        "dialog-dialog-dry-run-msg-1710000000000-003",
+        "dialog-dialog-dry-run-msg-1710000000000-004",
+      ]);
+    } finally {
+      rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+  });
+});

package/client/localToolPolicy.ts

@@ -1,81 +1,8 @@
-import type { AgentRuntimeToolCallInput, AgentRuntimeToolResult } from "../../agent-runtime";
-
-type EnvLike = Record<string, string | undefined>;
-
-export type LocalToolPolicyDecision =
-  | { allowed: true; toolName: string }
-  | { allowed: false; toolName: string; reason: string };
-
-const NEVER_LOCAL_TOOLS = new Set([
-  "deleteSpaces",
-  "updateAgent",
-  "updateSelf",
-  "createAgent",
-]);
-
-function parseCsv(value: string | undefined) {
-  return (value ?? "")
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean);
-}
-
-export function resolveLocalToolPolicy(args: {
-  env: EnvLike;
-  agentToolNames?: string[];
-  toolName: string;
-}): LocalToolPolicyDecision {
-  if (args.toolName === "execShell") {
-    const shellMode = args.env.NOLO_LOCAL_SHELL_MODE || "";
-    if (["worktree", "dangerous", "1", "true"].includes(shellMode)) {
-      return { allowed: true, toolName: args.toolName };
-    }
-    return {
-      allowed: false,
-      toolName: args.toolName,
-      reason: "execShell requires NOLO_LOCAL_SHELL_MODE=worktree.",
-    };
-  }
-
-  if (NEVER_LOCAL_TOOLS.has(args.toolName)) {
-    return {
-      allowed: false,
-      toolName: args.toolName,
-      reason: `${args.toolName} is blocked by the local CLI safety policy.`,
-    };
-  }
-
-  const allowedByEnv = new Set(parseCsv(args.env.NOLO_LOCAL_ALLOWED_TOOLS));
-  const agentTools = new Set(args.agentToolNames ?? []);
-  if (allowedByEnv.has(args.toolName) && agentTools.has(args.toolName)) {
-    return { allowed: true, toolName: args.toolName };
-  }
-
-  return {
-    allowed: false,
-    toolName: args.toolName,
-    reason:
-      `${args.toolName} is not enabled for local CLI runs. ` +
-      "Set NOLO_LOCAL_ALLOWED_TOOLS and make sure the agent declares the tool before using it locally.",
-  };
-}
-
-export async function executeLocalToolWithPolicy(args: {
-  env: EnvLike;
-  agentToolNames?: string[];
-  call: AgentRuntimeToolCallInput;
-  executors?: Record<string, (call: AgentRuntimeToolCallInput) => Promise<AgentRuntimeToolResult>>;
-}): Promise<AgentRuntimeToolResult> {
-  const decision = resolveLocalToolPolicy({
-    env: args.env,
-    agentToolNames: args.agentToolNames,
-    toolName: args.call.name,
-  });
-  if (!decision.allowed) throw new Error(decision.reason);
-
-  const executor = args.executors?.[args.call.name];
-  if (!executor) {
-    throw new Error(`${args.call.name} is allowed by policy but no local executor is registered.`);
-  }
-  return executor(args.call);
-}
+export {
+  executeLocalToolWithPolicy,
+  resolveLocalToolPolicy,
+} from "../agentRuntimeLocal";
+
+export type {
+  LocalToolPolicyDecision,
+} from "../agentRuntimeLocal";

package/client/taskRunPrompt.ts

@@ -0,0 +1,26 @@
+export type TaskRunPromptContext = {
+  rowDbKey: string;
+  taskRunId?: string;
+  workItemId?: string;
+  artifactIds?: string[];
+};
+
+export function prependTaskRunPrompt(message: string, context?: TaskRunPromptContext): string {
+  if (!context?.rowDbKey) return message;
+  const artifactIds = context.artifactIds?.filter(Boolean) ?? [];
+  return [
+    "AI-native task-run context:",
+    "- This system is AI-native. The current task board is only the present observation and validation use case; different users, companies, and workflows may use different task owners later.",
+    "- Treat the task row meta as the durable execution context. Do not infer branch, runner, handoff, review, or blocker state from chat history alone.",
+    `- rowDbKey: ${context.rowDbKey}`,
+    ...(context.taskRunId ? [`- taskRunId: ${context.taskRunId}`] : []),
+    ...(context.workItemId ? [`- workItemId: ${context.workItemId}`] : []),
+    ...(artifactIds.length ? [`- artifactIds: ${artifactIds.join(",")}`] : []),
+    "- When you create, update, hand off, block, or review work, update the task context with `bun run task:run -- ...`.",
+    "- If this turn already includes a server TaskRun preflight snapshot, use that snapshot directly for read-only reporting or planning.",
+    "- Keep long reasoning and logs in the dialog; record only resumable references in task row meta.",
+    "",
+    "User task:",
+    message,
+  ].join("\n");
+}

package/client/taskWorktree.ts

@@ -0,0 +1,8 @@
+export {
+  ensureWorkspacePackageLinks,
+  formatPreparedGitTaskWorkspace as formatPreparedTaskWorktree,
+  prepareGitTaskWorkspace as prepareTaskWorktree,
+} from "../agent-runtime/taskWorkspace";
+export type {
+  PreparedGitTaskWorkspace as PreparedTaskWorktree,
+} from "../agent-runtime/taskWorkspace";

package/client/workspaceSession.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  activateWorkspaceSession,
+  createWorkspaceSession,
+  formatWorkspaceSessionActivation,
+} from "./workspaceSession";
+
+describe("CLI workspace session", () => {
+  test("starts from an explicit workspace root without preparing a task worktree", async () => {
+    const session = createWorkspaceSession({ cwd: "/repo/current" });
+
+    const result = await activateWorkspaceSession(session, {
+      agentKey: "frontend",
+      mode: "task-worktree",
+      prepareTaskWorkspace: async () => {
+        throw new Error("should not prepare a task worktree for explicit cwd");
+      },
+    });
+
+    expect(result.workspaceRoot).toBe("/repo/current");
+    expect(result.kind).toBe("current");
+  });
+
+  test("activates a task worktree once when requested by agent policy", async () => {
+    const calls: string[] = [];
+    let session = createWorkspaceSession({ cwd: undefined });
+
+    session = await activateWorkspaceSession(session, {
+      agentKey: "agent-user-1-frontend",
+      mode: "task-worktree",
+      prepareTaskWorkspace: async ({ agentKey }) => {
+        calls.push(agentKey);
+        return {
+          path: "/repo/.worktrees/nolo-agent-frontend",
+          branchName: "nolo-agent-frontend",
+        };
+      },
+    });
+    session = await activateWorkspaceSession(session, {
+      agentKey: "agent-user-1-frontend",
+      mode: "task-worktree",
+      prepareTaskWorkspace: async () => {
+        throw new Error("task worktree should only be prepared once");
+      },
+    });
+
+    expect(calls).toEqual(["agent-user-1-frontend"]);
+    expect(session).toMatchObject({
+      kind: "task-worktree",
+      workspaceRoot: "/repo/.worktrees/nolo-agent-frontend",
+      branchName: "nolo-agent-frontend",
+    });
+    expect(formatWorkspaceSessionActivation(session)).toContain("workspace session: task-worktree");
+    expect(formatWorkspaceSessionActivation(session)).toContain("/repo/.worktrees/nolo-agent-frontend");
+  });
+});

package/client/workspaceSession.ts

@@ -0,0 +1,11 @@
+export {
+  activateWorkspaceSession,
+  createWorkspaceSession,
+  formatWorkspaceSessionActivation,
+} from "../agent-runtime/workspaceSession";
+export type {
+  PrepareTaskWorkspace,
+  PreparedTaskWorkspace,
+  WorkspaceSession,
+  WorkspaceSessionMode,
+} from "../agent-runtime/workspaceSession";

package/commandRegistry.ts

@@ -2,10 +2,11 @@ export type CommandEntry = {
   path: string[];
   script: string;
   description: string;
+  fixedArgs?: string[];
 };
 
 export const COMMANDS: CommandEntry[] = [
-  { path: ["chat"], script: "chatWithAgent.ts", description: "Chat with an agent" },
+  { path: ["chat"], script: "", description: "Chat with an agent" },
 
   { path: ["doc", "create"], script: "createDoc.ts", description: "Create a normal doc" },
   { path: ["doc", "read"], script: "readDoc.ts", description: "Read a normal doc" },
@@ -19,24 +20,35 @@ export const COMMANDS: CommandEntry[] = [
   { path: ["skill", "create-doc"], script: "createSkillDoc.ts", description: "Create a skill-backed doc" },
 
   { path: ["dialog", "read"], script: "readDialog.ts", description: "Read a dialog" },
+  { path: ["dialog", "status"], script: "dialogStatus.ts", description: "Read compact dialog status" },
+  { path: ["space", "list"], script: "listSpaces.ts", description: "List joined spaces" },
   { path: ["space", "read"], script: "readSpace.ts", description: "Read a space" },
   { path: ["space", "delete"], script: "deleteSpaces.ts", description: "Delete spaces by safe filters" },
   { path: ["space", "category"], script: "upsertSpaceCategory.ts", description: "Create or update a space category" },
   { path: ["space", "content-category"], script: "setSpaceContentCategory.ts", description: "Move content into a space category" },
 
-  { path: ["table", "data"], script: "tableData.ts", description: "Query or mutate table rows" },
+  { path: ["table", "query"], script: "tableData.ts", fixedArgs: ["--action", "query"], description: "Query table rows" },
+  { path: ["table", "add-column"], script: "tableData.ts", fixedArgs: ["--action", "add-column"], description: "Add one table column" },
+  { path: ["table", "add-row"], script: "tableData.ts", fixedArgs: ["--action", "add-row"], description: "Add one table row" },
+  { path: ["table", "add-rows"], script: "tableData.ts", fixedArgs: ["--action", "add-rows"], description: "Add table rows" },
+  { path: ["table", "update-row"], script: "tableData.ts", fixedArgs: ["--action", "update-row"], description: "Update one table row" },
+  { path: ["table", "update-rows"], script: "tableData.ts", fixedArgs: ["--action", "update-rows"], description: "Update table rows" },
+  { path: ["table", "delete-row"], script: "tableData.ts", fixedArgs: ["--action", "delete-row"], description: "Delete one table row" },
+  { path: ["table", "delete-rows"], script: "tableData.ts", fixedArgs: ["--action", "delete-rows"], description: "Delete table rows" },
+  { path: ["table", "data"], script: "tableData.ts", description: "Low-level table row script bridge" },
   { path: ["table", "meta"], script: "upsertTableMeta.ts", description: "Create or update table metadata" },
+  { path: ["task-run"], script: "", description: "Update durable task-run state through the runner bridge" },
 
   { path: ["agent", "list"], script: "listMyAgents.ts", description: "List owned agents" },
   { path: ["agent", "pull"], script: "", description: "Cache an agent for local runs" },
-  { path: ["agent", "read"], script: "readAgent.ts", description: "Read a single agent" },
+  { path: ["agent", "read"], script: "", description: "Read a single agent" },
   { path: ["agent", "run"], script: "", description: "Run an agent" },
   { path: ["agent", "update"], script: "updateAgent.ts", description: "Update agent fields" },
   { path: ["agent", "bind-current"], script: "", description: "Bind an agent to this machine" },
   { path: ["agent", "smoke-current"], script: "", description: "Smoke test a bound agent through this machine" },
   { path: ["agent", "runtime-doctor"], script: "", description: "Diagnose current machine runtime compatibility" },
   { path: ["agent", "unpublish"], script: "unpublishAgent.ts", description: "Remove an agent's public record" },
-  { path: ["agent", "chat"], script: "chatWithAgent.ts", description: "Chat with an agent" },
+  { path: ["agent", "chat"], script: "", description: "Chat with an agent" },
   { path: ["agent", "dialogs"], script: "queryAgentDialogs.ts", description: "Inspect recent dialogs for an agent" },
   { path: ["agent", "doctor"], script: "doctorAgentWorkspace.ts", description: "Audit agent workspace health" },
   { path: ["agent", "create-custom"], script: "createCustomCodingAgent.ts", description: "Create a custom coding agent" },
@@ -61,6 +73,7 @@ export const GROUP_ORDER = [
   "dialog",
   "space",
   "table",
+  "task-run",
   "llama",
   "model-runtime",
   "dev",
@@ -95,16 +108,20 @@ export function renderHelpText() {
     '  nolo doc create --title "Trip Notes" --body "hello" --sync local,us --dry-run',
     '  nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs" --sync local,main,us',
     "  nolo agent list --json",
+    "  nolo space list --json",
     "  nolo agent pull agent-pub-01APPBUILDER00000001YAII3I",
     "  nolo agent read agent-pub-01APPBUILDER00000001YAII3I",
-    '  nolo agent run frontend-implementer --msg "polish notifications" --local',
+    '  nolo agent run frontend-implementer --msg "polish notifications"',
     "  nolo agent bind-current agent-user-1-agent-1",
     "  nolo agent runtime-doctor agent-user-1-agent-1",
     '  nolo agent smoke-current agent-user-1-agent-1 --msg "ping"',
     '  nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"',
     "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",
     "  nolo space delete --name-prefix rn_owner_verify_0504 --yes",
-    "  nolo table data --table 01ABCXYZ --action query",
+    "  nolo table query --table 01ABCXYZ",
+    '  nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
+    '  nolo table update-row --table meta-b2e06f801f-NOLOTASKBOARD --row 01ROWID --changes \'{"status":"已完成"}\'',
+    "  nolo task-run read-context --row-dbkey row-user-table-row",
     "  nolo llama status",
   ];
 

package/connectorRunArtifact.ts

@@ -0,0 +1,121 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import type { MachineRunPermissionPolicy } from "./ai/agent/machineRunPermissions";
+
+type EnvLike = Record<string, string | undefined>;
+
+export type ConnectorRunArtifact = {
+  cwd: string;
+  exitStatus: "completed" | "failed";
+  collectedAt: string;
+  baseSha?: string | null;
+  headSha?: string | null;
+  changedFiles?: string[];
+  statusShort?: string;
+  diffStat?: string;
+  patchPreview?: string;
+  error?: string;
+  artifactError?: string;
+};
+
+const MAX_PATCH_PREVIEW_CHARS = 24_000;
+
+function normalizePath(value: string) {
+  return resolve(value.trim());
+}
+
+export function resolveConnectorRunCwd(args: {
+  env?: EnvLike;
+  policy: MachineRunPermissionPolicy;
+  fallbackCwd?: string;
+}) {
+  const explicit =
+    args.env?.NOLO_CONNECTOR_WORKDIR ||
+    args.env?.NOLO_AGENT_WORKDIR ||
+    args.env?.NOLO_LOCAL_WORKTREE ||
+    "";
+  const candidate = explicit || args.policy.writableRoots[0] || args.fallbackCwd || process.cwd();
+  const cwd = normalizePath(candidate);
+  if (!existsSync(cwd)) {
+    throw new Error(`Connector run cwd does not exist: ${cwd}`);
+  }
+  return cwd;
+}
+
+async function runGit(
+  args: string[],
+  cwd: string,
+  options: { trim?: boolean } = {}
+): Promise<string | null> {
+  const proc = Bun.spawn(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+  });
+  const [stdout, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) return null;
+  return options.trim === false ? stdout.replace(/\r?\n$/, "") : stdout.trim();
+}
+
+export function parseStatusChangedFiles(statusShort: string | null): string[] {
+  if (!statusShort) return [];
+  return [...new Set(statusShort
+    .split(/\r?\n/)
+    .map((line) => {
+      const porcelainMatch = line.match(/^.{2} (.+)$/);
+      if (porcelainMatch?.[1]) return porcelainMatch[1].trim();
+      const trimmedMatch = line.match(/^[MADRCU?!]{1,2}\s+(.+)$/);
+      return trimmedMatch?.[1]?.trim() ?? "";
+    })
+    .map((line) => line.includes(" -> ") ? line.split(" -> ").at(-1) ?? line : line)
+    .filter(Boolean))];
+}
+
+export async function readConnectorGitHead(cwd: string): Promise<string | null> {
+  return runGit(["rev-parse", "HEAD"], cwd);
+}
+
+export async function collectConnectorRunArtifact(args: {
+  cwd: string;
+  baseSha?: string | null;
+  exitStatus: "completed" | "failed";
+  error?: string;
+}): Promise<ConnectorRunArtifact> {
+  const collectedAt = new Date().toISOString();
+  try {
+    const [headSha, statusShort, diffStat, patchText] = await Promise.all([
+      readConnectorGitHead(args.cwd),
+      runGit(["status", "--short"], args.cwd, { trim: false }),
+      runGit(["diff", "--stat"], args.cwd),
+      runGit(["diff", "--no-color", "--unified=3"], args.cwd),
+    ]);
+    const patchPreview = patchText && patchText.length > MAX_PATCH_PREVIEW_CHARS
+      ? `${patchText.slice(0, MAX_PATCH_PREVIEW_CHARS)}\n...[truncated ${patchText.length - MAX_PATCH_PREVIEW_CHARS} chars]`
+      : patchText || undefined;
+    return {
+      cwd: args.cwd,
+      exitStatus: args.exitStatus,
+      collectedAt,
+      baseSha: args.baseSha ?? null,
+      headSha,
+      changedFiles: parseStatusChangedFiles(statusShort),
+      ...(statusShort ? { statusShort } : {}),
+      ...(diffStat ? { diffStat } : {}),
+      ...(patchPreview ? { patchPreview } : {}),
+      ...(args.error ? { error: args.error } : {}),
+    };
+  } catch (error) {
+    return {
+      cwd: args.cwd,
+      exitStatus: args.exitStatus,
+      collectedAt,
+      baseSha: args.baseSha ?? null,
+      ...(args.error ? { error: args.error } : {}),
+      artifactError: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/database/actions/write.ts

@@ -10,6 +10,16 @@ import {
 } from "./replication";
 import { toast } from "app/utils/toast";
 
+const SPACE_MEMBER_PREFIX = "space-member-";
+
+const getMemberUserIdFromSpaceMemberKey = (dbKey: string): string | null => {
+  if (!dbKey.startsWith(SPACE_MEMBER_PREFIX)) return null;
+  const rest = dbKey.slice(SPACE_MEMBER_PREFIX.length);
+  const lastDash = rest.lastIndexOf("-");
+  if (lastDash <= 0) return null;
+  return rest.slice(0, lastDash);
+};
+
 // 辅助函数：保存到本地 DB
 const saveToClientDb = async (
   clientDb: any,
@@ -51,6 +61,10 @@ export const writeAction = async (
 
   const { data, customKey } = writeConfig;
   const userId = writeConfig.userId || currentUserId;
+  const isSpaceMemberRecord = customKey.startsWith(SPACE_MEMBER_PREFIX);
+  const recordUserId = isSpaceMemberRecord
+    ? data.userId || getMemberUserIdFromSpaceMemberKey(customKey) || userId
+    : userId;
 
   // 1. 基础参数校验
   if (!data || !customKey) {
@@ -87,7 +101,7 @@ export const writeAction = async (
     const willSaveData = normalizeTimeFields({
       ...data,
       dbKey: customKey,
-      userId,
+      userId: recordUserId,
     });
 
     // 4. 本地保存
@@ -99,7 +113,7 @@ export const writeAction = async (
     const serverWriteConfig = {
       data: willSaveData,
       customKey,
-      userId,
+      userId: recordUserId,
     };
 
     // 6. 后台异步同步到远程（若在线且有可用服务器）

package/database/hooks/useUserData.ts

@@ -42,6 +42,7 @@ interface UseUserDataReturn extends FetchState {
 interface UseUserDataOptions {
   allowPartialData?: boolean;
   partialDataStrategy?: PartialDataStrategy;
+  remoteSummary?: boolean;
 }
 
 export type PartialDataStrategy = "always" | "never" | "hydrated-cache";
@@ -164,11 +165,13 @@ const loadRemoteUserData = async ({
   queryUserId,
   types,
   limit,
+  summary,
 }: {
   serverOrigin: string;
   queryUserId: string;
   types: DataType[];
   limit: number;
+  summary?: boolean;
 }) => {
   try {
     const batchResponse = await noloQueryRequest({
@@ -176,7 +179,7 @@ const loadRemoteUserData = async ({
       queryUserId,
       options: {
         limit,
-        condition: { type: types, includeDeleted: true },
+        condition: { type: types, includeDeleted: true, ...(summary ? { summary: true } : {}) },
       },
     });
 
@@ -198,7 +201,7 @@ const loadRemoteUserData = async ({
             queryUserId,
             options: {
               limit,
-              condition: { type, includeDeleted: true },
+              condition: { type, includeDeleted: true, ...(summary ? { summary: true } : {}) },
             },
           });
           if (!response.ok) return [];
@@ -227,6 +230,7 @@ export function useUserData(
     if (options.partialDataStrategy) return options.partialDataStrategy;
     return options.allowPartialData ?? true ? "always" : "never";
   }, [options.allowPartialData, options.partialDataStrategy]);
+  const remoteSummary = options.remoteSummary === true;
 
   const [{ loading, error, data }, setState] = useState<FetchState>({
     loading: true,
@@ -383,6 +387,7 @@ export function useUserData(
             queryUserId: effectiveUserId,
             types: typeArray,
             limit,
+            summary: remoteSummary,
           })
         )
       );
@@ -415,7 +420,7 @@ export function useUserData(
         limitedAppKeys: summarizeAppKeys(limitedData),
       });
 
-      if (mergedDataWithDeleted.length > 0) {
+      if (mergedDataWithDeleted.length > 0 && !remoteSummary) {
         try {
           await dispatch(cacheMergedUserDataThunk({ records: mergedDataWithDeleted })).unwrap();
         } catch (cacheError) {
@@ -462,6 +467,7 @@ export function useUserData(
     userId,
     typeArray,
     partialDataStrategy,
+    remoteSummary,
     allServers,
   ]);