nolo-cli 0.102.2 → 0.102.3

package/{chunk-XTM4WSXT.js → chunk-O2LBWZLR.js}

@@ -5,14 +5,14 @@ import {
   inlineImageUrlsForCustomProvider,
   prepareTools,
   shouldInlineImageUrlsForAgent
-} from "./chunk-2K54PIZY.js";
+} from "./chunk-6XHM3LNF.js";
 import {
   INVALID_TOOL_ARGS_REPLACEMENT,
   buildInvalidToolCallSelfHealResult,
   parseToolCallArguments,
   performFetchRequest,
   sanitizeOutboundMessages
-} from "./chunk-DLXHN5XZ.js";
+} from "./chunk-S274RDSE.js";
 import {
   createSSEParser,
   createToolRunId,
@@ -23,7 +23,7 @@ import {
   toolRunSetPending,
   toolRunStarted,
   toolRunSucceeded
-} from "./chunk-TTMNMJVI.js";
+} from "./chunk-YIEUDVD6.js";
 import {
   getPublicImageAgentMode
 } from "./chunk-VIDPVFP3.js";
@@ -38,10 +38,10 @@ import {
   messageStreamEnd,
   messageStreaming,
   updateToolMessage
-} from "./chunk-NMMU6M4Z.js";
+} from "./chunk-GLD6Q25H.js";
 import {
   streamAgentChatTurn
-} from "./chunk-TAPMD4SO.js";
+} from "./chunk-JVP74JRH.js";
 import {
   addActiveController,
   removeActiveController,

package/{chunk-GJ647AYV.js → chunk-REPRKRB2.js}

@@ -7,7 +7,7 @@ import {
   deleteDialog,
   runtime_default,
   toast
-} from "./chunk-NMMU6M4Z.js";
+} from "./chunk-GLD6Q25H.js";
 import {
   formatISO
 } from "./chunk-ZRAU6T47.js";

package/{chunk-DLXHN5XZ.js → chunk-S274RDSE.js}

@@ -7,7 +7,7 @@ import {
 import {
   clipMultilineText,
   fetchAndSerializeTable
-} from "./chunk-TTMNMJVI.js";
+} from "./chunk-YIEUDVD6.js";
 import {
   isGatewayHttpStatus
 } from "./chunk-NF64D32W.js";
