nolo-cli 0.138.0-alpha.1 → 0.140.0-alpha.1

package/{handleSendMessageAction-2AF42N6F.js → handleSendMessageAction-HAVG5ANU.js}

@@ -1,26 +1,39 @@
 import {
   scanValidationDetails
 } from "./chunk-BMQ2MJUK.js";
+import {
+  buildForegroundTurnAdmissionFetchInit,
+  consumeAgentRunStream
+} from "./chunk-PWOXYPE6.js";
 import {
   CONTEXT_OVERFLOW_ACTIONS,
   CONTEXT_TOO_LARGE_ACTIONS,
   isContextOverflowText
 } from "./chunk-OCZKATRC.js";
 import {
+  performServerProxyFetchWithRetry
+} from "./chunk-6OTOA5MH.js";
+import {
+  createSSEParser,
   waitForAbortableDelay
-} from "./chunk-N4G4PKQ6.js";
+} from "./chunk-GOMR6S5Z.js";
+import "./chunk-NF64D32W.js";
+import "./chunk-3L2WKC3W.js";
 import {
+  initMsgs,
   messageStreamEnd,
+  messageStreaming,
   prepareAndPersistUserMessage,
+  removeTransientMessage,
   resolveHandleSendMessageContext,
   selectAllMsgs
-} from "./chunk-FSEVS4U3.js";
+} from "./chunk-KFMLZ3B5.js";
 import "./chunk-MC4XLIJ7.js";
 import "./chunk-YYLHWIW6.js";
 import "./chunk-6O4IK4V2.js";
 import {
   streamAgentChatTurn
-} from "./chunk-PA2BRUNR.js";
+} from "./chunk-QFDNAM7T.js";
 import "./chunk-D76D3RTR.js";
 import "./chunk-5RGU3J7P.js";
 import "./chunk-M76ECQRD.js";
@@ -45,9 +58,14 @@ import "./chunk-W7XHHYWM.js";
 import "./chunk-B7ANJQWZ.js";
 import "./chunk-UAD2WT54.js";
 import "./chunk-HNGRBWYF.js";
+import {
+  canonicalizeToolName
+} from "./chunk-O6OSWFZQ.js";
 import "./chunk-ACTMNVHM.js";
 import "./chunk-Q67DOFOO.js";
-import "./chunk-3IYMTWYZ.js";
+import {
+  selectCurrentServer
+} from "./chunk-3IYMTWYZ.js";
 import "./chunk-Y5GCAMGP.js";
 import "./chunk-QDSINZM3.js";
 import "./chunk-KX6YBIHG.js";
@@ -63,8 +81,13 @@ import "./chunk-WWC7I6TA.js";
 import "./chunk-QSJ3HFEF.js";
 import "./chunk-EFZKILX6.js";
 import "./chunk-AUXHZ2M5.js";
-import "./chunk-QOKAKDPE.js";
-import "./chunk-SEJ5OS6F.js";
+import {
+  getIsDesktopApp
+} from "./chunk-QOKAKDPE.js";
+import {
+  selectIdentityToken,
+  selectIdentityUserId
+} from "./chunk-SEJ5OS6F.js";
 import "./chunk-OW765XBU.js";
 import "./chunk-GBRG75BQ.js";
 import "./chunk-KUG52IAP.js";
@@ -80,6 +103,344 @@ import "./chunk-CF7PE763.js";
 import "./chunk-G3SUCT4W.js";
 import "./chunk-4VNS5WPM.js";
 
