@jira-deploy/core 1.0.1 → 1.0.3

package/tools.test.js

@@ -4,7 +4,8 @@
  */
 import { test, describe } from 'node:test';
 import assert from 'node:assert/strict';
-import { executeTool } from './tools/index.js';
+import http from 'node:http';
+import { executeTool, getToolDefinitions } from './tools/index.js';
 
 process.env.JIRA_BASE_URL = 'https://jira.test';
 
@@ -118,6 +119,154 @@ function makeMockJira({
 
 const mockNotifier = { notify: async () => [] };
 
+function getToolDefinition(name) {
+  return getToolDefinitions().find((tool) => tool.name === name);
+}
+
+describe('tool schemas — agent contract', () => {
+  test('create_cd_ticket schema matches handler-supported arguments', () => {
+    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',
+      'clusterDeploy',
+      'moduleChild',
+      'restartOnly',
+      'extraVars',
+    ]) {
+      assert.ok(tool.inputSchema.properties[property], `missing ${property}`);
+    }
+  });
+
+  test('create_library_ticket schema treats module as defaultable', () => {
+    const tool = getToolDefinition('create_library_ticket');
+
+    assert.deepEqual(tool.inputSchema.required, ['systemCode', 'gitBranch']);
+    assert.match(tool.inputSchema.properties.module.description, /預設/);
+  });
+
+  test('release workflows are exposed as MCP tools', () => {
+    assert.ok(getToolDefinition('run_stg_full_release'));
+    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('run_stg_full_release dispatches shared workflow steps', async () => {
+    const calls = [];
+    const result = await executeTool('run_stg_full_release', {systemCode: 'IBK'}, {
+      jira: makeMockJira(),
+      notifier: mockNotifier,
+      executeToolImpl: async (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'},
+        };
+        return {content: [{type: 'text', text: JSON.stringify(outputs[name])}]};
+      },
+    });
+
+    const output = JSON.parse(result.content[0].text);
+    assert.equal(output.type, 'STG Full Release');
+    assert.equal(output.ciIssueKey, 'CID-100');
+    assert.equal(output.cdIssueKey, 'CID-200');
+    assert.deepEqual(calls.map((call) => call.name), [
+      'create_ci_ticket',
+      'build_ticket',
+      'wait_to_stg',
+      'create_cd_ticket',
+      'prepare_cd_deployment',
+      'trigger_deployment',
+    ]);
+    assert.equal(calls[3].args.linkedCiKey, 'CID-100');
+    assert.equal(calls[5].args.applyForClose, true);
+  });
+
+  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', {
+      systemCode: 'IBK',
+      gitBranch: 'release/v1.5.2.0',
+    }, {
+      jira: {
+        ...makeMockJira(),
+        getIssue: async () => ({fields: {status: {name: 'WAIT FOR LIB BUILD'}}}),
+      },
+      notifier: mockNotifier,
+      workflowWaitOptions: {timeoutMs: 1, intervalMs: 1},
+      executeToolImpl: async (name, args) => {
+        calls.push({name, args});
+        const outputs = {
+          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])}]};
+      },
+    });
+
+    assert.equal(result.isError, true);
+    assert.match(result.content[0].text, /等待 LIB-100 狀態 Released 超時/);
+    assert.deepEqual(calls.map((call) => call.name), [
+      'create_library_ticket',
+      'build_ticket',
+    ]);
+  });
+
+  test('workflow tool failures are marked as MCP errors', async () => {
+    const result = await executeTool('run_stg_full_release', {systemCode: 'IBK'}, {
+      jira: makeMockJira(),
+      notifier: mockNotifier,
+      executeToolImpl: async () => ({
+        content: [{type: 'text', text: '❌ 錯誤: nested tool failed'}],
+        isError: true,
+      }),
+    });
+
+    assert.equal(result.isError, true);
+    assert.match(result.content[0].text, /run_stg_full_release 失敗/);
+    assert.match(result.content[0].text, /nested tool failed/);
+  });
+
+  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},
+    );
+
+    assert.equal(result.isError, true);
+    assert.match(result.content[0].text, /不支援的 CD 部署環境/);
+  });
+
+  test('read-only tools expose readOnlyHint metadata for CLI confirmation', () => {
+    for (const name of [
+      'get_issue_status',
+      'list_transitions',
+      'get_release_status',
+      'get_unreleased_versions',
+      'get_release_manager',
+      'wait_for_comment',
+    ]) {
+      assert.equal(getToolDefinition(name).annotations?.readOnlyHint, true, `${name} should be read-only`);
+    }
+  });
+
+  test('write workflow tools are not marked read-only', () => {
+    assert.notEqual(getToolDefinition('run_stg_full_release').annotations?.readOnlyHint, true);
+    assert.notEqual(getToolDefinition('run_lib_to_stg_release').annotations?.readOnlyHint, true);
+  });
+});
+
 /** 執行 tool，回傳 createIssue 收到的 fields（合併 updateIssue 的欄位，或 throw 若 ❌） */
 async function getCreatedFields(toolName, args, jiraOpts = {}) {
   const jira = makeMockJira(jiraOpts);
@@ -224,6 +373,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/);
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════
@@ -448,6 +613,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']);
@@ -1205,6 +1387,352 @@ 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'},
+        CID_build_result: 'pass',
+        CID_deploy_result: '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) => server.close(resolve));
+      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('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('Build waits until CID_build_result becomes pass before Apply to approval', async () => {
+    useFastPolling();
+    let status = 'WAIT FOR BUILD';
+    let buildResultCalls = 0;
+    const transitions = [];
+    const jira = {
+      getIssueFields: async (_issueKey, fieldNames = []) => {
+        if (fieldNames.includes('CID_build_result')) {
+          buildResultCalls++;
+          return {CID_build_result: 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},
+      );
+
+      assert.ok(!result.content[0].text.startsWith('❌'), 'Build flow should succeed');
+      assert.equal(buildResultCalls, 3);
+      assert.deepEqual(transitions, ['GrayRelease Build', 'Apply to approval']);
+    } finally {
+      restoreEnv();
+    }
+  });
+
+  test('Deploy waits until CID_deploy_result 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')) {
+          deployResultCalls++;
+          return {CID_deploy_result: 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('CID_deploy_result')) {
+          return {CID_deploy_result: '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('CID_deploy_result')) {
+          return {CID_deploy_result: '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
 // ═══════════════════════════════════════════════════════════════════
@@ -1237,6 +1765,19 @@ describe('prepare_cd_deployment', () => {
     };
   }
 
+  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(
@@ -1430,6 +1971,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);
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════
@@ -1523,7 +2204,10 @@ describe('trigger_deployment', () => {
   test('環境比對：[STG] summary 對應 stg → 選擇 STG sub-task，不選 UAT', async () => {
     const jira = makeTriggerMock({
       subTasks: [makeSubTask('CID-9001', '[STG]'), makeSubTask('CID-9002', '[UAT]')],
-      deployTrans: [{ id: '11', name: 'To AutoDeploy', to: { name: 'Pre Auto Deploy' } }],
+      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',
@@ -1540,7 +2224,10 @@ describe('trigger_deployment', () => {
   test('環境比對：[UAT] summary 對應 uat → 選擇 UAT sub-task', async () => {
     const jira = makeTriggerMock({
       subTasks: [makeSubTask('CID-9001', '[STG]'), makeSubTask('CID-9002', '[UAT]')],
-      deployTrans: [{ id: '11', name: 'To AutoDeploy', to: { name: 'Pre Auto Deploy' } }],
+      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',
@@ -1554,10 +2241,33 @@ 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]')],
-      deployTrans: [{ id: '11', name: 'To AutoDeploy', to: { name: 'Pre Auto Deploy' } }],
+      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',
@@ -1575,7 +2285,7 @@ describe('trigger_deployment', () => {
     );
   });
 
-  test('找不到 transition → 跳過，不中斷，仍回傳成功', async () => {
+  test('找不到必要 deployment transition → 回傳錯誤', async () => {
     const jira = makeTriggerMock({
       subTasks: [makeSubTask('CID-9001', '[STG]')],
       deployTrans: [], // 完全沒有 transitions
@@ -1588,12 +2298,8 @@ describe('trigger_deployment', () => {
         notifier: mockNotifier,
       },
     );
-    assert.ok(!result.content[0].text.startsWith('❌'), '應成功回傳（跳過所有 transition）');
-    const data = JSON.parse(result.content[0].text);
-    assert.ok(
-      data.steps.some((s) => s.includes('跳過')),
-      '應記錄跳過',
-    );
+    assert.equal(result.isError, true);
+    assert.match(result.content[0].text, /找不到必要部署 transition/);
   });
 
   test('applyForClose=true → 觸發 CD 單的 Apply for close', async () => {
@@ -1620,7 +2326,10 @@ describe('trigger_deployment', () => {
   test('applyForClose 預設 false → 不觸發 CD 單 transition', async () => {
     const jira = makeTriggerMock({
       subTasks: [makeSubTask('CID-9001', '[STG]')],
-      deployTrans: [{ id: '11', name: 'To AutoDeploy', to: { name: 'Pre Auto Deploy' } }],
+      deployTrans: [
+        { id: '11', name: 'To AutoDeploy', to: { name: 'Pre Auto Deploy' } },
+        { id: '12', name: 'Trigger AutoDeploy', to: { name: 'Auto Deploy' } },
+      ],
       cdTrans: [{ id: '99', name: 'Apply for close', to: { name: 'Wait For Close' } }],
     });
     await executeTool(
@@ -1638,7 +2347,10 @@ describe('trigger_deployment', () => {
   test('applyForClose=true 但 CD 單找不到 Apply for close → 記錄警告不中斷', async () => {
     const jira = makeTriggerMock({
       subTasks: [makeSubTask('CID-9001', '[STG]')],
-      deployTrans: [{ id: '11', name: 'To AutoDeploy', to: { name: 'Pre Auto Deploy' } }],
+      deployTrans: [
+        { id: '11', name: 'To AutoDeploy', to: { name: 'Pre Auto Deploy' } },
+        { id: '12', name: 'Trigger AutoDeploy', to: { name: 'Auto Deploy' } },
+      ],
       cdTrans: [], // CD 單沒有 Apply for close
     });
     const result = await executeTool(