@@ -29,13 +29,13 @@ import {
 } from "./chunk-AGIM7IMJ.js";
 import {
   fetchAndCacheMessages
-} from "./chunk-NMMU6M4Z.js";
+} from "./chunk-GLD6Q25H.js";
 import {
   shouldUseServerProxy
 } from "./chunk-YYLHWIW6.js";
 import {
   fetchServerSyncedCredential
-} from "./chunk-TAPMD4SO.js";
+} from "./chunk-JVP74JRH.js";
 import {
   buildSkillGuidancePromptBlock,
   extractRuntimePageCapabilities,

package/{chunk-ERFIIS4C.js → chunk-USTPPV3J.js}

@@ -1,7 +1,7 @@
 import {
   fetchReferenceContents,
   resolveReferenceAssets
-} from "./chunk-DLXHN5XZ.js";
+} from "./chunk-S274RDSE.js";
 
 // packages/ai/agent/fetchAgentContexts.ts
 async function fetchAgentContexts(references, dispatch) {

package/{chunk-K4URP6NQ.js → chunk-VL3H5ZU3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-GMZLP5DV.js";
 import {
   sanitizeForOutbound
-} from "./chunk-CQ3WA2NE.js";
+} from "./chunk-NKWIS6G2.js";
 import {
   accumulateToolCallDelta,
   createThinkParserState,
@@ -218,18 +218,58 @@ function createResponsesToolAccumulator() {
 function keyOf(event) {
   return typeof event?.item_id === "string" && event.item_id ? event.item_id : typeof event?.item?.id === "string" && event.item.id ? event.item.id : typeof event?.item?.call_id === "string" && event.item.call_id ? event.item.call_id : typeof event?.call_id === "string" && event.call_id ? event.call_id : "";
 }
+function shortFingerprint(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function parsesAsJsonObject(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed !== null && typeof parsed === "object";
+  } catch {
+    return false;
+  }
+}
 function applyResponsesToolEvent(calls, event) {
   const key = keyOf(event);
   if (!key) return;
   const item = event?.item;
   const id = item?.call_id || item?.id || event?.call_id || key;
-  const current = calls.get(key) ?? { id, name: "", arguments: "" };
+  const current = calls.get(key) ?? { id, name: "", arguments: "", sawDelta: false };
   if (typeof item?.name === "string" && item.name) current.name = item.name;
+  const applySnapshot = (next) => {
+    if (!current.sawDelta) {
+      current.arguments = next;
+      return;
+    }
+    if (next.startsWith(current.arguments)) {
+      current.arguments = next;
+    } else if (current.arguments.startsWith(next)) {
+    } else {
+      if (!parsesAsJsonObject(current.arguments) && parsesAsJsonObject(next)) {
+        console.warn(
+          `[responses-tool-call] adopting parsable snapshot over unparsable accumulation (accumulated length=${current.arguments.length}, fingerprint=${shortFingerprint(current.arguments)}; snapshot length=${next.length}, fingerprint=${shortFingerprint(next)})`
+        );
+        current.arguments = next;
+        return;
+      }
+      console.warn(
+        `[responses-tool-call] conflicting arguments snapshot (accumulated length=${current.arguments.length}, fingerprint=${shortFingerprint(current.arguments)}; snapshot length=${next.length}, fingerprint=${shortFingerprint(next)})`
+      );
+    }
+  };
   const itemArguments = normalizeResponsesToolArguments(item?.arguments);
-  if (itemArguments !== void 0) current.arguments = itemArguments;
+  if (itemArguments !== void 0) applySnapshot(itemArguments);
   const eventArguments = normalizeResponsesToolArguments(event?.arguments);
-  if (eventArguments !== void 0) current.arguments = eventArguments;
-  if (typeof event?.delta === "string") current.arguments += event.delta;
+  if (eventArguments !== void 0) applySnapshot(eventArguments);
+  if (typeof event?.delta === "string") {
+    current.sawDelta = true;
+    current.arguments += event.delta;
+  }
   calls.set(key, current);
 }
 function addResponsesToolCall(calls, call) {
@@ -237,7 +277,8 @@ function addResponsesToolCall(calls, call) {
   calls.set(key, {
     id: call.id,
     name: call.function.name,
-    arguments: call.function.arguments
+    arguments: call.function.arguments,
+    sawDelta: false
   });
 }
 function finalizeResponsesToolCalls(calls) {

package/{chunk-TTMNMJVI.js → chunk-YIEUDVD6.js}

@@ -75,10 +75,10 @@ import {
 } from "./chunk-VF4K2QE6.js";
 import {
   createDocState
-} from "./chunk-VPNDYFUB.js";
+} from "./chunk-3MSJ4XDQ.js";
 import {
   createDialogAction
-} from "./chunk-5UQRASYE.js";
+} from "./chunk-NR7N2RWA.js";
 import {
   TASK_PREVIEW_MAX,
   buildDelegatedTaskContent,
@@ -108,7 +108,7 @@ import {
   updateContentCategory,
   updateContentTitle,
   writeStoredCollapsedCategories
-} from "./chunk-GJ647AYV.js";
+} from "./chunk-REPRKRB2.js";
 import {
   getCurrentSpaceId,
   getCurrentSpaceIdRaw,
@@ -130,14 +130,14 @@ import {
   selectMsgById,
   uiAskChoiceFunc,
   uiAskChoiceFunctionSchema
-} from "./chunk-NMMU6M4Z.js";
+} from "./chunk-GLD6Q25H.js";
 import {
   createAgent,
   deleteServerSyncedCredential,
   runLlm,
   streamAgentChatTurn,
   updateAgent
-} from "./chunk-TAPMD4SO.js";
+} from "./chunk-JVP74JRH.js";
 import {
   getActiveDialogKey,
   selectCurrentDialogKey,
@@ -3998,7 +3998,7 @@ async function deleteDialogsFunc(args, thunkApi) {
   const deletedDialogIds = [];
   const deletedDialogKeys = [];
   const failures = [];
-  const { deleteDialog: deleteDialog2 } = await import("./dialogSlice-LUUVLJKZ.js");
+  const { deleteDialog: deleteDialog2 } = await import("./dialogSlice-KXBFWRVK.js");
   for (const target of targets) {
     try {
       await thunkApi.dispatch(deleteDialog2(target.dbKey)).unwrap();
@@ -14907,7 +14907,7 @@ var executeToolRun = createAsyncThunk(
     if (!executionInput) {
       throw new Error(`ToolRun ${id} has no input to execute with.`);
     }
-    const { findToolExecutor: findToolExecutor2 } = await import("./tools-NPSZ3DTN.js");
+    const { findToolExecutor: findToolExecutor2 } = await import("./tools-U6BT6H56.js");
     const { executor } = findToolExecutor2(run.toolName);
     toolRunStarted({
       id: run.id,
@@ -17425,7 +17425,7 @@ async function updateDocFunc(args, thunkApi) {
       updated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
     await dispatch(write({ data: updatedPageData, customKey: id })).unwrap();
-    const { getDocState, applyExternalDocUpdate } = await import("./docStore-RRAGFCNQ.js");
+    const { getDocState, applyExternalDocUpdate } = await import("./docStore-PLGBTV5U.js");
     if (getDocState().pageKey === id) {
       applyExternalDocUpdate({
         slateData: finalSlateData,

package/{chunk-OW4APERY.js → chunk-YK5MHOWM.js}

@@ -295,6 +295,43 @@ function sanitizeGeminiSchemaNode(node, active) {
     seen.delete(node);
   }
 }
+var enumMetaByNode = /* @__PURE__ */ new WeakMap();
+function enumMetaOf(node) {
+  return node && typeof node === "object" ? enumMetaByNode.get(node) : void 0;
+}
+function rawEnumValues(src) {
+  if (Array.isArray(src.enum) && src.enum.length > 0) return src.enum;
+  if ("const" in src && src.const !== void 0) return [src.const];
+  return void 0;
+}
+function geminiEnumFields(values, baseDescription) {
+  if (values.every((v) => typeof v === "string")) {
+    return {
+      enum: [...new Set(values)],
+      description: baseDescription
+    };
+  }
+  if (values.every((v) => typeof v === "number" || typeof v === "boolean")) {
+    const allowed2 = [...new Set(values.map((v) => String(v)))].join(", ");
+    const note2 = `(allowed: ${allowed2})`;
+    return {
+      description: baseDescription ? `${baseDescription} ${note2}` : note2
+    };
+  }
+  const allowed = [...new Set(values.map(geminiEnumLiteral))].join(", ");
+  const note = `(allowed: ${allowed})`;
+  return {
+    description: baseDescription ? `${baseDescription} ${note}` : note
+  };
+}
+function geminiEnumLiteral(value) {
+  const json = JSON.stringify(value);
+  return json === void 0 ? String(value) : json;
+}
+function applyGeminiEnum(out, fields) {
+  if (fields.enum) out.enum = fields.enum;
+  if (fields.description !== void 0) out.description = fields.description;
+}
 function sanitizeGeminiSchemaNodeInner(src, out, seen) {
   if (Array.isArray(src.type)) {
     const firstNonNull = src.type.find((t) => t !== "null");
@@ -306,10 +343,12 @@ function sanitizeGeminiSchemaNodeInner(src, out, seen) {
   if (typeof src.description === "string") out.description = src.description;
   if (typeof src.minimum === "number") out.minimum = src.minimum;
   if (typeof src.maximum === "number") out.maximum = src.maximum;
-  if (Array.isArray(src.enum) && src.enum.length > 0) out.enum = src.enum;
   if (src.nullable === true) out.nullable = true;
-  if ("const" in src && src.const !== void 0 && !out.enum) {
-    out.enum = [src.const];
+  const enumValues = rawEnumValues(src);
+  if (enumValues) {
+    const baseDescription = typeof src.description === "string" ? src.description : void 0;
+    enumMetaByNode.set(out, { values: enumValues, baseDescription });
+    applyGeminiEnum(out, geminiEnumFields(enumValues, baseDescription));
   }
   const variantBranches = [
     ...Array.isArray(src.oneOf) ? src.oneOf : [],
@@ -323,13 +362,19 @@ function sanitizeGeminiSchemaNodeInner(src, out, seen) {
       const branchProperties = sanitized.properties ?? {};
       for (const [key, value] of Object.entries(branchProperties)) {
         const previous = mergedProperties[key];
-        const prevEnum = previous?.enum;
-        const nextEnum = value?.enum;
-        if (prevEnum && nextEnum) {
-          mergedProperties[key] = {
-            ...value,
-            enum: [.../* @__PURE__ */ new Set([...prevEnum, ...nextEnum])]
+        const prevMeta = enumMetaOf(previous);
+        const nextMeta = enumMetaOf(value);
+        if (prevMeta && nextMeta) {
+          const values = [...prevMeta.values, ...nextMeta.values];
+          const baseDescription = nextMeta.baseDescription ?? prevMeta.baseDescription;
+          const node = {
+            ...value
           };
+          delete node.enum;
+          delete node.description;
+          applyGeminiEnum(node, geminiEnumFields(values, baseDescription));
+          enumMetaByNode.set(node, { values, baseDescription });
+          mergedProperties[key] = node;
         } else {
           mergedProperties[key] = value;
         }

package/{commandRegistry-X7FA6WJQ.js → commandRegistry-POKHERIN.js}

@@ -103,7 +103,7 @@ function createDaemonShortcutCommand(path, description, command) {
 // packages/cli/agentInternalCommandEntries.ts
 function getAgentInternalCommandEntries() {
   const createAgentRunCommand = (path, description) => createContextCommand(path, description, async (args, ctx) => {
-    const { runAgentRunCommand } = await import("./agentRunCommand-2SZBC7BP.js");
+    const { runAgentRunCommand } = await import("./agentRunCommand-IWKQO47Q.js");
     return runAgentRunCommand(args, {
       env: ctx.env,
       scriptDir: ctx.scriptDir,
@@ -115,11 +115,11 @@ function getAgentInternalCommandEntries() {
     createAgentRunCommand(["run"], "Run a no-login local agent in this workspace"),
     createAgentRunCommand(["chat"], "Chat with an agent"),
     createEnvCommand(["agent", "list"], "List owned agents", async (args, deps) => {
-      const { runAgentListCommand } = await import("./agentListCommands-VLNQH2BR.js");
+      const { runAgentListCommand } = await import("./agentListCommands-SRRN3TCW.js");
       return runAgentListCommand(args, deps);
     }),
     createEnvCommand(["agent", "create"], "Create a new agent", async (args, deps) => {
-      const { runAgentCreateCommand } = await import("./agentRecordCommands-2INKPT2O.js");
+      const { runAgentCreateCommand } = await import("./agentRecordCommands-KQMZLZHW.js");
       return runAgentCreateCommand(args, deps);
     }),
     createEnvCommand(["agent", "models"], "List models: --preset <id> (server discovery, exit 1 on static fallback) or --url <base> --api-key <key> (OpenAI-compatible /models)", async (args, deps) => {
@@ -135,7 +135,7 @@ function getAgentInternalCommandEntries() {
       return runAgentPullCommand(args, deps);
     }),
     createEnvCommand(["agent", "read"], "Read a single agent", async (args, deps) => {
-      const { runAgentReadCommand } = await import("./agentRecordCommands-2INKPT2O.js");
+      const { runAgentReadCommand } = await import("./agentRecordCommands-KQMZLZHW.js");
       return runAgentReadCommand(args, deps);
     }),
     createAgentRunCommand(["agent", "run"], "Run an agent"),
@@ -164,31 +164,31 @@ function getAgentInternalCommandEntries() {
       return runSetupOfflineMarxistsAgentCommand(args, deps);
     }),
     createEnvCommand(["agent", "update"], "Update agent fields", async (args, deps) => {
-      const { runAgentUpdateCommand } = await import("./agentRecordCommands-2INKPT2O.js");
+      const { runAgentUpdateCommand } = await import("./agentRecordCommands-KQMZLZHW.js");
       return runAgentUpdateCommand(args, deps);
     }),
     createEnvCommand(["agent", "email", "provision"], "Provision a controlled inbox for an agent", async (args, deps) => {
-      const { runAgentEmailProvisionCommand } = await import("./agentEmailCommands-NCQSCDX7.js");
+      const { runAgentEmailProvisionCommand } = await import("./agentEmailCommands-V2V54ZIH.js");
       return runAgentEmailProvisionCommand(args, deps);
     }),
     createEnvCommand(["agent", "email", "bind"], "Bind an existing email address to an agent", async (args, deps) => {
-      const { runAgentEmailBindCommand } = await import("./agentEmailCommands-NCQSCDX7.js");
+      const { runAgentEmailBindCommand } = await import("./agentEmailCommands-V2V54ZIH.js");
       return runAgentEmailBindCommand(args, deps);
     }),
     createEnvCommand(["agent", "email", "transfer"], "Transfer an email identity from one agent to another (cross-account)", async (args, deps) => {
-      const { runAgentEmailTransferCommand } = await import("./agentEmailCommands-NCQSCDX7.js");
+      const { runAgentEmailTransferCommand } = await import("./agentEmailCommands-V2V54ZIH.js");
       return runAgentEmailTransferCommand(args, deps);
     }),
     createEnvCommand(
       ["agent", "email", "create-and-provision"],
       "Create an agent and provision its controlled inbox",
       async (args, deps) => {
-        const { runAgentEmailCreateAndProvisionCommand } = await import("./agentEmailCommands-NCQSCDX7.js");
+        const { runAgentEmailCreateAndProvisionCommand } = await import("./agentEmailCommands-V2V54ZIH.js");
         return runAgentEmailCreateAndProvisionCommand(args, deps);
       }
     ),
     createEnvCommand(["agent", "delete"], "Hard-delete an agent's private and public records", async (args, deps) => {
-      const { runAgentDeleteCommand } = await import("./agentDeleteCommand-MEKEAJS6.js");
+      const { runAgentDeleteCommand } = await import("./agentDeleteCommand-3EV2EOUI.js");
       return runAgentDeleteCommand(args, deps);
     }),
     createEnvCommand(["agent", "grant"], "Grant another user access to this agent's owner credentials", async (args, deps) => {
@@ -204,15 +204,15 @@ function getAgentInternalCommandEntries() {
       return runAgentRevokeGrantCommand(args, deps);
     }),
     createEnvCommand(["agent", "bind-current"], "Bind an agent to this machine", async (args, deps) => {
-      const { runAgentBindCurrentCommand } = await import("./agentMachineCommands-ZYKZGX65.js");
+      const { runAgentBindCurrentCommand } = await import("./agentMachineCommands-JYJMU27G.js");
       return runAgentBindCurrentCommand(args, deps);
     }),
     createEnvCommand(["agent", "smoke-current"], "Smoke test a bound agent through this machine", async (args, deps) => {
-      const { runAgentSmokeCurrentCommand } = await import("./agentMachineCommands-ZYKZGX65.js");
+      const { runAgentSmokeCurrentCommand } = await import("./agentMachineCommands-JYJMU27G.js");
       return runAgentSmokeCurrentCommand(args, deps);
     }),
     createEnvCommand(["agent", "runtime-doctor"], "Diagnose current machine runtime compatibility", async (args, deps) => {
-      const { runAgentRuntimeDoctorCommand } = await import("./agentMachineCommands-ZYKZGX65.js");
+      const { runAgentRuntimeDoctorCommand } = await import("./agentMachineCommands-JYJMU27G.js");
       return runAgentRuntimeDoctorCommand(args, deps);
     }),
     createAgentRunCommand(["agent", "chat"], "Chat with an agent")
@@ -223,23 +223,23 @@ function getAgentInternalCommandEntries() {
 function getAppInternalCommandEntries() {
   return [
     createEnvCommand(["app", "list"], "List your apps", async (args, deps) => {
-      const { runAppListCommand } = await import("./appListCommands-O6QDXYKT.js");
+      const { runAppListCommand } = await import("./appListCommands-IIUS64VI.js");
       return runAppListCommand(args, deps);
     }),
     createEnvCommand(["app", "get"], "Get app details", async (args, deps) => {
-      const { runAppGetCommand } = await import("./appGetCommands-MCY6JLD3.js");
+      const { runAppGetCommand } = await import("./appGetCommands-4Z7V7UYA.js");
       return runAppGetCommand(args, deps);
     }),
     createEnvCommand(["app", "deploy"], "Deploy an app", async (args, deps) => {
-      const { runAppDeployCommand } = await import("./appDeployCommands-7PQPIIEL.js");
+      const { runAppDeployCommand } = await import("./appDeployCommands-JWH5HMET.js");
       return runAppDeployCommand(args, deps);
     }),
     createEnvCommand(["app", "deploy", "status"], "Check app deploy status", async (args, deps) => {
-      const { runAppDeployStatusCommand } = await import("./appDeployStatusCommands-Z3YBCYU3.js");
+      const { runAppDeployStatusCommand } = await import("./appDeployStatusCommands-CLONFBVO.js");
       return runAppDeployStatusCommand(args, deps);
     }),
     createEnvCommand(["app", "delete"], "Delete an app", async (args, deps) => {
-      const { runAppDeleteCommand } = await import("./appDeleteCommands-YLCAVP4I.js");
+      const { runAppDeleteCommand } = await import("./appDeleteCommands-SZFKFV4S.js");
       return runAppDeleteCommand(args, deps);
     })
   ];
@@ -317,27 +317,27 @@ function getChromeInternalCommandEntries() {
 function getDialogInternalCommandEntries() {
   return [
     createEnvCommand(["dialog", "search"], "Search dialog messages across dialogs", async (args, deps) => {
-      const { runDialogSearchCommand } = await import("./dialogCommands-NNSKMYZR.js");
+      const { runDialogSearchCommand } = await import("./dialogCommands-4XNYPCE7.js");
       return runDialogSearchCommand(args, deps);
     }),
     createEnvCommand(["dialog", "list"], "List dialogs (default --limit 50; --all/--limit 0 full; --jsonl streams)", async (args, deps) => {
-      const { runDialogListCommand } = await import("./dialogCommands-NNSKMYZR.js");
+      const { runDialogListCommand } = await import("./dialogCommands-4XNYPCE7.js");
       return runDialogListCommand(args, deps);
     }),
     createEnvCommand(["dialog", "delete"], "Delete one or more dialogs", async (args, deps) => {
-      const { runDialogDeleteCommand } = await import("./dialogCommands-NNSKMYZR.js");
+      const { runDialogDeleteCommand } = await import("./dialogCommands-4XNYPCE7.js");
       return runDialogDeleteCommand(args, deps);
     }),
     createEnvCommand(["dialog", "query"], "Query dialogs by subject refs (default --limit 50; --all full; --jsonl streams)", async (args, deps) => {
-      const { runDialogQueryCommand } = await import("./dialogCommands-NNSKMYZR.js");
+      const { runDialogQueryCommand } = await import("./dialogCommands-4XNYPCE7.js");
       return runDialogQueryCommand(args, deps);
     }),
     createEnvCommand(["dialog", "read"], "Read a dialog", async (args, deps) => {
-      const { runDialogReadCommand } = await import("./dialogCommands-NNSKMYZR.js");
+      const { runDialogReadCommand } = await import("./dialogCommands-4XNYPCE7.js");
       return runDialogReadCommand(args, deps);
     }),
     createEnvCommand(["dialog", "status"], "Read compact dialog status", async (args, deps) => {
-      const { runDialogStatusCommand } = await import("./dialogCommands-NNSKMYZR.js");
+      const { runDialogStatusCommand } = await import("./dialogCommands-4XNYPCE7.js");
       return runDialogStatusCommand(args, deps);
     })
   ];
@@ -347,39 +347,39 @@ function getDialogInternalCommandEntries() {
 function getDocInternalCommandEntries() {
   return [
     createEnvCommand(["doc", "create"], "Create a normal doc", async (args, deps) => {
-      const { runDocCreateCommand } = await import("./docCreateCommands-BKCYZTJW.js");
+      const { runDocCreateCommand } = await import("./docCreateCommands-P4XCR2SW.js");
       return runDocCreateCommand(args, deps);
     }),
     createEnvCommand(["doc", "read"], "Read a normal doc", async (args, deps) => {
-      const { runDocReadCommand } = await import("./docReadCommands-PPI2UAIW.js");
+      const { runDocReadCommand } = await import("./docReadCommands-JN6HL4BC.js");
       return runDocReadCommand(args, deps);
     }),
     createEnvCommand(["doc", "update"], "Update a normal doc", async (args, deps) => {
-      const { runDocUpdateCommand } = await import("./docUpdateCommands-62WIRKAN.js");
+      const { runDocUpdateCommand } = await import("./docUpdateCommands-EYE7BTXW.js");
       return runDocUpdateCommand(args, deps);
     }),
     createEnvCommand(["doc", "delete"], "Delete a normal doc", async (args, deps) => {
-      const { runDocDeleteCommand } = await import("./docDeleteCommands-AJDU5BUV.js");
+      const { runDocDeleteCommand } = await import("./docDeleteCommands-KZZ3L6LS.js");
       return runDocDeleteCommand(args, deps);
     }),
     createEnvCommand(["skill-doc", "create"], "Create a skill-backed doc", async (args, deps) => {
-      const { runSkillDocCreateCommand } = await import("./docCreateCommands-BKCYZTJW.js");
+      const { runSkillDocCreateCommand } = await import("./docCreateCommands-P4XCR2SW.js");
       return runSkillDocCreateCommand(args, deps);
     }),
     createEnvCommand(["skill", "create-doc"], "Create a skill-backed doc", async (args, deps) => {
-      const { runSkillDocCreateCommand } = await import("./docCreateCommands-BKCYZTJW.js");
+      const { runSkillDocCreateCommand } = await import("./docCreateCommands-P4XCR2SW.js");
       return runSkillDocCreateCommand(args, deps);
     }),
     createEnvCommand(["skill-doc", "read"], "Read a skill doc", async (args, deps) => {
-      const { runSkillDocReadCommand } = await import("./docReadCommands-PPI2UAIW.js");
+      const { runSkillDocReadCommand } = await import("./docReadCommands-JN6HL4BC.js");
       return runSkillDocReadCommand(args, deps);
     }),
     createEnvCommand(["skill-doc", "update"], "Update a skill doc", async (args, deps) => {
-      const { runSkillDocUpdateCommand } = await import("./docUpdateCommands-62WIRKAN.js");
+      const { runSkillDocUpdateCommand } = await import("./docUpdateCommands-EYE7BTXW.js");
       return runSkillDocUpdateCommand(args, deps);
     }),
     createEnvCommand(["skill-doc", "delete"], "Delete a skill doc", async (args, deps) => {
-      const { runSkillDocDeleteCommand } = await import("./docDeleteCommands-AJDU5BUV.js");
+      const { runSkillDocDeleteCommand } = await import("./docDeleteCommands-KZZ3L6LS.js");
       return runSkillDocDeleteCommand(args, deps);
     })
   ];
@@ -407,19 +407,19 @@ function getMemoryInternalCommandEntries() {
 function getSpaceInternalCommandEntries() {
   return [
     createEnvCommand(["space", "create"], "Create a space", async (args, deps) => {
-      const { runSpaceCreateCommand } = await import("./spaceCommands-BBEY2U7J.js");
+      const { runSpaceCreateCommand } = await import("./spaceCommands-QCZUWUMS.js");
       return runSpaceCreateCommand(args, deps);
     }),
     createEnvCommand(["space", "invite"], "Invite an existing user to a space", async (args, deps) => {
-      const { runSpaceInviteCommand } = await import("./spaceCommands-BBEY2U7J.js");
+      const { runSpaceInviteCommand } = await import("./spaceCommands-QCZUWUMS.js");
       return runSpaceInviteCommand(args, deps);
     }),
     createEnvCommand(["space", "accept-invite"], "Accept a space invite", async (args, deps) => {
-      const { runSpaceAcceptInviteCommand } = await import("./spaceCommands-BBEY2U7J.js");
+      const { runSpaceAcceptInviteCommand } = await import("./spaceCommands-QCZUWUMS.js");
       return runSpaceAcceptInviteCommand(args, deps);
     }),
     createEnvCommand(["space", "upload"], "Upload a file to a space", async (args, deps) => {
-      const { runSpaceUploadCommand } = await import("./spaceCommands-BBEY2U7J.js");
+      const { runSpaceUploadCommand } = await import("./spaceCommands-QCZUWUMS.js");
       return runSpaceUploadCommand(args, deps);
     })
   ];
@@ -433,31 +433,31 @@ function getSystemInternalCommandEntries(renderHelpText2) {
       return runAuthCooldownCommand(_args, ctx.env);
     }),
     createArgsCommand(["auth", "cloudflare"], "Authorize Cloudflare OAuth", async (args) => {
-      const { runAuthCloudflareCommand } = await import("./authCommand-I6LVUQKM.js");
+      const { runAuthCloudflareCommand } = await import("./authCommand-NQPMGYHP.js");
       return runAuthCloudflareCommand(args);
     }),
     createArgsCommand(["auth", "chatgpt"], "Authorize ChatGPT / OpenAI Codex OAuth", async (args) => {
-      const { runAuthChatgptCommand } = await import("./authCommand-I6LVUQKM.js");
+      const { runAuthChatgptCommand } = await import("./authCommand-NQPMGYHP.js");
       return runAuthChatgptCommand(args);
     }),
     createArgsCommand(["auth", "xai"], "Authorize xAI Grok OAuth (SuperGrok subscription)", async (args) => {
-      const { runAuthXaiCommand } = await import("./authCommand-I6LVUQKM.js");
+      const { runAuthXaiCommand } = await import("./authCommand-NQPMGYHP.js");
       return runAuthXaiCommand(args);
     }),
     createArgsCommand(["auth", "antigravity"], "Authorize Google Antigravity OAuth", async (args) => {
-      const { runAuthAntigravityCommand } = await import("./authCommand-I6LVUQKM.js");
+      const { runAuthAntigravityCommand } = await import("./authCommand-NQPMGYHP.js");
       return runAuthAntigravityCommand(args);
     }),
     createArgsCommand(["auth", "claude"], "Authorize Claude Pro/Max OAuth", async (args) => {
-      const { runAuthClaudeCommand } = await import("./authCommand-I6LVUQKM.js");
+      const { runAuthClaudeCommand } = await import("./authCommand-NQPMGYHP.js");
       return runAuthClaudeCommand(args);
     }),
     createArgsCommand(["auth", "cursor"], "Authorize Cursor Pro OAuth", async (args) => {
-      const { runAuthCursorCommand } = await import("./authCommand-I6LVUQKM.js");
+      const { runAuthCursorCommand } = await import("./authCommand-NQPMGYHP.js");
       return runAuthCursorCommand(args);
     }),
     createArgsCommand(["auth", "devin"], "Authorize Devin OAuth (Free SWE-2)", async (args) => {
-      const { runAuthDevinCommand } = await import("./authCommand-I6LVUQKM.js");
+      const { runAuthDevinCommand } = await import("./authCommand-NQPMGYHP.js");
       return runAuthDevinCommand(args);
     }),
     createArgsCommand(["login"], "Log in to Nolo", async (args) => {
@@ -473,15 +473,15 @@ function getSystemInternalCommandEntries(renderHelpText2) {
       return runWhoamiCommand({ args, env: ctx.env });
     }),
     createEntrypointEnvCommand(["connect"], "Send machine heartbeats or hold a connector websocket", async (args, deps) => {
-      const { runMachineConnectCommand } = await import("./machineCommands-FG6HBFB7.js");
+      const { runMachineConnectCommand } = await import("./machineCommands-4LP4XFEY.js");
       return runMachineConnectCommand(args, deps);
     }),
     createDaemonShortcutCommand(["daemon"], "Run the connector daemon shortcut", async (args, deps) => {
-      const { runMachineConnectCommand } = await import("./machineCommands-FG6HBFB7.js");
+      const { runMachineConnectCommand } = await import("./machineCommands-4LP4XFEY.js");
       return runMachineConnectCommand(args, deps);
     }),
     createEnvCommand(["machine", "status"], "List machines registered to the current profile", async (args, deps) => {
-      const { runMachineStatusCommand } = await import("./machineCommands-FG6HBFB7.js");
+      const { runMachineStatusCommand } = await import("./machineCommands-4LP4XFEY.js");
       return runMachineStatusCommand(args, deps);
     }),
     createEnvCommand(["doctor", "runtime"], "Diagnose local-first agent runtime selection", async (args, deps) => {

package/{contentThunks-CH5Z3XAD.js → contentThunks-HEEW3GBT.js}

@@ -7,14 +7,14 @@ import {
   updateContentPinned,
   updateContentTitle,
   uploadAndAddFileToSpace
-} from "./chunk-GJ647AYV.js";
+} from "./chunk-REPRKRB2.js";
 import "./chunk-ZJ7UHBJS.js";
-import "./chunk-NMMU6M4Z.js";
+import "./chunk-GLD6Q25H.js";
 import "./chunk-YYLHWIW6.js";
 import "./chunk-CUF4MYKI.js";
 import "./chunk-523DITKR.js";
 import "./chunk-AGGIDPCZ.js";
-import "./chunk-TAPMD4SO.js";
+import "./chunk-JVP74JRH.js";
 import "./chunk-2K4TM6AW.js";
 import "./chunk-5RGU3J7P.js";
 import "./chunk-ZRAU6T47.js";

package/{createAgentAutomationAction-4MV3MWVE.js → createAgentAutomationAction-C5UTM2ZI.js}

@@ -1,13 +1,13 @@
 import {
   addContentToSpace
-} from "./chunk-GJ647AYV.js";
+} from "./chunk-REPRKRB2.js";
 import "./chunk-ZJ7UHBJS.js";
-import "./chunk-NMMU6M4Z.js";
+import "./chunk-GLD6Q25H.js";
 import "./chunk-YYLHWIW6.js";
 import "./chunk-CUF4MYKI.js";
 import "./chunk-523DITKR.js";
 import "./chunk-AGGIDPCZ.js";
-import "./chunk-TAPMD4SO.js";
+import "./chunk-JVP74JRH.js";
 import "./chunk-2K4TM6AW.js";
 import "./chunk-5RGU3J7P.js";
 import "./chunk-ZRAU6T47.js";