@jira-deploy/core 1.0.2 → 1.0.4

package/tools.test.js

@@ -4,7 +4,9 @@
  */
 import { test, describe } from 'node:test';
 import assert from 'node:assert/strict';
+import http from 'node:http';
 import { executeTool, getToolDefinitions } from './tools/index.js';
+import { Poller } from './poller.js';
 
 process.env.JIRA_BASE_URL = 'https://jira.test';
 
@@ -109,9 +111,9 @@ function makeMockJira({
     },
     getIssue: async () => ({ fields: { status: { name: 'TO DO' }, summary: 'test' } }),
     getTransitions: async () => [],
-    transitionById: async () => {},
+    transitionById: async () => { },
     transitionByName: async () => ({ transitioned: 'Test', toStatus: 'Done' }),
-    addComment: async () => {},
+    addComment: async () => { },
     getSubTasks: async () => [],
   };
 }
@@ -127,6 +129,7 @@ describe('tool schemas — agent contract', () => {
     const tool = getToolDefinition('create_cd_ticket');
 
     assert.deepEqual(tool.inputSchema.required, ['systemCode', 'environment']);
+    assert.ok(tool.inputSchema.properties.environment.enum.includes('dev'));
     for (const property of [
       'ciTicket',
       'linkedCiKey',
@@ -139,6 +142,19 @@ describe('tool schemas — agent contract', () => {
     }
   });
 
+  test('create_cd_ticket schema requires explicit CD intent and CI ticket context', () => {
+    const tool = getToolDefinition('create_cd_ticket');
+
+    assert.match(tool.description, /明確要求或確認/);
+    assert.match(tool.description, /deploy_grayrelease/);
+    assert.match(tool.description, /不可直接開 CD 單/);
+    assert.match(tool.inputSchema.properties.environment.description, /應先詢問/);
+    assert.match(tool.inputSchema.properties.environment.description, /不可.*自行補 stg/);
+    assert.match(tool.inputSchema.properties.ciTicket.description, /必須是 CI 單/);
+    assert.match(tool.inputSchema.properties.ciTicket.description, /不可使用 GrayRelease 單/);
+    assert.match(tool.inputSchema.properties.linkedCiKey.description, /不可使用 GrayRelease 單/);
+  });
+
   test('create_library_ticket schema treats module as defaultable', () => {
     const tool = getToolDefinition('create_library_ticket');
 
@@ -151,22 +167,112 @@ describe('tool schemas — agent contract', () => {
     assert.ok(getToolDefinition('run_lib_to_stg_release'));
   });
 
+  test('wait_to_dev is exposed as a CI workflow tool', () => {
+    assert.ok(getToolDefinition('wait_to_dev'));
+  });
+
+  test('deploy_grayrelease is exposed as the GrayRelease deployment tool', () => {
+    const deployTool = getToolDefinition('deploy_grayrelease');
+    const buildTool = getToolDefinition('build_ticket');
+
+    assert.ok(deployTool);
+    assert.match(deployTool.description, /與 CD 部署完全分離/);
+    assert.match(deployTool.description, /只說 deploy\/部署/);
+    assert.match(deployTool.description, /先確認是否部署該 GrayRelease 單/);
+    assert.match(deployTool.description, /不會建立 CD 單/);
+    assert.match(deployTool.description, /不接受 CI 單/);
+    assert.match(deployTool.description, /不會重新 build/);
+    assert.match(buildTool.description, /deploy_grayrelease/);
+    assert.match(buildTool.description, /不可用此 tool 觸發 rebuild/);
+  });
+
+  test('build_ticket schema is limited to explicit GrayRelease build or rebuild', () => {
+    const tool = getToolDefinition('build_ticket');
+
+    assert.match(tool.description, /GrayRelease/);
+    assert.match(tool.description, /build\/rebuild/);
+    assert.doesNotMatch(tool.description, /build\/deploy/);
+    assert.match(tool.inputSchema.properties.issueKey.description, /GrayRelease/);
+    assert.equal(tool.inputSchema.properties.rebuild.type, 'boolean');
+    assert.match(tool.inputSchema.properties.rebuild.description, /rebuild=true/);
+  });
+
+  test('build_ticket refuses GrayRelease VERIFY rebuild without rebuild flag', async () => {
+    let status = 'VERIFY';
+    const transitions = [];
+    const jira = {
+      ...makeMockJira(),
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
+      getTransitions: async () => {
+        if (status === 'VERIFY') return [{ id: '10', name: 'Verify fail', to: { name: 'PLANNING' } }];
+        return [];
+      },
+      transitionById: async (_issueKey, transitionId) => {
+        transitions.push(transitionId);
+      },
+    };
+
+    const result = await executeTool(
+      'build_ticket',
+      { issueKey: 'CID-822' },
+      { jira, notifier: mockNotifier },
+    );
+
+    assert.equal(result.isError, true);
+    assert.match(result.content[0].text, /rebuild=true/);
+    assert.deepEqual(transitions, []);
+  });
+
+  test('build_ticket resets GrayRelease VERIFY flow before GrayRelease Build when rebuild is explicit', async () => {
+    let status = 'VERIFY';
+    const transitions = [];
+    const jira = {
+      ...makeMockJira(),
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
+      getTransitions: async () => {
+        if (status === 'VERIFY') return [{ id: '10', name: 'Verify fail', to: { name: 'PLANNING' } }];
+        if (status === 'PLANNING') return [{ id: '11', name: 'Accept', to: { name: 'WAIT FOR BUILD' } }];
+        if (status === 'WAIT FOR BUILD') {
+          return [{ id: '12', name: 'GrayRelease Build', to: { name: 'WAIT FOR BUILD' } }];
+        }
+        return [];
+      },
+      transitionById: async (_issueKey, transitionId) => {
+        transitions.push(transitionId);
+        if (transitionId === '10') status = 'PLANNING';
+        if (transitionId === '11') status = 'WAIT FOR BUILD';
+      },
+    };
+
+    const result = await executeTool(
+      'build_ticket',
+      { issueKey: 'CID-822', rebuild: true },
+      { jira, notifier: mockNotifier },
+    );
+
+    assert.ok(!result.isError, result.content[0].text);
+    const output = JSON.parse(result.content[0].text);
+    assert.equal(output.status, 'WAIT FOR BUILD');
+    assert.deepEqual(transitions, ['10', '11', '12']);
+    assert.match(output.steps.join('\n'), /GrayRelease Build/);
+  });
+
   test('run_stg_full_release dispatches shared workflow steps', async () => {
     const calls = [];
-    const result = await executeTool('run_stg_full_release', {systemCode: 'IBK'}, {
+    const result = await executeTool('run_stg_full_release', { systemCode: 'IBK' }, {
       jira: makeMockJira(),
       notifier: mockNotifier,
       executeToolImpl: async (name, args) => {
-        calls.push({name, args});
+        calls.push({ name, args });
         const outputs = {
-          create_ci_ticket: {issueKey: 'CID-100'},
-          build_ticket: {issueKey: args.issueKey, status: 'Compliance Scan'},
-          wait_to_stg: {issueKey: args.issueKey, status: 'Wait To STG'},
-          create_cd_ticket: {issueKey: 'CID-200'},
-          prepare_cd_deployment: {issueKey: args.issueKey, status: 'Deployment Created'},
-          trigger_deployment: {cdIssueKey: args.cdIssueKey, status: 'Done'},
+          create_ci_ticket: { issueKey: 'CID-100' },
+          build_ticket: { issueKey: args.issueKey, status: 'Compliance Scan' },
+          wait_to_stg: { issueKey: args.issueKey, status: 'Wait To STG' },
+          create_cd_ticket: { issueKey: 'CID-200' },
+          prepare_cd_deployment: { issueKey: args.issueKey, status: 'Deployment Created' },
+          trigger_deployment: { cdIssueKey: args.cdIssueKey, status: 'Done' },
         };
-        return {content: [{type: 'text', text: JSON.stringify(outputs[name])}]};
+        return { content: [{ type: 'text', text: JSON.stringify(outputs[name]) }] };
       },
     });
 
@@ -186,6 +292,38 @@ describe('tool schemas — agent contract', () => {
     assert.equal(calls[5].args.applyForClose, true);
   });
 
+  test('run_stg_full_release emits route progress for each workflow step', async () => {
+    const events = [];
+    const result = await executeTool('run_stg_full_release', { systemCode: 'IBK' }, {
+      jira: makeMockJira(),
+      notifier: mockNotifier,
+      progress: (event) => events.push(event),
+      executeToolImpl: async (name, args) => {
+        const outputs = {
+          create_ci_ticket: { issueKey: 'CID-100' },
+          build_ticket: { issueKey: args.issueKey, status: 'Compliance Scan' },
+          wait_to_stg: { issueKey: args.issueKey, status: 'Wait To STG' },
+          create_cd_ticket: { issueKey: 'CID-200' },
+          prepare_cd_deployment: { issueKey: args.issueKey, status: 'Deployment Created' },
+          trigger_deployment: { cdIssueKey: args.cdIssueKey, status: 'Done' },
+        };
+        return { content: [{ type: 'text', text: JSON.stringify(outputs[name]) }] };
+      },
+    });
+
+    assert.ok(!result.isError, result.content[0].text);
+    assert.deepEqual(events.map((event) => event.toolName), [
+      'create_ci_ticket',
+      'build_ticket',
+      'wait_to_stg',
+      'create_cd_ticket',
+      'prepare_cd_deployment',
+      'trigger_deployment',
+    ]);
+    assert.ok(events.every((event) => event.phase === 'action'));
+    assert.equal(events[0].title, '執行 workflow step: create_ci_ticket');
+  });
+
   test('run_lib_to_stg_release waits for the Library ticket to reach Released', async () => {
     const calls = [];
     const result = await executeTool('run_lib_to_stg_release', {
@@ -194,17 +332,17 @@ describe('tool schemas — agent contract', () => {
     }, {
       jira: {
         ...makeMockJira(),
-        getIssue: async () => ({fields: {status: {name: 'WAIT FOR LIB BUILD'}}}),
+        getIssue: async () => ({ fields: { status: { name: 'WAIT FOR LIB BUILD' } } }),
       },
       notifier: mockNotifier,
-      workflowWaitOptions: {timeoutMs: 1, intervalMs: 1},
+      workflowWaitOptions: { timeoutMs: 1, intervalMs: 1 },
       executeToolImpl: async (name, args) => {
-        calls.push({name, args});
+        calls.push({ name, args });
         const outputs = {
-          create_library_ticket: {issueKey: 'LIB-100'},
-          build_ticket: {issueKey: args.issueKey, status: 'WAIT FOR LIB BUILD'},
+          create_library_ticket: { issueKey: 'LIB-100' },
+          build_ticket: { issueKey: args.issueKey, status: 'WAIT FOR LIB BUILD' },
         };
-        return {content: [{type: 'text', text: JSON.stringify(outputs[name])}]};
+        return { content: [{ type: 'text', text: JSON.stringify(outputs[name]) }] };
       },
     });
 
@@ -217,11 +355,11 @@ describe('tool schemas — agent contract', () => {
   });
 
   test('workflow tool failures are marked as MCP errors', async () => {
-    const result = await executeTool('run_stg_full_release', {systemCode: 'IBK'}, {
+    const result = await executeTool('run_stg_full_release', { systemCode: 'IBK' }, {
       jira: makeMockJira(),
       notifier: mockNotifier,
       executeToolImpl: async () => ({
-        content: [{type: 'text', text: '❌ 錯誤: nested tool failed'}],
+        content: [{ type: 'text', text: '❌ 錯誤: nested tool failed' }],
         isError: true,
       }),
     });
@@ -234,8 +372,8 @@ describe('tool schemas — agent contract', () => {
   test('core dispatcher tool failures are marked as MCP errors', async () => {
     const result = await executeTool(
       'prepare_cd_deployment',
-      {issueKey: 'CID-1', environment: 'qa'},
-      {jira: makeMockJira(), notifier: mockNotifier},
+      { issueKey: 'CID-1', environment: 'qa' },
+      { jira: makeMockJira(), notifier: mockNotifier },
     );
 
     assert.equal(result.isError, true);
@@ -259,6 +397,75 @@ describe('tool schemas — agent contract', () => {
     assert.notEqual(getToolDefinition('run_stg_full_release').annotations?.readOnlyHint, true);
     assert.notEqual(getToolDefinition('run_lib_to_stg_release').annotations?.readOnlyHint, true);
   });
+
+  test('Poller reports each polling attempt with current status and timing', async () => {
+    const events = [];
+    let calls = 0;
+    const jira = {
+      getIssue: async () => {
+        calls += 1;
+        return {
+          fields: {
+            status: {
+              name: calls === 1 ? 'WAIT APPROVAL' : 'WAIT DEPLOY',
+            },
+          },
+        };
+      },
+    };
+
+    const result = await new Poller(jira).waitForStatus('CID-822', 'WAIT DEPLOY', {
+      intervalMs: 1,
+      timeoutMs: 100,
+      onProgress: (event) => events.push(event),
+    });
+
+    assert.equal(result.attempts, 2);
+    assert.deepEqual(events.map((event) => event.attempts), [1, 2]);
+    assert.equal(events[0].phase, 'polling');
+    assert.equal(events[0].issueKey, 'CID-822');
+    assert.equal(events[0].currentStatus, 'WAIT APPROVAL');
+    assert.equal(events[0].targetStatus, 'WAIT DEPLOY');
+    assert.equal(events[0].nextPollMs, 1);
+    assert.equal(events[1].currentStatus, 'WAIT DEPLOY');
+  });
+
+  test('wait_for_comment reports each polling attempt before the comment is found', async () => {
+    const events = [];
+    let calls = 0;
+    const jira = {
+      getComments: async () => {
+        calls += 1;
+        if (calls === 1) return [];
+        return [
+          {
+            body: 'Approved',
+            author: { name: 'BK00178', displayName: 'James Yu' },
+          },
+        ];
+      },
+    };
+
+    const result = await executeTool('wait_for_comment', {
+      issueKey: 'CID-822',
+      keyword: 'approved',
+      authorAccountId: 'BK00178',
+      intervalMs: 1,
+      timeoutMs: 100,
+    }, {
+      jira,
+      notifier: mockNotifier,
+      progress: (event) => events.push(event),
+    });
+
+    const data = JSON.parse(result.content[0].text);
+    assert.equal(data.found, true);
+    assert.deepEqual(events.map((event) => event.attempts), [1, 2]);
+    assert.equal(events[0].phase, 'polling');
+    assert.equal(events[0].title, '等待 Jira comment');
+    assert.equal(events[0].detail, 'keyword="approved", author=BK00178');
+    assert.equal(events[0].issueKey, 'CID-822');
+  });
 });
 
 /** 執行 tool，回傳 createIssue 收到的 fields（合併 updateIssue 的欄位，或 throw 若 ❌） */
@@ -367,6 +574,22 @@ describe('create_library_ticket — fields', () => {
     const f = await getCreatedFields('create_library_ticket', BASE);
     assert.equal(f['customfield_13431'], 'release/v1.5.2.0');
   });
+  test('通知與回傳使用預設 module，不顯示 undefined', async () => {
+    const notifications = [];
+    const result = await executeTool(
+      'create_library_ticket',
+      { systemCode: 'CWA', gitBranch: 'release/v1.0.0' },
+      {
+        jira: makeMockJira(),
+        notifier: { notify: async (key, message) => notifications.push({ key, message }) },
+      },
+    );
+
+    const data = JSON.parse(result.content[0].text);
+    assert.equal(data.module, 'cwa');
+    assert.match(notifications.at(-1).message, /模組: cwa/);
+    assert.doesNotMatch(notifications.at(-1).message, /undefined/);
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════
@@ -591,6 +814,23 @@ describe('create_cd_ticket — fields', () => {
     });
     assert.equal(f['customfield_13442'], 'tvdev-ibk-web01');
   });
+  test('通知與回傳使用自動推導 cluster，不顯示 undefined', async () => {
+    const notifications = [];
+    const result = await executeTool(
+      'create_cd_ticket',
+      { systemCode: 'CWA', environment: 'dev' },
+      {
+        jira: makeMockJira(),
+        notifier: { notify: async (key, message) => notifications.push({ key, message }) },
+      },
+    );
+
+    const data = JSON.parse(result.content[0].text);
+    assert.deepEqual(data.clusterDeploy, ['tvdev-cwa-web01']);
+    assert.equal(data.isClusterDeploy, false);
+    assert.match(notifications.at(-1).message, /Cluster: tvdev-cwa-web01/);
+    assert.doesNotMatch(notifications.at(-1).message, /undefined/);
+  });
   test('customfield_13437 (CID_extra_vars) IBK STG 自動生成', async () => {
     const f = await getCreatedFields('create_cd_ticket', BASE);
     const ev = JSON.parse(f['customfield_13437']);
@@ -1348,6 +1588,498 @@ describe('create_grayrelease_ticket — fields', () => {
   });
 });
 
+// ═══════════════════════════════════════════════════════════════════
+// auto_grayrelease approval payload handling
+// ═══════════════════════════════════════════════════════════════════
+describe('auto_grayrelease — approval payload handling', () => {
+  const savedEnv = {
+    CONF_BASE_URL: process.env.CONF_BASE_URL,
+    CONF_TOKEN: process.env.CONF_TOKEN,
+    JABBER_NOTIFY_SCRIPT: process.env.JABBER_NOTIFY_SCRIPT,
+    POLL_INTERVAL_MS: process.env.POLL_INTERVAL_MS,
+    POLL_TIMEOUT_MS: process.env.POLL_TIMEOUT_MS,
+  };
+
+  function restoreEnv() {
+    for (const [key, value] of Object.entries(savedEnv)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+
+  function makeApprovalJira(environment, { comments = [] } = {}) {
+    let status = 'WAIT APPROVAL';
+    const calls = { updateAssignee: [], transitionByName: [] };
+
+    return {
+      calls,
+      getIssueFields: async () => ({
+        customfield_13436: { value: environment },
+        customfield_13443: { value: 'CWA' },
+        customfield_13432: 'pass',
+        customfield_13433: 'pass',
+      }),
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
+      getTransitions: async () => [],
+      updateAssignee: async (issueKey, accountId) => {
+        calls.updateAssignee.push({ issueKey, accountId });
+        if (environment === 'stg' || calls.updateAssignee.length >= 2) {
+          status = 'WAIT DEPLOY';
+        }
+      },
+      getComments: async () => comments,
+      searchIssues: async () => [{ fields: { customfield_13436: { value: 'stg' } } }],
+      transitionByName: async (issueKey, transitionName) => {
+        calls.transitionByName.push({ issueKey, transitionName });
+        if (transitionName === 'To Verify') {
+          status = 'VERIFY';
+        }
+        return { transitioned: transitionName, toStatus: status };
+      },
+    };
+  }
+
+  test('STG approval parses get_release_manager MCP content payload', async () => {
+    const server = http.createServer((_req, res) => {
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ events: [{ what: 'Sign off staff', who: 'Alvin Wang' }] }));
+    });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+
+    try {
+      process.env.CONF_BASE_URL = `http://127.0.0.1:${server.address().port}`;
+      process.env.CONF_TOKEN = 'test-token';
+      process.env.JABBER_NOTIFY_SCRIPT = '/dev/null';
+      process.env.POLL_INTERVAL_MS = '0';
+      process.env.POLL_TIMEOUT_MS = '10';
+
+      const jira = makeApprovalJira('stg');
+      const result = await executeTool(
+        'auto_grayrelease',
+        { issueKey: 'CID-100', autoVerify: false },
+        { jira, notifier: mockNotifier },
+      );
+
+      assert.ok(!result.content[0].text.startsWith('❌'), 'STG approval should continue');
+      const data = JSON.parse(result.content[0].text);
+      assert.equal(data.finalStatus, 'VERIFY');
+      assert.deepEqual(jira.calls.updateAssignee, [{ issueKey: 'CID-100', accountId: 'BK00619' }]);
+    } finally {
+      await new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+        server.closeAllConnections?.();
+      });
+      restoreEnv();
+    }
+  });
+
+  test('UAT approval parses wait_for_comment MCP content payload', async () => {
+    try {
+      process.env.JABBER_NOTIFY_SCRIPT = '/dev/null';
+      process.env.POLL_INTERVAL_MS = '0';
+      process.env.POLL_TIMEOUT_MS = '10';
+
+      const jira = makeApprovalJira('uat', {
+        comments: [{ body: 'Approved, please proceed', author: { name: 'BK00619', displayName: 'James Yu' } }],
+      });
+      const result = await executeTool(
+        'auto_grayrelease',
+        { issueKey: 'CID-101', autoVerify: false },
+        { jira, notifier: mockNotifier },
+      );
+
+      assert.ok(!result.content[0].text.startsWith('❌'), 'UAT approval should continue');
+      const data = JSON.parse(result.content[0].text);
+      assert.equal(data.finalStatus, 'VERIFY');
+      assert.deepEqual(jira.calls.updateAssignee, [
+        { issueKey: 'CID-101', accountId: 'BK00619' },
+        { issueKey: 'CID-101', accountId: 'BK00619' },
+      ]);
+    } finally {
+      restoreEnv();
+    }
+  });
+
+  test('UAT approval emits progress for assignee, notification, comment wait, and final approval wait', async () => {
+    const events = [];
+    try {
+      process.env.JABBER_NOTIFY_SCRIPT = '/dev/null';
+      process.env.POLL_INTERVAL_MS = '0';
+      process.env.POLL_TIMEOUT_MS = '10';
+
+      const jira = makeApprovalJira('uat', {
+        comments: [{ body: 'Approved, please proceed', author: { name: 'BK00619', displayName: 'James Yu' } }],
+      });
+      const result = await executeTool(
+        'auto_grayrelease',
+        { issueKey: 'CID-101', autoVerify: false },
+        {
+          jira,
+          notifier: mockNotifier,
+          progress: (event) => events.push(event),
+        },
+      );
+
+      assert.ok(!result.content[0].text.startsWith('❌'), result.content[0].text);
+      assert.ok(events.some((event) => event.title === '指派 GrayRelease 簽核人' && event.detail.includes('James Yu')));
+      assert.ok(events.some((event) => event.title === '發送 GrayRelease 簽核通知' && event.detail.includes('James Yu')));
+      assert.ok(events.some((event) => event.title === '等待 Jira comment' && event.attempts === 1));
+      assert.ok(events.some((event) => event.title === '指派 GrayRelease 簽核人' && event.detail.includes('Solar Chen')));
+      assert.ok(events.some((event) => event.phase === 'polling' && event.targetStatus === 'WAIT DEPLOY'));
+    } finally {
+      restoreEnv();
+    }
+  });
+
+  test('WAIT APPROVAL fails when GrayRelease environment field is missing', async () => {
+    const transitions = [];
+    const jira = {
+      getIssueFields: async () => ({
+        customfield_13443: { value: 'CWA' },
+      }),
+      getIssue: async () => ({ fields: { status: { name: 'WAIT APPROVAL' }, summary: 'GrayRelease' } }),
+      transitionByName: async (_issueKey, transitionName) => {
+        transitions.push(transitionName);
+      },
+    };
+
+    const result = await executeTool(
+      'auto_grayrelease',
+      { issueKey: 'CID-102', autoVerify: false },
+      { jira, notifier: mockNotifier },
+    );
+
+    assert.ok(result.content[0].text.startsWith('❌'), 'missing environment should fail closed');
+    assert.match(result.content[0].text, /無法讀取 GrayRelease 環境欄位/);
+    assert.deepEqual(transitions, []);
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════
+// auto_grayrelease build/deploy completion result fields
+// ═══════════════════════════════════════════════════════════════════
+describe('auto_grayrelease — build/deploy result fields', () => {
+  const savedEnv = {
+    POLL_INTERVAL_MS: process.env.POLL_INTERVAL_MS,
+    POLL_TIMEOUT_MS: process.env.POLL_TIMEOUT_MS,
+    SWITCH_EXECUTION_NODE_WAIT_MS: process.env.SWITCH_EXECUTION_NODE_WAIT_MS,
+  };
+
+  function useFastPolling() {
+    process.env.POLL_INTERVAL_MS = '0';
+    process.env.POLL_TIMEOUT_MS = '10';
+    process.env.SWITCH_EXECUTION_NODE_WAIT_MS = '0';
+  }
+
+  function restoreEnv() {
+    for (const [key, value] of Object.entries(savedEnv)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+
+  test('get_grayrelease_status normalizes Jira display status names', async () => {
+    const jira = {
+      getIssueFields: async () => ({
+        customfield_13436: { value: 'dev' },
+        customfield_13443: { value: 'IBK' },
+      }),
+      getIssue: async () => ({ fields: { status: { name: 'Wait for Build' }, summary: 'GrayRelease' } }),
+      getTransitions: async () => [
+        { id: '1', name: 'Apply to approval', to: { name: 'Wait Approval' } },
+        { id: '2', name: 'GrayRelease Build', to: { name: 'Wait for Build' } },
+      ],
+    };
+
+    const result = await executeTool(
+      'get_grayrelease_status',
+      { issueKey: 'CID-822' },
+      { jira, notifier: mockNotifier },
+    );
+
+    assert.ok(!result.isError, result.content[0].text);
+    const output = JSON.parse(result.content[0].text);
+    assert.equal(output.currentStatus, 'Wait for Build');
+    assert.equal(output.normalizedStatus, 'WAIT FOR BUILD');
+    assert.deepEqual(output.nextSteps, ['GrayRelease Build']);
+  });
+
+  test('deploy_grayrelease advances Wait for Build via approval without rebuilding', async () => {
+    useFastPolling();
+    let status = 'Wait for Build';
+    const transitions = [];
+    const jira = {
+      getIssueFields: async (_issueKey, fieldNames = []) => {
+        if (fieldNames.includes('customfield_13433')) {
+          return { customfield_13433: 'pass' };
+        }
+        return {
+          customfield_13436: { value: 'dev' },
+          customfield_13443: { value: 'IBK' },
+        };
+      },
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
+      getTransitions: async () => {
+        if (status === 'Wait for Build') {
+          return [
+            { id: '1', name: 'Apply to approval', to: { name: 'Wait Approval' } },
+            { id: '2', name: 'GrayRelease Build', to: { name: 'Wait for Build' } },
+          ];
+        }
+        return [];
+      },
+      searchIssues: async () => [{ fields: { customfield_13436: { value: 'stg' } } }],
+      transitionByName: async (_issueKey, transitionName) => {
+        transitions.push(transitionName);
+        if (transitionName === 'Apply to approval') status = 'Wait Approval';
+        if (transitionName === 'Approve') status = 'Wait Deploy';
+        if (transitionName === 'To Verify') status = 'VERIFY';
+      },
+    };
+
+    try {
+      const result = await executeTool(
+        'deploy_grayrelease',
+        { issueKey: 'CID-822' },
+        { jira, notifier: mockNotifier },
+      );
+
+      assert.ok(!result.isError, result.content[0].text);
+      const output = JSON.parse(result.content[0].text);
+      assert.equal(output.finalStatus, 'VERIFY');
+      assert.deepEqual(transitions, [
+        'Apply to approval',
+        'Approve',
+        'GrayRelease Deploy',
+        'To Verify',
+      ]);
+    } finally {
+      restoreEnv();
+    }
+  });
+
+  test('deploy_grayrelease stops in VERIFY without rebuilding', async () => {
+    const transitions = [];
+    const jira = {
+      getIssueFields: async () => ({
+        customfield_13436: { value: 'dev' },
+        customfield_13443: { value: 'IBK' },
+      }),
+      getIssue: async () => ({ fields: { status: { name: 'VERIFY' }, summary: 'GrayRelease' } }),
+      transitionByName: async (_issueKey, transitionName) => {
+        transitions.push(transitionName);
+      },
+    };
+
+    const result = await executeTool(
+      'deploy_grayrelease',
+      { issueKey: 'CID-822' },
+      { jira, notifier: mockNotifier },
+    );
+
+    assert.ok(!result.isError, result.content[0].text);
+    const output = JSON.parse(result.content[0].text);
+    assert.equal(output.finalStatus, 'VERIFY');
+    assert.deepEqual(transitions, []);
+    assert.match(output.log.join('\n'), /若需重 build 請明確執行 build\/rebuild/);
+  });
+
+  test('Build waits until customfield_13432 becomes pass before Apply to approval', async () => {
+    useFastPolling();
+    const events = [];
+    let status = 'WAIT FOR BUILD';
+    let buildResultCalls = 0;
+    const transitions = [];
+    const jira = {
+      getIssueFields: async (_issueKey, fieldNames = []) => {
+        if (fieldNames.includes('customfield_13432')) {
+          buildResultCalls++;
+          return { customfield_13432: buildResultCalls >= 3 ? 'pass' : 'starting' };
+        }
+        return {
+          customfield_13436: { value: 'dev' },
+          customfield_13443: { value: 'CWA' },
+        };
+      },
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
+      transitionByName: async (_issueKey, transitionName) => {
+        transitions.push(transitionName);
+        if (transitionName === 'Apply to approval') {
+          status = 'DONE';
+        }
+      },
+    };
+
+    try {
+      const result = await executeTool(
+        'auto_grayrelease',
+        { issueKey: 'CID-200', autoVerify: false },
+        { jira, notifier: mockNotifier, progress: (event) => events.push(event) },
+      );
+
+      assert.ok(!result.content[0].text.startsWith('❌'), 'Build flow should succeed');
+      assert.equal(buildResultCalls, 3);
+      assert.deepEqual(transitions, ['GrayRelease Build', 'Apply to approval']);
+      assert.ok(events.some((event) => (
+        event.phase === 'polling' &&
+        event.title === '等待 GrayRelease Build 結果' &&
+        event.attempts === 3
+      )));
+    } finally {
+      restoreEnv();
+    }
+  });
+
+  test('Deploy waits until customfield_13433 becomes pass before To Verify', async () => {
+    useFastPolling();
+    let status = 'WAIT DEPLOY';
+    let deployResultCalls = 0;
+    const transitions = [];
+    const jira = {
+      getIssueFields: async (_issueKey, fieldNames = []) => {
+        if (fieldNames.includes('customfield_13433')) {
+          deployResultCalls++;
+          return { customfield_13433: deployResultCalls >= 3 ? 'pass' : 'starting' };
+        }
+        return {
+          customfield_13436: { value: 'stg' },
+          customfield_13443: { value: 'CWA' },
+        };
+      },
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
+      searchIssues: async () => [{ fields: { customfield_13436: { value: 'stg' } } }],
+      transitionByName: async (_issueKey, transitionName) => {
+        transitions.push(transitionName);
+        if (transitionName === 'To Verify') {
+          status = 'VERIFY';
+        }
+      },
+    };
+
+    try {
+      const result = await executeTool(
+        'auto_grayrelease',
+        { issueKey: 'CID-201', autoVerify: false },
+        { jira, notifier: mockNotifier },
+      );
+
+      assert.ok(!result.content[0].text.startsWith('❌'), 'Deploy flow should succeed');
+      assert.equal(deployResultCalls, 3);
+      assert.deepEqual(transitions, ['GrayRelease Deploy', 'To Verify']);
+    } finally {
+      restoreEnv();
+    }
+  });
+
+  test('Deploy skips Switch Execution Node when recent cid jira worker success comment exists', async () => {
+    useFastPolling();
+    let status = 'WAIT DEPLOY';
+    const transitions = [];
+    const jira = {
+      getIssueFields: async (_issueKey, fieldNames = []) => {
+        if (fieldNames.includes('customfield_13433')) {
+          return { customfield_13433: 'pass' };
+        }
+        return {
+          customfield_13436: { value: 'stg' },
+          customfield_13443: { value: 'IBK' },
+        };
+      },
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
+      getComments: async () => [
+        {
+          body: "Trigger update IBK's instance_group to [ING]NonPRD_ExecutionNode success, please wait about 3 mins before trigger deploy.",
+          author: { displayName: 'cid jira worker' },
+          created: new Date().toISOString(),
+        },
+      ],
+      searchIssues: async () => [{ fields: { customfield_13436: { value: 'prd' } } }],
+      transitionByName: async (_issueKey, transitionName) => {
+        transitions.push(transitionName);
+        if (transitionName === 'To Verify') {
+          status = 'VERIFY';
+        }
+      },
+    };
+
+    try {
+      const result = await executeTool(
+        'auto_grayrelease',
+        { issueKey: 'CID-202', autoVerify: false },
+        { jira, notifier: mockNotifier },
+      );
+
+      assert.ok(!result.content[0].text.startsWith('❌'), 'Deploy flow should succeed');
+      assert.deepEqual(transitions, ['GrayRelease Deploy', 'To Verify']);
+    } finally {
+      restoreEnv();
+    }
+  });
+
+  test('Deploy waits for worker success comment after Switch Execution Node then deploys directly', async () => {
+    useFastPolling();
+    let status = 'WAIT DEPLOY';
+    let getCommentsCalls = 0;
+    let searchIssuesCalls = 0;
+    const transitions = [];
+    const jira = {
+      getIssueFields: async (_issueKey, fieldNames = []) => {
+        if (fieldNames.includes('customfield_13433')) {
+          return { customfield_13433: 'pass' };
+        }
+        return {
+          customfield_13436: { value: 'stg' },
+          customfield_13443: { value: 'IBK' },
+        };
+      },
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
+      getComments: async () => {
+        getCommentsCalls++;
+        if (getCommentsCalls < 2) {
+          return [];
+        }
+        return [
+          {
+            body: "Trigger update IBK's instance_group to [ING]NonPRD_ExecutionNode success, please wait about 3 mins before trigger deploy.",
+            author: { displayName: 'CID Jira Worker' },
+            created: new Date().toISOString(),
+          },
+        ];
+      },
+      searchIssues: async () => {
+        searchIssuesCalls++;
+        return [{ fields: { customfield_13436: { value: 'prd' } } }];
+      },
+      transitionByName: async (_issueKey, transitionName) => {
+        transitions.push(transitionName);
+        if (transitionName === 'To Verify') {
+          status = 'VERIFY';
+        }
+      },
+    };
+
+    try {
+      const result = await executeTool(
+        'auto_grayrelease',
+        { issueKey: 'CID-203', autoVerify: false },
+        { jira, notifier: mockNotifier },
+      );
+
+      assert.ok(!result.content[0].text.startsWith('❌'), 'Deploy flow should succeed');
+      assert.equal(searchIssuesCalls, 1);
+      assert.deepEqual(transitions, ['Switch Execution Node', 'GrayRelease Deploy', 'To Verify']);
+    } finally {
+      restoreEnv();
+    }
+  });
+});
+
 // ═══════════════════════════════════════════════════════════════════
 // prepare_cd_deployment
 // ═══════════════════════════════════════════════════════════════════
@@ -1376,10 +2108,23 @@ describe('prepare_cd_deployment', () => {
         return {};
       },
       getIssue: async () => ({ fields: { status: { name: resultStatus }, summary: 'CD test' } }),
-      addComment: async () => {},
+      addComment: async () => { },
     };
   }
 
+  test('dev：更新 customfield_13436 為 id 14355', async () => {
+    const jira = makeDeployMock();
+    await executeTool(
+      'prepare_cd_deployment',
+      { issueKey: 'CID-1697', environment: 'dev' },
+      {
+        jira,
+        notifier: mockNotifier,
+      },
+    );
+    assert.deepEqual(jira.calls.updateIssue[0].fields['customfield_13436'], { id: '14355' });
+  });
+
   test('stg：更新 customfield_13436 為 id 14356', async () => {
     const jira = makeDeployMock();
     await executeTool(
@@ -1492,12 +2237,12 @@ describe('prepare_cd_deployment', () => {
 
   test('找不到任何 deploy transition → 回傳錯誤', async () => {
     const jira = {
-      updateIssue: async () => {},
+      updateIssue: async () => { },
       getTransitions: async () => [
         { id: '1', name: 'Some Other Transition', to: { name: 'Other' } },
       ],
       getIssue: async () => ({ fields: { status: { name: 'Approved' }, summary: 'CD test' } }),
-      addComment: async () => {},
+      addComment: async () => { },
     };
     const result = await executeTool(
       'prepare_cd_deployment',
@@ -1529,7 +2274,7 @@ describe('prepare_cd_deployment', () => {
     let callCount = 0;
     const calls = { transitionById: [] };
     const jira = {
-      updateIssue: async () => {},
+      updateIssue: async () => { },
       getTransitions: async () => {
         callCount++;
         // findDeployTrans(1) → 無；pre-transition check(2) → Accept；findDeployTrans after Accept(3) → deploy
@@ -1548,7 +2293,7 @@ describe('prepare_cd_deployment', () => {
         return {};
       },
       getIssue: async () => ({ fields: { status: { name: 'Prepare For Deploy' }, summary: 'CD' } }),
-      addComment: async () => {},
+      addComment: async () => { },
     };
     const result = await executeTool(
       'prepare_cd_deployment',
@@ -1573,6 +2318,146 @@ describe('prepare_cd_deployment', () => {
       '第 2 次應觸發 Prepare to create deployment ticket',
     );
   });
+
+  test('dev：建立 deployment 後自助執行 Apply for approval 與 Approved 到 Wait Deploy', async () => {
+    let callCount = 0;
+    let status = 'TO DO';
+    const calls = { transitionById: [] };
+    const jira = {
+      updateIssue: async () => { },
+      getTransitions: async () => {
+        callCount++;
+        if (callCount === 1) {
+          return [{ id: '71', name: 'Prepare to create deployment ticket', to: { name: 'Prepare For Deploy' } }];
+        }
+        if (callCount === 2) {
+          return [{ id: '21', name: 'Apply for approval', to: { name: 'Wait Approval' } }];
+        }
+        if (callCount === 3) {
+          return [{ id: '72', name: 'Approved', to: { name: 'Wait Deploy' } }];
+        }
+        return [];
+      },
+      transitionById: async (key, id) => {
+        calls.transitionById.push({ key, id });
+        if (id === '71') status = 'Prepare For Deploy';
+        if (id === '21') status = 'Wait Approval';
+        if (id === '72') status = 'Wait Deploy';
+        return {};
+      },
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'CD' } }),
+      addComment: async () => { },
+    };
+    const result = await executeTool(
+      'prepare_cd_deployment',
+      { issueKey: 'CID-1697', environment: 'dev' },
+      {
+        jira,
+        notifier: mockNotifier,
+      },
+    );
+    assert.ok(!result.content[0].text.startsWith('❌'), '應成功觸發');
+    const data = JSON.parse(result.content[0].text);
+    assert.equal(data.status, 'Wait Deploy');
+    assert.deepEqual(calls.transitionById.map((call) => call.id), ['71', '21', '72']);
+  });
+
+  test('dev：deployment ticket 已存在時續跑 approval 到 Wait Deploy', async () => {
+    let callCount = 0;
+    let status = 'Prepare For Deploy';
+    const calls = { transitionById: [] };
+    const jira = {
+      updateIssue: async () => { },
+      getTransitions: async () => {
+        callCount++;
+        if (callCount === 1) {
+          return [{ id: '71', name: 'Prepare to create deployment ticket', to: { name: 'Prepare For Deploy' } }];
+        }
+        if (callCount === 2) {
+          return [{ id: '21', name: 'Apply for approval', to: { name: 'Wait Approval' } }];
+        }
+        if (callCount === 3) {
+          return [{ id: '72', name: 'Approved', to: { name: 'Wait Deploy' } }];
+        }
+        return [];
+      },
+      transitionById: async (key, id) => {
+        calls.transitionById.push({ key, id });
+        if (id === '71') throw new Error('Transition id=71 failed: {"errorMessages":["Already create deployment ticket"],"errors":{}}');
+        if (id === '21') status = 'Wait Approval';
+        if (id === '72') status = 'Wait Deploy';
+        return {};
+      },
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'CD' } }),
+      addComment: async () => { },
+    };
+    const result = await executeTool(
+      'prepare_cd_deployment',
+      { issueKey: 'CID-1910', environment: 'dev' },
+      {
+        jira,
+        notifier: mockNotifier,
+      },
+    );
+
+    assert.ok(!result.content[0].text.startsWith('❌'), '應成功續跑');
+    const data = JSON.parse(result.content[0].text);
+    assert.equal(data.status, 'Wait Deploy');
+    assert.deepEqual(calls.transitionById.map((call) => call.id), ['71', '21', '72']);
+    assert.ok(data.steps.some((step) => step.includes('Deployment ticket 已存在')));
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════
+// wait_to_dev
+// ═══════════════════════════════════════════════════════════════════
+describe('wait_to_dev', () => {
+  test('執行 Upload Scan Report 與 Accept，停在 Wait To DEV', async () => {
+    const calls = [];
+    const jira = {
+      getTransitions: async () => [
+        { id: '10', name: 'Upload Scan Report', to: { name: 'Upload Report' } },
+        { id: '11', name: 'Accept', to: { name: 'Wait To DEV' } },
+      ],
+      transitionById: async (key, id) => {
+        calls.push({ key, id });
+      },
+      getIssue: async () => ({ fields: { status: { name: 'Wait To DEV' }, summary: 'CI' } }),
+      addComment: async () => { },
+    };
+
+    const result = await executeTool(
+      'wait_to_dev',
+      { issueKey: 'CID-1709' },
+      { jira, notifier: mockNotifier },
+    );
+
+    assert.ok(!result.content[0].text.startsWith('❌'), '應成功觸發');
+    const data = JSON.parse(result.content[0].text);
+    assert.equal(data.status, 'Wait To DEV');
+    assert.deepEqual(calls.map((call) => call.id), ['10', '11']);
+  });
+
+  test('已是 Wait To DEV 時可跳過缺少的 Accept transition', async () => {
+    const calls = [];
+    const jira = {
+      getTransitions: async () => [],
+      transitionById: async (key, id) => {
+        calls.push({ key, id });
+      },
+      getIssue: async () => ({ fields: { status: { name: 'Wait To DEV' }, summary: 'CI' } }),
+      addComment: async () => { },
+    };
+
+    const result = await executeTool(
+      'wait_to_dev',
+      { issueKey: 'CID-1709' },
+      { jira, notifier: mockNotifier },
+    );
+
+    assert.ok(!result.content[0].text.startsWith('❌'), '應成功');
+    assert.equal(calls.length, 0);
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════
@@ -1615,7 +2500,7 @@ describe('trigger_deployment', () => {
       getIssue: async (key) => ({
         fields: { status: { name: finalStatus }, summary: `[MOCK] ${key}` },
       }),
-      addComment: async () => {},
+      addComment: async () => { },
     };
   }
 
@@ -1703,6 +2588,26 @@ describe('trigger_deployment', () => {
     assert.equal(data.deploymentKey, 'CID-9002', '應選 UAT sub-task');
   });
 
+  test('環境比對：[DEV] summary 對應 dev → 選擇 DEV sub-task', async () => {
+    const jira = makeTriggerMock({
+      subTasks: [makeSubTask('CID-9001', '[DEV]'), makeSubTask('CID-9002', '[STG]')],
+      deployTrans: [
+        { id: '11', name: 'To AutoDeploy', to: { name: 'Pre Auto Deploy' } },
+        { id: '12', name: 'Trigger AutoDeploy', to: { name: 'Auto Deploy' } },
+      ],
+    });
+    const result = await executeTool(
+      'trigger_deployment',
+      { cdIssueKey: 'CID-9000', environment: 'dev' },
+      {
+        jira,
+        notifier: mockNotifier,
+      },
+    );
+    const data = JSON.parse(result.content[0].text);
+    assert.equal(data.deploymentKey, 'CID-9001', '應選 DEV sub-task');
+  });
+
   test('無符合環境的 sub-task → fallback 取第一個', async () => {
     const jira = makeTriggerMock({
       subTasks: [makeSubTask('CID-9001', '[DEV]')],