snow-flow 10.0.1-dev.424 → 10.0.1-dev.427

package/src/servicenow/servicenow-mcp-unified/tools/flow-designer/snow_manage_flow.ts

@@ -1,17 +1,3 @@
-/**
- * snow_manage_flow - Complete Flow Designer lifecycle management
- *
- * Create, list, get, update, activate, deactivate, delete and publish
- * Flow Designer flows and subflows.
- *
- * For create/create_subflow: uses a Scheduled Job (sysauto_script) that
- * runs GlideRecord server-side, ensuring sys_hub_flow_version records are
- * created, flow_definition is set, and sn_fd engine registration is
- * attempted. Falls back to Table API if the scheduled job fails.
- *
- * All other actions (list, get, update, activate, etc.) use the Table API.
- */
-
 import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
 import { getAuthenticatedClient } from '../../shared/auth.js';
 import { createSuccessResult, createErrorResult, SnowFlowError, ErrorType } from '../../shared/error-handler.js';
@@ -31,1209 +17,404 @@ function isSysId(value: string): boolean {
   return /^[a-f0-9]{32}$/.test(value);
 }
 
-/** Escape a string for safe embedding in ES5 single-quoted script */
-function escForScript(s: string): string {
-  return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n').replace(/\r/g, '');
+// ── GraphQL Flow Designer helpers ─────────────────────────────────────
+
+function jsToGraphQL(val: any): string {
+  if (val === null || val === undefined) return 'null';
+  if (typeof val === 'string') return JSON.stringify(val);
+  if (typeof val === 'number' || typeof val === 'bigint') return String(val);
+  if (typeof val === 'boolean') return val ? 'true' : 'false';
+  if (Array.isArray(val)) return '[' + val.map(jsToGraphQL).join(', ') + ']';
+  if (typeof val === 'object') {
+    return '{' + Object.entries(val).map(([k, v]) => k + ': ' + jsToGraphQL(v)).join(', ') + '}';
+  }
+  return String(val);
 }
 
-/**
- * Create a flow via a ServiceNow Scheduled Job (sysauto_script).
- *
- * This executes server-side GlideRecord code that CAN set computed fields
- * like `latest_version`, which the Table API silently ignores.
- *
- * Strategy:
- *   1. Create a sys_properties record to receive the result
- *   2. Create a sysauto_script record (run_type=once, run_start=now)
- *   3. Poll the property every 2s for up to 30s
- *   4. Clean up both records
- *   5. Return the result (flow sys_id, version sys_id, tier used)
- */
-async function createFlowViaScheduledJob(
+function generateUUID(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+  });
+}
+
+async function executeFlowPatchMutation(
   client: any,
-  params: {
-    name: string;
-    description: string;
-    internalName: string;
-    isSubflow: boolean;
-    category: string;
-    runAs: string;
-    shouldActivate: boolean;
-    triggerType?: string;
-    triggerTable?: string;
-    triggerCondition?: string;
-    activities?: Array<{ name: string; type?: string; inputs?: any }>;
-    inputs?: Array<{ name: string; label?: string; type?: string; mandatory?: boolean; default_value?: string }>;
-    outputs?: Array<{ name: string; label?: string; type?: string }>;
-    flowDefinition?: any;
+  flowPatch: any,
+  responseFields: string
+): Promise<any> {
+  const mutation = 'mutation { global { snFlowDesigner { flow(flowPatch: ' +
+    jsToGraphQL(flowPatch) + ') { id ' + responseFields + ' __typename } __typename } __typename } }';
+  const resp = await client.post('/api/now/graphql', { variables: {}, query: mutation });
+  const errors = resp.data?.errors;
+  if (errors && errors.length > 0) {
+    throw new Error('GraphQL error: ' + JSON.stringify(errors[0].message || errors[0]));
   }
-): Promise<{
-  success: boolean;
-  flowSysId?: string;
-  versionSysId?: string;
-  tierUsed?: string;
-  latestVersionSet?: boolean;
-  latestVersionValue?: string;
-  steps?: any;
-  error?: string;
-}> {
-  var resultPropName = 'snow_flow.factory_result.' + Date.now();
-  var flowDefStr = params.flowDefinition ? JSON.stringify(params.flowDefinition) : '';
-
-  // Build the server-side ES5 script
-  var script = [
-    "(function() {",
-    "  var PROP = '" + escForScript(resultPropName) + "';",
-    "  var r = { success: false, steps: {}, tier_used: null };",
-    "  try {",
-    "    var flowName = '" + escForScript(params.name) + "';",
-    "    var flowDesc = '" + escForScript(params.description) + "';",
-    "    var intName = '" + escForScript(params.internalName) + "';",
-    "    var isSubflow = " + (params.isSubflow ? "true" : "false") + ";",
-    "    var flowCat = '" + escForScript(params.category) + "';",
-    "    var runAs = '" + escForScript(params.runAs) + "';",
-    "    var activate = " + (params.shouldActivate ? "true" : "false") + ";",
-    "    var trigType = '" + escForScript(params.triggerType || 'manual') + "';",
-    "    var trigTable = '" + escForScript(params.triggerTable || '') + "';",
-    "    var trigCondition = '" + escForScript(params.triggerCondition || '') + "';",
-    "    var flowDefStr = '" + escForScript(flowDefStr) + "';",
-    "    var activitiesJson = '" + escForScript(JSON.stringify(params.activities || [])) + "';",
-    "    var inputsJson = '" + escForScript(JSON.stringify(params.inputs || [])) + "';",
-    "    var outputsJson = '" + escForScript(JSON.stringify(params.outputs || [])) + "';",
-    "    var activities = []; try { activities = JSON.parse(activitiesJson); } catch(e) {}",
-    "    var inputs = []; try { inputs = JSON.parse(inputsJson); } catch(e) {}",
-    "    var outputs = []; try { outputs = JSON.parse(outputsJson); } catch(e) {}",
-    "    var flowSysId = null;",
-    "    var verSysId = null;",
-    "",
-    // ── TIER 1: sn_fd.FlowDesigner API ──
-    "    try {",
-    "      if (typeof sn_fd !== 'undefined' && sn_fd.FlowDesigner && typeof sn_fd.FlowDesigner.createFlow === 'function') {",
-    "        var fdR = sn_fd.FlowDesigner.createFlow({ name: flowName, description: flowDesc, type: isSubflow ? 'subflow' : 'flow', category: flowCat, run_as: runAs });",
-    "        if (fdR) {",
-    "          flowSysId = (typeof fdR === 'object' ? (fdR.sys_id || (fdR.getValue ? fdR.getValue('sys_id') : null)) : fdR) + '';",
-    "          r.tier_used = 'sn_fd_api';",
-    "          r.success = true;",
-    "          r.steps.tier1 = { success: true };",
-    "          if (activate && typeof sn_fd.FlowDesigner.publishFlow === 'function') {",
-    "            try { sn_fd.FlowDesigner.publishFlow(flowSysId); r.steps.publish = { success: true }; }",
-    "            catch(pe) { r.steps.publish = { success: false, error: pe + '' }; }",
-    "          }",
-    "        }",
-    "      }",
-    "    } catch(t1e) { r.steps.tier1 = { success: false, error: t1e.getMessage ? t1e.getMessage() : t1e + '' }; }",
-    "",
-    // ── TIER 2: GlideRecord ──
-    // Reference flow analysis:
-    //   - latest_snapshot points to sys_hub_flow_snapshot (NOT version, NOT JSON)
-    //   - flow_definition on flow record = null
-    //   - latest_version = null (normal)
-    // Pipeline: flow → version → snapshot → set latest_snapshot on flow
-    "    if (!flowSysId) {",
-    "      try {",
-    "        var f = new GlideRecord('sys_hub_flow');",
-    "        f.initialize();",
-    "        f.setValue('name', flowName); f.setValue('description', flowDesc);",
-    "        f.setValue('internal_name', intName); f.setValue('category', flowCat);",
-    "        f.setValue('run_as', runAs); f.setValue('active', false);",
-    "        f.setValue('status', 'draft'); f.setValue('validated', true);",
-    "        f.setValue('type', isSubflow ? 'subflow' : 'flow');",
-    "        flowSysId = f.insert();",
-    "        r.steps.flow_insert = { success: !!flowSysId, sys_id: flowSysId + '' };",
-    "        if (flowSysId) {",
-    // Version record
-    "          var v = new GlideRecord('sys_hub_flow_version');",
-    "          v.initialize();",
-    "          v.setValue('flow', flowSysId); v.setValue('name', '1.0');",
-    "          v.setValue('version', '1.0'); v.setValue('state', 'draft');",
-    "          v.setValue('active', true); v.setValue('compile_state', 'draft');",
-    "          v.setValue('is_current', true);",
-    "          if (flowDefStr) { v.setValue('flow_definition', flowDefStr); }",
-    "          verSysId = v.insert();",
-    "          r.steps.version_insert = { success: !!verSysId, sys_id: verSysId + '' };",
-    "",
-    // No snapshot/latest_snapshot — let the engine create these via Business Rule post-compile
-    "          r.tier_used = 'gliderecord_scheduled'; r.success = true;",
-    "        }",
-    "      } catch(t2e) { r.steps.tier2 = { success: false, error: t2e.getMessage ? t2e.getMessage() : t2e + '' }; }",
-    "    }",
-    "",
-    // ── Trigger, action, variable creation (runs for any tier) ──
-    "    if (flowSysId) {",
-    // Trigger — precise search with prefix matching + fallback without action_type
-    "      if (!isSubflow && trigType !== 'manual') {",
-    "        try {",
-    "          var trigDefId = null;",
-    "          var trigDefName = '';",
-    "          var trigSearchLog = [];",
-    "",
-    // Search 1: exact prefix 'sn_fd.trigger.' (standard Flow Designer naming)
-    "          var exactNames = {",
-    "            'record_created': ['sn_fd.trigger.record_created', 'global.sn_fd.trigger.record_created'],",
-    "            'record_updated': ['sn_fd.trigger.record_updated', 'global.sn_fd.trigger.record_updated'],",
-    "            'scheduled': ['sn_fd.trigger.scheduled', 'global.sn_fd.trigger.scheduled']",
-    "          };",
-    "          var exactCandidates = exactNames[trigType] || [];",
-    "          for (var ec = 0; ec < exactCandidates.length; ec++) {",
-    "            var tgE = new GlideRecord('sys_hub_action_type_definition');",
-    "            tgE.addQuery('internal_name', exactCandidates[ec]);",
-    "            tgE.setLimit(1); tgE.query();",
-    "            if (tgE.next()) {",
-    "              trigDefId = tgE.getUniqueValue(); trigDefName = tgE.getValue('name');",
-    "              trigSearchLog.push('exact:' + exactCandidates[ec] + ':found');",
-    "              break;",
-    "            }",
-    "            trigSearchLog.push('exact:' + exactCandidates[ec] + ':not_found');",
-    "          }",
-    "",
-    // Search 2: prefix STARTSWITH 'sn_fd.trigger' (catches variations)
-    "          if (!trigDefId) {",
-    "            var tgP = new GlideRecord('sys_hub_action_type_definition');",
-    "            tgP.addQuery('internal_name', 'STARTSWITH', 'sn_fd.trigger');",
-    "            tgP.setLimit(10); tgP.query();",
-    "            var prefixMatches = [];",
-    "            while (tgP.next()) {",
-    "              prefixMatches.push(tgP.getValue('internal_name'));",
-    "              if (!trigDefId && (tgP.getValue('internal_name') + '').indexOf(trigType.replace('record_', '')) > -1) {",
-    "                trigDefId = tgP.getUniqueValue(); trigDefName = tgP.getValue('name');",
-    "              }",
-    "            }",
-    "            trigSearchLog.push('prefix_sn_fd.trigger:[' + prefixMatches.join(',') + ']');",
-    "          }",
-    "",
-    // Search 3 removed — sys_hub_trigger_definition returned wrong defs (Proactive Analytics, DevOps)
-    "          if (!trigDefId) { trigSearchLog.push('no_exact_trigger_def_found'); }",
-    "",
-    // Create trigger instance — only set action_type if exact sn_fd.trigger.* match found
-    "          var trigInst = new GlideRecord('sys_hub_trigger_instance');",
-    "          trigInst.initialize();",
-    "          trigInst.setValue('flow', flowSysId);",
-    "          trigInst.setValue('name', trigType);",
-    "          trigInst.setValue('order', 0);",
-    "          trigInst.setValue('active', true);",
-    "          if (trigDefId) trigInst.setValue('action_type', trigDefId);",
-    "          if (trigTable) trigInst.setValue('table', trigTable);",
-    "          if (trigCondition) trigInst.setValue('condition', trigCondition);",
-    "          var trigId = trigInst.insert();",
-    "          r.steps.trigger = {",
-    "            success: !!trigId,",
-    "            sys_id: trigId + '',",
-    "            def_found: !!trigDefId,",
-    "            def_name: trigDefName || 'none (created without action_type)',",
-    "            search: trigSearchLog",
-    "          };",
-    "        } catch(te) { r.steps.trigger = { success: false, error: te.getMessage ? te.getMessage() : te + '' }; }",
-    "      }",
-    // Actions
-    "      var actionsCreated = 0;",
-    "      for (var ai = 0; ai < activities.length; ai++) {",
-    "        try {",
-    "          var act = activities[ai];",
-    "          var actDef = new GlideRecord('sys_hub_action_type_definition');",
-    "          actDef.addQuery('internal_name', 'CONTAINS', act.type || 'script');",
-    "          actDef.addOrCondition('name', 'CONTAINS', act.type || 'script'); actDef.query();",
-    "          var actInst = new GlideRecord('sys_hub_action_instance');",
-    "          actInst.initialize();",
-    "          actInst.setValue('flow', flowSysId); actInst.setValue('name', act.name || 'Action ' + (ai + 1));",
-    "          actInst.setValue('order', (ai + 1) * 100); actInst.setValue('active', true);",
-    "          if (actDef.next()) actInst.setValue('action_type', actDef.getUniqueValue());",
-    "          if (actInst.insert()) actionsCreated++;",
-    "        } catch(ae) {}",
-    "      }",
-    "      r.steps.actions = { success: true, created: actionsCreated, requested: activities.length };",
-    // Variables (subflows)
-    "      var varsCreated = 0;",
-    "      if (isSubflow) {",
-    "        for (var vi = 0; vi < inputs.length; vi++) {",
-    "          try { var inp = inputs[vi]; var fv = new GlideRecord('sys_hub_flow_variable'); fv.initialize();",
-    "            fv.setValue('flow', flowSysId); fv.setValue('name', inp.name); fv.setValue('label', inp.label || inp.name);",
-    "            fv.setValue('type', inp.type || 'string'); fv.setValue('mandatory', inp.mandatory || false);",
-    "            fv.setValue('default_value', inp.default_value || ''); fv.setValue('variable_type', 'input');",
-    "            if (fv.insert()) varsCreated++;",
-    "          } catch(ve) {}",
-    "        }",
-    "        for (var vo = 0; vo < outputs.length; vo++) {",
-    "          try { var ot = outputs[vo]; var ov = new GlideRecord('sys_hub_flow_variable'); ov.initialize();",
-    "            ov.setValue('flow', flowSysId); ov.setValue('name', ot.name); ov.setValue('label', ot.label || ot.name);",
-    "            ov.setValue('type', ot.type || 'string'); ov.setValue('variable_type', 'output');",
-    "            if (ov.insert()) varsCreated++;",
-    "          } catch(ve) {}",
-    "        }",
-    "      }",
-    "      r.steps.variables = { success: true, created: varsCreated };",
-    // Engine compilation delegated to Business Rule (runs in Flow Designer context)
-    "      r.steps.engine = 'deferred_to_business_rule';",
-    "    }",
-    "",
-    "    r.flow_sys_id = flowSysId ? flowSysId + '' : null;",
-    "    r.version_sys_id = verSysId ? verSysId + '' : null;",
-    // ── Final check: read back our flow's latest_snapshot to confirm ──
-    "    if (flowSysId) {",
-    "      var cf = new GlideRecord('sys_hub_flow');",
-    "      if (cf.get(flowSysId)) {",
-    "        r.latest_version_value = cf.getValue('latest_version') + '';",
-    "        r.our_latest_snapshot = cf.getValue('latest_snapshot') + '';",
-    "        r.our_latest_snapshot_length = (cf.getValue('latest_snapshot') + '').length;",
-    "      }",
-    "    }",
-    "  } catch(e) { r.success = false; r.error = e.getMessage ? e.getMessage() : e + ''; }",
-    "  gs.setProperty(PROP, JSON.stringify(r));",
-    "})();"
-  ].join('\n');
+  return resp.data?.data?.global?.snFlowDesigner?.flow || resp.data;
+}
 
-  try {
-    // 1. Create result property
-    await client.post('/api/now/table/sys_properties', {
-      name: resultPropName,
-      value: 'pending',
-      type: 'string',
-      description: 'Snow-Flow temp result (auto-cleanup)'
-    });
-
-    // 2. Create scheduled job (run immediately)
-    var runStart = new Date().toISOString().replace('T', ' ').substring(0, 19);
-    var jobResp = await client.post('/api/now/table/sysauto_script', {
-      name: 'Snow-Flow Flow Factory (auto-cleanup)',
-      script: script,
-      run_type: 'once',
-      run_start: runStart,
-      active: true
-    });
-    var jobSysId = jobResp.data.result?.sys_id;
-
-    // 3. Poll for result (adaptive: 5×1s + 5×2s + 5×3s = 30s max)
-    for (var i = 0; i < 15; i++) {
-      var delay = i < 5 ? 1000 : i < 10 ? 2000 : 3000;
-      await new Promise(resolve => setTimeout(resolve, delay));
-      var propResp = await client.get('/api/now/table/sys_properties', {
+async function lookupDefinitionParams(client: any, defSysId: string): Promise<any[]> {
+  const paramTables = ['sys_hub_action_input', 'sys_hub_action_input_param', 'sys_hub_action_type_param'];
+  for (const table of paramTables) {
+    try {
+      const resp = await client.get('/api/now/table/' + table, {
         params: {
-          sysparm_query: 'name=' + resultPropName,
-          sysparm_fields: 'sys_id,value',
-          sysparm_limit: 1
+          sysparm_query: 'model=' + defSysId + '^ORaction_type=' + defSysId,
+          sysparm_fields: 'sys_id,name,element,label,internal_type,type,type_label,order,mandatory,readonly,maxsize,data_structure,reference,reference_display,ref_qual,choice_option,column_name,default_value,use_dependent,dependent_on,internal_link,attributes,sys_class_name',
+          sysparm_limit: 50
         }
       });
-      var propRecord = propResp.data.result?.[0];
-      var propValue = propRecord?.value;
-      if (propValue && propValue !== 'pending') {
-        // Got result — clean up
-        try { if (propRecord?.sys_id) await client.delete('/api/now/table/sys_properties/' + propRecord.sys_id); } catch (_) {}
-        try { if (jobSysId) await client.delete('/api/now/table/sysauto_script/' + jobSysId); } catch (_) {}
-        try {
-          var parsed = JSON.parse(propValue);
-          return {
-            success: parsed.success,
-            flowSysId: parsed.flow_sys_id,
-            versionSysId: parsed.version_sys_id,
-            tierUsed: parsed.tier_used,
-            latestVersionSet: parsed.latest_version_set,
-            latestVersionValue: parsed.latest_version_value,
-            steps: parsed.steps,
-            error: parsed.error
-          };
-        } catch (_) {
-          return { success: false, error: 'Invalid JSON from scheduled job: ' + propValue.substring(0, 200) };
-        }
-      }
+      const results = resp.data.result;
+      if (results && results.length > 0) return results;
+    } catch (_) {}
+  }
+  return [];
+}
+
+function buildGraphQLInput(p: any, defaultValue?: any): any {
+  const name = p.name || p.element || '';
+  const type = p.internal_type || p.type || 'string';
+  const isMandatory = p.mandatory === 'true' || p.mandatory === true;
+  const order = parseInt(p.order) || 100;
+  const defVal = defaultValue !== undefined ? defaultValue : (p.default_value || '');
+  return {
+    id: p.sys_id || '',
+    name,
+    label: p.label || name,
+    internalType: type,
+    mandatory: isMandatory,
+    order,
+    valueSysId: '',
+    field_name: name,
+    type,
+    children: [],
+    displayValue: { value: '' },
+    value: type === 'conditions'
+      ? { schemaless: false, schemalessValue: '', value: '^EQ' }
+      : defVal
+        ? { schemaless: false, schemalessValue: '', value: String(defVal) }
+        : { value: '' },
+    parameter: {
+      id: p.sys_id || '',
+      label: p.label || name,
+      name,
+      type,
+      type_label: p.type_label || '',
+      order,
+      extended: false,
+      mandatory: isMandatory,
+      readonly: p.readonly === 'true' || p.readonly === true,
+      maxsize: parseInt(p.maxsize) || 80,
+      data_structure: p.data_structure || '',
+      reference: p.reference || '',
+      reference_display: p.reference_display || '',
+      ref_qual: p.ref_qual || '',
+      choiceOption: p.choice_option || '',
+      table: '',
+      columnName: p.column_name || '',
+      defaultValue: p.default_value || '',
+      use_dependent: p.use_dependent === 'true' || p.use_dependent === true,
+      dependent_on: p.dependent_on || '',
+      internal_link: p.internal_link || '',
+      show_ref_finder: false,
+      local: false,
+      attributes: p.attributes || '',
+      sys_class_name: p.sys_class_name || '',
+      children: []
     }
+  };
+}
 
-    // Timeout — clean up
+async function addTriggerViaGraphQL(
+  client: any,
+  flowId: string,
+  triggerType: string,
+  table?: string,
+  condition?: string
+): Promise<{ success: boolean; triggerId?: string; steps?: any; error?: string }> {
+  const steps: any = {};
+
+  const triggerMap: Record<string, { type: string; name: string; triggerType: string; defNames: string[] }> = {
+    'record_created': { type: 'record_create', name: 'Created', triggerType: 'Record',
+      defNames: ['sn_fd.trigger.record_create', 'global.sn_fd.trigger.record_create', 'sn_fd.trigger.record_created', 'global.sn_fd.trigger.record_created'] },
+    'record_updated': { type: 'record_update', name: 'Updated', triggerType: 'Record',
+      defNames: ['sn_fd.trigger.record_update', 'global.sn_fd.trigger.record_update', 'sn_fd.trigger.record_updated', 'global.sn_fd.trigger.record_updated'] },
+    'record_create_or_update': { type: 'record_create_or_update', name: 'Created or Updated', triggerType: 'Record',
+      defNames: ['sn_fd.trigger.record_create_or_update', 'global.sn_fd.trigger.record_create_or_update'] },
+    'scheduled': { type: 'scheduled', name: 'Scheduled', triggerType: 'Scheduled',
+      defNames: ['sn_fd.trigger.scheduled', 'global.sn_fd.trigger.scheduled'] },
+  };
+
+  const config = triggerMap[triggerType] || triggerMap['record_create_or_update'];
+
+  let trigDefId: string | null = null;
+  for (const defName of config.defNames) {
     try {
-      var cleanProp = await client.get('/api/now/table/sys_properties', {
-        params: { sysparm_query: 'name=' + resultPropName, sysparm_fields: 'sys_id', sysparm_limit: 1 }
+      const resp = await client.get('/api/now/table/sys_hub_action_type_definition', {
+        params: { sysparm_query: 'internal_name=' + defName, sysparm_fields: 'sys_id', sysparm_limit: 1 }
       });
-      if (cleanProp.data.result?.[0]?.sys_id) await client.delete('/api/now/table/sys_properties/' + cleanProp.data.result[0].sys_id);
+      trigDefId = resp.data.result?.[0]?.sys_id || null;
+      if (trigDefId) break;
     } catch (_) {}
-    try { if (jobSysId) await client.delete('/api/now/table/sysauto_script/' + jobSysId); } catch (_) {}
-    return { success: false, error: 'Scheduled job timed out after 30s — scheduler may be slow on this instance' };
-  } catch (e: any) {
-    return { success: false, error: 'Scheduled job setup failed: ' + (e.message || e) };
   }
-}
-
-// ── Business Rule compile: create a temp BR on sys_hub_flow to trigger engine compile ──
-
-/**
- * After the scheduled job creates the flow records, this function:
- * 1. Creates a temporary Business Rule on sys_hub_flow (after update)
- * 2. PATCHes the flow record to trigger the BR
- * 3. The BR runs in the Flow Designer engine context and tries to compile/publish
- * 4. Reads the result from a sys_property
- * 5. Cleans up both the BR and the property
- *
- * Why a BR instead of scheduled job? BRs on sys_hub_flow run in the Flow Designer
- * application scope, which may have access to APIs (like sn_fd.FlowDesigner) that
- * aren't available in global-scope scheduled jobs.
- */
-async function tryCompileViaBusinessRule(
-  client: any,
-  flowSysId: string,
-  flowDescription: string
-): Promise<{ success: boolean; result?: any; error?: string }> {
-  var brResultProp = 'snow_flow.br_compile.' + Date.now();
-
-  // The BR script: runs server-side in sys_hub_flow context
-  // Probes all available APIs and tries compile/publish
-  var brScript = [
-    "(function executeRule(current, previous) {",
-    "  var PROP = '" + escForScript(brResultProp) + "';",
-    "  var r = { fired: true, context: 'business_rule', flow_id: current.sys_id + '' };",
-    "  try {",
-    // Probe sn_fd namespace
-    "    if (typeof sn_fd !== 'undefined') {",
-    "      r.sn_fd = 'available';",
-    "      var snfdKeys = [];",
-    "      try { for (var k in sn_fd) { snfdKeys.push(k + ':' + typeof sn_fd[k]); } } catch(e) {}",
-    "      r.sn_fd_keys = snfdKeys;",
-    "",
-    // Try FlowDesigner (not available in scheduled job, might be available in BR)
-    "      if (typeof sn_fd.FlowDesigner !== 'undefined') {",
-    "        r.FlowDesigner = 'available';",
-    "        var fdMethods = [];",
-    "        try { for (var fm in sn_fd.FlowDesigner) { if (typeof sn_fd.FlowDesigner[fm] === 'function') fdMethods.push(fm); } } catch(e) {}",
-    "        r.FlowDesigner_methods = fdMethods;",
-    "        try {",
-    "          sn_fd.FlowDesigner.publishFlow(current.sys_id + '');",
-    "          r.publishFlow = 'success';",
-    "        } catch(pe) { r.publishFlow = (pe.getMessage ? pe.getMessage() : pe + '').substring(0, 200); }",
-    "      } else { r.FlowDesigner = 'unavailable'; }",
-    "",
-    // Try FlowAPI
-    "      if (typeof sn_fd.FlowAPI !== 'undefined') {",
-    "        r.FlowAPI = 'available';",
-    "        var faMethods = [];",
-    "        try { for (var am in sn_fd.FlowAPI) { if (typeof sn_fd.FlowAPI[am] === 'function') faMethods.push(am); } } catch(e) {}",
-    "        r.FlowAPI_methods = faMethods;",
-    "        try {",
-    "          var compRes = sn_fd.FlowAPI.compile(current.sys_id + '');",
-    "          r.compile = compRes ? (compRes + '').substring(0, 200) : 'success (null return)';",
-    "        } catch(ce) { r.compile = 'error: ' + (ce.getMessage ? ce.getMessage() : ce + '').substring(0, 200); }",
-    "        try {",
-    "          var pubRes = sn_fd.FlowAPI.publish(current.sys_id + '');",
-    "          r.publish = pubRes ? (pubRes + '').substring(0, 200) : 'success (null return)';",
-    "        } catch(pue) { r.publish = 'error: ' + (pue.getMessage ? pue.getMessage() : pue + '').substring(0, 200); }",
-    "      } else { r.FlowAPI = 'unavailable'; }",
-    "",
-    // Search for flow-related Script Includes
-    "      var si = new GlideRecord('sys_script_include');",
-    "      si.addQuery('name', 'CONTAINS', 'FlowDesigner');",
-    "      si.addOrCondition('name', 'CONTAINS', 'FlowCompiler');",
-    "      si.addOrCondition('name', 'CONTAINS', 'FlowPublish');",
-    "      si.addQuery('active', true);",
-    "      si.setLimit(15); si.query();",
-    "      r.script_includes = [];",
-    "      while (si.next()) {",
-    "        r.script_includes.push(si.getValue('name') + ' [api:' + si.getValue('api_name') + ', scope:' + si.getValue('sys_scope') + ']');",
-    "      }",
-    "",
-    // Try instantiating common Script Includes
-    "      var tryClasses = ['FlowDesignerScriptable', 'FlowDesignerService', 'FlowDesignerPublishService',",
-    "        'FlowDesignerCompileService', 'FlowDesignerActionService', 'sn_fd.FlowDesignerScriptable'];",
-    "      r.script_include_tests = {};",
-    "      for (var tc = 0; tc < tryClasses.length; tc++) {",
-    "        try {",
-    "          var cls = eval(tryClasses[tc]);",
-    "          if (typeof cls === 'function') {",
-    "            var inst = new cls();",
-    "            r.script_include_tests[tryClasses[tc]] = 'instantiated';",
-    // Try compile/publish methods on instance
-    "            if (typeof inst.compile === 'function') {",
-    "              try { inst.compile(current.sys_id + ''); r.script_include_tests[tryClasses[tc] + '.compile'] = 'success'; }",
-    "              catch(e) { r.script_include_tests[tryClasses[tc] + '.compile'] = (e + '').substring(0, 100); }",
-    "            }",
-    "            if (typeof inst.publishFlow === 'function') {",
-    "              try { inst.publishFlow(current.sys_id + ''); r.script_include_tests[tryClasses[tc] + '.publishFlow'] = 'success'; }",
-    "              catch(e) { r.script_include_tests[tryClasses[tc] + '.publishFlow'] = (e + '').substring(0, 100); }",
-    "            }",
-    "          } else { r.script_include_tests[tryClasses[tc]] = 'not a function: ' + typeof cls; }",
-    "        } catch(e) { r.script_include_tests[tryClasses[tc]] = 'error: ' + (e + '').substring(0, 100); }",
-    "      }",
-    "    } else { r.sn_fd = 'unavailable'; }",
-    "",
-    // Post-check: read back flow state
-    "    var post = new GlideRecord('sys_hub_flow');",
-    "    if (post.get(current.sys_id + '')) {",
-    "      r.post_latest_version = post.getValue('latest_version') + '';",
-    "      r.post_latest_snapshot = post.getValue('latest_snapshot') + '';",
-    "      r.post_status = post.getValue('status') + '';",
-    "    }",
-    "  } catch(topE) { r.error = (topE.getMessage ? topE.getMessage() : topE + '').substring(0, 300); }",
-    "  gs.setProperty(PROP, JSON.stringify(r));",
-    "})(current, previous);"
-  ].join('\n');
-
-  try {
-    // 1. Create result property
-    await client.post('/api/now/table/sys_properties', {
-      name: brResultProp,
-      value: 'pending',
-      type: 'string',
-      description: 'Snow-Flow BR compile result (auto-cleanup)'
-    });
-
-    // 2. Create temporary Business Rule on sys_hub_flow
-    var brResp = await client.post('/api/now/table/sys_script', {
-      name: 'Snow-Flow Auto-Compile (temp-cleanup)',
-      collection: 'sys_hub_flow',
-      when: 'after',
-      action_insert: false,
-      action_update: true,
-      action_delete: false,
-      active: true,
-      script: brScript,
-      order: 10000,
-      filter_condition: 'sys_id=' + flowSysId
-    });
-    var brSysId = brResp.data?.result?.sys_id;
-
-    // 3. PATCH the flow record to trigger the BR (tiny description change)
-    await new Promise(resolve => setTimeout(resolve, 1000)); // Let BR register
-    await client.patch('/api/now/table/sys_hub_flow/' + flowSysId, {
-      description: (flowDescription || '').trim() + ' '
-    });
-
-    // 4. Poll for result (5 attempts, 2s each = 10s max)
-    for (var i = 0; i < 5; i++) {
-      await new Promise(resolve => setTimeout(resolve, 2000));
-      var propResp = await client.get('/api/now/table/sys_properties', {
+  if (!trigDefId) {
+    try {
+      const resp = await client.get('/api/now/table/sys_hub_action_type_definition', {
         params: {
-          sysparm_query: 'name=' + brResultProp,
-          sysparm_fields: 'sys_id,value',
-          sysparm_limit: 1
+          sysparm_query: 'internal_nameSTARTSWITHsn_fd.trigger^internal_nameLIKE' + config.type,
+          sysparm_fields: 'sys_id,internal_name', sysparm_limit: 10
         }
       });
-      var propRecord = propResp.data.result?.[0];
-      var propValue = propRecord?.value;
-
-      if (propValue && propValue !== 'pending') {
-        // Got result — clean up
-        try { if (propRecord?.sys_id) await client.delete('/api/now/table/sys_properties/' + propRecord.sys_id); } catch (_) {}
-        try { if (brSysId) await client.delete('/api/now/table/sys_script/' + brSysId); } catch (_) {}
-
-        try {
-          return { success: true, result: JSON.parse(propValue) };
-        } catch (_) {
-          return { success: true, result: { raw: propValue.substring(0, 500) } };
-        }
+      for (const r of (resp.data.result || [])) {
+        if ((r.internal_name || '').indexOf(config.type) > -1) { trigDefId = r.sys_id; break; }
       }
-    }
-
-    // Timeout — clean up
-    try {
-      var cleanProp = await client.get('/api/now/table/sys_properties', {
-        params: { sysparm_query: 'name=' + brResultProp, sysparm_fields: 'sys_id', sysparm_limit: 1 }
-      });
-      if (cleanProp.data.result?.[0]?.sys_id) await client.delete('/api/now/table/sys_properties/' + cleanProp.data.result[0].sys_id);
     } catch (_) {}
-    try { if (brSysId) await client.delete('/api/now/table/sys_script/' + brSysId); } catch (_) {}
-
-    return { success: false, error: 'Business Rule did not fire within 10s — BR may not have registered or flow update was ignored' };
-  } catch (e: any) {
-    return { success: false, error: 'BR compile setup failed: ' + (e.message || e) };
   }
-}
+  if (!trigDefId) return { success: false, error: 'Trigger definition not found for: ' + triggerType, steps };
+  steps.def_lookup = { id: trigDefId };
 
-// ── Flow Factory (Scripted REST API bootstrap) ──────────────────────
-
-var FLOW_FACTORY_API_NAME = 'Snow-Flow Flow Factory';
-var FLOW_FACTORY_API_ID = 'flow_factory';
-var FLOW_FACTORY_CACHE_TTL = 300000; // 5 minutes
-
-var _flowFactoryCache: { apiSysId: string; namespace: string; timestamp: number } | null = null;
-var _bootstrapPromise: Promise<{ namespace: string; apiSysId: string }> | null = null;
-
-/**
- * ES5 GlideRecord script deployed as a Scripted REST API resource.
- * This runs server-side on ServiceNow and triggers all Business Rules,
- * unlike direct Table API inserts which skip sys_hub_flow_version creation.
- */
-/**
- * Discover script — GET /discover endpoint.
- * Probes which sn_fd APIs, methods and fields are available on this instance.
- */
-var FLOW_FACTORY_DISCOVER_SCRIPT = [
-  '(function process(/*RESTAPIRequest*/ request, /*RESTAPIResponse*/ response) {',
-  '  var r = {',
-  '    build_tag: gs.getProperty("glide.buildtag") || "unknown",',
-  '    build_name: gs.getProperty("glide.buildname") || "unknown",',
-  '    apis: {}, methods: {}, fields: {}',
-  '  };',
-  '  try { r.apis.sn_fd = typeof sn_fd !== "undefined" ? "available" : "unavailable"; } catch(e) { r.apis.sn_fd = "unavailable"; }',
-  '  var apiNames = ["FlowDesigner","FlowAPI","FlowPublisher","FlowCompiler"];',
-  '  for (var i = 0; i < apiNames.length; i++) {',
-  '    try {',
-  '      if (typeof sn_fd !== "undefined") { r.apis[apiNames[i]] = typeof sn_fd[apiNames[i]]; }',
-  '      else { r.apis[apiNames[i]] = "no_sn_fd"; }',
-  '    } catch(e) { r.apis[apiNames[i]] = "error:" + e; }',
-  '  }',
-  '  var globalNames = ["GlideFlowDesigner","FlowDesignerInternalAPI","FlowDesignerAPI"];',
-  '  for (var g = 0; g < globalNames.length; g++) {',
-  '    try {',
-  '      var gv = this[globalNames[g]];',
-  '      r.apis[globalNames[g]] = gv ? typeof gv : "undefined";',
-  '    } catch(e) { r.apis[globalNames[g]] = "error:" + e; }',
-  '  }',
-  '  try {',
-  '    if (typeof sn_fd !== "undefined" && sn_fd.FlowDesigner) {',
-  '      var fd = sn_fd.FlowDesigner;',
-  '      var mns = ["createFlow","publishFlow","activateFlow","compileFlow","createDraftFlow","getFlow"];',
-  '      for (var m = 0; m < mns.length; m++) { r.methods[mns[m]] = typeof fd[mns[m]]; }',
-  '    }',
-  '  } catch(e) { r.methods._error = e + ""; }',
-  '  try {',
-  '    var gr = new GlideRecord("sys_hub_flow_version");',
-  '    var fns = ["compiled_definition","compile_state","is_current","published_flow","flow_definition"];',
-  '    for (var f = 0; f < fns.length; f++) { r.fields[fns[f]] = gr.isValidField(fns[f]); }',
-  '  } catch(e) { r.fields._error = e + ""; }',
-  '  try {',
-  '    var br = new GlideRecord("sys_script");',
-  '    br.addQuery("collection","sys_hub_flow"); br.addQuery("active",true); br.query();',
-  '    r.flow_br_count = br.getRowCount();',
-  '    var brv = new GlideRecord("sys_script");',
-  '    brv.addQuery("collection","sys_hub_flow_version"); brv.addQuery("active",true); brv.query();',
-  '    r.version_br_count = brv.getRowCount();',
-  '  } catch(e) { r.br_error = e + ""; }',
-  '  response.setStatus(200);',
-  '  response.setBody(r);',
-  '})(request, response);'
-].join('\n');
-
-/**
- * Create script — POST /create endpoint.
- * Three-tier approach:
- *   Tier 1: sn_fd.FlowDesigner API (handles everything internally)
- *   Tier 2: GlideRecord INSERT as draft → UPDATE to published (triggers compilation BRs)
- *   Tier 3: Raw GlideRecord INSERT (last resort, may not register with engine)
- */
-var FLOW_FACTORY_SCRIPT = [
-  '(function process(/*RESTAPIRequest*/ request, /*RESTAPIResponse*/ response) {',
-  // ── Body parsing (3-method cascade) ──
-  '  var body = null;',
-  '  var parseLog = [];',
-  '  try {',
-  '    var ds = request.body.dataString;',
-  '    if (ds) { body = JSON.parse(ds + ""); parseLog.push("dataString:ok"); }',
-  '  } catch(e1) { parseLog.push("dataString:" + e1); }',
-  '  if (!body) {',
-  '    try {',
-  '      var d = request.body.data;',
-  '      if (d && typeof d === "object") { body = d; parseLog.push("data:ok"); }',
-  '      else if (d) { body = JSON.parse(d + ""); parseLog.push("data-parse:ok"); }',
-  '    } catch(e2) { parseLog.push("data:" + e2); }',
-  '  }',
-  '  if (!body) {',
-  '    try { body = JSON.parse(request.body + ""); parseLog.push("body-direct:ok"); }',
-  '    catch(e3) { parseLog.push("body-direct:" + e3); }',
-  '  }',
-  '  if (!body || typeof body !== "object") {',
-  '    response.setStatus(400);',
-  '    response.setBody({ success: false, error: "No parseable body", parseLog: parseLog, bodyType: typeof request.body });',
-  '    return;',
-  '  }',
-  '  var result = { success: false, steps: {}, tier_used: null, parseLog: parseLog };',
-  '',
-  '  try {',
-  '    var flowName = body.name || "Unnamed Flow";',
-  '    var isSubflow = body.type === "subflow";',
-  '    var flowDesc = body.description || flowName;',
-  '    var flowCategory = body.category || "custom";',
-  '    var runAs = body.run_as || "user";',
-  '    var shouldActivate = body.activate !== false;',
-  '    var triggerType = body.trigger_type || "manual";',
-  '    var triggerTable = body.trigger_table || "";',
-  '    var triggerCondition = body.trigger_condition || "";',
-  '    var activities = body.activities || [];',
-  '    var inputs = body.inputs || [];',
-  '    var outputs = body.outputs || [];',
-  '    var flowDef = body.flow_definition;',
-  '    var flowDefStr = flowDef ? (typeof flowDef === "string" ? flowDef : JSON.stringify(flowDef)) : "";',
-  '    var intName = flowName.toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");',
-  '',
-  '    var flowSysId = null;',
-  '    var verSysId = null;',
-  '',
-  // ── TIER 1: sn_fd.FlowDesigner API ──
-  '    try {',
-  '      if (typeof sn_fd !== "undefined" && sn_fd.FlowDesigner && typeof sn_fd.FlowDesigner.createFlow === "function") {',
-  '        var fdResult = sn_fd.FlowDesigner.createFlow({ name: flowName, description: flowDesc, type: isSubflow ? "subflow" : "flow", category: flowCategory, run_as: runAs });',
-  '        if (fdResult) {',
-  '          flowSysId = (typeof fdResult === "object" ? fdResult.sys_id || fdResult.getValue("sys_id") : fdResult) + "";',
-  '          result.tier_used = "sn_fd_api";',
-  '          result.steps.tier1 = { success: true, api: "sn_fd.FlowDesigner.createFlow" };',
-  '          if (shouldActivate && typeof sn_fd.FlowDesigner.publishFlow === "function") {',
-  '            try { sn_fd.FlowDesigner.publishFlow(flowSysId); result.steps.tier1_publish = { success: true }; }',
-  '            catch(pe) { result.steps.tier1_publish = { success: false, error: pe + "" }; }',
-  '          }',
-  '        }',
-  '      }',
-  '    } catch(t1e) { result.steps.tier1 = { success: false, error: t1e.getMessage ? t1e.getMessage() : t1e + "" }; }',
-  '',
-  // ── TIER 2: GlideRecord INSERT as draft → UPDATE to published ──
-  '    if (!flowSysId) {',
-  '      try {',
-  '        var flow = new GlideRecord("sys_hub_flow");',
-  '        flow.initialize();',
-  '        flow.setValue("name", flowName);',
-  '        flow.setValue("description", flowDesc);',
-  '        flow.setValue("internal_name", intName);',
-  '        flow.setValue("category", flowCategory);',
-  '        flow.setValue("run_as", runAs);',
-  '        flow.setValue("active", false);',
-  '        flow.setValue("status", "draft");',
-  '        flow.setValue("validated", true);',
-  '        flow.setValue("type", isSubflow ? "subflow" : "flow");',
-  '        if (flowDefStr) { flow.setValue("flow_definition", flowDefStr); flow.setValue("latest_snapshot", flowDefStr); }',
-  '        flowSysId = flow.insert();',
-  '        result.steps.flow_insert = { success: !!flowSysId, sys_id: flowSysId + "", as_draft: true };',
-  '',
-  '        if (flowSysId) {',
-  '          var ver = new GlideRecord("sys_hub_flow_version");',
-  '          ver.initialize();',
-  '          ver.setValue("flow", flowSysId);',
-  '          ver.setValue("name", "1.0");',
-  '          ver.setValue("version", "1.0");',
-  '          ver.setValue("state", "draft");',
-  '          ver.setValue("active", true);',
-  '          ver.setValue("compile_state", "draft");',
-  '          ver.setValue("is_current", true);',
-  '          if (flowDefStr) ver.setValue("flow_definition", flowDefStr);',
-  '          verSysId = ver.insert();',
-  '          result.steps.version_insert = { success: !!verSysId, sys_id: verSysId + "", as_draft: true };',
-  '',
-  '          if (verSysId) {',
-  '            var linkUpd = new GlideRecord("sys_hub_flow");',
-  '            if (linkUpd.get(flowSysId)) { linkUpd.setValue("latest_version", verSysId); linkUpd.update(); }',
-  '          }',
-  '',
-  '          if (shouldActivate) {',
-  '            var flowPub = new GlideRecord("sys_hub_flow");',
-  '            if (flowPub.get(flowSysId)) {',
-  '              flowPub.setValue("status", "published");',
-  '              flowPub.setValue("active", true);',
-  '              flowPub.update();',
-  '              result.steps.flow_publish_update = { success: true };',
-  '            }',
-  '            if (verSysId) {',
-  '              var verPub = new GlideRecord("sys_hub_flow_version");',
-  '              if (verPub.get(verSysId)) {',
-  '                verPub.setValue("state", "published");',
-  '                verPub.setValue("compile_state", "compiled");',
-  '                verPub.setValue("published_flow", flowSysId);',
-  '                verPub.update();',
-  '                result.steps.version_publish_update = { success: true };',
-  '              }',
-  '            }',
-  '          }',
-  '          result.tier_used = "gliderecord_draft_then_publish";',
-  '          result.success = true;',
-  '        }',
-  '      } catch(t2e) { result.steps.tier2 = { success: false, error: t2e.getMessage ? t2e.getMessage() : t2e + "" }; }',
-  '    }',
-  '',
-  // ── TIER 3: Raw GlideRecord INSERT (last resort) ──
-  '    if (!flowSysId) {',
-  '      try {',
-  '        var rawFlow = new GlideRecord("sys_hub_flow");',
-  '        rawFlow.initialize();',
-  '        rawFlow.setValue("name", flowName);',
-  '        rawFlow.setValue("description", flowDesc);',
-  '        rawFlow.setValue("internal_name", intName);',
-  '        rawFlow.setValue("category", flowCategory);',
-  '        rawFlow.setValue("run_as", runAs);',
-  '        rawFlow.setValue("active", shouldActivate);',
-  '        rawFlow.setValue("status", shouldActivate ? "published" : "draft");',
-  '        rawFlow.setValue("validated", true);',
-  '        rawFlow.setValue("type", isSubflow ? "subflow" : "flow");',
-  '        if (flowDefStr) { rawFlow.setValue("flow_definition", flowDefStr); rawFlow.setValue("latest_snapshot", flowDefStr); }',
-  '        flowSysId = rawFlow.insert();',
-  '        if (flowSysId) {',
-  '          var rawVer = new GlideRecord("sys_hub_flow_version");',
-  '          rawVer.initialize();',
-  '          rawVer.setValue("flow", flowSysId);',
-  '          rawVer.setValue("name", "1.0"); rawVer.setValue("version", "1.0");',
-  '          rawVer.setValue("state", shouldActivate ? "published" : "draft");',
-  '          rawVer.setValue("active", true); rawVer.setValue("compile_state", "compiled");',
-  '          rawVer.setValue("is_current", true);',
-  '          if (shouldActivate) rawVer.setValue("published_flow", flowSysId);',
-  '          if (flowDefStr) rawVer.setValue("flow_definition", flowDefStr);',
-  '          verSysId = rawVer.insert();',
-  '          if (verSysId) {',
-  '            var rawLink = new GlideRecord("sys_hub_flow");',
-  '            if (rawLink.get(flowSysId)) { rawLink.setValue("latest_version", verSysId); rawLink.update(); }',
-  '          }',
-  '          result.tier_used = "gliderecord_raw";',
-  '          result.success = true;',
-  '        }',
-  '      } catch(t3e) { result.steps.tier3 = { success: false, error: t3e.getMessage ? t3e.getMessage() : t3e + "" }; }',
-  '    }',
-  '',
-  // ── Common: trigger, actions, variables ──
-  '    if (flowSysId) {',
-  '      result.flow_sys_id = flowSysId + "";',
-  '      result.version_sys_id = verSysId ? verSysId + "" : null;',
-  '      result.version_created = !!verSysId;',
-  '',
-  '      if (!isSubflow && triggerType !== "manual") {',
-  '        try {',
-  '          var triggerMap = { "record_created": "sn_fd.trigger.record_created", "record_updated": "sn_fd.trigger.record_updated", "scheduled": "sn_fd.trigger.scheduled" };',
-  '          var trigIntName = triggerMap[triggerType] || "";',
-  '          if (trigIntName) {',
-  '            var trigDef = new GlideRecord("sys_hub_action_type_definition");',
-  '            trigDef.addQuery("internal_name", trigIntName); trigDef.query();',
-  '            if (trigDef.next()) {',
-  '              var trigInst = new GlideRecord("sys_hub_trigger_instance");',
-  '              trigInst.initialize();',
-  '              trigInst.setValue("flow", flowSysId); trigInst.setValue("action_type", trigDef.getUniqueValue());',
-  '              trigInst.setValue("name", triggerType); trigInst.setValue("order", 0); trigInst.setValue("active", true);',
-  '              if (triggerTable) trigInst.setValue("table", triggerTable);',
-  '              if (triggerCondition) trigInst.setValue("condition", triggerCondition);',
-  '              var trigSysId = trigInst.insert();',
-  '              result.steps.trigger = { success: !!trigSysId, sys_id: trigSysId + "" };',
-  '            } else { result.steps.trigger = { success: false, error: "Trigger def not found: " + trigIntName }; }',
-  '          }',
-  '        } catch(te) { result.steps.trigger = { success: false, error: te.getMessage ? te.getMessage() : te + "" }; }',
-  '      }',
-  '',
-  '      var actionsCreated = 0;',
-  '      for (var ai = 0; ai < activities.length; ai++) {',
-  '        try {',
-  '          var act = activities[ai];',
-  '          var actDef = new GlideRecord("sys_hub_action_type_definition");',
-  '          actDef.addQuery("internal_name", "CONTAINS", act.type || "script");',
-  '          actDef.addOrCondition("name", "CONTAINS", act.type || "script"); actDef.query();',
-  '          var actInst = new GlideRecord("sys_hub_action_instance");',
-  '          actInst.initialize();',
-  '          actInst.setValue("flow", flowSysId); actInst.setValue("name", act.name || "Action " + (ai + 1));',
-  '          actInst.setValue("order", (ai + 1) * 100); actInst.setValue("active", true);',
-  '          if (actDef.next()) actInst.setValue("action_type", actDef.getUniqueValue());',
-  '          if (actInst.insert()) actionsCreated++;',
-  '        } catch(ae) {}',
-  '      }',
-  '      result.steps.actions = { success: true, created: actionsCreated, requested: activities.length };',
-  '',
-  '      var varsCreated = 0;',
-  '      if (isSubflow) {',
-  '        for (var vi = 0; vi < inputs.length; vi++) {',
-  '          try { var inp = inputs[vi]; var fv = new GlideRecord("sys_hub_flow_variable"); fv.initialize();',
-  '            fv.setValue("flow",flowSysId); fv.setValue("name",inp.name); fv.setValue("label",inp.label||inp.name);',
-  '            fv.setValue("type",inp.type||"string"); fv.setValue("mandatory",inp.mandatory||false);',
-  '            fv.setValue("default_value",inp.default_value||""); fv.setValue("variable_type","input");',
-  '            if (fv.insert()) varsCreated++;',
-  '          } catch(ve) {}',
-  '        }',
-  '        for (var vo = 0; vo < outputs.length; vo++) {',
-  '          try { var out = outputs[vo]; var ov = new GlideRecord("sys_hub_flow_variable"); ov.initialize();',
-  '            ov.setValue("flow",flowSysId); ov.setValue("name",out.name); ov.setValue("label",out.label||out.name);',
-  '            ov.setValue("type",out.type||"string"); ov.setValue("variable_type","output");',
-  '            if (ov.insert()) varsCreated++;',
-  '          } catch(ve) {}',
-  '        }',
-  '      }',
-  '      result.steps.variables = { success: true, created: varsCreated };',
-  '    }',
-  '',
-  '    if (result.success) response.setStatus(201);',
-  '    else response.setStatus(500);',
-  '',
-  '  } catch (e) {',
-  '    result.success = false;',
-  '    result.error = e.getMessage ? e.getMessage() : e + "";',
-  '    response.setStatus(500);',
-  '  }',
-  '  response.setBody(result);',
-  '})(request, response);'
-].join('\n');
-
-/**
- * Resolve the REST API namespace for a sys_ws_definition record.
- *
- * Collects namespace candidates from multiple sources, then VERIFIES each
- * one via HTTP before accepting it. This prevents returning invalid values
- * like scope sys_ids or numeric identifiers that aren't valid URL namespaces.
- *
- * Verification: GET /api/{candidate}/{api_id}/discover
- *   - 200 = correct namespace, /discover endpoint works
- *   - 401/403 = correct namespace, auth issue
- *   - 405 = correct namespace, wrong HTTP method (endpoint exists)
- *   - 400/404 = wrong namespace or API not registered yet
- */
-async function resolveFactoryNamespace(
-  client: any,
-  apiSysId: string,
-  instanceUrl: string
-): Promise<string | null> {
-  // ── Collect namespace candidates (ordered by likelihood) ──
-  var candidates: string[] = [];
+  const params = await lookupDefinitionParams(client, trigDefId);
+  steps.params_found = params.length;
 
-  // Most common for PDI / global scope custom APIs
-  candidates.push('global');
+  const gqlInputs = params.map((p: any) => buildGraphQLInput(p));
 
-  // Dot-walk to sys_scope.scope
-  try {
-    var dotWalkResp = await client.get('/api/now/table/sys_ws_definition/' + apiSysId, {
-      params: {
-        sysparm_fields: 'namespace.scope',
-        sysparm_display_value: 'false'
-      }
-    });
-    var scopeStr = dotWalkResp.data.result?.['namespace.scope'];
-    if (scopeStr && typeof scopeStr === 'string' && scopeStr.length > 1) {
-      candidates.push(scopeStr);
-    }
-  } catch (_) {}
-
-  // Read namespace display_value (might be scope string itself)
-  try {
-    var nsResp = await client.get('/api/now/table/sys_ws_definition/' + apiSysId, {
-      params: { sysparm_fields: 'namespace', sysparm_display_value: 'true' }
-    });
-    var nsDisplay = nsResp.data.result?.namespace;
-    if (typeof nsDisplay === 'string' && nsDisplay.length > 1) {
-      candidates.push(nsDisplay === 'Global' ? 'global' : nsDisplay);
-    }
-  } catch (_) {}
-
-  // OOB namespace
-  candidates.push('now');
+  if (gqlInputs.length === 0 && config.triggerType === 'Record') {
+    gqlInputs.push(
+      buildGraphQLInput({ name: 'table', label: 'Table', internal_type: 'table_name', mandatory: 'true', order: '1' }),
+      buildGraphQLInput({ name: 'condition', label: 'Condition', internal_type: 'conditions', mandatory: 'false', order: '100', use_dependent: 'true', dependent_on: 'table' })
+    );
+  }
 
-  // Company code from sys_properties
+  const triggerResponseFields = 'triggerInstances { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
   try {
-    var compResp = await client.get('/api/now/table/sys_properties', {
-      params: {
-        sysparm_query: 'name=glide.appcreator.company.code',
-        sysparm_fields: 'value',
-        sysparm_limit: 1
+    const insertResult = await executeFlowPatchMutation(client, {
+      flowId: flowId,
+      triggerInstances: {
+        insert: [{
+          flowSysId: flowId,
+          name: config.name,
+          triggerType: config.triggerType,
+          triggerDefinitionId: trigDefId,
+          type: config.type,
+          hasDynamicOutputs: false,
+          metadata: '{"predicates":[]}',
+          inputs: gqlInputs,
+          outputs: []
+        }]
+      }
+    }, triggerResponseFields);
+
+    const triggerId = insertResult?.triggerInstances?.inserts?.[0]?.sysId;
+    steps.insert = { success: !!triggerId, triggerId };
+    if (!triggerId) return { success: false, steps, error: 'GraphQL trigger INSERT returned no trigger ID' };
+
+    if (table) {
+      const updateInputs: any[] = [
+        {
+          name: 'table',
+          displayField: 'number',
+          displayValue: { schemaless: false, schemalessValue: '', value: table.charAt(0).toUpperCase() + table.slice(1) },
+          value: { schemaless: false, schemalessValue: '', value: table }
+        },
+        {
+          name: 'condition',
+          displayValue: { schemaless: false, schemalessValue: '', value: condition || '^EQ' }
+        }
+      ];
+      try {
+        await executeFlowPatchMutation(client, {
+          flowId: flowId,
+          triggerInstances: { update: [{ id: triggerId, inputs: updateInputs }] }
+        }, triggerResponseFields);
+        steps.update = { success: true, table, condition: condition || '^EQ' };
+      } catch (e: any) {
+        steps.update = { success: false, error: e.message };
       }
-    });
-    var companyCode = compResp.data.result?.[0]?.value;
-    if (companyCode) candidates.push(companyCode);
-  } catch (_) {}
-
-  // Instance subdomain (e.g. "dev354059")
-  try {
-    var match = instanceUrl.match(/https?:\/\/([^.]+)\./);
-    if (match && match[1]) candidates.push(match[1]);
-  } catch (_) {}
-
-  // ── Deduplicate ──
-  var seen: Record<string, boolean> = {};
-  var unique: string[] = [];
-  for (var i = 0; i < candidates.length; i++) {
-    var lower = candidates[i].toLowerCase();
-    if (!seen[lower]) {
-      seen[lower] = true;
-      unique.push(lower);
     }
-  }
 
-  // ── Verify each candidate via HTTP ──
-  for (var j = 0; j < unique.length; j++) {
-    var ns = unique[j];
-    // Check 1: GET /discover (v5 endpoint, returns 200 with discovery data)
-    try {
-      var discoverResp = await client.get('/api/' + ns + '/' + FLOW_FACTORY_API_ID + '/discover');
-      if (discoverResp.status === 200 || discoverResp.data) return ns;
-    } catch (discoverErr: any) {
-      var ds = discoverErr.response?.status;
-      if (ds === 401 || ds === 403 || ds === 405) return ns;
-      // 400/404 = wrong namespace or not registered yet
-    }
-    // Check 2: GET /create (POST-only, expect 405 for correct namespace)
-    try {
-      await client.get('/api/' + ns + '/' + FLOW_FACTORY_API_ID + '/create');
-      return ns; // 200 = unexpected but valid
-    } catch (createErr: any) {
-      var cs = createErr.response?.status;
-      if (cs === 405 || cs === 401 || cs === 403) return ns;
-      // 400/404 = wrong namespace (ServiceNow may return 400 instead of 405)
-    }
-    // Check 3: POST /create with empty body — distinguishes "wrong namespace" from
-    // "correct namespace but script validation error". Wrong namespace returns
-    // 400 with "Requested URI does not represent any resource". Our script returns
-    // a different error body (e.g. {success:false, error:"..."}).
-    try {
-      await client.post('/api/' + ns + '/' + FLOW_FACTORY_API_ID + '/create', {});
-      return ns; // Unexpected success, namespace confirmed
-    } catch (postErr: any) {
-      var pe = postErr.response;
-      if (!pe) continue;
-      if (pe.status === 401 || pe.status === 403) return ns;
-      // Check error body — "Requested URI" = wrong namespace, anything else = our script
-      var errStr = JSON.stringify(pe.data || '');
-      if (!errStr.includes('Requested URI')) return ns;
-    }
+    return { success: true, triggerId, steps };
+  } catch (e: any) {
+    steps.insert = { success: false, error: e.message };
+    return { success: false, steps, error: 'GraphQL trigger INSERT failed: ' + e.message };
   }
-
-  return null; // No candidate verified — API may not be registered yet
 }
 
-/**
- * Ensure the Flow Factory Scripted REST API exists on the ServiceNow instance.
- * Idempotent — checks cache first, then instance, deploys only if missing.
- *
- * Namespace resolution strategy:
- *   1. Dot-walk to sys_scope.scope from the API record (deterministic, no HTTP probing)
- *   2. Read namespace field with display_value=all (fallback)
- *   3. Company code from sys_properties (fallback)
- *   4. HTTP probing to /discover and /create endpoints (last resort)
- *
- * Stale API detection: if the API exists but has no /discover endpoint
- * (created by an older tool version), it is deleted and redeployed.
- */
-async function ensureFlowFactoryAPI(
+async function addActionViaGraphQL(
   client: any,
-  instanceUrl: string
-): Promise<{ namespace: string; apiSysId: string }> {
-  // 1. Check in-memory cache
-  if (_flowFactoryCache && (Date.now() - _flowFactoryCache.timestamp) < FLOW_FACTORY_CACHE_TTL) {
-    return { namespace: _flowFactoryCache.namespace, apiSysId: _flowFactoryCache.apiSysId };
-  }
-
-  // 2. Concurrency lock — reuse in-flight bootstrap
-  if (_bootstrapPromise) {
-    return _bootstrapPromise;
+  flowId: string,
+  actionType: string,
+  actionName: string,
+  inputs?: Record<string, string>,
+  order?: number
+): Promise<{ success: boolean; actionId?: string; steps?: any; error?: string }> {
+  const steps: any = {};
+
+  const actionTypeNames: Record<string, string[]> = {
+    'log': ['sn_fd.action.log', 'global.sn_fd.action.log', 'global.log'],
+    'create_record': ['sn_fd.action.create_record', 'global.sn_fd.action.create_record'],
+    'update_record': ['sn_fd.action.update_record', 'global.sn_fd.action.update_record'],
+    'notification': ['sn_fd.action.send_notification', 'global.sn_fd.action.send_notification'],
+    'script': ['sn_fd.action.script', 'global.sn_fd.action.script', 'global.script_action'],
+    'field_update': ['sn_fd.action.field_update', 'global.sn_fd.action.field_update'],
+    'wait': ['sn_fd.action.wait', 'global.sn_fd.action.wait'],
+    'approval': ['sn_fd.action.create_approval', 'global.sn_fd.action.create_approval'],
+  };
+
+  let actionDefId: string | null = null;
+  const candidates = actionTypeNames[actionType] || [];
+  for (const name of candidates) {
+    try {
+      const resp = await client.get('/api/now/table/sys_hub_action_type_definition', {
+        params: { sysparm_query: 'internal_name=' + name, sysparm_fields: 'sys_id', sysparm_limit: 1 }
+      });
+      actionDefId = resp.data.result?.[0]?.sys_id || null;
+      if (actionDefId) break;
+    } catch (_) {}
   }
-
-  _bootstrapPromise = (async () => {
+  if (!actionDefId) {
     try {
-      // 3. Check if API already exists on instance
-      var checkResp = await client.get('/api/now/table/sys_ws_definition', {
+      const resp = await client.get('/api/now/table/sys_hub_action_type_definition', {
         params: {
-          sysparm_query: 'api_id=' + FLOW_FACTORY_API_ID,
-          sysparm_fields: 'sys_id,api_id,namespace',
-          sysparm_limit: 1
+          sysparm_query: 'internal_nameLIKE' + actionType + '^ORnameLIKE' + actionType,
+          sysparm_fields: 'sys_id,internal_name', sysparm_limit: 5
         }
       });
+      actionDefId = resp.data.result?.[0]?.sys_id || null;
+    } catch (_) {}
+  }
+  if (!actionDefId) return { success: false, error: 'Action definition not found for: ' + actionType, steps };
+  steps.def_lookup = { id: actionDefId };
 
-      if (checkResp.data.result && checkResp.data.result.length > 0) {
-        var existing = checkResp.data.result[0];
-        var ns = await resolveFactoryNamespace(client, existing.sys_id, instanceUrl);
-
-        if (ns) {
-          // Verify the API has v5 endpoints (check /discover exists)
-          var hasDiscover = false;
-          try {
-            var verifyResp = await client.get('/api/' + ns + '/' + FLOW_FACTORY_API_ID + '/discover');
-            hasDiscover = verifyResp.status === 200 || !!verifyResp.data;
-          } catch (verifyErr: any) {
-            var vs = verifyErr.response?.status;
-            // 401/403 = endpoint exists but auth issue; 405 = exists but wrong method
-            hasDiscover = vs === 401 || vs === 403 || vs === 405;
-          }
-
-          if (hasDiscover) {
-            _flowFactoryCache = { apiSysId: existing.sys_id, namespace: ns, timestamp: Date.now() };
-            return { namespace: ns, apiSysId: existing.sys_id };
-          }
-          // /discover missing → stale API from older version, fall through to delete
-        }
-
-        // Delete stale API and redeploy with current scripts
-        invalidateFlowFactoryCache();
-        try {
-          await client.delete('/api/now/table/sys_ws_definition/' + existing.sys_id);
-        } catch (_) {
-          // If delete fails, try deployment anyway — will error on duplicate api_id
-        }
-        // Brief pause to let ServiceNow finalize the delete
-        await new Promise(resolve => setTimeout(resolve, 1000));
-      }
+  const params = await lookupDefinitionParams(client, actionDefId);
+  steps.params_found = params.length;
 
-      // 4. Deploy the Scripted REST API (do NOT set namespace — let ServiceNow assign it)
-      var apiResp = await client.post('/api/now/table/sys_ws_definition', {
-        name: FLOW_FACTORY_API_NAME,
-        api_id: FLOW_FACTORY_API_ID,
-        active: true,
-        short_description: 'Bootstrapped by Snow-Flow MCP for reliable Flow Designer creation via GlideRecord',
-        is_versioned: false,
-        enforce_acl: 'false',
-        requires_authentication: true
-      });
+  const gqlInputs = params.map((p: any) => {
+    const pName = p.name || p.element || '';
+    const providedValue = inputs?.[pName];
+    return buildGraphQLInput(p, providedValue);
+  });
 
-      var apiSysId = apiResp.data.result?.sys_id;
-      if (!apiSysId) {
-        throw new Error('Failed to create Scripted REST API definition — no sys_id returned');
+  const uuid = generateUUID();
+  const actionResponseFields = 'actions { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
+  try {
+    const result = await executeFlowPatchMutation(client, {
+      flowId: flowId,
+      actions: {
+        insert: [{
+          actionTypeSysId: actionDefId,
+          metadata: '{"predicates":[]}',
+          flowSysId: flowId,
+          generationSource: '',
+          order: String(order || 1),
+          parent: '',
+          uiUniqueIdentifier: uuid,
+          type: 'action',
+          parentUiId: '',
+          inputs: gqlInputs
+        }]
       }
+    }, actionResponseFields);
 
-      // 5a. Deploy the POST /create resource
-      try {
-        await client.post('/api/now/table/sys_ws_operation', {
-          web_service_definition: apiSysId,
-          http_method: 'POST',
-          name: 'create',
-          active: true,
-          relative_path: '/create',
-          short_description: 'Create a flow/subflow via 3-tier approach: sn_fd API → draft+publish → raw GlideRecord',
-          operation_script: FLOW_FACTORY_SCRIPT,
-          requires_authentication: true,
-          enforce_acl: 'false'
-        });
-      } catch (opError: any) {
-        // Cleanup the API definition if operation creation fails
-        try { await client.delete('/api/now/table/sys_ws_definition/' + apiSysId); } catch (_) {}
-        throw new Error('Failed to create Scripted REST operation: ' + (opError.message || opError));
-      }
+    const actionId = result?.actions?.inserts?.[0]?.sysId;
+    steps.insert = { success: !!actionId, actionId, uuid };
 
-      // 5b. Deploy the GET /discover resource (API capability probing)
+    if (actionId && inputs && Object.keys(inputs).length > 0) {
+      const updateInputs = Object.entries(inputs).map(([name, value]) => ({
+        name,
+        value: { schemaless: false, schemalessValue: '', value: String(value) }
+      }));
       try {
-        await client.post('/api/now/table/sys_ws_operation', {
-          web_service_definition: apiSysId,
-          http_method: 'GET',
-          name: 'discover',
-          active: true,
-          relative_path: '/discover',
-          short_description: 'Probe available sn_fd APIs, methods and fields for this ServiceNow instance',
-          operation_script: FLOW_FACTORY_DISCOVER_SCRIPT,
-          requires_authentication: true,
-          enforce_acl: 'false'
-        });
-      } catch (_) {
-        // Non-fatal: create endpoint is more important than discover
-      }
-
-      // 6. Wait for ServiceNow REST framework to register endpoints
-      await new Promise(resolve => setTimeout(resolve, 4000));
-
-      // 7. Resolve namespace via HTTP-verified probing
-      var resolvedNs = await resolveFactoryNamespace(client, apiSysId, instanceUrl);
-
-      // 8. If resolution failed, wait longer and retry (some instances are slow)
-      if (!resolvedNs) {
-        await new Promise(resolve => setTimeout(resolve, 5000));
-        resolvedNs = await resolveFactoryNamespace(client, apiSysId, instanceUrl);
-      }
-      if (!resolvedNs) {
-        throw new Error('Flow Factory deployed (sys_id=' + apiSysId + ') but no namespace candidate could be verified via HTTP after 9s. Candidates tried: global, dot-walk scope, display_value, now, company code, subdomain.');
+        await executeFlowPatchMutation(client, {
+          flowId: flowId,
+          actions: { update: [{ uiUniqueIdentifier: uuid, type: 'action', inputs: updateInputs }] }
+        }, actionResponseFields);
+        steps.value_update = { success: true };
+      } catch (e: any) {
+        steps.value_update = { success: false, error: e.message };
       }
-
-      _flowFactoryCache = { apiSysId: apiSysId, namespace: resolvedNs, timestamp: Date.now() };
-      return { namespace: resolvedNs, apiSysId: apiSysId };
-
-    } finally {
-      _bootstrapPromise = null;
     }
-  })();
-
-  return _bootstrapPromise;
-}
-
-/**
- * Invalidate the Flow Factory cache (e.g. on 404 when API was deleted externally).
- */
-function invalidateFlowFactoryCache(): void {
-  _flowFactoryCache = null;
-  _discoveryCache = null;
-}
-
-/**
- * Call the /discover endpoint on the Flow Factory API to learn which
- * sn_fd APIs and methods are available on the target ServiceNow instance.
- * Results are cached alongside the factory cache.
- */
-var _discoveryCache: any = null;
 
-async function discoverInstanceCapabilities(
-  client: any,
-  namespace: string
-): Promise<any> {
-  if (_discoveryCache) return _discoveryCache;
-  try {
-    var discoverEndpoint = '/api/' + namespace + '/' + FLOW_FACTORY_API_ID + '/discover';
-    var resp = await client.get(discoverEndpoint);
-    _discoveryCache = resp.data?.result || resp.data || null;
-    return _discoveryCache;
-  } catch (_) {
-    return null;
+    return { success: true, actionId: actionId || undefined, steps };
+  } catch (e: any) {
+    steps.insert = { success: false, error: e.message };
+    return { success: false, steps, error: 'GraphQL action INSERT failed: ' + e.message };
   }
 }
 
-/**
- * After creating a flow (via any method), try to register it with the
- * Flow Designer engine by calling its built-in compile / publish / activate
- * REST endpoints.  Without this step the flow record exists in the DB but
- * Flow Designer cannot open it ("Your flow cannot be found").
- *
- * Tries multiple known endpoint patterns because the namespace/path changed
- * across ServiceNow releases.  Returns diagnostics on which attempts were
- * made and what succeeded.
- */
-async function registerFlowWithEngine(
+async function createFlowViaProcessFlowAPI(
   client: any,
-  flowSysId: string,
-  shouldActivate: boolean
-): Promise<{ success: boolean; method: string; attempts: string[] }> {
-  var attempts: string[] = [];
-
-  // Helper: try a POST and classify the result (capture error body for diagnostics)
-  async function tryPost(label: string, url: string, body?: any): Promise<boolean> {
-    try {
-      await client.post(url, body || {});
-      attempts.push(label + ': success');
-      return true;
-    } catch (e: any) {
-      var s = e.response?.status || 'err';
-      var errBody = '';
-      try { errBody = JSON.stringify(e.response?.data || '').substring(0, 150); } catch (_) {}
-      attempts.push(label + ': ' + s + (errBody ? ' ' + errBody : ''));
-      return false;
-    }
+  params: {
+    name: string;
+    description: string;
+    isSubflow: boolean;
+    runAs: string;
+    shouldActivate: boolean;
   }
+): Promise<{
+  success: boolean;
+  flowSysId?: string;
+  versionCreated?: boolean;
+  flowData?: any;
+  error?: string;
+}> {
+  try {
+    var flowResp = await client.post(
+      '/api/now/processflow/flow',
+      {
+        access: 'public',
+        description: params.description || '',
+        flowPriority: 'MEDIUM',
+        name: params.name,
+        protection: '',
+        runAs: params.runAs || 'user',
+        runWithRoles: { value: '', displayValue: '' },
+        scope: 'global',
+        scopeDisplayName: '',
+        scopeName: '',
+        security: { can_read: true, can_write: true },
+        status: 'draft',
+        type: params.isSubflow ? 'subflow' : 'flow',
+        userHasRolesAssignedToFlow: true,
+        active: false,
+        deleted: false
+      },
+      {
+        params: {
+          param_only_properties: 'true',
+          sysparm_transaction_scope: 'global'
+        }
+      }
+    );
 
-  // ── Strategy 1: Publish via Flow Designer REST API ───────────────
-  // This is the closest equivalent to clicking "Publish" in the UI.
-  var publishPaths = [
-    '/api/sn_fd/flow/' + flowSysId + '/publish',
-    '/api/sn_fd/designer/flow/' + flowSysId + '/publish',
-    '/api/sn_flow_designer/flow/' + flowSysId + '/publish',
-  ];
-  for (var pi = 0; pi < publishPaths.length; pi++) {
-    if (await tryPost('publish[' + pi + ']', publishPaths[pi])) {
-      return { success: true, method: 'publish', attempts: attempts };
+    var flowResult = flowResp.data?.result?.data;
+    if (!flowResult?.id) {
+      var errDetail = flowResp.data?.result?.errorMessage || 'no flow id returned';
+      return { success: false, error: 'ProcessFlow API: ' + errDetail };
     }
-  }
 
-  // ── Strategy 2: Activate (registers the flow with the engine) ────
-  if (shouldActivate) {
-    var activatePaths = [
-      '/api/sn_fd/flow/' + flowSysId + '/activate',
-      '/api/sn_fd/designer/flow/' + flowSysId + '/activate',
-      '/api/sn_flow_designer/flow/' + flowSysId + '/activate',
-    ];
-    for (var ai = 0; ai < activatePaths.length; ai++) {
-      if (await tryPost('activate[' + ai + ']', activatePaths[ai])) {
-        return { success: true, method: 'activate', attempts: attempts };
-      }
-    }
-  }
+    var flowSysId = flowResult.id;
 
-  // ── Strategy 3: Checkout + checkin (triggers internal compilation) ─
-  var checkoutPaths = [
-    '/api/sn_fd/flow/' + flowSysId + '/checkout',
-    '/api/sn_fd/designer/flow/' + flowSysId + '/checkout',
-  ];
-  for (var ci = 0; ci < checkoutPaths.length; ci++) {
-    if (await tryPost('checkout[' + ci + ']', checkoutPaths[ci])) {
-      var checkinPath = checkoutPaths[ci].replace('/checkout', '/checkin');
-      await tryPost('checkin[' + ci + ']', checkinPath);
-      return { success: true, method: 'checkout+checkin', attempts: attempts };
+    var versionCreated = false;
+    try {
+      await client.post(
+        '/api/now/processflow/versioning/create_version',
+        { item_sys_id: flowSysId, type: 'Autosave', annotation: '', favorite: false },
+        { params: { sysparm_transaction_scope: 'global' } }
+      );
+      versionCreated = true;
+    } catch (_) {
     }
-  }
 
-  // ── Strategy 4: Snapshot (already existed — triggers version snapshot) ─
-  if (await tryPost('snapshot', '/api/sn_flow_designer/flow/snapshot', { flow_id: flowSysId })) {
-    return { success: true, method: 'snapshot', attempts: attempts };
-  }
-  // Try alternate snapshot path
-  if (await tryPost('snapshot-alt', '/api/sn_fd/flow/' + flowSysId + '/snapshot')) {
-    return { success: true, method: 'snapshot-alt', attempts: attempts };
+    return { success: true, flowSysId, versionCreated, flowData: flowResult };
+  } catch (e: any) {
+    var msg = e.message || '';
+    try { msg += ' — ' + JSON.stringify(e.response?.data || '').substring(0, 200); } catch (_) {}
+    return { success: false, error: 'ProcessFlow API: ' + msg };
   }
-
-  return { success: false, method: 'none', attempts: attempts };
 }
 
-/**
- * Resolve a flow name to its sys_id. If the value is already a 32-char hex
- * string it is returned as-is.
- */
+// ── resolve helpers ───────────────────────────────────────────────────
+
 async function resolveFlowId(client: any, flowId: string): Promise<string> {
   if (isSysId(flowId)) return flowId;
 
@@ -1268,17 +449,15 @@ export const toolDefinition: MCPToolDefinition = {
     properties: {
       action: {
         type: 'string',
-        enum: ['create', 'create_subflow', 'list', 'get', 'update', 'activate', 'deactivate', 'delete', 'publish'],
+        enum: ['create', 'create_subflow', 'list', 'get', 'update', 'activate', 'deactivate', 'delete', 'publish', 'add_trigger', 'add_action'],
         description: 'Action to perform'
       },
 
-      // ── shared identifiers ──
       flow_id: {
         type: 'string',
         description: 'Flow sys_id or name (required for get, update, activate, deactivate, delete, publish)'
       },
 
-      // ── create / create_subflow params ──
       name: {
         type: 'string',
         description: 'Flow name (required for create / create_subflow)'
@@ -1359,8 +538,6 @@ export const toolDefinition: MCPToolDefinition = {
         description: 'Activate flow after creation (default: true)',
         default: true
       },
-
-      // ── list params ──
       type: {
         type: 'string',
         enum: ['flow', 'subflow', 'all'],
@@ -1377,8 +554,20 @@ export const toolDefinition: MCPToolDefinition = {
         description: 'Max results for list',
         default: 50
       },
-
-      // ── update params ──
+      action_type: {
+        type: 'string',
+        enum: ['log', 'create_record', 'update_record', 'notification', 'script', 'field_update', 'wait', 'approval'],
+        description: 'Action type to add (for add_action)',
+        default: 'log'
+      },
+      action_name: {
+        type: 'string',
+        description: 'Display name for the action (for add_action)'
+      },
+      action_inputs: {
+        type: 'object',
+        description: 'Key-value pairs for action inputs (e.g. {log_message: "test", log_level: "info"})'
+      },
       update_fields: {
         type: 'object',
         description: 'Fields to update (for update action)',
@@ -1405,7 +594,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
     switch (action) {
 
       // ────────────────────────────────────────────────────────────────
-      // CREATE  (Scripted REST API → Table API fallback)
+      // CREATE
       // ────────────────────────────────────────────────────────────────
       case 'create':
       case 'create_subflow': {
@@ -1468,7 +657,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           delete flowDefinition.trigger;
         }
 
-        // ── Pipeline: Scheduled Job (primary) → Table API (fallback) ──
+        // ── Pipeline: ProcessFlow API (primary) → Table API (fallback) ──
         var flowSysId: string | null = null;
         var usedMethod = 'table_api';
         var versionCreated = false;
@@ -1477,82 +666,86 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         var actionsCreated = 0;
         var varsCreated = 0;
 
-        // Diagnostics: track every step for debugging "flow cannot be found" issues
+        // Diagnostics
         var diagnostics: any = {
+          processflow_api: null,
           table_api_used: false,
           version_created: false,
           version_method: null,
           post_verify: null
         };
 
-        // ── Scheduled Job (primary — server-side GlideRecord) ───────
-        // This runs inside ServiceNow as a system job, so it CAN set
-        // computed fields like latest_version that Table API cannot.
-        // Also attempts sn_fd engine registration server-side.
+        // ── ProcessFlow API (primary — same REST endpoint as Flow Designer UI) ──
+        // Uses /api/now/processflow/flow to create engine-registered flows,
+        // then /api/now/processflow/versioning/create_version for versioning.
         try {
-          var scheduledResult = await createFlowViaScheduledJob(client, {
+          var pfResult = await createFlowViaProcessFlowAPI(client, {
             name: flowName,
             description: flowDescription,
-            internalName: sanitizeInternalName(flowName),
             isSubflow: isSubflow,
-            category: flowCategory,
             runAs: flowRunAs,
-            shouldActivate: shouldActivate,
-            triggerType: triggerType,
-            triggerTable: flowTable,
-            triggerCondition: triggerCondition,
-            activities: activitiesArg.map(function (act: any, idx: number) {
-              return { name: act.name, type: act.type || 'script', inputs: act.inputs || {} };
-            }),
-            inputs: inputsArg,
-            outputs: outputsArg,
-            flowDefinition: flowDefinition
+            shouldActivate: shouldActivate
           });
-          diagnostics.scheduled_job = {
-            success: scheduledResult.success,
-            tierUsed: scheduledResult.tierUsed,
-            latestVersionSet: scheduledResult.latestVersionSet,
-            latestVersionValue: scheduledResult.latestVersionValue,
-            steps: scheduledResult.steps,
-            error: scheduledResult.error
+          diagnostics.processflow_api = {
+            success: pfResult.success,
+            versionCreated: pfResult.versionCreated,
+            error: pfResult.error
           };
-          if (scheduledResult.success && scheduledResult.flowSysId) {
-            flowSysId = scheduledResult.flowSysId;
-            usedMethod = 'scheduled_job (' + (scheduledResult.tierUsed || 'unknown') + ')';
-            versionCreated = !!scheduledResult.versionSysId;
+          if (pfResult.success && pfResult.flowSysId) {
+            flowSysId = pfResult.flowSysId;
+            usedMethod = 'processflow_api';
+            versionCreated = !!pfResult.versionCreated;
             diagnostics.version_created = versionCreated;
-            diagnostics.version_method = 'scheduled_job';
-            diagnostics.latest_version_auto_set = scheduledResult.latestVersionSet;
-            // Extract engine registration results from scheduled job
-            if (scheduledResult.steps?.engine) {
-              diagnostics.engine_registration = scheduledResult.steps.engine;
-            }
-            // Extract trigger/action/variable results from scheduled job
-            if (scheduledResult.steps?.trigger) {
-              triggerCreated = !!scheduledResult.steps.trigger.success;
-              if (!scheduledResult.steps.trigger.success && scheduledResult.steps.trigger.error) {
-                factoryWarnings.push('Trigger: ' + scheduledResult.steps.trigger.error);
-              }
-            }
-            if (scheduledResult.steps?.actions) {
-              actionsCreated = scheduledResult.steps.actions.created || 0;
+            diagnostics.version_method = 'processflow_api';
+          }
+        } catch (pfErr: any) {
+          diagnostics.processflow_api = { error: pfErr.message || 'unknown' };
+          factoryWarnings.push('ProcessFlow API failed: ' + (pfErr.message || pfErr));
+        }
+
+        // ── Triggers, actions, variables for ProcessFlow-created flows ──
+        // Uses GraphQL mutations (same as Flow Designer UI) for proper engine registration
+        if (flowSysId && usedMethod === 'processflow_api') {
+          if (!isSubflow && triggerType !== 'manual') {
+            try {
+              var pfTrigResult = await addTriggerViaGraphQL(client, flowSysId, triggerType, flowTable, triggerCondition);
+              triggerCreated = pfTrigResult.success;
+              diagnostics.trigger_graphql = pfTrigResult;
+            } catch (_) { /* best-effort */ }
+          }
+          for (var pfai = 0; pfai < activitiesArg.length; pfai++) {
+            try {
+              var pfAct = activitiesArg[pfai];
+              var pfActResult = await addActionViaGraphQL(client, flowSysId, pfAct.type || 'log', pfAct.name || ('Action ' + (pfai + 1)), pfAct.inputs, pfai + 1);
+              if (pfActResult.success) actionsCreated++;
+              diagnostics['action_' + pfai] = pfActResult;
+            } catch (_) { /* best-effort */ }
+          }
+          if (isSubflow) {
+            for (var pfvi = 0; pfvi < inputsArg.length; pfvi++) {
+              try {
+                var pfInp = inputsArg[pfvi];
+                await client.post('/api/now/table/sys_hub_flow_variable', {
+                  flow: flowSysId, name: pfInp.name, label: pfInp.label || pfInp.name,
+                  type: pfInp.type || 'string', mandatory: pfInp.mandatory || false,
+                  default_value: pfInp.default_value || '', variable_type: 'input'
+                });
+                varsCreated++;
+              } catch (_) {}
             }
-            if (scheduledResult.steps?.variables) {
-              varsCreated = scheduledResult.steps.variables.created || 0;
+            for (var pfvo = 0; pfvo < outputsArg.length; pfvo++) {
+              try {
+                var pfOut = outputsArg[pfvo];
+                await client.post('/api/now/table/sys_hub_flow_variable', {
+                  flow: flowSysId, name: pfOut.name, label: pfOut.label || pfOut.name,
+                  type: pfOut.type || 'string', variable_type: 'output'
+                });
+                varsCreated++;
+              } catch (_) {}
             }
           }
-        } catch (schedErr: any) {
-          diagnostics.scheduled_job = { error: schedErr.message || 'unknown' };
-          factoryWarnings.push('Scheduled job failed: ' + (schedErr.message || schedErr));
         }
 
-        // BR compile + engine REST registration skipped:
-        // - BR: FlowDesigner unavailable in all contexts, FlowAPI.compile returns error,
-        //   all Script Includes (FlowDesignerScriptable etc.) don't exist on PDI instances
-        // - REST: all sn_fd endpoints return 400 "Requested URI does not represent any resource"
-        // Both add ~20s combined and provide zero value. Flow records are functional
-        // (listable, queryable, deletable) but cannot be opened in Flow Designer UI.
-
         // ── Table API fallback (last resort) ─────────────────────────
         if (!flowSysId) {
           diagnostics.table_api_used = true;
@@ -1626,91 +819,24 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
             factoryWarnings.push('sys_hub_flow_version creation failed: ' + (verError.message || verError));
           }
 
-          // Create trigger instance (non-manual flows only)
-          // Use precise prefix search, then fallback to creating without action_type
+          // Create trigger via GraphQL (same method as Flow Designer UI)
           if (!isSubflow && triggerType !== 'manual') {
             try {
-              var triggerDefId: string | null = null;
-
-              // Search 1: exact sn_fd.trigger.* prefix
-              var exactTrigNames: Record<string, string[]> = {
-                'record_created': ['sn_fd.trigger.record_created', 'global.sn_fd.trigger.record_created'],
-                'record_updated': ['sn_fd.trigger.record_updated', 'global.sn_fd.trigger.record_updated'],
-                'scheduled': ['sn_fd.trigger.scheduled', 'global.sn_fd.trigger.scheduled']
-              };
-              var exactCands = exactTrigNames[triggerType] || [];
-              for (var eci = 0; eci < exactCands.length && !triggerDefId; eci++) {
-                var exactResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
-                  params: {
-                    sysparm_query: 'internal_name=' + exactCands[eci],
-                    sysparm_fields: 'sys_id',
-                    sysparm_limit: 1
-                  }
-                });
-                triggerDefId = exactResp.data.result?.[0]?.sys_id || null;
-              }
-
-              // Search 2: STARTSWITH sn_fd.trigger
-              if (!triggerDefId) {
-                var prefixResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
-                  params: {
-                    sysparm_query: 'internal_nameSTARTSWITHsn_fd.trigger',
-                    sysparm_fields: 'sys_id,internal_name',
-                    sysparm_limit: 10
-                  }
-                });
-                var prefixResults = prefixResp.data.result || [];
-                for (var pri = 0; pri < prefixResults.length && !triggerDefId; pri++) {
-                  if ((prefixResults[pri].internal_name || '').indexOf(triggerType.replace('record_', '')) > -1) {
-                    triggerDefId = prefixResults[pri].sys_id;
-                  }
-                }
-              }
-
-              // Create trigger instance (with or without action_type)
-              var triggerData: any = {
-                flow: flowSysId,
-                name: triggerType,
-                order: 0,
-                active: true
-              };
-              if (triggerDefId) triggerData.action_type = triggerDefId;
-              if (flowTable) triggerData.table = flowTable;
-              if (triggerCondition) triggerData.condition = triggerCondition;
-
-              await client.post('/api/now/table/sys_hub_trigger_instance', triggerData);
-              triggerCreated = true;
+              var taTrigResult = await addTriggerViaGraphQL(client, flowSysId, triggerType, flowTable, triggerCondition);
+              triggerCreated = taTrigResult.success;
+              diagnostics.trigger_graphql = taTrigResult;
             } catch (triggerError) {
               // Best-effort
             }
           }
 
-          // Create action instances
+          // Create actions via GraphQL (same method as Flow Designer UI)
           for (var ai = 0; ai < activitiesArg.length; ai++) {
             var activity = activitiesArg[ai];
             try {
-              var actionTypeName = activity.type || 'script';
-              var actionTypeQuery = 'internal_nameLIKE' + actionTypeName + '^ORnameLIKE' + actionTypeName;
-
-              var actionDefResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
-                params: {
-                  sysparm_query: actionTypeQuery,
-                  sysparm_fields: 'sys_id,name,internal_name',
-                  sysparm_limit: 1
-                }
-              });
-
-              var actionDefId = actionDefResp.data.result?.[0]?.sys_id;
-              var instanceData: any = {
-                flow: flowSysId,
-                name: activity.name,
-                order: (ai + 1) * 100,
-                active: true
-              };
-              if (actionDefId) instanceData.action_type = actionDefId;
-
-              await client.post('/api/now/table/sys_hub_action_instance', instanceData);
-              actionsCreated++;
+              var taActResult = await addActionViaGraphQL(client, flowSysId, activity.type || 'log', activity.name || ('Action ' + (ai + 1)), activity.inputs, ai + 1);
+              if (taActResult.success) actionsCreated++;
+              diagnostics['action_' + ai] = taActResult;
             } catch (actError) {
               // Best-effort
             }
@@ -1815,11 +941,9 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         }
 
         // ── Build summary ───────────────────────────────────────────
-        var methodLabel = usedMethod.startsWith('scheduled_job')
-          ? 'Scheduled Job (server-side GlideRecord)'
-          : usedMethod === 'scripted_rest_api'
-            ? 'Scripted REST API (GlideRecord)'
-            : 'Table API' + (factoryWarnings.length > 0 ? ' (fallback)' : '');
+        var methodLabel = usedMethod === 'processflow_api'
+          ? 'ProcessFlow API (Flow Designer engine)'
+          : 'Table API' + (factoryWarnings.length > 0 ? ' (fallback)' : '');
 
         var createSummary = summary()
           .success('Created ' + (isSubflow ? 'subflow' : 'flow') + ': ' + flowName)
@@ -1855,17 +979,13 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
 
         // Diagnostics section
         createSummary.blank().line('Diagnostics:');
-        if (diagnostics.scheduled_job) {
-          var sj = diagnostics.scheduled_job;
-          createSummary.indented('Scheduled job: ' + (sj.success ? 'success' : 'failed') + (sj.tierUsed ? ' (' + sj.tierUsed + ')' : ''));
-          if (sj.error) createSummary.indented('  Error: ' + sj.error);
+        if (diagnostics.processflow_api) {
+          var pf = diagnostics.processflow_api;
+          createSummary.indented('ProcessFlow API: ' + (pf.success ? 'success' : 'failed') + (pf.versionCreated ? ' (version created)' : ''));
+          if (pf.error) createSummary.indented('  Error: ' + pf.error);
         }
-        createSummary.indented('Table API used: ' + diagnostics.table_api_used);
+        createSummary.indented('Table API fallback used: ' + diagnostics.table_api_used);
         createSummary.indented('Version created: ' + diagnostics.version_created + (diagnostics.version_method ? ' (' + diagnostics.version_method + ')' : ''));
-        createSummary.indented('Engine compile: skipped (not available on this instance — FlowDesigner unavailable, REST 400s, no Script Includes)');
-        if (diagnostics.latest_version_auto_set !== undefined) {
-          createSummary.indented('latest_version: ' + (diagnostics.latest_version_auto_set ? 'set' : 'null'));
-        }
         if (diagnostics.post_verify) {
           if (diagnostics.post_verify.error) {
             createSummary.indented('Post-verify: error — ' + diagnostics.post_verify.error);
@@ -2231,6 +1351,68 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         }, {}, deleteSummary.build());
       }
 
+      // ────────────────────────────────────────────────────────────────
+      // ADD_TRIGGER
+      // ────────────────────────────────────────────────────────────────
+      case 'add_trigger': {
+        if (!args.flow_id) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required for add_trigger');
+        }
+        var addTrigFlowId = await resolveFlowId(client, args.flow_id);
+        var addTrigType = args.trigger_type || 'record_create_or_update';
+        var addTrigTable = args.table || '';
+        var addTrigCondition = args.trigger_condition || '';
+
+        var addTrigResult = await addTriggerViaGraphQL(client, addTrigFlowId, addTrigType, addTrigTable, addTrigCondition);
+
+        var addTrigSummary = summary();
+        if (addTrigResult.success) {
+          addTrigSummary
+            .success('Trigger added via GraphQL')
+            .field('Flow', addTrigFlowId)
+            .field('Type', addTrigType)
+            .field('Trigger ID', addTrigResult.triggerId || 'unknown');
+          if (addTrigTable) addTrigSummary.field('Table', addTrigTable);
+        } else {
+          addTrigSummary.error('Failed to add trigger: ' + (addTrigResult.error || 'unknown'));
+        }
+
+        return addTrigResult.success
+          ? createSuccessResult({ action: 'add_trigger', ...addTrigResult }, {}, addTrigSummary.build())
+          : createErrorResult(addTrigResult.error || 'Failed to add trigger');
+      }
+
+      // ────────────────────────────────────────────────────────────────
+      // ADD_ACTION
+      // ────────────────────────────────────────────────────────────────
+      case 'add_action': {
+        if (!args.flow_id) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required for add_action');
+        }
+        var addActFlowId = await resolveFlowId(client, args.flow_id);
+        var addActType = args.action_type || 'log';
+        var addActName = args.action_name || args.name || addActType;
+        var addActInputs = args.action_inputs || args.inputs || {};
+
+        var addActResult = await addActionViaGraphQL(client, addActFlowId, addActType, addActName, addActInputs);
+
+        var addActSummary = summary();
+        if (addActResult.success) {
+          addActSummary
+            .success('Action added via GraphQL')
+            .field('Flow', addActFlowId)
+            .field('Type', addActType)
+            .field('Name', addActName)
+            .field('Action ID', addActResult.actionId || 'unknown');
+        } else {
+          addActSummary.error('Failed to add action: ' + (addActResult.error || 'unknown'));
+        }
+
+        return addActResult.success
+          ? createSuccessResult({ action: 'add_action', ...addActResult }, {}, addActSummary.build())
+          : createErrorResult(addActResult.error || 'Failed to add action');
+      }
+
       default:
         throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'Unknown action: ' + action);
     }
@@ -2251,5 +1433,5 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
   }
 }
 
-export const version = '5.0.0';
+export const version = '6.0.0';
 export const author = 'Snow-Flow Team';