flowmind 1.5.3 → 1.5.6

package/skills/auto-flow/index.js

@@ -6,6 +6,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { callMcpTool } = require('../../core/mcp-http-client');
 
 const BUILTIN_WORKFLOWS = {
   'dev-workflow': {
@@ -72,19 +73,14 @@ module.exports = {
     const workflow = createWorkflowClient(context);
 
     if (params.action === 'define') {
+      const definition = buildWorkflowDefinitionSummary();
       return {
         type: 'result',
         skill: 'auto-flow',
         message: 'Define a workflow in YAML format',
         data: {
           format: 'YAML workflow definition',
-          example: {
-            name: 'My Workflow',
-            steps: [
-              { id: 'step1', action: 'run-command', command: 'echo hello' },
-              { id: 'step2', skill: 'code-review', depends_on: ['step1'] }
-            ]
-          }
+          execution: definition
         },
         input,
         timestamp: new Date().toISOString()
@@ -96,7 +92,7 @@ module.exports = {
     }
 
     if (params.action === 'status') {
-      await executeStatus(workflow, params, input);
+      const execution = await executeStatus(workflow, params, input);
       return {
         type: 'result',
         skill: 'auto-flow',
@@ -106,7 +102,8 @@ module.exports = {
           provider: workflow.provider,
           binding: workflow.binding,
           status: 'completed',
-          mcpServer: getWorkflowMcpServer(workflow)
+          mcpServer: getWorkflowMcpServer(workflow),
+          execution: summarizeWorkflowExecution('status', params, execution)
         },
         input,
         timestamp: new Date().toISOString()
@@ -118,7 +115,7 @@ module.exports = {
     }
 
     if (params.action === 'list' || params.serviceNames.length > 0) {
-      await workflow.client.listPipelines(buildListPipelineParams(params));
+      const execution = await workflow.client.listPipelines(buildListPipelineParams(params));
       return {
         type: 'result',
         skill: 'auto-flow',
@@ -128,7 +125,8 @@ module.exports = {
           provider: workflow.provider,
           binding: workflow.binding,
           status: 'completed',
-          mcpServer: getWorkflowMcpServer(workflow)
+          mcpServer: getWorkflowMcpServer(workflow),
+          execution: summarizeWorkflowExecution('list', params, execution)
         },
         input,
         timestamp: new Date().toISOString()
@@ -143,7 +141,7 @@ module.exports = {
         message: `Workflow ready: ${workflowDef.name}`,
         data: {
           workflow: params.workflow,
-          steps: workflowDef.steps,
+          execution: buildBuiltinWorkflowSummary(params.workflow, workflowDef),
           provider: workflow.provider
         },
         input,
@@ -164,7 +162,8 @@ module.exports = {
         ],
         builtinWorkflows: Object.keys(BUILTIN_WORKFLOWS),
         provider: workflow.provider,
-        binding: workflow.binding
+        binding: workflow.binding,
+        execution: buildAutoFlowHintSummary(workflow)
       },
       input,
       timestamp: new Date().toISOString()
@@ -191,40 +190,391 @@ function createWorkflowClient(context) {
     return { client: null, provider: null, binding: null, transportBacked: false };
   }
 
+  const transport = buildWorkflowTransport(binding);
+  if (!transport.url) {
+    return { client: null, provider: binding.provider || null, binding, transportBacked: false };
+  }
+
   return {
     client: {
       providerName: binding.provider || 'workflow-binding',
       async listPipelines(params) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.listPipelines, params };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.listPipelines, params);
       },
       async getCurrentIterate() {
-        return { mcpServer: binding.mcpServer, tool: 'getCurrentIterate', params: {} };
+        return callWorkflowMcp(binding, transport, 'getCurrentIterate', {});
       },
       async listDeployChecklists(params) {
-        return { mcpServer: binding.mcpServer, tool: 'listDeployChecklists', params };
+        return callWorkflowMcp(binding, transport, 'listDeployChecklists', params);
       },
       async orderList(params) {
-        return { mcpServer: binding.mcpServer, tool: 'orderList', params };
+        return callWorkflowMcp(binding, transport, 'orderList', params);
       },
       async startPipelineRun(pipelineId) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.startPipelineRun, params: { pipelineId } };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.startPipelineRun, { pipelineId });
       },
       async startBatchPipelineRun(params) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.startBatchPipelineRun, params };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.startBatchPipelineRun, params);
       },
       async getPipelineRun(pipelineId, runId) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.getPipelineRun, params: { pipelineId, pipelineRunId: runId } };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.getPipelineRun, { pipelineId, pipelineRunId: runId });
       },
       async listPipelineRuns(pipelineId, params) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.listPipelineRuns, params: { pipelineId, ...(params || {}) } };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.listPipelineRuns, { pipelineId, ...(params || {}) });
       }
     },
     provider: binding.provider || 'workflow-binding',
     binding,
