nolo-cli 0.1.55 → 0.1.56

package/index.js

@@ -1306,66 +1306,158 @@ async function connectCliAuthorityBroker(args2) {
     ...defaultCliAuthorityBrokerConnectDeps,
     ...args2.deps
   };
-  const client = deps.createClient({
-    endpoint: args2.endpoint,
-    invoke: createCliAuthorityBrokerSocketInvoker({ endpoint: args2.endpoint })
-  });
-  async function attachToExistingBroker(attempts) {
-    for (let attempt = 0; attempt < attempts; attempt += 1) {
-      await deps.sleep(100);
-      try {
-        await client.open();
-        return true;
-      } catch (error) {
-        if (!isCliAuthorityBrokerUnavailableError(error)) throw error;
-      }
-    }
-    return false;
-  }
-  try {
-    await deps.startBroker({
+  async function connectClient() {
+    const client2 = deps.createClient({
       endpoint: args2.endpoint,
-      metadataPath: args2.metadataPath,
-      healthPath: args2.healthPath,
-      createStore: () => createLevelAuthorityStore(args2.dbPath)
+      invoke: createCliAuthorityBrokerSocketInvoker({ endpoint: args2.endpoint })
     });
-    await client.open();
-    return client;
-  } catch (error) {
-    if (!isCliAuthorityLockError(error)) throw error;
-    if (await attachToExistingBroker(5)) {
-      return client;
+    async function attachToExistingBroker(attempts) {
+      for (let attempt = 0; attempt < attempts; attempt += 1) {
+        await deps.sleep(100);
+        try {
+          await client2.open();
+          return true;
+        } catch (error) {
+          if (!isCliAuthorityBrokerUnavailableError(error)) throw error;
+        }
+      }
+      return false;
     }
-    let lastError = error;
-    for (let attempt = 0; attempt < 5; attempt += 1) {
-      await deps.sleep(100);
-      try {
-        await deps.startBroker({
-          endpoint: args2.endpoint,
-          metadataPath: args2.metadataPath,
-          healthPath: args2.healthPath,
-          createStore: () => createLevelAuthorityStore(args2.dbPath)
-        });
-        await client.open();
-        return client;
-      } catch (retryError) {
-        lastError = retryError;
-        if (isCliAuthorityLockError(retryError)) {
-          if (await attachToExistingBroker(2)) {
-            return client;
+    try {
+      await deps.startBroker({
+        endpoint: args2.endpoint,
+        metadataPath: args2.metadataPath,
+        healthPath: args2.healthPath,
+        createStore: () => createLevelAuthorityStore(args2.dbPath)
+      });
+      await client2.open();
+      return client2;
+    } catch (error) {
+      if (!isCliAuthorityLockError(error)) throw error;
+      if (await attachToExistingBroker(5)) {
+        return client2;
+      }
+      let lastError = error;
+      for (let attempt = 0; attempt < 5; attempt += 1) {
+        await deps.sleep(100);
+        try {
+          await deps.startBroker({
+            endpoint: args2.endpoint,
+            metadataPath: args2.metadataPath,
+            healthPath: args2.healthPath,
+            createStore: () => createLevelAuthorityStore(args2.dbPath)
+          });
+          await client2.open();
+          return client2;
+        } catch (retryError) {
+          lastError = retryError;
+          if (isCliAuthorityLockError(retryError)) {
+            if (await attachToExistingBroker(2)) {
+              return client2;
+            }
+            continue;
           }
-          continue;
-        }
-        if (isCliAuthorityBrokerUnavailableError(retryError)) {
-          continue;
+          if (isCliAuthorityBrokerUnavailableError(retryError)) {
+            continue;
+          }
+          throw retryError;
         }
-        throw retryError;
       }
+      throw new Error(`CLI authority broker could not attach or take ownership for ${args2.endpoint}`, {
+        cause: lastError
+      });
+    }
+  }
+  let client = await connectClient();
+  let reconnecting = null;
+  async function reconnect() {
+    reconnecting ??= connectClient();
+    try {
+      client = await reconnecting;
+      return client;
+    } finally {
+      reconnecting = null;
     }
-    throw new Error(`CLI authority broker could not attach or take ownership for ${args2.endpoint}`, {
-      cause: lastError
-    });
   }
+  async function runWithSelfHealing(operation) {
+    try {
+      return await operation(client);
+    } catch (error) {
+      if (!isCliAuthorityBrokerUnavailableError(error)) throw error;
+      const recoveredClient = await reconnect();
+      return operation(recoveredClient);
+    }
+  }
+  return {
+    get location() {
+      return client.location;
+    },
+    get status() {
+      return client.status;
+    },
+    open: () => runWithSelfHealing((activeClient) => activeClient.open()),
+    close: () => runWithSelfHealing((activeClient) => activeClient.close()),
+    get: (key) => runWithSelfHealing((activeClient) => activeClient.get(key)),
+    put: (key, value) => runWithSelfHealing((activeClient) => activeClient.put(key, value)),
+    del: (key) => runWithSelfHealing((activeClient) => activeClient.del(key)),
+    batchWrite: (ops) => runWithSelfHealing((activeClient) => activeClient.batchWrite(ops)),
+    createBatch() {
+      const ops = [];
+      return {
+        put(key, value) {
+          ops.push({ type: "put", key, value });
+        },
+        del(key) {
+          ops.push({ type: "del", key });
+        },
+        write: () => runWithSelfHealing((activeClient) => activeClient.batchWrite(ops))
+      };
+    },
+    iterator(options = {}) {
+      return async function* iterate() {
+        let activeOptions = options;
+        let lastYieldedKey;
+        let skipResumeKey = false;
+        let recovered = false;
+        while (true) {
+          try {
+            for await (const entry of client.iterator(activeOptions)) {
+              if (skipResumeKey && entry[0] === lastYieldedKey) {
+                skipResumeKey = false;
+                continue;
+              }
+              skipResumeKey = false;
+              lastYieldedKey = entry[0];
+              yield entry;
+            }
+            return;
+          } catch (error) {
+            if (recovered || !isCliAuthorityBrokerUnavailableError(error)) {
+              throw error;
+            }
+            recovered = true;
+            await reconnect();
+            if (lastYieldedKey === void 0) {
+              activeOptions = options;
+              continue;
+            }
+            if (options.reverse) {
+              activeOptions = {
+                ...options,
+                lt: lastYieldedKey
+              };
+              continue;
+            }
+            activeOptions = {
+              ...options,
+              gte: lastYieldedKey
+            };
+            skipResumeKey = true;
+          }
+        }
+      }();
+    }
+  };
 }
 async function getDefaultCliLocalRuntimeAuthority(options = {}) {
   const env = options.env ?? process.env;
@@ -1602,7 +1694,6 @@ var init_keys = __esm({
   "packages/share/keys.ts"() {
     "use strict";
     init_keys2();
-    init_types();
     init_toTrimmedString();
     init_userId();
     init_helpers();
@@ -5025,9 +5116,9 @@ function buildAgentRuntimeDialogWritePlan(args2) {
       existingDialog: args2.existingDialog,
       messages: args2.input.messages
     }),
-    status: "done",
+    status: args2.input.result.error === true ? "failed" : "done",
     triggerType: `${args2.runtimeHost}-local`,
-    executionMode: "foreground",
+    executionMode: args2.existingDialog?.executionMode ?? "foreground",
     createdAt: args2.existingDialog?.createdAt ?? nowIso,
     updatedAt: nowIso,
     finishedAt: args2.now,
@@ -8519,7 +8610,53 @@ async function resolveAgentRecordFromHybridStore(args2) {
   }
   return null;
 }
+function isNonEmptyCredentialValue(value) {
+  if (value == null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function agentRecordHasConfiguredCredential(record) {
+  if (!record || typeof record !== "object") return false;
+  if (Array.isArray(record)) {
+    return record.some(agentRecordHasConfiguredCredential);
+  }
+  for (const [key, value] of Object.entries(record)) {
+    const normalizedKey = normalizeCredentialFieldName(key);
+    if ((CLI_SECRET_FIELD_NAMES.has(normalizedKey) || CLI_CREDENTIAL_REF_FIELDS.has(normalizedKey)) && isNonEmptyCredentialValue(value)) {
+      return true;
+    }
+    if (typeof value === "object" && value != null && agentRecordHasConfiguredCredential(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function sanitizeAgentRecordForCliOutput(record) {
+  if (record == null || typeof record !== "object") return record;
+  if (Array.isArray(record)) {
+    return record.map((item) => sanitizeAgentRecordForCliOutput(item));
+  }
+  const source = record;
+  const out = {};
+  for (const [key, value] of Object.entries(source)) {
+    const normalizedKey = normalizeCredentialFieldName(key);
+    if (CLI_SECRET_FIELD_NAMES.has(normalizedKey)) continue;
+    if (CLI_CREDENTIAL_REF_FIELDS.has(normalizedKey)) {
+      if (isNonEmptyCredentialValue(value)) out[key] = value;
+      continue;
+    }
+    if (value != null && typeof value === "object") {
+      out[key] = sanitizeAgentRecordForCliOutput(value);
+      continue;
+    }
+    out[key] = value;
+  }
+  return out;
+}
 function normalizeAgentRecordForOutput(agentKey, authToken, agent) {
+  const credentialConfigured = agentRecordHasConfiguredCredential(agent);
+  const sanitizedRecord = sanitizeAgentRecordForCliOutput(agent);
   return {
     agentKey,
     baseUrl: agent?.serverOrigin ?? null,
@@ -8531,9 +8668,12 @@ function normalizeAgentRecordForOutput(agentKey, authToken, agent) {
     customProviderUrl: agent?.customProviderUrl ?? null,
     tools: agent?.tools ?? [],
     isPublic: agent?.isPublic,
+    credentialConfigured,
+    credentialRef: agent?.credentialRef ?? void 0,
+    apiKeyRef: agent?.apiKeyRef ?? void 0,
     authUserId: parseUserIdFromAuthToken(authToken),
     userId: agent?.userId,
-    record: agent
+    record: sanitizedRecord
   };
 }
 function parseAgentUpdateArgs(args2) {
@@ -8709,7 +8849,7 @@ async function buildUpdatedAgentRecord(args2) {
     updates: args2.parsed.updates
   };
 }
-var PROVIDER_COPY_FIELDS;
+var PROVIDER_COPY_FIELDS, CLI_SECRET_FIELD_NAMES, CLI_CREDENTIAL_REF_FIELDS, normalizeCredentialFieldName;
 var init_agentRecordHelpers = __esm({
   "packages/cli/agentRecordHelpers.ts"() {
     "use strict";
@@ -8732,6 +8872,26 @@ var init_agentRecordHelpers = __esm({
       "inputPrice",
       "outputPrice"
     ];
+    CLI_SECRET_FIELD_NAMES = /* @__PURE__ */ new Set([
+      "apikey",
+      "password",
+      "passwd",
+      "secret",
+      "clientsecret",
+      "accesstoken",
+      "refreshtoken",
+      "sessiontoken",
+      "bearertoken",
+      "authorization",
+      "authheader",
+      "token",
+      "oauthtoken",
+      "idtoken",
+      "credentials",
+      "credential"
+    ]);
+    CLI_CREDENTIAL_REF_FIELDS = /* @__PURE__ */ new Set(["credentialref", "apikeyref"]);
+    normalizeCredentialFieldName = (value) => value.replace(/[^a-z0-9]/gi, "").toLowerCase();
   }
 });
 
@@ -8779,26 +8939,36 @@ function ensureHeavyCliLocalRuntimeModules() {
   ({ fetchAntigravityCloudCodeCompletion } = requireFromAdapter(
     "../../agent-runtime/antigravityCloudCodeProvider.ts"
   ));
-  ({ isAntigravityOAuthAgent } = requireFromAdapter("../../agent-runtime/antigravityOAuth.ts"));
-  ({ readOAuthCredential: readOAuthCredential2 } = requireFromAdapter("../../agent-runtime/oauthTokenStore.ts"));
-  ({ getDefaultCliLocalRuntimeDb: getDefaultCliLocalRuntimeDb3 } = requireFromAdapter("../localRuntimeDb.ts"));
-  ({ resolveAgentRuntimeConfigFromRecord: resolveAgentRuntimeConfigFromRecord2 } = requireFromAdapter("./agentConfigResolver.ts"));
-  ({ resolveCliOpenAiProviderConfig } = requireFromAdapter("./localProviderResolver.ts"));
+  ({ isAntigravityOAuthAgent } = requireFromAdapter(
+    "../../agent-runtime/antigravityOAuth.ts"
+  ));
+  ({ readOAuthCredential: readOAuthCredential2 } = requireFromAdapter(
+    "../../agent-runtime/oauthTokenStore.ts"
+  ));
+  ({ getDefaultCliLocalRuntimeDb: getDefaultCliLocalRuntimeDb3 } = requireFromAdapter(
+    "../localRuntimeDb.ts"
+  ));
+  ({ resolveAgentRuntimeConfigFromRecord: resolveAgentRuntimeConfigFromRecord2 } = requireFromAdapter(
+    "./agentConfigResolver.ts"
+  ));
+  ({ resolveCliOpenAiProviderConfig } = requireFromAdapter(
+    "./localProviderResolver.ts"
+  ));
   ({ createFileCredentialBroker: createFileCredentialBroker2 } = requireFromAdapter(
     "../../agent-runtime/fileCredentialBroker.ts"
   ));
-  ({ createOAuthApiKeyRefResolver } = requireFromAdapter("../oauth/apiKeyRefResolver.ts"));
-  ({
-    buildLocalDialogWritePlan,
-    localDialogMessageRecordToRuntimeMessage
-  } = requireFromAdapter("./localDialogRecords.ts"));
-  ({
-    buildLocalAgentLookupKeys: buildLocalAgentLookupKeys2,
-    shouldReadAgentKeyRemotely: shouldReadAgentKeyRemotely2
-  } = requireFromAdapter("./localAgentRecords.ts"));
-  ({ createCliHybridRecordStore } = requireFromAdapter("./hybridRecordStore.ts"));
+  ({ createOAuthApiKeyRefResolver } = requireFromAdapter(
+    "../oauth/apiKeyRefResolver.ts"
+  ));
+  ({ buildLocalDialogWritePlan, localDialogMessageRecordToRuntimeMessage } = requireFromAdapter("./localDialogRecords.ts"));
+  ({ buildLocalAgentLookupKeys: buildLocalAgentLookupKeys2, shouldReadAgentKeyRemotely: shouldReadAgentKeyRemotely2 } = requireFromAdapter("./localAgentRecords.ts"));
+  ({ createCliHybridRecordStore } = requireFromAdapter(
+    "./hybridRecordStore.ts"
+  ));
   ({ executeLocalToolWithPolicy: executeLocalToolWithPolicy2 } = requireFromAdapter("./localToolPolicy.ts"));
-  ({ inferCaptureIntent } = requireFromAdapter("../../ai/policy/runtimePolicy.ts"));
+  ({ inferCaptureIntent } = requireFromAdapter(
+    "../../ai/policy/runtimePolicy.ts"
+  ));
   ({ TOOL_PACKS } = requireFromAdapter("../../ai/tools/toolPacks.ts"));
   ({ prepareTools } = requireFromAdapter("../../ai/tools/prepareTools.ts"));
   ({
@@ -8811,14 +8981,12 @@ function ensureHeavyCliLocalRuntimeModules() {
   defaultExecuteCli = cliExecutor.executeCli;
   CliProviderQuotaError = cliExecutor.CliProviderQuotaError;
   ({ buildCliPrompt } = requireFromAdapter("../../ai/agent/cliPrompt.ts"));
-  ({
-    readXhsProfileFunc,
-    readXhsProfileFunctionSchema
-  } = requireFromAdapter("../../ai/tools/readXhsProfileTool.ts"));
-  ({
-    readXPostFunc,
-    readXPostFunctionSchema
-  } = requireFromAdapter("../../ai/tools/readXPostTool.ts"));
+  ({ readXhsProfileFunc, readXhsProfileFunctionSchema } = requireFromAdapter(
+    "../../ai/tools/readXhsProfileTool.ts"
+  ));
+  ({ readXPostFunc, readXPostFunctionSchema } = requireFromAdapter(
+    "../../ai/tools/readXPostTool.ts"
+  ));
   ({ ulid: ulid2 } = requireFromAdapter("ulid"));
 }
 function normalizeRuntimeCacheCwd(cwd) {
@@ -8877,7 +9045,8 @@ function parseLocalToolBudgets(env) {
   for (const part of raw.split(",")) {
     const [name, value] = part.split("=").map((item) => item.trim());
     const limit = Number(value);
-    if (name && Number.isFinite(limit) && limit >= 0) budgets[name] = Math.floor(limit);
+    if (name && Number.isFinite(limit) && limit >= 0)
+      budgets[name] = Math.floor(limit);
   }
   return budgets;
 }
@@ -8893,7 +9062,9 @@ function assertWithinLocalToolBudget(args2) {
 }
 function isTransientFetchError(error) {
   const message = toErrorMessage(error);
-  return /certificate|handshake|network|socket|timed out|timeout|ECONNRESET/i.test(message);
+  return /certificate|handshake|network|socket|timed out|timeout|ECONNRESET/i.test(
+    message
+  );
 }
 async function defaultSleep(ms) {
   await new Promise((resolve8) => setTimeout(resolve8, ms));
@@ -8925,26 +9096,39 @@ async function defaultLoopbackRequest(input2, init) {
   }
   return await new Promise((resolve8, reject) => {
     const requestImpl = target.protocol === "https:" ? httpsRequest : httpRequest;
-    const req = requestImpl(target, {
-      method: init?.method ?? "GET",
-      headers: Object.fromEntries(headers.entries())
-    }, (res) => {
-      const chunks = [];
-      res.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
-      res.on("end", () => {
-        resolve8(new Response(Buffer.concat(chunks), {
-          status: res.statusCode ?? 500,
-          headers: res.headers
-        }));
-      });
-    });
+    const req = requestImpl(
+      target,
+      {
+        method: init?.method ?? "GET",
+        headers: Object.fromEntries(headers.entries())
+      },
+      (res) => {
+        const chunks = [];
+        res.on(
+          "data",
+          (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+        );
+        res.on("end", () => {
+          resolve8(
+            new Response(Buffer.concat(chunks), {
+              status: res.statusCode ?? 500,
+              headers: res.headers
+            })
+          );
+        });
+      }
+    );
     req.on("error", reject);
-    init?.signal?.addEventListener("abort", () => {
-      req.destroy(
-        init.signal?.reason instanceof Error ? init.signal.reason : new Error("request aborted")
-      );
-      reject(init.signal?.reason ?? new Error("request aborted"));
-    }, { once: true });
+    init?.signal?.addEventListener(
+      "abort",
+      () => {
+        req.destroy(
+          init.signal?.reason instanceof Error ? init.signal.reason : new Error("request aborted")
+        );
+        reject(init.signal?.reason ?? new Error("request aborted"));
+      },
+      { once: true }
+    );
     if (body) req.write(body);
     req.end();
   });
@@ -8962,7 +9146,9 @@ async function fetchWithTransientRetry(fetchImpl, input2, init, options = {}) {
       if (!isTransientFetchError(error)) throw error;
       lastError = error;
       if (attempt < TRANSIENT_FETCH_MAX_ATTEMPTS) {
-        await (options.sleep ?? defaultSleep)(transientFetchRetryDelayMs(attempt));
+        await (options.sleep ?? defaultSleep)(
+          transientFetchRetryDelayMs(attempt)
+        );
       }
     }
   }
@@ -9041,8 +9227,11 @@ function summarizeOpenAiToolNames(tools) {
   }, []);
 }
 function addDefaultLightWebToolsForConfiguredAgents(toolNames, agentConfig) {
-  const explicitToolNames = Array.isArray(agentConfig?.toolSurface?.explicitToolNames) ? agentConfig.toolSurface.explicitToolNames : agentConfig?.toolNames;
-  if (!Array.isArray(explicitToolNames) || explicitToolNames.length === 0) return toolNames;
+  const explicitToolNames = Array.isArray(
+    agentConfig?.toolSurface?.explicitToolNames
+  ) ? agentConfig.toolSurface.explicitToolNames : agentConfig?.toolNames;
+  if (!Array.isArray(explicitToolNames) || explicitToolNames.length === 0)
+    return toolNames;
   const webCapable = explicitToolNames.some(
     (toolName) => toolName === "fetchWebpage" || toolName === "exa_search" || toolName === "firecrawl_scrape" || toolName === "firecrawl_search" || toolName === "read_x_post" || toolName === "read_xhs_profile" || toolName.startsWith("browser_")
   );
@@ -9051,7 +9240,10 @@ function addDefaultLightWebToolsForConfiguredAgents(toolNames, agentConfig) {
 }
 function buildOpenAiTools(args2) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args2);
+  const toolNameSet = new Set(args2.toolNames ?? []);
+  const callAgentTools = toolNameSet.has("callAgent") ? prepareTools(["callAgent"]) : [];
   return [
+    ...callAgentTools,
     ...buildLocalWorkspaceOpenAiTools2({
       toolNames: toolset.toolNames,
       exposeShellTools: toolset.exposeShellTools,
@@ -9061,7 +9253,9 @@ function buildOpenAiTools(args2) {
       readFileParameterVariant: resolveReadFileParameterVariant(args2.env),
       globFilesDescriptionVariant: resolveGlobFilesDescriptionVariant(args2.env),
       globFilesParameterVariant: resolveGlobFilesParameterVariant(args2.env),
-      searchFilesDescriptionVariant: resolveSearchFilesDescriptionVariant(args2.env),
+      searchFilesDescriptionVariant: resolveSearchFilesDescriptionVariant(
+        args2.env
+      ),
       searchFilesParameterVariant: resolveSearchFilesParameterVariant(args2.env)
     }),
     ...buildServerPlatformOpenAiTools({ toolNames: args2.toolNames }),
@@ -9084,7 +9278,9 @@ function buildLocalWorkspaceToolsetForEnv(args2) {
   const toolset = buildLocalWorkspaceToolset2({
     declaredToolNames: args2.toolNames,
     exposeShellTools: true,
-    useDeclaredToolNamesOnly: shouldUseDeclaredOnlyLocalWorkspaceTools(args2.env)
+    useDeclaredToolNamesOnly: shouldUseDeclaredOnlyLocalWorkspaceTools(
+      args2.env
+    )
   });
   return toolset;
 }
@@ -9093,7 +9289,9 @@ function buildLocalPolicyToolNames(args2) {
     ...buildLocalWorkspacePolicyToolNames2({
       declaredToolNames: args2.toolNames,
       exposeShellTools: true,
-      useDeclaredToolNamesOnly: shouldUseDeclaredOnlyLocalWorkspaceTools(args2.env)
+      useDeclaredToolNamesOnly: shouldUseDeclaredOnlyLocalWorkspaceTools(
+        args2.env
+      )
     }),
     ...(() => {
       const extra = [];
@@ -9101,6 +9299,7 @@ function buildLocalPolicyToolNames(args2) {
       for (const name of names) {
         if (name === "read_x_post") extra.push("read_x_post");
         if (name === "read_xhs_profile") extra.push("read_xhs_profile");
+        if (name === "callAgent") extra.push("callAgent");
         if (LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name)) extra.push(name);
       }
       return extra;
@@ -9113,28 +9312,44 @@ function shouldUseDeclaredOnlyLocalWorkspaceTools(env) {
   return value === "declared-only" || value === "declared";
 }
 function resolveGlobFilesDescriptionVariant(env) {
-  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_GLOBFILES_DESCRIPTION_VARIANT);
+  return resolveLocalWorkspaceDescriptionVariant(
+    env.NOLO_GLOBFILES_DESCRIPTION_VARIANT
+  );
 }
 function resolveListFilesDescriptionVariant(env) {
-  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_LISTFILES_DESCRIPTION_VARIANT);
+  return resolveLocalWorkspaceDescriptionVariant(
+    env.NOLO_LISTFILES_DESCRIPTION_VARIANT
+  );
 }
 function resolveListFilesParameterVariant(env) {
-  return resolveLocalWorkspaceParameterVariant(env.NOLO_LISTFILES_PARAMETER_VARIANT);
+  return resolveLocalWorkspaceParameterVariant(
+    env.NOLO_LISTFILES_PARAMETER_VARIANT
+  );
 }
 function resolveReadFileDescriptionVariant(env) {
-  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_READFILE_DESCRIPTION_VARIANT);
+  return resolveLocalWorkspaceDescriptionVariant(
+    env.NOLO_READFILE_DESCRIPTION_VARIANT
+  );
 }
 function resolveReadFileParameterVariant(env) {
-  return resolveLocalWorkspaceParameterVariant(env.NOLO_READFILE_PARAMETER_VARIANT);
+  return resolveLocalWorkspaceParameterVariant(
+    env.NOLO_READFILE_PARAMETER_VARIANT
+  );
 }
 function resolveGlobFilesParameterVariant(env) {
-  return resolveLocalWorkspaceParameterVariant(env.NOLO_GLOBFILES_PARAMETER_VARIANT);
+  return resolveLocalWorkspaceParameterVariant(
+    env.NOLO_GLOBFILES_PARAMETER_VARIANT
+  );
 }
 function resolveSearchFilesDescriptionVariant(env) {
-  return resolveLocalWorkspaceDescriptionVariant(env.NOLO_SEARCHFILES_DESCRIPTION_VARIANT);
+  return resolveLocalWorkspaceDescriptionVariant(
+    env.NOLO_SEARCHFILES_DESCRIPTION_VARIANT
+  );
 }
 function resolveSearchFilesParameterVariant(env) {
-  return resolveLocalWorkspaceParameterVariant(env.NOLO_SEARCHFILES_PARAMETER_VARIANT);
+  return resolveLocalWorkspaceParameterVariant(
+    env.NOLO_SEARCHFILES_PARAMETER_VARIANT
+  );
 }
 function resolveLocalWorkspaceDescriptionVariant(value) {
   return value === "brief" || value === "strategy" || value === "workflow" || value === "antiShell" ? value : "strategy";
@@ -9145,17 +9360,23 @@ function resolveLocalWorkspaceParameterVariant(value) {
 function buildServerPlatformOpenAiTools(args2) {
   const toolNameSet = new Set(args2.toolNames ?? []);
   const tableTools = prepareTools(
-    Array.from(toolNameSet).filter((name) => LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name))
+    Array.from(toolNameSet).filter(
+      (name) => LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name)
+    )
   );
   return [
-    ...toolNameSet.has("read_xhs_profile") ? [{
-      type: "function",
-      function: readXhsProfileFunctionSchema
-    }] : [],
-    ...toolNameSet.has("read_x_post") ? [{
-      type: "function",
-      function: readXPostFunctionSchema
-    }] : [],
+    ...toolNameSet.has("read_xhs_profile") ? [
+      {
+        type: "function",
+        function: readXhsProfileFunctionSchema
+      }
+    ] : [],
+    ...toolNameSet.has("read_x_post") ? [
+      {
+        type: "function",
+        function: readXPostFunctionSchema
+      }
+    ] : [],
     ...tableTools
   ];
 }
@@ -9199,7 +9420,10 @@ function withResolvedRuntimeToolSurface(agentConfig, env) {
   };
 }
 function resolveRuntimeServerUrl(env) {
-  return (env.NOLO_SERVER_URL || env.NOLO_SERVER || env.BASE_URL || "").replace(/\/+$/, "");
+  return (env.NOLO_SERVER_URL || env.NOLO_SERVER || env.BASE_URL || "").replace(
+    /\/+$/,
+    ""
+  );
 }
 function resolveRuntimeAuthToken(env) {
   return env.AUTH_TOKEN || env.AUTH || env.NOLO_MACHINE_API_KEY || "";
@@ -9267,11 +9491,7 @@ function buildLocalParentWakeMessage(args2) {
     `childDialogKey: ${args2.childDialogKey}`,
     `childAgentKey: ${args2.childAgentKey}`,
     "status: done",
-    ...args2.childEvidenceSummary ? [
-      "",
-      "childEvidenceSummary:",
-      args2.childEvidenceSummary
-    ] : [],
+    ...args2.childEvidenceSummary ? ["", "childEvidenceSummary:", args2.childEvidenceSummary] : [],
     "",
     "Read the childEvidenceSummary and decide the next step yourself. This wake came from a local CLI run, so completion evidence is the synced child dialog, subjectRefs, commits, artifacts, and test output rather than a server-side child process."
   ].join("\n");
@@ -9291,7 +9511,9 @@ async function postRemoteRecord(args2) {
   });
   if (!response.ok) {
     const text = await response.text().catch(() => "");
-    throw new Error(`remote dialog evidence write failed: HTTP ${response.status} ${text.slice(0, 500)}`);
+    throw new Error(
+      `remote dialog evidence write failed: HTTP ${response.status} ${text.slice(0, 500)}`
+    );
   }
 }
 async function readRemoteRecord(args2) {
@@ -9311,7 +9533,9 @@ async function readRemoteRecord(args2) {
 async function maybeWakeParentDialogAfterLocalSync(args2) {
   if (args2.input.runtimeContext?.parentWakeOnTerminal !== true) return;
   if (args2.childDialogRecord.parentWake?.terminalNotifiedAt) return;
-  const parentDialogId = asOptionalTrimmedString(args2.childDialogRecord.parentDialogId);
+  const parentDialogId = asOptionalTrimmedString(
+    args2.childDialogRecord.parentDialogId
+  );
   if (!parentDialogId) return;
   const parentDialogKey = `dialog-${args2.userId}-${parentDialogId}`;
   const parentDialog = await readRemoteRecord({
@@ -9329,8 +9553,12 @@ async function maybeWakeParentDialogAfterLocalSync(args2) {
     args2.childDialogRecord.subjectRefs,
     [{ kind: "dialog", id: childDialogId, role: "completed-child-dialog" }]
   );
-  const allowedChildAgentKeys = normalizeRemoteStringList(args2.input.runtimeContext?.allowedChildAgentKeys);
-  const allowedToolNames = normalizeRemoteStringList(args2.input.runtimeContext?.allowedToolNames);
+  const allowedChildAgentKeys = normalizeRemoteStringList(
+    args2.input.runtimeContext?.allowedChildAgentKeys
+  );
+  const allowedToolNames = normalizeRemoteStringList(
+    args2.input.runtimeContext?.allowedToolNames
+  );
   const wakeResponse = await args2.fetchImpl(`${args2.serverUrl}/api/agent/run`, {
     method: "POST",
     headers: {
@@ -9360,7 +9588,9 @@ async function maybeWakeParentDialogAfterLocalSync(args2) {
   });
   if (!wakeResponse.ok) {
     const text = await wakeResponse.text().catch(() => "");
-    throw new Error(`parent dialog wake failed: HTTP ${wakeResponse.status} ${text.slice(0, 500)}`);
+    throw new Error(
+      `parent dialog wake failed: HTTP ${wakeResponse.status} ${text.slice(0, 500)}`
+    );
   }
   const notifiedAt = Date.now();
   await postRemoteRecord({
@@ -9410,7 +9640,9 @@ async function syncLocalDialogEvidenceToRemote(args2) {
       })
     )
   );
-  const childDialogOp = args2.ops.find((op) => op.type === "put" && !op.key.includes("-msg-"));
+  const childDialogOp = args2.ops.find(
+    (op) => op.type === "put" && !op.key.includes("-msg-")
+  );
   const childDialogRecord = childDialogOp?.value && typeof childDialogOp.value === "object" ? childDialogOp.value : null;
   if (childDialogOp && childDialogRecord) {
     try {
@@ -9425,7 +9657,9 @@ async function syncLocalDialogEvidenceToRemote(args2) {
       });
     } catch (error) {
       args2.output?.write(
-        `[nolo] Parent dialog wake failed; synced local child evidence remains queryable: ${toErrorMessage(error)}
+        `[nolo] Parent dialog wake failed; synced local child evidence remains queryable: ${toErrorMessage(
+          error
+        )}
 `
       );
     }
@@ -9436,8 +9670,14 @@ function buildServerPlatformToolExecutors(args2) {
   const postServer = async (path8, body) => {
     const serverUrl = resolveRuntimeServerUrl(args2.env);
     const authToken = resolveRuntimeAuthToken(args2.env);
-    if (!serverUrl) throw new Error("server platform tools require NOLO_SERVER_URL, NOLO_SERVER, or BASE_URL.");
-    if (!authToken) throw new Error("server platform tools require AUTH_TOKEN or NOLO_MACHINE_API_KEY.");
+    if (!serverUrl)
+      throw new Error(
+        "server platform tools require NOLO_SERVER_URL, NOLO_SERVER, or BASE_URL."
+      );
+    if (!authToken)
+      throw new Error(
+        "server platform tools require AUTH_TOKEN or NOLO_MACHINE_API_KEY."
+      );
     const response = await args2.fetchImpl(`${serverUrl}${path8}`, {
       method: "POST",
       headers: {
@@ -9448,12 +9688,15 @@ function buildServerPlatformToolExecutors(args2) {
     });
     const text = await response.text().catch(() => "");
     if (!response.ok) {
-      throw new Error(`server platform tool bridge failed: HTTP ${response.status} ${text.slice(0, 500)}`);
+      throw new Error(
+        `server platform tool bridge failed: HTTP ${response.status} ${text.slice(0, 500)}`
+      );
     }
     return text;
   };
   const guardExplicitTableCapture = (call) => {
-    if (inferCaptureIntent(String(call.userInput ?? "")) === "strong") return null;
+    if (inferCaptureIntent(String(call.userInput ?? "")) === "strong")
+      return null;
     return JSON.stringify({
       error: "knowledge_capture_requires_confirmation",
       message: "\u5F53\u524D\u672C\u5730\u8FD0\u884C\u4E0D\u5141\u8BB8\u81EA\u52A8\u5199\u5165\u8868\u683C\u3002\u53EA\u6709\u5F53\u7528\u6237\u5728\u5F53\u524D\u8BF7\u6C42\u91CC\u660E\u786E\u8981\u6C42\u4FDD\u5B58\u3001\u5EFA\u8868\u3001\u5199\u5165 table \u6216\u505A\u6210\u6570\u636E\u96C6\u65F6\uFF0C\u624D\u80FD\u7EE7\u7EED\uFF1B\u5426\u5219\u8BF7\u5148\u8BE2\u95EE\u7528\u6237\u3002",
@@ -9487,6 +9730,231 @@ function buildServerPlatformToolExecutors(args2) {
   );
   return tableExecutors;
 }
+function buildCliDelegatedAgentInput(task, input2) {
+  if (input2 === void 0 || input2 === null) {
+    return task;
+  }
+  if (typeof input2 === "string") {
+    return `${task}
+
+--- INPUT (text) ---
+${input2}`;
+  }
+  return `${task}
+
+--- INPUT (json) ---
+${JSON.stringify(input2, null, 2)}`;
+}
+async function persistCliPendingChildDialog(args2) {
+  const nowIso = new Date(args2.now).toISOString();
+  const dialogKey = `dialog-${args2.userId}-${args2.dialogId}`;
+  const record = {
+    id: args2.dialogId,
+    dbKey: dialogKey,
+    type: "dialog",
+    userId: args2.userId,
+    cybots: [args2.agentKey],
+    primaryAgentKey: args2.agentKey,
+    title: args2.title.slice(0, 80),
+    status: "pending",
+    triggerType: "cli-local",
+    executionMode: args2.background ? "background" : "foreground",
+    createdAt: nowIso,
+    updatedAt: nowIso,
+    ...args2.spaceId ? { spaceId: args2.spaceId } : {},
+    ...args2.parentDialogId ? { parentDialogId: args2.parentDialogId } : {},
+    ...args2.rootDialogId ? { rootDialogId: args2.rootDialogId } : {},
+    localRuntime: {
+      host: "cli",
+      workspaceRoot: args2.workspaceRoot,
+      workspaceKind: "current",
+      workspaceAccess: "inherited"
+    }
+  };
+  await args2.store.batch([{ type: "put", key: dialogKey, value: record }]);
+}
+async function persistCliFailedChildDialog(args2) {
+  const dialogKey = `dialog-${args2.userId}-${args2.dialogId}`;
+  const existing = await args2.store.read(dialogKey);
+  const existingRecord = existing && typeof existing === "object" ? existing : {};
+  await args2.store.batch([
+    {
+      type: "put",
+      key: dialogKey,
+      value: {
+        ...existingRecord,
+        id: args2.dialogId,
+        dbKey: dialogKey,
+        status: "failed",
+        errorMessage: args2.errorMessage,
+        updatedAt: new Date(args2.now).toISOString(),
+        finishedAt: args2.now
+      }
+    }
+  ]);
+}
+function createCliCallAgentToolExecutor(deps, ctx) {
+  ensureHeavyCliLocalRuntimeModules();
+  const userId = resolveLocalUserId(deps.env);
+  const workspaceRoot = deps.cwd ?? process.cwd();
+  const now = deps.now ?? Date.now;
+  const createId = deps.createId ?? createFallbackId;
+  return async (call) => {
+    const parsed = parseNoloWorkspaceToolArguments2(call.arguments);
+    const agentKey = asTrimmedString(parsed.agentKey);
+    const task = asTrimmedString(parsed.task);
+    if (!agentKey) {
+      return {
+        content: JSON.stringify({ error: "callAgent: agentKey is required" }),
+        metadata: { callAgent: true }
+      };
+    }
+    if (!task) {
+      return {
+        content: JSON.stringify({ error: "callAgent: task is required" }),
+        metadata: { callAgent: true }
+      };
+    }
+    const allowedChildAgentKeys = asTrimmedNonEmptyStringArray(
+      ctx.runtimeContext?.allowedChildAgentKeys
+    );
+    if (allowedChildAgentKeys.length > 0 && !allowedChildAgentKeys.includes(agentKey)) {
+      return {
+        content: JSON.stringify({
+          error: "callAgent: agentKey is not allowed by parent runtimeContext.allowedChildAgentKeys",
+          agentKey,
+          allowedChildAgentKeys
+        }),
+        metadata: { callAgent: true }
+      };
+    }
+    const background = parsed.background === true;
+    const parentDialogId = asOptionalTrimmedString(ctx.dialogId);
+    const parentThreadId = parentDialogId ?? asOptionalTrimmedString(ctx.runtimeContext?.parentThreadId);
+    const rootThreadId = asOptionalTrimmedString(ctx.runtimeContext?.rootThreadId) ?? asOptionalTrimmedString(ctx.runtimeContext?.parentThreadId) ?? parentThreadId;
+    const presentationIntent = background ? "background_handoff" : "inline_result";
+    const threadKind = background ? "background" : "inline";
+    const childRuntimeContext = {
+      ...ctx.runtimeContext ?? {},
+      surface: "cli",
+      entrypoint: "agent-tool:callAgent",
+      threadKind,
+      presentationIntent,
+      ...parentThreadId ? { parentThreadId } : {},
+      ...rootThreadId ? { rootThreadId } : {},
+      workspaceRoot,
+      workspaceKind: "current",
+      workspaceAccess: "inherited"
+    };
+    const childDialogId = createId();
+    const store = await getOrCreateSharedStore(deps);
+    await persistCliPendingChildDialog({
+      store,
+      userId,
+      dialogId: childDialogId,
+      agentKey,
+      title: task,
+      spaceId: ctx.spaceId,
+      parentDialogId,
+      rootDialogId: rootThreadId,
+      workspaceRoot,
+      background,
+      now: now()
+    });
+    const childAdapter = ctx.createChildAdapter({
+      dialogId: childDialogId,
+      spaceId: ctx.spaceId,
+      runtimeContext: childRuntimeContext
+    });
+    const childInputBase = {
+      adapter: childAdapter,
+      agentRef: agentKey,
+      input: buildCliDelegatedAgentInput(task, parsed.input),
+      runtimeContext: childRuntimeContext,
+      spaceId: ctx.spaceId,
+      continueDialogId: childDialogId,
+      parentDialogId
+    };
+    if (background) {
+      void ctx.runChildTurn(childInputBase).catch(async (error) => {
+        const errorMessage = toErrorMessage(error);
+        try {
+          await persistCliFailedChildDialog({
+            store,
+            userId,
+            dialogId: childDialogId,
+            errorMessage,
+            now: now()
+          });
+        } catch (persistError) {
+          deps.output?.write(
+            `[nolo] failed to persist background child failure: ${toErrorMessage(
+              persistError
+            )}
+`
+          );
+        }
+      });
+      return {
+        content: JSON.stringify({
+          success: true,
+          status: "pending",
+          agentKey,
+          childDialogId,
+          ...parentDialogId ? { parentDialogId } : {}
+        }),
+        metadata: { callAgent: true, background: true, localRuntime: true }
+      };
+    }
+    try {
+      const childResult = await ctx.runChildTurn(childInputBase);
+      return {
+        content: JSON.stringify({
+          success: true,
+          agentKey,
+          dialogId: childDialogId,
+          model: childResult.model ?? null,
+          provider: childResult.provider ?? null,
+          content: childResult.content ?? "",
+          usage: childResult.usage ?? null
+        }),
+        metadata: { callAgent: true, background: false, localRuntime: true }
+      };
+    } catch (error) {
+      const errorMessage = toErrorMessage(error);
+      try {
+        await persistCliFailedChildDialog({
+          store,
+          userId,
+          dialogId: childDialogId,
+          errorMessage,
+          now: now()
+        });
+      } catch (persistError) {
+        deps.output?.write(
+          `[nolo] failed to persist foreground child failure: ${toErrorMessage(
+            persistError
+          )}
+`
+        );
+      }
+      return {
+        content: JSON.stringify({
+          success: false,
+          agentKey,
+          dialogId: childDialogId,
+          error: errorMessage
+        }),
+        metadata: {
+          callAgent: true,
+          background: false,
+          localRuntime: true,
+          error: true
+        }
+      };
+    }
+  };
+}
 function buildLocalToolExecutors(args2) {
   return {
     ...createLocalWorkspaceToolExecutors2({
@@ -9573,7 +10041,10 @@ async function readAgentFromStore(args2) {
   const normalizedRef = normalizeAgentHandle(args2.agentRef);
   if (!normalizedRef) return null;
   try {
-    const iterator = args2.store.iterator({ gte: "agent-", lte: "agent-\uFFFF" });
+    const iterator = args2.store.iterator({
+      gte: "agent-",
+      lte: "agent-\uFFFF"
+    });
     for await (const [key, record] of iterator) {
       if (!record || typeof record !== "object") continue;
       const handle = normalizeAgentHandle(record.handle);
@@ -9629,7 +10100,9 @@ async function writeDialog(args2) {
       throw error;
     }
     args2.output?.write(
-      `[nolo] Remote dialog evidence sync failed; local dialog only: ${toErrorMessage(error)}
+      `[nolo] Remote dialog evidence sync failed; local dialog only: ${toErrorMessage(
+        error
+      )}
 `
     );
   }
@@ -9659,7 +10132,12 @@ function createCliLocalRuntimeAdapter(deps) {
   });
   return {
     host: "cli",
-    capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence", "local-tools"],
+    capabilities: [
+      "leveldb-agent-config",
+      "local-provider",
+      "leveldb-persistence",
+      "local-tools"
+    ],
     loadAgentConfig: async (agentRef) => {
       const cacheKey = buildPreparedAgentCacheKey({
         userId,
@@ -9830,7 +10308,9 @@ function createCliLocalRuntimeAdapter(deps) {
             });
             if (result.status < 200 || result.status >= 300) {
               const errMsg = result.body && typeof result.body === "object" && result.body.error && typeof result.body.error.message === "string" ? result.body.error.message : JSON.stringify(result.body);
-              throw new Error(`local antigravity provider failed: HTTP ${result.status} ${errMsg}`);
+              throw new Error(
+                `local antigravity provider failed: HTTP ${result.status} ${errMsg}`
+              );
             }
             const choice = Array.isArray(result.body.choices) ? result.body.choices[0] : void 0;
             const message = choice?.message ?? {};
@@ -9905,16 +10385,23 @@ function createCliLocalRuntimeAdapter(deps) {
               openAiToolNames: summarizeOpenAiToolNames(tools2),
               stream
             });
-            const res = await fetchWithTransientRetry(fetchImpl, request.url, {
-              ...request.init
-            }, {
-              sleep: deps.sleep,
-              loopbackRequest
-            });
+            const res = await fetchWithTransientRetry(
+              fetchImpl,
+              request.url,
+              {
+                ...request.init
+              },
+              {
+                sleep: deps.sleep,
+                loopbackRequest
+              }
+            );
             if (!res.ok) {
               const raw2 = await res.text().catch(() => "");
               const data2 = parsePlatformChatCompletionData2(raw2);
-              throw new Error(`platform provider failed: HTTP ${res.status} ${JSON.stringify(data2)}`);
+              throw new Error(
+                `platform provider failed: HTTP ${res.status} ${JSON.stringify(data2)}`
+              );
             }
             const contentType = res.headers.get("content-type") ?? "";
             const shouldStream = Boolean(stream && options?.onTextDelta) && contentType.includes("text/event-stream");
@@ -10044,7 +10531,9 @@ function createCliLocalRuntimeAdapter(deps) {
         const code = error && typeof error === "object" && typeof error.code === "string" ? error.code : void 0;
         const request = error && typeof error === "object" && error.permissionRequest;
         if (code === "destructive_action_requires_confirmation" && deps.confirmDestructiveAction && request && typeof request === "object") {
-          const confirmed = await deps.confirmDestructiveAction(request);
+          const confirmed = await deps.confirmDestructiveAction(
+            request
+          );
           if (confirmed) {
             const result = await executeLocalToolWithPolicy2({
               env: deps.env,
@@ -10083,6 +10572,7 @@ var init_localRuntimeAdapter = __esm({
     init_optionalString();
     init_recordOrEmpty();
     init_stringArray();
+    init_trimmedString();
     init_summarizeEndpoint();
     requireFromAdapter = createRequire(import.meta.url);
     heavyCliLocalRuntimeModulesLoaded = false;
@@ -10092,7 +10582,11 @@ var init_localRuntimeAdapter = __esm({
     BUILTIN_NOLO_AGENT_KEY = NOLO_DEFAULT_AGENT_KEY;
     SOURCE_CLI_DIR = dirname3(fileURLToPath3(import.meta.url));
     CLI_DIR = isCompiledBinary() ? dirname3(process.execPath) : SOURCE_CLI_DIR;
-    CLI_ENTRYPOINT = isCompiledBinary() ? process.execPath : join5(SOURCE_CLI_DIR, "..", `index${extname2(fileURLToPath3(import.meta.url)) || ".ts"}`);
+    CLI_ENTRYPOINT = isCompiledBinary() ? process.execPath : join5(
+      SOURCE_CLI_DIR,
+      "..",
+      `index${extname2(fileURLToPath3(import.meta.url)) || ".ts"}`
+    );
     LOCAL_SERVER_TABLE_TOOL_NAMES = [
       "createTable",
       "addTableRow",
@@ -10100,7 +10594,9 @@ var init_localRuntimeAdapter = __esm({
       "updateTableRow",
       "updateTableRows"
     ];
-    LOCAL_SERVER_TABLE_TOOL_NAME_SET = new Set(LOCAL_SERVER_TABLE_TOOL_NAMES);
+    LOCAL_SERVER_TABLE_TOOL_NAME_SET = new Set(
+      LOCAL_SERVER_TABLE_TOOL_NAMES
+    );
     preparedAgentRuntimeCache = /* @__PURE__ */ new Map();
     hybridStoreCache = /* @__PURE__ */ new Map();
   }
@@ -10216,8 +10712,8 @@ async function runAgentUpdateCommand(args2, deps = {}) {
       ok: true,
       agentKey: built.agentKey,
       baseUrl: built.serverUrl,
-      updates: built.updates,
-      record: built.nextRecord
+      updates: sanitizeAgentRecordForCliOutput(built.updates),
+      record: sanitizeAgentRecordForCliOutput(built.nextRecord)
     }, null, 2));
     output2.write("\n");
     return 0;
@@ -10289,8 +10785,8 @@ async function runAgentCreateCommand(args2, deps = {}) {
       ok: true,
       agentKey: built.agentKey,
       baseUrl: built.serverUrl,
-      updates: built.updates,
-      record: built.nextRecord
+      updates: sanitizeAgentRecordForCliOutput(built.updates),
+      record: sanitizeAgentRecordForCliOutput(built.nextRecord)
     }, null, 2));
     output2.write("\n");
     return 0;
@@ -10588,35 +11084,59 @@ function isTableRow(line) {
   const cells = splitTableCells(line);
   return cells.length >= 2 && cells.some((cell) => cell.length > 0);
 }
+function isPipeWrappedTableRow(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith("|") && trimmed.endsWith("|") && isTableRow(line);
+}
+function isCodeFenceLine(line) {
+  return /^\s*```/.test(line);
+}
+function tableRowToBullet(line) {
+  const row = splitTableCells(line);
+  const label = row[0] ?? "";
+  const detail = row.slice(1).join(" \u2014 ").trim();
+  return detail ? `  \u2022 ${label} \u2014 ${detail}` : `  \u2022 ${label}`;
+}
 function convertMarkdownTablesForTerminal(text) {
   const lines = text.split("\n");
   const out = [];
+  let inFence = false;
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index] ?? "";
+    if (isCodeFenceLine(line)) {
+      inFence = !inFence;
+      out.push(line);
+      continue;
+    }
+    if (inFence) {
+      out.push(line);
+      continue;
+    }
     const next = lines[index + 1] ?? "";
     if (isTableRow(line) && isTableSeparator(next)) {
-      const headers = splitTableCells(line);
       index += 1;
       while (index + 1 < lines.length && isTableRow(lines[index + 1] ?? "") && !isTableSeparator(lines[index + 1] ?? "")) {
         index += 1;
-        const row = splitTableCells(lines[index] ?? "");
-        const label = row[0] ?? "";
-        const detail = row.slice(1).join(" \u2014 ").trim();
-        out.push(detail ? `  \u2022 ${label} \u2014 ${detail}` : `  \u2022 ${label}`);
+        out.push(tableRowToBullet(lines[index] ?? ""));
       }
       if (out.length > 0 && out[out.length - 1] !== "") out.push("");
       continue;
     }
+    if (isPipeWrappedTableRow(line)) {
+      if (!isTableSeparator(line)) out.push(tableRowToBullet(line));
+      continue;
+    }
     out.push(line);
   }
   return out.join("\n");
 }
-function polishAssistantStructure(text) {
-  return convertMarkdownTablesForTerminal(text).replace(/\r\n/g, "\n").replace(/([^\n])\n(#{1,3} )/g, "$1\n\n$2").replace(/\n{4,}/g, "\n\n\n").trim();
+function polishAssistantStructure(text, options = {}) {
+  const polished = convertMarkdownTablesForTerminal(text).replace(/\r\n/g, "\n").replace(/([^\n])\n(#{1,3} )/g, "$1\n\n$2").replace(/\n{4,}/g, "\n\n\n");
+  return options.trimEdges === false ? polished : polished.trim();
 }
 function styleInlineMarkdown(line, mode) {
   if (mode === "plain") return line;
-  return line.replace(/\*\*(.+?)\*\*/g, `${ANSI.bold}$1${ANSI.reset}`);
+  return line.replace(/`([^`]+)`/g, `${ANSI.cyan}$1${ANSI.reset}`).replace(/\*\*(.+?)\*\*/g, `${ANSI.bold}$1${ANSI.reset}`);
 }
 function styleRichMarkdownLine(line) {
   const heading = line.match(/^(#{1,3})\s+(.+)$/);
@@ -10631,20 +11151,27 @@ function styleRichMarkdownLine(line) {
   }
   return styleInlineMarkdown(line, "rich");
 }
-function formatAssistantDisplay(text, mode = "rich") {
-  const polished = polishAssistantStructure(text);
-  if (mode === "plain") {
-    return polished.split("\n").map((line) => styleInlineMarkdown(line, "plain")).join("\n");
-  }
-  return polished.split("\n").map((line) => styleRichMarkdownLine(line)).join("\n");
+function formatAssistantDisplay(text, mode = "rich", options = {}) {
+  const polished = polishAssistantStructure(text, options);
+  let inFence = false;
+  return polished.split("\n").map((line) => {
+    if (isCodeFenceLine(line)) {
+      inFence = !inFence;
+      return mode === "plain" ? line : `${ANSI.dim}${line}${ANSI.reset}`;
+    }
+    if (inFence) return line;
+    if (mode === "plain") return styleInlineMarkdown(line, "plain");
+    return styleRichMarkdownLine(line);
+  }).join("\n");
 }
 function emitFormattedAssistantBlock(write, text, renderMode, trailingNewline = false) {
   if (!text) return;
-  write(formatAssistantDisplay(text, renderMode));
+  write(formatAssistantDisplay(text, renderMode, { trimEdges: false }));
   if (trailingNewline) write("\n");
 }
 function createRenderAwareStreamWriter(args2) {
   let buffer = "";
+  let inFence = false;
   const flushCompleteBlocks = () => {
     if (args2.renderMode === "plain") {
       if (!buffer) return;
@@ -10655,23 +11182,41 @@ function createRenderAwareStreamWriter(args2) {
     while (buffer.includes("\n")) {
       const lines = buffer.split("\n");
       if (lines.length < 2) break;
-      if (isTableRow(lines[0] ?? "") && isTableSeparator(lines[1] ?? "")) {
-        let end = 2;
-        while (end < lines.length && isTableRow(lines[end] ?? "") && !isTableSeparator(lines[end] ?? "")) {
-          end += 1;
-        }
-        const tableComplete = end < lines.length || buffer.endsWith("\n");
-        if (!tableComplete) break;
-        emitFormattedAssistantBlock(
-          args2.write,
-          lines.slice(0, end).join("\n"),
-          args2.renderMode,
-          true
-        );
-        buffer = lines.slice(end).join("\n");
+      const firstLine = lines[0] ?? "";
+      if (isCodeFenceLine(firstLine)) {
+        inFence = !inFence;
+        args2.write(`${ANSI.dim}${firstLine}${ANSI.reset}
+`);
+        buffer = lines.slice(1).join("\n");
+        continue;
+      }
+      if (inFence) {
+        args2.write(`${firstLine}
+`);
+        buffer = lines.slice(1).join("\n");
         continue;
       }
-      emitFormattedAssistantBlock(args2.write, lines[0] ?? "", args2.renderMode, true);
+      if (isTableRow(firstLine)) {
+        const nextLineComplete = lines.length > 2;
+        if (!nextLineComplete) break;
+        if (isTableSeparator(lines[1] ?? "")) {
+          let end = 2;
+          while (end < lines.length && isTableRow(lines[end] ?? "") && !isTableSeparator(lines[end] ?? "")) {
+            end += 1;
+          }
+          const tableComplete = end < lines.length - 1;
+          if (!tableComplete) break;
+          emitFormattedAssistantBlock(
+            args2.write,
+            lines.slice(0, end).join("\n"),
+            args2.renderMode,
+            true
+          );
+          buffer = lines.slice(end).join("\n");
+          continue;
+        }
+      }
+      emitFormattedAssistantBlock(args2.write, firstLine, args2.renderMode, true);
       buffer = lines.slice(1).join("\n");
     }
   };
@@ -10689,6 +11234,8 @@ function createRenderAwareStreamWriter(args2) {
       if (!buffer) return;
       if (args2.renderMode === "plain") {
         args2.write(buffer);
+      } else if (inFence) {
+        args2.write(buffer);
       } else {
         emitFormattedAssistantBlock(args2.write, buffer, args2.renderMode);
       }
@@ -11307,6 +11854,7 @@ var init_gatewayHttpStatus = __esm({
 });
 
 // packages/cli/client/agentRun.ts
+import { ulid as ulid3 } from "ulid";
 async function loadRunLocalAgentTurn() {
   const { runLocalAgentTurn: runLocalAgentTurn2 } = await Promise.resolve().then(() => (init_agentRuntimeLocal(), agentRuntimeLocal_exports));
   return runLocalAgentTurn2;
@@ -11322,7 +11870,9 @@ function formatElapsed(totalSeconds) {
 }
 function findServerPlatformTools(toolNames) {
   if (!Array.isArray(toolNames)) return [];
-  return toolNames.filter((toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName));
+  return toolNames.filter(
+    (toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName)
+  );
 }
 function resolveServerPlatformToolNames(agentConfig) {
   return findServerPlatformTools([
@@ -11333,7 +11883,9 @@ function resolveServerPlatformToolNames(agentConfig) {
 function isKnownServerPlatformAgent(options) {
   if (KNOWN_SERVER_PLATFORM_AGENT_KEYS.has(options.agentKey)) return true;
   const normalizedKey = normalizeAgentHandle(options.agentKey);
-  return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
+  return Boolean(
+    normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey)
+  );
 }
 function shouldShowUsage(env) {
   return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
@@ -11344,7 +11896,8 @@ async function resolveCurrentMachineId(options) {
 function resolveRequestedRuntimeMode(options) {
   const envMode = options.env.NOLO_RUNTIME_MODE;
   if (options.runtimeMode) return options.runtimeMode;
-  if (envMode === "local" || envMode === "server" || envMode === "auto") return envMode;
+  if (envMode === "local" || envMode === "server" || envMode === "auto")
+    return envMode;
   return "auto";
 }
 function buildDefaultLocalRuntimeAdapter(options) {
@@ -11357,7 +11910,9 @@ function buildDefaultLocalRuntimeAdapter(options) {
   });
 }
 function resolveLocalRuntimeAdapter(options) {
-  return options.localRuntimeAdapter || options.localRuntimeAdapterFactory?.(options.env, { cwd: options.localRuntimeCwd }) || buildDefaultLocalRuntimeAdapter(options);
+  return options.localRuntimeAdapter || options.localRuntimeAdapterFactory?.(options.env, {
+    cwd: options.localRuntimeCwd
+  }) || buildDefaultLocalRuntimeAdapter(options);
 }
 async function shouldSkipAutoLocalForServerPlatformTools(options) {
   if (isBuiltinNoloAgentRef(options.agentKey)) return false;
@@ -11492,7 +12047,8 @@ function formatToolJsonEvent(event) {
 `;
 }
 function shouldAttemptAutoLocal(options) {
-  if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory) return true;
+  if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory)
+    return true;
   if (options.env.NOLO_DISABLE_CLI_WORKSPACE_TOOLS !== "1" && isBuiltinNoloAgentRef(options.agentKey) && resolveAuthToken2(options.env)) {
     return true;
   }
@@ -11505,7 +12061,8 @@ function shouldAttemptAutoLocal(options) {
 }
 function formatUsage(usage2, dialogId) {
   const parts = [];
-  if (typeof dialogId === "string" && dialogId) parts.push(`dialog=${dialogId}`);
+  if (typeof dialogId === "string" && dialogId)
+    parts.push(`dialog=${dialogId}`);
   const input2 = usage2?.input_tokens ?? usage2?.prompt_tokens ?? 0;
   const output2 = usage2?.output_tokens ?? usage2?.completion_tokens ?? 0;
   if (input2 || output2) parts.push(`tokens=${input2}+${output2}`);
@@ -11535,19 +12092,23 @@ async function readAgentRunFailureMetadata(res) {
   };
 }
 async function runHttpAgentTurn(options, authToken) {
-  const spinner = new Spinner(options.output, `${options.agentName} -> working`);
+  const spinner = new Spinner(
+    options.output,
+    `${options.agentName} -> working`
+  );
   spinner.start();
   const fetchImpl = options.fetchImpl ?? fetch;
   const subjectRefs = buildSubjectRefs(options);
-  const allowedChildAgentKeys = options.allowedChildAgentKeys?.filter((key) => key.trim());
-  const allowedToolNames = options.allowedToolNames?.filter((name) => name.trim());
+  const allowedChildAgentKeys = options.allowedChildAgentKeys?.filter(
+    (key) => key.trim()
+  );
+  const allowedToolNames = options.allowedToolNames?.filter(
+    (name) => name.trim()
+  );
   const shouldStream = !options.noStream && !options.background;
   const buildRequestBody = (stream) => JSON.stringify({
     agentKey: options.agentKey,
-    userInput: buildUserInputContent(
-      options.message,
-      options.imageUrls
-    ),
+    userInput: buildUserInputContent(options.message, options.imageUrls),
     runtimeContext: {
       surface: "cli",
       host: "terminal",
@@ -11683,12 +12244,78 @@ async function refreshMissingLocalAgentConfig(options) {
   return Boolean(agentConfig);
 }
 async function runLocalAgentTurnForCli(options, settings) {
-  const adapter = resolveLocalRuntimeAdapter(options);
-  if (!adapter) {
-    options.output.write("[nolo] Local runtime was requested but no local runtime adapter is available.\n");
+  const baseAdapter = resolveLocalRuntimeAdapter(options);
+  if (!baseAdapter) {
+    options.output.write(
+      "[nolo] Local runtime was requested but no local runtime adapter is available.\n"
+    );
     return { exitCode: 1 };
   }
-  const spinner = new Spinner(options.output, `${options.agentName} -> working locally`);
+  const subjectRefs = buildSubjectRefs(options);
+  const allowedChildAgentKeys = options.allowedChildAgentKeys?.filter(
+    (key) => key.trim()
+  );
+  const allowedToolNames = options.allowedToolNames?.filter(
+    (name) => name.trim()
+  );
+  const runtimeContext2 = subjectRefs || allowedChildAgentKeys?.length || allowedToolNames?.length || options.parentWakeOnTerminal ? {
+    ...subjectRefs ? { subjectRefs } : {},
+    ...allowedChildAgentKeys?.length ? { allowedChildAgentKeys } : {},
+    ...allowedToolNames?.length ? { allowedToolNames } : {},
+    ...options.parentWakeOnTerminal ? { parentWakeOnTerminal: true } : {},
+    ...options.parentDialogId ? { parentThreadId: options.parentDialogId } : {}
+  } : void 0;
+  const currentDialogId = options.continueDialogId ?? ulid3();
+  const runChildTurn = async (input2) => {
+    const { runLocalAgentTurn: runLocalAgentTurn2 } = await Promise.resolve().then(() => (init_agentRuntimeLocal(), agentRuntimeLocal_exports));
+    return runLocalAgentTurn2(input2);
+  };
+  const createFreshChildBaseAdapter = () => options.localRuntimeAdapterFactory?.(options.env, {
+    cwd: options.localRuntimeCwd
+  }) ?? buildDefaultLocalRuntimeAdapter(options);
+  const withLocalDelegation = (args2) => {
+    let adapter2;
+    const callAgentExecutor = createCliCallAgentToolExecutor(
+      {
+        env: options.env,
+        fetchImpl: options.fetchImpl,
+        cwd: options.localRuntimeCwd,
+        output: options.output
+      },
+      {
+        createChildAdapter: (child) => withLocalDelegation({
+          base: createFreshChildBaseAdapter(),
+          dialogId: child.dialogId,
+          spaceId: child.spaceId,
+          runtimeContext: child.runtimeContext
+        }),
+        runChildTurn,
+        dialogId: args2.dialogId,
+        spaceId: args2.spaceId,
+        runtimeContext: args2.runtimeContext
+      }
+    );
+    adapter2 = {
+      ...args2.base,
+      executeTool: async (call) => {
+        if (call.name === "callAgent") {
+          return callAgentExecutor(call);
+        }
+        return args2.base.executeTool(call);
+      }
+    };
+    return adapter2;
+  };
+  const adapter = withLocalDelegation({
+    base: baseAdapter,
+    dialogId: currentDialogId,
+    spaceId: options.spaceId,
+    runtimeContext: runtimeContext2
+  });
+  const spinner = new Spinner(
+    options.output,
+    `${options.agentName} -> working locally`
+  );
   spinner.start();
   try {
     const toolDisplayMode = resolveToolDisplayMode(options.env);
@@ -11707,32 +12334,19 @@ async function runLocalAgentTurnForCli(options, settings) {
       (chunk) => renderWriter.push(chunk),
       thinkingMode
     );
-    const subjectRefs = buildSubjectRefs(options);
-    const allowedChildAgentKeys = options.allowedChildAgentKeys?.filter((key) => key.trim());
-    const allowedToolNames = options.allowedToolNames?.filter((name) => name.trim());
     const runLocalAgentTurn2 = await loadRunLocalAgentTurn();
     const result = await runLocalAgentTurn2({
       adapter,
       agentRef: options.agentKey,
-      input: buildUserInputContent(
-        options.message,
-        options.imageUrls
-      ),
-      continueDialogId: options.continueDialogId,
+      input: buildUserInputContent(options.message, options.imageUrls),
+      continueDialogId: currentDialogId,
       spaceId: options.spaceId,
       category: options.category,
       inheritedFromDialogKey: options.inheritedFromDialogKey,
       parentDialogId: options.parentDialogId,
       background: options.background,
       noStream: options.noStream,
-      ...subjectRefs || allowedChildAgentKeys?.length || allowedToolNames?.length ? {
-        runtimeContext: {
-          ...subjectRefs ? { subjectRefs } : {},
-          ...allowedChildAgentKeys?.length ? { allowedChildAgentKeys } : {},
-          ...allowedToolNames?.length ? { allowedToolNames } : {},
-          ...options.parentWakeOnTerminal ? { parentWakeOnTerminal: true } : {}
-        }
-      } : {},
+      ...runtimeContext2 ? { runtimeContext: runtimeContext2 } : {},
       ...typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {},
       ...options.actionGateHandler ? { onActionGate: options.actionGateHandler } : {},
       ...options.onLoopEvent ? { onLoopEvent: options.onLoopEvent } : {},
@@ -11764,7 +12378,10 @@ ${options.agentName} > `);
       renderWriter.flush();
       options.output.write("\n");
     } else {
-      const content = formatAssistantResponseForCli(result.content.trim(), options);
+      const content = formatAssistantResponseForCli(
+        result.content.trim(),
+        options
+      );
       if (content) {
         options.output.write(`
 ${options.agentName} > ${content}
@@ -11794,7 +12411,9 @@ ${options.agentName} > (no text response)
 async function readStreamingAgentRun(options, res) {
   const reader = res.body?.getReader();
   if (!reader) {
-    options.output.write("[nolo] Agent stream response did not include a readable body.\n");
+    options.output.write(
+      "[nolo] Agent stream response did not include a readable body.\n"
+    );
     return { exitCode: 1 };
   }
   const decoder = new TextDecoder();
@@ -11827,7 +12446,9 @@ ${options.agentName} > `);
       dialogId = payload.dialogId;
     }
     if (payload?.error || payload?.type === "error") {
-      throw new Error(String(payload.error || payload.message || "Agent stream failed"));
+      throw new Error(
+        String(payload.error || payload.message || "Agent stream failed")
+      );
     }
     if (payload?.type === "done") {
       usage2 = payload.usage;
@@ -11868,7 +12489,9 @@ ${options.agentName} > `);
 [nolo] Agent stream transport interrupted after dialog ${dialogId} was created: ${message}
 `
       );
-      options.output.write("[nolo] The agent run may still finish on the server; read the dialog before retrying.\n");
+      options.output.write(
+        "[nolo] The agent run may still finish on the server; read the dialog before retrying.\n"
+      );
       return { exitCode: 0, dialogId, streamInterrupted: true };
     }
     options.output.write(`
@@ -11888,7 +12511,8 @@ ${options.agentName} > (no text response)
     options.output.write("\n");
   }
   const usageText = formatUsage(usage2, dialogId);
-  if (usageText && shouldShowUsage(options.env)) options.output.write(`${usageText}
+  if (usageText && shouldShowUsage(options.env))
+    options.output.write(`${usageText}
 `);
   return {
     exitCode: 0,
@@ -11905,7 +12529,9 @@ async function runAgentTurn(options) {
   if (runtimeMode === "auto" && shouldAttemptAutoLocal(options)) {
     const skipLocal = await shouldSkipAutoLocalForServerPlatformTools(options);
     if (!skipLocal) {
-      const localResult = await runLocalAgentTurnForCli(options, { reportFailure: false });
+      const localResult = await runLocalAgentTurnForCli(options, {
+        reportFailure: false
+      });
       if (localResult.exitCode === 0) {
         return {
           exitCode: localResult.exitCode,
@@ -13673,19 +14299,19 @@ import { homedir as nodeHomedir } from "node:os";
 import { join as join10 } from "node:path";
 import * as nodeFs from "node:fs";
 import { spawn as nodeSpawn } from "node:child_process";
-function resolveNoloHome2(env, homedir11 = nodeHomedir) {
+function resolveNoloHome2(env, homedir10 = nodeHomedir) {
   const fromEnv = env?.NOLO_HOME;
   if (typeof fromEnv === "string" && fromEnv.length > 0) return fromEnv;
-  return join10(homedir11(), ".nolo");
+  return join10(homedir10(), ".nolo");
 }
-function resolveRunsDir(env, homedir11 = nodeHomedir) {
-  return join10(resolveNoloHome2(env, homedir11), "runs");
+function resolveRunsDir(env, homedir10 = nodeHomedir) {
+  return join10(resolveNoloHome2(env, homedir10), "runs");
 }
-function resolveRunRecordPath(runId, env, homedir11 = nodeHomedir) {
-  return join10(resolveRunsDir(env, homedir11), `${runId}.json`);
+function resolveRunRecordPath(runId, env, homedir10 = nodeHomedir) {
+  return join10(resolveRunsDir(env, homedir10), `${runId}.json`);
 }
-function resolveRunLogPath(runId, env, homedir11 = nodeHomedir) {
-  return join10(resolveRunsDir(env, homedir11), `${runId}.log`);
+function resolveRunLogPath(runId, env, homedir10 = nodeHomedir) {
+  return join10(resolveRunsDir(env, homedir10), `${runId}.log`);
 }
 function defaultGenerateRunId() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -13693,13 +14319,13 @@ function defaultGenerateRunId() {
   return `run-${timestamp}-${random}`;
 }
 function writeRunRecord(record, deps = {}) {
-  const fs5 = deps.fs ?? nodeFs;
+  const fs6 = deps.fs ?? nodeFs;
   const path8 = resolveRunRecordPath(record.runId, deps.env, deps.homedir);
-  fs5.mkdirSync(resolveRunsDir(deps.env, deps.homedir), { recursive: true });
-  fs5.writeFileSync(path8, JSON.stringify(record, null, 2));
+  fs6.mkdirSync(resolveRunsDir(deps.env, deps.homedir), { recursive: true });
+  fs6.writeFileSync(path8, JSON.stringify(record, null, 2));
 }
 function createRunActivityTracker(runId, deps = {}, options = {}) {
-  const fs5 = deps.fs ?? nodeFs;
+  const fs6 = deps.fs ?? nodeFs;
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const minWriteIntervalMs = options.minWriteIntervalMs ?? DEFAULT_ACTIVITY_WRITE_INTERVAL_MS;
   let lastEventAt = now().toISOString();
@@ -13773,20 +14399,20 @@ function createRunActivityTracker(runId, deps = {}, options = {}) {
   return { onLoopEvent, getActivity, flush, dispose };
 }
 function readRunRecord(runId, deps = {}) {
-  const fs5 = deps.fs ?? nodeFs;
+  const fs6 = deps.fs ?? nodeFs;
   const path8 = resolveRunRecordPath(runId, deps.env, deps.homedir);
   try {
-    return JSON.parse(fs5.readFileSync(path8, "utf8"));
+    return JSON.parse(fs6.readFileSync(path8, "utf8"));
   } catch {
     return null;
   }
 }
 function listRunRecords(deps = {}) {
-  const fs5 = deps.fs ?? nodeFs;
+  const fs6 = deps.fs ?? nodeFs;
   const dir = resolveRunsDir(deps.env, deps.homedir);
   let entries = [];
   try {
-    entries = fs5.readdirSync(dir);
+    entries = fs6.readdirSync(dir);
   } catch {
     return [];
   }
@@ -13832,16 +14458,16 @@ function buildAgentRunChildCommand(options) {
 }
 async function spawnLocalBackgroundRun(input2, deps = {}) {
   const env = deps.env ?? process.env;
-  const homedir11 = deps.homedir ?? nodeHomedir;
-  const fs5 = deps.fs ?? nodeFs;
+  const homedir10 = deps.homedir ?? nodeHomedir;
+  const fs6 = deps.fs ?? nodeFs;
   const spawn5 = deps.spawn ?? nodeSpawn;
   const generateRunId = deps.generateRunId ?? defaultGenerateRunId;
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const runId = generateRunId();
-  const logPath = resolveRunLogPath(runId, env, homedir11);
-  const recordPath = resolveRunRecordPath(runId, env, homedir11);
-  const runsDir = resolveRunsDir(env, homedir11);
-  fs5.mkdirSync(runsDir, { recursive: true });
+  const logPath = resolveRunLogPath(runId, env, homedir10);
+  const recordPath = resolveRunRecordPath(runId, env, homedir10);
+  const runsDir = resolveRunsDir(env, homedir10);
+  fs6.mkdirSync(runsDir, { recursive: true });
   const record = {
     runId,
     agentKey: input2.agentKey,
@@ -13852,7 +14478,7 @@ async function spawnLocalBackgroundRun(input2, deps = {}) {
     status: "running",
     logPath
   };
-  fs5.writeFileSync(recordPath, JSON.stringify(record, null, 2));
+  fs6.writeFileSync(recordPath, JSON.stringify(record, null, 2));
   const { execPath, childArgs } = buildAgentRunChildCommand({
     rawArgs: input2.rawArgs,
     commandPath: input2.commandPath,
@@ -13863,7 +14489,7 @@ async function spawnLocalBackgroundRun(input2, deps = {}) {
     NOLO_AGENT_RUN_CHILD: "1",
     NOLO_AGENT_RUN_ID: runId
   };
-  const logFd = fs5.openSync(logPath, "a");
+  const logFd = fs6.openSync(logPath, "a");
   const proc = spawn5(execPath, childArgs, {
     cwd: input2.cwd,
     env: childEnv,
@@ -13873,7 +14499,7 @@ async function spawnLocalBackgroundRun(input2, deps = {}) {
   proc.unref();
   if (typeof proc.pid === "number") {
     record.pid = proc.pid;
-    fs5.writeFileSync(recordPath, JSON.stringify(record, null, 2));
+    fs6.writeFileSync(recordPath, JSON.stringify(record, null, 2));
   }
   return { runId, pid: proc.pid, logPath };
 }
@@ -13926,9 +14552,9 @@ function formatDuration(startedAt, endedAt) {
   return `${seconds}s`;
 }
 function readLastLogLines(logPath, count, deps) {
-  const fs5 = deps.fs ?? nodeFs;
+  const fs6 = deps.fs ?? nodeFs;
   try {
-    const content = fs5.readFileSync(logPath, "utf8");
+    const content = fs6.readFileSync(logPath, "utf8");
     const lines = content.split("\n");
     if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
     return lines.slice(-count);
@@ -13937,9 +14563,9 @@ function readLastLogLines(logPath, count, deps) {
   }
 }
 function readLogContent(logPath, tailCount, deps) {
-  const fs5 = deps.fs ?? nodeFs;
+  const fs6 = deps.fs ?? nodeFs;
   try {
-    const content = fs5.readFileSync(logPath, "utf8");
+    const content = fs6.readFileSync(logPath, "utf8");
     if (typeof tailCount === "number" && tailCount > 0) {
       const lines = content.split("\n");
       if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
@@ -14206,8 +14832,8 @@ async function runAgentLogsCommand(args2, deps) {
 `);
     return 1;
   }
-  const fs5 = deps.fs ?? nodeFs;
-  if (!fs5.existsSync(record.logPath)) {
+  const fs6 = deps.fs ?? nodeFs;
+  if (!fs6.existsSync(record.logPath)) {
     deps.output.write(`Log not found: ${record.logPath}
 `);
     return 1;
@@ -14750,7 +15376,6 @@ __export(agentRunCommand_exports, {
   resolveWorkflowReference: () => resolveWorkflowReference,
   runAgentRunCommand: () => runAgentRunCommand
 });
-import { homedir as homedir6 } from "node:os";
 function resolvePositiveMs(value, fallback) {
   return parsePositiveFiniteNumberOrFallback(value, fallback);
 }
@@ -14923,7 +15548,7 @@ async function runAgentRunCommand(args2, deps) {
   }
   let localRuntimeCwd = parsed.cwd;
   if (!localRuntimeCwd && parsed.runtimeMode === "local") {
-    localRuntimeCwd = homedir6();
+    localRuntimeCwd = process.cwd();
   }
   const runEnv = buildLocalRunEnv({
     env,
@@ -14936,7 +15561,7 @@ async function runAgentRunCommand(args2, deps) {
         commandPath: deps.commandPath,
         cliEntrypointPath: deps.cliEntrypointPath,
         agentKey,
-        cwd: parsed.cwd,
+        cwd: localRuntimeCwd,
         msgFile: readFlagValue(args2, "--msg-file"),
         timeoutMs: parsed.timeoutMs,
         output: output2
@@ -15455,12 +16080,14 @@ function buildCompanionKeys(rawId, userId) {
 }
 function normalizeListedAgent(record) {
   const privateKey = typeof record?.dbKey === "string" ? record.dbKey : "";
-  if (privateKey.startsWith("cybot-")) return null;
   const explicitId = typeof record?.id === "string" && record.id ? record.id : void 0;
   const ownerUserId = typeof record?.userId === "string" ? record.userId : "";
   const rawId = explicitId || (ownerUserId && privateKey.startsWith(`agent-${ownerUserId}-`) ? privateKey.slice(`agent-${ownerUserId}-`.length) : parseAgentRecordId(privateKey, explicitId));
   if (!privateKey || !rawId || !ownerUserId) return null;
   const keys = buildCompanionKeys(rawId, ownerUserId);
+  const credentialConfigured = agentRecordHasConfiguredCredential(record);
+  const credentialRef = typeof record?.credentialRef === "string" && record.credentialRef ? record.credentialRef : void 0;
+  const apiKeyRef = typeof record?.apiKeyRef === "string" && record.apiKeyRef ? record.apiKeyRef : void 0;
   return {
     id: rawId,
     privateKey,
@@ -15471,7 +16098,10 @@ function normalizeListedAgent(record) {
     isPublicFlag: !!record?.isPublic,
     publicRecordExists: false,
     type: typeof record?.type === "string" ? record.type : null,
-    tools: Array.isArray(record?.tools) ? record.tools.filter((tool) => typeof tool === "string") : []
+    tools: Array.isArray(record?.tools) ? record.tools.filter((tool) => typeof tool === "string") : [],
+    credentialConfigured,
+    credentialRef,
+    apiKeyRef
   };
 }
 function sortListedAgents(agents) {
@@ -15486,8 +16116,7 @@ function parseAgentListArgs(args2) {
   return {
     wantJson: args2.includes("--json"),
     publicOnly: args2.includes("--public-only"),
-    idsOnly: args2.includes("--ids-only"),
-    includeLegacy: args2.includes("--include-legacy")
+    idsOnly: args2.includes("--ids-only")
   };
 }
 async function listLocalCachedAgents(args2) {
@@ -15576,6 +16205,7 @@ var init_agentListHelpers = __esm({
   "packages/cli/agentListHelpers.ts"() {
     "use strict";
     init_globalRecordOperations();
+    init_agentRecordHelpers();
   }
 });
 
@@ -15632,7 +16262,7 @@ __export(agentListCommands_exports, {
 async function runAgentListCommand(args2, deps = {}) {
   const env = deps.env ?? process.env;
   const output2 = deps.output ?? process.stdout;
-  const { wantJson, publicOnly, idsOnly, includeLegacy } = parseAgentListArgs(args2);
+  const { wantJson, publicOnly, idsOnly } = parseAgentListArgs(args2);
   const spaceInput = readOption2(args2, "--space") ?? readOption2(args2, "--space-id");
   const authToken = resolveAuthToken(args2, env);
   if (!authToken) {
@@ -15657,7 +16287,6 @@ async function runAgentListCommand(args2, deps = {}) {
         authToken,
         fallbackFetchImpl,
         fetchImpl,
-        includeLegacy,
         serverUrls,
         userId
       });
@@ -15674,7 +16303,6 @@ async function runAgentListCommand(args2, deps = {}) {
           authToken,
           fallbackFetchImpl,
           fetchImpl,
-          includeLegacy,
           serverUrl,
           userId,
           queryUserRecords,
@@ -15683,9 +16311,7 @@ async function runAgentListCommand(args2, deps = {}) {
         source = "remote-cache";
       }
     }
-    if (!includeLegacy) {
-      agents = agents.filter((agent) => agent.privateKey.startsWith("agent-"));
-    }
+    agents = agents.filter((agent) => agent.privateKey.startsWith("agent-"));
     let resolvedSpaceId = null;
     if (spaceInput) {
       const { spaceId, spaceKey } = buildSpaceLookup(spaceInput);
@@ -15760,6 +16386,7 @@ async function runAgentListCommand(args2, deps = {}) {
     for (const agent of agents) {
       const status = agent.publicRecordExists ? "public" : "private";
       const flagMismatch = agent.isPublicFlag !== agent.publicRecordExists ? ` flag=${agent.isPublicFlag}` : "";
+      const credentialLine = agent.credentialConfigured ? `credentialConfigured=true${agent.credentialRef ? ` credentialRef=${agent.credentialRef}` : ""}${agent.apiKeyRef ? ` apiKeyRef=${agent.apiKeyRef}` : ""}` : "credentialConfigured=false";
       output2.write(
         [
           `
@@ -15770,7 +16397,8 @@ async function runAgentListCommand(args2, deps = {}) {
           `updatedAt=${agent.updatedAt ?? "-"}`,
           `privateKey=${agent.privateKey}`,
           `publicKey=${agent.publicKey}${flagMismatch}`,
-          `tools=${agent.tools.join(", ") || "-"}`
+          `tools=${agent.tools.join(", ") || "-"}`,
+          credentialLine
         ].join("\n")
       );
       output2.write("\n");
@@ -17133,7 +17761,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { basename, dirname as dirname6, join as join12 } from "node:path";
 function readChatgptWebImageLocalJobMeta(payload) {
   if (!isRecord(payload)) return null;
@@ -17274,7 +17902,7 @@ async function runChatgptWebImageLocalJob(input2, deps = {}) {
   if (!prompt) {
     throw new Error("\u7F3A\u5C11\u751F\u56FE prompt\uFF08payload.meta.prompt \u5FC5\u586B\uFF09");
   }
-  const home = (deps.homedir ?? homedir7)();
+  const home = (deps.homedir ?? homedir6)();
   const lockPath = deps.lockPath ?? defaultLockPath(home);
   const outDir = deps.outDir ?? defaultOutDir(home);
   const release2 = acquireChatgptWebImageLock(lockPath);
@@ -19912,7 +20540,7 @@ var init_dialogCommands = __esm({
 
 // packages/cli/docPageHelpers.ts
 import { readFileSync as readFileSync10 } from "node:fs";
-import { ulid as ulid3 } from "ulid";
+import { ulid as ulid4 } from "ulid";
 function getCliArg(args2, flag) {
   const idx = args2.indexOf(flag);
   return idx !== -1 ? args2[idx + 1] : void 0;
@@ -19931,7 +20559,7 @@ function textToSlate(text) {
   }));
 }
 function createPageId() {
-  return ulid3();
+  return ulid4();
 }
 function buildPageKey(userId, pageId) {
   return `page-${userId}-${pageId}`;
@@ -20976,7 +21604,9 @@ var init_docDeleteCommands = __esm({
 // packages/cli/memoryCommands.ts
 var memoryCommands_exports = {};
 __export(memoryCommands_exports, {
-  runMemoryDeleteCommand: () => runMemoryDeleteCommand
+  runMemoryDeleteCommand: () => runMemoryDeleteCommand,
+  runMemoryListCommand: () => runMemoryListCommand,
+  runMemoryRememberCommand: () => runMemoryRememberCommand
 });
 function hasFlag4(args2, flag) {
   return args2.includes(flag);
@@ -21182,7 +21812,232 @@ async function runMemoryDeleteCommand(args2, deps = {}) {
     return 1;
   }
 }
-var VALUE_FLAGS2;
+function printMemoryListUsage(output2) {
+  output2.write(`Usage:
+  nolo memory list [--limit 50] [--kind episodic] [--subject-type agent]
+  nolo memory list --subject-type agent --subject <subjectId> --json
+
+Options:
+  --limit <n>               Page size (1-200, default 50).
+  --cursor <cursor>         Continue from a previous page's nextCursor.
+  --kind <kind>             Filter episodic / semantic / procedural.
+  --subject-type <type>     Filter user / agent / space / project / system.
+  --subject <subjectId>    Filter subjectId (requires --subject-type).
+  --json                    Print machine-readable JSON.
+  --server <url>            Prefer this server and include known Nolo peers.
+  --token <jwt>             Override AUTH_TOKEN.
+
+Listing is scoped to the authenticated user's memories.
+`);
+}
+function buildListBody(args2) {
+  const body = {};
+  const limit = readLimit(args2);
+  if (typeof limit === "number") body.limit = limit;
+  const cursor = readOption2(args2, "--cursor")?.trim();
+  if (cursor) body.cursor = cursor;
+  const kind = readOption2(args2, "--kind")?.trim();
+  if (kind) body.kind = kind;
+  const subjectType = readOption2(args2, "--subject-type")?.trim();
+  if (subjectType) body.subjectType = subjectType;
+  const subjectId = (readOption2(args2, "--subject") ?? readOption2(args2, "--subject-id"))?.trim();
+  if (subjectId) body.subjectId = subjectId;
+  return body;
+}
+function parseMemoryResponse(text) {
+  if (!text) return { result: null, errorMessage: void 0 };
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed === "object" && parsed !== null && "error" in parsed) {
+      const err = parsed.error;
+      const message = typeof err === "object" && err !== null && "message" in err ? String(err.message ?? "") : "";
+      return { result: parsed, errorMessage: message || parsed.message };
+    }
+    return { result: parsed, errorMessage: void 0 };
+  } catch {
+    return { result: { raw: text }, errorMessage: void 0 };
+  }
+}
+async function postMemoryList(args2) {
+  const res = await args2.fetchImpl(`${args2.serverUrl}/api/memory/list`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args2.authToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(args2.body)
+  });
+  const text = await res.text();
+  const parsed = parseMemoryResponse(text);
+  if (!res.ok) {
+    throw new Error(parsed.errorMessage ?? `HTTP ${res.status}`);
+  }
+  if (parsed.errorMessage) {
+    throw new Error(parsed.errorMessage);
+  }
+  return parsed.result;
+}
+function renderMemoryItem(item) {
+  if (typeof item !== "object" || item === null) return String(item);
+  const record = item;
+  const parts = [];
+  if (record.id) parts.push(record.id);
+  if (record.kind) parts.push(`kind=${record.kind}`);
+  if (record.subjectType) parts.push(`subject=${record.subjectType}${record.subjectId ? `:${record.subjectId}` : ""}`);
+  if (record.scope) parts.push(`scope=${record.scope}`);
+  const content = record.content ? record.content.length > 80 ? `${record.content.slice(0, 80)}\u2026` : record.content : "";
+  return [parts.join("  "), content].filter(Boolean).join("\n    ");
+}
+async function runMemoryListCommand(args2, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output2 = deps.output ?? process.stdout;
+  if (hasFlag4(args2, "--help") || hasFlag4(args2, "-h")) {
+    printMemoryListUsage(output2);
+    return 0;
+  }
+  try {
+    assertNoUnknownFlags(args2);
+    const authToken = resolveAuthToken(args2, env);
+    if (!authToken) {
+      output2.write("[nolo] memory list requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+      return 1;
+    }
+    const body = buildListBody(args2);
+    const wantJson = hasFlag4(args2, "--json");
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const serverUrl = resolveServerUrl(args2, env);
+    const serverUrls = resolveServerCandidates(args2, env, serverUrl);
+    const target = serverUrls[0] ?? serverUrl;
+    try {
+      const result = await postMemoryList({ authToken, body, fetchImpl, serverUrl: target });
+      const items = Array.isArray(result.items) ? result.items : [];
+      if (wantJson) {
+        output2.write(`${JSON.stringify({ items, nextCursor: result.nextCursor, truncated: result.truncated }, null, 2)}
+`);
+      } else {
+        output2.write(`${target}: ${items.length} memor${items.length === 1 ? "y" : "ies"}
+`);
+        for (const item of items) {
+          output2.write(`  ${renderMemoryItem(item)}
+`);
+        }
+        if (result.nextCursor) {
+          output2.write(`nextCursor: ${result.nextCursor}
+`);
+        }
+        if (result.truncated) {
+          output2.write("truncated: true (more entries may exist; page with --cursor)\n");
+        }
+      }
+      return 0;
+    } catch (error) {
+      output2.write(`[nolo] memory list failed: ${toErrorMessage(error)}
+`);
+      return 1;
+    }
+  } catch (error) {
+    output2.write(`[nolo] memory list failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+}
+function printMemoryRememberUsage(output2) {
+  output2.write(`Usage:
+  nolo memory remember --content "\u7528\u6237\u504F\u597D\u5148\u770B\u7ED3\u8BBA" --kind semantic
+  nolo memory remember --content "..." --kind episodic --scope auto --dialog-id <id>
+
+Options:
+  --content <text>         The memory text to store (required).
+  --kind <kind>            episodic / semantic / procedural (required).
+  --scope <scope>          auto / user / space (default auto).
+  --dialog-id <id>         Attach to a dialog.
+  --space <spaceId>        Store under a space (requires space membership).
+  --json                    Print machine-readable JSON.
+  --server <url>            Prefer this server and include known Nolo peers.
+  --token <jwt>             Override AUTH_TOKEN.
+`);
+}
+function buildRememberBody(args2) {
+  const content = readOption2(args2, "--content")?.trim();
+  const kind = readOption2(args2, "--kind")?.trim();
+  const scope = readOption2(args2, "--scope")?.trim();
+  const dialogId = readOption2(args2, "--dialog-id")?.trim();
+  const spaceId = readOption2(args2, "--space")?.trim();
+  return { content, kind, scope, dialogId, spaceId };
+}
+async function postMemoryRemember(args2) {
+  const res = await args2.fetchImpl(`${args2.serverUrl}/api/memory/remember`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args2.authToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(args2.body)
+  });
+  const text = await res.text();
+  const parsed = parseMemoryResponse(text);
+  if (!res.ok) {
+    throw new Error(parsed.errorMessage ?? `HTTP ${res.status}`);
+  }
+  if (parsed.errorMessage) {
+    throw new Error(parsed.errorMessage);
+  }
+  return parsed.result;
+}
+async function runMemoryRememberCommand(args2, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output2 = deps.output ?? process.stdout;
+  if (hasFlag4(args2, "--help") || hasFlag4(args2, "-h")) {
+    printMemoryRememberUsage(output2);
+    return 0;
+  }
+  try {
+    assertNoUnknownFlags(args2);
+    const authToken = resolveAuthToken(args2, env);
+    if (!authToken) {
+      output2.write("[nolo] memory remember requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+      return 1;
+    }
+    const { content, kind, scope, dialogId, spaceId } = buildRememberBody(args2);
+    if (!content) {
+      output2.write("[nolo] memory remember requires --content <text>; use --help for examples.\n");
+      return 1;
+    }
+    if (!kind || !REMEMBER_KINDS.has(kind)) {
+      output2.write("[nolo] memory remember requires --kind <episodic|semantic|procedural>.\n");
+      return 1;
+    }
+    const normalizedScope = scope && REMEMBER_SCOPES.has(scope) ? scope : "auto";
+    const body = { content, kind, scope: normalizedScope };
+    if (dialogId) body.dialogId = dialogId;
+    if (spaceId) body.spaceId = spaceId;
+    const wantJson = hasFlag4(args2, "--json");
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const serverUrl = resolveServerUrl(args2, env);
+    const serverUrls = resolveServerCandidates(args2, env, serverUrl);
+    const target = serverUrls[0] ?? serverUrl;
+    try {
+      const result = await postMemoryRemember({ authToken, body, fetchImpl, serverUrl: target });
+      if (wantJson) {
+        output2.write(`${JSON.stringify(result, null, 2)}
+`);
+      } else {
+        output2.write(`${target}: remembered ${kind}
+`);
+      }
+      return 0;
+    } catch (error) {
+      output2.write(`[nolo] memory remember failed: ${toErrorMessage(error)}
+`);
+      return 1;
+    }
+  } catch (error) {
+    output2.write(`[nolo] memory remember failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+}
+var VALUE_FLAGS2, REMEMBER_KINDS, REMEMBER_SCOPES;
 var init_memoryCommands = __esm({
   "packages/cli/memoryCommands.ts"() {
     "use strict";
@@ -21190,14 +22045,19 @@ var init_memoryCommands = __esm({
     init_optionalString();
     init_cliEnvHelpers();
     VALUE_FLAGS2 = /* @__PURE__ */ new Set([
+      "--content",
+      "--cursor",
+      "--dialog-id",
       "--facet",
       "--id",
       "--ids",
       "--kind",
       "--limit",
       "--pattern-prefix",
+      "--scope",
       "--server",
       "--server-url",
+      "--space",
       "--source-dialog",
       "--subject",
       "--subject-id",
@@ -21205,6 +22065,8 @@ var init_memoryCommands = __esm({
       "--tag",
       "--token"
     ]);
+    REMEMBER_KINDS = /* @__PURE__ */ new Set(["episodic", "semantic", "procedural"]);
+    REMEMBER_SCOPES = /* @__PURE__ */ new Set(["auto", "user", "space"]);
   }
 });
 
@@ -21452,7 +22314,7 @@ __export(spaceCommands_exports, {
   runSpaceInviteCommand: () => runSpaceInviteCommand,
   runSpaceUploadCommand: () => runSpaceUploadCommand
 });
-import { ulid as ulid4 } from "ulid";
+import { ulid as ulid5 } from "ulid";
 import { readFileSync as readFileSync11 } from "node:fs";
 import { basename as basename2, extname as extname4 } from "node:path";
 function hasHelpArg2(args2) {
@@ -21548,7 +22410,7 @@ async function runSpaceCreateCommand(args2, deps) {
   const { authToken, userId } = requireTokenUser2(args2, deps.env);
   const serverUrl = resolveServerUrl(args2, deps.env);
   const fetchImpl = deps.fetchImpl ?? fetch;
-  const spaceId = normalizeSpaceId(readOption2(args2, "--id") ?? ulid4());
+  const spaceId = normalizeSpaceId(readOption2(args2, "--id") ?? ulid5());
   const now = Date.now();
   const nowISO = new Date(now).toISOString();
   const visibilityRaw = readOption2(args2, "--visibility");
@@ -21763,7 +22625,7 @@ async function runSpaceUploadCommand(args2, deps) {
   });
   const formData = new FormData();
   formData.append("file", new Blob([fileContent], { type: mimeType }), uploadName);
-  const fileId = ulid4();
+  const fileId = ulid5();
   const fileDbKey = `file-${userId}-${fileId}`;
   formData.append("metadata", JSON.stringify({
     id: fileId,
@@ -22581,9 +23443,9 @@ var init_noloServerUrl = __esm({
 // packages/cli/client/profileConfig.ts
 import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname7, join as join13 } from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 function getDefaultProfileConfigPath() {
-  return join13(homedir8(), ".nolo", "config.json");
+  return join13(homedir7(), ".nolo", "config.json");
 }
 function loadProfileConfig(path8 = getDefaultProfileConfigPath()) {
   if (!existsSync11(path8)) return null;
@@ -23611,7 +24473,7 @@ var init_heartbeatLoop = __esm({
 // packages/cli/machineDaemonCommands.ts
 import { spawn as spawn4 } from "node:child_process";
 import { existsSync as existsSync12, mkdirSync as mkdirSync7, openSync, readFileSync as readFileSync13, readdirSync as readdirSync2, realpathSync } from "node:fs";
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import { dirname as dirname8, isAbsolute as isAbsolute2, join as join14, relative as relative2, resolve as resolve6 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function readJsonFile(path8) {
@@ -23718,7 +24580,7 @@ async function checkConnectorWorkspaceLinks(cwd, output2, validateWorkspaceLinks
   return false;
 }
 function resolveDaemonLogPath(env) {
-  return env.NOLO_CONNECT_LOG || join14(homedir9(), ".nolo", "logs", "connector.log");
+  return env.NOLO_CONNECT_LOG || join14(homedir8(), ".nolo", "logs", "connector.log");
 }
 function buildDaemonCommand(cliEntrypointPath) {
   const execPath = process.execPath;
@@ -24322,9 +25184,87 @@ var init_machineCommands = __esm({
   }
 });
 
+// packages/cli/cliAuthorityBrokerHealth.ts
+import fs5 from "node:fs/promises";
+function asBrokerHealthRecord(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+async function probeCliAuthorityBrokerHealth(args2) {
+  const deps = {
+    ...defaultCliAuthorityBrokerHealthDeps,
+    ...args2.deps
+  };
+  let metadata;
+  let health;
+  try {
+    [metadata, health] = await Promise.all([
+      deps.readJson(args2.metadataPath).then(asBrokerHealthRecord),
+      deps.readJson(args2.healthPath).then(asBrokerHealthRecord)
+    ]);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `authority broker health artifacts are unavailable: ${toErrorMessage(error)}`
+    };
+  }
+  if (health.ok !== true) {
+    return { ok: false, error: "authority broker health artifact is not ok" };
+  }
+  if (typeof metadata.endpoint !== "string" || metadata.endpoint !== args2.endpoint || health.endpoint !== args2.endpoint) {
+    return { ok: false, error: "authority broker endpoint metadata does not match" };
+  }
+  if (typeof metadata.pid !== "number" || !Number.isInteger(metadata.pid) || metadata.pid <= 0 || health.pid !== metadata.pid) {
+    return { ok: false, error: "authority broker pid metadata is invalid" };
+  }
+  if (!deps.isPidAlive(metadata.pid)) {
+    return {
+      ok: false,
+      error: `authority broker metadata pid ${metadata.pid} is not alive`
+    };
+  }
+  try {
+    await deps.openEndpoint(args2.endpoint);
+  } catch (error) {
+    return {
+      ok: false,
+      error: `authority broker endpoint is unreachable: ${toErrorMessage(error)}`
+    };
+  }
+  return { ok: true };
+}
+var defaultCliAuthorityBrokerHealthDeps;
+var init_cliAuthorityBrokerHealth = __esm({
+  "packages/cli/cliAuthorityBrokerHealth.ts"() {
+    "use strict";
+    init_errorMessage();
+    init_cliAuthorityBrokerClient();
+    defaultCliAuthorityBrokerHealthDeps = {
+      async readJson(filePath) {
+        return JSON.parse(await fs5.readFile(filePath, "utf8"));
+      },
+      isPidAlive(pid) {
+        try {
+          process.kill(pid, 0);
+          return true;
+        } catch (error) {
+          return error.code === "EPERM";
+        }
+      },
+      async openEndpoint(endpoint) {
+        const client = createCliAuthorityBrokerClient({
+          endpoint,
+          invoke: createCliAuthorityBrokerSocketInvoker({ endpoint })
+        });
+        await client.open();
+      }
+    };
+  }
+});
+
 // packages/cli/runtimeDoctorCommands.ts
 var runtimeDoctorCommands_exports = {};
 __export(runtimeDoctorCommands_exports, {
+  defaultLocalRuntimeProbe: () => defaultLocalRuntimeProbe,
   runDoctorRuntimeCommand: () => runDoctorRuntimeCommand
 });
 function detectLocalAgentConfig(env) {
@@ -24347,7 +25287,7 @@ function detectProviderLabel(env) {
   if (env.GEMINI_API_KEY) return "google via env GEMINI_API_KEY";
   return "missing";
 }
-async function defaultLocalRuntimeProbe(env) {
+async function defaultLocalRuntimeProbe(env, deps = {}) {
   const { resolveCliLocalRuntimeDbPath: resolveCliLocalRuntimeDbPath3 } = await Promise.resolve().then(() => (init_localRuntimeDb(), localRuntimeDb_exports));
   const dbPath = resolveCliLocalRuntimeDbPath3({ env });
   const authorityDriver = resolveCliAuthorityStoreDriver({ env });
@@ -24356,8 +25296,28 @@ async function defaultLocalRuntimeProbe(env) {
   const authorityHealthPath = resolveCliAuthorityBrokerHealthPath({ transport: "tcp", env });
   const agentKey = readLocalAgentKey(env);
   try {
-    const { getDefaultCliLocalRuntimeDb: getDefaultCliLocalRuntimeDb4 } = await Promise.resolve().then(() => (init_localRuntimeDb(), localRuntimeDb_exports));
-    const db = await getDefaultCliLocalRuntimeDb4({ env });
+    const db = deps.getDb ? await deps.getDb() : await Promise.resolve().then(() => (init_localRuntimeDb(), localRuntimeDb_exports)).then(
+      ({ getDefaultCliLocalRuntimeDb: getDefaultCliLocalRuntimeDb4 }) => getDefaultCliLocalRuntimeDb4({ env })
+    );
+    const authorityHealth = await (deps.probeAuthorityHealth ?? probeCliAuthorityBrokerHealth)({
+      endpoint: authorityEndpoint,
+      metadataPath: authorityMetadataPath,
+      healthPath: authorityHealthPath
+    });
+    if (!authorityHealth.ok) {
+      return {
+        ok: true,
+        dbPath,
+        authorityDriver,
+        authorityEndpoint,
+        authorityMetadataPath,
+        authorityHealthPath,
+        authorityHealthy: false,
+        authorityError: authorityHealth.error,
+        agentFound: false,
+        ...agentKey ? { agentKey } : {}
+      };
+    }
     if (!agentKey) {
       return {
         ok: true,
@@ -24366,6 +25326,7 @@ async function defaultLocalRuntimeProbe(env) {
         authorityEndpoint,
         authorityMetadataPath,
         authorityHealthPath,
+        authorityHealthy: true,
         agentFound: false
       };
     }
@@ -24378,6 +25339,7 @@ async function defaultLocalRuntimeProbe(env) {
         authorityEndpoint,
         authorityMetadataPath,
         authorityHealthPath,
+        authorityHealthy: true,
         agentFound: record != null,
         agentKey
       };
@@ -24389,11 +25351,13 @@ async function defaultLocalRuntimeProbe(env) {
         authorityEndpoint,
         authorityMetadataPath,
         authorityHealthPath,
+        authorityHealthy: true,
         agentFound: false,
         agentKey
       };
     }
   } catch (error) {
+    const errorMessage = toErrorMessage(error);
     return {
       ok: false,
       dbPath,
@@ -24401,9 +25365,11 @@ async function defaultLocalRuntimeProbe(env) {
       authorityEndpoint,
       authorityMetadataPath,
       authorityHealthPath,
+      authorityHealthy: false,
+      authorityError: errorMessage,
       agentFound: false,
       ...agentKey ? { agentKey } : {},
-      error: toErrorMessage(error)
+      error: errorMessage
     };
   }
 }
@@ -24417,6 +25383,7 @@ async function runDoctorRuntimeCommand(args2, deps = {}) {
   const hasLocalProvider = detectLocalProvider(env);
   const missingLocalCapabilities = [
     ...localProbe.ok ? [] : ["leveldb"],
+    ...localProbe.authorityHealthy === false ? ["authority-broker"] : [],
     ...hasLocalAgentConfig ? [] : ["agent-config"],
     ...hasLocalProvider ? [] : ["provider"]
   ];
@@ -24453,6 +25420,14 @@ async function runDoctorRuntimeCommand(args2, deps = {}) {
   }
   if (localProbe.authorityHealthPath) {
     output2.write(`Authority health: ${localProbe.authorityHealthPath}
+`);
+  }
+  output2.write(
+    `Authority broker: ${localProbe.authorityHealthy === true ? "healthy" : localProbe.authorityHealthy === false ? "unhealthy" : "unknown"}
+`
+  );
+  if (localProbe.authorityHealthy === false && localProbe.authorityError) {
+    output2.write(`Authority error: ${localProbe.authorityError}
 `);
   }
   if (!localProbe.ok && localProbe.error) {
@@ -24488,6 +25463,7 @@ var init_runtimeDoctorCommands = __esm({
     init_runtimeDecision();
     init_cliAuthorityStoreDriver();
     init_cliEnvHelpers();
+    init_cliAuthorityBrokerHealth();
   }
 });
 
@@ -24773,7 +25749,9 @@ __export(tableCommands_exports, {
   runTableDeleteRowCommand: () => runTableDeleteRowCommand,
   runTableDeleteRowsCommand: () => runTableDeleteRowsCommand,
   runTableListCommand: () => runTableListCommand,
+  runTablePurgeRowsCommand: () => runTablePurgeRowsCommand,
   runTableQueryCommand: () => runTableQueryCommand,
+  runTableRemoveRowFieldsCommand: () => runTableRemoveRowFieldsCommand,
   runTableUpdateRowCommand: () => runTableUpdateRowCommand,
   runTableUpdateRowsCommand: () => runTableUpdateRowsCommand
 });
@@ -25636,6 +26614,124 @@ async function postTableJson(deps, ctx, path8, body) {
   }
   return { ok: true, payload };
 }
+function parseNonEmptyStringArray(flag, raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`${flag} must be valid JSON: ${toErrorMessage(error)}`);
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0 || !parsed.every((value) => typeof value === "string" && value.trim().length > 0)) {
+    throw new Error(`${flag} must be a non-empty JSON array of strings.`);
+  }
+  return [...new Set(parsed.map((value) => value.trim()))];
+}
+function readAffectedCount(payload) {
+  if (!isRecord(payload)) return 0;
+  const direct = asOptionalFiniteNumber(payload.affectedCount);
+  if (direct !== void 0) return direct;
+  if (isRecord(payload.rawData)) {
+    return asOptionalFiniteNumber(payload.rawData.affectedCount) ?? 0;
+  }
+  return 0;
+}
+async function runExactTableMaintenanceCommand(input2) {
+  const env = input2.deps.env ?? process.env;
+  const output2 = input2.deps.output ?? process.stdout;
+  if (hasFlag7(input2.args, "--help") || hasFlag7(input2.args, "-h")) {
+    output2.write(input2.usage);
+    return 0;
+  }
+  const tableDbKey = readOption5(input2.args, "--table").trim();
+  if (!tableDbKey || !tableDbKey.startsWith("meta-")) {
+    output2.write(`[nolo] table ${input2.action} failed: --table must be an exact table dbKey beginning with "meta-".
+${input2.usage}`);
+    return 1;
+  }
+  const authToken = resolveAuthToken5(input2.args, env);
+  if (!authToken) {
+    output2.write(`[nolo] table ${input2.action} failed: AUTH_TOKEN is required.
+`);
+    return 1;
+  }
+  const rowDbKeysRaw = readOption5(input2.args, "--row-dbkeys");
+  if (!rowDbKeysRaw) {
+    output2.write(`[nolo] table ${input2.action} failed: --row-dbkeys is required.
+${input2.usage}`);
+    return 1;
+  }
+  let rowDbKeys;
+  let fields;
+  try {
+    rowDbKeys = parseNonEmptyStringArray("--row-dbkeys", rowDbKeysRaw);
+    if (!rowDbKeys.every((dbKey) => dbKey.startsWith("row-"))) {
+      throw new Error(
+        '--row-dbkeys must contain exact row dbKeys beginning with "row-".'
+      );
+    }
+    if (input2.requireFields) {
+      const fieldsRaw = readOption5(input2.args, "--fields");
+      if (!fieldsRaw) {
+        output2.write(`[nolo] table ${input2.action} failed: --fields is required.
+${input2.usage}`);
+        return 1;
+      }
+      fields = parseNonEmptyStringArray("--fields", fieldsRaw);
+    }
+  } catch (error) {
+    output2.write(`[nolo] table ${input2.action} failed: ${toErrorMessage(error)}
+${input2.usage}`);
+    return 1;
+  }
+  const execute = hasFlag7(input2.args, "--yes");
+  const body = {
+    tableDbKey,
+    rowDbKeys,
+    ...fields ? { fields } : {},
+    dryRun: !execute,
+    ...execute ? { confirmTableDbKey: tableDbKey } : {}
+  };
+  const result = await postTableJson(
+    input2.deps,
+    { authToken, serverUrl: resolveServerUrl4(input2.args, env) },
+    input2.path,
+    body
+  );
+  if (!result.ok) {
+    output2.write(`[nolo] table ${input2.action} failed: ${result.message}
+`);
+    return 1;
+  }
+  if (hasFlag7(input2.args, "--json") || readOption5(input2.args, "--output") === "json") {
+    output2.write(`${JSON.stringify(result.payload)}
+`);
+    return 0;
+  }
+  const status = execute ? "EXECUTED" : "DRY RUN";
+  output2.write(`[nolo] table ${input2.action} ${status}: affectedCount=${readAffectedCount(result.payload)}
+`);
+  return 0;
+}
+async function runTablePurgeRowsCommand(args2, deps = {}) {
+  return runExactTableMaintenanceCommand({
+    args: args2,
+    deps,
+    action: "purge-rows",
+    path: "/api/table/purge-rows",
+    usage: TABLE_PURGE_ROWS_USAGE,
+    requireFields: false
+  });
+}
+async function runTableRemoveRowFieldsCommand(args2, deps = {}) {
+  return runExactTableMaintenanceCommand({
+    args: args2,
+    deps,
+    action: "remove-row-fields",
+    path: "/api/table/remove-row-fields",
+    usage: TABLE_REMOVE_ROW_FIELDS_USAGE,
+    requireFields: true
+  });
+}
 async function runTableAddColumnCommand(args2, deps = {}) {
   const env = deps.env ?? process.env;
   const output2 = deps.output ?? process.stdout;
@@ -25870,7 +26966,7 @@ ${TABLE_DELETE_ROW_USAGE}`);
 `);
   return 0;
 }
-var MULTI_SERVER_FETCH_LIMIT, DELETE_ROWS_QUERY_PAGE_SIZE, DEFAULT_TABLE_LIST_LIMIT, DEFAULT_TABLE_QUERY_LIMIT, UNBOUNDED_CLIENT_CAP, TABLE_ADD_COLUMN_USAGE, TABLE_ADD_ROW_USAGE, TABLE_ADD_ROWS_USAGE, TABLE_UPDATE_ROW_USAGE, TABLE_UPDATE_ROWS_USAGE, TABLE_DELETE_ROW_USAGE;
+var MULTI_SERVER_FETCH_LIMIT, DELETE_ROWS_QUERY_PAGE_SIZE, DEFAULT_TABLE_LIST_LIMIT, DEFAULT_TABLE_QUERY_LIMIT, UNBOUNDED_CLIENT_CAP, TABLE_ADD_COLUMN_USAGE, TABLE_ADD_ROW_USAGE, TABLE_ADD_ROWS_USAGE, TABLE_UPDATE_ROW_USAGE, TABLE_UPDATE_ROWS_USAGE, TABLE_DELETE_ROW_USAGE, TABLE_PURGE_ROWS_USAGE, TABLE_REMOVE_ROW_FIELDS_USAGE;
 var init_tableCommands = __esm({
   "packages/cli/tableCommands.ts"() {
     "use strict";
@@ -25896,6 +26992,8 @@ var init_tableCommands = __esm({
     TABLE_UPDATE_ROW_USAGE = "Usage:\n  nolo table update-row --table <tableId|metaKey> --row <rowId|rowDbKey> --changes <json-object>\n\n";
     TABLE_UPDATE_ROWS_USAGE = "Usage:\n  nolo table update-rows --table <tableId|metaKey> --updates <non-empty-json-array>\n\n";
     TABLE_DELETE_ROW_USAGE = "Usage:\n  nolo table delete-row --table <tableId|metaKey> --row <rowId|rowDbKey>\n\n";
+    TABLE_PURGE_ROWS_USAGE = "Usage:\n  nolo table purge-rows --table <exact-meta-dbKey> --row-dbkeys <non-empty-json-array> [--yes] [--json]\n\n";
+    TABLE_REMOVE_ROW_FIELDS_USAGE = "Usage:\n  nolo table remove-row-fields --table <exact-meta-dbKey> --row-dbkeys <non-empty-json-array> --fields <non-empty-json-array> [--yes] [--json]\n\n";
   }
 });
 
@@ -25922,7 +27020,7 @@ var init_prefix = __esm({
 });
 
 // packages/cli/client/compactDialog.ts
-import { ulid as ulid5 } from "ulid";
+import { ulid as ulid6 } from "ulid";
 function parseTokenUserId(token) {
   try {
     const parts = token.split(".");
@@ -25947,7 +27045,7 @@ async function readDialogRecord(fetchImpl, serverUrl, authToken, dialogKey) {
   return data;
 }
 function buildForkedDialogRecord(current, userId) {
-  const newId = ulid5();
+  const newId = ulid6();
   const dbKey = `dialog-${userId}-${newId}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const carried = {};
@@ -26103,15 +27201,23 @@ function renderSelectDialog(args2) {
   }
   return lines.join("\n");
 }
-function countRenderedLines(text) {
-  return text.split("\n").length;
+function outputIsTty(output2) {
+  return typeof output2 === "object" && output2 !== null && "isTTY" in output2 && Boolean(output2.isTTY);
 }
 function clearRenderedLines(output2, lineCount) {
-  if (!output2.isTTY || lineCount <= 0) return;
+  if (!outputIsTty(output2) || lineCount <= 0) return;
   for (let index = 0; index < lineCount; index += 1) {
     output2.write("\x1B[1A\x1B[2K");
   }
 }
+function clearAnchoredLines(output2, bottomRow, lineCount) {
+  if (!outputIsTty(output2) || lineCount <= 0) return;
+  for (let index = 0; index < lineCount; index += 1) {
+    const row = bottomRow - index;
+    if (row < 1) break;
+    output2.write(`\x1B[${row};1H\x1B[2K`);
+  }
+}
 function isArrowUp(sequence) {
   return sequence === CSI_ARROW_UP || sequence === CSI_ARROW_UP_APP;
 }
@@ -26155,35 +27261,30 @@ function createRawKeyReader(input2) {
     buffer = "";
     return sequence;
   };
-  return () => new Promise((resolve8) => {
-    const finalize = (sequence) => {
-      cleanup();
-      resolve8(sequence ?? null);
-    };
-    const onReadable = () => {
-      while (true) {
-        const chunk = input2.read();
-        if (chunk == null) break;
-        buffer += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
-        const parsed = tryParseSequence();
-        if (parsed === void 0) return;
-        finalize(parsed);
-        return;
-      }
-    };
-    const cleanup = () => {
-      input2.off("readable", onReadable);
-    };
-    onReadable();
-    if (buffer) {
-      const parsed = tryParseSequence();
-      if (parsed !== void 0) {
-        finalize(parsed);
-        return;
-      }
-    }
-    input2.on("readable", onReadable);
+  let waiter = null;
+  const tryDeliver = () => {
+    if (!waiter || !buffer) return;
+    const parsed = tryParseSequence();
+    if (parsed === void 0) return;
+    const resolve8 = waiter;
+    waiter = null;
+    resolve8(parsed);
+  };
+  const onData = (chunk) => {
+    buffer += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    tryDeliver();
+  };
+  input2.on("data", onData);
+  input2.resume?.();
+  const reader = () => new Promise((resolve8) => {
+    waiter = resolve8;
+    tryDeliver();
   });
+  reader.dispose = () => {
+    waiter = null;
+    input2.off("data", onData);
+  };
+  return reader;
 }
 function drainInputBuffer(input2) {
   if (typeof input2.read !== "function") return;
@@ -26203,8 +27304,9 @@ async function runSelectDialog(args2) {
   const input2 = args2.input ?? process.stdin;
   const readKey = args2.readKey ?? createRawKeyReader(input2);
   const wasRaw = Boolean(input2.isTTY && input2.isRaw);
-  const wasPaused = typeof input2.isPaused === "function" ? input2.isPaused() : false;
   let renderedLineCount = 0;
+  const bottomAnchored = Boolean(args2.bottomAnchored && args2.bottomRow && args2.bottomRow > 0);
+  const bottomRow = args2.bottomRow ?? 0;
   const paint = () => {
     const frame = renderSelectDialog({
       items,
@@ -26212,22 +27314,34 @@ async function runSelectDialog(args2) {
       title: args2.title,
       maxVisible: args2.maxVisible
     });
-    if (output2.isTTY && typeof output2.write === "function") {
+    const lines = frame.split("\n");
+    const lineCount = lines.length;
+    const canPosition = outputIsTty(output2) && typeof output2.write === "function";
+    if (bottomAnchored && canPosition) {
+      clearAnchoredLines(output2, bottomRow, renderedLineCount);
+      for (let i = 0; i < lines.length; i += 1) {
+        const row = bottomRow - (lines.length - 1 - i);
+        if (row < 1) break;
+        output2.write(`\x1B[${row};1H\x1B[2K${lines[i]}`);
+      }
+      renderedLineCount = lineCount;
+      return;
+    }
+    if (canPosition) {
       clearRenderedLines(output2, renderedLineCount);
       output2.write(`${frame}
 `);
-      renderedLineCount = countRenderedLines(frame);
+      renderedLineCount = lineCount;
       return;
     }
     if (typeof output2.write === "function") {
       output2.write(`${frame}
 `);
     }
-    renderedLineCount = countRenderedLines(frame);
+    renderedLineCount = lineCount;
   };
-  if (input2.isTTY) {
-    if (!wasRaw) input2.setRawMode(true);
-    if (!wasPaused) input2.pause();
+  if (input2.isTTY && !wasRaw) {
+    input2.setRawMode(true);
   }
   paint();
   try {
@@ -26254,11 +27368,15 @@ async function runSelectDialog(args2) {
       }
     }
   } finally {
+    readKey.dispose?.();
     if (input2.isTTY) {
       drainInputBuffer(input2);
       if (!wasRaw) input2.setRawMode(false);
-      if (!wasPaused) input2.resume();
-      clearRenderedLines(output2, renderedLineCount);
+      if (bottomAnchored) {
+        clearAnchoredLines(output2, bottomRow, renderedLineCount);
+      } else {
+        clearRenderedLines(output2, renderedLineCount);
+      }
       renderedLineCount = 0;
     }
   }
@@ -26368,7 +27486,6 @@ async function loadAgentCatalog(args2) {
       authToken,
       fallbackFetchImpl,
       fetchImpl,
-      includeLegacy: false,
       serverUrls,
       userId
     });
@@ -26384,7 +27501,6 @@ async function loadAgentCatalog(args2) {
         authToken,
         fallbackFetchImpl,
         fetchImpl,
-        includeLegacy: false,
         serverUrl,
         userId,
         queryUserRecords,
@@ -26468,7 +27584,7 @@ function formatAgentSwitchMessage(args2) {
 async function runAgentPicker(args2) {
   const output2 = args2.output ?? process.stdout;
   const input2 = args2.input ?? process.stdin;
-  const interactive = args2.interactive ?? Boolean(input2.isTTY && output2.isTTY);
+  const interactive = args2.interactive ?? ("isTTY" in input2 && Boolean(input2.isTTY) && "isTTY" in output2 && Boolean(output2.isTTY));
   const entries = await loadAgentCatalog({
     env: args2.env,
     currentKey: args2.currentKey,
@@ -26493,7 +27609,9 @@ async function runAgentPicker(args2) {
     title: void 0,
     input: input2,
     output: output2,
-    readKey: args2.readKey
+    readKey: args2.readKey,
+    bottomAnchored: args2.bottomAnchored,
+    bottomRow: args2.bottomRow
   });
   if (result.kind === "cancelled") {
     return { kind: "cancelled", entries };
@@ -26530,7 +27648,7 @@ var init_agentPicker = __esm({
 // packages/cli/tui/pasteImage.ts
 import { existsSync as existsSync14 } from "node:fs";
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { homedir as homedir10 } from "node:os";
+import { homedir as homedir9 } from "node:os";
 import { isAbsolute as isAbsolute3, resolve as resolve7 } from "node:path";
 function extnameOf(path8) {
   const slash = Math.max(path8.lastIndexOf("/"), path8.lastIndexOf("\\"));
@@ -26546,9 +27664,9 @@ function basenameOf(path8) {
 function resolveImageSource(rawPath, cwd) {
   let candidate = rawPath.trim();
   if (!candidate) return candidate;
-  if (candidate === "~") return homedir10();
+  if (candidate === "~") return homedir9();
   if (candidate.startsWith("~/") || candidate.startsWith("~\\")) {
-    return homedir10() + candidate.slice(1);
+    return homedir9() + candidate.slice(1);
   }
   if (isAbsolute3(candidate)) return candidate;
   return resolve7(cwd, candidate);
@@ -27394,7 +28512,8 @@ __export(readlineWorkspace_exports, {
   takeDisplayWidth: () => takeDisplayWidth,
   truncateAnsi: () => truncateAnsi,
   visibleWidth: () => visibleWidth,
-  wrapTextToLines: () => wrapTextToLines
+  wrapTextToLines: () => wrapTextToLines,
+  wrapTranscriptLine: () => wrapTranscriptLine
 });
 import { createInterface as createInterface2 } from "node:readline";
 import { stdin as defaultInput, stdout as defaultOutput } from "node:process";
@@ -27438,33 +28557,54 @@ function stripAnsi(text) {
   return text.replace(ANSI_ESCAPE_REGEX, "");
 }
 function applyTerminalOutputToText(existing, chunk) {
-  const cleaned = stripAnsi(chunk);
-  if (!cleaned) return existing;
+  if (!chunk) return existing;
   let text = existing;
-  for (const ch of cleaned) {
+  let index = 0;
+  while (index < chunk.length) {
+    if (chunk[index] === "\x1B") {
+      const sgr = SGR_SEQUENCE_REGEX.exec(chunk.slice(index));
+      if (sgr) {
+        text += sgr[0];
+        index += sgr[0].length;
+        continue;
+      }
+      const csi = chunk.slice(index).match(/^\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/);
+      if (csi) {
+        index += csi[0].length;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    const ch = chunk[index];
     if (ch === "\r") {
       const lastNl = text.lastIndexOf("\n");
       text = lastNl === -1 ? "" : text.slice(0, lastNl + 1);
+      index += 1;
       continue;
     }
     if (ch === "\n") {
       text += "\n";
+      index += 1;
       continue;
     }
     if (ch === "\b") {
-      if (text.length > 0 && text[text.length - 1] !== "\n") {
-        text = text.slice(0, -1);
+      const trailing = TRAILING_SGR_REGEX.exec(text);
+      const sgrTail = trailing ? trailing[0] : "";
+      const head = sgrTail ? text.slice(0, -sgrTail.length) : text;
+      if (head.length > 0 && head[head.length - 1] !== "\n") {
+        text = head.slice(0, -1) + sgrTail;
       }
+      index += 1;
       continue;
     }
     const code = ch.charCodeAt(0);
-    if (code < 32 && ch !== "	") {
-      continue;
-    }
-    if (code === 127) {
+    if (code < 32 && ch !== "	" || code === 127) {
+      index += 1;
       continue;
     }
     text += ch;
+    index += 1;
   }
   return text;
 }
@@ -27738,12 +28878,98 @@ function takeDisplayWidth(text, width) {
   return { prefix: text.slice(0, index), rest: text.slice(index) };
 }
 function padOrTruncateToWidth(text, width) {
-  const textWidth = displayWidth(text);
+  const textWidth = visibleWidth(text);
   if (textWidth > width) {
-    return takeDisplayWidth(text, width).prefix;
+    return truncateAnsi(text, width);
   }
   return `${text}${" ".repeat(width - textWidth)}`;
 }
+function tokenizeAnsiLine(line) {
+  const tokens = [];
+  let index = 0;
+  while (index < line.length) {
+    if (line[index] === "\x1B") {
+      const sgr = SGR_SEQUENCE_REGEX.exec(line.slice(index));
+      if (sgr) {
+        tokens.push({ kind: "sgr", value: sgr[0], width: 0 });
+        index += sgr[0].length;
+        continue;
+      }
+    }
+    const codePoint = line.codePointAt(index) ?? 0;
+    const value = String.fromCodePoint(codePoint);
+    tokens.push({ kind: "char", value, width: displayWidth(value) });
+    index += value.length;
+  }
+  return tokens;
+}
+function wrapTranscriptLine(line, columns) {
+  if (line === "") return [""];
+  const tokens = tokenizeAnsiLine(line);
+  const result = [];
+  let activeStyles = [];
+  const applyStyleToken = (value) => {
+    if (SGR_RESET_REGEX.test(value)) {
+      activeStyles = [];
+    } else {
+      activeStyles.push(value);
+    }
+  };
+  let start = 0;
+  while (start < tokens.length) {
+    if (tokens.slice(start).every((token) => token.kind === "sgr")) {
+      if (result.length > 0) break;
+    }
+    const openingStyles = [...activeStyles];
+    let width = 0;
+    let end = start;
+    let lastBreak = -1;
+    while (end < tokens.length) {
+      const token = tokens[end];
+      if (token.kind === "sgr") {
+        end += 1;
+        continue;
+      }
+      if (width + token.width > columns && width > 0) break;
+      width += token.width;
+      end += 1;
+      if (token.value === " " || token.value === "	") {
+        lastBreak = end;
+      }
+    }
+    let segmentEnd = end;
+    if (end < tokens.length && lastBreak > start) {
+      const overflowToken = tokens[end];
+      if (overflowToken.kind === "char" && overflowToken.value !== " " && overflowToken.width === 1) {
+        segmentEnd = lastBreak;
+      }
+    }
+    if (segmentEnd === start) segmentEnd = start + 1;
+    let segment = "";
+    let sawStyle = openingStyles.length > 0;
+    for (let i = start; i < segmentEnd; i += 1) {
+      const token = tokens[i];
+      segment += token.value;
+      if (token.kind === "sgr") {
+        sawStyle = true;
+        applyStyleToken(token.value);
+      }
+    }
+    const prefix = openingStyles.join("");
+    const needsReset = (sawStyle || activeStyles.length > 0) && !segment.endsWith("\x1B[0m");
+    result.push(`${prefix}${segment}${needsReset ? "\x1B[0m" : ""}`);
+    start = segmentEnd;
+    while (start < tokens.length) {
+      const token = tokens[start];
+      if (token.kind === "char" && token.value === " ") {
+        start += 1;
+        continue;
+      }
+      break;
+    }
+  }
+  return result.length > 0 ? result : [""];
+}
 function wrapTextToLines(text, columns) {
   const result = [];
   for (const logicalLine of text.split("\n")) {
@@ -27777,8 +29003,10 @@ function buildHistoryLines(history, contentWidth) {
     }
   }
   const wrapped = [];
-  for (const line of lines) {
-    wrapped.push(...wrapTextToLines(line, contentWidth));
+  for (const entry of lines) {
+    for (const logicalLine of entry.split("\n")) {
+      wrapped.push(...wrapTranscriptLine(logicalLine, contentWidth));
+    }
   }
   return wrapped;
 }
@@ -27800,6 +29028,13 @@ function renderScrollbarRow(rowIndex, visibleHeight, totalLines, scrollTop) {
   return "\u2502";
 }
 function parseScrollAction(sequence) {
+  const mouse = SGR_MOUSE_REGEX.exec(sequence);
+  if (mouse) {
+    const button = Number(mouse[1]);
+    if ((button & 64) === 0) return null;
+    if ((button & 2) !== 0) return null;
+    return (button & 1) !== 0 ? "wheel-down" : "wheel-up";
+  }
   switch (sequence) {
     case "\x1B[5~":
       return "page-up";
@@ -27848,6 +29083,13 @@ function applyScrollAction(history, action, output2, inputLines) {
         history.scrollTop + Math.floor(visibleHeight / 2)
       );
       break;
+    case "wheel-up":
+      history.scrollTop = Math.max(0, history.scrollTop - WHEEL_SCROLL_LINES);
+      break;
+    case "wheel-down":
+      history.scrollTop = Math.min(maxScrollTop, history.scrollTop + WHEEL_SCROLL_LINES);
+      if (history.scrollTop >= maxScrollTop) history.followBottom = true;
+      break;
     case "top":
       history.scrollTop = 0;
       break;
@@ -27894,6 +29136,8 @@ function createFixedInput(output2, config) {
   const saveCursor = () => write("\x1B7");
   const restoreCursor = () => write("\x1B8");
   const resetScrollRegion = () => write("\x1B[r");
+  const enableMouse = () => write("\x1B[?1006h\x1B[?1000h");
+  const disableMouse = () => write("\x1B[?1000l\x1B[?1006l");
   const renderInputArea = (buffer) => {
     const colorEnabled = resolveCliColorEnabled();
     const cols = Math.max(1, getColumns());
@@ -27951,7 +29195,7 @@ function createFixedInput(output2, config) {
     write("\x1B[J");
     write(text);
     const cursorLine = startRow + cursorRow;
-    write(`\x1B[${cursorLine};${cursorCol + 1}G`);
+    write(`\x1B[${cursorLine};${cursorCol + 1}H`);
   };
   if (!isTTY) return createNoopFixedInput();
   return {
@@ -27959,6 +29203,7 @@ function createFixedInput(output2, config) {
     init() {
       saveCursor();
       setScrollRegion(inputLines);
+      enableMouse();
     },
     enterOutputMode(_submittedText) {
       repaintAt("");
@@ -27971,10 +29216,12 @@ function createFixedInput(output2, config) {
       repaintAt(buffer);
     },
     pause() {
+      disableMouse();
       resetScrollRegion();
     },
     resumeFromSubprocess() {
       setScrollRegion(inputLines);
+      enableMouse();
       const scrollBottom = Math.max(1, getRows() - inputLines);
       write(`\x1B[${scrollBottom};1H
 `);
@@ -27982,8 +29229,10 @@ function createFixedInput(output2, config) {
     resumeFromDialog() {
       saveCursor();
       setScrollRegion(inputLines);
+      enableMouse();
     },
     disable() {
+      disableMouse();
       resetScrollRegion();
       const rows = getRows();
       write(`\x1B[${rows};1H\x1B[2K\x1B[${Math.max(1, rows - 1)};1H`);
@@ -28195,13 +29444,18 @@ async function startTuiWorkspace(options) {
       }
     }
     if (result.action?.type === "pick-agent") {
+      const pickerInputLines = fixedInput.getInputLines();
+      const ttyRows = typeof output2 === "object" && output2 !== null && "rows" in output2 && typeof output2.rows === "number" ? output2.rows : 24;
+      const bottomRow = Math.max(1, ttyRows - pickerInputLines);
       fixedInput.pause();
       try {
         const pickResult = await runAgentPicker({
           currentKey: state.agentKey,
           env: options.env ?? process.env,
           input: input2,
-          output: output2
+          output: output2,
+          bottomAnchored: true,
+          bottomRow
         });
         if (pickResult.kind === "list") {
           output2.write(`${pickResult.output}
@@ -28459,7 +29713,7 @@ ${renderStatusLine(state)}
     rl.close();
   }
 }
-var MAX_TUI_HISTORY_TURNS, ANSI_ESCAPE_REGEX;
+var MAX_TUI_HISTORY_TURNS, ANSI_ESCAPE_REGEX, SGR_SEQUENCE_REGEX, TRAILING_SGR_REGEX, SGR_RESET_REGEX, SGR_MOUSE_REGEX, WHEEL_SCROLL_LINES;
 var init_readlineWorkspace = __esm({
   "packages/cli/tui/readlineWorkspace.ts"() {
     "use strict";
@@ -28478,6 +29732,11 @@ var init_readlineWorkspace = __esm({
     init_i18n();
     MAX_TUI_HISTORY_TURNS = 500;
     ANSI_ESCAPE_REGEX = /\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g;
+    SGR_SEQUENCE_REGEX = /^\x1b\[[0-9;]*m/;
+    TRAILING_SGR_REGEX = /(?:\x1b\[[0-9;]*m)+$/;
+    SGR_RESET_REGEX = /^\x1b\[0?m$/;
+    SGR_MOUSE_REGEX = /^\x1b\[<(\d+);\d+;\d+[Mm]$/;
+    WHEEL_SCROLL_LINES = 3;
   }
 });
 
@@ -29162,6 +30421,14 @@ function getDocInternalCommandEntries() {
 // packages/cli/memoryInternalCommandEntries.ts
 function getMemoryInternalCommandEntries() {
   return [
+    createEnvCommand(["memory", "list"], "List long-term memories by filter", async (args2, deps) => {
+      const { runMemoryListCommand: runMemoryListCommand2 } = await Promise.resolve().then(() => (init_memoryCommands(), memoryCommands_exports));
+      return runMemoryListCommand2(args2, deps);
+    }),
+    createEnvCommand(["memory", "remember"], "Store a long-term memory", async (args2, deps) => {
+      const { runMemoryRememberCommand: runMemoryRememberCommand2 } = await Promise.resolve().then(() => (init_memoryCommands(), memoryCommands_exports));
+      return runMemoryRememberCommand2(args2, deps);
+    }),
     createEnvCommand(["memory", "delete"], "Delete long-term memories by filter", async (args2, deps) => {
       const { runMemoryDeleteCommand: runMemoryDeleteCommand2 } = await Promise.resolve().then(() => (init_memoryCommands(), memoryCommands_exports));
       return runMemoryDeleteCommand2(args2, deps);
@@ -29303,6 +30570,8 @@ function renderTableHelpText() {
     "  nolo table update-rows --table <tableId|metaKey> --updates <json-array>",
     "  nolo table delete-row --table <tableId|metaKey> --row <rowId|rowDbKey>",
     "  nolo table delete-rows --table <tableId|metaKey> (--row-ids <json-array> | --row-dbkeys <json-array> | --filters <json-object>)",
+    "  nolo table purge-rows --table <exact-meta-dbKey> --row-dbkeys <json-array> [--yes] [--json]",
+    "  nolo table remove-row-fields --table <exact-meta-dbKey> --row-dbkeys <json-array> --fields <json-array> [--yes] [--json]",
     "",
     "Examples:",
     `  nolo table query --table meta-0e95801d90-01KWSK4Q4TESXQ06SW39JN2TTJ --columns '["title","status","owner","priority","codeStatus"]' --no-base-fields --output items`,
@@ -29328,6 +30597,14 @@ function getTableInternalCommandEntries() {
       const { runTableDeleteRowsCommand: runTableDeleteRowsCommand2 } = await Promise.resolve().then(() => (init_tableCommands(), tableCommands_exports));
       return runTableDeleteRowsCommand2(args2);
     }),
+    createEnvCommand(["table", "purge-rows"], "Permanently purge table rows", async (args2, deps) => {
+      const { runTablePurgeRowsCommand: runTablePurgeRowsCommand2 } = await Promise.resolve().then(() => (init_tableCommands(), tableCommands_exports));
+      return runTablePurgeRowsCommand2(args2, deps);
+    }),
+    createEnvCommand(["table", "remove-row-fields"], "Remove fields from table rows", async (args2, deps) => {
+      const { runTableRemoveRowFieldsCommand: runTableRemoveRowFieldsCommand2 } = await Promise.resolve().then(() => (init_tableCommands(), tableCommands_exports));
+      return runTableRemoveRowFieldsCommand2(args2, deps);
+    }),
     createEnvCommand(["table", "add-column"], "Add a table column", async (args2, deps) => {
       const { runTableAddColumnCommand: runTableAddColumnCommand2 } = await Promise.resolve().then(() => (init_tableCommands(), tableCommands_exports));
       return runTableAddColumnCommand2(args2, deps);