nolo-cli 0.19.0 → 0.24.0-alpha.13

package/{chunk-R35XMF6F.js → chunk-SIUEKVK4.js}

@@ -4,45 +4,50 @@ import {
   providerHttpFailure,
   readSseFrames,
   throwIfChatCompletionStreamFailed
-} from "./chunk-N54HIJVJ.js";
+} from "./chunk-MCXQNEJ3.js";
 import {
   parseToolArgumentsJson
-} from "./chunk-YGW4G5W5.js";
+} from "./chunk-P3RZ6DHN.js";
 import {
   createThinkParserState,
   createToolCallAccumulator,
   createToolCallTextParserState,
   extractThinkContent,
   finalizeAccumulatedToolCalls
-} from "./chunk-LSFAWXKC.js";
+} from "./chunk-N7J63Q6C.js";
 import {
   requiresBareImageUrl,
   toBareImageUrlMessages
-} from "./chunk-34WPV75U.js";
+} from "./chunk-ZUXIXYJI.js";
 import {
   shouldStripReasoningContentForOutbound,
   toOpenAiCompatibleMessages
-} from "./chunk-KFEVY3ST.js";
+} from "./chunk-D34RI6NI.js";
 import {
   buildProviderAuthHeaders,
   buildProviderExecutionPlan
-} from "./chunk-MHSGJW4Z.js";
+} from "./chunk-PXPISYEH.js";
 import {
-  createGlob,
-  resolveExecutableOnPath
-} from "./chunk-DKZFOK24.js";
+  NOLO_WORKSPACE_TOOL_NAMES,
+  buildNoloWorkspaceCommandArgs,
+  noloStringArg,
+  parseNoloWorkspaceToolArguments
+} from "./chunk-WCP5FDTF.js";
 import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
+  buildDialogFallbackTitleFromUserInput
+} from "./chunk-2MBTWINN.js";
 import {
   canonicalizeToolName
 } from "./chunk-ZZ2MH7LE.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
 import {
   dialogMessageKey
-} from "./chunk-6Y7A3OQQ.js";
+} from "./chunk-NRY4GCKJ.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
@@ -68,6 +73,44 @@ import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
 
+// packages/agent-runtime/agentAvailability.ts
+var DEFAULT_PROVIDER_RETRY_MS = 5 * 60 * 1e3;
+function parseResetText(value) {
+  const m = value.match(/(?:resets?\s+in|retry[- ]after)\s*(?:(\d+)\s*hr)?\s*(?:(\d+)\s*min)?\s*(?:(\d+)\s*sec)?/i);
+  if (!m) return void 0;
+  return (Number(m[1] ?? 0) * 3600 + Number(m[2] ?? 0) * 60 + Number(m[3] ?? 0)) * 1e3;
+}
+function resolveAgentNextAvailableAt(body, now = Date.now()) {
+  const root = body && typeof body === "object" ? body : {};
+  const error = root.error && typeof root.error === "object" ? root.error : root;
+  const details = error.details && typeof error.details === "object" ? error.details : void 0;
+  const retryRaw = error.retryAfter ?? error.retry_after ?? error["Retry-After"];
+  if (typeof retryRaw === "number" && Number.isFinite(retryRaw)) {
+    return retryRaw > 1e12 ? retryRaw : now + Math.max(0, retryRaw) * 1e3;
+  }
+  if (typeof retryRaw === "string") {
+    const numeric = Number(retryRaw.trim());
+    if (Number.isFinite(numeric)) return now + Math.max(0, numeric) * 1e3;
+    const date = Date.parse(retryRaw);
+    if (Number.isFinite(date) && date > now) return date;
+  }
+  const resetRaw = error.resets_at ?? error.resetsAt ?? details?.resets_at ?? details?.resetsAt;
+  if (typeof resetRaw === "number" && Number.isFinite(resetRaw)) {
+    const absolute = resetRaw > 1e12 ? resetRaw : resetRaw * 1e3;
+    if (absolute > now) return absolute;
+  }
+  if (typeof resetRaw === "string") {
+    const parsed = Date.parse(resetRaw);
+    if (Number.isFinite(parsed) && parsed > now) return parsed;
+  }
+  const text = typeof body === "string" ? body : JSON.stringify(body ?? "");
+  return now + (parseResetText(text) ?? DEFAULT_PROVIDER_RETRY_MS);
+}
+function isAgentCoolingDown(agent, now = Date.now()) {
+  const at = agent && typeof agent === "object" ? agent.nextAvailableAt : void 0;
+  return typeof at === "number" && Number.isFinite(at) && at > now;
+}
+
 // packages/agent-runtime/kimiUserAgent.ts
 var KIMI_CODE_CLI_VERSION = "0.29.2";
 var KIMI_CODE_USER_AGENT = `kimi-code-cli/${KIMI_CODE_CLI_VERSION} (nolo)`;
