@jira-deploy/core 1.0.3 → 1.0.5

package/tools.test.js

@@ -6,6 +6,7 @@ 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';
 
@@ -110,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 () => [],
   };
 }
@@ -141,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');
 
@@ -157,22 +171,108 @@ describe('tool schemas — agent contract', () => {
     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]) }] };
       },
     });
 
@@ -192,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', {
@@ -200,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]) }] };
       },
     });
 
@@ -223,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,
       }),
     });
@@ -240,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);
@@ -265,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 若 ❌） */
@@ -377,10 +578,10 @@ describe('create_library_ticket — fields', () => {
     const notifications = [];
     const result = await executeTool(
       'create_library_ticket',
-      {systemCode: 'CWA', gitBranch: 'release/v1.0.0'},
+      { systemCode: 'CWA', gitBranch: 'release/v1.0.0' },
       {
         jira: makeMockJira(),
-        notifier: {notify: async (key, message) => notifications.push({key, message})},
+        notifier: { notify: async (key, message) => notifications.push({ key, message }) },
       },
     );
 
@@ -617,10 +818,10 @@ describe('create_cd_ticket — fields', () => {
     const notifications = [];
     const result = await executeTool(
       'create_cd_ticket',
-      {systemCode: 'CWA', environment: 'dev'},
+      { systemCode: 'CWA', environment: 'dev' },
       {
         jira: makeMockJira(),
-        notifier: {notify: async (key, message) => notifications.push({key, message})},
+        notifier: { notify: async (key, message) => notifications.push({ key, message }) },
       },
     );
 
@@ -1409,34 +1610,34 @@ describe('auto_grayrelease — approval payload handling', () => {
     }
   }
 
-  function makeApprovalJira(environment, {comments = []} = {}) {
+  function makeApprovalJira(environment, { comments = [] } = {}) {
     let status = 'WAIT APPROVAL';
-    const calls = {updateAssignee: [], transitionByName: []};
+    const calls = { updateAssignee: [], transitionByName: [] };
 
     return {
       calls,
       getIssueFields: async () => ({
-        customfield_13436: {value: environment},
-        customfield_13443: {value: 'CWA'},
-        CID_build_result: 'pass',
-        CID_deploy_result: 'pass',
+        customfield_13436: { value: environment },
+        customfield_13443: { value: 'CWA' },
+        customfield_13432: 'pass',
+        customfield_13433: 'pass',
       }),
-      getIssue: async () => ({fields: {status: {name: status}, summary: 'GrayRelease'}}),
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
       getTransitions: async () => [],
       updateAssignee: async (issueKey, accountId) => {
-        calls.updateAssignee.push({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'}}}],
+      searchIssues: async () => [{ fields: { customfield_13436: { value: 'stg' } } }],
       transitionByName: async (issueKey, transitionName) => {
-        calls.transitionByName.push({issueKey, transitionName});
+        calls.transitionByName.push({ issueKey, transitionName });
         if (transitionName === 'To Verify') {
           status = 'VERIFY';
         }
-        return {transitioned: transitionName, toStatus: status};
+        return { transitioned: transitionName, toStatus: status };
       },
     };
   }
@@ -1444,7 +1645,7 @@ describe('auto_grayrelease — approval payload handling', () => {
   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'}]}));
+      res.end(JSON.stringify({ events: [{ what: 'Sign off staff', who: 'Alvin Wang' }] }));
     });
     await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
 
@@ -1458,16 +1659,19 @@ describe('auto_grayrelease — approval payload handling', () => {
       const jira = makeApprovalJira('stg');
       const result = await executeTool(
         'auto_grayrelease',
-        {issueKey: 'CID-100', autoVerify: false},
-        {jira, notifier: mockNotifier},
+        { 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'}]);
+      assert.deepEqual(jira.calls.updateAssignee, [{ issueKey: 'CID-100', accountId: 'BK00619' }]);
     } finally {
-      await new Promise((resolve) => server.close(resolve));
+      await new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+        server.closeAllConnections?.();
+      });
       restoreEnv();
     }
   });
@@ -1479,33 +1683,64 @@ describe('auto_grayrelease — approval payload handling', () => {
       process.env.POLL_TIMEOUT_MS = '10';
 
       const jira = makeApprovalJira('uat', {
-        comments: [{body: 'Approved, please proceed', author: {name: 'BK00619', displayName: 'James Yu'}}],
+        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},
+        { 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'},
+        { 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'},
+        customfield_13443: { value: 'CWA' },
       }),
-      getIssue: async () => ({fields: {status: {name: 'WAIT APPROVAL'}, summary: 'GrayRelease'}}),
+      getIssue: async () => ({ fields: { status: { name: 'WAIT APPROVAL' }, summary: 'GrayRelease' } }),
       transitionByName: async (_issueKey, transitionName) => {
         transitions.push(transitionName);
       },
@@ -1513,8 +1748,8 @@ describe('auto_grayrelease — approval payload handling', () => {
 
     const result = await executeTool(
       'auto_grayrelease',
-      {issueKey: 'CID-102', autoVerify: false},
-      {jira, notifier: mockNotifier},
+      { issueKey: 'CID-102', autoVerify: false },
+      { jira, notifier: mockNotifier },
     );
 
     assert.ok(result.content[0].text.startsWith('❌'), 'missing environment should fail closed');
@@ -1549,23 +1784,130 @@ describe('auto_grayrelease — build/deploy result fields', () => {
     }
   }
 
-  test('Build waits until CID_build_result becomes pass before Apply to approval', async () => {
+  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('CID_build_result')) {
+        if (fieldNames.includes('customfield_13432')) {
           buildResultCalls++;
-          return {CID_build_result: buildResultCalls >= 3 ? 'pass' : 'starting'};
+          return { customfield_13432: buildResultCalls >= 3 ? 'pass' : 'starting' };
         }
         return {
-          customfield_13436: {value: 'dev'},
-          customfield_13443: {value: 'CWA'},
+          customfield_13436: { value: 'dev' },
+          customfield_13443: { value: 'CWA' },
         };
       },
-      getIssue: async () => ({fields: {status: {name: status}, summary: 'GrayRelease'}}),
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
       transitionByName: async (_issueKey, transitionName) => {
         transitions.push(transitionName);
         if (transitionName === 'Apply to approval') {
@@ -1577,36 +1919,41 @@ describe('auto_grayrelease — build/deploy result fields', () => {
     try {
       const result = await executeTool(
         'auto_grayrelease',
-        {issueKey: 'CID-200', autoVerify: false},
-        {jira, notifier: mockNotifier},
+        { 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 CID_deploy_result becomes pass before To Verify', async () => {
+  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('CID_deploy_result')) {
+        if (fieldNames.includes('customfield_13433')) {
           deployResultCalls++;
-          return {CID_deploy_result: deployResultCalls >= 3 ? 'pass' : 'starting'};
+          return { customfield_13433: deployResultCalls >= 3 ? 'pass' : 'starting' };
         }
         return {
-          customfield_13436: {value: 'stg'},
-          customfield_13443: {value: 'CWA'},
+          customfield_13436: { value: 'stg' },
+          customfield_13443: { value: 'CWA' },
         };
       },
-      getIssue: async () => ({fields: {status: {name: status}, summary: 'GrayRelease'}}),
-      searchIssues: async () => [{fields: {customfield_13436: {value: 'stg'}}}],
+      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') {
@@ -1618,8 +1965,8 @@ describe('auto_grayrelease — build/deploy result fields', () => {
     try {
       const result = await executeTool(
         'auto_grayrelease',
-        {issueKey: 'CID-201', autoVerify: false},
-        {jira, notifier: mockNotifier},
+        { issueKey: 'CID-201', autoVerify: false },
+        { jira, notifier: mockNotifier },
       );
 
       assert.ok(!result.content[0].text.startsWith('❌'), 'Deploy flow should succeed');
@@ -1636,23 +1983,23 @@ describe('auto_grayrelease — build/deploy result fields', () => {
     const transitions = [];
     const jira = {
       getIssueFields: async (_issueKey, fieldNames = []) => {
-        if (fieldNames.includes('CID_deploy_result')) {
-          return {CID_deploy_result: 'pass'};
+        if (fieldNames.includes('customfield_13433')) {
+          return { customfield_13433: 'pass' };
         }
         return {
-          customfield_13436: {value: 'stg'},
-          customfield_13443: {value: 'IBK'},
+          customfield_13436: { value: 'stg' },
+          customfield_13443: { value: 'IBK' },
         };
       },
-      getIssue: async () => ({fields: {status: {name: status}, summary: 'GrayRelease'}}),
+      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'},
+          author: { displayName: 'cid jira worker' },
           created: new Date().toISOString(),
         },
       ],
-      searchIssues: async () => [{fields: {customfield_13436: {value: 'prd'}}}],
+      searchIssues: async () => [{ fields: { customfield_13436: { value: 'prd' } } }],
       transitionByName: async (_issueKey, transitionName) => {
         transitions.push(transitionName);
         if (transitionName === 'To Verify') {
@@ -1664,8 +2011,8 @@ describe('auto_grayrelease — build/deploy result fields', () => {
     try {
       const result = await executeTool(
         'auto_grayrelease',
-        {issueKey: 'CID-202', autoVerify: false},
-        {jira, notifier: mockNotifier},
+        { issueKey: 'CID-202', autoVerify: false },
+        { jira, notifier: mockNotifier },
       );
 
       assert.ok(!result.content[0].text.startsWith('❌'), 'Deploy flow should succeed');
@@ -1683,15 +2030,15 @@ describe('auto_grayrelease — build/deploy result fields', () => {
     const transitions = [];
     const jira = {
       getIssueFields: async (_issueKey, fieldNames = []) => {
-        if (fieldNames.includes('CID_deploy_result')) {
-          return {CID_deploy_result: 'pass'};
+        if (fieldNames.includes('customfield_13433')) {
+          return { customfield_13433: 'pass' };
         }
         return {
-          customfield_13436: {value: 'stg'},
-          customfield_13443: {value: 'IBK'},
+          customfield_13436: { value: 'stg' },
+          customfield_13443: { value: 'IBK' },
         };
       },
-      getIssue: async () => ({fields: {status: {name: status}, summary: 'GrayRelease'}}),
+      getIssue: async () => ({ fields: { status: { name: status }, summary: 'GrayRelease' } }),
       getComments: async () => {
         getCommentsCalls++;
         if (getCommentsCalls < 2) {
@@ -1700,14 +2047,14 @@ describe('auto_grayrelease — build/deploy result fields', () => {
         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'},
+            author: { displayName: 'CID Jira Worker' },
             created: new Date().toISOString(),
           },
         ];
       },
       searchIssues: async () => {
         searchIssuesCalls++;
-        return [{fields: {customfield_13436: {value: 'prd'}}}];
+        return [{ fields: { customfield_13436: { value: 'prd' } } }];
       },
       transitionByName: async (_issueKey, transitionName) => {
         transitions.push(transitionName);
@@ -1720,8 +2067,8 @@ describe('auto_grayrelease — build/deploy result fields', () => {
     try {
       const result = await executeTool(
         'auto_grayrelease',
-        {issueKey: 'CID-203', autoVerify: false},
-        {jira, notifier: mockNotifier},
+        { issueKey: 'CID-203', autoVerify: false },
+        { jira, notifier: mockNotifier },
       );
 
       assert.ok(!result.content[0].text.startsWith('❌'), 'Deploy flow should succeed');
@@ -1761,7 +2108,7 @@ describe('prepare_cd_deployment', () => {
         return {};
       },
       getIssue: async () => ({ fields: { status: { name: resultStatus }, summary: 'CD test' } }),
-      addComment: async () => {},
+      addComment: async () => { },
     };
   }
 
@@ -1890,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',
@@ -1927,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
@@ -1946,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',
@@ -1977,7 +2324,7 @@ describe('prepare_cd_deployment', () => {
     let status = 'TO DO';
     const calls = { transitionById: [] };
     const jira = {
-      updateIssue: async () => {},
+      updateIssue: async () => { },
       getTransitions: async () => {
         callCount++;
         if (callCount === 1) {
@@ -1999,7 +2346,7 @@ describe('prepare_cd_deployment', () => {
         return {};
       },
       getIssue: async () => ({ fields: { status: { name: status }, summary: 'CD' } }),
-      addComment: async () => {},
+      addComment: async () => { },
     };
     const result = await executeTool(
       'prepare_cd_deployment',
@@ -2020,7 +2367,7 @@ describe('prepare_cd_deployment', () => {
     let status = 'Prepare For Deploy';
     const calls = { transitionById: [] };
     const jira = {
-      updateIssue: async () => {},
+      updateIssue: async () => { },
       getTransitions: async () => {
         callCount++;
         if (callCount === 1) {
@@ -2042,7 +2389,7 @@ describe('prepare_cd_deployment', () => {
         return {};
       },
       getIssue: async () => ({ fields: { status: { name: status }, summary: 'CD' } }),
-      addComment: async () => {},
+      addComment: async () => { },
     };
     const result = await executeTool(
       'prepare_cd_deployment',
@@ -2076,7 +2423,7 @@ describe('wait_to_dev', () => {
         calls.push({ key, id });
       },
       getIssue: async () => ({ fields: { status: { name: 'Wait To DEV' }, summary: 'CI' } }),
-      addComment: async () => {},
+      addComment: async () => { },
     };
 
     const result = await executeTool(
@@ -2099,7 +2446,7 @@ describe('wait_to_dev', () => {
         calls.push({ key, id });
       },
       getIssue: async () => ({ fields: { status: { name: 'Wait To DEV' }, summary: 'CI' } }),
-      addComment: async () => {},
+      addComment: async () => { },
     };
 
     const result = await executeTool(
@@ -2153,7 +2500,7 @@ describe('trigger_deployment', () => {
       getIssue: async (key) => ({
         fields: { status: { name: finalStatus }, summary: `[MOCK] ${key}` },
       }),
-      addComment: async () => {},
+      addComment: async () => { },
     };
   }