nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.20

package/chunk-P3PKED2I.js

@@ -0,0 +1,962 @@
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import {
+  asNonEmptyStringArray,
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/agent-runtime/toolNameAliases.ts
+var LEGACY_TOOL_NAME_ALIASES = {
+  createPage: "createDoc",
+  updatePage: "updateDoc",
+  update_page: "updateDoc",
+  create_page: "createDoc",
+  fetchwebpage: "fetchWebpage",
+  fetch_webpage: "fetchWebpage",
+  "fetch-page": "fetchWebpage",
+  exasearch: "exa_search",
+  "exa-search": "exa_search",
+  exa_search: "exa_search",
+  firecrawlscrape: "firecrawl_scrape",
+  "firecrawl-scrape": "firecrawl_scrape",
+  firecrawl_scrape: "firecrawl_scrape",
+  firecrawlsearch: "firecrawl_search",
+  "firecrawl-search": "firecrawl_search",
+  firecrawl_search: "firecrawl_search",
+  readDoc: "readDoc",
+  readpage: "readDoc",
+  read_page: "readDoc",
+  read_doc: "readDoc",
+  createdoc: "createDoc",
+  updateDocTool: "updateDoc",
+  terminalCommand: "execShell",
+  terminal_command: "execShell",
+  runCommand: "execShell",
+  run_command: "execShell",
+  runInBash: "execShell",
+  run_in_bash: "execShell",
+  executeCommand: "execShell",
+  execute_command: "execShell",
+  // Codex CLI 风格工具名 → nolo 原生工具名
+  bash: "execShell",
+  shell: "execShell",
+  read: "readFile",
+  edit: "editFile",
+  write: "writeFile",
+  glob: "globFiles",
+  grep: "searchFiles",
+  // 联网搜索别名
+  web_search: "exa_search",
+  websearch: "exa_search",
+  search_web: "exa_search",
+  searchweb: "exa_search",
+  webfetch: "fetchWebpage",
+  web_fetch: "fetchWebpage",
+  fetchweb: "fetchWebpage",
+  fetch_web: "fetchWebpage"
+};
+var normalizeToolName = (name) => name.replace(/[-_]/g, "").toLowerCase();
+var canonicalizeToolName = (rawName) => {
+  const trimmedName = rawName.trim();
+  if (!trimmedName) return rawName;
+  if (LEGACY_TOOL_NAME_ALIASES[trimmedName]) {
+    return LEGACY_TOOL_NAME_ALIASES[trimmedName];
+  }
+  const normalizedRawName = normalizeToolName(trimmedName);
+  const matchedAlias = Object.entries(LEGACY_TOOL_NAME_ALIASES).find(
+    ([alias]) => normalizeToolName(alias) === normalizedRawName
+  );
+  return matchedAlias?.[1] ?? trimmedName;
+};
+var canonicalizeToolNames = (toolNames) => Array.from(
+  new Set(
+    toolNames.filter((toolName) => typeof toolName === "string").map(canonicalizeToolName)
+  )
+);
+var prioritizeToolNames = (toolNames, preferredToolNames) => {
+  const canonicalTools = canonicalizeToolNames(toolNames);
+  const preferred = new Set(canonicalizeToolNames(preferredToolNames));
+  const prioritized = canonicalTools.filter((toolName) => preferred.has(toolName));
+  const remaining = canonicalTools.filter((toolName) => !preferred.has(toolName));
+  return [...prioritized, ...remaining];
+};
+
+// packages/agent-runtime/runtimeToolSurface.ts
+var DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOLS = [
+  "listDialogs",
+  "readDialog",
+  "queryDialogsBySubjectRef",
+  "listAgents",
+  "readAgent",
+  "listSpaces",
+  "readSpace",
+  "readDoc",
+  "readSkillDoc",
+  "loadSkill",
+  "listTables",
+  "queryTableRows",
+  "cliWhoami",
+  "cliDoctor"
+];
+function uniqueToolNames(values) {
+  return [...new Set(asTrimmedNonEmptyStringArray(values))];
+}
+function canInjectPrivateDefaults(args) {
+  if (!args.currentUserId) return false;
+  if (args.invocationVisibility !== "private") return false;
+  if (args.agentOwnerId && args.agentOwnerId === args.currentUserId) return true;
+  if (args.trustedPrivateInvocation === true) return true;
+  return false;
+}
+function explicitOnlyReason(args) {
+  if (!args.currentUserId || !args.agentOwnerId) {
+    return "explicit-only-missing-identity";
+  }
+  if (args.invocationVisibility === "public") return "explicit-only-public";
+  if (args.invocationVisibility === "shared") return "explicit-only-shared";
+  if (args.agentOwnerId !== args.currentUserId) {
+    return "explicit-only-owner-mismatch";
+  }
+  return "explicit-only-anonymous";
+}
+function resolveRuntimeToolSurface(args) {
+  const explicitToolNames = uniqueToolNames(args.explicitToolNames ?? []);
+  if (canInjectPrivateDefaults(args)) {
+    const injectedToolNames = [...DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOLS];
+    return {
+      explicitToolNames,
+      injectedToolNames,
+      finalToolNames: uniqueToolNames([
+        ...explicitToolNames,
+        ...injectedToolNames
+      ]),
+      auditReason: "private-authenticated-defaults"
+    };
+  }
+  return {
+    explicitToolNames,
+    injectedToolNames: [],
+    finalToolNames: explicitToolNames,
+    auditReason: explicitOnlyReason(args)
+  };
+}
+function isPublicRuntimeAgentRef(value) {
+  return typeof value === "string" && value.startsWith("agent-pub-");
+}
+function inferOwnerIdFromRuntimeAgentKey(value) {
+  if (typeof value !== "string") return null;
+  const privateAgentMatch = value.match(/^agent-([^-]+)-(.+)$/);
+  if (privateAgentMatch && privateAgentMatch[1] !== "pub") {
+    return privateAgentMatch[1];
+  }
+  return null;
+}
+function resolveRuntimeToolSurfaceForAgent(args) {
+  const agentKey = typeof args.agentKey === "string" ? args.agentKey : "";
+  const currentUserId = typeof args.currentUserId === "string" ? args.currentUserId : "";
+  const inferredOwnerId = args.agentOwnerId ?? (currentUserId && agentKey.startsWith(`agent-${currentUserId}-`) ? currentUserId : inferOwnerIdFromRuntimeAgentKey(agentKey));
+  const publicRef = isPublicRuntimeAgentRef(agentKey);
+  const visibility = args.trustedPrivateInvocation === true ? "private" : publicRef || args.isPublic === true || args.sharingLevel === "public" ? "public" : "private";
+  return resolveRuntimeToolSurface({
+    explicitToolNames: args.explicitToolNames,
+    currentUserId: args.currentUserId,
+    agentOwnerId: inferredOwnerId,
+    invocationVisibility: visibility,
+    runtimeHost: args.runtimeHost,
+    trustedPrivateInvocation: args.trustedPrivateInvocation
+  });
+}
+var SECRET_FIELD_NAMES = [
+  "apikey",
+  "api_key",
+  "secret",
+  "token",
+  "authorization",
+  "credential",
+  "password"
+];
+function isSecretFieldName(key) {
+  const normalized = key.toLowerCase();
+  return SECRET_FIELD_NAMES.some((name) => normalized.includes(name));
+}
+function redactAgentRecordForWorkspaceTool(record) {
+  if (Array.isArray(record)) return record.map(redactAgentRecordForWorkspaceTool);
+  if (!isRecord(record)) return record;
+  const redacted = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (isSecretFieldName(key)) {
+      redacted[key] = "[redacted]";
+      continue;
+    }
+    redacted[key] = Array.isArray(value) || isRecord(value) ? redactAgentRecordForWorkspaceTool(value) : value;
+  }
+  return redacted;
+}
+
+// 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 sep = pathEnv.includes(";") && IS_WINDOWS ? ";" : ":";
+  const pathDirs = pathEnv.split(sep).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((resolve) => {
+    child.on("exit", (code) => resolve(code ?? 1));
+    child.on("error", () => resolve(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/noloWorkspaceTools.ts
+var NOLO_WORKSPACE_TOOL_NAMES = [
+  "listDialogs",
+  "readDialog",
+  "queryDialogsBySubjectRef",
+  "deleteDialogs",
+  "listAgents",
+  "readAgent",
+  "listSpaces",
+  "readSpace",
+  "readDoc",
+  "readSkillDoc",
+  "loadSkill",
+  "listTables",
+  "queryTableRows",
+  "cliWhoami",
+  "cliDoctor"
+];
+var NOLO_WORKSPACE_TOOL_NAME_SET = new Set(NOLO_WORKSPACE_TOOL_NAMES);
+var DIALOG_ID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+var DIALOG_PATH_RE = /^\/(?:space\/([^/]+)\/)?dialog-(.+)-([0-9A-HJKMNP-TV-Z]{26})\/?$/i;
+function stringToolParam(description) {
+  return { type: "string", description };
+}
+function isNoloWorkspaceToolName(toolName) {
+  return typeof toolName === "string" && NOLO_WORKSPACE_TOOL_NAME_SET.has(toolName);
+}
+function filterNoloWorkspaceToolNames(toolNames) {
+  return (toolNames ?? []).filter(isNoloWorkspaceToolName);
+}
+function buildNoloWorkspaceOpenAiTools(args) {
+  const toolNames = new Set(args.toolNames ?? []);
+  const tools = [];
+  function add(name, description, properties, required = []) {
+    if (!toolNames.has(name)) return;
+    tools.push({
+      type: "function",
+      function: {
+        name,
+        description,
+        parameters: {
+          type: "object",
+          properties,
+          ...required.length ? { required } : {}
+        }
+      }
+    });
+  }
+  add("listDialogs", "List the current user's dialogs in the Nolo workspace.", {
+    limit: { type: "integer", description: "Maximum dialogs to return." },
+    space: stringToolParam("Optional space id or URL.")
+  });
+  add("readDialog", "Read one persisted dialog in the Nolo workspace.", {
+    dialog: stringToolParam("Dialog id, dialog db key, or dialog URL."),
+    limit: { type: "integer", description: "Optional message limit." }
+  }, ["dialog"]);
+  add("queryDialogsBySubjectRef", "Query persisted dialog evidence by a generic dialog.subjectRefs target.", {
+    rowDbKey: stringToolParam("Optional convenience alias for subjectKind=table-row, subjectId=<rowDbKey>, subjectRole=task."),
+    subjectKind: stringToolParam("Generic subject ref kind, for example table-row, page, file, commit, or artifact."),
+    subjectId: stringToolParam("Generic subject ref id."),
+    subjectRole: stringToolParam("Optional subject ref role."),
+    limit: { type: "integer", description: "Maximum matching dialog summaries to return." },
+    status: stringToolParam("Optional dialog status filter, for example running, done, or failed."),
+    checkpointStatus: stringToolParam("Optional runtimeCheckpoint.status filter."),
+    hasArtifacts: { type: "boolean", description: "When true, only return dialogs with artifact evidence." },
+    excludeDialogId: stringToolParam("Optional dialog id or dialog dbKey to exclude from evidence results, typically the current caller dialog.")
+  });
+  add("deleteDialogs", "Find and delete the current user's dialogs by title/id/dbKey. This is destructive: preview matches first and wait for explicit user confirmation before deleting.", {
+    query: stringToolParam("Dialog title/id/dbKey search text, for example \u4E2D\u533B\u8BC4\u6D4B or a dialog id."),
+    matchMode: {
+      type: "string",
+      enum: ["contains", "exact", "prefix", "dialogId"],
+      description: "Matching mode. Default contains."
+    },
+    confirmedDialogIds: {
+      type: "array",
+      items: { type: "string" },
+      description: "Confirmed dialog ids or dbKeys to delete."
+    }
+  }, ["query"]);
+  add("listAgents", "List the current user's agents in the Nolo workspace.", {
+    space: stringToolParam("Optional space id or URL."),
+    publicOnly: { type: "boolean", description: "Only show public agents." }
+  });
+  add("readAgent", "Read one agent config in the Nolo workspace.", {
+    agent: stringToolParam("Agent key, id, alias, or URL.")
+  }, ["agent"]);
+  add("listSpaces", "List joined spaces in the Nolo workspace.", {});
+  add("readSpace", "Read one space in the Nolo workspace.", {
+    space: stringToolParam("Space id or URL."),
+    contentKey: stringToolParam("Optional content key inside the space."),
+    brief: { type: "boolean", description: "Return brief output when supported." }
+  }, ["space"]);
+  add("readDoc", "Read one normal doc/page in the Nolo workspace.", {
+    doc: stringToolParam("Doc/page key.")
+  }, ["doc"]);
+  add("readSkillDoc", "Read one skill doc in the Nolo workspace.", {
+    doc: stringToolParam("Skill doc/page key.")
+  }, ["doc"]);
+  add("loadSkill", "Load a Skill by name from the workspace skill directories (.agents/skills/<name>/SKILL.md, then docs/skills/<name>.md) and return its full SKILL.md content inline so you can follow its instructions. Use this instead of readFile when you want to activate a skill. On an unknown name the tool returns a plain text list of available skill names rather than failing.", {
+    name: stringToolParam("Skill name (the name advertised in the skill-discovery layer).")
+  }, ["name"]);
+  add("listTables", "List tables in the current user scope or an optional space scope.", {
+    limit: { type: "integer", description: "Maximum tables to return." },
+    space: stringToolParam("Optional space id or URL."),
+    titleQuery: stringToolParam("Optional case-insensitive title substring."),
+    purpose: stringToolParam("Optional purpose value such as agent_eval_workbench.")
+  });
+  add("queryTableRows", "Query rows from a Nolo table.", {
+    table: stringToolParam("Table id or meta key."),
+    limit: { type: "integer", description: "Optional row limit." },
+    row: stringToolParam("Optional row id or row db key."),
+    output: stringToolParam("Optional output format such as json, jsonl, or items.")
+  }, ["table"]);
+  add("cliWhoami", "Show the current Nolo CLI login state.", {});
+  add("cliDoctor", "Show Nolo CLI doctor diagnostics.", {});
+  return tools;
+}
+function noloPositiveIntegerString(value) {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? String(parsed) : null;
+}
+function noloStringArg(value) {
+  return asOptionalTrimmedString(value) ?? null;
+}
+function parseNoloWorkspaceToolArguments(raw) {
+  try {
+    return asRecordOrEmpty(JSON.parse(raw || "{}"));
+  } catch {
+    return {};
+  }
+}
+function clampNoloPositiveInteger(value, fallback, max = 500) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.min(Math.floor(parsed), max);
+}
+function getNoloDialogIdFromKey(dbKey) {
+  const index = dbKey.lastIndexOf("-");
+  return index >= 0 ? dbKey.slice(index + 1) : dbKey;
+}
+function resolveNoloDialogInput(rawInput, userId) {
+  const raw = rawInput.trim();
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    const url = new URL(raw);
+    const match = url.pathname.match(DIALOG_PATH_RE);
+    if (!match) throw new Error(`Unsupported dialog URL path: ${url.pathname}`);
+    const [, spaceId, ownerId, dialogId] = match;
+    return {
+      dbKey: `dialog-${ownerId}-${dialogId}`,
+      dialogId,
+      ownerId,
+      spaceId: spaceId ? decodeURIComponent(spaceId) : null
+    };
+  }
+  if (raw.startsWith("dialog-")) {
+    const dialogId = getNoloDialogIdFromKey(raw);
+    return {
+      dbKey: raw,
+      dialogId,
+      ownerId: raw.slice("dialog-".length, Math.max("dialog-".length, raw.length - dialogId.length - 1)),
+      spaceId: null
+    };
+  }
+  if (!DIALOG_ID_RE.test(raw)) {
+    throw new Error(`Unsupported dialog id: ${raw}`);
+  }
+  return {
+    dbKey: `dialog-${userId}-${raw}`,
+    dialogId: raw,
+    ownerId: userId,
+    spaceId: null
+  };
+}
+function normalizeNoloSpaceInput(raw) {
+  const value = raw.trim();
+  if (!value) return "";
+  if (value.startsWith("http://") || value.startsWith("https://")) {
+    const match = new URL(value).pathname.match(/^\/space\/([^/]+)/);
+    return match?.[1] ? decodeURIComponent(match[1]).replace(/^space-/, "") : "";
+  }
+  return value.replace(/^space-/, "");
+}
+function getNoloComparableUpdatedAt(record) {
+  const raw = record?.updatedAt ?? record?.updated_at ?? record?.createdAt ?? record?.created;
+  const asNumber = asOptionalFiniteNumber(raw);
+  if (asNumber !== void 0) return asNumber;
+  if (typeof raw === "string") return Date.parse(raw) || 0;
+  return 0;
+}
+function normalizeNoloSubjectKind(kind) {
+  return kind === "tableRow" ? "table-row" : kind;
+}
+function normalizeNoloSubjectRef(value) {
+  if (!isRecord(value)) return null;
+  const kindRaw = asOptionalTrimmedString(value.kind);
+  const kind = kindRaw ? normalizeNoloSubjectKind(kindRaw) : "";
+  const id = asOptionalTrimmedString(value.id) ?? "";
+  if (!kind || !id) return null;
+  const role = asOptionalTrimmedString(value.role) ?? "";
+  return {
+    kind,
+    id,
+    ...role ? { role } : {}
+  };
+}
+function buildNoloSubjectRefQueryTarget(args) {
+  const rowDbKey = noloStringArg(args.rowDbKey ?? args.row ?? args.taskRowDbKey);
+  const subjectKind = noloStringArg(args.subjectKind ?? args.kind) ?? (rowDbKey ? "table-row" : null);
+  const subjectId = noloStringArg(args.subjectId ?? args.id) ?? rowDbKey;
+  const subjectRole = noloStringArg(args.subjectRole ?? args.role) ?? (rowDbKey ? "task" : null);
+  if (!subjectKind || !subjectId) return null;
+  return {
+    kind: normalizeNoloSubjectKind(subjectKind),
+    id: subjectId,
+    ...subjectRole ? { role: subjectRole } : {}
+  };
+}
+function extractNoloDialogSubjectRefs(dialog) {
+  if (!isRecord(dialog) || !Array.isArray(dialog.subjectRefs)) return [];
+  return dialog.subjectRefs.map(normalizeNoloSubjectRef).filter((ref) => Boolean(ref));
+}
+function noloDialogMatchesSubjectRef(dialog, target) {
+  const normalizedTarget = normalizeNoloSubjectRef(target);
+  if (!normalizedTarget) return false;
+  return extractNoloDialogSubjectRefs(dialog).some(
+    (ref) => ref.kind === normalizedTarget.kind && ref.id === normalizedTarget.id
+  );
+}
+function noloArtifactCount(value) {
+  if (Array.isArray(value)) return value.length;
+  if (isRecord(value)) return Object.keys(value).length > 0 ? 1 : 0;
+  return value ? 1 : 0;
+}
+function summarizeNoloDialogSubjectRefEvidence(dialog, target) {
+  const dialogKey = asOptionalTrimmedString(dialog?.dbKey) ?? "";
+  const checkpoint = asRecordOrEmpty(dialog?.runtimeCheckpoint);
+  const matchedSubjectRefs = extractNoloDialogSubjectRefs(dialog).filter(
+    (ref) => ref.kind === normalizeNoloSubjectKind(target.kind) && ref.id === target.id
+  );
+  const lastToolNames = asNonEmptyStringArray(checkpoint.lastToolNames);
+  const artifactCount = noloArtifactCount(dialog?.artifacts);
+  return {
+    dialogId: asOptionalTrimmedString(dialog?.dialogId) ?? asOptionalTrimmedString(dialog?.id) ?? (dialogKey ? getNoloDialogIdFromKey(dialogKey) : null),
+    dialogKey: dialogKey || null,
+    title: asOptionalTrimmedString(dialog?.title) ?? null,
+    status: asOptionalTrimmedString(dialog?.status) ?? null,
+    checkpointStatus: asOptionalTrimmedString(checkpoint.status) ?? null,
+    updatedAt: typeof dialog?.updatedAt === "string" || typeof dialog?.updatedAt === "number" ? dialog.updatedAt : null,
+    hasArtifacts: artifactCount > 0,
+    artifactCount,
+    subjectRefs: matchedSubjectRefs,
+    lastToolNames
+  };
+}
+function normalizeNoloExcludeDialogIds(value) {
+  const rawValues = Array.isArray(value) ? value : [value];
+  const ids = /* @__PURE__ */ new Set();
+  for (const rawValue of rawValues) {
+    if (typeof rawValue !== "string") continue;
+    const trimmed = rawValue.trim();
+    if (!trimmed) continue;
+    ids.add(trimmed);
+    if (trimmed.startsWith("dialog-")) {
+      ids.add(getNoloDialogIdFromKey(trimmed));
+    }
+  }
+  return [...ids];
+}
+function getNoloDialogIdentityValues(dialog) {
+  if (!isRecord(dialog)) return [];
+  const values = /* @__PURE__ */ new Set();
+  for (const rawValue of [dialog.dialogId, dialog.id, dialog.dbKey]) {
+    if (typeof rawValue !== "string") continue;
+    const trimmed = rawValue.trim();
+    if (!trimmed) continue;
+    values.add(trimmed);
+    if (trimmed.startsWith("dialog-")) {
+      values.add(getNoloDialogIdFromKey(trimmed));
+    }
+  }
+  return [...values];
+}
+function filterNoloDialogsByExcludedIds(dialogs, excludeDialogIds) {
+  const excluded = new Set(normalizeNoloExcludeDialogIds(excludeDialogIds));
+  if (excluded.size === 0) return dialogs;
+  return dialogs.filter(
+    (dialog) => getNoloDialogIdentityValues(dialog).every((value) => !excluded.has(value))
+  );
+}
+function filterNoloDialogSubjectRefEvidence(args) {
+  const matched = [];
+  for (const dialog of filterNoloDialogsByExcludedIds(args.dialogs, args.excludeDialogIds)) {
+    if (noloDialogMatchesSubjectRef(dialog, args.target)) {
+      matched.push(dialog);
+    }
+  }
+  matched.sort((left, right) => getNoloComparableUpdatedAt(right) - getNoloComparableUpdatedAt(left));
+  const evidence = [];
+  for (const dialog of matched) {
+    const entry = summarizeNoloDialogSubjectRefEvidence(dialog, args.target);
+    if (args.status && entry.status !== args.status) continue;
+    if (args.checkpointStatus && entry.checkpointStatus !== args.checkpointStatus) continue;
+    if (args.hasArtifacts != null && entry.hasArtifacts !== args.hasArtifacts) continue;
+    evidence.push(entry);
+  }
+  return evidence.slice(0, args.limit);
+}
+function verifyNoloDialogSubjectRefQuery(dialogs, target, options = {}) {
+  const checkedDialogs = filterNoloDialogsByExcludedIds(dialogs, options.excludeDialogIds);
+  const unmatchedDialogs = [];
+  for (const dialog of checkedDialogs) {
+    if (noloDialogMatchesSubjectRef(dialog, target)) continue;
+    unmatchedDialogs.push({
+      dialogId: asOptionalTrimmedString(dialog?.dialogId) ?? asOptionalTrimmedString(dialog?.id) ?? (typeof dialog?.dbKey === "string" ? getNoloDialogIdFromKey(dialog.dbKey) : null),
+      dialogKey: asOptionalTrimmedString(dialog?.dbKey) ?? null,
+      subjectRefs: extractNoloDialogSubjectRefs(dialog)
+    });
+  }
+  const reason = unmatchedDialogs.length > 0 ? "unmatched_results" : "ok";
+  return {
+    ok: reason === "ok",
+    reason,
+    target,
+    returnedCount: checkedDialogs.length,
+    matchedCount: checkedDialogs.length - unmatchedDialogs.length,
+    unmatchedCount: unmatchedDialogs.length,
+    unmatchedDialogs
+  };
+}
+function buildNoloTableQueryRequest(args, currentUserId) {
+  const tableInput = noloStringArg(args.table ?? args.metaKey);
+  if (!tableInput) return null;
+  const tableMetaParts = tableInput.startsWith("meta-") ? tableInput.split("-") : [];
+  const tenantId = args.tenantId ?? (tableMetaParts.length >= 3 ? tableMetaParts[1] : currentUserId);
+  const tableId = args.tableId ?? (tableMetaParts.length >= 3 ? tableMetaParts.slice(2).join("-") : tableInput);
+  const filters = {
+    ...asRecordOrEmpty(args.filters)
+  };
+  const row = noloStringArg(args.row ?? args.rowId);
+  if (row) {
+    if (row.startsWith("row-")) filters.dbKey = row;
+    else filters.rowId = row;
+  }
+  return {
+    tenantId,
+    tableId,
+    filters,
+    columns: args.columns,
+    limit: args.limit ?? (row ? 1 : 20),
+    offset: args.offset,
+    includeBaseFields: args.includeBaseFields,
+    sortBy: args.sortBy ?? "updatedAt",
+    sortOrder: args.sortOrder === "asc" ? "asc" : "desc"
+  };
+}
+function buildNoloWorkspaceCommandArgs(call) {
+  const args = parseNoloWorkspaceToolArguments(call.arguments);
+  switch (call.name) {
+    case "listDialogs": {
+      const cliArgs = ["dialog", "list"];
+      const limit = noloPositiveIntegerString(args.limit);
+      const space = noloStringArg(args.space);
+      if (limit) cliArgs.push("--limit", limit);
+      if (space) cliArgs.push("--space", space);
+      return cliArgs;
+    }
+    case "readDialog": {
+      const dialog = noloStringArg(args.dialog ?? args.dialogId ?? args.id);
+      if (!dialog) throw new Error("readDialog requires dialog.");
+      const cliArgs = ["dialog", "read", dialog];
+      const limit = noloPositiveIntegerString(args.limit);
+      if (limit) cliArgs.push(limit);
+      return cliArgs;
+    }
+    case "queryDialogsBySubjectRef": {
+      const target = buildNoloSubjectRefQueryTarget(args);
+      if (!target) throw new Error("queryDialogsBySubjectRef requires rowDbKey or subjectKind plus subjectId.");
+      const cliArgs = ["dialog", "query"];
+      const rowDbKey = noloStringArg(args.rowDbKey ?? args.row ?? args.taskRowDbKey);
+      if (rowDbKey && target.kind === "table-row" && target.id === rowDbKey) {
+        cliArgs.push("--row-dbkey", rowDbKey);
+      } else {
+        cliArgs.push("--subject-kind", target.kind, "--subject-id", target.id);
+        if (target.role) cliArgs.push("--subject-role", target.role);
+      }
+      const limit = noloPositiveIntegerString(args.limit);
+      if (limit) cliArgs.push("--limit", limit);
+      const excludeDialogId = noloStringArg(args.excludeDialogId ?? args.excludeDialog);
+      if (excludeDialogId) cliArgs.push("--exclude-dialog", excludeDialogId);
+      cliArgs.push("--json");
+      return cliArgs;
+    }
+    case "listAgents": {
+      const cliArgs = ["agent", "list"];
+      const space = noloStringArg(args.space);
+      if (space) cliArgs.push("--space", space);
+      if (args.publicOnly === true) cliArgs.push("--public-only");
+      return cliArgs;
+    }
+    case "readAgent": {
+      const agent = noloStringArg(args.agent ?? args.agentKey ?? args.id);
+      if (!agent) throw new Error("readAgent requires agent.");
+      return ["agent", "read", agent];
+    }
+    case "listSpaces":
+      return ["space", "list"];
+    case "readSpace": {
+      const space = noloStringArg(args.space ?? args.spaceId ?? args.id);
+      if (!space) throw new Error("readSpace requires space.");
+      const cliArgs = ["space", "read", space];
+      const contentKey = noloStringArg(args.contentKey);
+      if (contentKey) cliArgs.push("--content-key", contentKey);
+      if (args.brief === true) cliArgs.push("--brief");
+      return cliArgs;
+    }
+    case "readDoc": {
+      const doc = noloStringArg(args.doc ?? args.docKey ?? args.pageKey ?? args.key);
+      if (!doc) throw new Error("readDoc requires doc.");
+      return ["doc", "read", doc];
+    }
+    case "readSkillDoc": {
+      const doc = noloStringArg(args.doc ?? args.docKey ?? args.pageKey ?? args.key);
+      if (!doc) throw new Error("readSkillDoc requires doc.");
+      return ["skill-doc", "read", doc];
+    }
+    case "loadSkill":
+      throw new Error("loadSkill is a local-fs tool and has no CLI mapping; wire buildLoadSkillExecutor instead.");
+    case "listTables": {
+      const cliArgs = ["table", "list"];
+      const limit = noloPositiveIntegerString(args.limit);
+      const space = noloStringArg(args.space ?? args.spaceId);
+      const titleQuery = noloStringArg(args.titleQuery);
+      const purpose = noloStringArg(args.purpose);
+      if (limit) cliArgs.push("--limit", limit);
+      if (space) cliArgs.push("--space", space);
+      if (titleQuery) cliArgs.push("--title-query", titleQuery);
+      if (purpose) cliArgs.push("--purpose", purpose);
+      return cliArgs;
+    }
+    case "queryTableRows": {
+      const table = noloStringArg(args.table ?? args.tableId ?? args.metaKey);
+      if (!table) throw new Error("queryTableRows requires table.");
+      const cliArgs = ["table", "query", "--table", table];
+      const limit = noloPositiveIntegerString(args.limit);
+      const row = noloStringArg(args.row ?? args.rowId);
+      const output = noloStringArg(args.output);
+      if (limit) cliArgs.push("--limit", limit);
+      if (row) cliArgs.push("--row", row);
+      if (output) cliArgs.push("--output", output);
+      return cliArgs;
+    }
+    case "cliWhoami":
+      return ["whoami"];
+    case "cliDoctor":
+      return ["doctor"];
+    default:
+      throw new Error(`Unsupported Nolo workspace tool: ${call.name}`);
+  }
+}
+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;
+}
+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-UGSQGX2U.js");
+    const resolved = resolveSkillByName(args.cwd, name);
+    if (!resolved) {
+      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-UGSQGX2U.js");
+  let available = [];
+  try {
+    available = discoverSkills(cwd).map((s) => s.name);
+  } catch {
+  }
+  const header = `Skill "${requestedName}" not found in this workspace's skill directories (.agents/skills/<name>/SKILL.md, docs/skills/<name>.md).`;
+  if (available.length === 0) return `${header}
+
+No skills were discovered in this workspace.`;
+  return `${header}
+
+Available skills: ${available.join(", ")}`;
+}
+var nodeSpawnFallback = (options) => {
+  return spawnToWebStreams({ cmd: options.cmd, env: options.env });
+};
+
+export {
+  canonicalizeToolName,
+  canonicalizeToolNames,
+  prioritizeToolNames,
+  resolveRuntimeToolSurfaceForAgent,
+  redactAgentRecordForWorkspaceTool,
+  resolveExecutableOnPath,
+  createGlob,
+  NOLO_WORKSPACE_TOOL_NAMES,
+  filterNoloWorkspaceToolNames,
+  buildNoloWorkspaceOpenAiTools,
+  parseNoloWorkspaceToolArguments,
+  clampNoloPositiveInteger,
+  getNoloDialogIdFromKey,
+  resolveNoloDialogInput,
+  normalizeNoloSpaceInput,
+  getNoloComparableUpdatedAt,
+  buildNoloSubjectRefQueryTarget,
+  normalizeNoloExcludeDialogIds,
+  filterNoloDialogSubjectRefEvidence,
+  verifyNoloDialogSubjectRefQuery,
+  buildNoloTableQueryRequest,
+  buildNoloWorkspaceCliToolExecutors,
+  buildLoadSkillExecutor
+};