@@ -443,21 +486,37 @@ function extractLastUserText(messages) {
   return "";
 }
 function resolveDialogTitle(args) {
-  if (typeof args.existingDialog?.title === "string" && args.existingDialog.title.trim()) {
-    return args.existingDialog.title;
+  const existing = args.existingDialog?.title;
+  if (typeof existing === "string" && existing.trim()) {
+    return existing.trim();
   }
   const lastUserText = extractLastUserText(args.messages).trim();
-  return lastUserText ? lastUserText.slice(0, 80) : "Local agent run";
+  return buildDialogFallbackTitleFromUserInput(lastUserText) || "Local agent run";
 }
 function pickDialogTitle(args) {
-  const existing = args.existingDialog?.title;
-  if (typeof existing === "string" && existing.trim()) return existing.trim();
+  const existingSource = args.existingDialog?.titleSource;
+  const existingIsManual = existingSource === "manual";
   const override = args.titleOverride?.trim();
-  if (override) return override;
-  return resolveDialogTitle({
-    existingDialog: args.existingDialog,
-    messages: args.messages
-  });
+  if (override && !existingIsManual) {
+    return { title: override, titleSource: "generated" };
+  }
+  const existing = args.existingDialog?.title;
+  if (typeof existing === "string" && existing.trim()) {
+    return {
+      title: existing.trim(),
+      titleSource: existingIsManual ? "manual" : "generated"
+    };
+  }
+  if (override) {
+    return { title: override, titleSource: "generated" };
+  }
+  return {
+    title: resolveDialogTitle({
+      existingDialog: args.existingDialog,
+      messages: args.messages
+    }),
+    titleSource: "generated"
+  };
 }
 function normalizeSubjectRef(ref) {
   if (!ref || typeof ref !== "object") return null;
@@ -472,6 +531,15 @@ function normalizeSubjectRef(ref) {
     ...role ? { role } : {}
   };
 }
+function parseTitleUpdatedAtMs(existingDialog) {
+  const raw = existingDialog?.titleUpdatedAt;
+  if (typeof raw === "number" && !Number.isNaN(raw)) return raw;
+  if (typeof raw === "string" && raw.trim()) {
+    const parsed = Date.parse(raw);
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  return 0;
+}
 function mergeSubjectRefs(...groups) {
   const refs = [];
   const seen = /* @__PURE__ */ new Set();
@@ -550,6 +618,14 @@ function buildAgentRuntimeDialogWritePlan(args) {
     cybots: [args.input.agentKey],
     primaryAgentKey: args.input.agentKey
   };
+  const pickedTitle = pickDialogTitle({
+    existingDialog: args.existingDialog,
+    titleOverride: args.titleOverride,
+    messages: args.input.messages
+  });
+  const existingTitleUpdatedAtMs = parseTitleUpdatedAtMs(args.existingDialog);
+  const titleChanged = typeof args.titleOverride === "string" && args.titleOverride.trim().length > 0;
+  const titleUpdatedAtIso = titleChanged ? nowIso : existingTitleUpdatedAtMs > 0 ? new Date(existingTitleUpdatedAtMs).toISOString() : args.existingDialog?.createdAt ?? nowIso;
   const dialogRecord = {
     ...asRecordOrEmpty(args.existingDialog),
     id: dialogId,
@@ -557,11 +633,9 @@ function buildAgentRuntimeDialogWritePlan(args) {
     type: "dialog",
     userId: args.userId,
     ...dialogAgentFields,
-    title: pickDialogTitle({
-      existingDialog: args.existingDialog,
-      titleOverride: args.titleOverride,
-      messages: args.input.messages
-    }),
+    title: pickedTitle.title,
+    titleSource: pickedTitle.titleSource,
+    titleUpdatedAt: titleUpdatedAtIso,
     status: args.input.result.error === true ? "failed" : "done",
     triggerType: `${args.runtimeHost}-local`,
     executionMode: args.existingDialog?.executionMode ?? "foreground",
@@ -687,6 +761,11 @@ function shouldCacheHybridRemoteRecord(remoteRecord, localRecord) {
   if (!localRecord || typeof localRecord !== "object") return true;
   return shouldReplaceWithHybridRecord(remoteRecord, localRecord);
 }
+function parseSyncServersEnv(env) {
+  const raw = env?.NOLO_SYNC_SERVERS?.trim();
+  if (!raw) return [];
+  return raw.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+}
 function createHybridRecordStore(deps) {
   const fetchImpl = deps.fetchImpl ?? fetch;
   return {
@@ -1124,11 +1203,185 @@ async function executeLocalToolWithPolicy(args) {
 }
 
 // packages/agent-runtime/localWorkspaceTools.ts
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, relative, resolve, sep } from "node:path";
 import { spawnSync, spawn as spawnChildProcess } from "node:child_process";
 
+// packages/agent-runtime/runtimeCompat.ts
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+var IS_WINDOWS = process.platform === "win32";
+function isExecutableFile(candidate) {
+  if (!existsSync(candidate)) return false;
+  try {
+    return statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveExecutableOnPath(name) {
+  if (IS_WINDOWS && !/\.[a-z]+$/i.test(name)) {
+    const exts = (process.env.PATHEXT || ".EXE;.CMD;.BAT").split(";").filter(Boolean);
+    for (const ext of exts) {
+      const found = resolveExecutableOnPath(name + ext);
+      if (found) return found;
+    }
+    return null;
+  }
+  const pathEnv = process.env.PATH ?? "";
+  const sep2 = pathEnv.includes(";") && IS_WINDOWS ? ";" : ":";
+  const pathDirs = pathEnv.split(sep2).filter(Boolean);
+  const fallbackDirs = IS_WINDOWS ? [] : [
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+    `${process.env.HOME ?? ""}/.local/bin`
+  ].filter(Boolean);
+  for (const dir of [...pathDirs, ...fallbackDirs]) {
+    const candidate = join(dir, name);
+    if (isExecutableFile(candidate)) return candidate;
+  }
+  return null;
+}
+function createGlob(pattern) {
+  const regex = globToRegExp(pattern);
+  return {
+    match(path) {
+      return regex.test(path);
+    },
+    scanSync(opts) {
+      const dot = opts.dot ?? false;
+      const results = [];
+      walkDir(opts.cwd, "", dot, results);
+      return results.filter((rel) => regex.test(rel));
+    }
+  };
+}
+function walkDir(dir, prefix, dot, out) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true, encoding: "utf8" });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const name = String(entry.name);
+    if (!dot && name.startsWith(".")) continue;
+    const rel = prefix ? `${prefix}/${name}` : name;
+    const full = join(dir, name);
+    if (entry.isDirectory()) {
+      walkDir(full, rel, dot, out);
+    } else if (entry.isFile()) {
+      out.push(rel);
+    }
+  }
+}
+function globToRegExp(pattern) {
+  const trailingDir = pattern.endsWith("/");
+  const src = trailingDir ? pattern.slice(0, -1) : pattern;
+  const anchored = src.startsWith("/");
+  const body = anchored ? src.slice(1) : src;
+  let regex = "^";
+  if (!anchored) regex += "(?:.*/)?";
+  regex += convertBody(body);
+  if (trailingDir) {
+    regex += "(?:/.*)?";
+  }
+  regex += "$";
+  return new RegExp(regex);
+}
+function convertBody(p) {
+  let out = "";
+  let i = 0;
+  while (i < p.length) {
+    const c = p[i];
+    if (c === "*") {
+      if (p[i + 1] === "*") {
+        i += 2;
+        if (p[i] === "/") {
+          out += "(?:.*/)?";
+          i += 1;
+        } else {
+          out += ".*";
+        }
+      } else {
+        out += "[^/]*";
+        i += 1;
+      }
+    } else if (c === "?") {
+      out += "[^/]";
+      i += 1;
+    } else if (c === "[") {
+      out += "[";
+      i += 1;
+      if (p[i] === "!") {
+        out += "^";
+        i += 1;
+      }
+      while (i < p.length && p[i] !== "]") {
+        out += p[i] === "\\" ? "\\\\" : p[i];
+        i += 1;
+      }
+      if (p[i] === "]") {
+        out += "]";
+        i += 1;
+      }
+    } else if (c === "{") {
+      let depth = 1;
+      let j = i + 1;
+      let bodyStr = "";
+      while (j < p.length && depth > 0) {
+        if (p[j] === "{") depth += 1;
+        else if (p[j] === "}") depth -= 1;
+        if (depth > 0) bodyStr += p[j];
+        j += 1;
+      }
+      const alts = bodyStr.split(",").map((alt) => convertBody(alt));
+      out += `(?:${alts.join("|")})`;
+      i = j;
+    } else {
+      out += escapeRegexChar(c);
+      i += 1;
+    }
+  }
+  return out;
+}
+function escapeRegexChar(c) {
+  if ("\\^$.|+()".includes(c)) {
+    return `\\${c}`;
+  }
+  return c;
+}
+function spawnToWebStreams(options) {
+  const [command, ...args] = options.cmd;
+  const child = spawn(command, args, {
+    env: options.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const exited = new Promise((resolve2) => {
+    child.on("exit", (code) => resolve2(code ?? 1));
+    child.on("error", () => resolve2(127));
+  });
+  const toWeb = (stream) => {
+    if (!stream) return null;
+    return stream.toWeb?.() ?? new ReadableStream({
+      start(controller) {
+        stream.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
+        stream.on("end", () => controller.close());
+        stream.on("error", (e) => controller.error(e));
+      }
+    });
+  };
+  return {
+    stdout: toWeb(child.stdout),
+    stderr: toWeb(child.stderr),
+    exited
+  };
+}
+
 // packages/agent-runtime/processRegistry.ts
 var ProcessRegistry = class {
   processes = /* @__PURE__ */ new Map();
@@ -1228,7 +1481,8 @@ function tokenizeShellPrefix(command) {
 function buildWorkspacePathProperty() {
   return {
     type: "string",
-    description: "Path relative to the workspace root."
+    minLength: 1,
+    description: "Path relative to the workspace root. Required and must be non-empty for readFile/writeFile/editFile; for listFiles/searchFiles/globFiles it is optional and defaults to the workspace root when omitted."
   };
 }
 function buildListWorkspaceDescription(variant) {
@@ -1236,12 +1490,12 @@ function buildListWorkspaceDescription(variant) {
     return "List files and directories inside a workspace directory.";
   }
   if (variant === "workflow") {
-    return "List a bounded directory overview inside the workspace. Use first when you need to understand nearby structure, choose a subdirectory, or inspect a non-code project. Then use globFiles for path-pattern discovery, searchFiles for text/content discovery, and readFile only for the specific files or line ranges you need.";
+    return "List directory overview inside workspace. Then use globFiles for path patterns, searchFiles for text discovery, and readFile for content.";
   }
   if (variant === "antiShell") {
-    return "List a bounded directory overview inside the workspace. Do not use execShell with ls/find/tree for normal directory overviews when listFiles can show the needed depth and limit. Use globFiles for path-pattern discovery and searchFiles for content search.";
+    return "List directory overview inside workspace. Prefer listFiles over shell ls/find commands.";
   }
-  return "List a bounded directory overview inside the workspace. Use for scanning nearby structure, not for path-pattern discovery across the repo. Prefer globFiles for finding files by name/extension and searchFiles for text inside files.";
+  return "List files and directories inside a workspace folder. Defaults to shallow overview (depth 1).";
 }
 function buildListWorkspaceParameters(variant) {
   const path = buildWorkspacePathProperty();
@@ -1298,18 +1552,18 @@ function buildReadWorkspaceDescription(variant) {
     return "Read a UTF-8 text file inside the workspace.";
   }
   if (variant === "workflow") {
-    return 'Read a UTF-8 text file inside the workspace after listFiles, globFiles, or searchFiles has narrowed the target. Use lines with a range from searchFiles matches, or lines: "-50" for logs and generated output. Read the whole file only when the task truly needs all content or exact edit context.';
+    return 'Read a UTF-8 text file inside the workspace. Use lines with a range from searchFiles matches, or lines: "-50" for logs. Read the whole file only when the task needs all content.';
   }
   if (variant === "antiShell") {
-    return "Read a UTF-8 text file inside the workspace. Do not use execShell with cat/sed/head/tail for normal text reads when readFile can return the needed file or line range. Use searchFiles first for content search, then readFile only the relevant lines when possible.";
+    return "Read a UTF-8 text file inside the workspace. Prefer readFile over shell commands (cat/head/tail).";
   }
-  return "Read a UTF-8 text file inside the workspace. Read before editing when you need exact text for editFile. For discovery or classification tasks, avoid batch-reading every candidate; report candidate paths first, or read only one to three representative files with a small lines count. Use lines ranges for large code, docs, data, configs, and logs after searchFiles returns line numbers. Read the whole file only when the task truly needs all content or exact edit context.";
+  return "Read a UTF-8 text file inside the workspace. Use lines for focused range reads after searchFiles to save tokens.";
 }
 function buildReadWorkspaceParameters(variant) {
   const path = buildWorkspacePathProperty();
   const lines = {
     type: "string",
-    description: 'Which lines to return: "40-120" for a range (1-based, inclusive), "120-" from a line to the end, "-50" for the last N lines (logs, generated output), "50" for the first N. Omit to read the whole file. Use a range after searchFiles gives a line number, and a small count to preview candidates instead of reading many whole files. When the user gives a read/preview budget, each readFile preview consumes one budget slot.'
+    description: 'Line slice: "40-120" (range, 1-based, inclusive), "120-" (from line to end), "-50" (tail N lines), "50" (head N lines). Omit to read full file.'
   };
   if (variant === "minimal") {
     return {
@@ -1339,7 +1593,7 @@ function buildWriteWorkspaceFileTool() {
     type: "function",
     function: {
       name: "writeFile",
-      description: "Write full UTF-8 file content inside the workspace. For new files or deliberate whole-file rewrites only. For existing files, prefer editFile for targeted edits. Warn that whole-file rewrites can cause line-ending churn.",
+      description: "Write full UTF-8 file content inside the workspace (new files or whole-file rewrites). Prefer editFile for targeted edits.",
       parameters: {
         type: "object",
         properties: {
@@ -1359,7 +1613,7 @@ function buildReplaceWorkspaceTextTool() {
     type: "function",
     function: {
       name: "editFile",
-      description: "Use for small, exact edits in one workspace file without constructing a patch. Read the file first when you need the exact oldText; set expectedReplacements to avoid accidental broad edits. When expected replacement count fails, report a blocker instead of falling back to a full-file rewrite.",
+      description: "Replace exact text occurrences in a workspace file. If expected replacement count fails, report the error instead of falling back to a whole-file rewrite.",
       parameters: {
         type: "object",
         properties: {
@@ -1387,35 +1641,35 @@ function buildSearchWorkspaceDescription(variant) {
     return "Search workspace file contents.";
   }
   if (variant === "workflow") {
-    return "Search file contents inside the current workspace after listFiles or globFiles has scoped the likely area, or directly when the task names text to find. Use for code, docs, data, configs, logs, and other text files. Return line numbers, then use readFile with focused ranges for interpretation or editing.";
+    return "Search file contents inside workspace. Returns line numbers; use readFile with line ranges for focused reading.";
   }
   if (variant === "antiShell") {
-    return "Search text inside workspace files for code, docs, data, configs, logs, or other text-like assets. Do not use execShell for content search when searchFiles can directly find matching lines. Use globFiles instead for path-only discovery, then readFile for exact surrounding content when needed.";
+    return "Search text inside workspace files using ripgrep. Prefer searchFiles over shell grep.";
   }
-  return "Search file contents inside the current workspace using ripgrep when available. Use for grep-like text or regex search across code, docs, data, configs, logs, and other text files. Use globFiles instead when you only need to find files by name or extension before readFile.";
+  return "Search file contents inside the workspace using ripgrep. Returns matching lines and line numbers. Prefer globFiles when only finding file paths.";
 }
 function buildSearchWorkspaceParameters(variant) {
   const query = {
     type: "string",
-    description: "Search query. Treated as a regular expression unless literal is true."
+    description: "Search query (regex or literal string)."
   };
   const path = buildWorkspacePathProperty();
   const includeIgnored = {
     type: "boolean",
-    description: "When true, search files ignored by .gitignore such as .tmp. Defaults to false. Build artifacts (dist/, *.tsbuildinfo, *.min.js, etc.) are always excluded regardless of this flag. .git and node_modules remain excluded."
+    description: "When true, search gitignored files. Build artifacts (dist/, node_modules, .git) remain excluded."
   };
   const exclude = {
     type: "array",
     items: { type: "string" },
-    description: "Glob patterns to exclude from content search, for example ['dist/**', 'build/**', 'exports/**', '*.log']."
+    description: "Glob patterns to exclude from content search (e.g. ['dist/**', '*.log'])."
   };
   const maxResults = {
     type: "integer",
-    description: "Maximum number of matching output lines to return. Use a small value when you only need candidate files or examples."
+    description: "Max matching output lines to return."
   };
   const literal = {
     type: "boolean",
-    description: "When true, search for query as literal text instead of a regular expression."
+    description: "When true, search query as literal text instead of regex."
   };
   const caseSensitive = {
     type: "boolean",
@@ -1423,7 +1677,7 @@ function buildSearchWorkspaceParameters(variant) {
   };
   const contextLines = {
     type: "integer",
-    description: "Number of surrounding context lines to include around each match. Defaults to 0."
+    description: "Number of surrounding context lines around each match. Defaults to 0."
   };
   if (variant === "minimal") {
     return {
@@ -1474,31 +1728,31 @@ function buildGlobWorkspaceDescription(variant) {
     return "Find workspace files by path glob without reading file contents.";
   }
   if (variant === "workflow") {
-    return "Find files by glob pattern inside the current workspace without reading file contents. Use after listFiles when you know the likely area, or first when the task names a filename, extension, asset type, config, or document pattern. Then use searchFiles for text inside candidates or readFile for the specific candidate paths.";
+    return "Find files by glob pattern. Use searchFiles for text inside candidates, and readFile for specific paths.";
   }
   if (variant === "antiShell") {
-    return "Find workspace files by path glob without reading file contents. Use for code, docs, data, images, configs, logs, or any file discovery task. Do not use execShell or listFiles for path discovery when globFiles can directly narrow candidate files. Use before opening or reading files, and use searchFiles instead for searching text inside files.";
+    return "Find workspace files by path glob. Prefer globFiles over shell find/ls commands.";
   }
-  return "Find files by glob pattern inside the current workspace without reading file contents. Use for code, docs, data, images, configs, logs, or any file discovery task. Use one bounded glob with brace groups before repeated narrow globs when a task names several extensions or config names, for example **/*.{png,jpg,svg}, **/{package.json,bunfig.toml,tsconfig*.json}, or src/**/*.ts. Prefer searchFiles for searching text inside files, and readFile only after candidate paths are narrow enough.";
+  return "Find file paths by glob pattern without reading file contents. Use brace groups (e.g. '**/*.{ts,tsx}') to match multiple patterns in one call.";
 }
 function buildGlobWorkspaceParameters(variant) {
   const pattern = {
     type: "string",
-    description: "Glob pattern for files. For candidate discovery, combine related names or extensions in one brace-group pattern before making repeated narrow calls, for example '**/*.ts', 'packages/**/local*.test.ts', '**/*.{png,jpg,svg}', or '**/{package.json,bunfig.toml,tsconfig*.json}'."
+    description: "Glob pattern for files (supports brace groups like '**/*.{ts,tsx}', '**/{package.json,tsconfig*.json}')."
   };
   const path = buildWorkspacePathProperty();
   const includeIgnored = {
     type: "boolean",
-    description: "When true, include files ignored by .gitignore. Defaults to false; .git and node_modules remain excluded."
+    description: "When true, include gitignored files (.git and node_modules remain excluded)."
   };
   const maxResults = {
     type: "integer",
-    description: "Maximum number of file paths to return. Use a small value when you only need candidate paths before readFile; if results are truncated, report that and narrow the pattern or path before reading."
+    description: "Max file paths to return."
   };
   const exclude = {
     type: "array",
     items: { type: "string" },
-    description: "Glob patterns to exclude from results, for example ['dist/**', 'build/**', 'exports/**', '*.tmp']."
+    description: "Glob patterns to exclude from results."
   };
   if (variant === "minimal") {
     return {
@@ -1526,7 +1780,7 @@ function buildGlobWorkspaceParameters(variant) {
       pattern,
       glob: {
         type: "string",
-        description: "Alias for pattern, kept for compatibility with codeSearch-style prompts."
+        description: "Alias for pattern, kept for compatibility."
       },
       path,
       exclude,
@@ -1597,17 +1851,17 @@ function buildExecShellTool(toolName) {
     type: "function",
     function: {
       name: toolName,
-      description: "Run a shell command in the local workspace. Commands already execute from the workspace root; do not cd into guessed paths such as /workspace, /repo, /home/user, or /home/user/workspace. Prefer one command that performs a complete verification or related git operation instead of many tiny commands. For branch setup, prefer idempotent commands such as git switch -C <branch> when replacing or recreating a benchmark branch is acceptable. Use portable POSIX commands for macOS/BSD shells; avoid GNU-only flags such as cat -A. Do not use cat -A. Do not use brittle byte-offset commands such as xxd -s -32. For separator lines, use echo or printf '%s\\n'. For text-file content or trailing-newline checks, prefer readFile over shell byte inspection when that tool is available. Do not run repeated git status, git log, git rev-parse, or branch checks after a successful command already returned the needed clean status and commit information; use one final verification command. If a command fails, use the error output to adjust the next command rather than repeating the same shape. For long-running commands that should keep running in the background (dev servers, watchers, REPLs, `--watch`/`serve`/`dev` scripts), prefer launchProcess. Obviously long-running commands run via execShell (sleep over 5s, tail -f, watch, infinite loops, dev/serve/watch scripts) are moved to the background automatically and return {detached: true, pid, label} \u2014 use listProcesses to inspect or stop them, and tell the user the command is running in the background. Any other command blocks until it exits, so keep those short.",
+      description: `Execute a shell command from the workspace root. Prefer one compound command (e.g. 'git status && git diff --stat') to perform complete verification instead of multiple small roundtrips. Do not cd into guessed paths (e.g. /workspace, /repo, /home/user); commands already run from the workspace root. Use portable POSIX commands for macOS/BSD shells; do not use cat -A or brittle byte-offset tools such as xxd -s -32. For text-file content or trailing-newline checks, prefer readFile over shell byte inspection. After a successful command returned the needed status/commit info, do not run repeated git status/log/rev-parse checks; use one final verification command. Commands block until exit. Long-running commands (sleep over ${IMMEDIATE_DETACH_SLEEP_THRESHOLD_SECONDS}s, dev servers, watchers) automatically detach to background returning {detached: true, pid, label}; for persistent services, prefer launchProcess.`,
       parameters: {
         type: "object",
         properties: {
           cmd: {
             type: "string",
-            description: "Shell command to run."
+            description: "Shell command to run. Must be a non-empty command string \u2014 never pass an empty string, whitespace-only text, or null."
           },
           command: {
             type: "string",
-            description: "Shell command to run."
+            description: "Shell command to run. Compatibility field for providers that model the command under this name; the executor reads cmd first, then falls back to command. Must also be non-empty when used."
           }
         }
       }
@@ -1619,7 +1873,7 @@ function buildLaunchProcessTool() {
     type: "function",
     function: {
       name: "launchProcess",
-      description: "Launch a long-running process (dev server, watcher, REPL) in the background and return immediately without blocking the conversation. Use this instead of execShell for commands that do not exit on their own. Returns {pid, label, status:'running'}. The process keeps running after the tool returns; use listProcesses to check status or the host UI (/procs, /stop) to stop it.",
+      description: "Start a long-running background process (dev server, watcher, REPL) and return immediately with {pid, label, status}. Use listProcesses to inspect or stop it.",
       parameters: {
         type: "object",
         properties: {
@@ -1633,7 +1887,7 @@ function buildLaunchProcessTool() {
           },
           persist: {
             type: "boolean",
-            description: "Mark the process as persistent so it survives the current TUI/session exit (kept running in the background when the conversation closes). Defaults to false. Use for long-lived services (e.g. a desktop dev server) you want to keep alive after the session ends."
+            description: "Keep process alive after session/conversation closes. Defaults to false."
           }
         },
         required: ["command"]
@@ -1646,7 +1900,7 @@ function buildListProcessesTool() {
     type: "function",
     function: {
       name: "listProcesses",
-      description: "List currently registered background processes launched via launchProcess. Returns array of {pid, label, command, status, startedAt, persist}.",
+      description: "List active background processes launched via launchProcess. Returns {pid, label, command, status, startedAt, persist}[].",
       parameters: {
         type: "object",
         properties: {}
@@ -2037,7 +2291,7 @@ function isPathInsideWorkspace(args) {
   const relativePath = relative(args.workspaceRoot, args.targetPath);
   return relativePath === "" || !relativePath.startsWith("..") && !relativePath.includes(`..${sep}`);
 }
-var PATH_FIELD_ALIASES = ["path", "file_path", "filePath", "filename", "file", "target_file", "targetFile", "file_to_read", "fileToRead"];
+var PATH_FIELD_ALIASES = ["path", "file_path", "filePath", "filename", "file", "target_file", "targetFile", "file_to_read", "fileToRead", "target_path", "read_path", "path_to_read", "pathToRead"];
 var OLD_TEXT_FIELD_ALIASES = ["oldText", "old_string", "oldString", "search", "search_string", "find", "match"];
 var NEW_TEXT_FIELD_ALIASES = ["newText", "new_string", "newString", "replacement", "replace"];
 var SEARCH_QUERY_FIELD_ALIASES = ["query", "search_query", "searchQuery", "q", "pattern", "search"];
@@ -2494,7 +2748,7 @@ function resolveRipgrepBinary(env = process.env) {
   const fromEnv = asOptionalTrimmedString(env.NOLO_BUNDLED_RG);
   if (fromEnv) {
     try {
-      if (existsSync(fromEnv)) return fromEnv;
+      if (existsSync2(fromEnv)) return fromEnv;
     } catch {
     }
   }
@@ -2801,6 +3055,48 @@ async function resolveLocalWorkspaceToolPath(args) {
   }
   return targetPath;
 }
+var READ_FILE_MAX_CHAR_LIMIT = 32e3;
+function defensivelyTruncateReadFile(args) {
+  const limit = args.limit ?? READ_FILE_MAX_CHAR_LIMIT;
+  if (args.content.length <= limit) {
+    return { content: args.content, truncatedByCharLimit: false };
+  }
+  const maxBudget = Math.floor(limit * 0.4);
+  const lines = splitTextLines(args.content);
+  if (lines.length <= 10) {
+    const head2 = args.content.slice(0, maxBudget);
+    const tail2 = args.content.slice(-maxBudget);
+    const omitted = args.content.length - head2.length - tail2.length;
+    return {
+      content: `${head2}
+
+[... ${omitted} characters omitted. Content exceeds limit (${args.content.length} chars). Use lines slice or searchFiles to inspect specific parts. ...]
+
+${tail2}`,
+      truncatedByCharLimit: true
+    };
+  }
+  const headLinesCount = Math.min(150, Math.floor(lines.length * 0.4));
+  const tailLinesCount = Math.min(50, Math.floor(lines.length * 0.2));
+  let head = lines.slice(0, headLinesCount).join("\n");
+  let tail = lines.slice(-tailLinesCount).join("\n");
+  if (head.length > maxBudget) {
+    head = head.slice(0, maxBudget);
+  }
+  if (tail.length > maxBudget) {
+    tail = tail.slice(-maxBudget);
+  }
+  const omittedLines = lines.length - headLinesCount - tailLinesCount;
+  const omittedChars = args.content.length - head.length - tail.length;
+  return {
+    content: `${head}
+
+[... Omitted ${Math.max(1, omittedLines)} lines (${omittedChars} chars). File exceeds safety limit (${args.content.length} chars, ${args.totalLines} lines). Use lines="start-end" (e.g. lines="151-300") or searchFiles to read specific sections. ...]
+
+${tail}`,
+    truncatedByCharLimit: true
+  };
+}
 async function readFileTool(args) {
   const parsed = parseWorkspaceToolArguments(args.call.arguments);
   const requestedPath = requireWorkspaceToolPath(parsed);
@@ -2816,19 +3112,25 @@ async function readFileTool(args) {
     content,
     ...sliceArgs
   });
-  return {
+  const truncatedRead = defensivelyTruncateReadFile({
     content: sliced.content,
+    totalLines: sliced.totalLines
+  });
+  const isTruncated = sliced.truncated || truncatedRead.truncatedByCharLimit;
+  return {
+    content: truncatedRead.content,
     metadata: {
       path: normalizeWorkspaceRelativePath({
         workspaceRoot: resolve(args.workspaceRoot),
         targetPath: absolutePath
       }),
-      bytes: Buffer.byteLength(sliced.content),
+      bytes: Buffer.byteLength(truncatedRead.content),
       totalBytes: Buffer.byteLength(content),
       startLine: sliced.startLine,
       endLine: sliced.endLine,
       totalLines: sliced.totalLines,
-      truncated: sliced.truncated,
+      truncated: isTruncated,
+      ...truncatedRead.truncatedByCharLimit ? { truncatedByByteLimit: true, truncatedByCharLimit: true } : {},
       ...sliceArgs.maxLines ? { maxLines: sliceArgs.maxLines } : {},
       ...sliceArgs.tailLines ? { tailLines: sliceArgs.tailLines } : {},
       ...warnings.length ? { warnings: [...warnings, buildReadFileSliceHint(sliced.totalLines)] } : {},
@@ -3656,7 +3958,119 @@ function createLocalWorkspaceToolExecutors(args) {
   };
 }
 
+// packages/agent-runtime/noloWorkspaceTools.node.ts
+async function readNoloProcessStream(readable) {
+  if (!readable) return "";
+  return new Response(readable).text();
+}
+async function runNoloWorkspaceCliTool(call, args) {
+  const cliArgs = buildNoloWorkspaceCommandArgs(call);
+  const bunSpawn = globalThis.Bun?.spawn;
+  const spawn2 = args.spawn ?? (typeof bunSpawn === "function" ? bunSpawn : nodeSpawnFallback);
+  const execPath = args.processExecPath ?? process.execPath;
+  const entrypoint = args.cliEntrypoint;
+  const cmd = entrypoint && entrypoint !== execPath ? [execPath, entrypoint, ...cliArgs] : [execPath, ...cliArgs];
+  const proc = spawn2({
+    cmd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: args.env
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    readNoloProcessStream(proc.stdout),
+    readNoloProcessStream(proc.stderr),
+    proc.exited
+  ]);
+  const content = `${stdout}${stderr}`;
+  if (exitCode !== 0) {
+    throw new Error(content.trim() || `nolo ${cliArgs.join(" ")} exited ${exitCode}`);
+  }
+  return {
+    content,
+    metadata: {
+      [args.metadataKind ?? "noloWorkspaceTool"]: true,
+      command: ["nolo", ...cliArgs].join(" "),
+      exitCode
+    }
+  };
+}
+function buildNoloWorkspaceCliToolExecutors(args) {
+  const executors = {};
+  for (const toolName of NOLO_WORKSPACE_TOOL_NAMES) {
+    if (toolName === "loadSkill") continue;
+    executors[toolName] = (call) => runNoloWorkspaceCliTool(call, args);
+  }
+  return executors;
+}
+var nodeSpawnFallback = (options) => {
+  return spawnToWebStreams({ cmd: options.cmd, env: options.env });
+};
+function buildLoadSkillExecutor(args) {
+  return async (call) => {
+    const parsed = parseNoloWorkspaceToolArguments(call.arguments);
+    const name = noloStringArg(parsed.name ?? parsed.skillName ?? parsed.skill);
+    if (!name) {
+      return {
+        content: await formatUnknownSkillMessage(args.cwd, "(no name provided)"),
+        metadata: { loadSkill: true, resolved: false }
+      };
+    }
+    const { resolveSkillByName } = await import("./skillDiscovery-KJWT7JBU.js");
+    const resolved = resolveSkillByName(args.cwd, name);
+    if (!resolved) {
+      const { resolveCodingBuiltinSlug, buildCodingSkillContentBySlug } = await import("./codingSkills-EN6Z6G6U.js");
+      const builtinSlug = resolveCodingBuiltinSlug(name);
+      if (builtinSlug) {
+        const body = buildCodingSkillContentBySlug(builtinSlug);
+        return {
+          content: `Skill "${name}" loaded inline. Follow its instructions.
+
+${body}`,
+          metadata: { loadSkill: true, resolved: true, name, requestedName: name, builtin: true }
+        };
+      }
+      return {
+        content: await formatUnknownSkillMessage(args.cwd, name),
+        metadata: { loadSkill: true, resolved: false, name, requestedName: name }
+      };
+    }
+    try {
+      const { readFileSync } = await import("node:fs");
+      const body = readFileSync(resolved, "utf8");
+      return {
+        content: `Skill "${name}" loaded inline. Follow its instructions.
+
+${body}`,
+        metadata: { loadSkill: true, resolved: true, name, requestedName: name, path: resolved }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: `Skill "${name}" could not be read: ${message}`,
+        metadata: { loadSkill: true, resolved: true, name, requestedName: name, path: resolved, readError: message }
+      };
+    }
+  };
+}
+async function formatUnknownSkillMessage(cwd, requestedName) {
+  const { discoverSkills } = await import("./skillDiscovery-KJWT7JBU.js");
+  let available = [];
+  try {
+    available = discoverSkills(cwd).map((s) => s.name);
+  } catch {
+  }
+  const header = `Skill "${requestedName}" not found in this workspace's skill directory (.agents/skills/<name>/SKILL.md).`;
+  if (available.length === 0) return `${header}
+
+No skills were discovered in this workspace.`;
+  return `${header}
+
+Available skills: ${available.join(", ")}`;
+}
+
 export {
+  resolveAgentNextAvailableAt,
+  isAgentCoolingDown,
   parseSseDataLineJson,
   parseSseDataLineObject,
   buildOpenAiCompatibleChatCompletionRequest,
@@ -3669,6 +4083,7 @@ export {
   dialogMessageRecordToAgentRuntimeMessage,
   buildAgentRuntimeDialogWritePlan,
   shouldCacheHybridRemoteRecord,
+  parseSyncServersEnv,
   createHybridRecordStore,
   isDestructiveShellCommand,
   evaluateShellCommandPolicy,
@@ -3678,5 +4093,7 @@ export {
   buildLocalWorkspaceToolset,
   buildLocalWorkspacePolicyToolNames,
   buildLocalWorkspaceOpenAiTools,
-  createLocalWorkspaceToolExecutors
+  createLocalWorkspaceToolExecutors,
+  buildNoloWorkspaceCliToolExecutors,
+  buildLoadSkillExecutor
 };