@jacebenson/jsn 4.3.7-dev.33 → 4.3.7-dev.34

package/README.md

@@ -97,8 +97,27 @@ jsn logs follow --level error --tail 10
 ### Flow Designer actions
 
 `actions` and `action` are the same command. `list`, `show`, and explicit
-`delete` remain available. Create and edit use full Process Flow JSON, not
-ordinary table-field updates.
+`delete` remain available. In a human terminal, omit the target to open a
+searchable picker. Create and edit guide you through provider schemas and save
+full Process Flow definitions, not ordinary table-field updates.
+
+```bash
+jsn actions create                 # Guided scope, name, schemas, inputs and script
+jsn actions edit                   # Pick an action, edit its saved definition
+jsn actions definition             # Pick and inspect a complete definition
+jsn actions test --wait            # Pick an action, supply saved-schema inputs, confirm
+jsn actions step-types             # Pick the exact transaction scope
+```
+
+Script inputs offer a file path or your `$VISUAL`/`$EDITOR`. New script steps can
+declare outputs and map them to action outputs. Variable declarations reuse
+provider schema templates and receive fresh UI identities. Unknown nested
+schema fields are retained. Unsupported input types stop with instructions to
+use `--data-file`; JSN does not silently omit them or invent schema defaults.
+Creation waits for an explicit final confirmation before allocating a parent.
+It saves a draft only and never publishes or runs it automatically.
+
+For automation, keep using explicit identifiers and full JSON:
 
 ```bash
 jsn actions step-types --scope <scope_sys_id> --get data > step-types.json
@@ -177,9 +196,43 @@ These internal endpoints and runtime-table permissions can vary by instance.
 
 ### Flow execution fields
 
+### Flow Designer terminal workflows
+
+```bash
+jsn flows create         # Guided record trigger and published action inputs
+jsn flows edit           # Pick an inactive Draft, edit condition or existing inputs
+jsn flows show           # Pick a flow to inspect
+jsn flows status         # Pick a flow to diagnose
+jsn flows test           # Pick flow and a record from its actual trigger table, confirm
+jsn flows publish        # Pick a flow, explicitly confirm activation
+# Automation must explicitly confirm publication too:
+jsn flows publish <flow_sys_id> --force --json
+```
+
+Wizards and omitted-target pickers require both a prompt-capable terminal and
+`auto` output. `--json`, explicit formats, `--get`, `--data`, `--data-file`,
+`--output-map`, pipes, `CI`, `NONINTERACTIVE` and `JSN_NO_PROMPTS=1` never open a
+wizard. In those modes provide identifiers and required scope/record/data
+explicitly. Tests, publish and deletion require `--force` or the profile's
+existing explicit skip-confirmations setting when prompting is unavailable.
+Read-only profiles still block mutations before authentication or prompting.
+Press Escape in record pickers or Ctrl+C in any wizard to cancel. Refusing a
+final confirmation leaves the instance untouched.
+
+Existing action/flow scopes come from saved raw identifiers. New scopes offer
+the active application preference if available, then a searchable scope picker.
+No scope name is guessed. Input pills are passed through unchanged.
+
+Flow edits are limited to the existing manifest contract. They do not rename
+flows, add/remove steps, implement Flow Logic, subflows, variables or error
+handling. Flow deletion remains unsupported. Action deletion retains its
+existing explicit parent-record cleanup and absence readback, not a new native
+builder deletion lifecycle. See [command coverage and local proof](docs/flow-designer-interactive.md).
+
 ### Flow creation manifest
 
-`jsn flows create` accepts `--data-file` or inline `--data`. The first slice
+`jsn flows create` accepts `--data-file` or inline `--data`, or guides human
+terminal users without those options. The supported slice
 supports one `record_create_or_update` trigger and published Action types whose
 input schemas are available from the instance. JSN resolves action metadata,
 defaults, and typed inputs from ServiceNow; callers do not provide GraphQL or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacebenson/jsn",
-  "version": "4.3.7-dev.33",
+  "version": "4.3.7-dev.34",
   "description": "A command-line interface for ServiceNow that follows the Unix philosophy: simple, composable, and scriptable.",
   "type": "module",
   "bin": {

package/src/commands/_generic.js

@@ -181,11 +181,12 @@ export function buildDevCmd(name, table, aliases, defaultColumns, wrap, opts = {
         }),
       })
       .command({
-        command: 'show <identifier>',
+        command: opts.resolveIdentifier ? 'show [identifier]' : 'show <identifier>',
         aliases: ['get'],
         describe: `Show ${vowelArticle(singular)} ${singular} by name or sys_id`,
         handler: wrap(async (argv, app) => {
-          const id = argv.identifier;
+          const id = opts.resolveIdentifier ? await opts.resolveIdentifier(argv, app) : argv.identifier;
+          if (id === undefined) return;
           // Only restrict sysparm_fields if showFields is explicitly set.
           // Go version fetches all fields for show unless explicitly restricted.
           const fields = (showFields && showFields.length > 0)

package/src/commands/actions.js

@@ -1,15 +1,19 @@
 import { buildDevCmd } from './_generic.js';
-import { parseDataArg, confirmDelete } from '../helpers.js';
+import { parseDataArg } from '../helpers.js';
 import { resolveRecord, unwrapSysId } from '../resolve-record.js';
 import { declareCapabilities } from '../capabilities.js';
-import { ACTION_TABLE, actionScope, validateScope } from '../processflow-actions.js';
+import { ACTION_TABLE, actionScope } from '../processflow-actions.js';
 import { errUsage } from '../errors.js';
+import { cancelled, pickDesignerRecord, designerScope, guidedActionCreate, guidedActionEdit, guidedActionTestInputs, interactiveDesigner, hasDefinitionData, confirmDesignerMutation } from '../flow-designer-interactive.js';
 
 const scopeOption = y => y.option('scope', { type: 'string', describe: 'Exact transaction scope sys_id; inferred from existing action when omitted' });
 const dataOptions = y => y
   .option('data-file', { type: 'string', describe: 'Full action definition JSON file, not table fields' })
   .option('data', { type: 'string', describe: 'Full action definition as JSON' });
 async function actionID(argv, app) {
+  const identifier = await pickDesignerRecord(argv, app, ACTION_TABLE, 'action');
+  if (identifier === undefined) return undefined;
+  argv = { ...argv, identifier };
   return unwrapSysId(await resolveRecord(app.sdk, { table: ACTION_TABLE, identifier: argv.identifier, matchField: 'name', resource: 'action' }));
 }
 
@@ -17,6 +21,7 @@ export const actionsCmd = wrap => {
   // Reuse the existing list/show picker and output contract only.
   const base = buildDevCmd('actions', ACTION_TABLE, ['action'], ['name', 'active', 'sys_scope', 'sys_updated_on'], wrap, {
     singular: 'action', readOnly: true,
+    resolveIdentifier: (argv, app) => cancelled(() => pickDesignerRecord(argv, app, ACTION_TABLE, 'action')),
     showBreadcrumbs: (_record, id) => [
       { action: 'definition', cmd: `jsn actions definition ${id}`, description: 'Read complete executable definition' },
       { action: 'list', cmd: 'jsn actions list', description: 'Back to actions' },
@@ -26,7 +31,7 @@ export const actionsCmd = wrap => {
   // Retain the common wrap and output controller; domain failures get a
   // structured error envelope and nonzero exit, never a success-shaped dispatch.
   const run = handler => wrap(async (argv, app) => {
-    try { await handler(argv, app); }
+    try { await cancelled(() => handler(argv, app)); }
     catch (error) {
       if (!error.code?.startsWith('action_')) throw error;
       if (error.details) error.hint = JSON.stringify(error.details);
@@ -40,37 +45,43 @@ export const actionsCmd = wrap => {
     builder: y => base.builder(y)
       .command({
         command: 'create', describe: 'Create parent and executable Process Flow action; verify persistence',
-        builder: yy => dataOptions(yy).option('scope', { type: 'string', demandOption: true, describe: 'Exact target scope sys_id, or global' }),
+        builder: yy => dataOptions(yy).option('scope', { type: 'string', describe: 'Exact target scope sys_id, or global' }),
         handler: run(async (argv, app) => {
-          const definition = parseDataArg(argv);
-          const result = await app.sdk.createProcessFlowAction(argv.scope, definition);
+          const guided = !hasDefinitionData(argv) ? await guidedActionCreate(argv, app) : undefined;
+          const definition = guided?.definition ?? parseDataArg(argv);
+          const scope = guided?.scope ?? await designerScope(argv, app);
+          const result = await app.sdk.createProcessFlowAction(scope, definition);
           app.ok(result, { summary: `Created and verified action ${result.sys_id}` });
         }),
       })
       .command({
-        command: 'definition <identifier>', describe: 'Read full JSON definition including executable step_instances',
+        command: 'definition [identifier]', describe: 'Read full JSON definition including executable step_instances',
         builder: scopeOption,
         handler: run(async (argv, app) => {
           const id = await actionID(argv, app);
+          if (id === undefined) return;
           const scope = await actionScope(app.sdk, id, argv.scope);
           app.ok(await app.sdk.getProcessFlowAction(id, scope), { summary: `Read action definition ${id}` });
         }),
       })
       .command({
-        command: 'update <identifier>', aliases: ['edit'], describe: 'Save a full definition through Process Flow PUT and verify readback',
+        command: 'update [identifier]', aliases: ['edit'], describe: 'Save a full definition through Process Flow PUT and verify readback',
         builder: yy => dataOptions(scopeOption(yy)),
         handler: run(async (argv, app) => {
-          const definition = parseDataArg(argv);
+          if (!hasDefinitionData(argv) && !interactiveDesigner(argv, app)) throw errUsage('Provide --data-file or --data for the full action definition in noninteractive mode');
           const id = await actionID(argv, app);
+          if (id === undefined) return;
+          const definition = hasDefinitionData(argv) ? parseDataArg(argv)
+            : await guidedActionEdit(argv, app, await app.sdk.getProcessFlowAction(id, await actionScope(app.sdk, id, argv.scope)));
           const result = await app.sdk.updateProcessFlowAction(id, argv.scope, definition);
           app.ok(result, { summary: `Saved and verified action ${id}` });
         }),
       })
       .command({
-        command: 'test <identifier>', describe: 'Execute saved or supplied definition; optionally wait for actual outputs',
+        command: 'test [identifier]', describe: 'Execute saved or supplied definition; optionally wait for actual outputs',
         builder: yy => dataOptions(scopeOption(yy))
           .option('force', { type: 'boolean', default: false, describe: 'Confirm execution of action scripts, which may have side effects' })
-          .option('output-map', { type: 'string', default: '{}', describe: 'JSON action input names to values; sent as outputMap' })
+          .option('output-map', { type: 'string', describe: 'JSON action input names to values; sent as outputMap' })
           .option('run-on-thread', { type: 'boolean', default: true, describe: 'Run test on a worker thread' })
           .option('tracing-enabled', { type: 'boolean', default: false, describe: 'Enable Flow Designer tracing' })
           .option('wait', { type: 'boolean', default: false, describe: 'Wait for COMPLETE context and actual runtime outputs' })
@@ -79,9 +90,14 @@ export const actionsCmd = wrap => {
           let outputMap;
           try { outputMap = JSON.parse(argv['output-map'] ?? '{}'); }
           catch { throw errUsage('--output-map must be valid JSON'); }
-          const definition = argv['data-file'] || argv.data ? parseDataArg(argv) : undefined;
+          let definition = hasDefinitionData(argv) ? parseDataArg(argv) : undefined;
           const id = await actionID(argv, app);
-          await confirmDelete(app, argv, `Execute action '${argv.identifier}' scripts, which may have side effects`);
+          if (id === undefined) return;
+          if (argv['output-map'] === undefined && interactiveDesigner(argv, app)) {
+            definition = await app.sdk.getProcessFlowAction(id, await actionScope(app.sdk, id, argv.scope));
+            outputMap = await guidedActionTestInputs(argv, app, definition);
+          }
+          await confirmDesignerMutation(argv, app, `Execute action '${id}' scripts, which may have side effects`);
           const result = await app.sdk.testProcessFlowAction(id, argv.scope, definition, outputMap, {
             wait: argv.wait, timeout: argv.timeout, runOnThread: argv['run-on-thread'], tracingEnabled: argv['tracing-enabled'],
           });
@@ -90,19 +106,20 @@ export const actionsCmd = wrap => {
       })
       .command({
         command: 'step-types', describe: 'Read step schema templates for a target scope',
-        builder: yy => yy.option('scope', { type: 'string', demandOption: true, describe: 'Exact transaction scope sys_id, or global' }),
+        builder: yy => yy.option('scope', { type: 'string', describe: 'Exact transaction scope sys_id, or global' }),
         handler: run(async (argv, app) => {
-          await validateScope(app.sdk, argv.scope);
-          app.ok(await app.sdk.getProcessFlowStepTypes(argv.scope), { summary: 'Process Flow step schemas' });
+          const scope = await designerScope(argv, app);
+          app.ok(await app.sdk.getProcessFlowStepTypes(scope), { summary: 'Process Flow step schemas' });
         }),
       })
       .command({
-        command: 'delete <identifier>', describe: 'Delete action parent explicitly',
+        command: 'delete [identifier]', describe: 'Delete action parent explicitly',
         builder: yy => scopeOption(yy).option('force', { type: 'boolean', default: false, describe: 'Skip confirmation' }),
         handler: run(async (argv, app) => {
           const id = await actionID(argv, app);
+          if (id === undefined) return;
           await actionScope(app.sdk, id, argv.scope);
-          await confirmDelete(app, argv, `Delete action '${argv.identifier}'`);
+          await confirmDesignerMutation(argv, app, `Delete action '${id}'`);
           await app.sdk.delete(ACTION_TABLE, id);
           // Verify the exact target is absent. Do not interpret a 403 as deletion.
           const query = new URLSearchParams({ sysparm_query: `sys_id=${id}`, sysparm_limit: '1', sysparm_fields: 'sys_id', sysparm_display_value: 'false' });
@@ -115,7 +132,7 @@ export const actionsCmd = wrap => {
       }),
     handler: wrap(async (_argv, app) => {
       app.ok({ commands: ['list', 'show', 'definition', 'step-types', 'create', 'update', 'test', 'delete'] }, {
-        summary: 'Use jsn actions <command> --help. Create/update require full JSON definitions, not table fields.',
+        summary: 'Use jsn actions <command> --help. Create/update guide terminal users; automation uses full JSON definitions, not table fields.',
       });
     }),
   };

package/src/commands/flows.js

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { formatRecordForDisplay, getStringField, interactiveList, confirmDelete } from '../helpers.js';
+import { formatRecordForDisplay, getStringField, interactiveList } from '../helpers.js';
 import { discoverFlowContextFields, normalizeFlowContext, summarizeFlowContexts, formatFlowContextSummary, aggregateFlowContextMappings, mergeFlowContextStats, buildFlowContextQuery } from '../flow-context.js';
 import { declareCapabilities } from '../capabilities.js';
 import { inspectFlow } from '../flow-inspection.js';
@@ -7,6 +7,10 @@ import { publishFlows, publishFlowLifecycle, publishDoctor, flowStatus } from '.
 import { resolveRecord, unwrapSysId } from '../resolve-record.js';
 import { createFlowFromManifest, updateFlowFromManifest, readCurrentUpdateSet } from '../flow-create.js';
 import { testFlow } from '../flow-test.js';
+import { errUsage } from '../errors.js';
+import { cancelled, pickDesignerRecord, guidedFlowCreate, guidedFlowEdit, guidedFlowTestRecord, hasDefinitionData, confirmDesignerMutation } from '../flow-designer-interactive.js';
+
+const pickFlow = (argv, app, query = '') => pickDesignerRecord(argv, app, argv.action ? 'sys_hub_action_type_definition' : 'sys_hub_flow', argv.action ? 'action' : 'flow', query);
 
 function flowInspectionAdapter(app) {
   return {
@@ -15,7 +19,7 @@ function flowInspectionAdapter(app) {
   };
 }
 
-declareCapabilities('flows', { mutationSubcommands: ['create', 'update', 'delete', 'publish', 'test'] });
+declareCapabilities('flows', { mutationSubcommands: ['create', 'update', 'edit', 'delete', 'publish', 'test'] });
 
 function renderChecks(checks) {
   return checks.map((c) => {
@@ -25,6 +29,8 @@ function renderChecks(checks) {
 }
 
 export function flowsCmd(wrap) {
+  const originalWrap = wrap;
+  wrap = handler => originalWrap((argv, app) => cancelled(() => handler(argv, app)));
   return {
     command: 'flows [subcommand]',
     aliases: ['flow'],
@@ -143,7 +149,7 @@ export function flowsCmd(wrap) {
           }),
         })
         .command({
-          command: 'show <identifier>',
+          command: 'show [identifier]',
           aliases: ['get'],
           describe: 'Show flow details by name or sys_id',
           builder: (y) => y
@@ -153,9 +159,11 @@ export function flowsCmd(wrap) {
               describe: 'Expand nested subflows to this depth (1 = subflow names only, 2 = one level, 3+ = deeper)',
             }),
           handler: wrap(async (argv, app) => {
+            const identifier = await pickFlow(argv, app);
+            if (identifier === undefined) return;
             const inspection = await inspectFlow({
               adapter: flowInspectionAdapter(app),
-              identifier: argv.identifier,
+              identifier,
               instanceURL: app.getEffectiveInstance(),
               depth: argv.depth,
             });
@@ -168,20 +176,24 @@ export function flowsCmd(wrap) {
           }),
         })
         .command({
-          command: 'publish <identifier>',
+          command: 'publish [identifier]',
           aliases: ['activate'],
           describe: 'Publish (activate) a flow so it can actually run',
           builder: (y) => y
-            .option('action', { type: 'boolean', default: false, describe: 'Treat the identifier as a custom action rather than a flow' }),
+            .option('action', { type: 'boolean', default: false, describe: 'Treat the identifier as a custom action rather than a flow' })
+            .option('force', { type: 'boolean', default: false, describe: 'Confirm publication and activation' }),
           handler: wrap(async (argv, app) => {
             app.requireInstance();
+            const identifier = await pickFlow(argv, app);
+            if (identifier === undefined) return;
             const sysID = unwrapSysId(await resolveRecord(app.sdk, {
                 table: argv.action ? 'sys_hub_action_type_definition' : 'sys_hub_flow',
-                identifier: argv.identifier,
+                identifier,
                 matchField: 'name',
                 resource: argv.action ? 'Custom action' : 'Flow',
               }));
 
+            await confirmDesignerMutation(argv, app, `Publish and activate ${argv.action ? 'action' : 'flow'} ${sysID}?`);
             if (!argv.action) {
               const lifecycle = await publishFlowLifecycle(app.sdk, app.getEffectiveInstance(), sysID);
               return app.ok(lifecycle, {
@@ -201,12 +213,14 @@ export function flowsCmd(wrap) {
           }),
         })
         .command({
-          command: 'status <identifier>',
+          command: 'status [identifier]',
           describe: 'Check whether a flow is actually able to run',
           handler: wrap(async (argv, app) => {
             app.requireInstance();
+            const identifier = await pickFlow(argv, app);
+            if (identifier === undefined) return;
             const sysID = unwrapSysId(await resolveRecord(app.sdk, {
-              table: 'sys_hub_flow', identifier: argv.identifier, matchField: 'name', resource: 'Flow',
+              table: 'sys_hub_flow', identifier, matchField: 'name', resource: 'Flow',
             }));
             const status = await flowStatus(app.sdk, sysID);
 
@@ -217,15 +231,20 @@ export function flowsCmd(wrap) {
           }),
         })
         .command({
-          command: 'test <identifier>',
+          command: 'test [identifier]',
           describe: 'Execute a record-triggered flow against one record (may cause side effects)',
           builder: (y) => y
-            .option('record', { type: 'string', demandOption: true, describe: 'Trigger record sys_id to test against' })
+            .option('record', { type: 'string', describe: 'Trigger record sys_id to test against' })
             .option('force', { type: 'boolean', default: false, describe: 'Skip confirmation' }),
           handler: wrap(async (argv, app) => {
             app.requireInstance();
-            await confirmDelete(app, argv, `Execute flow test for ${argv.identifier} against record ${argv.record}; actions may cause side effects`);
-            const result = await testFlow(app.sdk, app.getEffectiveInstance(), argv.identifier, argv.record);
+            const identifier = await pickFlow(argv, app);
+            if (identifier === undefined) return;
+            argv = { ...argv, identifier };
+            const record = await guidedFlowTestRecord(argv, app);
+            if (record === undefined) return;
+            await confirmDesignerMutation(argv, app, `Execute flow test for ${identifier} against record ${record}; actions may cause side effects`);
+            const result = await testFlow(app.sdk, app.getEffectiveInstance(), identifier, record);
             return app.ok(result, {
               summary: result.status === 'completed'
                 ? `Flow test completed (${result.success ? 'success' : 'failed'})`
@@ -249,16 +268,16 @@ export function flowsCmd(wrap) {
         })
         .command({
           command: 'create',
-          describe: 'Create a draft flow from a schema-driven JSON manifest',
+          describe: 'Guide draft flow creation in a terminal, or use a schema-driven JSON manifest',
           builder: (y) => y
             .option('data', { type: 'string', describe: 'Flow manifest as inline JSON' })
             .option('data-file', { type: 'string', describe: 'Read the flow manifest from a JSON file' }),
           handler: wrap(async (argv, app) => {
             app.requireInstance();
             const dataFile = argv.dataFile ?? argv['data-file'];
-            if (!dataFile && argv.data === undefined) throw new Error('Provide --data-file or --data for the flow manifest');
             let manifest;
-            try {
+            if (!hasDefinitionData(argv)) manifest = await guidedFlowCreate(argv, app);
+            else try {
               const raw = dataFile ? fs.readFileSync(dataFile, 'utf8') : argv.data;
               manifest = JSON.parse(raw.charCodeAt?.(0) === 0xFEFF ? raw.slice(1) : raw);
             } catch (error) {
@@ -274,7 +293,8 @@ export function flowsCmd(wrap) {
           }),
         })
         .command({
-          command: 'update <identifier>',
+          command: 'update [identifier]',
+          aliases: ['edit'],
           describe: 'Safely update supported fields of an existing inactive Draft flow',
           builder: (y) => y
             .option('data', { type: 'string', describe: 'Update manifest as inline JSON' })
@@ -283,15 +303,18 @@ export function flowsCmd(wrap) {
           handler: wrap(async (argv, app) => {
             app.requireInstance();
             const dataFile = argv.dataFile ?? argv['data-file'];
-            if (!dataFile && argv.data === undefined) throw new Error('Provide --data-file or --data for the flow update manifest');
+            const identifier = await pickFlow(argv, app, !hasDefinitionData(argv) ? 'active=false^status=draft' : '');
+            if (identifier === undefined) return;
+            argv = { ...argv, identifier };
             let manifest;
-            try {
+            if (!hasDefinitionData(argv)) manifest = await guidedFlowEdit(argv, app);
+            else try {
               const raw = dataFile ? fs.readFileSync(dataFile, 'utf8') : argv.data;
               manifest = JSON.parse(raw.charCodeAt?.(0) === 0xFEFF ? raw.slice(1) : raw);
             } catch (error) {
               throw new Error(`Invalid flow update manifest JSON: ${error.message}`, { cause: error });
             }
-            await confirmDelete(app, argv, `Update draft flow ${argv.identifier}; unspecified components and inputs are preserved`);
+            await confirmDesignerMutation(argv, app, `Update draft flow ${identifier}; unspecified components and inputs are preserved`);
             const result = await updateFlowFromManifest(app.sdk, app.getEffectiveInstance(), argv.identifier, manifest, {
               readUpdateSet: () => readCurrentUpdateSet(app.sdk),
             });
@@ -302,34 +325,20 @@ export function flowsCmd(wrap) {
           }),
         })
         .command({
-          command: 'delete <identifier>',
+          command: 'delete [identifier]',
           describe: 'Delete a flow (not yet implemented)',
-          handler: wrap(async (_argv, _app) => {
-            throw new Error('Flow deletion requires the Flow Designer GraphQL API - not yet implemented.\n'
+          handler: wrap(async (argv, app) => {
+            const identifier = await pickFlow(argv, app);
+            if (identifier === undefined) return;
+            throw errUsage('Flow deletion requires the Flow Designer GraphQL API - not yet implemented.\n'
               + 'Use the ServiceNow web UI to delete flows.');
           }),
         });
     },
-    handler: () => {
-      console.log('Manage Flow Designer flows from the sys_hub_flow table.');
-      console.log('');
-      console.log('Available subcommands:');
-      console.log('  list                  List flows');
-      console.log('  executions            Show flow executions from sys_flow_context');
-      console.log('  show <identifier>     Show flow details by name or sys_id');
-      console.log('  status <identifier>   Check whether a flow is actually able to run');
-      console.log('  publish <identifier>  Publish (activate) a flow');
-      console.log('  test <identifier>    Execute a record-triggered flow against one record');
-      console.log('  doctor                Check whether this instance can publish flows');
-      console.log('  create                Create a draft flow from a JSON manifest');
-      console.log('  update <identifier>   Safely update supported fields of an existing Draft flow');
-      console.log('  delete <identifier>   Delete a flow (not yet implemented)');
-      console.log('');
-      console.log('Run "jsn flows <command> --help" for details.');
-      console.log('');
-      console.log('Note: Flow structure comes from the ProcessFlow API (the Flow');
-      console.log('Designer UI source), so V1, V2, and subflow definitions all');
-      console.log('render with full action inputs and conditions.');
-    },
+    handler: wrap(async (_argv, app) => {
+      app.ok({ commands: ['list', 'executions', 'show', 'status', 'publish', 'test', 'doctor', 'create', 'update', 'delete'] }, {
+        summary: 'Use jsn flows <command> --help. Human terminals can omit targets and guide create/edit; automation uses explicit identifiers and manifests.',
+      });
+    }),
   };
 }

package/src/errors.js

@@ -204,6 +204,11 @@ export function renderAppError(err, { app = null, argv = null, identifier = '' }
   // 'usage' is the legacy literal; CodeUsage ('usage_error') is the
   // exported constant. Both render as the usage class.
   if (code === CodeUsage || code === 'usage') {
+    // Interactive command families can opt into machine-readable fail-fast errors
+    // without changing the legacy stderr contract for other usage errors.
+    if (err.jsonEnvelope === true && resolveJsonMode(app, argv) && app) {
+      return { stream: 'stdout', text: null, exitCode: 2, appErr: true };
+    }
     return { stream: 'stderr', text: `Error (usage): ${err.message}\n`, exitCode: 2 };
   }
 

package/src/flow-create.js

@@ -91,7 +91,7 @@ function assertGraphQLSuccess(response, operation) {
   if (response?.result?.errorMessage) throw new Error(`${operation} failed: ${response.result.errorMessage}`);
 }
 
-function schemaEntries(definition) {
+function schemaEntries(definition, requireTypes = false) {
   const entries = [];
   const seen = new Set();
   walk(definition, object => {
@@ -102,6 +102,7 @@ function schemaEntries(definition) {
         const name = stringValue(field.name || field.key || field.element || field.parameter);
         if (!name || seen.has(name)) continue;
         seen.add(name);
+        if (requireTypes && !stringValue(field.type || field.inputType || field.valueType)) throw new Error(`Input ${name} has no provider type; refusing to invent a guided schema`);
         entries.push({
           ...field,
           name,
@@ -193,7 +194,7 @@ export function buildFlowUpdateMutation({ flowId, triggerUpdates = [], actionUpd
   return `mutation { global { snFlowDesigner { flow(${patch}) { triggerInstances { updates } actions { updates } } } } }`;
 }
 
-async function readProcessFlow(sdk, instance, flowId, scope) {
+export async function readProcessFlow(sdk, instance, flowId, scope) {
   if (!scope) throw new Error(`Flow ${flowId} has no transaction scope for ProcessFlow read`);
   const endpoint = `${instance}${FLOW_ENDPOINT}/${encodeURIComponent(flowId)}?sysparm_transaction_scope=${encodeURIComponent(scope)}`;
   const response = await sdk.request(endpoint, { method: 'GET' });
@@ -220,11 +221,11 @@ async function resolveActionType(sdk, actionType) {
   return { id: actionTypeId(record), record };
 }
 
-async function readActionDefinition(sdk, instance, actionTypeId, scope) {
+export async function readActionDefinition(sdk, instance, actionTypeId, scope, { requireTypes = false } = {}) {
   const endpoint = `${instance}/api/now/processflow/action/action_types/${encodeURIComponent(actionTypeId)}?sysparm_transaction_scope=${encodeURIComponent(scope)}`;
   const response = await sdk.request(endpoint, { method: 'GET' });
   const definition = response?.result ?? response?.data?.result ?? response?.data ?? response;
-  const schema = schemaEntries(definition);
+  const schema = schemaEntries(definition, requireTypes);
   if (schema.length === 0) throw new Error(`Action type ${actionTypeId} returned no input schema`);
   return { definition, schema };
 }
@@ -257,7 +258,7 @@ function parseSimpleCondition(condition) {
   return { field: match[1], operator: match[2], term: match[3] };
 }
 
-async function readTableDescriptor(sdk, instance, scope, table, override) {
+export async function readTableDescriptor(sdk, instance, scope, table, override) {
   if (override) return override(table);
   const endpoint = `${instance}${TABLE_DESCRIPTOR_ENDPOINT}?table=${encodeURIComponent(table)}&sysparm_transaction_scope=${encodeURIComponent(scope)}`;
   const response = await sdk.request(endpoint, { method: 'GET' });

package/src/flow-designer-interactive.js

@@ -0,0 +1,327 @@
+// Terminal orchestration only. Persistence and lifecycle remain in the SDK.
+import fs from 'node:fs';
+import { randomUUID, randomBytes } from 'node:crypto';
+import { input, select, confirm, editor } from '@inquirer/prompts';
+import { canPrompt, interactiveList, getStringField } from './helpers.js';
+import { FormatAuto } from './output.js';
+import { errUsage, errConfirmationRequired } from './errors.js';
+import { getCurrentUser, getCurrentApplication } from './context.js';
+import { validateDefinition, validateScope, ACTION_TABLE } from './processflow-actions.js';
+import { validateFlowManifest, validateFlowUpdateManifest, readProcessFlow, readActionDefinition, readTableDescriptor } from './flow-create.js';
+import { deriveRecordTrigger } from './flow-test.js';
+import { getActiveProfile } from './config.js';
+
+const CANCEL = Symbol('cancel');
+const clone = value => structuredClone(value);
+export const rawField = value => value && typeof value === 'object' && 'value' in value ? value.value : value;
+const prompts = app => app.flowDesignerPrompts || { input, select, confirm, editor };
+export function hasDefinitionData(argv) {
+  return argv.data !== undefined || argv['data-file'] !== undefined || argv.dataFile !== undefined;
+}
+export function interactiveDesigner(argv, app) {
+  return !hasDefinitionData(argv) && argv['output-map'] === undefined && !argv.get && app.output?.getFormat() === FormatAuto && canPrompt();
+}
+export async function cancelled(operation) {
+  try { return await operation(); }
+  catch (error) {
+    if (error === CANCEL || ['ExitPromptError', 'AbortPromptError'].includes(error.name)) return undefined;
+    // Keep direct handler errors throwable; opt into the shared JSON renderer at the CLI boundary.
+    if (error.code === 'usage_error') error.jsonEnvelope = true;
+    throw error;
+  }
+}
+export async function pickDesignerRecord(argv, app, table, singular, query = '', labelField = 'name') {
+  if (argv.identifier !== undefined) {
+    if (!String(argv.identifier).trim()) throw errUsage(`${singular} identifier must not be empty`);
+    return argv.identifier;
+  }
+  if (!interactiveDesigner(argv, app)) throw errUsage(`Provide an explicit ${singular} identifier in noninteractive mode`);
+  const picked = await interactiveList({ app, table, singular, query, labelField,
+    columns: [labelField], promptFn: app.promptFn });
+  if (picked === null) throw errUsage(`No readable ${singular} records are available for selection`);
+  if (picked === undefined) return undefined;
+  const id = rawField(picked.sys_id);
+  if (!id) throw errUsage(`Selected ${singular} has no raw sys_id`);
+  return id;
+}
+export async function designerScope(argv, app) {
+  if (argv.scope !== undefined) return validateScope(app.sdk, argv.scope);
+  if (!interactiveDesigner(argv, app)) throw errUsage('Provide --scope <exact sys_id or global> in noninteractive mode');
+  const user = await getCurrentUser(app.sdk);
+  const current = user ? await getCurrentApplication(app.sdk, user.sys_id) : null;
+  if (current?.appSysId && await prompts(app).confirm({ message: `Use current application scope ${current.appSysId}?`, default: true })) {
+    return validateScope(app.sdk, current.appSysId);
+  }
+  const scope = await pickDesignerRecord(argv, app, 'sys_scope', 'scope');
+  if (scope === undefined) throw CANCEL;
+  return validateScope(app.sdk, scope);
+}
+export async function confirmDesignerSave(app, message) {
+  if (!await prompts(app).confirm({ message, default: false })) throw CANCEL;
+}
+// Explicit JSON/data, pipes and disabled prompts never enter a TTY confirmation.
+export async function confirmDesignerMutation(argv, app, message) {
+  if (argv.force) return;
+  if (interactiveDesigner(argv, app)) return confirmDesignerSave(app, message);
+  if (getActiveProfile(app.config)?.skip_confirmations === true) return;
+  throw errConfirmationRequired(message, ['jsn', ...(argv._ || [])].join(' '));
+}
+function required(value) { return String(value).trim() ? true : 'A value is required'; }
+function scalarDefault(value) { return value == null ? '' : typeof value === 'string' ? value : JSON.stringify(value); }
+function schemaObjectValue(field, value) {
+  return ['object', 'complex'].includes(field.type) && value && typeof value === 'object'
+    && !('schemaless' in value) && field.children?.some(child => Object.hasOwn(value, child.name));
+}
+
+// Preserve schema objects. Change only a requested value, never regenerate metadata.
+export async function promptSchemaValue(app, field, existing, prefix = '') {
+  if (!field?.name || !field.type) throw errUsage('Provider returned an incomplete named, typed input schema');
+  const p = prompts(app);
+  const message = `${prefix}${field.label || field.name} [${field.type}]`;
+  const supplied = existing ?? field.defaultValue ?? field.default;
+  const value = schemaObjectValue(field, supplied) ? supplied : rawField(supplied);
+  if (field.type === 'script') {
+    const method = await p.select({ message: `${message}: script source`, choices: [
+      { name: 'Script file', value: 'file' }, { name: 'Open $VISUAL/$EDITOR', value: 'editor' },
+    ] });
+    const script = method === 'file'
+      ? fs.readFileSync(await p.input({ message: 'Script file path', validate: required }), 'utf8')
+      : await p.editor({ message, default: scalarDefault(value), waitForUse: true });
+    if ((field.mandatory === true || field.required === true) && !script.trim()) throw errUsage(`Script ${field.name} is required; nothing was saved`);
+    return script;
+  }
+  if (typeof value === 'string' && value.startsWith('{{')) {
+    return p.input({ message: `${message} (raw pill)`, default: value, validate: required });
+  }
+  if (field.children?.length && ['object', 'complex'].includes(field.type)) {
+    const result = value && typeof value === 'object' && !Array.isArray(value) ? clone(value) : {};
+    for (const child of field.children) result[child.name] = await promptSchemaValue(app, child, result[child.name], `${message}.`);
+    return result;
+  }
+  if (['boolean', 'bool'].includes(field.type)) {
+    return p.confirm({ message, default: value === true || value === 'true' });
+  }
+  if (field.type === 'choice' && Array.isArray(field.choices) && field.choices.length) {
+    if (field.choices.some(choice => typeof choice !== 'string' && (!choice || !Object.hasOwn(choice, 'value')))) {
+      throw errUsage(`Choice input ${field.name} has incomplete provider choices; nothing was saved`);
+    }
+    return p.select({ message, default: value, choices: field.choices.map(choice => ({
+      name: typeof choice === 'string' ? choice : String(choice.label ?? choice.display_value ?? choice.value),
+      value: typeof choice === 'string' ? choice : choice.value,
+    })) });
+  }
+  const textual = ['string', 'reference', 'table_name', 'field_name', 'conditions', 'condition', 'html', 'url', 'email', 'choice', 'document_id'];
+  const numeric = ['integer', 'number', 'decimal', 'float'];
+  if (![...textual, ...numeric].includes(field.type)) {
+    throw errUsage(`Guided input ${field.name} has unsupported type ${field.type}; use --data-file to preserve its complete schema and value`);
+  }
+  const answer = await p.input({ message: `${message} (raw pills accepted)`, default: scalarDefault(value), validate: answer => {
+    if ((field.mandatory === true || field.required === true) && answer === '') return 'A value is required';
+    if (numeric.includes(field.type) && answer !== '' && !answer.startsWith('{{') && (!Number.isFinite(Number(answer)) || field.type === 'integer' && !Number.isInteger(Number(answer)))) return 'Enter a valid number or raw pill';
+    return true;
+  } });
+  // Pills are opaque provider expressions, not numbers to be coerced.
+  return numeric.includes(field.type) && answer !== '' && !answer.startsWith('{{') ? Number(answer) : answer;
+}
+async function editVariables(app, variables, message, valueKey = 'value') {
+  for (const field of variables.filter(field => !field.name.startsWith('__'))) {
+    if (await prompts(app).confirm({ message: `${message}: change ${field.name}?`, default: false })) {
+      const value = await promptSchemaValue(app, field, field[valueKey], `${message}: `);
+      const wrapped = field[valueKey] && typeof field[valueKey] === 'object' && 'value' in field[valueKey] && !schemaObjectValue(field, field[valueKey]);
+      field[valueKey] = wrapped ? { ...field[valueKey], value } : value;
+      if (valueKey === 'defaultValue') field.mandatory = await prompts(app).confirm({ message: `${field.name}: required?`, default: field.mandatory === true });
+    }
+  }
+}
+function schemaTemplates(types) {
+  const templates = [];
+  const visit = fields => {
+    if (fields !== undefined && !Array.isArray(fields)) throw errUsage('Provider variable schema must be an array; no parent was allocated');
+    for (const field of fields || []) {
+      if (!field || typeof field !== 'object') throw errUsage('Provider variable schema requires objects; no parent was allocated');
+      if (field.name && field.type && !field.name.startsWith('__')) templates.push(field);
+      visit(field.children);
+    }
+  };
+  for (const type of types) { visit(type.inputs); visit(type.outputs); visit(type.extended_inputs); visit(type.extended_outputs); }
+  return templates;
+}
+function freshVariable(template) {
+  const field = clone(template);
+  const renew = variable => {
+    variable.id = randomBytes(16).toString('hex');
+    if (variable.attributes?.uiUniqueId) variable.attributes.uiUniqueId = randomUUID();
+    for (const child of variable.children || []) renew(child);
+  };
+  renew(field);
+  return field;
+}
+async function newVariable(app, templates, message) {
+  const candidates = templates.filter(field => ['string', 'integer', 'boolean', 'reference', 'object'].includes(field.type));
+  if (!candidates.length) throw errUsage('Step schemas contain no supported variable templates; use --data-file');
+  const template = await prompts(app).select({ message: `${message}: select provider schema template`, choices: candidates.map(field => ({ name: `${field.name} [${field.type}]`, value: field })) });
+  const field = freshVariable(template);
+  field.name = await prompts(app).input({ message: `${message}: variable name`, validate: value => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value) || 'Use a JavaScript variable name' });
+  field.label = field.name;
+  field.mandatory = await prompts(app).confirm({ message: `${field.name}: required?`, default: false });
+  delete field.value;
+  delete field.display_value;
+  return field;
+}
+export function stepTypeSchemas(response) {
+  const types = Array.isArray(response) ? response : response?.step_types ?? response?.stepTypes;
+  if (!Array.isArray(types) || !types.length) throw errUsage('Provider returned no supported step_types schema array; no parent was allocated');
+  return types;
+}
+export async function guidedActionCreate(argv, app) {
+  if (!interactiveDesigner(argv, app)) throw errUsage('Provide --data-file or --data for a full action definition in noninteractive mode');
+  const scope = await designerScope(argv, app);
+  const types = stepTypeSchemas(await app.sdk.getProcessFlowStepTypes(scope));
+  const definition = { scope, name: await prompts(app).input({ message: 'Action name', validate: required }),
+    description: await prompts(app).input({ message: 'Description' }), inputs: [], outputs: [], steps: [] };
+  const templates = schemaTemplates(types);
+  while (await prompts(app).confirm({ message: 'Add an action input?', default: false })) {
+    definition.inputs.push(await newVariable(app, templates, 'Action input'));
+  }
+  do {
+    const schema = await prompts(app).select({ message: 'Select executable step schema', choices: types.map(type => ({ name: type.name || type.step_type_name || type.type || type.step_type, value: type })) });
+    if (!(schema.type || schema.step_type) || !(schema.id || schema.step_type_id) || !Array.isArray(schema.inputs) || !Array.isArray(schema.outputs)) {
+      throw errUsage('Selected provider step schema is incomplete; no parent was allocated');
+    }
+    const step = { ...clone(schema), cid: randomUUID(), step_type: schema.step_type || schema.type,
+      step_type_id: schema.step_type_id || schema.id, order: definition.steps.length + 1,
+      inputs: clone(schema.inputs), outputs: clone(schema.outputs),
+      extended_inputs: clone(schema.extended_inputs || []), extended_outputs: clone(schema.extended_outputs || []) };
+    delete step.id;
+    delete step.step_id;
+    delete step.action;
+    for (const field of step.inputs) field.value = await promptSchemaValue(app, field, field.value);
+    if (step.step_type === 'SCRIPT') {
+      for (const field of definition.inputs) step.extended_inputs.push({ ...freshVariable(field), extended: true, value: `{{inputs.${field.name}}}` });
+      while (await prompts(app).confirm({ message: 'Declare a script step output?', default: false })) {
+        step.extended_outputs.push({ ...await newVariable(app, templates, 'Script output'), extended: true });
+      }
+    }
+    definition.steps.push(step);
+  } while (await prompts(app).confirm({ message: 'Add another step?', default: false }));
+  const outputs = definition.steps.flatMap(step => [...step.outputs, ...step.extended_outputs]
+    .filter(field => !field.name.startsWith('__')).map(field => ({ step, field })));
+  while (await prompts(app).confirm({ message: 'Map a step output to an action output?', default: false })) {
+    if (!outputs.length) throw errUsage('No provider-declared step outputs available');
+    const { step, field } = await prompts(app).select({ message: 'Select output', choices: outputs.map(candidate => ({ name: `Step ${candidate.step.order}: ${candidate.field.name}`, value: candidate })) });
+    const output = { ...freshVariable(field), extended: false };
+    output.name = await prompts(app).input({ message: 'Action output name', default: field.name, validate: required });
+    output.value = `{{step[${step.cid}].${field.name}}}`;
+    definition.outputs.push(output);
+  }
+  validateDefinition(definition, undefined, scope);
+  await confirmDesignerSave(app, `Create inactive draft action '${definition.name}' with ${definition.steps.length} step(s)? No publish or execution.`);
+  return { scope, definition };
+}
+export async function guidedActionEdit(argv, app, definition) {
+  if (!interactiveDesigner(argv, app)) throw errUsage('Provide --data-file or --data for the full action definition in noninteractive mode');
+  validateDefinition(definition, definition.id, definition.scope);
+  const edited = clone(definition);
+  const fields = await prompts(app).select({ message: 'Edit action', choices: [
+    { name: 'Name and description', value: 'metadata' }, { name: 'Action inputs', value: 'inputs' },
+    { name: 'Action output mappings', value: 'outputs' }, { name: 'Step inputs, scripts and mappings', value: 'steps' },
+  ] });
+  if (fields === 'metadata') {
+    edited.name = await prompts(app).input({ message: 'Action name', default: edited.name, validate: required });
+    if (Object.hasOwn(edited, 'displayName')) edited.displayName = edited.name;
+    edited.description = await prompts(app).input({ message: 'Description', default: edited.description || '' });
+  } else if (fields === 'steps') {
+    const step = await prompts(app).select({ message: 'Select saved step', choices: edited.steps.map(step => ({ name: `${step.order}: ${step.step_type}`, value: step })) });
+    await editVariables(app, step.inputs, 'Step input');
+    await editVariables(app, step.extended_inputs, 'Step input mapping');
+    await editVariables(app, step.extended_outputs, 'Step output');
+  } else await editVariables(app, edited[fields], fields, fields === 'inputs' ? 'defaultValue' : 'value');
+  validateDefinition(edited, definition.id, definition.scope);
+  await confirmDesignerSave(app, `Save action '${edited.name}'? Unspecified schema and lifecycle identities are preserved. No publish or execution.`);
+  return edited;
+}
+export async function guidedActionTestInputs(argv, app, definition) {
+  const values = {};
+  for (const field of definition.inputs) values[field.name] = await promptSchemaValue(app, field, field.defaultValue, 'Test input: ');
+  return values;
+}
+async function tableName(argv, app) {
+  const id = await pickDesignerRecord(argv, app, 'sys_db_object', 'trigger table');
+  if (id === undefined) throw CANCEL;
+  const table = await app.sdk.get('sys_db_object', id);
+  const name = rawField(table?.name);
+  if (!name) throw errUsage('Selected trigger table has no raw name');
+  return name;
+}
+export async function guidedFlowCreate(argv, app) {
+  if (!interactiveDesigner(argv, app)) throw errUsage('Provide --data-file or --data for the flow manifest in noninteractive mode');
+  const manifest = { name: await prompts(app).input({ message: 'Flow name', validate: required }),
+    description: await prompts(app).input({ message: 'Description' }), scope: await designerScope(argv, app),
+    trigger: { type: 'record_create_or_update', table: await tableName(argv, app),
+      condition: await prompts(app).input({ message: 'Trigger condition (single supported encoded predicate, or empty)' }) }, actions: [] };
+  while (await prompts(app).confirm({ message: 'Add a published action?', default: true })) {
+    const id = await pickDesignerRecord(argv, app, ACTION_TABLE, 'published action', 'active=true^published=true');
+    if (id === undefined) throw CANCEL;
+    const { schema } = await readActionDefinition(app.sdk, app.getEffectiveInstance(), id, manifest.scope, { requireTypes: true });
+    const inputs = {};
+    for (const field of schema) {
+      if (!field.id || !field.parameter || typeof field.parameter !== 'object' || Array.isArray(field.parameter)) {
+        throw errUsage(`Published action input ${field.name} lacks provider id/parameter metadata; no flow was allocated`);
+      }
+      inputs[field.name] = await promptSchemaValue(app, field, field.default, 'Action input: ');
+    }
+    manifest.actions.push({ type: id, inputs });
+  }
+  validateFlowManifest(manifest);
+  await confirmDesignerSave(app, `Create inactive draft flow '${manifest.name}' with ${manifest.actions.length} action(s)? No publish or execution.`);
+  return manifest;
+}
+export async function savedFlowDefinition(app, identifier) {
+  const { resolveRecord, unwrapSysId } = await import('./resolve-record.js');
+  const record = await resolveRecord(app.sdk, { table: 'sys_hub_flow', identifier, matchField: 'name', resource: 'flow' });
+  const id = unwrapSysId(record);
+  const scope = rawField(record.scope);
+  if (!scope) throw errUsage('Saved flow has no raw transaction scope');
+  return { record, definition: await readProcessFlow(app.sdk, app.getEffectiveInstance(), id, scope) };
+}
+export async function guidedFlowEdit(argv, app) {
+  if (!interactiveDesigner(argv, app)) throw errUsage('Provide --data-file or --data for the flow update manifest in noninteractive mode');
+  const { record, definition } = await savedFlowDefinition(app, argv.identifier);
+  if (rawField(record.active) === true || rawField(record.active) === 'true' || rawField(record.status) !== 'draft') throw errUsage('Guided flow edit requires an inactive Draft');
+  const manifest = {};
+  const choice = await prompts(app).select({ message: 'Edit supported draft flow fields', choices: [
+    { name: 'Record trigger condition', value: 'trigger' }, { name: 'Existing action input values', value: 'actions' },
+  ] });
+  if (choice === 'trigger') {
+    const trigger = deriveRecordTrigger(definition).trigger;
+    const condition = (trigger.inputs || []).find(field => field.name === 'condition');
+    manifest.trigger = { condition: await prompts(app).input({ message: 'Trigger condition (single supported encoded predicate, or empty)', default: rawField(condition?.value) || '' }) };
+  } else {
+    const actions = definition.actionInstances || definition.actions || [];
+    if (!actions.length) throw errUsage('Saved flow contains no supported action instances');
+    const action = await prompts(app).select({ message: 'Select saved action instance', choices: actions.map(action => ({ name: `${action.order}: ${getStringField(action, 'name') || action.actionTypeSysId}`, value: action })) });
+    const fields = action.inputs || action.inputValues || [];
+    if (!fields.length) throw errUsage('Saved action instance contains no input schema');
+    const field = await prompts(app).select({ message: 'Select input to change', choices: fields.map(field => ({ name: `${field.name} [${field.type || field.parameter?.type || 'unknown'}]`, value: field })) });
+    const actionType = rawField(action.actionTypeSysId || action.action_type_sys_id || action.actionType?.sys_id || action.actionType?.sysId);
+    let inputSchema = { ...field, type: field.type || field.parameter?.type };
+    if (!inputSchema.type) {
+      const { schema } = await readActionDefinition(app.sdk, app.getEffectiveInstance(), actionType, rawField(record.scope), { requireTypes: true });
+      inputSchema = schema.find(candidate => candidate.name === field.name);
+      if (!inputSchema) throw errUsage(`Saved action input ${field.name} is absent from its provider schema`);
+    }
+    const value = await promptSchemaValue(app, inputSchema, rawField(field.value));
+    manifest.actions = [{ order: Number(action.order), type: actionType, inputs: { [field.name]: value } }];
+  }
+  validateFlowUpdateManifest(manifest);
+  return manifest;
+}
+export async function guidedFlowTestRecord(argv, app) {
+  if (argv.record !== undefined) return argv.record;
+  if (!interactiveDesigner(argv, app)) throw errUsage('Provide --record <sys_id> in noninteractive mode');
+  const { record, definition } = await savedFlowDefinition(app, argv.identifier);
+  const { table } = deriveRecordTrigger(definition);
+  const descriptor = await readTableDescriptor(app.sdk, app.getEffectiveInstance(), rawField(record.scope), table);
+  const { identifier: _identifier, ...pickerArgs } = argv;
+  return pickDesignerRecord(pickerArgs, app, table, `test record in ${table}`, '', descriptor.displayField);
+}