nolo-cli 0.32.0 → 0.33.0-alpha.3

package/chunk-ADLYMQB6.js

@@ -0,0 +1,642 @@
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
+import {
+  asNonEmptyStringArray,
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  isOwnedAgentKey,
+  ownedAgentKey,
+  publicAgentKey
+} from "./chunk-BJIRLHJR.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/agent-runtime/agentRecordKeys.ts
+function buildAgentRuntimeAgentLookupKeys(args) {
+  if (/^agent(-pub)?-/.test(args.agentRef)) {
+    return [args.agentRef];
+  }
+  return [
+    ownedAgentKey(args.userId, args.agentRef),
+    publicAgentKey(args.agentRef)
+  ];
+}
+function shouldFetchAgentRuntimeRecordRemotely(dbKey) {
+  return /^agent(-pub)?-/.test(dbKey);
+}
+
+// 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 && isOwnedAgentKey(agentKey, 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/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 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 (metadata + messages) by full dbKey (dialog-<userId>-<id>) or URL. Use listDialogs first if target is unclear; a bare id resolves against the current user, pass user for someone else's dialog. Reading an agent run's dialog is fine at any time, but do not poll a still-running one through the full transcript: if controlAgentRun is available prefer it for live runs, otherwise use mode="status" for a compact snapshot, and pull the full transcript once the run is done/failed/cancelled.`, {
+    dialog: stringToolParam("Dialog dbKey (dialog-<userId>-<id>), dialog URL, or bare id (resolved against user/current account)."),
+    mode: {
+      type: "string",
+      enum: ["full", "status"],
+      description: "full (default) returns meta + messages; status returns a compact run snapshot (status/checkpoint/tools/files/error) without the transcript \u2014 prefer it when you only need to know whether an agent run is still active or how it ended."
+    },
+    limit: { type: "integer", description: "Max messages to return in mode=full, newest first. Omit for the complete transcript; a small limit can hide earlier tool calls. Ignored in mode=status." },
+    user: stringToolParam("Owner userId for a bare dialog id (e.g. a child run started by another account). Ignored when dialog is a dbKey or URL."),
+    server: stringToolParam("Optional server base URL to read from, e.g. when the dialog lives on another machine's nolo server.")
+  }, ["dialog"]);
+  add("queryDialogsBySubjectRef", "Query persisted dialog evidence by a generic dialog.subjectRefs target.", {
+    rowDbKey: stringToolParam("Optional alias for subjectKind=table-row, subjectId=<rowDbKey>, subjectRole=task."),
+    subjectKind: stringToolParam("Subject ref kind (e.g. table-row, page, file, commit, artifact)."),
+    subjectId: stringToolParam("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 (running, done, failed)."),
+    checkpointStatus: stringToolParam("Optional runtimeCheckpoint.status filter."),
+    hasArtifacts: { type: "boolean", description: "When true, only return dialogs with artifact evidence." },
+    excludeDialogId: stringToolParam("Optional dialog id to exclude from results.")
+  });
+  add("deleteDialogs", "Find and delete dialogs by title/id/dbKey. Preview matches and wait for user confirmation before deleting.", {
+    query: stringToolParam("Dialog title/id/dbKey search text."),
+    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 with runnable agentKey for delegation. Copy the agentKey verbatim; do not infer it from the display name.", {
+    space: stringToolParam("Optional space id or URL."),
+    publicOnly: { type: "boolean", description: "Only show public agents." }
+  });
+  add("readAgent", "Read one agent's full config by exact agentKey returned by listAgents (agent-<userId>-<id> or agent-pub-<id>); do not use the display name.", {
+    agent: stringToolParam("Exact agentKey from listAgents (preferred; copy verbatim; plain id or URL are compatibility fallbacks).")
+  }, ["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 (.agents/skills/<name>/SKILL.md) and return its full instructions inline. Returns available skills if not found.", {
+    name: stringToolParam("Skill name advertised in skill discovery.")
+  }, ["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 mode = noloStringArg(args.mode);
+      if (mode && mode !== "full" && mode !== "status") {
+        throw new Error(`readDialog mode must be "full" or "status", got "${mode}".`);
+      }
+      const statusMode = mode === "status";
+      const cliArgs = ["dialog", statusMode ? "status" : "read", dialog];
+      const limit = statusMode ? null : noloPositiveIntegerString(args.limit);
+      if (limit) cliArgs.push(limit);
+      const user = noloStringArg(args.user ?? args.userId ?? args.owner);
+      if (user) cliArgs.push("--user", user);
+      const server = noloStringArg(args.server ?? args.serverBase ?? args.serverUrl);
+      if (server) cliArgs.push("--server", server);
+      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");
+      cliArgs.push("--json", "--safe");
+      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.startsWith("page-") ? ["doc", "read", "--key", doc] : ["doc", "read", "--id", doc];
+    }
+    case "readSkillDoc": {
+      const doc = noloStringArg(args.doc ?? args.docKey ?? args.pageKey ?? args.key);
+      if (!doc) throw new Error("readSkillDoc requires doc.");
+      return doc.startsWith("page-") ? ["skill-doc", "read", "--key", doc] : ["skill-doc", "read", "--id", 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}`);
+  }
+}
+
+export {
+  buildAgentRuntimeAgentLookupKeys,
+  shouldFetchAgentRuntimeRecordRemotely,
+  resolveRuntimeToolSurfaceForAgent,
+  redactAgentRecordForWorkspaceTool,
+  NOLO_WORKSPACE_TOOL_NAMES,
+  buildNoloWorkspaceOpenAiTools,
+  noloPositiveIntegerString,
+  noloStringArg,
+  parseNoloWorkspaceToolArguments,
+  clampNoloPositiveInteger,
+  getNoloDialogIdFromKey,
+  resolveNoloDialogInput,
+  normalizeNoloSpaceInput,
+  getNoloComparableUpdatedAt,
+  buildNoloSubjectRefQueryTarget,
+  normalizeNoloExcludeDialogIds,
+  filterNoloDialogSubjectRefEvidence,
+  verifyNoloDialogSubjectRefQuery,
+  buildNoloTableQueryRequest,
+  buildNoloWorkspaceCommandArgs
+};

package/{chunk-ZWJOGMKH.js → chunk-AETZ7AD6.js}

@@ -1,7 +1,7 @@
 import {
   dump,
   load
-} from "./chunk-WZSRQNQG.js";
+} from "./chunk-KHCLMKZZ.js";
 import {
   asTrimmedNonEmptyStringArray
 } from "./chunk-I42VC5KR.js";