-    transportBacked: false
+    transportBacked: true
+  };
+}
+
+function buildWorkflowTransport(binding) {
+  const connection = binding?.connection || {};
+  const headers = {};
+
+  if (connection.token) {
+    headers.Authorization = `Bearer ${connection.token}`;
+  }
+  if (connection.apiKey) {
+    headers['X-API-Key'] = connection.apiKey;
+  }
+
+  return {
+    url: connection.url || connection.address || connection.endpoint || null,
+    headers,
+    timeoutMs: connection.timeoutMs || 60000
+  };
+}
+
+function callWorkflowMcp(binding, transport, tool, params) {
+  return callMcpTool({
+    url: transport.url,
+    headers: transport.headers,
+    tool,
+    args: params || {},
+    timeoutMs: transport.timeoutMs || 60000,
+    serverName: binding.mcpServer || binding.provider || 'workflow'
+  });
+}
+
+function summarizeWorkflowExecution(action, params, execution) {
+  const payload = unwrapMcpResult(execution);
+  const records = extractRecords(payload);
+  const total = extractTotalCount(payload, records);
+
+  return compactObject({
+    action,
+    summary: buildWorkflowSummaryText(action, params, total, records),
+    total,
+    status: extractWorkflowStatus(payload, action),
+    target: buildWorkflowTargetLabel(params),
+    environment: params.environment || null,
+    items: records.slice(0, 5).map((record) => summarizeWorkflowRecord(record))
+  });
+}
+
+function summarizeDeployExecution(params, execution, context = {}) {
+  const payload = unwrapMcpResult(execution);
+  const payloadList = Array.isArray(payload) ? payload : [payload];
+  const primary = payloadList.find((item) => item !== null && item !== undefined) || null;
+  const summaryTarget = buildWorkflowTargetLabel(params) || buildDeployTargetLabel(context) || 'deployment';
+
+  return compactObject({
+    action: 'deploy',
+    summary: buildDeploySummaryText(summaryTarget, primary, context, payloadList.length),
+    status: extractDeployStatus(primary),
+    target: summaryTarget,
+    pipelineId: context.pipelineId || params.pipelineId || (Array.isArray(context.pipelineIds) && context.pipelineIds.length === 1 ? context.pipelineIds[0] : null),
+    pipelineIds: Array.isArray(context.pipelineIds) && context.pipelineIds.length > 0 ? context.pipelineIds : null,
+    source: context.source || null,
+    runId: extractDeployRunId(primary),
+    count: payloadList.length > 1 ? payloadList.length : null,
+    details: summarizeDeployDetails(primary)
+  });
+}
+
+function buildWorkflowDefinitionSummary() {
+  return {
+    action: 'define',
+    summary: 'Prepared a YAML workflow template',
+    format: 'YAML workflow definition',
+    example: {
+      name: 'My Workflow',
+      steps: [
+        { id: 'step1', action: 'run-command', command: 'echo hello' },
+        { id: 'step2', skill: 'code-review', depends_on: ['step1'] }
+      ]
+    }
   };
 }
 
+function buildBuiltinWorkflowSummary(workflowName, workflowDef) {
+  return {
+    action: 'workflow',
+    summary: `Workflow ready: ${workflowDef.name}`,
+    workflow: workflowName,
+    name: workflowDef.name,
+    stepCount: Array.isArray(workflowDef.steps) ? workflowDef.steps.length : 0,
+    steps: (workflowDef.steps || []).map((step) => compactObject({
+      id: step.id,
+      skill: step.skill || null,
+      action: step.action || null,
+      name: step.name || null,
+      depends_on: Array.isArray(step.depends_on) ? step.depends_on : null
+    }))
+  };
+}
+
+function buildAutoFlowHintSummary(workflow) {
+  return {
+    action: 'hint',
+    summary: workflow?.binding
+      ? `Workflow service bound to ${workflow.binding.mcpServer}`
+      : 'Workflow service not configured',
+    provider: workflow?.provider || null,
+    binding: workflow?.binding || null,
+    configured: !!workflow?.client
+  };
+}
+
+function buildWorkflowSummaryText(action, params, total, records) {
+  const target = buildWorkflowTargetLabel(params) || 'all workflows';
+  const count = typeof total === 'number' ? total : records.length;
+
+  if (action === 'status') {
+    return `Checked ${target}${count !== null ? `, ${count} record(s) found` : ''}`;
+  }
+
+  if (action === 'list') {
+    return `Listed workflows for ${target}${count !== null ? `, ${count} pipeline(s) found` : ''}`;
+  }
+
+  return `Workflow ${action} completed`;
+}
+
+function buildWorkflowTargetLabel(params) {
+  if (params.pipelineId && params.runId) {
+    return `pipeline ${params.pipelineId} / run ${params.runId}`;
+  }
+  if (params.pipelineId) {
+    return `pipeline ${params.pipelineId}`;
+  }
+  if (params.serviceNames?.length > 0) {
+    return params.serviceNames.join(', ');
+  }
+  if (params.workflow) {
+    return params.workflow;
+  }
+  return params.environment || null;
+}
+
+function buildDeployTargetLabel(context) {
+  if (Array.isArray(context.pipelineIds) && context.pipelineIds.length > 0) {
+    return `pipeline ${context.pipelineIds.join(', ')}`;
+  }
+  if (context.pipelineId) {
+    return `pipeline ${context.pipelineId}`;
+  }
+  if (Array.isArray(context.services) && context.services.length > 0) {
+    return context.services.map((item) => item.serviceName || item.service || item.pipelineName || item.pipelineId).filter(Boolean).join(', ');
+  }
+  return null;
+}
+
+function buildDeploySummaryText(target, payload, context, count = 1) {
+  const status = extractDeployStatus(payload) || 'submitted';
+  const runId = extractDeployRunId(payload);
+  const source = context.source ? ` via ${context.source}` : '';
+  const countSuffix = count > 1 ? ` (${count} items)` : '';
+
+  if (runId) {
+    return `Deployment ${status} for ${target}${source}, run ${runId}${countSuffix}`;
+  }
+
+  return `Deployment ${status} for ${target}${source}${countSuffix}`;
+}
+
+function extractDeployStatus(payload) {
+  if (payload && typeof payload === 'object') {
+    const candidates = [
+      payload.status,
+      payload.state,
+      payload.result?.status,
+      payload.result?.state
+    ].filter(Boolean);
+    if (candidates.length > 0) {
+      return String(candidates[0]);
+    }
+
+    if (payload.submitted === true) {
+      return 'submitted';
+    }
+  }
+
+  return null;
+}
+
+function extractDeployRunId(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  const candidates = [
+    payload.pipelineRunId,
+    payload.pipeline_run_id,
+    payload.runId,
+    payload.run_id,
+    payload.result?.pipelineRunId,
+    payload.result?.pipeline_run_id,
+    payload.result?.runId,
+    payload.result?.run_id
+  ];
+
+  for (const candidate of candidates) {
+    if (candidate === null || candidate === undefined || candidate === '') continue;
+    return String(candidate);
+  }
+
+  return null;
+}
+
+function summarizeDeployDetails(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  const details = compactObject({
+    submitted: typeof payload.submitted === 'boolean' ? payload.submitted : null,
+    pipelineRunId: payload.pipelineRunId || payload.pipeline_run_id || null,
+    pipelineId: payload.pipelineId || payload.pipeline_id || null,
+    message: payload.message || payload.result?.message || null
+  });
+
+  return Object.keys(details).length > 0 ? details : null;
+}
+
+function unwrapMcpResult(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return payload;
+  }
+
+  const textContent = Array.isArray(payload.content) ? payload.content : payload.result?.content;
+  if (Array.isArray(textContent)) {
+    const textItem = textContent.find((item) => item?.type === 'text' && typeof item.text === 'string');
+    if (textItem?.text) {
+      try {
+        return JSON.parse(textItem.text);
+      } catch (error) {
+        return payload;
+      }
+    }
+  }
+
+  return payload;
+}
+
+function extractRecords(payload) {
+  const normalized = unwrapMcpResult(payload);
+  if (!normalized) return [];
+  if (Array.isArray(normalized)) return normalized;
+
+  const candidates = [
+    normalized.data,
+    normalized.rows,
+    normalized.list,
+    normalized.records,
+    normalized.result?.data,
+    normalized.result?.rows,
+    normalized.result?.list,
+    normalized.result?.records
+  ];
+
+  for (const candidate of candidates) {
+    if (Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+
+  return [];
+}
+
+function extractTotalCount(payload, records) {
+  if (payload && typeof payload === 'object') {
+    const candidates = [payload.total, payload.count, payload.result?.total, payload.result?.count];
+    for (const candidate of candidates) {
+      if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+        return candidate;
+      }
+      if (typeof candidate === 'string' && candidate.trim() !== '' && !Number.isNaN(Number(candidate))) {
+        return Number(candidate);
+      }
+    }
+  }
+
+  return records.length;
+}
+
+function extractWorkflowStatus(payload, action) {
+  if (payload && typeof payload === 'object') {
+    const candidates = [
+      payload.status,
+      payload.state,
+      payload.result?.status,
+      payload.result?.state
+    ].filter(Boolean);
+    if (candidates.length > 0) {
+      return String(candidates[0]);
+    }
+  }
+
+  return action === 'status' ? 'completed' : 'completed';
+}
+
+function summarizeWorkflowRecord(record) {
+  const fields = parseWorkflowFields(record?.fields);
+  return compactObject({
+    pipelineName: record?.pipelineName || record?.name || fields?.pipelineName || fields?.name || null,
+    pipelineId: record?.pipelineId || fields?.pipelineId || extractIdFromFields(fields) || null,
+    service: extractWorkflowService(fields),
+    status: record?.status || fields?.status || fields?.state || null,
+    env: record?.env || fields?.env || fields?.environment || null
+  });
+}
+
+function parseWorkflowFields(fields) {
+  if (!fields) return null;
+  if (typeof fields === 'object') return fields;
+  if (typeof fields !== 'string') return null;
+
+  try {
+    return JSON.parse(fields);
+  } catch (error) {
+    return null;
+  }
+}
+
+function extractWorkflowService(fields) {
+  if (!fields) return null;
+  if (Array.isArray(fields.service) && fields.service.length > 0) {
+    return fields.service[0];
+  }
+  if (typeof fields.service === 'string') {
+    return fields.service;
+  }
+  return fields.serviceName || fields.service_name || null;
+}
+
+function extractIdFromFields(fields) {
+  if (!fields || typeof fields !== 'object') return null;
+  const candidates = [fields.pipelineId, fields.pipeline_id, fields.id];
+  for (const candidate of candidates) {
+    if (candidate === null || candidate === undefined || candidate === '') continue;
+    return String(candidate);
+  }
+  return null;
+}
+
 function buildNoAdapterResult(input, params) {
   if (params.workflow && BUILTIN_WORKFLOWS[params.workflow]) {
     const workflow = BUILTIN_WORKFLOWS[params.workflow];
@@ -234,7 +584,7 @@ function buildNoAdapterResult(input, params) {
       message: `Workflow ready: ${workflow.name}`,
       data: {
         workflow: params.workflow,
-        steps: workflow.steps
+        execution: buildBuiltinWorkflowSummary(params.workflow, workflow)
       },
       input,
       timestamp: new Date().toISOString()
@@ -247,7 +597,12 @@ function buildNoAdapterResult(input, params) {
     message: 'Workflow service not configured. Connect friday-auto-flow first.',
     data: {
       status: 'not_configured',
-      hint: 'Run `flowmind resource` to review current bindings, then save one like: `flowmind "绑定发布业务 mcp=friday-auto-flow token=xxx env=uat"`'
+      hint: 'Run `flowmind resource` to review current bindings, then save one like: `flowmind "绑定发布业务 mcp=friday-auto-flow token=xxx env=uat"`',
+      execution: buildAutoFlowHintSummary({
+        client: null,
+        provider: null,
+        binding: null
+      })
     },
     input,
     timestamp: new Date().toISOString()
@@ -267,7 +622,10 @@ async function executeDeploy(workflow, params, input, context) {
         binding: workflow.binding,
         status: 'submitted',
         mcpServer: getWorkflowMcpServer(workflow),
-        execution,
+        execution: summarizeDeployExecution(params, execution, {
+          source: 'direct-input',
+          pipelineId: params.pipelineId
+        }),
         resolution: {
           source: 'direct-input',
           pipelineId: params.pipelineId
@@ -295,7 +653,11 @@ async function executeDeploy(workflow, params, input, context) {
         binding: workflow.binding,
         status: 'submitted',
         mcpServer: getWorkflowMcpServer(workflow),
-        execution: executions.length === 1 ? executions[0] : executions,
+        execution: summarizeDeployExecution(params, executions.length === 1 ? executions[0] : executions, {
+          source: resolvedTargets.source,
+          pipelineIds: resolvedTargets.pipelineIds,
+          services: resolvedTargets.resolutions
+        }),
         resolution: {
           source: resolvedTargets.source,
           pipelineIds: resolvedTargets.pipelineIds,
@@ -307,57 +669,22 @@ async function executeDeploy(workflow, params, input, context) {
     };
   }
 
-  const listParams = buildListPipelineParams(params);
-  const lookup = await workflow.client.listPipelines(listParams);
-  const batchParams = buildBatchRunParams(params);
-  const execution = await workflow.client.startBatchPipelineRun(batchParams);
-
-    return {
-      type: 'result',
-      skill: 'auto-flow',
-      message: 'Workflow status: deployment submitted',
-      data: {
-        action: 'deploy',
-        provider: workflow.provider,
-        binding: workflow.binding,
-        status: 'submitted',
-        mcpServer: getWorkflowMcpServer(workflow),
-        execution,
-        resolution: {
-          source: 'batch-fallback',
-          lookup
-        }
-      },
-      input,
-      timestamp: new Date().toISOString()
-    };
-  }
+  return buildUnresolvedDeployResult(workflow, params, input, context);
+}
 
 async function executeStatus(workflow, params, input) {
+  let execution;
   if (params.pipelineId && params.runId) {
-    await workflow.client.getPipelineRun(params.pipelineId, params.runId);
+    execution = await workflow.client.getPipelineRun(params.pipelineId, params.runId);
   } else if (params.pipelineId) {
-    await workflow.client.listPipelineRuns(params.pipelineId, {
+    execution = await workflow.client.listPipelineRuns(params.pipelineId, {
       env: params.environment
     });
   } else {
-    await workflow.client.listPipelines(buildListPipelineParams(params));
+    execution = await workflow.client.listPipelines(buildListPipelineParams(params));
   }
 
-  return {
-    type: 'result',
-    skill: 'auto-flow',
-    message: 'Workflow status: query completed',
-    data: {
-      action: 'status',
-      provider: workflow.provider,
-      binding: workflow.binding,
-      status: 'completed',
-      mcpServer: workflow.binding?.mcpServer || workflow.provider
-    },
-    input,
-    timestamp: new Date().toISOString()
-  };
+  return execution;
 }
 
 function parseFlowParams(input) {
@@ -541,7 +868,7 @@ function resolveLocalPipelineForService(serviceName, environment, context) {
   const entry = pipelineMap[serviceName];
   if (!entry) return null;
 
-  const pipeline = selectPipelineFromEntry(entry, environment);
+  const pipeline = selectPipelineFromEntry(entry, environment, serviceName);
   if (!pipeline?.pipelineId) return null;
 
   return {
@@ -570,19 +897,13 @@ function readLocalPipelineMap(context) {
   return null;
 }
 
-function selectPipelineFromEntry(entry, environment) {
+function selectPipelineFromEntry(entry, environment, serviceName) {
   const preferredKeys = getEnvLookupOrder(environment);
   for (const key of preferredKeys) {
     const candidate = normalizePipelineCollection(entry?.[key]);
-    if (candidate.length > 0) {
-      return candidate[0];
-    }
-  }
-
-  for (const value of Object.values(entry || {})) {
-    const candidate = normalizePipelineCollection(value);
-    if (candidate.length > 0) {
-      return candidate[0];
+    const matched = candidate.find((item) => matchesPipelineName(item.pipelineName, environment, serviceName));
+    if (matched) {
+      return matched;
     }
   }
 
@@ -741,49 +1062,12 @@ function matchesRemoteService(fields, serviceName, environment) {
 }
 
 function selectPipelineFromFields(fields, environment, serviceName) {
-  const indexedCandidate = selectIndexedPipelineForService(fields, environment, serviceName);
-  if (indexedCandidate?.pipelineId) {
-    return indexedCandidate;
-  }
-
   const candidates = collectFieldPipelineDescriptors(fields, environment);
-  if (candidates.length > 0) {
-    return candidates[0];
-  }
-
-  const pipelineIds = String(fields.pipelineId || '')
-    .split(',')
-    .map((item) => item.trim())
-    .filter(Boolean);
-
-  if (pipelineIds.length === 0) {
-    return null;
-  }
-
-  return {
-    pipelineName: buildPrefixedPipelineName(
-      Array.isArray(fields.service) ? fields.service[0] : null,
-      environment
-    ),
-    pipelineId: pipelineIds[0]
-  };
-}
-
-function selectIndexedPipelineForService(fields, environment, serviceName) {
-  if (!serviceName) return null;
-
-  const services = Array.isArray(fields.service) ? fields.service.map((item) => String(item).trim()) : [];
-  const serviceIndex = services.indexOf(serviceName);
-  if (serviceIndex < 0) return null;
-
-  for (const key of getFieldKeysForEnvironment(environment)) {
-    const values = Array.isArray(fields[key]) ? fields[key] : [];
-    const parsed = parsePipelineDescriptor(values[serviceIndex]);
-    if (parsed?.pipelineId) {
-      return parsed;
+  for (const candidate of candidates) {
+    if (candidate?.pipelineId && matchesPipelineName(candidate.pipelineName, environment, serviceName)) {
+      return candidate;
     }
   }
-
   return null;
 }
 
@@ -824,10 +1108,11 @@ function parsePipelineDescriptor(value) {
 function getEnvLookupOrder(environment) {
   const normalized = normalizeEnvironment(environment || '');
   if (normalized === 'prod') return ['prod'];
-  if (normalized === 'gray') return ['gray', 'prod'];
+  if (normalized === 'gray') return ['gray'];
   if (normalized === 'uat') return ['uat'];
-  if (normalized === 'test') return ['test', 'dev', 'uat'];
-  return ['uat', 'test', 'dev', 'gray', 'prod'];
+  if (normalized === 'test') return ['test', 'dev'];
+  if (normalized === 'dev') return ['dev'];
+  return [];
 }
 
 function buildPrefixedPipelineName(serviceName, environment) {
@@ -838,6 +1123,24 @@ function buildPrefixedPipelineName(serviceName, environment) {
   return `${prefix}-${serviceName}`;
 }
 
+function matchesPipelineName(pipelineName, environment, serviceName) {
+  if (!pipelineName || !serviceName) return false;
+
+  const normalized = String(pipelineName).toLowerCase();
+  const candidatePrefixes = getAllowedPipelinePrefixes(environment);
+  return candidatePrefixes.some((prefix) => normalized === `${prefix}-${serviceName}`.toLowerCase());
+}
+
+function getAllowedPipelinePrefixes(environment) {
+  const normalized = normalizeEnvironment(environment || '');
+  if (normalized === 'test') return ['test', 'dev'];
+  if (normalized === 'dev') return ['dev'];
+  if (normalized === 'uat') return ['uat'];
+  if (normalized === 'gray') return ['gray'];
+  if (normalized === 'prod') return ['prod'];
+  return [];
+}
+
 function inferEnvironmentFromPipelineName(pipelineName) {
   const match = String(pipelineName || '').match(/^(test|dev|uat|gray|prod)-/i);
   return match ? (ENV_PREFIX_TO_ENV[match[1].toLowerCase()] || normalizeEnvironment(match[1])) : null;
@@ -866,6 +1169,32 @@ function collectNestedValues(payload, values = []) {
   return values;
 }
 
+function buildUnresolvedDeployResult(workflow, params, input, context) {
+  const target = buildWorkflowTargetLabel(params) || buildDeployTargetLabel(context) || 'deployment';
+  return {
+    type: 'error',
+    success: false,
+    skill: 'auto-flow',
+    message: `Unable to resolve deployment target for ${target}. Specify an exact environment or pipelineId.`,
+    data: {
+      action: 'deploy',
+      provider: workflow.provider,
+      binding: workflow.binding,
+      status: 'not_resolved',
+      mcpServer: getWorkflowMcpServer(workflow),
+      target,
+      environment: params.environment || null,
+      resolution: {
+        source: 'not-resolved',
+        serviceNames: params.serviceNames || [],
+        environment: params.environment || null
+      }
+    },
+    input,
+    timestamp: new Date().toISOString()
+  };
+}
+
 function compactObject(value) {
   return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined && item !== null && item !== ''));
 }