@kadoa/mcp 0.7.0 → 0.7.2

package/dist/index.js

@@ -17,7 +17,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@kadoa/mcp",
-    version: "0.7.0",
+    version: "0.7.2",
     description: "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
     type: "module",
     main: "dist/index.js",
@@ -44,7 +44,7 @@ var init_package = __esm(() => {
       prepublishOnly: "bun run check-types && bun run test:unit && bun run build"
     },
     dependencies: {
-      "@kadoa/node-sdk": "^0.45.0",
+      "@kadoa/node-sdk": "^0.48.0",
       "@modelcontextprotocol/client": "2.1.0",
       "@modelcontextprotocol/express": "2.0.1",
       "@modelcontextprotocol/node": "2.1.0",
@@ -212,252 +212,187 @@ function withVariableDashboardUrl(variable) {
   return { ...variable, dashboardUrl: variableSettingsDashboardUrl() };
 }
 
-// src/tools/shared/output-schemas.ts
-import { z } from "zod";
-var apiField, nullableString, PaginationOutput, WorkflowRowOutput, ListWorkflowsOutput, GetWorkflowOutput, FetchDataOutput, ASSISTANT_ACTIVITIES, WorkflowAssistantOutput, AssistantTimelineOutput, AssistantAnswerOutput, AssistantControlOutput, WorkflowStrategyOutput;
-var init_output_schemas = __esm(() => {
-  apiField = z.unknown().optional();
-  nullableString = z.string().nullable();
-  PaginationOutput = z.object({
-    totalCount: z.number().optional(),
-    hasMore: z.boolean(),
-    limit: z.number().optional(),
-    skip: z.number().optional(),
-    offset: z.number().optional(),
-    page: z.number().optional(),
-    totalPages: z.number().optional(),
-    nextCursor: nullableString.optional(),
-    next: z.record(z.string(), z.unknown()).optional()
-  }).loose();
-  WorkflowRowOutput = z.object({
-    id: apiField,
-    name: apiField,
-    dashboardUrl: z.string(),
-    status: z.string(),
-    state: nullableString,
-    displayState: nullableString,
-    runState: nullableString,
-    urls: apiField,
-    totalRecords: apiField,
-    startedAt: apiField,
-    finishedAt: apiField,
-    createdAt: apiField,
-    assistant: z.object({
-      eligible: z.boolean(),
-      dataStale: z.boolean(),
-      session: z.object({ id: z.string(), threadId: apiField, status: apiField }).loose().nullable()
-    }).loose(),
-    template: z.object({ id: z.string(), pinnedVersion: apiField, latestVersion: apiField, isOutdated: z.boolean() }).loose().nullable(),
-    realtime: z.object({ enabled: z.boolean(), lastDataChangedAt: apiField, health: apiField }).loose(),
-    awaitingUserInput: apiField
-  }).loose();
-  ListWorkflowsOutput = z.object({ workflows: z.array(WorkflowRowOutput), pagination: PaginationOutput }).loose();
-  GetWorkflowOutput = z.object({
-    id: z.string(),
-    name: apiField,
-    dashboardUrl: z.string(),
-    description: apiField,
-    status: z.string(),
-    state: nullableString,
-    displayState: nullableString,
-    runState: nullableString,
-    urls: apiField,
-    prompt: nullableString,
-    intentSource: z.enum(["extraction_spec", "legacy_prompt"]).nullable(),
-    extractionSpec: apiField,
-    entity: apiField,
-    schema: apiField,
-    navigationMode: apiField,
-    dataStale: apiField,
-    assistantEligible: z.boolean(),
-    assistantSessionId: apiField,
-    assistantThreadId: apiField,
-    assistantSessionStatus: apiField,
-    assistant: z.object({ eligible: z.boolean(), sessionId: apiField, threadId: apiField, sessionStatus: apiField }).loose(),
-    template: z.object({
-      id: apiField,
-      name: apiField,
-      version: apiField,
-      controlledParts: z.array(z.string()),
-      hasSchemaValidationRules: apiField
-    }).loose().nullable(),
-    updateInterval: apiField,
-    schedules: apiField,
-    scheduleTimezone: apiField,
-    nextInvocation: apiField,
-    location: apiField,
-    limit: apiField,
-    tags: apiField,
-    totalRecords: apiField,
-    job: z.object({ id: apiField }).loose().nullable(),
-    startedAt: apiField,
-    finishedAt: apiField,
-    estimatedFinishedAtUtc: apiField,
-    errors: apiField,
-    createdAt: apiField,
-    notificationConfig: apiField,
-    channelCounts: apiField,
-    dataValidation: apiField,
-    validationStatistics: apiField,
-    realtime: z.object({ lastDataChangedAt: apiField, observerHealth: apiField }).loose().nullable()
-  }).loose();
-  FetchDataOutput = z.object({
-    data: z.array(z.record(z.string(), z.unknown())),
-    pagination: PaginationOutput,
-    totalCount: z.number().optional(),
-    hint: z.string().optional()
-  }).loose();
-  ASSISTANT_ACTIVITIES = [
-    "unsupported",
-    "not_started",
-    "working",
-    "waiting_for_input",
-    "idle",
-    "interrupted",
-    "failed",
-    "closed",
-    "unknown"
-  ];
-  WorkflowAssistantOutput = z.object({
-    workflowId: z.string(),
-    assistantEligible: z.boolean(),
-    sessionId: nullableString,
-    threadId: apiField,
-    sessionStatus: apiField,
-    activity: z.enum(ASSISTANT_ACTIVITIES),
-    canAcceptUpdate: z.boolean(),
-    isTerminal: z.boolean(),
-    paused: apiField,
-    pause: apiField,
-    pendingQuestion: apiField
-  }).loose();
-  AssistantTimelineOutput = z.object({
-    workflowId: z.string(),
-    sessionId: apiField,
-    items: z.array(z.unknown()),
-    pagination: PaginationOutput,
-    dashboardUrl: z.string()
-  }).loose();
-  AssistantAnswerOutput = z.object({
-    success: z.literal(true),
-    workflowId: z.string(),
-    sessionId: z.string(),
-    threadId: apiField,
-    questionId: z.string(),
-    message: z.string()
-  }).loose();
-  AssistantControlOutput = z.object({
-    success: z.boolean(),
-    status: z.literal("accepted"),
-    action: z.enum(["interrupt", "resume", "stop"]),
-    workflowId: z.string(),
-    sessionId: z.string(),
-    delivery: apiField,
-    jobId: apiField,
-    message: z.string()
-  }).loose();
-  WorkflowStrategyOutput = z.object({
-    workflowId: z.string(),
-    sessionId: nullableString,
-    source: z.enum(["assistant_build", "workflow_metadata"]).nullable(),
-    status: z.enum(["ready", "building", "unavailable"]),
-    strategy: apiField,
-    message: z.string().optional()
-  }).loose();
-});
-
-// src/tools/shared/pagination.ts
-import { z as z2 } from "zod";
-function limitInput(options) {
-  const range = `limit must be a whole number from 1 to ${options.max}`;
-  const overMax = `${range}. ${options.overMaxHint ?? "Page with pagination.next."}`;
-  return z2.preprocess(coerceNumber(), z2.number().int(range).min(1, range).max(options.max, overMax)).optional().describe(`${options.noun} per page, 1-${options.max} (default ${options.defaultLimit})`);
-}
-function offsetInput(param, noun) {
-  const range = `${param} must be a whole number from 0 to ${MAX_OFFSET}`;
-  return z2.preprocess(coerceNumber(), z2.number().int(range).min(0, range).max(MAX_OFFSET, range)).optional().describe(`Number of ${noun} to skip (default 0)`);
-}
-function pageInput() {
-  const range = `page must be a whole number from 1 to ${MAX_PAGE}`;
-  return z2.preprocess(coerceNumber(), z2.number().int(range).min(1, range).max(MAX_PAGE, range)).optional().describe("Page number, 1-based (default 1)");
-}
-function nextArgs(args, patch) {
-  const next = {};
-  for (const [key, value] of Object.entries({ ...args, ...patch })) {
-    if (value !== undefined)
-      next[key] = value;
+// src/tools/shared/portable-schema.ts
+function lookupRef(ref, defs) {
+  if (typeof ref !== "string")
+    return;
+  const match = /^#\/(?:\$defs|definitions)\/(.+)$/.exec(ref);
+  if (!match)
+    return;
+  const name = match[1].replace(/~1/g, "/").replace(/~0/g, "~");
+  const def = defs[name];
+  return isObject(def) ? { name, def } : undefined;
+}
+function mergeSchemas(base, extra) {
+  const merged = { ...extra, ...base };
+  if (isObject(base.properties) || isObject(extra.properties)) {
+    merged.properties = {
+      ...isObject(extra.properties) ? extra.properties : {},
+      ...isObject(base.properties) ? base.properties : {}
+    };
   }
-  return next;
-}
-function withTotal(totalCount, hasMore) {
-  return totalCount !== undefined ? { totalCount, hasMore } : { hasMore };
-}
-function offsetPage(options) {
-  const nextOffset = options.offset + options.returned;
-  const more = options.hasMore ?? (options.totalCount !== undefined ? nextOffset < options.totalCount : options.returned >= options.limit);
-  const hasMore = options.returned > 0 && more;
-  const meta = withTotal(options.totalCount, hasMore);
-  meta.limit = options.limit;
-  meta[options.param] = options.offset;
-  if (hasMore)
-    meta.next = nextArgs(options.args, { [options.param]: nextOffset, limit: options.limit });
-  return meta;
-}
-function numberedPage(options) {
-  const more = options.totalPages !== undefined ? options.page < options.totalPages : options.totalCount !== undefined ? options.page * options.limit < options.totalCount : options.returned >= options.limit;
-  const hasMore = options.returned > 0 && more;
-  const meta = withTotal(options.totalCount, hasMore);
-  meta.limit = options.limit;
-  meta.page = options.page;
-  if (options.totalPages !== undefined)
-    meta.totalPages = options.totalPages;
-  if (hasMore)
-    meta.next = nextArgs(options.args, { page: options.page + 1, limit: options.limit });
-  return meta;
-}
-function cursorPage(options) {
-  const cursor = typeof options.nextCursor === "string" && options.nextCursor.length > 0 ? options.nextCursor : null;
-  const meta = { hasMore: options.hasMore && cursor !== null, nextCursor: cursor };
-  if (meta.hasMore)
-    meta.next = nextArgs(options.args, { cursor });
-  return meta;
-}
-function completeList(totalCount) {
-  return { totalCount, hasMore: false };
-}
-var MAX_OFFSET = 1e6, MAX_PAGE = 1e5;
-var init_pagination = () => {};
-
-// src/tools/shared/results.ts
-function asStructuredObject(data) {
-  return data !== null && !Array.isArray(data) ? data : { result: data };
-}
-function structuredResult(data, extra = []) {
-  const structuredContent = asStructuredObject(data);
-  return {
-    structuredContent,
-    content: [{ type: "text", text: JSON.stringify(structuredContent) }, ...extra]
-  };
-}
-function jsonResult(data) {
-  return structuredResult(data);
-}
-function textOnlyResult(data, extra = []) {
-  const structuredContent = asStructuredObject(data);
-  return { content: [{ type: "text", text: JSON.stringify(structuredContent) }, ...extra] };
+  if (Array.isArray(base.required) || Array.isArray(extra.required)) {
+    const required = [
+      ...Array.isArray(extra.required) ? extra.required : [],
+      ...Array.isArray(base.required) ? base.required : []
+    ];
+    merged.required = [...new Set(required)];
+  }
+  return merged;
+}
+function walk(node, defs, refCounts, io) {
+  if (!isObject(node))
+    return node;
+  let current = { ...node };
+  let counts = refCounts;
+  while ("$ref" in current) {
+    const { $ref, ...site } = current;
+    const target = lookupRef($ref, defs);
+    if (!target) {
+      current = site;
+      break;
+    }
+    const seen = counts.get(target.name) ?? 0;
+    counts = new Map(counts).set(target.name, seen + 1);
+    if (seen >= MAX_REF_DEPTH) {
+      const description = typeof target.def.description === "string" ? target.def.description : STUB_DESCRIPTION;
+      const type = typeof target.def.type === "string" ? target.def.type : io === "input" ? "object" : undefined;
+      current = { ...type ? { type } : {}, description, ...site };
+      break;
+    }
+    current = { ...target.def, ...site };
+  }
+  for (const keyword of DROPPED_KEYWORDS)
+    delete current[keyword];
+  if ("const" in current) {
+    const { const: value, ...rest } = current;
+    current = typeof value === "string" ? { ...rest, enum: [value] } : rest;
+    if (current.type === undefined && ["string", "number", "boolean"].includes(typeof value)) {
+      current.type = typeof value;
+    }
+  }
+  if (typeof current.exclusiveMinimum === "number") {
+    const bound = current.exclusiveMinimum;
+    current.minimum = typeof current.minimum === "number" ? Math.max(current.minimum, bound) : bound;
+  }
+  if (typeof current.exclusiveMaximum === "number") {
+    const bound = current.exclusiveMaximum;
+    current.maximum = typeof current.maximum === "number" ? Math.min(current.maximum, bound) : bound;
+  }
+  delete current.exclusiveMinimum;
+  delete current.exclusiveMaximum;
+  if (io === "input" && Array.isArray(current.enum) && Array.isArray(current.type) && current.type.includes("null")) {
+    current.enum = current.enum.filter((member) => member !== null);
+  }
+  if (Array.isArray(current.enum) && current.enum.some((member) => typeof member !== "string")) {
+    delete current.enum;
+  }
+  if (Array.isArray(current.prefixItems)) {
+    const { prefixItems, ...rest } = current;
+    current = rest;
+    if (current.items === undefined && prefixItems.length > 0) {
+      current.items = prefixItems.length === 1 ? prefixItems[0] : { anyOf: prefixItems };
+    }
+  }
+  if (isObject(current.properties)) {
+    current.properties = Object.fromEntries(Object.entries(current.properties).map(([name, value]) => [name, walk(value, defs, counts, io)]));
+  }
+  if (isObject(current.items))
+    current.items = walk(current.items, defs, counts, io);
+  if (Array.isArray(current.oneOf)) {
+    current.anyOf = [...Array.isArray(current.anyOf) ? current.anyOf : [], ...current.oneOf];
+    delete current.oneOf;
+  }
+  if (Array.isArray(current.anyOf))
+    current.anyOf = current.anyOf.map((member) => walk(member, defs, counts, io));
+  if (Array.isArray(current.allOf)) {
+    const { allOf, ...rest } = current;
+    current = rest;
+    for (const member of allOf) {
+      const walked = walk(member, defs, counts, io);
+      if (isObject(walked))
+        current = mergeSchemas(current, walked);
+    }
+  }
+  if (Array.isArray(current.type)) {
+    const types = current.type.filter((entry) => entry !== "null");
+    const nullable = types.length !== current.type.length;
+    if (types.length === 0) {
+      current.type = "null";
+    } else if (types.length === 1 && !(nullable && io === "output")) {
+      current.type = types[0];
+      if (nullable)
+        current.nullable = true;
+    } else {
+      const members = current.type.map((type) => ({ type }));
+      delete current.type;
+      current.anyOf = members;
+    }
+  }
+  if (Array.isArray(current.anyOf) && current.anyOf.some(isNullSchema)) {
+    const members = current.anyOf.filter((member) => !isNullSchema(member));
+    const { anyOf: _anyOf, ...rest } = current;
+    if (members.length === 0) {
+      current = { ...rest, type: "null" };
+    } else if (io === "input" && members.length === 1 && isObject(members[0])) {
+      const merged = mergeSchemas(rest, members[0]);
+      if (typeof merged.type === "string")
+        current = { ...merged, nullable: true };
+    }
+  }
+  return current;
 }
-function errorResult(message, details = {}) {
-  return {
-    content: [{ type: "text", text: JSON.stringify({ error: message, ...details }) }],
-    isError: true
+function toPortableJsonSchema(schema, options = {}) {
+  const io = options.io ?? "input";
+  const defs = {
+    ...isObject(schema.definitions) ? schema.definitions : {},
+    ...isObject(schema.$defs) ? schema.$defs : {}
   };
-}
-function withExtraContent(result, ...blocks) {
-  return { ...result, content: [...result.content, ...blocks] };
-}
+  return walk(schema, defs, new Map, io);
+}
+var NON_PORTABLE_KEYWORDS, DROPPED_KEYWORDS, MAX_REF_DEPTH = 3, STUB_DESCRIPTION = "Nested value of the same shape", isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value), isNullSchema = (schema) => isObject(schema) && schema.type === "null";
+var init_portable_schema = __esm(() => {
+  NON_PORTABLE_KEYWORDS = new Set([
+    "$ref",
+    "$defs",
+    "definitions",
+    "const",
+    "oneOf",
+    "allOf",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "prefixItems",
+    "$schema",
+    "additionalProperties",
+    "propertyNames",
+    "multipleOf",
+    "uniqueItems",
+    "id",
+    "$id",
+    "contentEncoding",
+    "contentMediaType",
+    "dependentRequired",
+    "patternProperties"
+  ]);
+  DROPPED_KEYWORDS = [
+    "$schema",
+    "$id",
+    "id",
+    "$defs",
+    "definitions",
+    "additionalProperties",
+    "propertyNames",
+    "patternProperties",
+    "multipleOf",
+    "uniqueItems",
+    "contentEncoding",
+    "contentMediaType",
+    "dependentRequired"
+  ];
+});
 
 // src/tools/shared/schemas.ts
-import { z as z3 } from "zod";
+import { z } from "zod";
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -519,18 +454,14 @@ function stampSchemaValidationRules(rules, attribution, previous) {
   return Object.fromEntries(Object.entries(rules).map(([name, field]) => [name, stampField(field, previousFields[name])]));
 }
 function strictSchema(shape) {
-  return z3.object(shape).strict();
+  return portable(z.object(shape).strict());
 }
-function withoutDefIds(schema) {
+function portable(schema) {
   const jsonSchema = schema["~standard"].jsonSchema;
   const emitInput = jsonSchema.input;
-  jsonSchema.input = (params) => {
-    const result = emitInput(params);
-    const defs = result.$defs;
-    for (const def of Object.values(defs ?? {}))
-      delete def.id;
-    return result;
-  };
+  const emitOutput = jsonSchema.output;
+  jsonSchema.input = (params) => toPortableJsonSchema(emitInput(params), { io: "input" });
+  jsonSchema.output = (params) => toPortableJsonSchema(emitOutput(params), { io: "output" });
   return schema;
 }
 function normalizeDataFilters(val, ctx) {
@@ -555,7 +486,7 @@ function normalizeDataFilters(val, ctx) {
         code: "custom",
         message: "Grouped filters ({logicalOperator, conditions}) are not supported. Send a flat array of " + "{field, operator, value} filters instead; multiple filters are combined with OR."
       });
-      return z3.NEVER;
+      return z.NEVER;
     }
     return [v];
   }
@@ -563,7 +494,8 @@ function normalizeDataFilters(val, ctx) {
 }
 var UpdateIntervalSchema, NOTIFICATION_EVENT_TYPES, NotificationEventTypeSchema, SchemaFieldDataTypeSchema, SchemaFieldShape, SchemaValidationPresenceRule, SchemaValidationUniquenessRule, SchemaValidationBoundRule, SchemaValidationStringFormatRule, SchemaValidationFieldRulesSchema, SchemaValidationRulesSchema, SCHEMA_VALIDATION_ATTRIBUTION_KEYS, LocationSchema, MonitoringValueOperators, MonitoringValuelessOperators, MonitoringConditionOperatorSchema, MonitoringConditionSchema, MonitoringSchema, urlInputShape, extractionPromptInput, extractionInputShape, webhookAuthShape, notificationChannelsSchema, notificationsInputShape, requiredNotificationsInputShape, DATA_FILTER_OPERATORS, DATA_FILTER_VALUELESS_OPERATORS, DATA_FILTER_LIST_OPERATORS, DataFilterSchema, dataFiltersInput;
 var init_schemas = __esm(() => {
-  UpdateIntervalSchema = z3.enum([
+  init_portable_schema();
+  UpdateIntervalSchema = z.enum([
     "ONLY_ONCE",
     "EVERY_10_MINUTES",
     "HALF_HOURLY",
@@ -597,8 +529,8 @@ var init_schemas = __esm(() => {
     "credits_low",
     "free_trial_ending"
   ];
-  NotificationEventTypeSchema = z3.enum(NOTIFICATION_EVENT_TYPES);
-  SchemaFieldDataTypeSchema = z3.enum([
+  NotificationEventTypeSchema = z.enum(NOTIFICATION_EVENT_TYPES);
+  SchemaFieldDataTypeSchema = z.enum([
     "STRING",
     "NUMBER",
     "BOOLEAN",
@@ -611,61 +543,61 @@ var init_schemas = __esm(() => {
     "ARRAY"
   ]);
   SchemaFieldShape = {
-    name: z3.string().describe("Field name"),
-    description: z3.string().optional().describe("What this field contains"),
-    example: z3.string().describe("Example value"),
+    name: z.string().describe("Field name"),
+    description: z.string().optional().describe("What this field contains"),
+    example: z.string().describe("Example value"),
     dataType: SchemaFieldDataTypeSchema.optional().describe("Data type for the field"),
-    isKey: z3.preprocess(coerceBoolean(), z3.boolean()).optional().describe("Marks this field as a key field - the stable identity used to match records across runs. Change detection diffs records by their key fields, so a monitored or real-time workflow without one cannot tell an updated record from a new one. Set it on whatever uniquely identifies a row (a detail URL, an ID, a ticker).")
+    isKey: z.preprocess(coerceBoolean(), z.boolean()).optional().describe("Marks this field as a key field - the stable identity used to match records across runs. Change detection diffs records by their key fields, so a monitored or real-time workflow without one cannot tell an updated record from a new one. Set it on whatever uniquely identifies a row (a detail URL, an ID, a ticker).")
   };
-  SchemaValidationPresenceRule = z3.object({
-    target: z3.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a value")
+  SchemaValidationPresenceRule = z.object({
+    target: z.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a value")
   }).strict().meta({ id: "PresenceRule" });
-  SchemaValidationUniquenessRule = z3.object({
-    target: z3.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a unique value")
+  SchemaValidationUniquenessRule = z.object({
+    target: z.number().int().min(0).max(100).step(20).describe("Expected percentage of rows with a unique value")
   }).strict().meta({ id: "UniquenessRule" });
-  SchemaValidationBoundRule = z3.object({
-    value: z3.number().int().min(0).describe("Length or count bound")
+  SchemaValidationBoundRule = z.object({
+    value: z.number().int().min(0).describe("Length or count bound")
   }).strict().meta({ id: "BoundRule" });
-  SchemaValidationStringFormatRule = z3.discriminatedUnion("kind", [
-    z3.object({
-      kind: z3.literal("FREE_TEXT"),
-      charset: z3.discriminatedUnion("kind", [
-        z3.object({
-          kind: z3.literal("PRESET"),
-          preset: z3.enum(["natural_language", "alphanumeric", "alpha"])
+  SchemaValidationStringFormatRule = z.discriminatedUnion("kind", [
+    z.object({
+      kind: z.literal("FREE_TEXT"),
+      charset: z.discriminatedUnion("kind", [
+        z.object({
+          kind: z.literal("PRESET"),
+          preset: z.enum(["natural_language", "alphanumeric", "alpha"])
         }).strict()
       ])
     }).strict(),
-    z3.object({
-      kind: z3.literal("FORMAT"),
-      source: z3.discriminatedUnion("kind", [
-        z3.object({
-          kind: z3.literal("PRESET"),
-          preset: z3.enum(["url", "email", "phone", "date", "datetime", "time", "uuid", "slug"])
+    z.object({
+      kind: z.literal("FORMAT"),
+      source: z.discriminatedUnion("kind", [
+        z.object({
+          kind: z.literal("PRESET"),
+          preset: z.enum(["url", "email", "phone", "date", "datetime", "time", "uuid", "slug"])
         }).strict(),
-        z3.object({
-          kind: z3.literal("CUSTOM"),
-          pattern: z3.string().min(1).describe("Regular expression pattern")
+        z.object({
+          kind: z.literal("CUSTOM"),
+          pattern: z.string().min(1).describe("Regular expression pattern")
         }).strict()
       ])
     }).strict(),
-    z3.object({
-      kind: z3.literal("LIST"),
-      source: z3.discriminatedUnion("kind", [
-        z3.object({
-          kind: z3.literal("PRESET"),
-          preset: z3.enum(["language2", "country2", "country3", "currency3", "month3", "usState2"])
+    z.object({
+      kind: z.literal("LIST"),
+      source: z.discriminatedUnion("kind", [
+        z.object({
+          kind: z.literal("PRESET"),
+          preset: z.enum(["language2", "country2", "country3", "currency3", "month3", "usState2"])
         }).strict(),
-        z3.object({
-          kind: z3.literal("CUSTOM"),
-          values: z3.array(z3.string().min(1)).min(1).describe("Allowed string values")
+        z.object({
+          kind: z.literal("CUSTOM"),
+          values: z.array(z.string().min(1)).min(1).describe("Allowed string values")
         }).strict()
       ])
     }).strict()
   ]);
-  SchemaValidationFieldRulesSchema = z3.lazy(() => z3.discriminatedUnion("kind", [
-    z3.object({
-      kind: z3.literal("STRING"),
+  SchemaValidationFieldRulesSchema = z.lazy(() => z.discriminatedUnion("kind", [
+    z.object({
+      kind: z.literal("STRING"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
       minLength: SchemaValidationBoundRule.optional(),
@@ -674,27 +606,27 @@ var init_schemas = __esm(() => {
       maxHtmlElements: SchemaValidationBoundRule.optional(),
       format: SchemaValidationStringFormatRule.optional()
     }).strict(),
-    z3.object({
-      kind: z3.literal("NUMBER"),
+    z.object({
+      kind: z.literal("NUMBER"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
-      minimum: z3.object({ value: z3.number().describe("Minimum numeric value") }).strict().optional(),
-      maximum: z3.object({ value: z3.number().describe("Maximum numeric value") }).strict().optional(),
-      maxDecimalPlaces: z3.object({ value: z3.number().int().min(0).max(16) }).strict().optional()
+      minimum: z.object({ value: z.number().describe("Minimum numeric value") }).strict().optional(),
+      maximum: z.object({ value: z.number().describe("Maximum numeric value") }).strict().optional(),
+      maxDecimalPlaces: z.object({ value: z.number().int().min(0).max(16) }).strict().optional()
     }).strict(),
-    z3.object({
-      kind: z3.literal("OTHER"),
+    z.object({
+      kind: z.literal("OTHER"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional()
     }).strict(),
-    z3.object({
-      kind: z3.literal("OBJECT"),
+    z.object({
+      kind: z.literal("OBJECT"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
-      properties: z3.record(z3.string(), SchemaValidationFieldRulesSchema)
+      properties: z.record(z.string(), SchemaValidationFieldRulesSchema)
     }).strict(),
-    z3.object({
-      kind: z3.literal("ARRAY"),
+    z.object({
+      kind: z.literal("ARRAY"),
       presence: SchemaValidationPresenceRule.optional(),
       uniqueness: SchemaValidationUniquenessRule.optional(),
       minItems: SchemaValidationBoundRule.optional(),
@@ -702,21 +634,21 @@ var init_schemas = __esm(() => {
       items: SchemaValidationFieldRulesSchema.optional()
     }).strict()
   ]));
-  SchemaValidationRulesSchema = z3.record(z3.string(), SchemaValidationFieldRulesSchema);
+  SchemaValidationRulesSchema = z.record(z.string(), SchemaValidationFieldRulesSchema);
   SCHEMA_VALIDATION_ATTRIBUTION_KEYS = new Set(["editedBy", "editedByLabel", "editedAt"]);
-  LocationSchema = z3.object({
-    type: z3.enum(["auto", "manual"]),
-    isoCode: z3.string().trim().min(2).optional()
+  LocationSchema = z.object({
+    type: z.enum(["auto", "manual"]),
+    isoCode: z.string().trim().min(2).optional()
   }).strict().superRefine((location, ctx) => {
     if (location.type === "manual" && !location.isoCode) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z.ZodIssueCode.custom,
         path: ["isoCode"],
         message: "isoCode is required for manual location"
       });
     }
     if (location.type === "auto" && location.isoCode) {
-      ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["isoCode"], message: "omit isoCode for auto location" });
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["isoCode"], message: "omit isoCode for auto location" });
     }
   });
   MonitoringValueOperators = [
@@ -738,81 +670,81 @@ var init_schemas = __esm(() => {
     "WITHIN_LAST_DAYS"
   ];
   MonitoringValuelessOperators = ["IS_NULL", "IS_NOT_NULL", "IS_EMPTY", "IS_NOT_EMPTY"];
-  MonitoringConditionOperatorSchema = z3.enum([...MonitoringValueOperators, ...MonitoringValuelessOperators]);
-  MonitoringConditionSchema = z3.object({
-    type: z3.enum(["SINGLE", "ANY"]),
-    field: z3.string().trim().min(1).optional(),
+  MonitoringConditionOperatorSchema = z.enum([...MonitoringValueOperators, ...MonitoringValuelessOperators]);
+  MonitoringConditionSchema = z.object({
+    type: z.enum(["SINGLE", "ANY"]),
+    field: z.string().trim().min(1).optional(),
     operator: MonitoringConditionOperatorSchema,
-    value: z3.union([z3.string(), z3.number(), z3.boolean()]).optional()
+    value: z.union([z.string(), z.number(), z.boolean()]).optional()
   }).strict().superRefine((condition, ctx) => {
     if (condition.type === "SINGLE" && !condition.field) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z.ZodIssueCode.custom,
         path: ["field"],
         message: "field is required for SINGLE conditions"
       });
     }
     const needsValue = MonitoringValueOperators.includes(condition.operator);
     if (needsValue && condition.value === undefined) {
-      ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["value"], message: `${condition.operator} requires a value` });
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["value"], message: `${condition.operator} requires a value` });
     }
     if (!needsValue && condition.value !== undefined) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z.ZodIssueCode.custom,
         path: ["value"],
         message: `${condition.operator} does not accept a value`
       });
     }
   });
-  MonitoringSchema = z3.object({
-    fields: z3.preprocess(coerceArray(), z3.array(z3.object({
-      fieldName: z3.string().trim().min(1),
-      operator: z3.enum(["changed", "added", "removed"]),
-      isKeyField: z3.preprocess(coerceBoolean(), z3.boolean()).optional()
+  MonitoringSchema = z.object({
+    fields: z.preprocess(coerceArray(), z.array(z.object({
+      fieldName: z.string().trim().min(1),
+      operator: z.enum(["changed", "added", "removed"]),
+      isKeyField: z.preprocess(coerceBoolean(), z.boolean()).optional()
     }).strict()).min(1)),
-    conditions: z3.object({
-      logicalOperator: z3.enum(["AND", "OR"]),
-      conditions: z3.preprocess(coerceArray(), z3.array(MonitoringConditionSchema).min(1))
+    conditions: z.object({
+      logicalOperator: z.enum(["AND", "OR"]),
+      conditions: z.preprocess(coerceArray(), z.array(MonitoringConditionSchema).min(1))
     }).strict().optional()
   }).strict();
   urlInputShape = {
-    url: z3.string().optional().describe("Single URL - prefer using 'urls' instead. If both are provided, 'urls' takes precedence."),
-    urls: z3.preprocess(coerceArray(true), z3.array(z3.string()).min(1)).optional().describe("Starting URLs for the workflow (array of strings). Also accepts a single URL string.")
+    url: z.string().optional().describe("Single URL - prefer using 'urls' instead. If both are provided, 'urls' takes precedence."),
+    urls: z.preprocess(coerceArray(true), z.array(z.string()).min(1)).optional().describe("Starting URLs for the workflow (array of strings). Also accepts a single URL string.")
   };
-  extractionPromptInput = z3.string().optional();
+  extractionPromptInput = z.string().optional();
   extractionInputShape = {
-    name: z3.string().optional().describe("Optional name for the workflow"),
-    entity: z3.string().optional().describe("Entity name for extraction (e.g., 'Product', 'Job Posting')"),
-    schema: z3.preprocess(coerceArray(), z3.array(z3.object(SchemaFieldShape).strict())).optional().describe("Extraction schema fields. If omitted, the AI agent auto-detects the schema. When you do supply fields, mark the one that identifies a record with isKey - change detection needs it.")
+    name: z.string().optional().describe("Optional name for the workflow"),
+    entity: z.string().optional().describe("Entity name for extraction (e.g., 'Product', 'Job Posting')"),
+    schema: z.preprocess(coerceArray(), z.array(z.object(SchemaFieldShape).strict())).optional().describe("Extraction schema fields. If omitted, the AI agent auto-detects the schema. When you do supply fields, mark the one that identifies a record with isKey - change detection needs it.")
   };
-  webhookAuthShape = z3.object({
-    type: z3.enum(["bearer", "basic", "header"]).describe("Authentication type"),
-    token: z3.string().optional().describe("Bearer token (required for 'bearer' type)"),
-    username: z3.string().optional().describe("Username (required for 'basic' type)"),
-    password: z3.string().optional().describe("Password (required for 'basic' type)"),
-    headers: z3.object({}).passthrough().optional().describe("Custom headers as key-value pairs (required for 'header' type)")
+  webhookAuthShape = z.object({
+    type: z.enum(["bearer", "basic", "header"]).describe("Authentication type"),
+    token: z.string().optional().describe("Bearer token (required for 'bearer' type)"),
+    username: z.string().optional().describe("Username (required for 'basic' type)"),
+    password: z.string().optional().describe("Password (required for 'basic' type)"),
+    headers: z.object({}).passthrough().optional().describe("Custom headers as key-value pairs (required for 'header' type)")
   }).optional().describe("Authentication configuration for the webhook endpoint");
-  notificationChannelsSchema = z3.object({
-    email: z3.object({
-      recipients: z3.array(z3.string().email()).optional().describe("Email addresses to notify. Omit to use account default email.")
+  notificationChannelsSchema = z.object({
+    email: z.object({
+      recipients: z.array(z.string().email()).optional().describe("Email addresses to notify. Omit to use account default email.")
     }).optional().describe("Send email notifications. Pass {} for account default email, or {recipients: [...]} for custom addresses."),
-    webhook: z3.object({
-      url: z3.string().url().describe("Webhook endpoint URL"),
-      httpMethod: z3.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method (defaults to POST)"),
+    webhook: z.object({
+      url: z.string().url().describe("Webhook endpoint URL"),
+      httpMethod: z.enum(["POST", "GET", "PUT", "PATCH"]).optional().describe("HTTP method (defaults to POST)"),
       auth: webhookAuthShape
     }).optional().describe("Send notifications via HTTP webhook"),
-    slack: z3.object({
-      webhookUrl: z3.string().url().optional().describe("Slack incoming webhook URL (legacy)"),
-      slackChannelId: z3.string().optional().describe("Slack channel ID from OAuth integration (e.g. C01ABCDEF)"),
-      slackChannelName: z3.string().optional().describe("Slack channel name (e.g. #alerts)")
+    slack: z.object({
+      webhookUrl: z.string().url().optional().describe("Slack incoming webhook URL (legacy)"),
+      slackChannelId: z.string().optional().describe("Slack channel ID from OAuth integration (e.g. C01ABCDEF)"),
+      slackChannelName: z.string().optional().describe("Slack channel name (e.g. #alerts)")
     }).optional().describe("Send notifications to a Slack channel. Use slackChannelId/slackChannelName for OAuth integration, or webhookUrl for legacy incoming webhooks."),
-    websocket: z3.boolean().optional().describe("Enable WebSocket notifications for programmatic real-time consumption")
+    websocket: z.boolean().optional().describe("Enable WebSocket notifications for programmatic real-time consumption")
   });
   notificationsInputShape = {
-    notifications: z3.preprocess(coerceJson(), notificationChannelsSchema.optional()).optional().describe("Optional notification channels to alert when data changes.")
+    notifications: z.preprocess(coerceJson(), notificationChannelsSchema.optional()).optional().describe("Optional notification channels to alert when data changes.")
   };
   requiredNotificationsInputShape = {
-    notifications: z3.preprocess(coerceJson(), notificationChannelsSchema).describe("Notification channels to alert when data changes.")
+    notifications: z.preprocess(coerceJson(), notificationChannelsSchema).describe("Notification channels to alert when data changes.")
   };
   DATA_FILTER_OPERATORS = [
     "EQUALS",
@@ -837,10 +769,10 @@ var init_schemas = __esm(() => {
   ];
   DATA_FILTER_VALUELESS_OPERATORS = new Set(["IS_NULL", "IS_NOT_NULL", "IS_EMPTY", "IS_NOT_EMPTY"]);
   DATA_FILTER_LIST_OPERATORS = new Set(["IN", "NOT_IN"]);
-  DataFilterSchema = z3.object({
-    field: z3.string().trim().min(1).describe("Field name from the workflow schema; one nested level is allowed, e.g. classification.match"),
-    operator: z3.preprocess((val) => typeof val === "string" ? val.trim().toUpperCase() : val, z3.enum(DATA_FILTER_OPERATORS)),
-    value: z3.union([z3.string(), z3.number(), z3.boolean(), z3.array(z3.union([z3.string(), z3.number()]))]).optional().describe("Omit for IS_NULL, IS_NOT_NULL, IS_EMPTY, IS_NOT_EMPTY; an array for IN/NOT_IN; days for WITHIN_LAST_DAYS")
+  DataFilterSchema = z.object({
+    field: z.string().trim().min(1).describe("Field name from the workflow schema; one nested level is allowed, e.g. classification.match"),
+    operator: z.preprocess((val) => typeof val === "string" ? val.trim().toUpperCase() : val, z.enum(DATA_FILTER_OPERATORS)),
+    value: z.union([z.string(), z.number(), z.boolean(), z.array(z.union([z.string(), z.number()]))]).optional().describe("Omit for IS_NULL, IS_NOT_NULL, IS_EMPTY, IS_NOT_EMPTY; an array for IN/NOT_IN; days for WITHIN_LAST_DAYS")
   }).strict().superRefine((filter, ctx) => {
     if (DATA_FILTER_VALUELESS_OPERATORS.has(filter.operator)) {
       if (filter.value !== undefined) {
@@ -865,9 +797,259 @@ var init_schemas = __esm(() => {
       });
     }
   });
-  dataFiltersInput = z3.preprocess(normalizeDataFilters, z3.array(DataFilterSchema).optional()).optional().describe('Row filters, e.g. [{"field":"title","operator":"CONTAINS","value":"Manager"}]. Multiple filters are combined with OR. BEFORE, AFTER and WITHIN_LAST_DAYS only apply to DATE/DATETIME fields.');
+  dataFiltersInput = z.preprocess(normalizeDataFilters, z.array(DataFilterSchema).optional()).optional().describe('Row filters, e.g. [{"field":"title","operator":"CONTAINS","value":"Manager"}]. Multiple filters are combined with OR. BEFORE, AFTER and WITHIN_LAST_DAYS only apply to DATE/DATETIME fields.');
 });
 
+// src/tools/shared/output-schemas.ts
+import { z as z2 } from "zod";
+var apiField, nullableString, PaginationOutput, workflowStatusFields, WorkflowRowOutput, ListWorkflowsOutput, GetWorkflowOutput, FetchDataOutput, ASSISTANT_ACTIVITIES, WorkflowAssistantOutput, AssistantTimelineOutput, AssistantAnswerOutput, AssistantControlOutput, WorkflowStrategyOutput;
+var init_output_schemas = __esm(() => {
+  init_schemas();
+  apiField = z2.unknown().optional();
+  nullableString = z2.string().nullable();
+  PaginationOutput = portable(z2.object({
+    totalCount: z2.number().optional(),
+    hasMore: z2.boolean(),
+    limit: z2.number().optional(),
+    skip: z2.number().optional(),
+    offset: z2.number().optional(),
+    page: z2.number().optional(),
+    totalPages: z2.number().optional(),
+    nextCursor: nullableString.optional(),
+    next: z2.record(z2.string(), z2.unknown()).optional()
+  }).loose());
+  workflowStatusFields = {
+    status: z2.string(),
+    badges: z2.array(z2.object({ kind: z2.string(), status: z2.string(), label: z2.string() }).loose()),
+    group: nullableString,
+    reviewReason: z2.object({ code: z2.string(), explanation: z2.string() }).loose().nullable(),
+    execution: apiField,
+    assistantState: apiField,
+    workspaceActivity: apiField
+  };
+  WorkflowRowOutput = z2.object({
+    id: apiField,
+    name: apiField,
+    dashboardUrl: z2.string(),
+    ...workflowStatusFields,
+    state: nullableString,
+    displayState: nullableString,
+    runState: nullableString,
+    urls: apiField,
+    totalRecords: apiField,
+    startedAt: apiField,
+    finishedAt: apiField,
+    createdAt: apiField,
+    assistant: z2.object({
+      eligible: z2.boolean(),
+      session: z2.object({ id: z2.string(), threadId: apiField, status: apiField }).loose().nullable()
+    }).loose(),
+    template: z2.object({ id: z2.string(), pinnedVersion: apiField, latestVersion: apiField, isOutdated: z2.boolean() }).loose().nullable(),
+    realtime: z2.object({ enabled: z2.boolean(), lastDataChangedAt: apiField, health: apiField }).loose(),
+    awaitingUserInput: apiField
+  }).loose();
+  ListWorkflowsOutput = portable(z2.object({ workflows: z2.array(WorkflowRowOutput), pagination: PaginationOutput }).loose());
+  GetWorkflowOutput = portable(z2.object({
+    id: z2.string(),
+    name: apiField,
+    dashboardUrl: z2.string(),
+    description: apiField,
+    ...workflowStatusFields,
+    state: nullableString,
+    displayState: nullableString,
+    runState: nullableString,
+    urls: apiField,
+    prompt: nullableString,
+    intentSource: z2.enum(["extraction_spec", "legacy_prompt"]).nullable(),
+    extractionSpec: apiField,
+    entity: apiField,
+    schema: apiField,
+    navigationMode: apiField,
+    assistantEligible: z2.boolean(),
+    assistantSessionId: apiField,
+    assistantThreadId: apiField,
+    assistantSessionStatus: apiField,
+    assistant: z2.object({ eligible: z2.boolean(), sessionId: apiField, threadId: apiField, sessionStatus: apiField }).loose(),
+    template: z2.object({
+      id: apiField,
+      name: apiField,
+      version: apiField,
+      controlledParts: z2.array(z2.string()),
+      hasSchemaValidationRules: apiField
+    }).loose().nullable(),
+    updateInterval: apiField,
+    schedules: apiField,
+    scheduleTimezone: apiField,
+    nextInvocation: apiField,
+    location: apiField,
+    limit: apiField,
+    tags: apiField,
+    totalRecords: apiField,
+    job: z2.object({ id: apiField }).loose().nullable(),
+    startedAt: apiField,
+    finishedAt: apiField,
+    estimatedFinishedAtUtc: apiField,
+    errors: apiField,
+    createdAt: apiField,
+    notificationConfig: apiField,
+    channelCounts: apiField,
+    realtime: z2.object({ lastDataChangedAt: apiField, observerHealth: apiField }).loose().nullable()
+  }).loose());
+  FetchDataOutput = portable(z2.object({
+    data: z2.array(z2.record(z2.string(), z2.unknown())),
+    pagination: PaginationOutput,
+    totalCount: z2.number().optional(),
+    hint: z2.string().optional()
+  }).loose());
+  ASSISTANT_ACTIVITIES = [
+    "unsupported",
+    "not_started",
+    "working",
+    "waiting_for_input",
+    "idle",
+    "interrupted",
+    "failed",
+    "closed",
+    "unknown"
+  ];
+  WorkflowAssistantOutput = portable(z2.object({
+    workflowId: z2.string(),
+    assistantEligible: z2.boolean(),
+    sessionId: nullableString,
+    threadId: apiField,
+    sessionStatus: apiField,
+    activity: z2.enum(ASSISTANT_ACTIVITIES),
+    canAcceptUpdate: z2.boolean(),
+    isTerminal: z2.boolean(),
+    paused: apiField,
+    pause: apiField,
+    pendingQuestion: apiField
+  }).loose());
+  AssistantTimelineOutput = portable(z2.object({
+    workflowId: z2.string(),
+    sessionId: apiField,
+    items: z2.array(z2.unknown()),
+    pagination: PaginationOutput,
+    dashboardUrl: z2.string()
+  }).loose());
+  AssistantAnswerOutput = portable(z2.object({
+    success: z2.literal(true),
+    workflowId: z2.string(),
+    sessionId: z2.string(),
+    threadId: apiField,
+    questionId: z2.string(),
+    message: z2.string()
+  }).loose());
+  AssistantControlOutput = portable(z2.object({
+    success: z2.boolean(),
+    status: z2.literal("accepted"),
+    action: z2.enum(["interrupt", "resume", "stop"]),
+    workflowId: z2.string(),
+    sessionId: z2.string(),
+    delivery: apiField,
+    jobId: apiField,
+    message: z2.string()
+  }).loose());
+  WorkflowStrategyOutput = portable(z2.object({
+    workflowId: z2.string(),
+    sessionId: nullableString,
+    source: z2.enum(["assistant_build", "workflow_metadata"]).nullable(),
+    status: z2.enum(["ready", "building", "unavailable"]),
+    strategy: apiField,
+    message: z2.string().optional()
+  }).loose());
+});
+
+// src/tools/shared/pagination.ts
+import { z as z3 } from "zod";
+function limitInput(options) {
+  const range = `limit must be a whole number from 1 to ${options.max}`;
+  const overMax = `${range}. ${options.overMaxHint ?? "Page with pagination.next."}`;
+  return z3.preprocess(coerceNumber(), z3.number().int(range).min(1, range).max(options.max, overMax)).optional().describe(`${options.noun} per page, 1-${options.max} (default ${options.defaultLimit})`);
+}
+function offsetInput(param, noun) {
+  const range = `${param} must be a whole number from 0 to ${MAX_OFFSET}`;
+  return z3.preprocess(coerceNumber(), z3.number().int(range).min(0, range).max(MAX_OFFSET, range)).optional().describe(`Number of ${noun} to skip (default 0)`);
+}
+function pageInput() {
+  const range = `page must be a whole number from 1 to ${MAX_PAGE}`;
+  return z3.preprocess(coerceNumber(), z3.number().int(range).min(1, range).max(MAX_PAGE, range)).optional().describe("Page number, 1-based (default 1)");
+}
+function nextArgs(args, patch) {
+  const next = {};
+  for (const [key, value] of Object.entries({ ...args, ...patch })) {
+    if (value !== undefined)
+      next[key] = value;
+  }
+  return next;
+}
+function withTotal(totalCount, hasMore) {
+  return totalCount !== undefined ? { totalCount, hasMore } : { hasMore };
+}
+function offsetPage(options) {
+  const nextOffset = options.offset + options.returned;
+  const more = options.hasMore ?? (options.totalCount !== undefined ? nextOffset < options.totalCount : options.returned >= options.limit);
+  const hasMore = options.returned > 0 && more;
+  const meta = withTotal(options.totalCount, hasMore);
+  meta.limit = options.limit;
+  meta[options.param] = options.offset;
+  if (hasMore)
+    meta.next = nextArgs(options.args, { [options.param]: nextOffset, limit: options.limit });
+  return meta;
+}
+function numberedPage(options) {
+  const more = options.totalPages !== undefined ? options.page < options.totalPages : options.totalCount !== undefined ? options.page * options.limit < options.totalCount : options.returned >= options.limit;
+  const hasMore = options.returned > 0 && more;
+  const meta = withTotal(options.totalCount, hasMore);
+  meta.limit = options.limit;
+  meta.page = options.page;
+  if (options.totalPages !== undefined)
+    meta.totalPages = options.totalPages;
+  if (hasMore)
+    meta.next = nextArgs(options.args, { page: options.page + 1, limit: options.limit });
+  return meta;
+}
+function cursorPage(options) {
+  const cursor = typeof options.nextCursor === "string" && options.nextCursor.length > 0 ? options.nextCursor : null;
+  const meta = { hasMore: options.hasMore && cursor !== null, nextCursor: cursor };
+  if (meta.hasMore)
+    meta.next = nextArgs(options.args, { cursor });
+  return meta;
+}
+function completeList(totalCount) {
+  return { totalCount, hasMore: false };
+}
+var MAX_OFFSET = 1e6, MAX_PAGE = 1e5;
+var init_pagination = () => {};
+
+// src/tools/shared/results.ts
+function asStructuredObject(data) {
+  return data !== null && !Array.isArray(data) ? data : { result: data };
+}
+function structuredResult(data, extra = []) {
+  const structuredContent = asStructuredObject(data);
+  return {
+    structuredContent,
+    content: [{ type: "text", text: JSON.stringify(structuredContent) }, ...extra]
+  };
+}
+function jsonResult(data) {
+  return structuredResult(data);
+}
+function textOnlyResult(data, extra = []) {
+  const structuredContent = asStructuredObject(data);
+  return { content: [{ type: "text", text: JSON.stringify(structuredContent) }, ...extra] };
+}
+function errorResult(message, details = {}) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message, ...details }) }],
+    isError: true
+  };
+}
+function withExtraContent(result, ...blocks) {
+  return { ...result, content: [...result.content, ...blocks] };
+}
+
 // src/tools/assistant.ts
 import { FREEFORM_ASSISTANT_ANSWER_KEY } from "@kadoa/node-sdk";
 import { z as z4 } from "zod";
@@ -2390,13 +2572,13 @@ function registerTemplateTools(server, ctx, helpers) {
     description: `Publish a new version of a template. Versions capture the full workflow config: prompt, schema, and notifications. All fields are optional - include only what this version should set.
 
 ` + "THIS IS HOW YOU EDIT A TEMPLATE'S PROMPT OR SCHEMA. Published versions are immutable, so 'changing the template prompt' means publishing a new version here and then calling `apply_template_version` to push it onto linked workflows. " + "`update_template` only renames a template; it cannot touch prompt or schema.",
-    inputSchema: withoutDefIds(strictSchema({
+    inputSchema: strictSchema({
       templateId: z10.string().min(1).describe("The template ID to publish a version for"),
       prompt: z10.string().optional().describe("User prompt to copy into workflow config"),
       schemaId: z10.string().optional().describe("Existing schema ID to reference (mutually exclusive with schemaFields)"),
       schemaFields: z10.preprocess(coerceArray(), z10.array(z10.preprocess(normalizeTemplateSchemaField, z10.object(TemplateSchemaFieldShape).strict()))).optional().describe("Inline schema fields to create a new schema (mutually exclusive with schemaId)"),
       schemaEntity: z10.string().optional().describe("Entity name for the inline schema"),
-      schemaValidationRules: z10.preprocess((val) => stripSchemaValidationAttribution(coerceJson()(val)), SchemaValidationRulesSchema).optional().describe('Per-field schema validation rules keyed by field name. Each rule uses kind STRING, NUMBER, OTHER, OBJECT, or ARRAY and nested rules are supported. Edit attribution is stamped server-side, so send only rule values. Example: { "price": { "kind": "NUMBER", "minimum": { "value": 0 } } }. Not inherited from prior versions - omitting this on a new version drops any rules the previous version had.'),
+      schemaValidationRules: z10.preprocess((val) => stripSchemaValidationAttribution(coerceJson()(val)), SchemaValidationRulesSchema).optional().describe("Per-field schema validation rules keyed by field name. Each value is an object with a required `kind` and optional rules for that kind; unknown keys are rejected. " + "Every kind accepts presence and uniqueness, each { target: integer 0-100 in steps of 20 } (expected percentage of rows with a value / a unique value). " + "STRING: minLength, maxLength, minHtmlElements, maxHtmlElements, each { value: integer >= 0 }; format, one of " + '{ kind: "FORMAT", source: { kind: "PRESET", preset: url | email | phone | date | datetime | time | uuid | slug } or { kind: "CUSTOM", pattern: regex string } }, ' + '{ kind: "FREE_TEXT", charset: { kind: "PRESET", preset: natural_language | alphanumeric | alpha } }, or ' + '{ kind: "LIST", source: { kind: "PRESET", preset: language2 | country2 | country3 | currency3 | month3 | usState2 } or { kind: "CUSTOM", values: [non-empty strings] } }. ' + "NUMBER: minimum and maximum, each { value: number }; maxDecimalPlaces { value: integer 0-16 }. " + "OTHER: only presence and uniqueness. " + "OBJECT: properties (required), a map of nested field name to rule. " + "ARRAY: minItems, maxItems, each { value: integer >= 0 }; items, the rule for each element. " + 'Examples: { "price": { "kind": "NUMBER", "minimum": { "value": 0 } } }; { "email": { "kind": "STRING", "format": { "kind": "FORMAT", "source": { "kind": "PRESET", "preset": "email" } } } }. ' + "Edit attribution is stamped server-side, so send only rule values. Not inherited from prior versions - omitting this on a new version drops any rules the previous version had."),
       notifications: z10.preprocess(coerceArray(), z10.array(z10.object({
         eventType: z10.string().describe("Notification event type"),
         eventConfiguration: z10.preprocess(coerceJson(), z10.record(z10.string(), z10.unknown())).optional(),
@@ -2412,7 +2594,7 @@ function registerTemplateTools(server, ctx, helpers) {
           expressions: z10.preprocess(coerceArray(true), z10.array(z10.string())).optional().describe("Cron expressions when type='cron' (e.g. '0 8 * * 2')")
         }))).optional().describe("Schedule specs. Required when interval='CUSTOM'.")
       })).optional().describe("Template-controlled scheduling for linked workflows ({interval, schedules}). Linked workflows inherit and cannot override this when set.")
-    })),
+    }),
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
   }, withErrorHandling("create_template_version", async (args) => {
     const { templateId, schemaValidationRules, ...rest } = args;
@@ -2662,49 +2844,109 @@ var init_variables = __esm(() => {
   init_schemas();
 });
 
-// src/tools/workflows.ts
-import { WorkflowStatusFilter } from "@kadoa/node-sdk";
-import { z as z12 } from "zod";
+// src/tools/shared/workflow-status.ts
+function reviewReasonExplanation(reason) {
+  return reason && REVIEW_REASON_EXPLANATIONS[reason] || UNKNOWN_REVIEW_REASON;
+}
 function isRealTimeInterval(interval) {
   return interval?.toUpperCase().replace("-", "_") === "REAL_TIME";
 }
-function deriveStatusLabel(workflow) {
-  const ds = workflow.displayState ?? workflow.state;
-  switch (ds) {
-    case "ACTIVE":
-      if (isRealTimeInterval(workflow.updateInterval))
-        return "Running";
-      if (!workflow.updateInterval || workflow.updateInterval === "only once")
-        return "Complete";
-      return "Scheduled";
-    case "RUNNING":
-      return "Running";
-    case "VALIDATING":
-      return "Validating";
-    case "FAILED":
-      return "Failed";
-    case "PAUSED":
-      return "Paused";
-    case "SETUP":
-      return "Sample Processing";
-    case "QUEUED":
-      return "Queued";
-    case "PENDING_START":
-      return "Not Started";
-    case "PREVIEW":
-      return "Pending Review";
-    case "DEGRADED":
-      return "Degraded";
-    case "DELETED":
-      return "Deleted";
-    case "COMPLIANCE_REVIEW":
-      return "Compliance Review";
-    case "COMPLIANCE_REJECTED":
-      return "Rejected";
-    default:
-      return ds ?? "Unknown";
+function fallbackStatusCode(w) {
+  const ds = w.displayState ?? w.state ?? null;
+  if (ds === "ACTIVE") {
+    if (w.isRealTime === true || isRealTimeInterval(w.updateInterval))
+      return "RUNNING";
+    return w.updateInterval && !["ONLY_ONCE", "only once"].includes(w.updateInterval) ? "SCHEDULED" : "COMPLETE";
   }
+  if (ds === "VALIDATING")
+    return "AWAITING_REVIEW";
+  return ds;
+}
+function labelFor(code, previewReady) {
+  const label = WORKFLOW_STATUS_LABELS[code === "PREVIEW" && previewReady ? "PREVIEW_READY" : code];
+  if (label)
+    return label;
+  console.error(`[workflow-status] unmapped workflow status, passing through verbatim: ${code}`);
+  return code;
+}
+function workflowStatusLabel(w) {
+  const code = w.presentation?.status ?? fallbackStatusCode(w);
+  if (!code)
+    return "Unknown";
+  return labelFor(code, w.availableActions?.approve?.allowed === true);
+}
+function workflowStatusView(w) {
+  const previewReady = w.availableActions?.approve?.allowed === true;
+  return {
+    status: workflowStatusLabel(w),
+    badges: (w.presentation?.badges ?? []).map((b) => ({
+      kind: b.kind,
+      status: b.status,
+      label: labelFor(b.status, previewReady)
+    })),
+    group: w.presentation?.group ?? null,
+    reviewReason: w.reviewReason ? { code: w.reviewReason, explanation: reviewReasonExplanation(w.reviewReason) } : null
+  };
 }
+function runStatusLabel(state) {
+  if (!state)
+    return "Unknown";
+  return RUN_STATE_LABELS[state] ?? state;
+}
+var REVIEW_STATUS_LABEL = "Verifying data", WORKFLOW_STATUS_LABELS, REVIEW_REASON_EXPLANATIONS, UNKNOWN_REVIEW_REASON = "Kadoa's quality or compliance checks selected this run for review.", RUN_STATE_LABELS;
+var init_workflow_status = __esm(() => {
+  WORKFLOW_STATUS_LABELS = {
+    ASSISTANT_WORKING: "Agent working",
+    AWAITING_REVIEW: REVIEW_STATUS_LABEL,
+    COMPLETE: "Complete",
+    COMPLIANCE_REJECTED: "Rejected",
+    COMPLIANCE_REVIEW: "Compliance review",
+    DEGRADED: "Degraded",
+    DELETED: "Deleted",
+    DRAFT: "Draft",
+    ERROR: "Failed",
+    FAILED: "Failed",
+    IN_SUPPORT: "In support",
+    NOT_SUPPORTED: "Not supported",
+    PAUSED: "Paused",
+    PENDING_START: "Not started",
+    PREVIEW: "Preview",
+    PREVIEW_READY: "Preview ready",
+    QUEUED: "Queued",
+    REPLY_NEEDED: "Reply needed",
+    RUNNING: "Running",
+    SCHEDULED: "Scheduled",
+    SETUP: "Setup",
+    STOPPED: "Stopped",
+    UPDATE_FAILED: "Update failed",
+    UPDATING: "Updating"
+  };
+  REVIEW_REASON_EXPLANATIONS = {
+    COMPLIANCE_REVIEW: "This run triggered a compliance check before delivery.",
+    HARD_FAIL: "An error stopped this run from completing normally.",
+    TRANSFORMATION_REPAIR_REQUIRED: "A data transformation could not be fixed automatically.",
+    MINIMUM_HUMAN_APPROVALS: "Kadoa's quality checks selected this run for review before delivery.",
+    DATA_QUALITY_SCHEMA_ADHERENCE: "The extracted data did not match this workflow's fields and data types.",
+    DATA_QUALITY_SCHEMA_VALIDATION: "Extracted values did not match this workflow's validation rules.",
+    DATA_QUALITY_COMPLETENESS: "The extracted record count did not match the expected source count.",
+    DATA_QUALITY_SEMANTIC_PLAUSIBILITY: "Some extracted values look unusual for their fields.",
+    ROW_COUNT_CHANGED: "This run's row count changed significantly.",
+    WORKFLOW_REVISION_DRIFT: "This run no longer matches the workflow's current setup.",
+    ZERO_RESULTS: "The source returned no data."
+  };
+  RUN_STATE_LABELS = {
+    FINISHED: "Success",
+    IN_PROGRESS: "Running",
+    VALIDATING: REVIEW_STATUS_LABEL,
+    FAILED: "Failed",
+    FAILED_INSUFFICIENT_FUNDS: "Failed",
+    NOT_SUPPORTED: "Failed"
+  };
+});
+
+// src/tools/workflows.ts
+import { WorkflowStatusFilter } from "@kadoa/node-sdk";
+import { z as z12 } from "zod";
 function mapRunStatus(state) {
   switch (state) {
     case "FINISHED":
@@ -3120,7 +3362,7 @@ function registerWorkflowCoreTools(server, ctx, helpers, defaultProductType) {
   }));
   server.registerTool("list_workflows", {
     title: "List Workflows",
-    description: `List workflows with customer-visible status, raw workflow and run states, Assistant session availability, template version drift, realtime freshness or health, and awaitingUserInput when the requesting user must act. Uses one paginated list request; use get_workflow only when you need full details for a selected workflow. To answer "what needs my attention", pass statusFilters: ["group:attention"]; this returns exactly the dashboard's "Needs your attention" group. In group:attention, a row with awaitingUserInput.prompt is an Assistant question: use get_workflow_assistant then answer_workflow_assistant_question. A row with awaitingUserInput but no prompt is a setup the user left unfinished: use get_workflow_assistant to see where it stopped, then resume_workflow_assistant or request_workflow_update. A row with displayState PREVIEW and no awaitingUserInput is preview data: use approve_workflow. Workflows with an open support ticket are excluded from group:attention and appear under group:support.`,
+    description: `List workflows with customer-visible status, raw workflow and run states, Assistant session availability, template version drift, realtime freshness or health, and awaitingUserInput when the requesting user must act. Uses one paginated list request; use get_workflow only when you need full details for a selected workflow. To answer "what needs my attention", pass statusFilters: ["group:attention"]; this returns exactly the dashboard's "Needs your attention" group. In group:attention, a row with awaitingUserInput.prompt is an Assistant question: use get_workflow_assistant then answer_workflow_assistant_question. A row with awaitingUserInput but no prompt is a setup the user left unfinished: use get_workflow_assistant to see where it stopped, then resume_workflow_assistant or request_workflow_update. A row with status "Preview ready" is preview data ready to approve with approve_workflow; "Preview" means preview data exists but approval isn't available yet. Workflows with an open support ticket are excluded from group:attention and appear under group:support. badges[].label is exactly what the Kadoa dashboard displays (lifecycle, activity, and support badges, e.g. "Setup" + "Agent working"): use these labels when describing the workflow to the user. status is the one-line summary in dashboard wording (e.g. "Verifying data" = the latest run is held for quality review before delivery; see reviewReason for why).`,
     inputSchema: strictSchema({
       limit: limitInput({
         noun: "Workflows",
@@ -3158,10 +3400,13 @@ function registerWorkflowCoreTools(server, ctx, helpers, defaultProductType) {
         id: w.id,
         name: w.name,
         dashboardUrl: workflowDashboardUrl(w.id),
-        status: deriveStatusLabel(w),
+        ...workflowStatusView(w),
         state: w.state ?? null,
         displayState: w.displayState ?? null,
         runState: w.runState ?? null,
+        execution: w.execution ?? null,
+        assistantState: w.assistantState ?? null,
+        workspaceActivity: w.workspaceActivity ?? null,
         urls: w.urls,
         totalRecords: w.totalRecords,
         startedAt: w.startedAt,
@@ -3169,7 +3414,6 @@ function registerWorkflowCoreTools(server, ctx, helpers, defaultProductType) {
         createdAt: w.createdAt,
         assistant: {
           eligible: w.assistantEligible === true,
-          dataStale: w.dataStale === true,
           session: w.assistantSessionId ? {
             id: w.assistantSessionId,
             threadId: w.assistantThreadId ?? null,
@@ -3201,7 +3445,7 @@ function registerWorkflowCoreTools(server, ctx, helpers, defaultProductType) {
   }));
   server.registerTool("get_workflow", {
     title: "Get Workflow",
-    description: "Get canonical workflow details, including Assistant/session linkage, extraction intent, template-controlled parts, stale-data state, job/run state, schedule timezone, location, monitoring, validation, and realtime health. For Assistant-built workflows, extractionSpec - not the legacy prompt - is authoritative.",
+    description: 'Get canonical workflow details, including Assistant/session linkage, extraction intent, template-controlled parts, job/run state, schedule timezone, location, monitoring, and realtime health. For Assistant-built workflows, extractionSpec - not the legacy prompt - is authoritative. badges[].label is exactly what the Kadoa dashboard displays (lifecycle, activity, and support badges, e.g. "Setup" + "Agent working"): use these labels when describing the workflow to the user. status is the one-line summary in dashboard wording (e.g. "Verifying data" = the latest run is held for quality review before delivery; see reviewReason for why).',
     inputSchema: strictSchema({
       workflowId: z12.string().min(1).describe("The workflow ID")
     }),
@@ -3226,10 +3470,13 @@ function registerWorkflowCoreTools(server, ctx, helpers, defaultProductType) {
       name: workflow.name,
       dashboardUrl: workflowDashboardUrl(workflow.id ?? args.workflowId),
       description: workflow.description,
-      status: deriveStatusLabel(workflow),
+      ...workflowStatusView(workflow),
       state: workflow.state ?? null,
       displayState: workflow.displayState ?? null,
       runState: workflow.runState ?? null,
+      execution: workflow.execution ?? null,
+      assistantState: workflow.assistantState ?? null,
+      workspaceActivity: workflow.workspaceActivity ?? null,
       urls: workflow.urls,
       prompt: extractionSpec ? null : legacyPrompt,
       intentSource: extractionSpec ? "extraction_spec" : legacyPrompt ? "legacy_prompt" : null,
@@ -3237,7 +3484,6 @@ function registerWorkflowCoreTools(server, ctx, helpers, defaultProductType) {
       entity: workflow.entity,
       schema: workflow.schema,
       navigationMode: workflow.navigationMode,
-      dataStale: workflow.dataStale ?? false,
       assistantEligible: workflow.assistantEligible === true,
       assistantSessionId: workflow.assistantSessionId ?? null,
       assistantThreadId: workflow.assistantThreadId ?? null,
@@ -3280,8 +3526,6 @@ function registerWorkflowCoreTools(server, ctx, helpers, defaultProductType) {
       createdAt: workflow.createdAt,
       notificationConfig: workflow.notificationConfig,
       channelCounts: workflow.channelCounts ?? {},
-      dataValidation: workflow.dataValidation ?? null,
-      validationStatistics: workflow.validationStatistics ?? null,
       realtime: isRealtime ? {
         lastDataChangedAt: workflow.lastDataChangedAt ?? null,
         observerHealth: workflow.observerHealth ?? null
@@ -3381,7 +3625,7 @@ function registerWorkflowHistoryTools(server, ctx, helpers) {
   }));
   server.registerTool("list_workflow_runs", {
     title: "List Workflow Runs",
-    description: "List a workflow's execution run history - each run's status, start/finish time, " + "record count, and errors. Use to answer 'when did this last succeed?' " + "(status='success', limit=1) or 'recent success/failure pattern?'. Distinct from " + "get_workflow_history, which is the config audit log. `status` is normally " + "success | failed | in_progress; a run whose backend state this server does not " + "recognize reports that raw state verbatim, so treat any other value as unknown " + "rather than as a failure.",
+    description: "List a workflow's execution run history - each run's status, start/finish time, " + "record count, and errors. Use to answer 'when did this last succeed?' " + "(status='success', limit=1) or 'recent success/failure pattern?'. Distinct from " + "get_workflow_history, which is the config audit log. `status` is normally " + "success | failed | in_progress; a run whose backend state this server does not " + "recognize reports that raw state verbatim, so treat any other value as unknown " + "rather than as a failure. `label` is the dashboard's wording for the run " + "(Success, Failed, Running, or 'Verifying data' = held for quality review before delivery); " + "prefer it when describing a run to the user.",
     inputSchema: strictSchema({
       workflowId: z12.string().min(1).describe("The workflow ID"),
       status: z12.enum(["success", "failed", "in_progress"]).optional().describe("Filter runs by outcome"),
@@ -3400,6 +3644,7 @@ function registerWorkflowHistoryTools(server, ctx, helpers) {
     const runs = (response.workflowRuns ?? []).map((r) => ({
       id: r.id,
       status: mapRunStatus(r.state),
+      label: runStatusLabel(r.state),
       startedAt: r.startedAt,
       finishedAt: r.finishedAt,
       records: r.records,
@@ -3449,7 +3694,7 @@ function registerWorkflowRunTools(server, ctx, helpers) {
   const FETCH_DATA_MAX_LIMIT = 500;
   server.registerTool("fetch_data", {
     title: "Fetch Workflow Data",
-    description: "Get a PAGE of extracted data from a workflow. Use ONLY for previews, sorted/filtered slices, or explicit 'first N rows' / 'top N' queries (capped at 500 rows per call). Do NOT use this to retrieve a full dataset, 'all rows', or anything the user wants to analyze in Excel / pandas / duckdb - use export_data for those. Data is only available after the workflow run has completed (status is no longer 'Running' or 'Validating'). Do NOT poll or sleep-wait for completion.",
+    description: "Get a PAGE of extracted data from a workflow. Use ONLY for previews, sorted/filtered slices, or explicit 'first N rows' / 'top N' queries (capped at 500 rows per call). Do NOT use this to retrieve a full dataset, 'all rows', or anything the user wants to analyze in Excel / pandas / duckdb - use export_data for those. Data is only available after the workflow run has completed (status is no longer 'Running' or 'Verifying data'). Do NOT poll or sleep-wait for completion.",
     inputSchema: strictSchema({
       workflowId: z12.string().min(1).describe("The workflow ID"),
       limit: limitInput({
@@ -3611,7 +3856,7 @@ function registerWorkflowRunTools(server, ctx, helpers) {
     try {
       const workflow = await ctx.client.workflow.get(args.workflowId);
       workflowName = workflow.name || args.workflowId;
-      workflowStatus = deriveStatusLabel(workflow);
+      workflowStatus = workflowStatusLabel(workflow);
     } catch {}
     if (!args.confirmed) {
       return jsonResult({
@@ -3679,7 +3924,7 @@ function registerWorkflowRunTools(server, ctx, helpers) {
       timezone: z12.string().min(1).optional().describe("IANA timezone for cron schedules, for example America/New_York. A timezone-only update preserves existing cron expressions."),
       location: z12.preprocess(coerceJson(), LocationSchema).optional().describe("Scraping location: {type:'auto'} or {type:'manual', isoCode:'US'}"),
       monitoring: z12.preprocess(coerceJson(), MonitoringSchema).optional().describe("Complete monitoring replacement: fields to monitor and optional AND/OR conditions. Call get_workflow first because this replaces the existing monitoring configuration."),
-      limit: z12.preprocess(coerceNumber(), z12.number().positive().nullable()).optional().describe("Maximum records per run. Pass null to clear the limit and extract all rows.")
+      limit: z12.preprocess(coerceNumber(), z12.number().positive().nullable()).optional().describe("Maximum records per run; must be positive (greater than 0). Pass null to clear the limit and extract all rows.")
     }),
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
   }, withErrorHandling("update_workflow", async (args) => {
@@ -3723,6 +3968,7 @@ var init_workflows = __esm(() => {
   init_output_schemas();
   init_pagination();
   init_schemas();
+  init_workflow_status();
   WORKFLOW_AUDIT_WATCHED_KEYS = [
     "name",
     "tags",
@@ -4476,7 +4722,7 @@ async function createServer3(auth, options) {
       "Use list_changes and get_change to retrieve detected diffs from realtime monitoring workflows.",
       "List tools, plus fetch_data, get_workflow_history, and get_workflow_assistant_timeline, all return pagination {totalCount?, hasMore, next?}. When hasMore is true, call the same tool again with pagination.next as its arguments to get the next page. totalCount is present only when the total is known; never treat the page size as the total.",
       "Large results (fetch_data, get_workflow_history, get_change) are cut to whole rows or entries under about 80 KB and marked truncated: true with a hint; follow pagination.next, narrow the filters, or use export_data, and never conclude the data ends there.",
-      "When the user asks what needs their attention, call list_workflows with statusFilters group:attention. A row with awaitingUserInput.prompt is the Assistant's pending question: answer it with get_workflow_assistant then answer_workflow_assistant_question. A row with awaitingUserInput but no prompt is a setup the user left unfinished: use get_workflow_assistant to see where it stopped, then resume_workflow_assistant or request_workflow_update. A row with displayState PREVIEW and no awaitingUserInput is preview data to review or approve with approve_workflow. Workflows with an open support ticket are excluded from group:attention and appear under group:support.",
+      `When the user asks what needs their attention, call list_workflows with statusFilters group:attention. A row with awaitingUserInput.prompt is the Assistant's pending question: answer it with get_workflow_assistant then answer_workflow_assistant_question. A row with awaitingUserInput but no prompt is a setup the user left unfinished: use get_workflow_assistant to see where it stopped, then resume_workflow_assistant or request_workflow_update. A row with status "Preview ready" is preview data ready to approve with approve_workflow; "Preview" means preview data exists but approval isn't available yet. Workflows with an open support ticket are excluded from group:attention and appear under group:support.`,
       "",
       "Schema tips: Use descriptive field names and examples. Group related data under one entity.",
       "The AI agent uses the schema + prompt to understand what to extract - a detailed prompt with a comprehensive schema produces better results than multiple simple workflows.",
@@ -4954,7 +5200,7 @@ async function createServer(auth, options) {
       "Use list_changes and get_change to retrieve detected diffs from realtime monitoring workflows.",
       "List tools, plus fetch_data, get_workflow_history, and get_workflow_assistant_timeline, all return pagination {totalCount?, hasMore, next?}. When hasMore is true, call the same tool again with pagination.next as its arguments to get the next page. totalCount is present only when the total is known; never treat the page size as the total.",
       "Large results (fetch_data, get_workflow_history, get_change) are cut to whole rows or entries under about 80 KB and marked truncated: true with a hint; follow pagination.next, narrow the filters, or use export_data, and never conclude the data ends there.",
-      "When the user asks what needs their attention, call list_workflows with statusFilters group:attention. A row with awaitingUserInput.prompt is the Assistant's pending question: answer it with get_workflow_assistant then answer_workflow_assistant_question. A row with awaitingUserInput but no prompt is a setup the user left unfinished: use get_workflow_assistant to see where it stopped, then resume_workflow_assistant or request_workflow_update. A row with displayState PREVIEW and no awaitingUserInput is preview data to review or approve with approve_workflow. Workflows with an open support ticket are excluded from group:attention and appear under group:support.",
+      `When the user asks what needs their attention, call list_workflows with statusFilters group:attention. A row with awaitingUserInput.prompt is the Assistant's pending question: answer it with get_workflow_assistant then answer_workflow_assistant_question. A row with awaitingUserInput but no prompt is a setup the user left unfinished: use get_workflow_assistant to see where it stopped, then resume_workflow_assistant or request_workflow_update. A row with status "Preview ready" is preview data ready to approve with approve_workflow; "Preview" means preview data exists but approval isn't available yet. Workflows with an open support ticket are excluded from group:attention and appear under group:support.`,
       "",
       "Schema tips: Use descriptive field names and examples. Group related data under one entity.",
       "The AI agent uses the schema + prompt to understand what to extract - a detailed prompt with a comprehensive schema produces better results than multiple simple workflows.",