@relipa/ai-flow-kit 0.1.2 → 0.1.4-beta.0

package/scripts/create-score-excel.js

@@ -164,16 +164,25 @@ function buildRow(email, u) {
   const ticketsStr      = ticketsCompleted.length ? ticketsCompleted.join(', ') : '';
 
   // Notes
+  const onlyExploreCmds = [...rawCmds].every(c => EXPLORE_CMDS.has(c));
   let notes = '';
-  if (score === 0) notes = 'Không có event nào trong tuần';
-  else if (score === 1) notes = 'Chỉ có lệnh khám phá cơ bản (init/update/version/help)';
+  if (score === 0) notes = 'Không có hoạt động';
+  else if (score === 1) notes = 'Chỉ dùng lệnh khám phá';
   else if (score === 2) {
-    if (ticketsStarted.length > 0) notes = `Có gate.start nhưng chưa gate4.approved, ${activeDays} ngày active`;
-    else notes = `${displayCmds.slice(0, 3).join('/')}, ${activeDays} ngày active, chưa dùng gate workflow`;
+    if (ticketsStarted.length > 0)
+      notes = `${ticketsStarted.length} ticket(s) trong tuần; Có gate.start nhưng chưa hoàn thành ticket`;
+    else if (onlyExploreCmds)
+      notes = 'Chỉ dùng lệnh khám phá';
   }
-  else if (score === 3) notes = `Gate workflow bắt đầu, ${ticketsStarted.length} ticket(s), chưa hoàn thành`;
-  else if (score === 4) notes = `${ticketsCompleted.length} ticket hoàn thành (gate4+)`;
-  else if (score === 5) notes = `Gate 3-5 approved, ${ticketsCompleted.length} tickets hoàn thành`;
+  else if (score === 3)
+    notes = `${ticketsStarted.length} ticket(s) trong tuần; Có gate.start nhưng chưa hoàn thành ticket`;
+  else if (score === 4) {
+    notes = `Gate 3-5 approved; ${ticketsCompleted.length} ticket(s) hoàn thành`;
+    if (ticketsStarted.length > ticketsCompleted.length)
+      notes += `; ${ticketsStarted.length} ticket(s) trong tuần`;
+  }
+  else if (score === 5)
+    notes = `Gate 3-5 approved; ${ticketsCompleted.length} ticket(s) hoàn thành; ${ticketsStarted.length} ticket(s) trong tuần`;
 
   return {
     email,
@@ -193,9 +202,9 @@ function buildRow(email, u) {
 }
 
 // ── Excel writer ───────────────────────────────────────────────────────────
-async function writeExcel(rows, outputPath) {
+async function writeExcel(rows, outputPath, sheetLabel, fromLabel, toLabel) {
   const workbook = new ExcelJS.Workbook();
-  const sheet = workbook.addWorksheet('Score 18-24.05.2026');
+  const sheet = workbook.addWorksheet(`Score ${sheetLabel}`);
 
   sheet.columns = [
     { key: 'no',           width: 5  },
@@ -220,7 +229,7 @@ async function writeExcel(rows, outputPath) {
   };
 
   // Title row
-  sheet.addRow(['AI Flow Kit — Weekly Score Report: 18/05/2026 – 24/05/2026']);
+  sheet.addRow([`AI Flow Kit — Weekly Score Report: ${fromLabel} – ${toLabel}`]);
   sheet.mergeCells('A1:N1');
   const title = sheet.getCell('A1');
   title.font      = { bold: true, size: 13, color: { argb: 'FF1F3864' } };
@@ -296,7 +305,7 @@ const CANONICAL_USERS = [
   'nguyenlt@relipasoft.com',
   'thuongvv@relipasoft.com',
   'yenvtb@relipasoft.com',
-  'tructth@relipasoft.com',
+  'tructh@relipasoft.com',
   'thainq@relipasoft.com',
   'tuoittx@relipasoft.com',
   'hungdv@relipasoft.com',
@@ -315,6 +324,7 @@ const CANONICAL_USERS = [
 const LOG_EMAIL_ALIAS = {
   'tructh@relipasoft.com':   'tructth@relipasoft.com',
   'duongnt1@relipasoft.com': 'duongnt@relipasoft.com',
+  'anhtt2@relipasoft.com':   'anhtt@relipasoft.com',
 };
 
 const EMPTY_USER = (email) => ({
@@ -323,8 +333,21 @@ const EMPTY_USER = (email) => ({
 
 // ── Main ───────────────────────────────────────────────────────────────────
 (async () => {
-  const logFile    = path.join(__dirname, '..', 'tellog', 'log_18-05-2026_24-05-2026');
-  const outputFile = path.join(__dirname, '..', 'tellog', 'log_18-05-2026_24-05-2026_new.xlsx');
+  // Usage: node create-score-excel.js [log-file-stem]
+  // e.g.:  node create-score-excel.js log_08-06-2026_14-06-2026
+  const stem = process.argv[2] || 'log_18-05-2026_24-05-2026';
+
+  // Derive display dates from stem: log_DD-MM-YYYY_DD-MM-YYYY → DD/MM/YYYY – DD/MM/YYYY
+  const dateMatch = stem.match(/log_(\d{2}-\d{2}-\d{4})_(\d{2}-\d{2}-\d{4})/);
+  const [fromLabel, toLabel] = dateMatch
+    ? [dateMatch[1].replace(/-/g, '/'), dateMatch[2].replace(/-/g, '/')]
+    : ['?', '?'];
+  const sheetLabel = dateMatch
+    ? `${dateMatch[1].slice(0,5).replace(/-/g,'.')}-${dateMatch[2].slice(0,5).replace(/-/g,'.')}.${dateMatch[1].slice(6,10)}`
+    : stem;
+
+  const logFile    = path.join(__dirname, '..', 'tellog', stem);
+  const outputFile = path.join(__dirname, '..', 'tellog', `${stem}.xlsx`);
 
   const rawUsers = parseLog(logFile);
 
@@ -350,5 +373,5 @@ const EMPTY_USER = (email) => ({
     return buildRow(email, u);
   });
 
-  await writeExcel(rows, outputFile);
+  await writeExcel(rows, outputFile, sheetLabel, fromLabel, toLabel);
 })();

package/scripts/detect.js

@@ -64,6 +64,16 @@ class TaskDetector {
                 antiKeywords: ['code'],
                 icon: '📖',
                 description: 'Writing documentation'
+            },
+            'testing': {
+                keywords: [
+                    'test', 'testing', 'unit test', 'integration test', 'e2e',
+                    'qa', 'quality assurance', 'coverage', 'spec', 'assert',
+                    'mock', 'stub', 'test case', 'test suite', 'automated test'
+                ],
+                antiKeywords: [],
+                icon: '🧪',
+                description: 'Writing tests and QA'
             }
         };
     }

package/scripts/guide.js

@@ -181,6 +181,14 @@ function showCommands() {
                 ['aiflow detect "<description>"', '', 'Auto-detect task type'],
             ]
         },
+        {
+            group: 'QA Execute Flow',
+            items: [
+                ['aiflow execute <TICKET-ID>', '', 'Execute tests from ticket (taskType: execute)'],
+                ['aiflow execute <TC-FILE>', '', 'Execute tests from TC file path'],
+                ['aiflow execute', '', 'Execute tests — manual (AI asks for TC file)'],
+            ]
+        },
         {
             group: 'Task management',
             items: [
@@ -279,6 +287,7 @@ function showPromptGuide() {
         ['refactor',         'Improving code without changing behavior'],
         ['impact-analysis',  'Analyzing the impact of changes'],
         ['documentation',    'Writing docs, README, API reference'],
+        ['testing',          'Writing tests, test coverage, QA'],
     ];
 
     for (const [type, when] of types) {

package/scripts/init.js

@@ -285,6 +285,37 @@ async function verifySuperpowersSkills(versionDir) {
     }
 }
 
+/**
+ * Install Claude Code custom commands from shared workflow templates.
+ * Creates .claude/commands/<name>.md for each shared workflow template.
+ * Users can invoke these with /<name> in Claude Code.
+ */
+async function setupClaudeCommands(projectDir) {
+    const commandsDir = path.join(projectDir, '.claude', 'commands');
+    await fs.ensureDir(commandsDir);
+
+    const commands = [
+        {
+            src: path.join(PKG_DIR, 'custom', 'templates', 'shared', 'create-spec-workflow.md'),
+            dest: 'create-spec.md',
+            description: 'BA 4-Gate Spec Creation Workflow — converts raw requirements (Jira/Backlog/file) into complete UC Spec documents following the UCflow process: Gate 1 (analysis & Q&A), Gate 2 (Q&A loop until all Confirmed), Gate 3 (HTML/CSS prototype design), Gate 4 (full UC Spec). Reads BA sub-skills from .claude/skills/ba-skills/.',
+        },
+        {
+            src: path.join(PKG_DIR, 'custom', 'templates', 'shared', 'create-testcase-workflow.md'),
+            dest: 'create-testcase.md',
+            description: 'QA 4-Gate TestCase Creation Workflow — converts raw requirements (SRS/Backlog/Jira/Spec file) into a complete, execution-ready Test Case set following the QA Workflow standard: Gate 1 (requirement & risk analysis), Gate 2 (scenario building), Gate 3 (detailed test case design), Gate 4 (review & optimization). Reads QA sub-skills from .claude/skills/test-skills/.',
+        },
+    ];
+
+    for (const cmd of commands) {
+        if (!(await fs.pathExists(cmd.src))) continue;
+        const body = await fs.readFile(cmd.src, 'utf-8');
+        const content = `---\ndescription: ${cmd.description}\n---\n\n${body}`;
+        await fs.writeFile(path.join(commandsDir, cmd.dest), content);
+        console.log(chalk.green(`✓ Installed /${path.basename(cmd.dest, '.md')} command → .claude/commands/${cmd.dest}`));
+    }
+}
+
 
 async function generateSkillRegistry(projectDir) {
     const skillsDir = path.join(projectDir, '.claude', 'skills');
@@ -332,10 +363,24 @@ async function setupFramework(projectDir, framework, multi = false, selectedTool
     const frameworkContent = await fs.readFile(frameworkTemplatePath, 'utf-8');
     const workflowFile = resolveWorkflowFile(framework);
     const workflowPath = path.join(PKG_DIR, 'custom', 'templates', 'shared', workflowFile);
-    const workflowContent = (await fs.pathExists(workflowPath))
+    const gateWorkflowContent = (await fs.pathExists(workflowPath))
         ? await fs.readFile(workflowPath, 'utf-8')
         : '';
 
+    // Load BA spec creation workflow (appended to all instruction files)
+    const createSpecPath = path.join(PKG_DIR, 'custom', 'templates', 'shared', 'create-spec-workflow.md');
+    const createSpecContent = (await fs.pathExists(createSpecPath))
+        ? await fs.readFile(createSpecPath, 'utf-8')
+        : '';
+
+    // Load QA testcase creation workflow (appended to all instruction files)
+    const createTestcasePath = path.join(PKG_DIR, 'custom', 'templates', 'shared', 'create-testcase-workflow.md');
+    const createTestcaseContent = (await fs.pathExists(createTestcasePath))
+        ? await fs.readFile(createTestcasePath, 'utf-8')
+        : '';
+
+    const workflowContent = [gateWorkflowContent, createSpecContent, createTestcaseContent].filter(Boolean).join('\n\n---\n\n');
+
     const separator = `\n\n---\n\n`;
     const skillRegistry = await generateSkillRegistry(projectDir);
 
@@ -1047,6 +1092,7 @@ async function init(options) {
         await verifySuperpowersSkills(versionDir);
         await updateSymlinks(projectDir, versionDir);
         await copyDocsToProject(projectDir);
+        await setupClaudeCommands(projectDir);
 
         const selectedTools = options.aiTools || Object.keys(AI_TOOL_FILES);
         for (const fw of frameworks) {
@@ -1103,6 +1149,7 @@ module.exports.AI_TOOL_FILES = AI_TOOL_FILES;
 module.exports.detectRtk = detectRtk;
 module.exports.isRtkHookConfigured = isRtkHookConfigured;
 module.exports.isGitNexusConfigured = isGitNexusConfigured;
+module.exports.setupClaudeCommands = setupClaudeCommands;
 module.exports.setupFramework = setupFramework;
 module.exports.ensureAiflowGitignored = ensureAiflowGitignored;
 module.exports.resolveWorkflowFile = resolveWorkflowFile;

package/scripts/prompt.js

@@ -215,6 +215,42 @@ AI must:
 5. Display "GATE 1: Impact report complete" → wait for **APPROVED**
 
 **Do NOT make any code changes.** Implementation needs a separate ticket.
+`,
+    },
+    'testing': {
+        header: 'Testing',
+        instruction: 'Write tests for the feature or scenario described below.',
+        skillWorkflow: `
+## STRICT GATE WORKFLOW — Testing
+
+### GATE 1 — AI Analyze Requirement
+**INVOKE:** \`read-study-requirement\` skill
+AI must:
+1. Load ticket context + read source code thoroughly
+2. Understand what needs to be tested (unit, integration, e2e)
+3. If unclear → ask ONE question at a time
+4. Output \`plan/[ticket-id]/requirement.md\` with:
+   - Test scope and strategy
+   - Test cases to cover (happy path + edge cases + failure cases)
+   - Source code references
+   - Effort estimate
+5. Display "GATE 1: Test plan ready" → wait for **APPROVED**
+
+### GATE 2 — Implementation Plan
+**INVOKE:** \`generate-spec\` skill, then \`superpowers:writing-plans\`
+- Create detailed TDD test implementation plan.
+- Output \`plan/[ticket-id]/plan.md\`.
+- Display: "GATE 2 PAUSED: type APPROVED to start coding".
+
+### GATE 3 — Write Tests (TDD)
+Only runs after Gate 2 APPROVED.
+**INVOKE:** \`superpowers:test-driven-development\`
+- Write failing tests first → confirm FAIL → implement → confirm PASS.
+
+### GATE 4 — AI Self-Review (wait for APPROVED)
+**INVOKE:** \`superpowers:verification-before-completion\`
+All tests must PASS. Check coverage meets requirements.
+Display: "GATE 4 PAUSED: type APPROVED or BUG: [description]"
 `,
     },
     'documentation': {

package/scripts/review.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+
+const REVIEW_DIR = '.aiflow/review';
+
+function reviewFilePath(gate, ticketId) {
+    return path.join(process.cwd(), REVIEW_DIR, `gate-${gate}-${ticketId}.md`);
+}
+
+/**
+ * Parse a gate review file and return checkbox state.
+ *
+ * @param {number} gate
+ * @param {string} ticketId
+ * @returns {Promise<{exists: boolean, passed?: boolean, total?: number, unchecked?: string[], commented?: Array<{item: string, comment: string}>}>}
+ */
+async function checkReviewFile(gate, ticketId) {
+    const filePath = reviewFilePath(gate, ticketId);
+
+    if (!(await fs.pathExists(filePath))) {
+        return { exists: false };
+    }
+
+    const content = await fs.readFile(filePath, 'utf-8');
+    const lines = content.split('\n');
+
+    const unchecked = [];
+    const commented = [];
+    let total = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const checkboxMatch = line.match(/^- \[([ xX])\] (.+)/);
+        if (!checkboxMatch) continue;
+
+        total++;
+        const isChecked = checkboxMatch[1].toLowerCase() === 'x';
+        const itemText = checkboxMatch[2].trim();
+
+        if (!isChecked) {
+            let comment = null;
+            let commentBuffer = '';
+            let inComment = false;
+            for (let j = i + 1; j < lines.length; j++) {
+                const nextLine = lines[j].trim();
+                if (!inComment && nextLine.match(/^- \[/)) break;
+                if (!inComment && nextLine === '---') break;
+                if (!inComment) {
+                    const singleLineMatch = nextLine.match(/<!--([\s\S]+?)-->/);
+                    if (singleLineMatch) {
+                        comment = singleLineMatch[1].trim();
+                        break;
+                    }
+                    if (nextLine.includes('<!--')) {
+                        inComment = true;
+                        commentBuffer = nextLine.replace(/^.*<!--/, '');
+                        if (commentBuffer.includes('-->')) {
+                            comment = commentBuffer.replace(/-->.*$/, '').trim();
+                            break;
+                        }
+                        continue;
+                    }
+                } else {
+                    if (nextLine.includes('-->')) {
+                        commentBuffer += ' ' + nextLine.replace(/-->.*$/, '');
+                        comment = commentBuffer.trim();
+                        break;
+                    }
+                    commentBuffer += ' ' + nextLine;
+                }
+            }
+            if (comment) {
+                commented.push({ item: itemText, comment });
+            } else {
+                unchecked.push(itemText);
+            }
+        }
+    }
+
+    return {
+        exists: true,
+        passed: unchecked.length === 0 && commented.length === 0,
+        total,
+        unchecked,
+        commented,
+    };
+}
+
+module.exports = { checkReviewFile, reviewFilePath };

package/scripts/scaffold-playwright.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+const PKG_DIR = path.join(__dirname, '..');
+const HARNESS_SRC = path.join(PKG_DIR, 'custom', 'harness', 'playwright');
+
+const HARNESS_FILES = [
+  'playwright.config.ts',
+  '.env.example',
+  'tests/e2e/pages/BasePage.ts',
+  'tests/e2e/fixtures/test.ts',
+  'tests/e2e/auth.setup.ts',
+  'tests/e2e/support/auth.ts',
+];
+
+const GITIGNORE_LINES = [
+  '# Playwright',
+  'playwright-report/',
+  'test-results/',
+  'tests/e2e/.auth/',
+  '.env',
+];
+
+const MCP_CONFIG = {
+  playwright: {
+    command: 'npx',
+    args: ['-y', '@playwright/mcp@latest', '--isolated', '--browser', 'chromium', '--headless'],
+  },
+};
+
+/**
+ * Scaffold Playwright E2E harness into a target project directory.
+ * @param {string} [targetDir]  Destination directory (defaults to process.cwd())
+ * @param {{ force?: boolean, silent?: boolean }} [opts]
+ * @returns {Promise<{ copied: string[], skipped: string[], mcpUpdated: boolean }>}
+ */
+async function scaffoldPlaywright(targetDir, opts) {
+  if (targetDir === undefined) targetDir = process.cwd();
+  var force = opts && opts.force ? true : false;
+  var silent = opts && opts.silent ? true : false;
+  var log = silent ? function () {} : console.log;
+
+  var result = { copied: [], skipped: [], mcpUpdated: false };
+
+  // ── Harness files ─────────────────────────────────────────────
+  for (var i = 0; i < HARNESS_FILES.length; i++) {
+    var relPath = HARNESS_FILES[i];
+    var src = path.join(HARNESS_SRC, relPath);
+    var dest = path.join(targetDir, relPath);
+    var exists = await fs.pathExists(dest);
+
+    if (!force && exists) {
+      log(chalk.gray('  ↷ Skipped (already exists): ' + relPath));
+      result.skipped.push(relPath);
+      continue;
+    }
+
+    await fs.ensureDir(path.dirname(dest));
+    await fs.copy(src, dest, { overwrite: true });
+    log(chalk.green('  ✓ ' + (exists ? 'Overwrote' : 'Created') + ': ' + relPath));
+    result.copied.push(relPath);
+  }
+
+  // ── .mcp.json ─────────────────────────────────────────────────
+  var mcpFile = path.join(targetDir, '.mcp.json');
+  var mcpConfig = { mcpServers: {} };
+  if (await fs.pathExists(mcpFile)) {
+    mcpConfig = await fs.readJson(mcpFile).catch(function () { return { mcpServers: {} }; });
+  }
+  if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+
+  if (!force && mcpConfig.mcpServers.playwright) {
+    log(chalk.gray('  ↷ Skipped .mcp.json playwright entry (already exists)'));
+  } else {
+    mcpConfig.mcpServers.playwright = MCP_CONFIG.playwright;
+    await fs.writeJson(mcpFile, mcpConfig, { spaces: 2 });
+    log(chalk.green('  ✓ Updated .mcp.json with playwright MCP server'));
+    result.mcpUpdated = true;
+  }
+
+  // ── .gitignore ────────────────────────────────────────────────
+  var gitignoreFile = path.join(targetDir, '.gitignore');
+  var gitignoreContent = '';
+  if (await fs.pathExists(gitignoreFile)) {
+    gitignoreContent = await fs.readFile(gitignoreFile, 'utf-8');
+  }
+  var missingLines = GITIGNORE_LINES.filter(function (line) {
+    return !gitignoreContent.includes(line);
+  });
+  if (missingLines.length > 0) {
+    var addition = '\n' + missingLines.join('\n') + '\n';
+    await fs.appendFile(gitignoreFile, addition);
+    log(chalk.green('  ✓ Updated .gitignore'));
+  }
+
+  return result;
+}
+
+module.exports = {
+  scaffoldPlaywright: scaffoldPlaywright,
+  HARNESS_FILES: HARNESS_FILES,
+  MCP_CONFIG: MCP_CONFIG,
+};

package/scripts/task.js

@@ -189,7 +189,7 @@ async function resumeTask(taskId) {
     await fs.writeJson(statePath, taskState, { spaces: 2 });
 
     console.log(chalk.green(`✓ Resumed task: ${taskId}`));
-    console.log(`  ${chalk.white('Gate:')}   ${taskState.currentGate} (${gateLabel(taskState.currentGate)})`);
+    console.log(`  ${chalk.white('Gate:')}   ${taskState.currentGate} (${gateLabel(taskState.currentGate, taskState.taskType)})`);
     console.log(`  ${chalk.white('Title:')}  ${ctx.title.substring(0, 70)}`);
     if (taskState.notes) console.log(`  ${chalk.white('Note:')}   ${taskState.notes}`);
     console.log(chalk.gray('\n  Open Claude to resume: claude'));
@@ -355,10 +355,11 @@ async function nextGate(taskId) {
     const summaryContent = await generateMarkdownSummary(taskState);
     await fs.writeFile(summaryPath, summaryContent, 'utf-8');
 
-    const gateLabels = { 1: 'Analyze', 2: 'Plan', 3: 'Code', 4: 'Review', 5: 'PR' };
+    const taskType = existing.taskType || 'feature';
     console.log(chalk.green(`✓ Gate ${currentGate} approved for ${resolvedId}.`));
     console.log(chalk.gray(`  Summary saved to: plan/${resolvedId}/task-summary.md`));
-    console.log(chalk.white(`\n  Next: Gate ${nextGateNum} — ${gateLabels[nextGateNum] || 'Done'}`));
+    const nextLabel = gateLabel(nextGateNum, taskType);
+    console.log(chalk.white(`\n  Next: Gate ${nextGateNum} — ${nextLabel}`));
     console.log(chalk.cyan(`\n  To continue in a fresh session (Recommended to avoid context pollution):`));
     console.log(chalk.gray(`    1. Open a NEW chatbox or terminal session.`));
     console.log(chalk.gray(`    2. Run: aiflow task resume ${resolvedId} (to load context).`));
@@ -418,21 +419,24 @@ async function detectCurrentGate(taskId) {
 }
 
 async function generateMarkdownSummary(taskState) {
+    const taskType = taskState.taskType || 'feature';
+    const maxGate  = taskType === 'testing' ? 4 : 5;
     const lines = [];
     lines.push(`# Task Summary: ${taskState.taskId}`);
     lines.push(`**Title:** ${taskState.title}`);
+    lines.push(`**Type:** ${taskType}`);
     lines.push(`**Status:** ${taskState.status}`);
-    lines.push(`**Current Gate:** ${taskState.currentGate} (${gateLabel(taskState.currentGate)})`);
+    lines.push(`**Current Gate:** ${taskState.currentGate} (${gateLabel(taskState.currentGate, taskType)})`);
     lines.push(`**Updated At:** ${new Date().toLocaleString()}`);
     lines.push(``);
     lines.push(`## Gate History`);
     lines.push(`| Gate | Status | Approved At |`);
     lines.push(`|------|--------|-------------|`);
-    for (let i = 1; i <= 5; i++) {
+    for (let i = 1; i <= maxGate; i++) {
         const approvedAt = taskState.gateApprovals && taskState.gateApprovals[String(i)];
         const status = approvedAt ? '✅ Approved' : (i === taskState.currentGate ? '⏳ In Progress' : '⚪ Pending');
         const timeStr = approvedAt ? new Date(approvedAt).toLocaleString() : '-';
-        lines.push(`| Gate ${i} (${gateLabel(i)}) | ${status} | ${timeStr} |`);
+        lines.push(`| Gate ${i} (${gateLabel(i, taskType)}) | ${status} | ${timeStr} |`);
     }
     lines.push(``);
     lines.push(`---`);
@@ -440,7 +444,16 @@ async function generateMarkdownSummary(taskState) {
     return lines.join('\n');
 }
 
-function gateLabel(n) {
+function gateLabel(n, taskType) {
+    if (taskType === 'testing') {
+        const labels = {
+            1: 'Phân tích & Confirm',
+            2: 'Lập kế hoạch Test',
+            3: 'Thực thi & Evidence',
+            4: 'Báo cáo & Sign-off',
+        };
+        return labels[n] || `Gate ${n}`;
+    }
     const labels = {
         1: 'AI Analyze Requirement',
         2: 'Implementation Plan',
@@ -494,6 +507,7 @@ module.exports.createOrActivateTaskState = async function createOrActivateTaskSt
         ...existing,
         taskId,
         title:         ctx.title || '',
+        taskType:      ctx.taskType || existing.taskType || 'feature',
         status:        'active',
         createdAt:     existing.createdAt || now,
         updatedAt:     now,