+// packages/ai/agent/serverOwnedWebForegroundEligibility.ts
+var FIRST_DURABLE_WEB_TOOL = "ask_user";
+function readToolName(value) {
+  if (typeof value === "string") {
+    const name2 = value.trim();
+    return name2 || null;
+  }
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  const candidate = typeof record.name === "string" && record.name || typeof record.toolName === "string" && record.toolName || typeof record.function?.name === "string" && record.function.name || "";
+  const name = candidate.trim();
+  return name || null;
+}
+function configuredToolNames(agent) {
+  const values = [];
+  if (Array.isArray(agent.tools)) values.push(...agent.tools);
+  if (Array.isArray(agent.toolNames)) values.push(...agent.toolNames);
+  const policies = [
+    agent.runtimeToolPolicy,
+    agent.runtimeBinding?.runtimeToolPolicy,
+    agent.runtimeBinding?.runtimeToolPolicySnapshot
+  ];
+  for (const policy of policies) {
+    if (!policy || typeof policy !== "object") continue;
+    if (Array.isArray(policy.agentTools)) values.push(...policy.agentTools);
+    if (Array.isArray(policy.runtimeTools)) values.push(...policy.runtimeTools);
+  }
+  return [...new Set(values.map(readToolName).filter((name) => !!name))];
+}
+function hasSupportedDurableToolSurface(agent) {
+  const policies = [
+    agent.runtimeToolPolicy,
+    agent.runtimeBinding?.runtimeToolPolicy,
+    agent.runtimeBinding?.runtimeToolPolicySnapshot
+  ];
+  if (policies.some(
+    (policy) => policy && typeof policy === "object" && (policy.shell?.enabled === true || policy.workspace?.mode === "lease")
+  )) {
+    return false;
+  }
+  const names = configuredToolNames(agent);
+  return names.length === 0 || names.every((name) => name === FIRST_DURABLE_WEB_TOOL);
+}
+function shouldUseServerOwnedWebForegroundTurn(input) {
+  if (input.isDesktopApp) return false;
+  if (!input.currentServer?.trim() || !input.token?.trim()) return false;
+  if (typeof input.userInput !== "string" || !input.userInput.trim()) return false;
+  const agent = input.agentConfig;
+  if (!agent) return false;
+  if (agent.useServerProxy === false) return false;
+  if (agent.apiSource === "cli") return false;
+  if (agent.runtimeBinding?.machineId) return false;
+  if (!hasSupportedDurableToolSurface(agent)) return false;
+  const runtimeOptions = input.runtimeOptions;
+  if (runtimeOptions?.extraTools?.length) return false;
+  if (runtimeOptions?.editingTarget) return false;
+  if (runtimeOptions?.imageConfigOverride) return false;
+  if (runtimeOptions?.quickChatModelOverride) return false;
+  if (runtimeOptions?.workspaceToolsHint) return false;
+  if (runtimeOptions?.cwd) return false;
+  if (runtimeOptions?.restrictShellToWorkspace) return false;
+  return true;
+}
+
+// packages/ai/agent/serverOwnedAskUserProjection.ts
+function parseToolArgs(raw) {
+  if (typeof raw !== "string" || !raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function createServerOwnedAskUserProjection(args) {
+  const transientByCallId = /* @__PURE__ */ new Map();
+  const handlePayload = (payload) => {
+    if (!payload || typeof payload !== "object") return;
+    if (payload.type === "assistant_tool_calls") {
+      const calls = Array.isArray(payload.tool_calls) ? payload.tool_calls : [];
+      for (const call of calls) {
+        const callId = typeof call?.id === "string" ? call.id : "";
+        const toolName = canonicalizeToolName(call?.function?.name ?? "");
+        if (!callId || toolName !== "ask_user") continue;
+        if (transientByCallId.has(callId)) continue;
+        const { key, messageId } = createDialogMessageKeyAndId(args.dialogId);
+        const input = parseToolArgs(call?.function?.arguments);
+        const message = {
+          id: messageId,
+          dialogId: args.dialogId,
+          dbKey: key,
+          role: "tool",
+          // Pending args, not a tool result: the panel renders the question card
+          // from `content`, so a single-question call (question + choices, no
+          // `questions`) would otherwise render as an empty row until the
+          // tool_result arrives. The canonical payload replaces this on done.
+          content: JSON.stringify({ type: "ask_user", ...input }),
+          isStreaming: true,
+          toolName: "ask_user",
+          toolCallId: callId,
+          toolPayload: {
+            toolName: "ask_user",
+            status: "running",
+            input,
+            rawToolCall: call,
+            summary: ""
+          },
+          ...args.messageMetadata
+        };
+        transientByCallId.set(callId, message);
+        args.dispatch(messageStreaming(message));
+      }
+      return;
+    }
+    if (payload.type === "tool_result") {
+      const callId = typeof payload.toolCallId === "string" ? payload.toolCallId : "";
+      const existing = transientByCallId.get(callId);
+      if (!existing || canonicalizeToolName(payload.toolName ?? existing.toolName) !== "ask_user") {
+        return;
+      }
+      const message = {
+        ...existing,
+        content: typeof payload.content === "string" ? payload.content : "",
+        // Keep read-only until canonical server persistence is reloaded.
+        isStreaming: true,
+        toolPayload: {
+          ...existing.toolPayload ?? {},
+          status: "running"
+        }
+      };
+      transientByCallId.set(callId, message);
+      args.dispatch(messageStreaming(message));
+    }
+  };
+  const cleanup = () => {
+    for (const message of transientByCallId.values()) {
+      args.dispatch(
+        removeTransientMessage({ id: message.id, dialogId: args.dialogId })
+      );
+    }
+    transientByCallId.clear();
+  };
+  return { handlePayload, cleanup, transientByCallId };
+}
+
+// packages/ai/agent/serverOwnedWebForegroundTurn.ts
+async function canRunServerOwnedWebForegroundTurn(args, thunk) {
+  let agentConfig = args.agentConfig ?? void 0;
+  if (!agentConfig) {
+    try {
+      const { readAndWait: readAndWait2 } = await import("./dbSlice-HFPIJT5P.js");
+      agentConfig = await thunk.dispatch(readAndWait2(args.agentKey)).unwrap();
+    } catch {
+      return { eligible: false };
+    }
+  }
+  const state = thunk.getState();
+  const currentServer = selectCurrentServer(state);
+  const token = selectIdentityToken(state);
+  return {
+    eligible: shouldUseServerOwnedWebForegroundTurn({
+      agentConfig,
+      userInput: args.userInput,
+      runtimeOptions: args.runtimeOptions,
+      currentServer,
+      token,
+      isDesktopApp: getIsDesktopApp()
+    }),
+    agentConfig
+  };
+}
+async function runServerOwnedWebForegroundTurn(args, thunk) {
+  const state = thunk.getState();
+  const currentServer = String(selectCurrentServer(state) ?? "").replace(/\/+$/, "");
+  const token = selectIdentityToken(state);
+  if (!currentServer || !token) {
+    throw new Error("Server-owned foreground turn requires an authenticated server");
+  }
+  const dialogKey = args.dialogConfig.dbKey;
+  const dialogId = args.dialogConfig.id ?? (dialogKey ? extractCustomId(dialogKey) : "");
+  if (!dialogId || !dialogKey) {
+    throw new Error("Server-owned foreground turn requires an existing dialog");
+  }
+  const userInput = typeof args.userInput === "string" ? args.userInput : "";
+  if (!userInput.trim()) {
+    throw new Error("Server-owned foreground turn requires text input");
+  }
+  const userId = selectIdentityUserId(thunk.getState());
+  const { key: transientKey, messageId: transientId } = createDialogMessageKeyAndId(dialogId);
+  const controller = new AbortController();
+  const loopKey = `server-owned:${dialogId}:${transientId}`;
+  let accumulated = "";
+  const askUserProjection = createServerOwnedAskUserProjection({
+    dialogId,
+    dispatch: thunk.dispatch,
+    messageMetadata: {
+      cybotKey: args.agentKey,
+      agentKey: args.agentKey,
+      userId
+    }
+  });
+  thunk.dispatch(
+    addActiveController({
+      messageId: loopKey,
+      controller,
+      dialogKey
+    })
+  );
+  thunk.dispatch(
+    messageStreaming({
+      id: transientId,
+      dialogId,
+      dbKey: transientKey,
+      role: "assistant",
+      content: "",
+      cybotKey: args.agentKey,
+      agentKey: args.agentKey,
+      userId
+    })
+  );
+  const body = JSON.stringify({
+    agentKey: args.agentKey,
+    userInput,
+    stream: true,
+    persistDialog: true,
+    continueDialogId: dialogId,
+    runtimeContext: {
+      surface: "web",
+      host: "browser",
+      runtime: "react",
+      entrypoint: "chat-dialog-server-owned",
+      capabilities: [
+        "streaming",
+        "dialog-ui",
+        "durable-foreground",
+        "client-user-prepersisted",
+        "ask-user-tool-card"
+      ],
+      ...args.dialogConfig.agentMode === "auto" ? { dialogAgentMode: "auto" } : { dialogAgentMode: "fixed" }
+    },
+    ...args.runtimeOptions ? { runtimeOptions: args.runtimeOptions } : {},
+    ...args.contextBlocks?.length ? { contextBlocks: args.contextBlocks } : {},
+    ...args.dialogConfig.spaceId ? { spaceId: args.dialogConfig.spaceId } : {}
+  });
+  const init = buildForegroundTurnAdmissionFetchInit({
+    body,
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream",
+      Authorization: `Bearer ${token}`
+    },
+    signal: controller.signal
+  });
+  try {
+    let response;
+    try {
+      response = await performServerProxyFetchWithRetry({
+        execute: () => fetch(`${currentServer}/api/agent/run`, init),
+        signal: controller.signal,
+        // This is an at-most-once foreground admission. A network error is
+        // ambiguous: the server may already own the execution, so never POST it again.
+        retryNetworkErrors: false,
+        logPrefix: "[serverOwnedWebForegroundTurn]"
+      });
+    } catch (error) {
+      if (controller.signal.aborted) return { serverOwned: true, aborted: true };
+      console.warn("[chat] server-owned foreground detached before response", {
+        dialogId,
+        error
+      });
+      return { serverOwned: true, detached: true };
+    }
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(text || `Agent run failed (${response.status})`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      return { serverOwned: true, detached: true };
+    }
+    const parseSSE = createSSEParser();
+    const decoder = new TextDecoder();
+    const outcome = await consumeAgentRunStream({
+      reader,
+      decoder,
+      parseChunk: (raw) => parseSSE(raw),
+      isAborted: () => controller.signal.aborted,
+      signal: controller.signal,
+      isDoneEvent: (payload) => payload?.type === "done",
+      onAbort: async () => {
+      },
+      onPayload: (payload) => {
+        if (payload?.type === "error") {
+          return { reject: payload.message || "Agent execution failed" };
+        }
+        askUserProjection.handlePayload(payload);
+        if (payload?.type === "text" && typeof payload.content === "string") {
+          accumulated += payload.content;
+          thunk.dispatch(
+            messageStreaming({
+              id: transientId,
+              dialogId,
+              dbKey: transientKey,
+              role: "assistant",
+              content: accumulated,
+              cybotKey: args.agentKey,
+              agentKey: args.agentKey,
+              userId
+            })
+          );
+        }
+      }
+    });
+    if (outcome.outcome === "aborted") {
+      return { serverOwned: true, aborted: true };
+    }
+    if (outcome.outcome === "rejected") {
+      throw new Error(outcome.message);
+    }
+    if (!outcome.sawDone) {
+      return { serverOwned: true, detached: true };
+    }
+    askUserProjection.cleanup();
+    thunk.dispatch(removeTransientMessage({ id: transientId, dialogId }));
+    await thunk.dispatch(initMsgs({ dialogId })).unwrap();
+    return { serverOwned: true };
+  } finally {
+    thunk.dispatch(
+      removeActiveController({
+        messageId: loopKey,
+        dialogKey
+      })
+    );
+    askUserProjection.cleanup();
+    thunk.dispatch(removeTransientMessage({ id: transientId, dialogId }));
+  }
+}
+
 // packages/chat/dialog/actions/parseOAuthError.ts
 var PROVIDER_NAMES = {
   antigravity: "Antigravity (Google)",
@@ -568,6 +929,36 @@ var handleSendMessageAction = async (args, { dispatch, getState, rejectWithValue
     const userInputText = typeof effectiveRawUserInput === "string" ? effectiveRawUserInput : "";
     const isDesktopContext = typeof window !== "undefined" && typeof location !== "undefined" && (location.hostname === "127.0.0.1" || location.hostname === "localhost");
     const browseContextPrefix = isDesktopContext ? await resolveBrowseContextPrefix(userInputText) : "";
+    const serverOwnedCandidate = await canRunServerOwnedWebForegroundTurn(
+      {
+        agentKey: agentKeyToUse,
+        agentConfig: agentConfigToUse,
+        userInput: effectiveRawUserInput,
+        dialogConfig,
+        runtimeOptions: effectiveRuntimeOptions,
+        contextBlocks: browseContextPrefix ? [browseContextPrefix] : void 0
+      },
+      { dispatch, getState }
+    );
+    if (serverOwnedCandidate.eligible && serverOwnedCandidate.agentConfig) {
+      const serverOwnedResult = await runServerOwnedWebForegroundTurn(
+        {
+          agentKey: agentKeyToUse,
+          agentConfig: serverOwnedCandidate.agentConfig,
+          userInput: effectiveRawUserInput,
+          dialogConfig,
+          runtimeOptions: effectiveRuntimeOptions,
+          contextBlocks: browseContextPrefix ? [browseContextPrefix] : void 0
+        },
+        { dispatch, getState }
+      );
+      if (serverOwnedResult.aborted || serverOwnedResult.detached) return;
+      logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-server-owned-finished", {
+        dialogKey: dialogConfig.dbKey,
+        agentKey: agentKeyToUse
+      });
+      return;
+    }
     const effectiveUserInput = browseContextPrefix ? `${browseContextPrefix}
 
 ${userInputText}` : effectiveRawUserInput ?? "";

package/index.js

@@ -71,7 +71,7 @@ async function runScript(script, forwardedArgs, env) {
   return proc.exited;
 }
 async function launchTuiWorkspace(args2) {
-  const { startTuiWorkspace } = await import("./readlineWorkspace-HDAVBAL5.js");
+  const { startTuiWorkspace } = await import("./readlineWorkspace-AGIDALGO.js");
   const { createTuiSummaryLlmCaller } = await import("./tuiSummaryLlmCaller-W36LJRZU.js");
   return startTuiWorkspace({
     ...args2,
@@ -81,7 +81,7 @@ async function launchTuiWorkspace(args2) {
   });
 }
 async function main() {
-  const { createCliRuntimeContext, looksLikeDaemonShortcut, renderHelpText, resolveCommand, runResolvedCommand } = await import("./commandRegistry-DMS5KFOK.js");
+  const { createCliRuntimeContext, looksLikeDaemonShortcut, renderHelpText, resolveCommand, runResolvedCommand } = await import("./commandRegistry-XMFDAEN3.js");
   const { buildCliRuntimeEnv, loadProfileConfig } = await import("./profileConfig-ZGOFORWV.js");
   const { resolveTuiLaunchMode } = await import("./runtimeModeArgs-2Y7BALTO.js");
   const runtimeEnv = {

package/{machineCommands-ZY5BB4O3.js → machineCommands-WDAQIYYL.js}

@@ -2,13 +2,13 @@ import {
   buildMachinePermissionPromptBlock,
   handleConnectorRunMessage,
   resolveMachineRunPermissionPolicy
-} from "./chunk-MLXQO7X4.js";
+} from "./chunk-C6EZXUCB.js";
 import {
   isConnectorWebSocketAuthError,
   isConnectorWebSocketRetryableError,
   resolveConnectorWebSocketTarget
 } from "./chunk-ALXHV7NK.js";
-import "./chunk-TNYKI3LI.js";
+import "./chunk-44YE37DR.js";
 import "./chunk-XSW2IKJM.js";
 import "./chunk-OY5IJI2N.js";
 import "./chunk-62IL3KQV.js";
@@ -25,35 +25,35 @@ import "./chunk-4XEYAFLY.js";
 import "./chunk-JBTJAPUF.js";
 import "./chunk-QJLEMM2V.js";
 import "./chunk-ATNTHIZI.js";
-import "./chunk-J2RGIFX5.js";
+import "./chunk-UOCZAVYF.js";
 import "./chunk-HS7MLR74.js";
-import "./chunk-KQW2EHWB.js";
-import "./chunk-NF64D32W.js";
+import "./chunk-RY3FI23Y.js";
 import "./chunk-YSC3EI23.js";
 import "./chunk-5UTFL4QJ.js";
+import "./chunk-KQHGZWSV.js";
+import "./chunk-GOMR6S5Z.js";
+import "./chunk-NF64D32W.js";
 import {
   CORE_DRAIN_REASON
 } from "./chunk-3L2WKC3W.js";
-import "./chunk-KQHGZWSV.js";
-import "./chunk-N4G4PKQ6.js";
 import "./chunk-3VNWWVKB.js";
-import "./chunk-27YNIIBN.js";
+import "./chunk-NRXXVGOQ.js";
 import "./chunk-HNRASX3X.js";
 import "./chunk-YRRASA5Q.js";
 import "./chunk-63W5N6P3.js";
 import "./chunk-VF4K2QE6.js";
-import "./chunk-ZTQANKS2.js";
+import "./chunk-AA2TX625.js";
 import "./chunk-Z7IZQF56.js";
 import "./chunk-XPRWFQQK.js";
 import "./chunk-BJUDYFV5.js";
 import "./chunk-MEYIRKDN.js";
-import "./chunk-ZWJ6WQBO.js";
+import "./chunk-AR7XM7CQ.js";
 import "./chunk-ZJ7UHBJS.js";
-import "./chunk-FSEVS4U3.js";
+import "./chunk-KFMLZ3B5.js";
 import "./chunk-MC4XLIJ7.js";
 import "./chunk-YYLHWIW6.js";
 import "./chunk-6O4IK4V2.js";
-import "./chunk-PA2BRUNR.js";
+import "./chunk-QFDNAM7T.js";
 import "./chunk-D76D3RTR.js";
 import "./chunk-5RGU3J7P.js";
 import "./chunk-M76ECQRD.js";
@@ -71,7 +71,7 @@ import "./chunk-KHCLMKZZ.js";
 import {
   PATH_FIELD_ALIASES,
   createLocalWorkspaceToolExecutors
-} from "./chunk-IEEGKL6X.js";
+} from "./chunk-YBUA6LCU.js";
 import "./chunk-VG72WLGI.js";
 import "./chunk-ZNFJWEN4.js";
 import "./chunk-6JPUN447.js";

package/{machineWsRunDispatch-5XE37H4C.js → machineWsRunDispatch-Y3MHLPCI.js}

@@ -11,8 +11,8 @@ import {
   runtimeWorkspacePermissionPolicy,
   scopePermissionPolicyToRuntimeWorkspace,
   summarizeAgentConfigForLogs
-} from "./chunk-MLXQO7X4.js";
-import "./chunk-TNYKI3LI.js";
+} from "./chunk-C6EZXUCB.js";
+import "./chunk-44YE37DR.js";
 import "./chunk-XSW2IKJM.js";
 import "./chunk-OY5IJI2N.js";
 import "./chunk-62IL3KQV.js";
@@ -26,33 +26,33 @@ import "./chunk-4XEYAFLY.js";
 import "./chunk-JBTJAPUF.js";
 import "./chunk-QJLEMM2V.js";
 import "./chunk-ATNTHIZI.js";
-import "./chunk-J2RGIFX5.js";
+import "./chunk-UOCZAVYF.js";
 import "./chunk-HS7MLR74.js";
-import "./chunk-KQW2EHWB.js";
-import "./chunk-NF64D32W.js";
+import "./chunk-RY3FI23Y.js";
 import "./chunk-YSC3EI23.js";
 import "./chunk-5UTFL4QJ.js";
-import "./chunk-3L2WKC3W.js";
 import "./chunk-KQHGZWSV.js";
-import "./chunk-N4G4PKQ6.js";
+import "./chunk-GOMR6S5Z.js";
+import "./chunk-NF64D32W.js";
+import "./chunk-3L2WKC3W.js";
 import "./chunk-3VNWWVKB.js";
-import "./chunk-27YNIIBN.js";
+import "./chunk-NRXXVGOQ.js";
 import "./chunk-HNRASX3X.js";
 import "./chunk-YRRASA5Q.js";
 import "./chunk-63W5N6P3.js";
 import "./chunk-VF4K2QE6.js";
-import "./chunk-ZTQANKS2.js";
+import "./chunk-AA2TX625.js";
 import "./chunk-Z7IZQF56.js";
 import "./chunk-XPRWFQQK.js";
 import "./chunk-BJUDYFV5.js";
 import "./chunk-MEYIRKDN.js";
-import "./chunk-ZWJ6WQBO.js";
+import "./chunk-AR7XM7CQ.js";
 import "./chunk-ZJ7UHBJS.js";
-import "./chunk-FSEVS4U3.js";
+import "./chunk-KFMLZ3B5.js";
 import "./chunk-MC4XLIJ7.js";
 import "./chunk-YYLHWIW6.js";
 import "./chunk-6O4IK4V2.js";
-import "./chunk-PA2BRUNR.js";
+import "./chunk-QFDNAM7T.js";
 import "./chunk-D76D3RTR.js";
 import "./chunk-5RGU3J7P.js";
 import "./chunk-M76ECQRD.js";
@@ -67,7 +67,7 @@ import "./chunk-J5H6SUOW.js";
 import "./chunk-WC6A2Q7S.js";
 import "./chunk-AUDNYVRC.js";
 import "./chunk-KHCLMKZZ.js";
-import "./chunk-IEEGKL6X.js";
+import "./chunk-YBUA6LCU.js";
 import "./chunk-VG72WLGI.js";
 import "./chunk-ZNFJWEN4.js";
 import "./chunk-6JPUN447.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.138.0-alpha.1",
+  "version": "0.140.0-alpha.1",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {