sim 2.1.0 → 2.1.1-preview.40.1

package/dist/index.js

@@ -2432,6 +2432,33 @@ function readConfigProfile(profile) {
 function readCredentialsProfile(profile) {
   return getSection(readIni(credentialsPath()), profile) ?? {};
 }
+function resolveAuthenticationProfileName(profile) {
+  const config = readConfigProfile(profile);
+  if (!Object.hasOwn(config, "auth_profile"))
+    return profile;
+  const authProfile = config.auth_profile.trim();
+  if (!authProfile) {
+    throw new ProfileConfigError(`Profile "${profile}" has an empty auth_profile.`);
+  }
+  if (authProfile === profile) {
+    throw new ProfileConfigError(`Profile "${profile}" cannot use itself as auth_profile. Remove the auth_profile setting instead.`);
+  }
+  if (Object.hasOwn(config, "endpoint")) {
+    throw new ProfileConfigError(`Profile "${profile}" cannot set both auth_profile and endpoint. Set the endpoint on authentication profile "${authProfile}".`);
+  }
+  if (readCredentialsProfile(profile).api_key) {
+    throw new ProfileConfigError(`Profile "${profile}" cannot set both auth_profile and its own API key. Remove one of them.`);
+  }
+  const authConfig = readConfigProfile(authProfile);
+  const credentials = readCredentialsProfile(authProfile);
+  if (Object.keys(authConfig).length === 0 && Object.keys(credentials).length === 0) {
+    throw new ProfileConfigError(`Profile "${profile}" references missing auth_profile "${authProfile}".`);
+  }
+  if (Object.hasOwn(authConfig, "auth_profile")) {
+    throw new ProfileConfigError(`Profile "${profile}" references auth_profile "${authProfile}", which also has auth_profile set. Authentication profile references cannot be chained.`);
+  }
+  return authProfile;
+}
 function listProfiles() {
   const names = new Set;
   for (const section of listSections(readIni(configPath()))) {
@@ -2445,6 +2472,9 @@ function listProfiles() {
   }
   return [...names].sort();
 }
+function listAuthenticationDependents(authProfile) {
+  return listProfiles().filter((profile) => profile !== authProfile && readConfigProfile(profile).auth_profile?.trim() === authProfile);
+}
 function writeConfigProfile(profile, values) {
   const doc = readIni(configPath());
   setSectionValues(doc, configSectionName(profile), values);
@@ -2489,11 +2519,13 @@ function resolve(candidates, fallback, fallbackSource) {
 function resolveProfile(overrides = {}) {
   const name = overrides.profile || process.env.SIM_PROFILE || DEFAULT_PROFILE;
   const config = readConfigProfile(name);
-  const credentials = readCredentialsProfile(name);
+  const authProfile = resolveAuthenticationProfileName(name);
+  const authConfig = authProfile === name ? config : readConfigProfile(authProfile);
+  const credentials = readCredentialsProfile(authProfile);
   const endpoint = resolve([
     ["flag", overrides.endpoint],
     ["env", process.env.SIM_ENDPOINT],
-    ["config", config.endpoint]
+    ["config", authConfig.endpoint]
   ], DEFAULT_ENDPOINT, "default");
   const apiKey = resolve([
     ["flag", overrides.apiKey],
@@ -6390,10 +6422,10 @@ var V2_OPERATIONS = {
   },
   abortKnowledgeDocumentUpload: {
     method: "DELETE",
-    path: "/api/v2/knowledge/[id]/documents/uploads/[uploadId]",
-    pathParams: ["id", "uploadId"],
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/uploads/[uploadId]",
+    pathParams: ["knowledgeBaseId", "uploadId"],
     pathParamDocs: {
-      id: "Unique knowledge base identifier.",
+      knowledgeBaseId: "Unique knowledge base identifier.",
       uploadId: "Upload session identifier returned when the upload was created."
     },
     responseMode: "json",
@@ -6406,6 +6438,17 @@ var V2_OPERATIONS = {
       }
     }
   },
+  activateWorkflowVersion: {
+    method: "POST",
+    path: "/api/v2/workflows/[workflowId]/versions/[version]/activate",
+    pathParams: ["workflowId", "version"],
+    pathParamDocs: {
+      workflowId: "Unique workflow identifier.",
+      version: "Numeric deployment version."
+    },
+    responseMode: "json",
+    summary: "Activate Workflow Version"
+  },
   addTableColumn: {
     method: "POST",
     path: "/api/v2/tables/[tableId]/columns",
@@ -6444,6 +6487,73 @@ var V2_OPERATIONS = {
       }
     }
   },
+  addWorkspaceFilesToKnowledgeBase: {
+    method: "POST",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/from-workspace-files",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
+    responseMode: "json",
+    summary: "Index Workspace Files",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns both the files and the base."
+      },
+      fileReferences: {
+        kind: "array",
+        required: true,
+        describe: "Workspace file identifiers or storage keys to index. Duplicates resolving to the same file are indexed once."
+      }
+    }
+  },
+  applyWorkflowOperations: {
+    method: "POST",
+    path: "/api/v2/workflows/[workflowId]/operations",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
+    responseMode: "json",
+    summary: "Apply Workflow Operations",
+    query: {
+      dryRun: {
+        kind: "boolean",
+        describe: "Validate and lint without persisting. The response is identical to the committed write of the same body, so a caller can inspect `lint` and then re-send the request for real. Nothing is written, no audit entry is recorded, and collaborators are not notified."
+      }
+    },
+    body: {
+      operations: { kind: "array", required: true, describe: "Edits to apply, in a single batch." },
+      atomic: {
+        kind: "boolean",
+        default: false,
+        describe: "Fail the whole batch when any operation is declined or any block input would be dropped. The default applies what it can and reports the rest in `skipped` and `inputValidationErrors`; `true` writes nothing and answers `409` instead."
+      },
+      layout: {
+        kind: "enum",
+        values: ["targeted", "none"],
+        default: "targeted",
+        describe: "Whether to reposition blocks the batch touched. `targeted` (default) nudges only the affected subgraph; `none` leaves every position exactly as supplied."
+      },
+      setBlockEnabled: {
+        kind: "array",
+        describe: "Blocks to enable or disable, applied after `operations`. Disabling a loop or parallel cascades to its unlocked descendants; enabling a block whose container is disabled is declined."
+      }
+    }
+  },
+  applyWorkflowVariables: {
+    method: "PATCH",
+    path: "/api/v2/workflows/[workflowId]/variables",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
+    responseMode: "json",
+    summary: "Update Workflow Variables",
+    body: {
+      operations: {
+        kind: "array",
+        required: true,
+        describe: "Variable changes to apply, in order."
+      }
+    }
+  },
   bulkDeleteFiles: {
     method: "POST",
     path: "/api/v2/files/bulk-delete",
@@ -6455,11 +6565,101 @@ var V2_OPERATIONS = {
       fileIds: { kind: "array", required: true, describe: "File identifiers to update." }
     }
   },
+  bulkDeleteTables: {
+    method: "POST",
+    path: "/api/v2/tables/bulk-delete",
+    pathParams: [],
+    responseMode: "json",
+    summary: "Bulk Delete Tables and Folders",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns every selected item."
+      },
+      tableIds: { kind: "array", default: [], describe: "Tables to archive, by identifier." },
+      folderPaths: {
+        kind: "array",
+        describe: "Table folders to delete, by canonical path. Each cascades to everything inside it."
+      }
+    }
+  },
+  bulkDownloadFiles: {
+    method: "GET",
+    path: "/api/v2/files/bulk-download",
+    pathParams: [],
+    responseMode: "binary",
+    summary: "Bulk Download Files",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace containing the selection."
+      },
+      fileIds: {
+        kind: "string",
+        describe: "File identifiers to include, comma-separated. At most 100 entries."
+      },
+      folderPaths: {
+        kind: "string",
+        describe: "Folder paths to include with all their descendants, comma-separated. At most 100 entries, and the files they resolve to count against the same 100-file download ceiling. A path that matches no folder is rejected rather than ignored."
+      }
+    }
+  },
+  bulkSaveKnowledgeTagDefinitions: {
+    method: "PUT",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/tags",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
+    responseMode: "json",
+    summary: "Bulk Save Tag Definitions",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      definitions: {
+        kind: "array",
+        required: true,
+        describe: "Tag definitions to create or update on the knowledge base."
+      }
+    }
+  },
+  bulkUpdateKnowledgeChunks: {
+    method: "PATCH",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/[documentId]/chunks",
+    pathParams: ["knowledgeBaseId", "documentId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Unique knowledge base identifier.",
+      documentId: "Unique knowledge document identifier."
+    },
+    responseMode: "json",
+    summary: "Bulk Update Chunks",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      operation: {
+        kind: "enum",
+        required: true,
+        values: ["enable", "disable", "delete"],
+        describe: "What to do with the selected chunks."
+      },
+      chunkIds: {
+        kind: "array",
+        required: true,
+        describe: "Chunks to operate on, by identifier. Ids outside the document are ignored."
+      }
+    }
+  },
   bulkUpdateKnowledgeDocuments: {
     method: "PATCH",
-    path: "/api/v2/knowledge/[id]/documents",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique knowledge base identifier." },
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
     responseMode: "json",
     summary: "Bulk Enable or Disable Documents",
     body: {
@@ -6486,11 +6686,48 @@ var V2_OPERATIONS = {
       }
     }
   },
+  bulkUpdateTableRows: {
+    method: "POST",
+    path: "/api/v2/tables/[tableId]/rows/bulk-update",
+    pathParams: ["tableId"],
+    pathParamDocs: { tableId: "Unique table identifier." },
+    responseMode: "json",
+    summary: "Bulk Update Rows",
+    body: {
+      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." },
+      updates: {
+        kind: "array",
+        required: true,
+        describe: "One merge patch per row. Each row identifier may appear at most once."
+      }
+    }
+  },
+  cancelTableDispatch: {
+    method: "DELETE",
+    path: "/api/v2/tables/[tableId]/dispatches/[dispatchId]",
+    pathParams: ["tableId", "dispatchId"],
+    pathParamDocs: {
+      tableId: "Unique table identifier.",
+      dispatchId: "Unique table run-dispatch identifier."
+    },
+    responseMode: "json",
+    summary: "Cancel Run Dispatch",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the transfer resource."
+      }
+    }
+  },
   cancelTableExport: {
     method: "DELETE",
-    path: "/api/v2/tables/exports/[exportId]",
-    pathParams: ["exportId"],
-    pathParamDocs: { exportId: "Unique table-export identifier." },
+    path: "/api/v2/tables/[tableId]/exports/[exportId]",
+    pathParams: ["tableId", "exportId"],
+    pathParamDocs: {
+      tableId: "Unique table identifier.",
+      exportId: "Unique table-export identifier."
+    },
     responseMode: "json",
     summary: "Cancel Table Export",
     query: {
@@ -6541,12 +6778,33 @@ var V2_OPERATIONS = {
   },
   cancelWorkflowRun: {
     method: "POST",
-    path: "/api/v2/workflows/[id]/runs/[runId]/cancel",
-    pathParams: ["id", "runId"],
-    pathParamDocs: { id: "Unique workflow identifier.", runId: "Unique workflow run identifier." },
+    path: "/api/v2/workflows/[workflowId]/runs/[runId]/cancel",
+    pathParams: ["workflowId", "runId"],
+    pathParamDocs: {
+      workflowId: "Unique workflow identifier.",
+      runId: "Unique workflow run identifier."
+    },
     responseMode: "json",
     summary: "Cancel Workflow Run"
   },
+  chat: {
+    method: "POST",
+    path: "/api/v2/chat",
+    pathParams: [],
+    responseMode: "json",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace the conversation runs in."
+      },
+      message: { kind: "string", required: true, describe: "The message to send to Sim." },
+      conversationId: {
+        kind: "string",
+        describe: "Conversation to continue; a new one starts when omitted."
+      }
+    }
+  },
   completeFileUpload: {
     method: "POST",
     path: "/api/v2/files/uploads/[uploadId]/complete",
@@ -6564,10 +6822,10 @@ var V2_OPERATIONS = {
   },
   completeKnowledgeDocumentUpload: {
     method: "POST",
-    path: "/api/v2/knowledge/[id]/documents/uploads/[uploadId]/complete",
-    pathParams: ["id", "uploadId"],
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/uploads/[uploadId]/complete",
+    pathParams: ["knowledgeBaseId", "uploadId"],
     pathParamDocs: {
-      id: "Unique knowledge base identifier.",
+      knowledgeBaseId: "Unique knowledge base identifier.",
       uploadId: "Upload session identifier returned when the upload was created."
     },
     responseMode: "json",
@@ -6759,11 +7017,73 @@ var V2_OPERATIONS = {
       }
     }
   },
+  createKnowledgeChunk: {
+    method: "POST",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/[documentId]/chunks",
+    pathParams: ["knowledgeBaseId", "documentId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Unique knowledge base identifier.",
+      documentId: "Unique knowledge document identifier."
+    },
+    responseMode: "json",
+    summary: "Create Chunk",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      content: {
+        kind: "string",
+        required: true,
+        describe: "Text to embed. It is embedded on write, so the chunk is searchable immediately."
+      },
+      enabled: {
+        kind: "boolean",
+        default: true,
+        describe: "Whether the new chunk participates in search."
+      }
+    }
+  },
+  createKnowledgeConnector: {
+    method: "POST",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/connectors",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
+    responseMode: "json",
+    summary: "Create Knowledge Connector",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      connectorType: { kind: "string", required: true, describe: "Registered connector type." },
+      credentialId: {
+        kind: "string",
+        describe: "OAuth credential identifier for connectors that require OAuth."
+      },
+      apiKey: {
+        kind: "string",
+        describe: "Write-only API key for connectors that use API-key authentication."
+      },
+      sourceConfig: {
+        kind: "object",
+        required: true,
+        describe: "Connector-specific source selection and filtering configuration."
+      },
+      syncIntervalMinutes: {
+        kind: "integer",
+        default: 1440,
+        describe: "Scheduled synchronization interval in minutes; zero disables scheduling."
+      }
+    }
+  },
   createKnowledgeDocumentUpload: {
     method: "POST",
-    path: "/api/v2/knowledge/[id]/documents/uploads",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique knowledge base identifier." },
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/uploads",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
     responseMode: "json",
     summary: "Create Document Upload",
     body: {
@@ -6795,10 +7115,10 @@ var V2_OPERATIONS = {
   },
   createKnowledgeDocumentUploadPartUrls: {
     method: "POST",
-    path: "/api/v2/knowledge/[id]/documents/uploads/[uploadId]/parts",
-    pathParams: ["id", "uploadId"],
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/uploads/[uploadId]/parts",
+    pathParams: ["knowledgeBaseId", "uploadId"],
     pathParamDocs: {
-      id: "Unique knowledge base identifier.",
+      knowledgeBaseId: "Unique knowledge base identifier.",
       uploadId: "Upload session identifier returned when the upload was created."
     },
     responseMode: "json",
@@ -6833,6 +7153,55 @@ var V2_OPERATIONS = {
       path: { kind: "string", required: true, describe: "Path of the folder to create." }
     }
   },
+  createKnowledgeTag: {
+    method: "POST",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/tags",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
+    responseMode: "json",
+    summary: "Create Tag",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      displayName: {
+        kind: "string",
+        required: true,
+        describe: "Name tag filters and document reads use for this tag."
+      },
+      fieldType: {
+        kind: "enum",
+        values: ["text", "number", "date", "boolean"],
+        default: "text",
+        describe: "Value type stored in the slot; it decides which slots are usable and which filter operators apply. Slot capacity per type: text 7, number 5, date 2, boolean 3."
+      },
+      tagSlot: {
+        kind: "enum",
+        values: [
+          "tag1",
+          "tag2",
+          "tag3",
+          "tag4",
+          "tag5",
+          "tag6",
+          "tag7",
+          "number1",
+          "number2",
+          "number3",
+          "number4",
+          "number5",
+          "date1",
+          "date2",
+          "boolean1",
+          "boolean2",
+          "boolean3"
+        ],
+        describe: "Slot to store the tag in. Omit to take the next free slot for the field type; a slot that does not belong to the field type, or one already in use, is rejected."
+      }
+    }
+  },
   createMcpServer: {
     method: "POST",
     path: "/api/v2/mcp-servers",
@@ -6923,22 +7292,11 @@ var V2_OPERATIONS = {
         kind: "string",
         describe: "Required only when provider discovery requests a client-generated ID."
       },
-      serviceAccountJson: {
+      credentials: {
         kind: "string",
-        describe: "Write-only Google service-account JSON key."
-      },
-      apiToken: { kind: "string", describe: "Write-only provider API token." },
-      domain: { kind: "string", describe: "Provider account domain." },
-      signingSecret: { kind: "string", describe: "Write-only webhook signing secret." },
-      botToken: { kind: "string", describe: "Write-only bot token." },
-      clientId: { kind: "string", describe: "OAuth client identifier." },
-      clientSecret: { kind: "string", describe: "Write-only OAuth client secret." },
-      certificateId: { kind: "string", describe: "Provider certificate mapping identifier." },
-      orgId: { kind: "string", describe: "Provider organization ID." },
-      dataCenter: { kind: "string", describe: "Provider data center." },
-      authMethod: { kind: "string", describe: "Provider authentication method." },
-      privateKey: { kind: "string", describe: "Write-only PEM private key." },
-      username: { kind: "string", describe: "Provider run-as username." }
+        required: true,
+        describe: "Write-only JSON object string containing the fields declared by credential-provider discovery."
+      }
     }
   },
   createSkill: {
@@ -6984,6 +7342,35 @@ var V2_OPERATIONS = {
       folderPath: { kind: "string", describe: "Folder in which to create the table." }
     }
   },
+  createTableDispatch: {
+    method: "POST",
+    path: "/api/v2/tables/[tableId]/dispatches",
+    pathParams: ["tableId"],
+    pathParamDocs: { tableId: "Unique table identifier." },
+    responseMode: "json",
+    summary: "Create Run Dispatch",
+    body: {
+      workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." },
+      groupIds: {
+        kind: "array",
+        required: true,
+        describe: "Workflow or enrichment groups to run."
+      },
+      runMode: {
+        kind: "enum",
+        values: ["all", "incomplete"],
+        default: "all",
+        describe: "Whether to run all or only incomplete cells."
+      },
+      rowIds: { kind: "array", describe: "Explicit row subset to run." },
+      filter: {
+        kind: "unknown",
+        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+      },
+      excludeRowIds: { kind: "array", describe: "Rows excluded from a select-all run scope." },
+      limit: { kind: "object", describe: "Optional cap on eligible rows to run." }
+    }
+  },
   createTableExport: {
     method: "POST",
     path: "/api/v2/tables/[tableId]/exports",
@@ -7120,11 +7507,40 @@ var V2_OPERATIONS = {
       path: { kind: "string", required: true, describe: "Path of the folder to create." }
     }
   },
-  deleteCredential: {
-    method: "DELETE",
+  createWorkflowMcpServer: {
+    method: "POST",
+    path: "/api/v2/workflow-mcp-servers",
+    pathParams: [],
+    responseMode: "json",
+    summary: "Create Workflow MCP Server",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace in which to publish the server."
+      },
+      name: {
+        kind: "string",
+        required: true,
+        describe: "Server display name, shown to connecting MCP clients."
+      },
+      description: { kind: "string", describe: "Optional server description." },
+      isPublic: {
+        kind: "boolean",
+        default: false,
+        describe: "Whether the server answers MCP clients without a Sim API key. Defaults to false — a public server executes the workflows it publishes for anyone holding its URL."
+      },
+      workflowIds: {
+        kind: "array",
+        describe: "Deployed workflows to publish as tools on the new server."
+      }
+    }
+  },
+  deleteCredential: {
+    method: "DELETE",
     path: "/api/v2/credentials/[credentialId]",
     pathParams: ["credentialId"],
-    pathParamDocs: { credentialId: "Credential to disconnect." },
+    pathParamDocs: { credentialId: "Credential to update or disconnect." },
     responseMode: "json",
     summary: "Disconnect Credential",
     query: {
@@ -7137,9 +7553,9 @@ var V2_OPERATIONS = {
   },
   deleteCustomTool: {
     method: "DELETE",
-    path: "/api/v2/custom-tools/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique custom tool identifier." },
+    path: "/api/v2/custom-tools/[customToolId]",
+    pathParams: ["customToolId"],
+    pathParamDocs: { customToolId: "Unique custom tool identifier." },
     responseMode: "json",
     summary: "Delete Custom Tool",
     query: {
@@ -7193,9 +7609,9 @@ var V2_OPERATIONS = {
   },
   deleteKnowledgeBase: {
     method: "DELETE",
-    path: "/api/v2/knowledge/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique knowledge base identifier." },
+    path: "/api/v2/knowledge/[knowledgeBaseId]",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
     responseMode: "json",
     summary: "Delete Knowledge Base",
     query: {
@@ -7206,12 +7622,53 @@ var V2_OPERATIONS = {
       }
     }
   },
+  deleteKnowledgeChunk: {
+    method: "DELETE",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/[documentId]/chunks/[chunkId]",
+    pathParams: ["knowledgeBaseId", "documentId", "chunkId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Unique knowledge base identifier.",
+      documentId: "Unique knowledge document identifier.",
+      chunkId: "Unique chunk identifier."
+    },
+    responseMode: "json",
+    summary: "Delete Chunk",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      }
+    }
+  },
+  deleteKnowledgeConnector: {
+    method: "DELETE",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/connectors/[connectorId]",
+    pathParams: ["knowledgeBaseId", "connectorId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Knowledge base that owns the connector.",
+      connectorId: "Connector selected for the operation."
+    },
+    responseMode: "json",
+    summary: "Delete Knowledge Connector",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      deleteDocuments: {
+        kind: "boolean",
+        describe: "Also permanently delete documents produced by this connector."
+      }
+    }
+  },
   deleteKnowledgeDocument: {
     method: "DELETE",
-    path: "/api/v2/knowledge/[id]/documents/[documentId]",
-    pathParams: ["id", "documentId"],
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/[documentId]",
+    pathParams: ["knowledgeBaseId", "documentId"],
     pathParamDocs: {
-      id: "Unique knowledge base identifier.",
+      knowledgeBaseId: "Unique knowledge base identifier.",
       documentId: "Unique knowledge document identifier."
     },
     responseMode: "json",
@@ -7254,11 +7711,48 @@ var V2_OPERATIONS = {
       }
     }
   },
+  deleteKnowledgeTag: {
+    method: "DELETE",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/tags/[tagId]",
+    pathParams: ["knowledgeBaseId", "tagId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Unique knowledge base identifier.",
+      tagId: "Unique tag definition identifier."
+    },
+    responseMode: "json",
+    summary: "Delete Tag",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      }
+    }
+  },
+  deleteKnowledgeTagDefinitions: {
+    method: "DELETE",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/tags",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
+    responseMode: "json",
+    summary: "Delete Tag Definitions",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      unused: {
+        kind: "boolean",
+        describe: "Whether to remove only the tag definitions no document in the knowledge base still carries a value for. Defaults to true. Pass `unused=false` to delete every definition on the knowledge base, which also clears its slot on every document and chunk and is not recoverable."
+      }
+    }
+  },
   deleteMcpServer: {
     method: "DELETE",
-    path: "/api/v2/mcp-servers/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique MCP server identifier." },
+    path: "/api/v2/mcp-servers/[mcpServerId]",
+    pathParams: ["mcpServerId"],
+    pathParamDocs: { mcpServerId: "Unique MCP server identifier." },
     responseMode: "json",
     summary: "Delete MCP Server",
     query: {
@@ -7292,10 +7786,10 @@ var V2_OPERATIONS = {
   },
   deleteSkill: {
     method: "DELETE",
-    path: "/api/v2/skills/[id]",
-    pathParams: ["id"],
+    path: "/api/v2/skills/[skillId]",
+    pathParams: ["skillId"],
     pathParamDocs: {
-      id: "Unique skill identifier. A built-in skill is `builtin-` followed by its name, for example `builtin-research`."
+      skillId: "Unique skill identifier. A built-in skill is `builtin-` followed by its name, for example `builtin-research`."
     },
     responseMode: "json",
     summary: "Delete Skill",
@@ -7397,12 +7891,20 @@ var V2_OPERATIONS = {
   },
   deleteWorkflow: {
     method: "DELETE",
-    path: "/api/v2/workflows/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "Delete Workflow"
   },
+  deleteWorkflowChatDeployment: {
+    method: "DELETE",
+    path: "/api/v2/workflows/[workflowId]/deployments/chat",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
+    responseMode: "json",
+    summary: "Delete Workflow Chat Deployment"
+  },
   deleteWorkflowFolder: {
     method: "DELETE",
     path: "/api/v2/workflows/folders",
@@ -7445,11 +7947,19 @@ var V2_OPERATIONS = {
       groupId: { kind: "string", required: true, describe: "Workflow group to delete." }
     }
   },
+  deleteWorkflowMcpServer: {
+    method: "DELETE",
+    path: "/api/v2/workflow-mcp-servers/[serverId]",
+    pathParams: ["serverId"],
+    pathParamDocs: { serverId: "Unique workflow-MCP server identifier." },
+    responseMode: "json",
+    summary: "Delete Workflow MCP Server"
+  },
   deployWorkflow: {
     method: "POST",
-    path: "/api/v2/workflows/[id]/deploy",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]/deploy",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "Deploy Workflow",
     body: {
@@ -7460,6 +7970,33 @@ var V2_OPERATIONS = {
       }
     }
   },
+  deployWorkflowMcpTool: {
+    method: "POST",
+    path: "/api/v2/workflow-mcp-servers/[serverId]/tools",
+    pathParams: ["serverId"],
+    pathParamDocs: { serverId: "Unique workflow-MCP server identifier." },
+    responseMode: "json",
+    summary: "Publish Workflow As MCP Tool",
+    body: {
+      workflowId: {
+        kind: "string",
+        required: true,
+        describe: "Deployed workflow to publish. The workflow must already be deployed."
+      },
+      toolName: {
+        kind: "string",
+        describe: "Name MCP clients call. Normalized to the MCP tool-name grammar, and derived from the workflow name when omitted."
+      },
+      toolDescription: {
+        kind: "string",
+        describe: "Description shown to MCP clients. Derived from the workflow name when omitted."
+      },
+      parameterDescriptions: {
+        kind: "array",
+        describe: "Per-field description overrides applied to the schema generated from the deployed workflow inputs. A name matching no input field is ignored."
+      }
+    }
+  },
   downloadFile: {
     method: "GET",
     path: "/api/v2/files/[fileId]",
@@ -7471,17 +8008,51 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Workspace that owns the file." }
     }
   },
+  downloadRunFile: {
+    method: "GET",
+    path: "/api/v2/workflows/[workflowId]/runs/[runId]/files/[fileId]",
+    pathParams: ["workflowId", "runId", "fileId"],
+    pathParamDocs: {
+      workflowId: "Unique workflow identifier.",
+      runId: "Unique workflow run identifier.",
+      fileId: "Identifier of a file the run produced, as reported by the run resource."
+    },
+    responseMode: "binary",
+    summary: "Download Workflow Run File"
+  },
+  duplicateWorkflow: {
+    method: "POST",
+    path: "/api/v2/workflows/[workflowId]/duplicate",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
+    responseMode: "json",
+    summary: "Duplicate Workflow",
+    body: {
+      name: {
+        kind: "string",
+        describe: "Name for the copy. Defaults to the source name, deduplicated within the folder."
+      },
+      folderPath: {
+        kind: "string",
+        describe: "Destination folder path. Defaults to the source workflow's folder."
+      }
+    }
+  },
   executeWorkflow: {
     method: "POST",
-    path: "/api/v2/workflows/[id]/execute",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]/execute",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "Execute Workflow",
     body: {
       input: {
         kind: "object",
-        describe: "Workflow input keyed by deployed trigger input-field name."
+        describe: "Workflow input keyed by the selected trigger input-field name."
+      },
+      run: {
+        kind: "unknown",
+        describe: "Workflow state and entry point to execute. Omit for the active deployment. Manual execution requires a personal API key with write access and supports synchronous or streamed runs only."
       },
       async: {
         kind: "boolean",
@@ -7517,40 +8088,23 @@ var V2_OPERATIONS = {
       },
       base64MaxBytes: {
         kind: "integer",
-        describe: "Maximum total bytes of file content to inline as base64. Rejected when `async` is true."
+        describe: "Maximum total bytes of file content to inline as base64, lowering but never raising the server limit of 16 MiB. Rejected when `async` is true."
       }
     }
   },
   exportWorkflow: {
     method: "GET",
-    path: "/api/v2/workflows/[id]/export",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]/export",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "Export Workflow"
   },
-  findTableRows: {
-    method: "POST",
-    path: "/api/v2/tables/[tableId]/rows/find",
-    pathParams: ["tableId"],
-    pathParamDocs: { tableId: "Unique table identifier." },
-    responseMode: "json",
-    summary: "Find Rows",
-    body: {
-      workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." },
-      q: { kind: "string", required: true, describe: "Case-insensitive cell substring to find." },
-      predicate: {
-        kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
-      },
-      sort: { kind: "array", describe: "Ordered table-row sort specification." }
-    }
-  },
   getAuditLog: {
     method: "GET",
-    path: "/api/v2/audit-logs/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Audit-log entry identifier." },
+    path: "/api/v2/audit-logs/[auditLogId]",
+    pathParams: ["auditLogId"],
+    pathParamDocs: { auditLogId: "Audit-log entry identifier." },
     responseMode: "json",
     summary: "Get Audit Log",
     query: {
@@ -7570,15 +8124,32 @@ var V2_OPERATIONS = {
     query: {
       workspaceId: {
         kind: "string",
-        describe: "Workspace whose payer should be resolved. Workspace API keys are pinned to their own workspace."
+        describe: "Workspace whose payer should be resolved. A workspace API key is pinned to its own workspace: any other id answers `404 Workspace not found`, which is also what an id that does not exist answers."
+      }
+    }
+  },
+  getBlock: {
+    method: "GET",
+    path: "/api/v2/blocks/[blockId]",
+    pathParams: ["blockId"],
+    pathParamDocs: {
+      blockId: "Block type identifier. An unversioned base type resolves to the newest version, and the response echoes the resolved id."
+    },
+    responseMode: "json",
+    summary: "Get Block",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace whose integration allowlist, revealed preview blocks, and deployed custom blocks decide what this catalog contains."
       }
     }
   },
   getCustomTool: {
     method: "GET",
-    path: "/api/v2/custom-tools/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique custom tool identifier." },
+    path: "/api/v2/custom-tools/[customToolId]",
+    pathParams: ["customToolId"],
+    pathParamDocs: { customToolId: "Unique custom tool identifier." },
     responseMode: "json",
     summary: "Get Custom Tool",
     query: {
@@ -7617,11 +8188,26 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Workspace that owns the file." }
     }
   },
+  getFileUpload: {
+    method: "GET",
+    path: "/api/v2/files/uploads/[uploadId]",
+    pathParams: ["uploadId"],
+    pathParamDocs: { uploadId: "Upload session identifier." },
+    responseMode: "json",
+    summary: "Get File Upload",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the upload session."
+      }
+    }
+  },
   getKnowledgeBase: {
     method: "GET",
-    path: "/api/v2/knowledge/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique knowledge base identifier." },
+    path: "/api/v2/knowledge/[knowledgeBaseId]",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
     responseMode: "json",
     summary: "Get Knowledge Base",
     query: {
@@ -7632,12 +8218,49 @@ var V2_OPERATIONS = {
       }
     }
   },
+  getKnowledgeChunk: {
+    method: "GET",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/[documentId]/chunks/[chunkId]",
+    pathParams: ["knowledgeBaseId", "documentId", "chunkId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Unique knowledge base identifier.",
+      documentId: "Unique knowledge document identifier.",
+      chunkId: "Unique chunk identifier."
+    },
+    responseMode: "json",
+    summary: "Get Chunk",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      }
+    }
+  },
+  getKnowledgeConnector: {
+    method: "GET",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/connectors/[connectorId]",
+    pathParams: ["knowledgeBaseId", "connectorId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Knowledge base that owns the connector.",
+      connectorId: "Connector selected for the operation."
+    },
+    responseMode: "json",
+    summary: "Get Knowledge Connector",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      }
+    }
+  },
   getKnowledgeDocument: {
     method: "GET",
-    path: "/api/v2/knowledge/[id]/documents/[documentId]",
-    pathParams: ["id", "documentId"],
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/[documentId]",
+    pathParams: ["knowledgeBaseId", "documentId"],
     pathParamDocs: {
-      id: "Unique knowledge base identifier.",
+      knowledgeBaseId: "Unique knowledge base identifier.",
       documentId: "Unique knowledge document identifier."
     },
     responseMode: "json",
@@ -7658,11 +8281,55 @@ var V2_OPERATIONS = {
     responseMode: "json",
     summary: "Get Log"
   },
+  getLogStats: {
+    method: "GET",
+    path: "/api/v2/logs/stats",
+    pathParams: [],
+    responseMode: "json",
+    summary: "Get Log Statistics",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace whose execution statistics to summarize."
+      },
+      workflowIds: {
+        kind: "string",
+        describe: "Comma-separated workflow identifiers to include. At most 200 entries. An empty entry is rejected."
+      },
+      folderPaths: {
+        kind: "string",
+        describe: "Comma-separated workflow folder paths to include. At most 100 entries. A path covers its whole subtree. A path that names no folder narrows the result to nothing, so the response is an empty page rather than an error."
+      },
+      triggers: {
+        kind: "string",
+        describe: "Comma-separated trigger types to include. An empty entry is rejected. The vocabulary is open, so an unrecognized member selects no runs; the literal `all` disables this filter."
+      },
+      level: {
+        kind: "enum",
+        values: ["info", "error"],
+        describe: "Severity level to include."
+      },
+      startDate: {
+        kind: "string",
+        describe: "Only include runs started at or after this UTC ISO 8601 timestamp, e.g. `2026-08-06T00:00:00Z`. A date without a time, or a timestamp carrying a UTC offset instead of `Z`, is rejected, as is year `0000`, which names no storable instant."
+      },
+      endDate: {
+        kind: "string",
+        describe: "Only include runs started at or before this UTC ISO 8601 timestamp, e.g. `2026-08-06T00:00:00Z`. A date without a time, or a timestamp carrying a UTC offset instead of `Z`, is rejected, as is year `0000`, which names no storable instant."
+      },
+      segmentCount: {
+        kind: "integer",
+        default: 72,
+        describe: "Number of equal time buckets to divide the window into, from 1 to 500. Exactly this many buckets are always returned. Buckets are never narrower than one minute, so on a short window the series extends past the end of the window rather than being compressed, and the trailing buckets are empty."
+      }
+    }
+  },
   getMcpServer: {
     method: "GET",
-    path: "/api/v2/mcp-servers/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique MCP server identifier." },
+    path: "/api/v2/mcp-servers/[mcpServerId]",
+    pathParams: ["mcpServerId"],
+    pathParamDocs: { mcpServerId: "Unique MCP server identifier." },
     responseMode: "json",
     summary: "Get MCP Server",
     query: {
@@ -7673,12 +8340,55 @@ var V2_OPERATIONS = {
       }
     }
   },
+  getMeta: {
+    method: "GET",
+    path: "/api/v2/meta",
+    pathParams: [],
+    responseMode: "json",
+    summary: "Get API Capabilities"
+  },
+  getNextKnowledgeTagSlot: {
+    method: "GET",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/tags/next-slot",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
+    responseMode: "json",
+    summary: "Get Next Tag Slot",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      fieldType: {
+        kind: "enum",
+        required: true,
+        values: ["text", "number", "date", "boolean"],
+        describe: "Value type stored in the slot; it decides which slots are usable and which filter operators apply. Slot capacity per type: text 7, number 5, date 2, boolean 3."
+      }
+    }
+  },
+  getRowEnrichment: {
+    method: "GET",
+    path: "/api/v2/tables/[tableId]/rows/[rowId]/enrichment/[groupId]",
+    pathParams: ["tableId", "rowId", "groupId"],
+    pathParamDocs: {
+      tableId: "Unique table identifier.",
+      rowId: "Unique table row identifier.",
+      groupId: "Workflow or enrichment group to run."
+    },
+    responseMode: "json",
+    summary: "Get Enrichment Run Detail",
+    query: {
+      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." }
+    }
+  },
   getSkill: {
     method: "GET",
-    path: "/api/v2/skills/[id]",
-    pathParams: ["id"],
+    path: "/api/v2/skills/[skillId]",
+    pathParams: ["skillId"],
     pathParamDocs: {
-      id: "Unique skill identifier. A built-in skill is `builtin-` followed by its name, for example `builtin-research`."
+      skillId: "Unique skill identifier. A built-in skill is `builtin-` followed by its name, for example `builtin-research`."
     },
     responseMode: "json",
     summary: "Get Skill",
@@ -7697,11 +8407,32 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." }
     }
   },
+  getTableDispatch: {
+    method: "GET",
+    path: "/api/v2/tables/[tableId]/dispatches/[dispatchId]",
+    pathParams: ["tableId", "dispatchId"],
+    pathParamDocs: {
+      tableId: "Unique table identifier.",
+      dispatchId: "Unique table run-dispatch identifier."
+    },
+    responseMode: "json",
+    summary: "Get Run Dispatch",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the transfer resource."
+      }
+    }
+  },
   getTableExport: {
     method: "GET",
-    path: "/api/v2/tables/exports/[exportId]",
-    pathParams: ["exportId"],
-    pathParamDocs: { exportId: "Unique table-export identifier." },
+    path: "/api/v2/tables/[tableId]/exports/[exportId]",
+    pathParams: ["tableId", "exportId"],
+    pathParamDocs: {
+      tableId: "Unique table identifier.",
+      exportId: "Unique table-export identifier."
+    },
     responseMode: "json",
     summary: "Get Table Export",
     query: {
@@ -7735,9 +8466,13 @@ var V2_OPERATIONS = {
     responseMode: "json",
     summary: "Get Row",
     query: {
-      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." }
-    }
-  },
+      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." },
+      includeRunState: {
+        kind: "boolean",
+        describe: "Include per-workflow-group run state on the returned row. Off by default."
+      }
+    }
+  },
   getTableView: {
     method: "GET",
     path: "/api/v2/tables/[tableId]/views/[viewId]",
@@ -7749,27 +8484,63 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." }
     }
   },
+  getTool: {
+    method: "GET",
+    path: "/api/v2/tools/[toolId]",
+    pathParams: ["toolId"],
+    pathParamDocs: {
+      toolId: "Tool identifier. An unversioned name resolves to the newest version, and the response echoes the resolved id."
+    },
+    responseMode: "json",
+    summary: "Get Tool",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace whose integration allowlist, revealed preview blocks, and deployed custom blocks decide what this catalog contains."
+      }
+    }
+  },
   getWorkflow: {
     method: "GET",
-    path: "/api/v2/workflows/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "Get Workflow"
   },
+  getWorkflowChatDeployment: {
+    method: "GET",
+    path: "/api/v2/workflows/[workflowId]/deployments/chat",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
+    responseMode: "json",
+    summary: "Get Workflow Chat Deployment"
+  },
   getWorkflowDeployment: {
     method: "GET",
-    path: "/api/v2/workflows/[id]/deployment",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]/deployment",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "Get Workflow Deployment"
   },
+  getWorkflowMcpServer: {
+    method: "GET",
+    path: "/api/v2/workflow-mcp-servers/[serverId]",
+    pathParams: ["serverId"],
+    pathParamDocs: { serverId: "Unique workflow-MCP server identifier." },
+    responseMode: "json",
+    summary: "Get Workflow MCP Server"
+  },
   getWorkflowRun: {
     method: "GET",
-    path: "/api/v2/workflows/[id]/runs/[runId]",
-    pathParams: ["id", "runId"],
-    pathParamDocs: { id: "Unique workflow identifier.", runId: "Unique workflow run identifier." },
+    path: "/api/v2/workflows/[workflowId]/runs/[runId]",
+    pathParams: ["workflowId", "runId"],
+    pathParamDocs: {
+      workflowId: "Unique workflow identifier.",
+      runId: "Unique workflow run identifier."
+    },
     responseMode: "json",
     summary: "Get Workflow Run",
     query: {
@@ -7780,14 +8551,33 @@ var V2_OPERATIONS = {
       selectedOutputs: {
         kind: "string",
         describe: "Comma-separated block output references to include, as `blockId` or `blockId.path`. Block *names* are not resolved here — unlike the execute request, this resource reads a recorded run and matches ids only, so a name selects nothing and yields an empty `blockOutputs`."
+      },
+      includeFileBase64: {
+        kind: "boolean",
+        describe: "Inline each produced file's bytes as base64. Requires `includeOutput`. A file above the inline ceiling answers `413` naming its download path; fetch large files from `downloadPath` instead."
+      },
+      base64MaxBytes: {
+        kind: "integer",
+        describe: "Per-file inline ceiling, lowering but never raising the server limit of 16 MiB."
       }
     }
   },
+  getWorkflowState: {
+    method: "GET",
+    path: "/api/v2/workflows/[workflowId]/state",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
+    responseMode: "json",
+    summary: "Get Workflow State"
+  },
   getWorkflowVersion: {
     method: "GET",
-    path: "/api/v2/workflows/[id]/versions/[version]",
-    pathParams: ["id", "version"],
-    pathParamDocs: { id: "Unique workflow identifier.", version: "Numeric deployment version." },
+    path: "/api/v2/workflows/[workflowId]/versions/[version]",
+    pathParams: ["workflowId", "version"],
+    pathParamDocs: {
+      workflowId: "Unique workflow identifier.",
+      version: "Numeric deployment version."
+    },
     responseMode: "json",
     summary: "Get Workflow Version"
   },
@@ -7799,6 +8589,24 @@ var V2_OPERATIONS = {
     responseMode: "json",
     summary: "Get Workspace"
   },
+  grantSkillEditor: {
+    method: "POST",
+    path: "/api/v2/skills/[skillId]/editors",
+    pathParams: ["skillId"],
+    pathParamDocs: {
+      skillId: "Unique skill identifier. A built-in skill is `builtin-` followed by its name, for example `builtin-research`."
+    },
+    responseMode: "json",
+    summary: "Grant Skill Editor",
+    body: {
+      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the skill." },
+      email: {
+        kind: "string",
+        required: true,
+        describe: "Email address of a current workspace member."
+      }
+    }
+  },
   importWorkflow: {
     method: "POST",
     path: "/api/v2/workflows/import",
@@ -7918,6 +8726,115 @@ var V2_OPERATIONS = {
       }
     }
   },
+  listBlocks: {
+    method: "GET",
+    path: "/api/v2/blocks",
+    pathParams: [],
+    responseMode: "json",
+    summary: "List Blocks",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace whose integration allowlist, revealed preview blocks, and deployed custom blocks decide what this catalog contains."
+      },
+      search: {
+        kind: "string",
+        describe: "Case-insensitive substring match against the block id, name, and description."
+      },
+      category: {
+        kind: "enum",
+        values: ["blocks", "tools", "triggers"],
+        describe: "Restrict to one toolbar category."
+      },
+      capability: {
+        kind: "enum",
+        values: ["trigger"],
+        describe: "Restrict to blocks that can start a workflow — the `triggers` category, blocks declaring `triggerAllowed`, and blocks with trigger-mode fields."
+      },
+      source: {
+        kind: "enum",
+        values: ["builtin", "custom"],
+        describe: "Restrict to shipped blocks or to this workspace’s deployed custom blocks."
+      },
+      sortBy: {
+        kind: "enum",
+        values: ["id", "name", "category"],
+        default: "id",
+        describe: "Field used to sort the result. Sorting by `name` is case-sensitive and follows the storage collation, so do not rely on a case-insensitive order."
+      },
+      sortOrder: {
+        kind: "enum",
+        values: ["asc", "desc"],
+        default: "asc",
+        describe: "Sort direction."
+      },
+      limit: {
+        kind: "integer",
+        default: 50,
+        describe: "Maximum blocks to return per page. Must be a whole number from 1 to 100. Defaults to 50."
+      },
+      cursor: {
+        kind: "string",
+        describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
+      }
+    }
+  },
+  listChatDeployments: {
+    method: "GET",
+    path: "/api/v2/chat-deployments",
+    pathParams: [],
+    responseMode: "json",
+    summary: "List Chat Deployments",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace whose chat deployments to list."
+      },
+      workflowId: { kind: "string", describe: "Restrict to deployments of one workflow." },
+      isActive: { kind: "boolean", describe: "Restrict to active or inactive deployments." },
+      sortBy: {
+        kind: "enum",
+        values: ["identifier", "createdAt", "updatedAt"],
+        default: "createdAt",
+        describe: "Field used to sort the result."
+      },
+      sortOrder: {
+        kind: "enum",
+        values: ["asc", "desc"],
+        default: "desc",
+        describe: "Sort direction."
+      },
+      limit: {
+        kind: "integer",
+        default: 50,
+        describe: "Maximum chat deployments to return per page. Must be a whole number from 1 to 100. Defaults to 50."
+      },
+      cursor: {
+        kind: "string",
+        describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
+      }
+    }
+  },
+  listConnectorTypes: {
+    method: "GET",
+    path: "/api/v2/connector-types",
+    pathParams: [],
+    responseMode: "json",
+    summary: "List Connector Types",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace whose integration allowlist, revealed preview blocks, and deployed custom blocks decide what this catalog contains."
+      },
+      search: {
+        kind: "string",
+        describe: "Case-insensitive substring match against the connector name."
+      }
+    }
+  },
   listCredentialProviders: {
     method: "GET",
     path: "/api/v2/credentials/providers",
@@ -8054,6 +8971,12 @@ var V2_OPERATIONS = {
         values: ["asc", "desc"],
         default: "asc",
         describe: "Sort direction."
+      },
+      scope: {
+        kind: "enum",
+        values: ["active", "archived"],
+        default: "active",
+        describe: "Which lifecycle set to list: `active` (default) returns live folders only; `archived` returns folders a recursive `DELETE` soft-deleted, which is how a caller finds a path to hand to `POST /api/v2/files/folders/restore`. Authorization is identical for both."
       }
     }
   },
@@ -8071,7 +8994,25 @@ var V2_OPERATIONS = {
       },
       folderPath: {
         kind: "string",
-        describe: "Restrict results to files directly inside this folder. A path that names no folder narrows the result to nothing, so the response is an empty page rather than an error."
+        describe: "Restrict results to files inside this folder — its direct children, or its whole subtree when `recursive` is true. A path that names no folder narrows the result to nothing, so the response is an empty page rather than an error."
+      },
+      recursive: {
+        kind: "enum",
+        values: [
+          "true",
+          "1",
+          "yes",
+          "on",
+          "y",
+          "enabled",
+          "false",
+          "0",
+          "no",
+          "off",
+          "n",
+          "disabled"
+        ],
+        describe: "Whether the folder filter includes files in subfolders. Defaults to true when a search is set, false otherwise, so listing a folder shows that folder while searching one looks through everything in it. Ignored when no folder filter is set, which already spans the workspace. The listed spellings are the whole accepted vocabulary and are case-sensitive; any other value is rejected."
       },
       scope: {
         kind: "enum",
@@ -8118,6 +9059,12 @@ var V2_OPERATIONS = {
         required: true,
         describe: "Workspace whose knowledge bases should be listed."
       },
+      scope: {
+        kind: "enum",
+        values: ["active", "archived"],
+        default: "active",
+        describe: "Which lifecycle set to list: `active` (default) for live knowledge bases, `archived` for knowledge bases a `DELETE` archived and `POST /knowledge/{knowledgeBaseId}/restore` can bring back. `folderPath` resolves against active folders only, so pairing it with `scope=archived` returns an empty page when the containing folder was archived too."
+      },
       folderPath: {
         kind: "string",
         describe: "Restrict results to knowledge bases in this folder. A path that names no folder narrows the result to nothing, so the response is an empty page rather than an error."
@@ -8149,11 +9096,127 @@ var V2_OPERATIONS = {
       }
     }
   },
+  listKnowledgeChunks: {
+    method: "GET",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/[documentId]/chunks",
+    pathParams: ["knowledgeBaseId", "documentId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Unique knowledge base identifier.",
+      documentId: "Unique knowledge document identifier."
+    },
+    responseMode: "json",
+    summary: "List Chunks",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      search: {
+        kind: "string",
+        describe: "Case-insensitive substring match against chunk content."
+      },
+      enabled: {
+        kind: "enum",
+        values: ["true", "false", "all"],
+        default: "all",
+        describe: "Restrict to enabled or disabled chunks. `all` returns both."
+      },
+      sortBy: {
+        kind: "enum",
+        values: ["chunkIndex", "tokenCount", "enabled"],
+        default: "chunkIndex",
+        describe: "Field used to sort the result."
+      },
+      sortOrder: {
+        kind: "enum",
+        values: ["asc", "desc"],
+        default: "asc",
+        describe: "Sort direction."
+      },
+      limit: {
+        kind: "integer",
+        default: 50,
+        describe: "Maximum chunks to return per page. Must be a whole number from 1 to 100. Defaults to 50."
+      },
+      cursor: {
+        kind: "string",
+        describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
+      }
+    }
+  },
+  listKnowledgeConnectorDocuments: {
+    method: "GET",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/connectors/[connectorId]/documents",
+    pathParams: ["knowledgeBaseId", "connectorId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Knowledge base that owns the connector.",
+      connectorId: "Connector selected for the operation."
+    },
+    responseMode: "json",
+    summary: "List Knowledge Connector Documents",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      includeExcluded: {
+        kind: "boolean",
+        describe: "Include documents explicitly excluded by a user."
+      },
+      limit: {
+        kind: "integer",
+        default: 50,
+        describe: "Maximum connector documents to return per page. Must be a whole number from 1 to 100. Defaults to 50."
+      },
+      cursor: {
+        kind: "string",
+        describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
+      }
+    }
+  },
+  listKnowledgeConnectors: {
+    method: "GET",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/connectors",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
+    responseMode: "json",
+    summary: "List Knowledge Connectors",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      sortBy: {
+        kind: "enum",
+        values: ["connectorType", "createdAt", "updatedAt"],
+        default: "createdAt",
+        describe: "Field used to sort the result."
+      },
+      sortOrder: {
+        kind: "enum",
+        values: ["asc", "desc"],
+        default: "desc",
+        describe: "Sort direction."
+      },
+      limit: {
+        kind: "integer",
+        default: 50,
+        describe: "Maximum connectors to return per page. Must be a whole number from 1 to 100. Defaults to 50."
+      },
+      cursor: {
+        kind: "string",
+        describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
+      }
+    }
+  },
   listKnowledgeDocuments: {
     method: "GET",
-    path: "/api/v2/knowledge/[id]/documents",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique knowledge base identifier." },
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
     responseMode: "json",
     summary: "List Documents",
     query: {
@@ -8243,9 +9306,9 @@ var V2_OPERATIONS = {
   },
   listKnowledgeTags: {
     method: "GET",
-    path: "/api/v2/knowledge/[id]/tags",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique knowledge base identifier." },
+    path: "/api/v2/knowledge/[knowledgeBaseId]/tags",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
     responseMode: "json",
     summary: "List Tags",
     query: {
@@ -8256,6 +9319,21 @@ var V2_OPERATIONS = {
       }
     }
   },
+  listKnowledgeTagUsage: {
+    method: "GET",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/tags/usage",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
+    responseMode: "json",
+    summary: "List Tag Usage",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      }
+    }
+  },
   listLogs: {
     method: "GET",
     path: "/api/v2/logs",
@@ -8270,11 +9348,11 @@ var V2_OPERATIONS = {
       },
       workflowIds: {
         kind: "string",
-        describe: "Comma-separated workflow identifiers to include. An empty entry is rejected."
+        describe: "Comma-separated workflow identifiers to include. An empty entry is rejected. At most 200 entries."
       },
       triggers: {
         kind: "string",
-        describe: "Comma-separated trigger types to include. An empty entry is rejected. Values are matched exactly and are case-sensitive — every recorded trigger is lowercase, so `API` matches nothing while `api` matches. The vocabulary is open: it covers the core trigger types (`manual`, `api`, `schedule`, `chat`, `webhook`, `mcp`, `copilot`, `workflow`, `custom_block`) and the provider id of any webhook trigger (`slack`, `gmail`, `github`, …), so an unrecognized member is not rejected — it selects no runs. The literal value `all` is a sentinel that disables this filter entirely, so a list containing it returns runs of every trigger type; no real trigger type is named `all`."
+        describe: "Comma-separated trigger types to include. An empty entry is rejected. Values are matched exactly and are case-sensitive — every recorded trigger is lowercase, so `API` matches nothing while `api` matches. The vocabulary is open: it covers the core trigger types (`manual`, `api`, `schedule`, `chat`, `webhook`, `mcp`, `copilot`, `workflow`, `custom_block`) and the provider id of any webhook trigger (`slack`, `gmail`, `github`, …), so an unrecognized member is not rejected — it selects no runs. The literal value `all` is a sentinel that disables this filter entirely, so a list containing it returns runs of every trigger type; no real trigger type is named `all`. At most 100 entries."
       },
       level: {
         kind: "enum",
@@ -8310,7 +9388,7 @@ var V2_OPERATIONS = {
         kind: "enum",
         values: ["basic", "full"],
         default: "basic",
-        describe: "Response detail level. `full` adds the `workflow` summary to every item. `includeTraceSpans=true` and `includeFinalOutput=true` each imply `full`, so either one adds `workflow` even when `details=basic` is sent explicitly."
+        describe: "Response detail level. `full` adds the `workflow` summary to every workflow run; a job run never carries one, whatever this is set to. `includeTraceSpans=true` and `includeFinalOutput=true` each imply `full`, so either one adds `workflow` even when `details=basic` is sent explicitly."
       },
       includeTraceSpans: {
         kind: "boolean",
@@ -8329,16 +9407,34 @@ var V2_OPERATIONS = {
         kind: "string",
         describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
       },
-      order: {
-        kind: "enum",
-        values: ["asc", "desc"],
-        default: "desc",
-        describe: "Sort direction by execution start time. This list is sortable only by execution start time, so it takes `order` in place of `sortBy`/`sortOrder`, which it rejects."
+      status: {
+        kind: "string",
+        describe: "Comma-separated execution statuses to include, from `pending` | `running` | `paused` | `redacting` | `completed` | `failed` | `cancelled`. An empty entry is rejected. ANDed with `level`, which reports severity rather than lifecycle."
+      },
+      workflowName: {
+        kind: "string",
+        describe: "Case-insensitive substring match against the run's workflow name. Runs whose workflow has been deleted match nothing, because the name is no longer joinable."
+      },
+      includeJobRuns: {
+        kind: "boolean",
+        describe: 'Whether Chat and Sim-agent job runs join the sequence alongside workflow runs. Job runs report `kind: "job"`, carry no `workflow` summary, and never carry a cost ledger. They are dropped entirely — not partially matched — whenever a filter they cannot answer is set (`workflowIds`, `workflowName`, `folderPaths`, `model`, or `status`), so a filter never means two different things across the union. Accepted only under `sortBy=startedAt`: job runs record cost as a document and no comparable status, so they cannot participate in the other orderings.'
       },
       runId: { kind: "string", describe: "Exact run identifier to match." },
+      sortBy: {
+        kind: "enum",
+        values: ["startedAt", "durationMs", "cost", "status"],
+        default: "startedAt",
+        describe: "Field used to sort the result. `durationMs` and `cost` are null until a run settles; those runs order as though the value were below every recorded one, so they trail an ascending page and lead a descending one. Only `startedAt` can order Chat and Sim-agent job runs, so any other value is rejected together with `includeJobRuns=true`."
+      },
+      sortOrder: {
+        kind: "enum",
+        values: ["asc", "desc"],
+        default: "desc",
+        describe: "Sort direction."
+      },
       folderPaths: {
         kind: "string",
-        describe: "Comma-separated workflow folder paths to include. A path that names no folder narrows the result to nothing, so the response is an empty page rather than an error."
+        describe: "Comma-separated workflow folder paths to include. At most 100 entries. A path covers its whole subtree, so `/prod` also selects runs in `/prod/nested`. A path that names no folder narrows the result to nothing, so the response is an empty page rather than an error."
       }
     }
   },
@@ -8383,9 +9479,9 @@ var V2_OPERATIONS = {
   },
   listMcpServerTools: {
     method: "GET",
-    path: "/api/v2/mcp-servers/[id]/tools",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique MCP server identifier." },
+    path: "/api/v2/mcp-servers/[mcpServerId]/tools",
+    pathParams: ["mcpServerId"],
+    pathParamDocs: { mcpServerId: "Unique MCP server identifier." },
     responseMode: "json",
     summary: "List MCP Server Tools",
     query: {
@@ -8444,6 +9540,40 @@ var V2_OPERATIONS = {
       }
     }
   },
+  listSkillEditors: {
+    method: "GET",
+    path: "/api/v2/skills/[skillId]/editors",
+    pathParams: ["skillId"],
+    pathParamDocs: {
+      skillId: "Unique skill identifier. A built-in skill is `builtin-` followed by its name, for example `builtin-research`."
+    },
+    responseMode: "json",
+    summary: "List Skill Editors",
+    query: {
+      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the skill." },
+      sortBy: {
+        kind: "enum",
+        values: ["email", "name"],
+        default: "email",
+        describe: "Field used to sort the result. Sorting by `name` is case-sensitive and follows the storage collation, so do not rely on a case-insensitive order."
+      },
+      sortOrder: {
+        kind: "enum",
+        values: ["asc", "desc"],
+        default: "asc",
+        describe: "Sort direction."
+      },
+      limit: {
+        kind: "integer",
+        default: 50,
+        describe: "Maximum skill editors to return per page. Must be a whole number from 1 to 100. Defaults to 50."
+      },
+      cursor: {
+        kind: "string",
+        describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
+      }
+    }
+  },
   listSkills: {
     method: "GET",
     path: "/api/v2/skills",
@@ -8479,6 +9609,17 @@ var V2_OPERATIONS = {
       }
     }
   },
+  listTableDispatches: {
+    method: "GET",
+    path: "/api/v2/tables/[tableId]/dispatches",
+    pathParams: ["tableId"],
+    pathParamDocs: { tableId: "Unique table identifier." },
+    responseMode: "json",
+    summary: "List Active Run Dispatches",
+    query: {
+      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." }
+    }
+  },
   listTableFolders: {
     method: "GET",
     path: "/api/v2/tables/folders",
@@ -8530,6 +9671,10 @@ var V2_OPERATIONS = {
       cursor: {
         kind: "string",
         describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
+      },
+      includeRunState: {
+        kind: "boolean",
+        describe: "Include per-workflow-group run state on every returned row. Off by default: run state is a separate sidecar read and its `blockErrors` are unbounded, so a full page carries it only when asked. Caps `limit` at 200."
       }
     }
   },
@@ -8545,6 +9690,12 @@ var V2_OPERATIONS = {
         required: true,
         describe: "Workspace whose tables should be listed."
       },
+      scope: {
+        kind: "enum",
+        values: ["active", "archived"],
+        default: "active",
+        describe: "Which lifecycle set to list: `active` (default) for live tables, `archived` for tables a `DELETE` archived and `POST /tables/{tableId}/restore` can bring back. `folderPath` resolves against active folders only, so pairing it with `scope=archived` returns an empty page when the containing folder was archived too."
+      },
       folderPath: {
         kind: "string",
         describe: "Restrict results to tables in this folder. A path that names no folder narrows the result to nothing, so the response is an empty page rather than an error."
@@ -8587,6 +9738,54 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." }
     }
   },
+  listTools: {
+    method: "GET",
+    path: "/api/v2/tools",
+    pathParams: [],
+    responseMode: "json",
+    summary: "List Tools",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace whose integration allowlist, revealed preview blocks, and deployed custom blocks decide what this catalog contains."
+      },
+      search: {
+        kind: "string",
+        describe: "Case-insensitive substring match against the tool id, name, and description."
+      },
+      hostedApiKey: {
+        kind: "enum",
+        values: ["always", "conditional", "none"],
+        describe: "Restrict to tools by how their API key is supplied."
+      },
+      oauthProvider: {
+        kind: "string",
+        describe: "Restrict to tools that authenticate against this OAuth service."
+      },
+      sortBy: {
+        kind: "enum",
+        values: ["id", "name"],
+        default: "id",
+        describe: "Field used to sort the result. Sorting by `name` is case-sensitive and follows the storage collation, so do not rely on a case-insensitive order."
+      },
+      sortOrder: {
+        kind: "enum",
+        values: ["asc", "desc"],
+        default: "asc",
+        describe: "Sort direction."
+      },
+      limit: {
+        kind: "integer",
+        default: 50,
+        describe: "Maximum tools to return per page. Must be a whole number from 1 to 100. Defaults to 50."
+      },
+      cursor: {
+        kind: "string",
+        describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
+      }
+    }
+  },
   listWorkflowFolders: {
     method: "GET",
     path: "/api/v2/workflows/folders",
@@ -8632,11 +9831,54 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." }
     }
   },
+  listWorkflowMcpServers: {
+    method: "GET",
+    path: "/api/v2/workflow-mcp-servers",
+    pathParams: [],
+    responseMode: "json",
+    summary: "List Workflow MCP Servers",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace whose published MCP servers to list."
+      },
+      sortBy: {
+        kind: "enum",
+        values: ["name", "createdAt", "updatedAt"],
+        default: "createdAt",
+        describe: "Field used to sort the result. Sorting by `name` is case-sensitive and follows the storage collation, so do not rely on a case-insensitive order."
+      },
+      sortOrder: {
+        kind: "enum",
+        values: ["asc", "desc"],
+        default: "desc",
+        describe: "Sort direction."
+      },
+      limit: {
+        kind: "integer",
+        default: 50,
+        describe: "Maximum workflow-MCP servers to return per page. Must be a whole number from 1 to 100. Defaults to 50."
+      },
+      cursor: {
+        kind: "string",
+        describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
+      }
+    }
+  },
+  listWorkflowMcpTools: {
+    method: "GET",
+    path: "/api/v2/workflow-mcp-servers/[serverId]/tools",
+    pathParams: ["serverId"],
+    pathParamDocs: { serverId: "Unique workflow-MCP server identifier." },
+    responseMode: "json",
+    summary: "List Workflow MCP Tools"
+  },
   listWorkflowRuns: {
     method: "GET",
-    path: "/api/v2/workflows/[id]/runs",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]/runs",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "List Workflow Runs",
     query: {
@@ -8683,6 +9925,12 @@ var V2_OPERATIONS = {
         required: true,
         describe: "Workspace whose workflows should be listed."
       },
+      scope: {
+        kind: "enum",
+        values: ["active", "archived"],
+        default: "active",
+        describe: "Which lifecycle set to list: `active` (default) for live workflows, `archived` for workflows a `DELETE` archived. `folderPath` resolves against active folders only, so pairing it with `scope=archived` returns an empty page when the containing folder was archived too."
+      },
       folderPath: {
         kind: "string",
         describe: "Restrict results to workflows in this folder path. A path that names no folder narrows the result to nothing, so the response is an empty page rather than an error."
@@ -8720,9 +9968,9 @@ var V2_OPERATIONS = {
   },
   listWorkflowVersions: {
     method: "GET",
-    path: "/api/v2/workflows/[id]/versions",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]/versions",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "List Workflow Versions",
     query: {
@@ -8756,6 +10004,36 @@ var V2_OPERATIONS = {
       }
     }
   },
+  listWorkspaces: {
+    method: "GET",
+    path: "/api/v2/workspaces",
+    pathParams: [],
+    responseMode: "json",
+    summary: "List Workspaces",
+    query: {
+      sortBy: {
+        kind: "enum",
+        values: ["name", "createdAt", "updatedAt"],
+        default: "createdAt",
+        describe: "Field used to sort the result. Sorting by `name` is case-sensitive and follows the storage collation, so do not rely on a case-insensitive order."
+      },
+      sortOrder: {
+        kind: "enum",
+        values: ["asc", "desc"],
+        default: "desc",
+        describe: "Sort direction."
+      },
+      limit: {
+        kind: "integer",
+        default: 50,
+        describe: "Maximum workspaces to return per page. Must be a whole number from 1 to 100. Defaults to 50."
+      },
+      cursor: {
+        kind: "string",
+        describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
+      }
+    }
+  },
   moveFileItems: {
     method: "POST",
     path: "/api/v2/files/move",
@@ -8771,6 +10049,50 @@ var V2_OPERATIONS = {
       }
     }
   },
+  moveTables: {
+    method: "POST",
+    path: "/api/v2/tables/move",
+    pathParams: [],
+    responseMode: "json",
+    summary: "Move Tables and Folders",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns every selected item."
+      },
+      tableIds: { kind: "array", default: [], describe: "Tables to move, by identifier." },
+      folderPaths: { kind: "array", describe: "Table folders to re-parent, by canonical path." },
+      targetFolderPath: {
+        kind: "string",
+        describe: "Destination folder path. Omit to move the selection to the workspace root."
+      }
+    }
+  },
+  moveWorkflows: {
+    method: "POST",
+    path: "/api/v2/workflows/move",
+    pathParams: [],
+    responseMode: "json",
+    summary: "Move Workflows",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace holding every workflow in the batch."
+      },
+      workflowIds: {
+        kind: "array",
+        required: true,
+        describe: "Workflows to move. Duplicates are collapsed."
+      },
+      folderPath: {
+        kind: "string",
+        required: true,
+        describe: "Destination folder path; `/` moves the workflows to the workspace root."
+      }
+    }
+  },
   queryRows: {
     method: "POST",
     path: "/api/v2/tables/[tableId]/query",
@@ -8782,14 +10104,19 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." },
       predicate: {
         kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       sort: { kind: "array", describe: "Ordered table-row sort specification." },
       limit: {
         kind: "integer",
         describe: "Maximum rows to return; zero requests an unbounded result."
       },
-      cursor: { kind: "string", describe: "Opaque cursor returned by the previous query page." }
+      cursor: { kind: "string", describe: "Opaque cursor returned by the previous query page." },
+      includeRunState: {
+        kind: "boolean",
+        default: false,
+        describe: "Include per-workflow-group run state on every returned row. Off by default: run state is a separate sidecar read and its `blockErrors` are unbounded, so a full page carries it only when asked. Incompatible with `limit: 0`, and caps `limit` at 200."
+      }
     }
   },
   queryRowsCount: {
@@ -8803,7 +10130,22 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." },
       predicate: {
         kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+      }
+    }
+  },
+  readFileText: {
+    method: "GET",
+    path: "/api/v2/files/[fileId]/text",
+    pathParams: ["fileId"],
+    pathParamDocs: { fileId: "File identifier." },
+    responseMode: "json",
+    summary: "Read File Text",
+    query: {
+      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the file." },
+      maxBytes: {
+        kind: "integer",
+        describe: "Optional ceiling on the source bytes fed to the parser, lowering but never raising the server limit."
       }
     }
   },
@@ -8883,6 +10225,88 @@ var V2_OPERATIONS = {
       name: { kind: "string", required: true, describe: "New file name, including its extension." }
     }
   },
+  replaceWorkflowChatDeployment: {
+    method: "PUT",
+    path: "/api/v2/workflows/[workflowId]/deployments/chat",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
+    responseMode: "json",
+    summary: "Create or Replace Workflow Chat Deployment",
+    body: {
+      identifier: {
+        kind: "string",
+        required: true,
+        describe: "URL slug the deployed chat answers on. Must be free across live deployments."
+      },
+      title: { kind: "string", required: true, describe: "Title shown to visitors." },
+      description: {
+        kind: "string",
+        describe: "Description shown to visitors. Omitted clears it."
+      },
+      customizations: {
+        kind: "object",
+        describe: "Presentation overrides. Omitted fields take platform defaults."
+      },
+      authType: {
+        kind: "enum",
+        values: ["public", "password", "email", "sso"],
+        default: "public",
+        describe: "How visitors are gated. `public` leaves the chat open to anyone holding the URL."
+      },
+      password: {
+        kind: "string",
+        describe: "Write-only password. Required whenever `authType` is `password`, and rejected otherwise. Never readable back."
+      },
+      allowedEmails: {
+        kind: "array",
+        describe: "Email addresses or domains admitted under `email` and `sso` gating. At least one is required for those modes."
+      },
+      outputConfigs: {
+        kind: "array",
+        describe: "Block outputs to surface to visitors. Omitted surfaces none."
+      },
+      includeThinking: {
+        kind: "boolean",
+        default: false,
+        describe: "Allow visitors to receive provider thinking events."
+      },
+      includeToolCalls: {
+        kind: "boolean",
+        default: false,
+        describe: "Allow visitors to receive tool lifecycle events."
+      }
+    }
+  },
+  replaceWorkflowState: {
+    method: "PUT",
+    path: "/api/v2/workflows/[workflowId]/state",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
+    responseMode: "json",
+    summary: "Replace Workflow State",
+    query: {
+      dryRun: {
+        kind: "boolean",
+        describe: "Validate and lint without persisting. The response is identical to the committed write of the same body, so a caller can inspect `lint` and then re-send the request for real. Nothing is written, no audit entry is recorded, and collaborators are not notified."
+      }
+    },
+    body: {
+      blocks: { kind: "object", required: true, describe: "Blocks keyed by block id." },
+      edges: { kind: "array", required: true, describe: "Directed connections between blocks." },
+      loops: {
+        kind: "object",
+        describe: "Ignored on write: loop containers are recomputed from `blocks`."
+      },
+      parallels: {
+        kind: "object",
+        describe: "Ignored on write: parallel containers are recomputed from `blocks`."
+      },
+      variables: {
+        kind: "object",
+        describe: "Replacement variable set. Omit to leave the stored variables untouched."
+      }
+    }
+  },
   restoreFile: {
     method: "POST",
     path: "/api/v2/files/[fileId]/restore",
@@ -8898,11 +10322,86 @@ var V2_OPERATIONS = {
       }
     }
   },
+  restoreFileFolder: {
+    method: "POST",
+    path: "/api/v2/files/folders/restore",
+    pathParams: [],
+    responseMode: "json",
+    summary: "Restore Folder",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the archived folder."
+      },
+      path: {
+        kind: "string",
+        required: true,
+        describe: "Path of the archived folder to restore, as reported by `GET /api/v2/files/folders?scope=archived`."
+      }
+    }
+  },
+  restoreKnowledgeBase: {
+    method: "POST",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/restore",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
+    responseMode: "json",
+    summary: "Restore Knowledge Base",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      }
+    }
+  },
+  restoreTable: {
+    method: "POST",
+    path: "/api/v2/tables/[tableId]/restore",
+    pathParams: ["tableId"],
+    pathParamDocs: { tableId: "Unique table identifier." },
+    responseMode: "json",
+    summary: "Restore Table",
+    body: {
+      workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." }
+    }
+  },
+  restoreTableFolder: {
+    method: "POST",
+    path: "/api/v2/tables/folders/restore",
+    pathParams: [],
+    responseMode: "json",
+    summary: "Restore Folder",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the archived folder."
+      },
+      path: {
+        kind: "string",
+        required: true,
+        describe: "Path the folder held when `DELETE /api/v2/tables/folders` archived it."
+      }
+    }
+  },
+  restoreWorkflow: {
+    method: "POST",
+    path: "/api/v2/workflows/[workflowId]/restore",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
+    responseMode: "json",
+    summary: "Restore Workflow"
+  },
   resumeWorkflow: {
     method: "POST",
-    path: "/api/v2/workflows/[id]/runs/[runId]/resume",
-    pathParams: ["id", "runId"],
-    pathParamDocs: { id: "Unique workflow identifier.", runId: "Unique workflow run identifier." },
+    path: "/api/v2/workflows/[workflowId]/runs/[runId]/resume",
+    pathParams: ["workflowId", "runId"],
+    pathParamDocs: {
+      workflowId: "Unique workflow identifier.",
+      runId: "Unique workflow run identifier."
+    },
     responseMode: "json",
     summary: "Resume Workflow Run",
     body: {
@@ -8914,11 +10413,40 @@ var V2_OPERATIONS = {
       input: { kind: "unknown", describe: "Input supplied to the paused workflow block." }
     }
   },
+  revertWorkflowVersion: {
+    method: "POST",
+    path: "/api/v2/workflows/[workflowId]/versions/[version]/revert",
+    pathParams: ["workflowId", "version"],
+    pathParamDocs: {
+      workflowId: "Unique workflow identifier.",
+      version: "Numeric deployment version, or `active` for the currently live version."
+    },
+    responseMode: "json",
+    summary: "Revert Workflow To Version"
+  },
+  revokeSkillEditor: {
+    method: "DELETE",
+    path: "/api/v2/skills/[skillId]/editors",
+    pathParams: ["skillId"],
+    pathParamDocs: {
+      skillId: "Unique skill identifier. A built-in skill is `builtin-` followed by its name, for example `builtin-research`."
+    },
+    responseMode: "json",
+    summary: "Revoke Skill Editor",
+    query: {
+      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the skill." },
+      email: {
+        kind: "string",
+        required: true,
+        describe: "Email address of a current workspace member."
+      }
+    }
+  },
   rollbackWorkflow: {
     method: "POST",
-    path: "/api/v2/workflows/[id]/rollback",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]/rollback",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "Rollback Workflow",
     body: {
@@ -8943,35 +10471,6 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." }
     }
   },
-  runTableColumn: {
-    method: "POST",
-    path: "/api/v2/tables/[tableId]/columns/run",
-    pathParams: ["tableId"],
-    pathParamDocs: { tableId: "Unique table identifier." },
-    responseMode: "json",
-    summary: "Run Column Groups",
-    body: {
-      workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." },
-      groupIds: {
-        kind: "array",
-        required: true,
-        describe: "Workflow or enrichment groups to run."
-      },
-      runMode: {
-        kind: "enum",
-        values: ["all", "incomplete"],
-        default: "all",
-        describe: "Whether to run all or only incomplete cells."
-      },
-      rowIds: { kind: "array", describe: "Explicit row subset to run." },
-      filter: {
-        kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
-      },
-      excludeRowIds: { kind: "array", describe: "Rows excluded from a select-all run scope." },
-      limit: { kind: "object", describe: "Optional cap on eligible rows to run." }
-    }
-  },
   searchKnowledge: {
     method: "POST",
     path: "/api/v2/knowledge/search",
@@ -9000,7 +10499,7 @@ var V2_OPERATIONS = {
       },
       tagFilters: {
         kind: "array",
-        describe: "Structured tag filters, at most 10 of them. Every filter must hold, including two that name the same tag: repeating one tag narrows the result rather than widening it, matching `GET /api/v2/knowledge/{id}/documents`. To match either of two values for one tag, issue a search per value. Each filtered tag must resolve to the same slot and field type in every knowledge base selected; one missing from any of them, or defined inconsistently across them, is rejected rather than ignored, and those knowledge bases must be searched separately. List the available names with `GET /api/v2/knowledge/{id}/tags`."
+        describe: "Structured tag filters, at most 10 of them. Every filter must hold, including two that name the same tag: repeating one tag narrows the result rather than widening it, matching `GET /api/v2/knowledge/{knowledgeBaseId}/documents`. To match either of two values for one tag, issue a search per value. Each filtered tag must resolve to the same slot and field type in every knowledge base selected; one missing from any of them, or defined inconsistently across them, is rejected rather than ignored, and those knowledge bases must be searched separately. List the available names with `GET /api/v2/knowledge/{knowledgeBaseId}/tags`."
       },
       searchMode: {
         kind: "enum",
@@ -9023,6 +10522,23 @@ var V2_OPERATIONS = {
       }
     }
   },
+  searchTableRows: {
+    method: "POST",
+    path: "/api/v2/tables/[tableId]/rows/search",
+    pathParams: ["tableId"],
+    pathParamDocs: { tableId: "Unique table identifier." },
+    responseMode: "json",
+    summary: "Search Rows",
+    body: {
+      workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." },
+      q: { kind: "string", required: true, describe: "Case-insensitive cell substring to find." },
+      predicate: {
+        kind: "unknown",
+        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+      },
+      sort: { kind: "array", describe: "Ordered table-row sort specification." }
+    }
+  },
   setSecret: {
     method: "PUT",
     path: "/api/v2/secrets/[name]",
@@ -9050,14 +10566,44 @@ var V2_OPERATIONS = {
       description: {
         kind: "string",
         describe: "What the secret is for, shown to teammates. Workspace scope only — sending it for a personal secret is rejected. Omit it to leave an existing description untouched; send null or an empty string to clear one."
+      },
+      unredacted: {
+        kind: "boolean",
+        describe: "Opt the workspace secret out of redaction: its value then appears in plaintext in run logs, model-visible content, and files, including publicly shared log links. Workspace scope only — sending it for a personal secret is rejected. Omit it to leave the current setting untouched."
+      }
+    }
+  },
+  syncKnowledgeConnector: {
+    method: "POST",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/connectors/[connectorId]/sync",
+    pathParams: ["knowledgeBaseId", "connectorId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Knowledge base that owns the connector.",
+      connectorId: "Connector selected for the operation."
+    },
+    responseMode: "json",
+    summary: "Sync Knowledge Connector",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      rehydrate: {
+        kind: "boolean",
+        default: false,
+        describe: "Re-fetch and re-index every existing connector document."
       }
     }
   },
   tableExportDownload: {
     method: "GET",
-    path: "/api/v2/tables/exports/[exportId]/download",
-    pathParams: ["exportId"],
-    pathParamDocs: { exportId: "Unique table-export identifier." },
+    path: "/api/v2/tables/[tableId]/exports/[exportId]/download",
+    pathParams: ["tableId", "exportId"],
+    pathParamDocs: {
+      tableId: "Unique table identifier.",
+      exportId: "Unique table-export identifier."
+    },
     responseMode: "json",
     summary: "Download Table Export",
     query: {
@@ -9070,17 +10616,77 @@ var V2_OPERATIONS = {
   },
   undeployWorkflow: {
     method: "DELETE",
-    path: "/api/v2/workflows/[id]/deploy",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]/deploy",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "Undeploy Workflow"
   },
+  undeployWorkflowMcpTool: {
+    method: "DELETE",
+    path: "/api/v2/workflow-mcp-servers/[serverId]/tools/[workflowId]",
+    pathParams: ["serverId", "workflowId"],
+    pathParamDocs: {
+      serverId: "Unique workflow-MCP server identifier.",
+      workflowId: "Workflow published as a tool on this server."
+    },
+    responseMode: "json",
+    summary: "Unpublish Workflow MCP Tool"
+  },
+  unzipFile: {
+    method: "POST",
+    path: "/api/v2/files/[fileId]/unzip",
+    pathParams: ["fileId"],
+    pathParamDocs: { fileId: "File identifier." },
+    responseMode: "json",
+    summary: "Unzip File",
+    body: {
+      workspaceId: { kind: "string", required: true, describe: "Workspace that owns the archive." }
+    }
+  },
+  updateCredential: {
+    method: "PATCH",
+    path: "/api/v2/credentials/[credentialId]",
+    pathParams: ["credentialId"],
+    pathParamDocs: { credentialId: "Credential to update or disconnect." },
+    responseMode: "json",
+    summary: "Update Credential",
+    query: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace expected to own the credential."
+      }
+    },
+    body: {
+      displayName: { kind: "string", describe: "New name shown for the credential in Sim." },
+      description: {
+        kind: "string",
+        describe: "New credential description. Send null to clear the stored one."
+      },
+      serviceAccountJson: {
+        kind: "string",
+        describe: "Write-only Google service-account JSON key."
+      },
+      apiToken: { kind: "string", describe: "Write-only provider API token." },
+      domain: { kind: "string", describe: "Provider account domain." },
+      signingSecret: { kind: "string", describe: "Write-only webhook signing secret." },
+      botToken: { kind: "string", describe: "Write-only bot token." },
+      clientId: { kind: "string", describe: "OAuth client identifier." },
+      clientSecret: { kind: "string", describe: "Write-only OAuth client secret." },
+      certificateId: { kind: "string", describe: "Provider certificate mapping identifier." },
+      orgId: { kind: "string", describe: "Provider organization ID." },
+      dataCenter: { kind: "string", describe: "Provider data center." },
+      authMethod: { kind: "string", describe: "Provider authentication method." },
+      privateKey: { kind: "string", describe: "Write-only PEM private key." },
+      username: { kind: "string", describe: "Provider run-as username." }
+    }
+  },
   updateCustomTool: {
     method: "PATCH",
-    path: "/api/v2/custom-tools/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique custom tool identifier." },
+    path: "/api/v2/custom-tools/[customToolId]",
+    pathParams: ["customToolId"],
+    pathParamDocs: { customToolId: "Unique custom tool identifier." },
     responseMode: "json",
     summary: "Update Custom Tool",
     body: {
@@ -9116,31 +10722,118 @@ var V2_OPERATIONS = {
       }
     }
   },
-  updateKnowledgeBase: {
+  updateKnowledgeBase: {
+    method: "PATCH",
+    path: "/api/v2/knowledge/[knowledgeBaseId]",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
+    responseMode: "json",
+    summary: "Update Knowledge Base",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      name: { kind: "string", describe: "New knowledge base name." },
+      description: { kind: "string", describe: "New knowledge base description." },
+      chunkingConfig: { kind: "object", describe: "New document chunking configuration." },
+      folderPath: { kind: "string", describe: "New containing-folder path." }
+    }
+  },
+  updateKnowledgeChunk: {
+    method: "PATCH",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/[documentId]/chunks/[chunkId]",
+    pathParams: ["knowledgeBaseId", "documentId", "chunkId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Unique knowledge base identifier.",
+      documentId: "Unique knowledge document identifier.",
+      chunkId: "Unique chunk identifier."
+    },
+    responseMode: "json",
+    summary: "Update Chunk",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      content: {
+        kind: "string",
+        describe: "Replacement text. Changing it re-embeds the chunk and re-derives its token and character counts."
+      },
+      enabled: {
+        kind: "boolean",
+        describe: "Whether the chunk participates in search. Disabling keeps it indexed."
+      }
+    }
+  },
+  updateKnowledgeConnector: {
+    method: "PATCH",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/connectors/[connectorId]",
+    pathParams: ["knowledgeBaseId", "connectorId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Knowledge base that owns the connector.",
+      connectorId: "Connector selected for the operation."
+    },
+    responseMode: "json",
+    summary: "Update Knowledge Connector",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      sourceConfig: {
+        kind: "object",
+        describe: "Replacement source selection and filtering configuration. Updating a runnable connector queues synchronization; paused connectors remain paused."
+      },
+      syncIntervalMinutes: {
+        kind: "integer",
+        describe: "New scheduled synchronization interval in minutes."
+      },
+      status: {
+        kind: "enum",
+        values: ["active", "paused"],
+        describe: "New connector state."
+      }
+    }
+  },
+  updateKnowledgeConnectorDocuments: {
     method: "PATCH",
-    path: "/api/v2/knowledge/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique knowledge base identifier." },
+    path: "/api/v2/knowledge/[knowledgeBaseId]/connectors/[connectorId]/documents",
+    pathParams: ["knowledgeBaseId", "connectorId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Knowledge base that owns the connector.",
+      connectorId: "Connector selected for the operation."
+    },
     responseMode: "json",
-    summary: "Update Knowledge Base",
+    summary: "Update Knowledge Connector Documents",
     body: {
       workspaceId: {
         kind: "string",
         required: true,
         describe: "Workspace that owns the knowledge base."
       },
-      name: { kind: "string", describe: "New knowledge base name." },
-      description: { kind: "string", describe: "New knowledge base description." },
-      chunkingConfig: { kind: "object", describe: "New document chunking configuration." },
-      folderPath: { kind: "string", describe: "New containing-folder path." }
+      operation: {
+        kind: "enum",
+        required: true,
+        values: ["restore", "exclude"],
+        describe: "Whether to restore or exclude the selected documents."
+      },
+      documentIds: {
+        kind: "array",
+        required: true,
+        describe: "Connector document identifiers to update."
+      }
     }
   },
   updateKnowledgeDocument: {
     method: "PATCH",
-    path: "/api/v2/knowledge/[id]/documents/[documentId]",
-    pathParams: ["id", "documentId"],
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents/[documentId]",
+    pathParams: ["knowledgeBaseId", "documentId"],
     pathParamDocs: {
-      id: "Unique knowledge base identifier.",
+      knowledgeBaseId: "Unique knowledge base identifier.",
       documentId: "Unique knowledge document identifier."
     },
     responseMode: "json",
@@ -9179,11 +10872,35 @@ var V2_OPERATIONS = {
       }
     }
   },
+  updateKnowledgeTag: {
+    method: "PATCH",
+    path: "/api/v2/knowledge/[knowledgeBaseId]/tags/[tagId]",
+    pathParams: ["knowledgeBaseId", "tagId"],
+    pathParamDocs: {
+      knowledgeBaseId: "Unique knowledge base identifier.",
+      tagId: "Unique tag definition identifier."
+    },
+    responseMode: "json",
+    summary: "Update Tag",
+    body: {
+      workspaceId: {
+        kind: "string",
+        required: true,
+        describe: "Workspace that owns the knowledge base."
+      },
+      displayName: { kind: "string", describe: "New tag display name." },
+      fieldType: {
+        kind: "enum",
+        values: ["text", "number", "date", "boolean"],
+        describe: "New value type for the tag."
+      }
+    }
+  },
   updateMcpServer: {
     method: "PATCH",
-    path: "/api/v2/mcp-servers/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique MCP server identifier." },
+    path: "/api/v2/mcp-servers/[mcpServerId]",
+    pathParams: ["mcpServerId"],
+    pathParamDocs: { mcpServerId: "Unique MCP server identifier." },
     responseMode: "json",
     summary: "Update MCP Server",
     body: {
@@ -9262,10 +10979,10 @@ var V2_OPERATIONS = {
   },
   updateSkill: {
     method: "PATCH",
-    path: "/api/v2/skills/[id]",
-    pathParams: ["id"],
+    path: "/api/v2/skills/[skillId]",
+    pathParams: ["skillId"],
     pathParamDocs: {
-      id: "Unique skill identifier. A built-in skill is `builtin-` followed by its name, for example `builtin-research`."
+      skillId: "Unique skill identifier. A built-in skill is `builtin-` followed by its name, for example `builtin-research`."
     },
     responseMode: "json",
     summary: "Update Skill",
@@ -9352,9 +11069,9 @@ var V2_OPERATIONS = {
   },
   updateWorkflow: {
     method: "PATCH",
-    path: "/api/v2/workflows/[id]",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique workflow identifier." },
+    path: "/api/v2/workflows/[workflowId]",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
     summary: "Update Workflow",
     body: {
@@ -9399,11 +11116,60 @@ var V2_OPERATIONS = {
       autoRun: { kind: "boolean", describe: "Replacement automatic-run setting." }
     }
   },
+  updateWorkflowMcpServer: {
+    method: "PATCH",
+    path: "/api/v2/workflow-mcp-servers/[serverId]",
+    pathParams: ["serverId"],
+    pathParamDocs: { serverId: "Unique workflow-MCP server identifier." },
+    responseMode: "json",
+    summary: "Update Workflow MCP Server",
+    body: {
+      name: { kind: "string", describe: "Server display name, shown to connecting MCP clients." },
+      description: { kind: "string", describe: "New server description, or null to clear it." },
+      isPublic: {
+        kind: "boolean",
+        describe: "Whether the server answers MCP clients without a Sim API key."
+      }
+    }
+  },
+  updateWorkflowPublicApi: {
+    method: "PATCH",
+    path: "/api/v2/workflows/[workflowId]/deployment",
+    pathParams: ["workflowId"],
+    pathParamDocs: { workflowId: "Unique workflow identifier." },
+    responseMode: "json",
+    summary: "Update Workflow Public API Access",
+    body: {
+      isPublicApi: {
+        kind: "boolean",
+        required: true,
+        describe: "Whether the deployed workflow should accept unauthenticated public API execution."
+      }
+    }
+  },
+  updateWorkflowVersion: {
+    method: "PATCH",
+    path: "/api/v2/workflows/[workflowId]/versions/[version]",
+    pathParams: ["workflowId", "version"],
+    pathParamDocs: {
+      workflowId: "Unique workflow identifier.",
+      version: "Numeric deployment version."
+    },
+    responseMode: "json",
+    summary: "Update Workflow Version",
+    body: {
+      name: { kind: "string", describe: "New label for the deployment version." },
+      description: {
+        kind: "string",
+        describe: "New release note for the deployment version, or null to clear it."
+      }
+    }
+  },
   uploadKnowledgeDocument: {
     method: "POST",
-    path: "/api/v2/knowledge/[id]/documents",
-    pathParams: ["id"],
-    pathParamDocs: { id: "Unique knowledge base identifier." },
+    path: "/api/v2/knowledge/[knowledgeBaseId]/documents",
+    pathParams: ["knowledgeBaseId"],
+    pathParamDocs: { knowledgeBaseId: "Unique knowledge base identifier." },
     responseMode: "json",
     summary: "Upload Document",
     query: {
@@ -9463,6 +11229,8 @@ var V2_OPERATIONS = {
 };
 
 // src/commands/auth.ts
+var PROFILE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var MAX_INTERACTIVE_WORKSPACES = 1000;
 function openBrowser(url) {
   const [command, args] = process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : [process.platform === "darwin" ? "open" : "xdg-open", [url]];
   try {
@@ -9498,9 +11266,91 @@ async function confirmProfileOverwrite(profileName) {
     prompt.close();
   }
 }
+function selectedProfileName(command) {
+  return globalsOf(command).profile || process.env.SIM_PROFILE || DEFAULT_PROFILE;
+}
+function validateNewProfileName(profileName) {
+  if (!PROFILE_NAME_PATTERN.test(profileName)) {
+    throw new SimApiError(`Invalid profile name "${profileName}". Use letters, numbers, dots, underscores, or hyphens, starting with a letter or number.`, 0);
+  }
+  if (listProfiles().includes(profileName)) {
+    throw new SimApiError(`Profile "${profileName}" already exists. Remove it first with: sim logout --all --profile ${profileName}`, 0);
+  }
+}
+function requireStoredAuthentication(profile) {
+  const authProfile = resolveAuthenticationProfileName(profile.name);
+  const storedKey = readCredentialsProfile(authProfile).api_key;
+  if (profile.sources.apiKey !== "credentials" || !storedKey) {
+    throw new SimApiError(`Cannot create a shared profile from "${profile.name}": the active API key is not stored. Run: sim login --profile ${authProfile}`, 0);
+  }
+  if (profile.sources.endpoint === "flag" || profile.sources.endpoint === "env") {
+    throw new SimApiError(`Cannot create a shared profile from "${profile.name}": the active endpoint comes from ${profile.sources.endpoint}. Save it with: sim configure --profile ${authProfile} --set-endpoint ${profile.endpoint}`, 0);
+  }
+  return authProfile;
+}
+async function getWorkspaceById(client, workspaceId) {
+  const operation = V2_OPERATIONS.getWorkspace;
+  const response = await client.request(resolvePath(operation.path, { workspaceId }), { method: operation.method });
+  return response.data;
+}
+async function chooseWorkspace(client) {
+  if (!process.stdin.isTTY) {
+    throw new SimApiError("No workspace provided. Pass --workspace <id> when creating a profile non-interactively.", 0);
+  }
+  const operation = V2_OPERATIONS.listWorkspaces;
+  const workspaces = await requestAllPages(client, operation.path, {
+    method: operation.method,
+    query: { sortBy: "name", sortOrder: "asc" },
+    pageSize: 100,
+    limit: MAX_INTERACTIVE_WORKSPACES + 1
+  });
+  if (workspaces.length === 0) {
+    throw new SimApiError("The active API key cannot access any workspaces.", 0);
+  }
+  if (workspaces.length > MAX_INTERACTIVE_WORKSPACES) {
+    throw new SimApiError(`The active API key can access more than ${MAX_INTERACTIVE_WORKSPACES} workspaces, which is too many to show interactively. Pass --workspace <id> instead.`, 0);
+  }
+  console.log(`
+Available workspaces:`);
+  for (const [index, workspace] of workspaces.entries()) {
+    console.log(`  ${index + 1}) ${safeOneLine(workspace.name)} (${workspace.id})`);
+  }
+  const prompt = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await prompt.question(`Choose a workspace [1-${workspaces.length}]: `);
+    const selected = Number(answer.trim());
+    if (!Number.isInteger(selected) || selected < 1 || selected > workspaces.length) {
+      throw new SimApiError(`Invalid workspace selection "${safeOneLine(answer)}". Choose a number from 1 to ${workspaces.length}.`, 0);
+    }
+    return workspaces[selected - 1];
+  } finally {
+    prompt.close();
+  }
+}
+function addProfileCommand() {
+  return new Command("add").description("Add a workspace profile that shares the active stored login").argument("<name>", "Name for the new profile").option("-w, --workspace <id>", "Existing workspace to use; omit for an interactive picker").action(async (profileName, _options, command) => {
+    validateNewProfileName(profileName);
+    const { client, profile } = clientFrom(command);
+    const authProfile = requireStoredAuthentication(profile);
+    const workspaceId = globalsOf(command).workspace;
+    const workspace = workspaceId ? await getWorkspaceById(client, workspaceId) : await chooseWorkspace(client);
+    writeConfigProfile(profileName, {
+      auth_profile: authProfile,
+      workspace: workspace.id
+    });
+    console.log(source_default.green(`✓ Added profile "${profileName}" in ${configPath()}`));
+    console.log(`  Workspace: ${safeOneLine(workspace.name)} (${workspace.id})`);
+    console.log(`  Authentication: ${authProfile}`);
+    console.log(source_default.dim(`  Try: sim --profile ${profileName} whoami`));
+  });
+}
 function loginCommand() {
   return new Command("login").description("Authorize this terminal and store an API key for the profile").option("--scope <scope>", "Key space to mint from: platform or copilot", "platform").option("--no-browser", "Print the URL instead of opening a browser").option("-y, --yes", "Overwrite an existing profile without prompting").action(async (options, command) => {
     const profile = profileFrom(command);
+    const authProfile = resolveAuthenticationProfileName(profile.name);
+    if (authProfile !== profile.name) {
+      throw new SimApiError(`Profile "${profile.name}" shares authentication with "${authProfile}". Run: sim login --profile ${authProfile}`, 0);
+    }
     if (options.scope !== "platform" && options.scope !== "copilot") {
       throw new SimApiError(`Unknown scope "${options.scope}". Use platform or copilot.`, 0);
     }
@@ -9547,16 +11397,25 @@ Waiting for approval…`));
 }
 function logoutCommand() {
   return new Command("logout").description("Remove the profile's stored API key").option("--all", "Remove the profile entirely, including its settings").action((options, command) => {
-    const profile = profileFrom(command);
     if (options.all) {
-      const removed = deleteProfile(profile.name);
+      const profileName = selectedProfileName(command);
+      const dependents = listAuthenticationDependents(profileName);
+      if (dependents.length > 0) {
+        throw new SimApiError(`Cannot remove authentication profile "${profileName}" because it is used by: ${dependents.join(", ")}. Remove those profiles first.`, 0);
+      }
+      const removed = deleteProfile(profileName);
       if (!removed.config && !removed.credentials) {
-        console.log(source_default.dim(`Nothing stored for profile "${profile.name}".`));
+        console.log(source_default.dim(`Nothing stored for profile "${profileName}".`));
         return;
       }
-      console.log(source_default.green(`✓ Removed profile "${profile.name}".`));
+      console.log(source_default.green(`✓ Removed profile "${profileName}".`));
       return;
     }
+    const profile = profileFrom(command);
+    const authProfile = resolveAuthenticationProfileName(profile.name);
+    if (authProfile !== profile.name) {
+      throw new SimApiError(`Profile "${profile.name}" shares authentication with "${authProfile}". Log out of the authentication profile instead: sim logout --profile ${authProfile}`, 0);
+    }
     if (!readCredentialsProfile(profile.name).api_key) {
       console.log(source_default.dim(`No stored key for profile "${profile.name}".`));
       return;
@@ -9664,27 +11523,38 @@ function whoamiCommand() {
   });
 }
 function profilesCommand() {
-  return new Command("profiles").alias("profile").description("List the profiles defined in the config and credentials files").action((_options, command) => {
+  const command = new Command("profiles").alias("profile").description("List profiles or add a workspace profile that shares a stored login");
+  const printProfiles = (_options, actionCommand) => {
     const profiles = listProfiles();
     if (profiles.length === 0) {
       console.log(source_default.dim("No profiles yet. Run: sim login"));
       return;
     }
-    const active = profileFrom(command).name;
+    const active = selectedProfileName(actionCommand);
     for (const name of profiles) {
       const marker = name === active ? source_default.green("*") : " ";
-      const hasKey = Boolean(readCredentialsProfile(name).api_key);
-      console.log(`${marker} ${name}${hasKey ? "" : source_default.dim("  (no key)")}`);
+      const authProfile = resolveAuthenticationProfileName(name);
+      const hasKey = Boolean(readCredentialsProfile(authProfile).api_key);
+      const authentication = authProfile === name ? "" : source_default.dim(`  (auth: ${authProfile})`);
+      console.log(`${marker} ${name}${hasKey ? "" : source_default.dim("  (no key)")}${authentication}`);
     }
-  });
+  };
+  command.action(printProfiles);
+  command.addCommand(new Command("list").description("List configured profiles").action(printProfiles));
+  command.addCommand(addProfileCommand());
+  return command;
 }
 
 // src/commands/configure.ts
 function configureCommand() {
   return new Command("configure").description("Set a profile's endpoint, default workspace, or output format").option("--set-endpoint <url>", "Sim deployment to talk to").option("--set-workspace <id>", "Default workspace for workspace-scoped commands").option("--set-output <format>", `Default output format (${OUTPUT_FORMATS.join(" | ")})`).option("--unset <key...>", "Remove settings (endpoint, workspace, output)").action((options, command) => {
     const profile = profileFrom(command);
+    const authProfile = resolveAuthenticationProfileName(profile.name);
     const updates = {};
     if (options.setEndpoint) {
+      if (authProfile !== profile.name) {
+        throw new SimApiError(`Profile "${profile.name}" shares its endpoint with authentication profile "${authProfile}". Run: sim configure --profile ${authProfile} --set-endpoint ${options.setEndpoint}`, 0);
+      }
       updates.endpoint = normalizeEndpoint(options.setEndpoint, "--set-endpoint");
     }
     if (options.setWorkspace)
@@ -9699,6 +11569,9 @@ function configureCommand() {
       if (!["endpoint", "workspace", "output"].includes(key)) {
         throw new SimApiError(`Cannot unset "${key}". Use endpoint, workspace, or output.`, 0);
       }
+      if (key === "endpoint" && authProfile !== profile.name) {
+        throw new SimApiError(`Profile "${profile.name}" shares its endpoint with authentication profile "${authProfile}". Run: sim configure --profile ${authProfile} --unset endpoint`, 0);
+      }
       updates[key] = null;
     }
     if (Object.keys(updates).length === 0) {
@@ -9723,7 +11596,9 @@ import { existsSync as existsSync2, readFileSync as readFileSync3, readSync } fr
 // src/contract/commands.ts
 var TABLE_NAME_HELP = "Identifier: letters, numbers, and underscores; cannot start with a number";
 var TABLE_FILTER_HELP = 'Predicate: {"all":[{"field":"status","op":"eq","value":"active"}]}; groups use all/any. Operators: eq, ne, gt, gte, lt, lte, in, nin, contains, ncontains, startsWith, endsWith, like, ilike, nlike, nilike, isEmpty, isNotEmpty, isNull, isNotNull';
+var TABLE_READ_FILTER_HELP = 'Condition: {"field":"status","op":"eq","value":"active"}. Groups: {"all":[{"field":"status","op":"eq","value":"active"}]} or {"any":[{"field":"status","op":"eq","value":"active"}]}; group entries may also be nested groups. Operators: eq, ne, gt, gte, lt, lte, in, nin, contains, ncontains, startsWith, endsWith, like, ilike, nlike, nilike, isEmpty, isNotEmpty, isNull, isNotNull';
 var TABLE_SORT_HELP = 'Ordered sort keys: [{"field":"createdAt","direction":"desc"}] (direction: asc or desc)';
+var KNOWLEDGE_TAG_DEFINITIONS_HELP = 'Tag definitions: [{"tagSlot":"tag1","displayName":"category","fieldType":"text"}]';
 var CUSTOM_TOOL_SCHEMA_HELP = 'OpenAI function schema: {"type":"function","function":{"name":"...","parameters":{"type":"object","properties":{}}}}';
 var FOLDER_PATH_INPUT = {
   describe: "Folder path as shown in the app; the leading / is optional",
@@ -9737,14 +11612,25 @@ var FOLDER_DELETE_FLAGS = {
   path: FOLDER_PATH_INPUT,
   recursive: { boolean: true, describe: "Delete the folder and its descendants" }
 };
-var KNOWLEDGE_BASE_PATH_ARGUMENT = { id: "knowledgeBaseId" };
+var KNOWLEDGE_BASE_PATH_ARGUMENT = { knowledgeBaseId: "knowledgeBaseId" };
 var WORKFLOW_RUN_SCOPE = {
-  id: {
+  workflowId: {
     name: "workflow",
     placeholder: "workflowId",
     describe: "Workflow ID"
   }
 };
+var FOLDER_PATHS_FLAG = { ...FOLDER_PATH_FLAG, list: true };
+var TARGET_FOLDER_PATH_FLAG = {
+  ...FOLDER_PATH_INPUT,
+  name: "to",
+  describe: "Destination folder path; omit for root"
+};
+var LOG_LIST_FILTER_FLAGS = {
+  workflowIds: { name: "workflow", list: true },
+  folderPaths: FOLDER_PATHS_FLAG,
+  triggers: { name: "trigger", list: true }
+};
 var FOLDER_COLUMN = { header: "folder", path: "folderPath", format: "folder-path" };
 var FOLDER_LIST_COLUMNS = [
   { header: "path", format: "folder-path" },
@@ -9761,6 +11647,7 @@ function moveResource(command, resource) {
   };
 }
 var CLI_CONTRACT = {
+  chat: { hidden: true },
   createCredentialConnection: { hidden: true },
   createServiceAccountCredential: { hidden: true },
   getBillingStatus: {
@@ -9825,6 +11712,43 @@ var CLI_CONTRACT = {
       selectAll: { boolean: true, describe: "Apply to every document in the knowledge base" }
     }
   },
+  bulkUpdateKnowledgeChunks: {
+    command: "knowledge chunks batch-update",
+    describe: "Enable, disable, or delete many chunks at once",
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
+    flags: {
+      chunkIds: { name: "chunk", list: true }
+    },
+    confirm: "This can delete every named chunk and its embedding, and cannot be undone."
+  },
+  createKnowledgeConnector: {
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT
+  },
+  listKnowledgeConnectors: {
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT
+  },
+  getKnowledgeConnector: {
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT
+  },
+  listKnowledgeConnectorDocuments: {
+    command: "knowledge connectors documents list",
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT
+  },
+  updateKnowledgeConnector: {
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT
+  },
+  updateKnowledgeConnectorDocuments: {
+    command: "knowledge connectors documents update",
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
+    flags: {
+      documentIds: { name: "document", list: true }
+    }
+  },
+  syncKnowledgeConnector: {
+    command: "knowledge connectors sync",
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
+    describe: "Queue a knowledge connector synchronization"
+  },
   undeployWorkflow: {
     command: "workflows undeploy",
     describe: "Take a workflow out of deployment"
@@ -9846,11 +11770,18 @@ var CLI_CONTRACT = {
     pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
     confirm: "This deletes the document and its embeddings."
   },
+  deleteKnowledgeConnector: {
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
+    confirm: "This deletes the connector; --delete-documents also deletes its synchronized documents."
+  },
   deleteFile: { confirm: "This archives the file." },
   deleteCredential: {
     confirm: "This disconnects the credential and removes its stored authentication."
   },
   deleteSkill: { confirm: "This deletes the skill." },
+  revokeSkillEditor: {
+    confirm: "This revokes the explicit skill editor grant for the selected email."
+  },
   deleteCustomTool: { confirm: "This deletes the custom tool." },
   deleteMcpServer: {
     confirm: "This removes the MCP server and the tools it provides."
@@ -9870,9 +11801,7 @@ var CLI_CONTRACT = {
   },
   listLogs: {
     flags: {
-      workflowIds: { name: "workflow", list: true },
-      folderPaths: { ...FOLDER_PATH_FLAG, list: true },
-      triggers: { name: "trigger", list: true },
+      ...LOG_LIST_FILTER_FLAGS,
       details: {
         requestDefault: "full",
         describe: "Response detail level; full is requested by default to name each run’s workflow"
@@ -9914,6 +11843,73 @@ var CLI_CONTRACT = {
       { header: "trace", path: "traceSpans", format: "trace-count" }
     ]
   },
+  getMeta: {
+    command: "meta status",
+    describe: "Show what this API supports and which limits apply"
+  },
+  getWorkflowChatDeployment: {
+    command: "workflows chat status",
+    describe: "Show a workflow’s chat deployment"
+  },
+  getLogStats: {
+    command: "logs stats",
+    describe: "Summarize run counts, failures, and cost over a window",
+    flags: LOG_LIST_FILTER_FLAGS
+  },
+  readFileText: {
+    command: "files read",
+    describe: "Read a file’s text content"
+  },
+  createWorkflowMcpServer: {
+    flags: { workflowIds: { name: "workflow", list: true } }
+  },
+  deleteWorkflowMcpServer: {
+    confirm: "This deletes the MCP server, and any agent calling its tools loses access."
+  },
+  undeployWorkflowMcpTool: {
+    confirm: "This withdraws the tool, and any agent calling it loses access."
+  },
+  duplicateWorkflow: {
+    flags: { folderPath: FOLDER_PATH_FLAG }
+  },
+  getWorkflowState: { command: "workflows state get" },
+  replaceWorkflowState: {
+    command: "workflows state replace",
+    confirm: "This replaces the entire draft graph and cannot be undone."
+  },
+  applyWorkflowOperations: {
+    command: "workflows operations apply",
+    confirm: "This edits the draft graph, and a delete operation removes blocks and their edges."
+  },
+  applyWorkflowVariables: {
+    confirm: "This replaces the workflow’s variables and cannot be undone."
+  },
+  revertWorkflowVersion: {
+    confirm: "This overwrites the draft graph with the selected version and cannot be undone."
+  },
+  moveWorkflows: {
+    command: "workflows move",
+    flags: {
+      workflowIds: { name: "workflow", list: true },
+      folderPath: FOLDER_PATH_FLAG
+    }
+  },
+  moveTables: {
+    command: "tables move",
+    flags: {
+      folderPaths: FOLDER_PATHS_FLAG,
+      targetFolderPath: TARGET_FOLDER_PATH_FLAG
+    }
+  },
+  bulkUpdateTableRows: {
+    command: "tables rows update-each",
+    describe: "Apply a distinct patch to each listed row"
+  },
+  bulkDeleteTables: {
+    command: "tables batch-delete",
+    flags: { folderPaths: FOLDER_PATHS_FLAG },
+    confirm: "This deletes every listed table and all of their rows."
+  },
   searchKnowledge: {
     flags: {
       knowledgeBaseIds: { name: "kb", list: true, describe: "Knowledge base ID (repeatable)" },
@@ -9946,7 +11942,7 @@ var CLI_CONTRACT = {
   queryRows: {
     command: "tables rows query",
     flags: {
-      predicate: { name: "filter", json: true, describe: TABLE_FILTER_HELP },
+      predicate: { name: "filter", json: true, describe: TABLE_READ_FILTER_HELP },
       sort: { json: true, describe: TABLE_SORT_HELP }
     },
     expand: "data"
@@ -10046,6 +12042,49 @@ var CLI_CONTRACT = {
   getKnowledgeDocument: { pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT },
   updateKnowledgeDocument: { pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT },
   listKnowledgeTags: { pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT },
+  createKnowledgeTag: { pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT },
+  updateKnowledgeTag: { pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT },
+  deleteKnowledgeTag: {
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
+    confirm: "This deletes the tag and clears its values on every document and chunk."
+  },
+  getNextKnowledgeTagSlot: {
+    command: "knowledge tags next-slot",
+    describe: "Show which tag slot a create would take for a field type",
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT
+  },
+  listKnowledgeTagUsage: {
+    command: "knowledge tags usage",
+    describe: "Show how many documents and chunks carry each tag",
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT
+  },
+  addWorkspaceFilesToKnowledgeBase: {
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
+    describe: "Index files the workspace already stores",
+    flags: {
+      fileReferences: {
+        name: "file",
+        list: true,
+        describe: "Workspace file ID or key (repeatable)"
+      }
+    }
+  },
+  listKnowledgeChunks: {
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
+    columns: [
+      { header: "id" },
+      { header: "index", path: "chunkIndex" },
+      { header: "tokens", path: "tokenCount" },
+      { header: "enabled" }
+    ]
+  },
+  createKnowledgeChunk: { pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT },
+  getKnowledgeChunk: { pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT },
+  updateKnowledgeChunk: { pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT },
+  deleteKnowledgeChunk: {
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
+    confirm: "This deletes the chunk and its embedding."
+  },
   listKnowledgeDocuments: {
     pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
     columns: [
@@ -10171,6 +12210,7 @@ var CLI_CONTRACT = {
     describe: "Show file metadata and sharing status",
     fields: [
       { header: "id" },
+      { header: "web URL", path: "webUrl" },
       { header: "name" },
       { header: "size", format: "bytes" },
       { header: "type" },
@@ -10190,11 +12230,7 @@ var CLI_CONTRACT = {
     describe: "Move files into another folder",
     flags: {
       fileIds: { list: true },
-      targetFolderPath: {
-        ...FOLDER_PATH_INPUT,
-        name: "to",
-        describe: "Destination folder path; omit for root"
-      }
+      targetFolderPath: TARGET_FOLDER_PATH_FLAG
     }
   },
   renameFile: {
@@ -10206,6 +12242,72 @@ var CLI_CONTRACT = {
     renamedFrom: ["files restore create"],
     describe: "Restore an archived file"
   },
+  restoreFileFolder: {
+    command: "files folders restore",
+    positionals: ["path"],
+    flags: { path: FOLDER_PATH_INPUT },
+    describe: "Restore an archived file folder"
+  },
+  restoreTable: {
+    command: "tables restore",
+    describe: "Restore an archived table"
+  },
+  restoreTableFolder: {
+    command: "tables folders restore",
+    positionals: ["path"],
+    flags: { path: FOLDER_PATH_INPUT },
+    describe: "Restore an archived table folder"
+  },
+  restoreKnowledgeBase: {
+    command: "knowledge restore",
+    describe: "Restore an archived knowledge base"
+  },
+  restoreWorkflow: {
+    command: "workflows restore",
+    describe: "Restore an archived workflow"
+  },
+  cancelTableDispatch: {
+    command: "tables dispatches cancel",
+    describe: "Cancel a running dispatch",
+    confirm: "This stops the dispatch. Cells already handed to the queue keep running — use `tables cancel-runs` to stop those."
+  },
+  replaceWorkflowChatDeployment: {
+    command: "workflows chat publish",
+    describe: "Publish or replace a workflow’s chat deployment",
+    confirm: "This replaces the chat deployment wholesale. Any field you omit returns to its default, including a stored password or allow-list."
+  },
+  deleteWorkflowChatDeployment: {
+    command: "workflows chat unpublish",
+    describe: "Take a workflow’s chat deployment offline",
+    confirm: "This takes the chat offline and frees its identifier. The workflow itself stays deployed and executable."
+  },
+  bulkSaveKnowledgeTagDefinitions: {
+    command: "knowledge tags save",
+    describe: "Declare the tag definitions a knowledge base needs",
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
+    flags: {
+      definitions: { json: true, describe: KNOWLEDGE_TAG_DEFINITIONS_HELP }
+    }
+  },
+  deleteKnowledgeTagDefinitions: {
+    command: "knowledge tags cleanup",
+    pathArgumentNames: KNOWLEDGE_BASE_PATH_ARGUMENT,
+    describe: "Remove tag definitions no document still uses",
+    confirm: "This deletes every tag definition no document still uses. Their slots become free for a different field."
+  },
+  unzipFile: {
+    command: "files unzip",
+    describe: "Unzip an archive into a new folder beside it",
+    confirm: "This writes every file in the archive into the workspace."
+  },
+  bulkDownloadFiles: {
+    command: "files bulk-download",
+    describe: "Download files and folders as a zip archive",
+    flags: {
+      fileIds: { list: true },
+      folderPaths: FOLDER_PATHS_FLAG
+    }
+  },
   updateFileContent: {
     command: "files set-content",
     describe: "Replace a file’s contents",
@@ -10354,11 +12456,12 @@ var CLI_CONTRACT = {
       filter: { json: true, describe: TABLE_FILTER_HELP }
     }
   },
-  findTableRows: {
-    command: "tables rows find",
-    describe: "Find rows matching a predicate",
+  searchTableRows: {
+    command: "tables rows search",
+    renamedFrom: ["tables rows find"],
+    describe: "Search cells for a value and return their coordinates",
     flags: {
-      q: { name: "query", renamedFrom: ["q"], describe: "Value to find" },
+      q: { name: "query", renamedFrom: ["q"], describe: "Value to search for" },
       predicate: { name: "filter", json: true, describe: TABLE_FILTER_HELP },
       sort: { json: true, describe: TABLE_SORT_HELP }
     },
@@ -10374,13 +12477,14 @@ var CLI_CONTRACT = {
         name: "filter",
         renamedFrom: ["predicate"],
         json: true,
-        describe: TABLE_FILTER_HELP
+        describe: TABLE_READ_FILTER_HELP
       }
     }
   },
-  runTableColumn: {
-    command: "tables columns run",
-    describe: "Run a column’s workflow",
+  createTableDispatch: {
+    command: "tables dispatches create",
+    renamedFrom: ["tables columns run"],
+    describe: "Start a column or enrichment run",
     flags: {
       groupIds: { list: true },
       rowIds: { list: true },
@@ -10407,10 +12511,14 @@ var CLI_CONTRACT = {
   },
   executeWorkflow: {
     command: "workflows run",
-    describe: "Run a deployed workflow",
+    describe: "Run a deployed workflow or execute saved state manually",
     flags: {
       async: { boolean: true, describe: "Queue the run and return immediately" },
       input: { json: true, describe: "Trigger input as JSON" },
+      run: {
+        hidden: true,
+        describe: "Low-level workflow state and entry-point selection"
+      },
       selectedOutputs: {
         name: "select-output",
         list: true,
@@ -11133,7 +13241,7 @@ async function createServiceAccount(command, providerId, options) {
   if (provider.requiresClientGeneratedCredentialId && !options.id) {
     throw new SimApiError(`--id is required for ${providerId}.`, 0);
   }
-  const credentials = credentialValues(provider, options.credentials);
+  const credentialFields = credentialValues(provider, options.credentials);
   const operation = V2_OPERATIONS.createServiceAccountCredential;
   const response = await client.request(operation.path, {
     method: operation.method,
@@ -11144,7 +13252,7 @@ async function createServiceAccount(command, providerId, options) {
       displayName: options.name,
       ...options.description ? { description: options.description } : {},
       ...options.id ? { id: options.id } : {},
-      ...credentials
+      credentials: JSON.stringify(credentialFields)
     }
   });
   renderResult("createServiceAccountCredential", profile.output, response.data, SERVICE_ACCOUNT_RESULT);
@@ -11170,21 +13278,129 @@ function attachCredentialCommands(program2) {
   credentials.command("reconnect").argument("<credentialId>", "Existing OAuth credential to re-authorize").description("Create a short-lived link for reconnecting an OAuth credential").action((credentialId, _options, command) => createConnectionLink(command, { credentialId }));
 }
 
-// src/commands/protocol/files-get.ts
-import { once as once2 } from "node:events";
-import { createWriteStream } from "node:fs";
-import { link, lstat, mkdtemp, readlink, rename, rm } from "node:fs/promises";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-
 // src/commands/protocol/result.ts
 function printProtocolResult(format, result) {
   const fields = Object.entries(result).map(([key, value]) => [key, text(value)]);
   printRecord(format, fields, result);
 }
 
+// src/commands/protocol/chat.ts
+function parseChatStreamLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed)
+    return;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    throw new SimApiError("Chat stream returned malformed data", 0);
+  }
+}
+async function readChatStream(response, onChunk) {
+  if (!response.body) {
+    throw new SimApiError("Chat stream ended without a response body", 0);
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let finalResult;
+  const processLine = (line) => {
+    const event = parseChatStreamLine(line);
+    if (!event || event.type === "heartbeat")
+      return;
+    if (event.type === "chunk") {
+      if (event.content)
+        onChunk(sanitize(event.content));
+      return;
+    }
+    if (event.type === "error") {
+      throw new SimApiError(event.error || "Chat request failed", 0);
+    }
+    if (event.type === "final") {
+      finalResult = event.data;
+      return;
+    }
+    throw new SimApiError("Chat stream returned an unknown event", 0);
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        processLine(line);
+      }
+    }
+    buffer += decoder.decode();
+    processLine(buffer);
+    if (!finalResult) {
+      throw new SimApiError("Chat stream ended without a final result", 0);
+    }
+    return finalResult;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function attachChat(program2) {
+  program2.command("chat").description("Ask Sim and print the reply").argument("<message>", "What to ask Sim").option("-c, --conversation <id>", "Continue the conversation with this ID").addHelpText("after", `
+Each turn prints the reply on stdout and the conversation ID on stderr; pass
+that ID back with -c to continue the same conversation. With --output json or
+yaml the reply is not streamed — the finished result is printed as one
+document, conversation ID included.
+
+Examples:
+  $ sim chat "What workflows do I have?"
+  $ sim chat -c 3f2a… "Which of those run on a schedule?"
+  $ sim --output json chat "Summarize yesterday's failed runs" | jq -r '.content'
+`).action(async (message, options, command) => {
+    const { client, profile } = clientFrom(command);
+    const workspaceId = client.requireWorkspace();
+    const response = await client.requestRaw(V2_OPERATIONS.chat.path, {
+      method: "POST",
+      body: {
+        workspaceId,
+        message,
+        ...options.conversation ? { conversationId: options.conversation } : {}
+      },
+      headers: { accept: "application/x-ndjson" }
+    });
+    const streaming = profile.output === "table" || profile.output === "text";
+    let streamed = "";
+    const result = await readChatStream(response, (content2) => {
+      if (!streaming)
+        return;
+      streamed += content2;
+      process.stdout.write(content2);
+    });
+    if (!streaming) {
+      printProtocolResult(profile.output, result);
+      return;
+    }
+    const content = sanitize(result.content ?? "");
+    if (content.startsWith(streamed) && content.length > streamed.length) {
+      process.stdout.write(content.slice(streamed.length));
+      streamed = content;
+    }
+    if (streamed.length > 0 && !streamed.endsWith(`
+`)) {
+      process.stdout.write(`
+`);
+    }
+    process.stderr.write(`${source_default.dim(`conversation: ${result.conversationId}`)}
+`);
+  });
+}
+
 // src/commands/protocol/files-get.ts
+import { once as once2 } from "node:events";
+import { createWriteStream } from "node:fs";
+import { link, lstat, mkdtemp, readlink, rename, rm } from "node:fs/promises";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 function writeFailure(path, error) {
   if (isRequestTimeout(error)) {
     return new SimApiError(`Downloading ${path} timed out. ${RAISE_TIMEOUT_HINT}`, 0);
@@ -11846,6 +14062,8 @@ function addFieldOption(command, operation, field, descriptor) {
   const describe = `${documented}${takesList ? " (space-separated, or @path / @- with one value per line)" : wantsJson ? " (JSON, or @path / @- to read a file or stdin)" : ""}${descriptor.required ? " (required)" : ""}`;
   const renamedFrom = flag.renamedFrom ?? [];
   const option = new Option(`${short}--${name} ${placeholder}`, describe);
+  if (flag.hidden)
+    option.hideHelp();
   if (choices && !takesList)
     option.choices([...choices]);
   if (descriptor.default !== undefined && field !== "limit") {
@@ -11946,6 +14164,7 @@ function entriesFor(config, folders, resources) {
       kind: config.kind,
       name: resource.name,
       ref: resource.id,
+      webUrl: resource.webUrl,
       folderPath: resource.folderPath,
       updatedAt: resource.updatedAt
     }))
@@ -12157,7 +14376,7 @@ async function executeOperation(operation, commandSpec, operationSpec, invocatio
     requestFlags[camel(flagNameFor(operation, field))] = invocation[pathPositionalCount + index];
   }
   foldRenamedFlags(operation, commandSpec, requestFlags);
-  if (commandSpec.confirm && !requestFlags.yes) {
+  if (commandSpec.confirm && !requestFlags.yes && requestFlags.dryRun !== true) {
     throw new SimApiError(`${commandSpec.confirm} Re-run with --yes to confirm.`, 0);
   }
   if (commandSpec.allWorkspaces && requestFlags.allWorkspaces && requestFlags.workspace) {
@@ -12211,6 +14430,49 @@ async function executeOperation(operation, commandSpec, operationSpec, invocatio
 var AGENT_STREAM_PROTOCOL_HEADER = "x-sim-stream-protocol";
 var AGENT_STREAM_PROTOCOL_V1 = "agent-events-v1";
 var DONE_SENTINEL = "[DONE]";
+function resolveWorkflowRunSelection(flags) {
+  const manual = flags.manual === true;
+  const trigger = typeof flags.trigger === "string" ? flags.trigger : undefined;
+  const useMockPayload = flags.mockPayload === true;
+  const fromBlock = typeof flags.fromBlock === "string" ? flags.fromBlock : undefined;
+  const sourceRun = typeof flags.sourceRun === "string" ? flags.sourceRun : undefined;
+  if ((trigger || useMockPayload) && !manual) {
+    throw new SimApiError("--trigger and --mock-payload require --manual", 0);
+  }
+  if (fromBlock && (trigger || useMockPayload)) {
+    throw new SimApiError("--from-block cannot be combined with --trigger or --mock-payload", 0);
+  }
+  if (fromBlock && !sourceRun) {
+    throw new SimApiError("--from-block requires --source-run <runId>", 0);
+  }
+  if (sourceRun && !fromBlock) {
+    throw new SimApiError("--source-run requires --from-block <blockId>", 0);
+  }
+  if ((manual || fromBlock) && flags.async === true) {
+    throw new SimApiError("Manual execution does not support --async", 0);
+  }
+  if (useMockPayload && flags.input !== undefined) {
+    throw new SimApiError("--mock-payload cannot be combined with --input", 0);
+  }
+  if (fromBlock && sourceRun) {
+    return {
+      source: "manual",
+      entry: { type: "block", blockId: fromBlock, sourceRunId: sourceRun }
+    };
+  }
+  if (!manual)
+    return;
+  if (!trigger && !useMockPayload)
+    return { source: "manual" };
+  return {
+    source: "manual",
+    entry: {
+      type: "trigger",
+      ...trigger ? { blockId: trigger } : {},
+      ...useMockPayload ? { useMockPayload: true } : {}
+    }
+  };
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -12377,6 +14639,10 @@ async function followRun(workflowId, command) {
 }
 function followOrDelegate(previous) {
   return async (workflowId, _options, command) => {
+    const initialFlags = command.optsWithGlobals();
+    const selection = resolveWorkflowRunSelection(initialFlags);
+    if (selection)
+      command.setOptionValue("run", selection);
     const flags = command.optsWithGlobals();
     if (flags.follow !== true) {
       if (flags.includeThinking === true || flags.includeToolCalls === true) {
@@ -12399,7 +14665,7 @@ function attachWorkflowRunFollow(workflows) {
   }
   const held = run._actionHandler;
   const previous = typeof held === "function" ? held : null;
-  run.option("--follow", "Stream the run as it happens; progress on stderr, result on stdout. The stream reports only success and output, so the result omits the run id and timings a non-streaming run returns").option("--include-thinking", "Show model reasoning while following (requires --follow)").option("--include-tool-calls", "Show tool calls while following (requires --follow)").action(followOrDelegate(previous));
+  run.option("--manual", "Run the current saved workflow state instead of the active deployment").option("--trigger <blockId>", "Enter a manual run through this runnable trigger (requires --manual)").option("--mock-payload", "Use the selected trigger's server-derived mock payload (requires --manual)").option("--from-block <blockId>", "Run manually from this saved workflow block").option("--source-run <runId>", "Prior run whose persisted state supplies upstream outputs (requires --from-block)").option("--follow", "Stream the run as it happens; progress on stderr, result on stdout. The stream reports only success and output, so the result omits the run id and timings a non-streaming run returns").option("--include-thinking", "Show model reasoning while following (requires --follow)").option("--include-tool-calls", "Show tool calls while following (requires --follow)").action(followOrDelegate(previous));
 }
 
 // src/commands/protocol/workflow-run-wait.ts
@@ -12484,7 +14750,7 @@ function attachWorkflowRunWait(runs) {
     const timeoutSeconds = options.waitTimeout === undefined ? DEFAULT_WAIT_TIMEOUT_SECONDS : parseWaitTimeout(options.waitTimeout);
     const { client, profile } = clientFrom(command);
     const operation = V2_OPERATIONS.getWorkflowRun;
-    const path = resolvePath(operation.path, { id: options.workflow, runId });
+    const path = resolvePath(operation.path, { workflowId: options.workflow, runId });
     const startedAt = Date.now();
     const deadline = timeoutSeconds === 0 ? Number.POSITIVE_INFINITY : startedAt + timeoutSeconds * 1000;
     const progress = waitProgress();
@@ -12566,6 +14832,7 @@ function attachProtocolCommands(program2) {
   attachWorkflowRunFollow(workflows);
   attachWorkflowRunWait(group(workflows, "runs"));
   attachLogsFollow(group(program2, "logs"));
+  attachChat(program2);
 }
 
 // src/terminal/secret-input.ts
@@ -12846,8 +15113,11 @@ function addLeafCommand(groups, operation, spec, segments) {
     throw new Error(`${operation} leaf command must include a verb`);
   const group2 = groupFor(groups, groupName);
   if (rest.length > 1) {
-    const [subName, ...tail] = rest;
-    nestedGroup(group2, subName).addCommand(buildLeaf(operation, spec, tail.join(" ")));
+    let parent = group2;
+    for (const segment of rest.slice(0, -1)) {
+      parent = nestedGroup(parent, segment);
+    }
+    parent.addCommand(buildLeaf(operation, spec, rest[rest.length - 1]));
     return;
   }
   group2.addCommand(buildLeaf(operation, spec, rest[0]));
@@ -12908,6 +15178,7 @@ with -P, --profile, or SIM_PROFILE.
 
 Examples:
   $ sim login                                    Authorize the default profile
+  $ sim profile add acme --workspace ws_123      Reuse that login for a workspace
   $ sim login --profile dev --endpoint http://localhost:3000
   $ sim workflows list
   $ sim logs list --level error --limit 20