nolo-cli 0.1.38 → 0.1.40

package/README.md

@@ -178,10 +178,10 @@ nolo dialog list --space <space>
 nolo dialog read <dialog>
 nolo dialog delete <dialog> --yes
 nolo doc list --agent <agent>
-nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --limit 20
-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 table add-column --table meta-b2e06f801f-NOLOTASKBOARD --schema-write-ok --name "blockedBy" --label "Blocked By"
+nolo table query --table meta-0e95801d90-NOLOTASKBOARD --limit 20
+nolo table query --table meta-0e95801d90-NOLOTASKBOARD --columns '["title","status","owner","priority","codeStatus"]' --no-base-fields --output items
+nolo table update-row --table meta-0e95801d90-NOLOTASKBOARD --row 01ROWID --changes '{"status":"已完成"}'
+nolo table add-column --table meta-0e95801d90-NOLOTASKBOARD --schema-write-ok --name "blockedBy" --label "Blocked By"
 ```
 
 `agent list`, `dialog list`, and record delete commands use global server

package/agent-runtime/agentRecordConfig.ts

@@ -19,18 +19,6 @@ function objectField(record: AgentRecord, key: string): Record<string, unknown>
     : undefined;
 }
 
-function localWorkspaceModeField(record: AgentRecord): "current" | "task-worktree" | undefined {
-  const directValue = stringField(record, "localWorkspaceMode");
-  const runtimeBinding = objectField(record, "runtimeBinding");
-  const runtimeValue = typeof runtimeBinding?.localWorkspaceMode === "string"
-    ? runtimeBinding.localWorkspaceMode
-    : typeof runtimeBinding?.workspaceMode === "string"
-      ? runtimeBinding.workspaceMode
-      : undefined;
-  const value = directValue ?? runtimeValue;
-  return value === "task-worktree" || value === "current" ? value : undefined;
-}
-
 function appendUniqueStrings(values: string[], next: unknown) {
   if (!Array.isArray(next)) return values;
   const seen = new Set(values);
@@ -84,7 +72,6 @@ export function resolveAgentRuntimeConfigFromRecord(
   const runtimeToolPolicy =
     objectField(record, "runtimeToolPolicy") ??
     objectField(runtimeBinding ?? {}, "runtimeToolPolicy");
-  const localWorkspaceMode = localWorkspaceModeField(record);
   const delegation = objectField(record, "delegation");
   return {
     key,
@@ -108,7 +95,6 @@ export function resolveAgentRuntimeConfigFromRecord(
     ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
     ...(runtimeBinding ? { runtimeBinding } : {}),
     ...(runtimeToolPolicy ? { runtimeToolPolicy } : {}),
-    ...(localWorkspaceMode ? { localWorkspaceMode } : {}),
     ...(delegation ? { delegation } : {}),
     rawRecord: record,
   };

package/agent-runtime/dialogWritePlan.ts

@@ -34,6 +34,28 @@ function resolveDialogTitle(args: {
   return lastUserText ? lastUserText.slice(0, 80) : "Local agent run";
 }
 
+function normalizeNonEmptyString(value: unknown) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function buildDialogLineageFields(args: {
+  input: AgentRuntimeSaveTurnInput;
+  existingDialog?: DialogRecord | null;
+}) {
+  const inheritedFromDialogKey = normalizeNonEmptyString(args.input.inheritedFromDialogKey);
+  const parentDialogId = normalizeNonEmptyString(args.input.parentDialogId);
+  if (!inheritedFromDialogKey && !parentDialogId) return {};
+  const rootDialogId =
+    normalizeNonEmptyString(args.existingDialog?.rootDialogId) ??
+    normalizeNonEmptyString(args.existingDialog?.parentDialogId) ??
+    parentDialogId;
+  return {
+    ...(inheritedFromDialogKey ? { inheritedFromDialogKey } : {}),
+    ...(parentDialogId ? { parentDialogId } : {}),
+    ...(rootDialogId ? { rootDialogId } : {}),
+  };
+}
+
 function buildDialogMessageWriteOps(args: {
   dialogId: string;
   input: AgentRuntimeSaveTurnInput;
@@ -102,6 +124,12 @@ export function buildAgentRuntimeDialogWritePlan(args: {
     updatedAt: nowIso,
     finishedAt: args.now,
     usage: args.input.result.usage,
+    ...(normalizeNonEmptyString(args.input.spaceId) ? { spaceId: normalizeNonEmptyString(args.input.spaceId) } : {}),
+    ...(normalizeNonEmptyString(args.input.category) ? { category: normalizeNonEmptyString(args.input.category) } : {}),
+    ...buildDialogLineageFields({
+      input: args.input,
+      existingDialog: args.existingDialog,
+    }),
     ...(typeof args.input.result.toolCallCount === "number"
       ? { toolCallCount: args.input.result.toolCallCount }
       : {}),
@@ -109,6 +137,17 @@ export function buildAgentRuntimeDialogWritePlan(args: {
       host: args.runtimeHost,
       ...(args.runtimeMetadata ?? {}),
     },
+    ...(args.input.result.runtimeToolSurface
+      ? {
+          runtimeCheckpoint: {
+            ...(args.existingDialog?.runtimeCheckpoint &&
+            typeof args.existingDialog.runtimeCheckpoint === "object"
+              ? args.existingDialog.runtimeCheckpoint
+              : {}),
+            toolSurface: args.input.result.runtimeToolSurface,
+          },
+        }
+      : {}),
   };
   return {
     dialogId,

package/agent-runtime/hostAdapter.ts

@@ -27,7 +27,6 @@ export type AgentRuntimeAgentConfig = {
   reasoning_effort?: string;
   runtimeBinding?: Record<string, unknown>;
   runtimeToolPolicy?: AgentRuntimeToolPolicy;
-  localWorkspaceMode?: "current" | "task-worktree";
   delegation?: Record<string, unknown>;
   rawRecord?: Record<string, unknown>;
 };
@@ -57,6 +56,10 @@ export type AgentRuntimeSaveTurnInput = {
   messages: AgentRuntimeChatMessage[];
   result: AgentRuntimeResult;
   continueDialogId?: string;
+  spaceId?: string;
+  category?: string;
+  inheritedFromDialogKey?: string;
+  parentDialogId?: string;
 };
 
 export type AgentRuntimeHostAdapter = {

package/agent-runtime/hybridRecordStore.ts

@@ -126,7 +126,7 @@ export function createHybridRecordStore(
   return {
     read: async (dbKey, options) => {
       const localRecord = await readHybridLocalRecord(deps.db, dbKey);
-      if (localRecord) return { ...localRecord, dbKey };
+      if (localRecord) return normalizeHybridRecord(dbKey, localRecord);
       if (options?.remote === false) return null;
 
       for (const server of resolveHybridServers(

package/agent-runtime/index.ts

@@ -39,15 +39,6 @@ export {
   createHybridRecordStore,
   shouldCacheHybridRemoteRecord,
 } from "./hybridRecordStore";
-export {
-  activateWorkspaceSession,
-  createWorkspaceSession,
-  formatWorkspaceSessionActivation,
-} from "./workspaceSession";
-export {
-  formatPreparedGitTaskWorkspace,
-  prepareGitTaskWorkspace,
-} from "./taskWorkspace";
 export {
   executeLocalToolWithPolicy,
   resolveLocalToolPolicy,
@@ -65,12 +56,44 @@ export {
   resolveLocalRuntimeEnvFromPolicy,
   resolveLocalWorkspaceExecutorOptionsFromPolicy,
 } from "./runtimeToolPolicy";
+export {
+  DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOLS,
+  inferOwnerIdFromRuntimeAgentKey,
+  isPublicRuntimeAgentRef,
+  redactAgentRecordForWorkspaceTool,
+  resolveRuntimeToolSurfaceForAgent,
+  resolveRuntimeToolSurface,
+} from "./runtimeToolSurface";
 export {
   buildLocalWorkspaceOpenAiTools,
   buildLocalWorkspacePolicyToolNames,
   buildLocalWorkspaceToolset,
   createLocalWorkspaceToolExecutors,
 } from "./localWorkspaceTools";
+export {
+  buildNoloWorkspaceCommandArgs,
+  buildNoloWorkspaceCliToolExecutors,
+  buildNoloWorkspaceOpenAiTools,
+  buildNoloTableQueryRequest,
+  clampNoloPositiveInteger,
+  filterNoloWorkspaceToolNames,
+  getNoloComparableUpdatedAt,
+  getNoloDialogIdFromKey,
+  getNoloSpaceContentKeys,
+  isNoloWorkspaceToolName,
+  noloPositiveIntegerString,
+  noloStringArg,
+  normalizeNoloDocReadArgs,
+  normalizeNoloSpaceInput,
+  NOLO_WORKSPACE_TOOL_NAMES,
+  NOLO_WORKSPACE_TOOL_PROMPT,
+  parseNoloWorkspaceToolArguments,
+  resolveNoloDialogInput,
+  runNoloWorkspaceCliTool,
+} from "./noloWorkspaceTools";
+export type {
+  NoloWorkspaceToolName,
+} from "./noloWorkspaceTools";
 export type {
   AgentRuntimeAgentConfig,
   AgentRuntimeHostAdapter,
@@ -87,15 +110,6 @@ export type {
   HybridRecordKvDb,
   HybridRecordStore,
 } from "./hybridRecordStore";
-export type {
-  PreparedTaskWorkspace,
-  PrepareTaskWorkspace,
-  WorkspaceSession,
-  WorkspaceSessionMode,
-} from "./workspaceSession";
-export type {
-  PreparedGitTaskWorkspace,
-} from "./taskWorkspace";
 export type {
   LocalToolPolicyDecision,
 } from "./localToolPolicy";
@@ -105,6 +119,13 @@ export type {
 export type {
   PlatformChatProviderConfig,
 } from "./platformChatProvider";
+export type {
+  RuntimeToolSurfaceHost,
+  RuntimeToolSurfaceForAgentInput,
+  RuntimeToolSurfaceInput,
+  RuntimeToolSurfaceResult,
+  RuntimeToolSurfaceVisibility,
+} from "./runtimeToolSurface";
 export type {
   AgentRuntimeChatMessage,
   AgentRuntimeDecision,

package/agent-runtime/localDialogRead.ts

@@ -0,0 +1,23 @@
+export type LocalDialogReadResult = {
+  meta: any;
+  msgs: any[];
+};
+
+export async function readDialogFromLocalDb(args: {
+  dialogKey: string;
+  dialogId: string;
+  limit: number;
+}): Promise<LocalDialogReadResult> {
+  const [{ default: serverDb, ensureServerDbOpen }, { fetchMessages }] = await Promise.all([
+    import("../database/server/db"),
+    import("../chat/messages/fetchMessages"),
+  ]);
+  await ensureServerDbOpen();
+  return {
+    meta: await serverDb.get(args.dialogKey),
+    msgs: await fetchMessages(serverDb, args.dialogId, {
+      limit: args.limit,
+      throwOnError: true,
+    }),
+  };
+}

package/agent-runtime/localLoop.ts

@@ -12,7 +12,10 @@ export type LocalAgentTurnInput = {
   agentRef: string;
   input: AgentRuntimeMessageContent;
   continueDialogId?: string;
-  maxToolRounds?: number;
+  spaceId?: string;
+  category?: string;
+  inheritedFromDialogKey?: string;
+  parentDialogId?: string;
   timeoutMs?: number;
   onToolEvent?: (event: LocalAgentToolEvent) => void;
 };
@@ -26,11 +29,13 @@ export type LocalAgentToolEvent = {
   round: number;
   toolCallId: string;
   toolName: string;
+  argumentsPreview?: string;
+  elapsedMs?: number;
+  summary?: string;
   message?: string;
   metadata?: Record<string, unknown>;
 };
 
-export const DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS = 128;
 export const LOCAL_AGENT_CONFIG_MISSING_CODE = "LOCAL_AGENT_CONFIG_MISSING";
 
 function formatToolExecutionError(args: {
@@ -75,6 +80,72 @@ function emitToolEvent(
   input.onToolEvent?.(event);
 }
 
+function compactWhitespace(value: string) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function clip(value: string, max = 240) {
+  const compact = compactWhitespace(value);
+  return compact.length > max ? `${compact.slice(0, max - 3)}...` : compact;
+}
+
+function parseToolArguments(raw: string | undefined) {
+  if (!raw?.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function summarizeToolArguments(toolName: string, rawArgs: string | undefined) {
+  const args = parseToolArguments(rawArgs);
+  const pick = (...keys: string[]) => {
+    for (const key of keys) {
+      const value = args[key];
+      if (typeof value === "string" && value.trim()) return value.trim();
+    }
+    return "";
+  };
+  const command = pick("command", "cmd", "runCommand", "executeCommand", "bash");
+  if (command) return clip(command);
+  const filePath = pick("filePath", "path", "filename", "file");
+  if (filePath) return clip(filePath);
+  const query = pick("query", "pattern", "search", "q");
+  if (query) return clip(query);
+  const keys = Object.keys(args);
+  if (keys.length === 0) return "";
+  return clip(keys.slice(0, 6).map((key) => {
+    const value = args[key];
+    if (typeof value === "string") return `${key}=${clip(value, 80)}`;
+    if (typeof value === "number" || typeof value === "boolean") return `${key}=${String(value)}`;
+    if (Array.isArray(value)) return `${key}[${value.length}]`;
+    return `${key}=${value === null ? "null" : typeof value}`;
+  }).join(" "));
+}
+
+function summarizeToolResult(content: unknown, metadata?: Record<string, unknown>) {
+  const parts: string[] = [];
+  const exitCode = metadata?.exitCode;
+  if (typeof exitCode === "number") parts.push(`exit=${exitCode}`);
+  if (typeof content === "string") {
+    const trimmed = content.trim();
+    if (trimmed) {
+      const lines = trimmed.split(/\r?\n/).length;
+      parts.push(`${lines} line${lines === 1 ? "" : "s"}`);
+      parts.push(`${trimmed.length} chars`);
+      const tail = clip(trimmed.slice(-160), 160);
+      if (tail) parts.push(`tail="${tail}"`);
+    } else {
+      parts.push("empty");
+    }
+  }
+  return parts.join(" ");
+}
+
 function buildMessages(args: {
   prompt?: string;
   history: AgentRuntimeChatMessage[];
@@ -124,19 +195,16 @@ export async function runLocalAgentTurn(
     input: input.input,
   });
   const provider = await input.adapter.resolveProvider(agentConfig);
-  const maxToolRounds = input.maxToolRounds ?? DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS;
   const userInputText = extractUserInputText(input.input);
   let toolCallCount = 0;
   let result: AgentRuntimeResult;
-  for (let round = 0; round <= maxToolRounds; round += 1) {
+  let round = 0;
+  while (true) {
     result = await provider.complete(messages, {
       ...(typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {}),
     });
     const toolCalls = result.tool_calls ?? [];
     if (toolCalls.length === 0) break;
-    if (round === maxToolRounds) {
-      throw new Error(`Local agent exceeded max tool rounds: ${maxToolRounds}`);
-    }
     toolCallCount += toolCalls.length;
     messages.push({
       role: "assistant",
@@ -147,11 +215,13 @@ export async function runLocalAgentTurn(
     for (const toolCall of toolCalls) {
       const toolName = toolCall.function.name;
       let toolResult;
+      const startedAt = Date.now();
       emitToolEvent(input, {
         type: "tool-call",
         round,
         toolCallId: toolCall.id,
         toolName,
+        argumentsPreview: summarizeToolArguments(toolName, toolCall.function.arguments),
       });
       try {
         toolResult = await input.adapter.executeTool({
@@ -165,6 +235,8 @@ export async function runLocalAgentTurn(
           round,
           toolCallId: toolCall.id,
           toolName,
+          elapsedMs: Math.max(0, Date.now() - startedAt),
+          summary: summarizeToolResult(toolResult.content, toolResult.metadata),
           metadata: toolResult.metadata,
         });
       } catch (error) {
@@ -174,6 +246,7 @@ export async function runLocalAgentTurn(
           round,
           toolCallId: toolCall.id,
           toolName,
+          elapsedMs: Math.max(0, Date.now() - startedAt),
           message: error instanceof Error ? error.message : String(error),
         });
         toolResult = {
@@ -201,6 +274,7 @@ export async function runLocalAgentTurn(
         ...(toolResult.metadata ? { tool_result_metadata: toolResult.metadata } : {}),
       });
     }
+    round += 1;
   }
   result = result!;
   messages.push({
@@ -213,13 +287,19 @@ export async function runLocalAgentTurn(
     result: {
       ...result,
       ...(toolCallCount > 0 ? { toolCallCount } : {}),
+      ...((agentConfig as any).toolSurface ? { runtimeToolSurface: (agentConfig as any).toolSurface } : {}),
     },
     ...(input.continueDialogId ? { continueDialogId: input.continueDialogId } : {}),
+    ...(input.spaceId ? { spaceId: input.spaceId } : {}),
+    ...(input.category ? { category: input.category } : {}),
+    ...(input.inheritedFromDialogKey ? { inheritedFromDialogKey: input.inheritedFromDialogKey } : {}),
+    ...(input.parentDialogId ? { parentDialogId: input.parentDialogId } : {}),
   });
 
   return {
     ...result,
     ...(toolCallCount > 0 ? { toolCallCount } : {}),
+    ...((agentConfig as any).toolSurface ? { runtimeToolSurface: (agentConfig as any).toolSurface } : {}),
     dialogId: saved.dialogId,
   };
 }

package/agent-runtime/localToolPolicy.ts

@@ -28,16 +28,11 @@ const REMOVED_LOCAL_TOOLS = new Set([
 ]);
 
 const DEFAULT_LOCAL_TOOLS = new Set([
-  "listWorkspaceFiles",
-  "readWorkspaceFile",
-  "writeWorkspaceFile",
-  "replaceWorkspaceText",
   "listFiles",
   "readFile",
   "writeFile",
   "editFile",
   "searchFiles",
-  "searchWorkspace",
   "execShell",
 ]);
 
@@ -66,10 +61,6 @@ function parseShellCommandPayload(rawArguments: string) {
   }
 }
 
-function isLocalShellModeEnabled(env: EnvLike) {
-  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
-}
-
 function isRestrictedLocalToolMode(env: EnvLike) {
   return env.NOLO_LOCAL_TOOL_MODE === "restricted";
 }
@@ -101,14 +92,7 @@ export function resolveLocalToolPolicy(args: {
   }
 
   if (toolName === "execShell") {
-    if (isLocalShellModeEnabled(args.env)) {
-      return { allowed: true, toolName };
-    }
-    return {
-      allowed: false,
-      toolName,
-      reason: "execShell requires NOLO_LOCAL_SHELL_MODE=worktree.",
-    };
+    return { allowed: true, toolName };
   }
 
   if (NEVER_LOCAL_TOOLS.has(toolName)) {