sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/langgraph/nodes/devops-node.ts

@@ -0,0 +1,180 @@
+/**
+ * DevOpsNode — KSA-210, KSA-242
+ * DevOps agent node. Handles deployment guide creation (DPG/RLN),
+ * deployment execution, and release process.
+ * KSA-242: Added template refs, steering injection, KB ingest, diagram requirements.
+ */
+
+import { BaseNode } from "./base-node";
+import { PipelineState, AgentOutput, DocumentState } from "../state";
+import { loadSteeringRules, injectSteering } from "../steering-loader";
+
+/** Template paths for DevOps documents */
+const DEVOPS_TEMPLATES = {
+  DPG: "documents/templates/DPG-TEMPLATE.md",
+  RLN: "documents/templates/RLN-TEMPLATE.md",
+} as const;
+
+const DEVOPS_SYSTEM_PROMPT_FALLBACK = `You are a DevOps Engineer agent for an SDLC pipeline.
+Your responsibilities:
+
+DEPLOYMENT PLANNING:
+- Create DPG (Deployment Guide) with step-by-step deployment instructions
+- Create RLN (Release Notes) summarizing changes
+- Define rollback procedures
+- Specify pre/post-deployment checks
+- Follow the provided template structures EXACTLY
+
+DEPLOYMENT EXECUTION:
+- Execute deployment according to DPG steps
+- Run sanity tests after deployment
+- Handle rollback if sanity fails
+
+RELEASE PROCESS:
+- Merge branch to master (--no-ff)
+- Create version tag (semver)
+- Update changelog in README
+
+DIAGRAM RULES (MANDATORY):
+- MUST create draw.io diagrams: deployment-flow.drawio + rollback-flow.drawio
+- All diagrams stored at documents/{TICKET}/diagrams/
+- Each diagram has both .drawio (source) and .png (rendered)
+- XML must start with <mxGraphModel>, NOT <mxfile>
+- Include Diagram Index table in appendix
+
+Always include rollback plans and health check verification.`;
+
+export class DevOpsNode extends BaseNode {
+  async execute(state: PipelineState): Promise<Partial<PipelineState>> {
+    this.streamHandler.emitToken(
+      this.nodeId,
+      `[DevOps] Preparing deployment for ${state.ticketKey}...`,
+      state.currentStreamId
+    );
+
+    const llmAvailable = await this.isLlmAvailable();
+    let result: string;
+
+    if (llmAvailable) {
+      // Step 0: Scan existing infrastructure (matches Kiro devops-agent Step 1)
+      this.streamHandler.emitToken(this.nodeId, `  → Step 0: Scanning existing infrastructure...`, state.currentStreamId);
+      const dockerfileContent = await this.readWorkspaceFile("Dockerfile") || "";
+      const dockerComposeContent = await this.readWorkspaceFile("docker-compose.yml") || "";
+      const ciContent = await this.readWorkspaceFile(".github/workflows/ci.yml")
+        || await this.readWorkspaceFile(".gitlab-ci.yml")
+        || await this.readWorkspaceFile("Jenkinsfile")
+        || "";
+
+      const infraContext = [
+        dockerfileContent ? `## Dockerfile\n\n${dockerfileContent.slice(0, 3000)}` : "",
+        dockerComposeContent ? `## docker-compose.yml\n\n${dockerComposeContent.slice(0, 3000)}` : "",
+        ciContent ? `## CI/CD Config\n\n${ciContent.slice(0, 3000)}` : "",
+      ].filter(Boolean).join("\n\n");
+
+      // Step 1: Read templates
+      this.streamHandler.emitToken(this.nodeId, `  → Step 1: Reading templates...`, state.currentStreamId);
+      const dpgTemplate = await this.readWorkspaceFile(DEVOPS_TEMPLATES.DPG) || "[DPG template not found]";
+      const rlnTemplate = await this.readWorkspaceFile(DEVOPS_TEMPLATES.RLN) || "[RLN template not found]";
+
+      // Step 2: Read TDD/FSD from KB
+      let kbContext = "";
+      try { kbContext = await this.kbSearch(`${state.ticketKey} TDD deployment architecture environment`); } catch { /* */ }
+
+      const userPrompt = `Create Deployment Guide and Release Notes for ${state.ticketKey}.
+
+## DPG TEMPLATE\n\n${dpgTemplate}
+
+## RLN TEMPLATE\n\n${rlnTemplate}
+
+${infraContext ? `## EXISTING INFRASTRUCTURE\n\n${infraContext}` : ""}
+
+TDD: ${state.documents.tdd?.path || "documents/" + state.ticketKey + "/TDD.md"}
+FSD: ${state.documents.fsd?.path || "documents/" + state.ticketKey + "/FSD.md"}
+
+${kbContext ? `## KB CONTEXT\n\n${kbContext}` : ""}
+
+Generate:
+1. DPG.md — Deployment Guide:
+   - Pre-deployment checklist
+   - Step-by-step deployment instructions
+   - Post-deployment verification
+   - Rollback plan with steps
+   - Deployment architecture diagram description
+
+2. RLN.md — Release Notes:
+   - Version number
+   - Changes summary (features, fixes, improvements)
+   - Breaking changes (if any)
+   - Migration instructions (if any)
+   - Known issues
+
+DIAGRAMS (MANDATORY):
+- Create documents/${state.ticketKey}/diagrams/deployment-flow.drawio + .png
+- Create documents/${state.ticketKey}/diagrams/rollback-flow.drawio + .png
+- Include Diagram Index table in appendix`;
+
+      // KSA-242: Inject steering rules
+      const workspaceRoot = require("vscode").workspace.workspaceFolders?.[0]?.uri.fsPath;
+      let systemPrompt = await this.loadAgentPrompt("devops-agent", DEVOPS_SYSTEM_PROMPT_FALLBACK);
+      if (workspaceRoot) {
+        const rules = await loadSteeringRules(workspaceRoot, "langgraph");
+        systemPrompt = injectSteering(systemPrompt, rules);
+      }
+      result = await this.callLlmStreamFull(systemPrompt, userPrompt, state);
+    } else {
+      result = await this.callMcp("invoke_sub_agent", {
+        name: "devops-agent",
+        prompt: `Tao Deployment Guide va Release Notes cho ${state.ticketKey}. PHAI tao draw.io diagrams (deployment-flow.drawio + rollback-flow.drawio) va export PNG. Templates: ${DEVOPS_TEMPLATES.DPG}, ${DEVOPS_TEMPLATES.RLN}`,
+      });
+    }
+
+    // KSA-242: Ingest documents into KB
+    try {
+      await this.callMcp("mem_ingest", {
+        content: result,
+        type: "DOCUMENT",
+        source: "langgraph-devops-dpg-rln",
+        tags: [state.ticketKey, "DPG", "RLN", "devops-agent", "langgraph"],
+        scope: "USER",
+      });
+    } catch {
+      // KB ingest failure is non-blocking
+    }
+
+    const output: AgentOutput = {
+      nodeId: this.nodeId,
+      content: result,
+      timestamp: new Date().toISOString(),
+      metadata: { phase: "deployment", action: "create_dpg_rln", usedLlm: llmAvailable, kbIngested: true },
+    };
+
+    const documents = { ...state.documents };
+    documents.dpg = {
+      status: "done",
+      version: (documents.dpg?.version || 0) + 1,
+      path: `documents/${state.ticketKey}/DPG.md`,
+      completedAt: new Date().toISOString(),
+    } satisfies DocumentState;
+    documents.rln = {
+      status: "done",
+      version: (documents.rln?.version || 0) + 1,
+      path: `documents/${state.ticketKey}/RLN.md`,
+      completedAt: new Date().toISOString(),
+    } satisfies DocumentState;
+
+    // Auto-promote all ticket-related USER entries to PROJECT on deploy/release
+    try {
+      await this.callMcp("mem_promote", {
+        action: "promote_on_merge",
+        ticket_key: state.ticketKey,
+      });
+    } catch {
+      // Non-blocking — promotion failure shouldn't block deployment
+    }
+
+    return {
+      agentOutputs: [output],
+      documents,
+    };
+  }
+}

package/extension/src/langgraph/nodes/feedback-node.ts

@@ -0,0 +1,68 @@
+/**
+ * FeedbackNode — KSA-210
+ * BA <-> SA feedback loop controller.
+ * Checks for discrepancies between FSD and TDD, triggers BA fix if needed.
+ * Max 5 iterations before escalating to user.
+ */
+
+import { BaseNode } from "./base-node";
+import { PipelineState, AgentOutput } from "../state";
+
+export class FeedbackNode extends BaseNode {
+  async execute(state: PipelineState): Promise<Partial<PipelineState>> {
+    const iteration = state.feedbackIterations;
+    const maxIterations = state.maxFeedbackIterations;
+
+    this.streamHandler.emitToken(
+      this.nodeId,
+      `[Feedback] Checking discrepancy — iteration ${iteration + 1}/${maxIterations}`,
+      state.currentStreamId
+    );
+
+    // Check if discrepancy was found by SA
+    if (!state.discrepancyFound) {
+      // No discrepancy — proceed to quality gate
+      const output: AgentOutput = {
+        nodeId: this.nodeId,
+        content: `No discrepancy found. FSD and TDD are consistent.`,
+        timestamp: new Date().toISOString(),
+        metadata: { action: "feedback_check", discrepancy: false, iteration },
+      };
+
+      return {
+        agentOutputs: [output],
+        feedbackIterations: iteration,
+      };
+    }
+
+    // Discrepancy found — check iteration limit
+    if (iteration >= maxIterations) {
+      const output: AgentOutput = {
+        nodeId: this.nodeId,
+        content: `Max feedback iterations (${maxIterations}) reached. Escalating to user.`,
+        timestamp: new Date().toISOString(),
+        metadata: { action: "feedback_escalate", iteration },
+      };
+
+      return {
+        agentOutputs: [output],
+        pipelineStatus: "paused",
+        discrepancyFound: false, // Reset to break loop
+        feedbackIterations: iteration,
+      };
+    }
+
+    // Discrepancy exists and within limit — trigger BA fix
+    const output: AgentOutput = {
+      nodeId: this.nodeId,
+      content: `Discrepancy detected (iteration ${iteration + 1}). Routing to BA for FSD fix.`,
+      timestamp: new Date().toISOString(),
+      metadata: { action: "feedback_loop", iteration: iteration + 1 },
+    };
+
+    return {
+      agentOutputs: [output],
+      feedbackIterations: iteration + 1,
+    };
+  }
+}

package/extension/src/langgraph/nodes/hook-helpers.ts

@@ -0,0 +1,122 @@
+/**
+ * Hook Helpers — extracted from BaseNode (KSA-242)
+ * Dynamic hook execution for pipeline nodes: agentStop, preToolUse, file hooks.
+ */
+
+import { debugError } from "../../debug-logger";
+import type { McpBridge } from "../mcp-bridge";
+import type { PipelineState } from "../state";
+import {
+  loadHooks, filterHooksByType, filterPreToolUseHooks, filterFileHooks,
+  type HookDefinition,
+} from "../hook-loader";
+import { getWorkspaceRoot } from "./workspace-file-ops";
+
+const TOOL_CALL_TIMEOUT_MS = 60_000;
+
+async function getHooks(): Promise<HookDefinition[]> {
+  const workspaceRoot = getWorkspaceRoot();
+  if (!workspaceRoot) return [];
+  return loadHooks(workspaceRoot);
+}
+
+export async function fireAgentStopHooks(
+  nodeId: string, state: PipelineState, output: string, mcpBridge: McpBridge
+): Promise<void> {
+  try {
+    const hooks = await getHooks();
+    const matching = filterHooksByType(hooks, "agentStop");
+    for (const hook of matching) {
+      await executeHookAction(hook, state, output, nodeId, mcpBridge);
+    }
+  } catch (err) {
+    debugError(`[HookHelpers] agentStop hook failed for ${nodeId}`, err as Error);
+  }
+}
+
+export async function firePreToolUseHooks(toolCategory: string): Promise<string[]> {
+  try {
+    const hooks = await getHooks();
+    const matching = filterPreToolUseHooks(hooks, toolCategory);
+    return matching
+      .filter(h => h.then.type === "askAgent" && h.then.prompt)
+      .map(h => h.then.prompt!);
+  } catch (err) {
+    debugError(`[HookHelpers] preToolUse hook failed for ${toolCategory}`, err as Error);
+    return [];
+  }
+}
+
+export async function fireFileHooks(
+  eventType: "fileEdited" | "fileCreated",
+  filePath: string,
+  state: PipelineState,
+  nodeId: string,
+  mcpBridge: McpBridge
+): Promise<void> {
+  try {
+    const hooks = await getHooks();
+    const matching = filterFileHooks(hooks, eventType, filePath);
+    for (const hook of matching) {
+      await executeHookAction(hook, state, "", nodeId, mcpBridge, filePath);
+    }
+  } catch (err) {
+    debugError(`[HookHelpers] file hook failed for ${eventType} on ${filePath}`, err as Error);
+  }
+}
+
+async function executeHookAction(
+  hook: HookDefinition,
+  state: PipelineState,
+  contextContent: string,
+  nodeId: string,
+  mcpBridge: McpBridge,
+  filePath?: string
+): Promise<void> {
+  try {
+    if (hook.then.type === "runCommand" && hook.then.command) {
+      const command = filePath
+        ? hook.then.command.replace("${file}", filePath)
+        : hook.then.command;
+      await execShell(command);
+    } else if (hook.then.type === "askAgent" && hook.then.prompt) {
+      if (hook.then.prompt.includes("mem_ingest")) {
+        const summary = contextContent.slice(0, 150);
+        await mcpBridge.callTool("mem_ingest", {
+          content: summary, type: "CONTEXT",
+          source: `hook-${hook.name.toLowerCase().replace(/\s+/g, "-")}`,
+          tags: ["hook", nodeId, state.ticketKey],
+          scope: "USER",
+        }, TOOL_CALL_TIMEOUT_MS);
+      } else if (hook.then.prompt.includes("mem_search") && hook.then.prompt.includes("drawio")) {
+        await mcpBridge.callTool("mem_search", {
+          query: "drawio procedure styles edges containers", limit: 10,
+        }, TOOL_CALL_TIMEOUT_MS);
+      }
+    }
+  } catch (err) {
+    debugError(`[HookHelpers] hook action failed for ${hook.name}`, err as Error);
+  }
+}
+
+export async function execShell(command: string, cwd?: string): Promise<string> {
+  const { exec } = require("child_process");
+  const workspaceRoot = getWorkspaceRoot();
+  const execCwd = cwd || workspaceRoot || process.cwd();
+
+  return new Promise<string>((resolve, reject) => {
+    const child = exec(
+      command,
+      { cwd: execCwd, maxBuffer: 10 * 1024 * 1024, timeout: TOOL_CALL_TIMEOUT_MS },
+      (error: Error | null, stdout: string, stderr: string) => {
+        if (error) reject(new Error(`Shell failed: ${command}\n${stderr || error.message}`));
+        else resolve(stdout.trim());
+      }
+    );
+    child.unref?.();
+  });
+}
+
+export async function execGit(args: string): Promise<string> {
+  return execShell(`git ${args}`);
+}

package/extension/src/langgraph/nodes/jira-helpers.ts

@@ -0,0 +1,86 @@
+/**
+ * Jira Helpers — extracted from BaseNode (KSA-242)
+ * Provides Jira issue fetching and recursive link traversal for pipeline nodes.
+ */
+
+import { debugError } from "../../debug-logger";
+import type { McpBridge } from "../mcp-bridge";
+
+/** Per-tool call timeout (60s) */
+const TOOL_CALL_TIMEOUT_MS = 60_000;
+
+export async function callDynamicTool(
+  toolName: string, args: Record<string, unknown>, mcpBridge: McpBridge
+): Promise<string> {
+  return mcpBridge.callTool("execute_dynamic_tool", {
+    tool_name: toolName, arguments: args,
+  }, TOOL_CALL_TIMEOUT_MS);
+}
+
+export async function getJiraIssue(issueKey: string, mcpBridge: McpBridge): Promise<string> {
+  return callDynamicTool("jira_get_issue", {
+    issue_key: issueKey, fields: "*all", expand: "renderedFields",
+  }, mcpBridge);
+}
+
+export async function getJiraIssueFields(
+  issueKey: string, fields: string, mcpBridge: McpBridge
+): Promise<string> {
+  return callDynamicTool("jira_get_issue", { issue_key: issueKey, fields }, mcpBridge);
+}
+
+export async function searchJira(jql: string, mcpBridge: McpBridge): Promise<string> {
+  return callDynamicTool("jira_search", { jql }, mcpBridge);
+}
+
+export async function getJiraIssueRecursive(
+  issueKey: string, mcpBridge: McpBridge, maxDepth = 2, maxTickets = 10
+): Promise<string> {
+  const visited = new Set<string>();
+  const results: string[] = [];
+  await traverseJiraLinks(issueKey, 0, maxDepth, maxTickets, visited, results, mcpBridge);
+  return results.join("\n\n---\n\n");
+}
+
+async function traverseJiraLinks(
+  issueKey: string,
+  currentDepth: number,
+  maxDepth: number,
+  maxTickets: number,
+  visited: Set<string>,
+  results: string[],
+  mcpBridge: McpBridge
+): Promise<void> {
+  if (visited.has(issueKey)) return;
+  if (visited.size >= maxTickets) return;
+  if (currentDepth > maxDepth) return;
+
+  visited.add(issueKey);
+
+  try {
+    const issueData = await getJiraIssue(issueKey, mcpBridge);
+    const prefix = currentDepth === 0 ? "## MAIN TICKET" : `## LINKED (depth ${currentDepth})`;
+    results.push(`${prefix}: ${issueKey}\n\n${issueData}`);
+
+    const linkedKeys = extractLinkedKeys(issueData, issueKey);
+    for (const linkedKey of linkedKeys) {
+      if (visited.size >= maxTickets) break;
+      await traverseJiraLinks(linkedKey, currentDepth + 1, maxDepth, maxTickets, visited, results, mcpBridge);
+    }
+  } catch (err) {
+    debugError(`[JiraHelpers] traversal failed for ${issueKey}`, err as Error);
+    results.push(`## ${issueKey} — [fetch failed]`);
+  }
+}
+
+function extractLinkedKeys(issueData: string, selfKey: string): string[] {
+  const keys: string[] = [];
+  const keyPattern = /\b([A-Z][A-Z0-9]{1,9}-\d+)\b/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = keyPattern.exec(issueData)) !== null) {
+    const key = match[1];
+    if (key !== selfKey && !keys.includes(key)) keys.push(key);
+  }
+  return keys.slice(0, 8);
+}

package/extension/src/langgraph/nodes/qa-node.ts

@@ -0,0 +1,82 @@
+/**
+ * QaNode --- KSA-210, KSA-242
+ * QA Engineer agent node. Handles test planning (STP/STC) and test execution.
+ */
+
+import { BaseNode } from "./base-node";
+import { PipelineState, AgentOutput, DocumentState } from "../state";
+import { loadSteeringRules, injectSteering } from "../steering-loader";
+import { QA_TEMPLATES, QA_SYSTEM_PROMPT_FALLBACK } from "./qa-prompts";
+
+export class QaNode extends BaseNode {
+  async execute(state: PipelineState): Promise<Partial<PipelineState>> {
+    if (state.currentPhase === "test_planning") return this.executeTestPlanning(state);
+    if (state.currentPhase === "testing") return this.executeTestExecution(state);
+    if (state.currentPhase === "user_guide") return this.executeUgVerification(state);
+    return this.executeTestPlanning(state);
+  }
+
+  private async executeTestPlanning(state: PipelineState): Promise<Partial<PipelineState>> {
+    this.streamHandler.emitToken(this.nodeId, `[QA] Creating STP/STC for ${state.ticketKey}...`, state.currentStreamId);
+    const llmAvailable = await this.isLlmAvailable();
+    let result: string;
+    if (llmAvailable) {
+      this.streamHandler.emitToken(this.nodeId, `  -> Step 1: Reading context...`, state.currentStreamId);
+      let kbContext = "";
+      try { kbContext = await this.kbSearch(`${state.ticketKey} BRD FSD TDD requirements`); } catch { /* */ }
+      const brdContent = await this.readWorkspaceFile(state.documents.brd?.path || `documents/${state.ticketKey}/BRD.md`) || "";
+      const fsdContent = await this.readWorkspaceFile(state.documents.fsd?.path || `documents/${state.ticketKey}/FSD.md`) || "";
+      const tddContent = await this.readWorkspaceFile(state.documents.tdd?.path || `documents/${state.ticketKey}/TDD.md`) || "";
+      this.streamHandler.emitToken(this.nodeId, `  -> Step 2: Reading templates...`, state.currentStreamId);
+      const stpTemplate = await this.readWorkspaceFile(QA_TEMPLATES.STP) || "[STP template not found]";
+      const stcTemplate = await this.readWorkspaceFile(QA_TEMPLATES.STC) || "[STC template not found]";
+      this.streamHandler.emitToken(this.nodeId, `  -> Step 3: Generating STP/STC...`, state.currentStreamId);
+      const userPrompt = `Create STP and STC for ticket ${state.ticketKey}.\n\n## STP TEMPLATE\n\n${stpTemplate}\n\n## STC TEMPLATE\n\n${stcTemplate}\n\n## BRD\n\n${brdContent.slice(0, 10000)}\n\n## FSD\n\n${fsdContent.slice(0, 10000)}\n\n## TDD\n\n${tddContent.slice(0, 10000)}\n\n${kbContext ? `## KB CONTEXT\n\n${kbContext}` : ""}\n\nRequirements:\n- 6 test levels: PBT, UT, IT, E2E-API, E2E-UI, SIT\n- RTM with 100% coverage\n- Test data CSV files\n\nDIAGRAMS (MANDATORY):\n- documents/${state.ticketKey}/diagrams/test-coverage.drawio + .png\n- documents/${state.ticketKey}/diagrams/test-execution-flow.drawio + .png`;
+      const workspaceRoot = this.getWorkspaceRoot();
+      let systemPrompt = await this.loadAgentPrompt("qa-agent", QA_SYSTEM_PROMPT_FALLBACK);
+      if (workspaceRoot) { const rules = await loadSteeringRules(workspaceRoot, "langgraph"); systemPrompt = injectSteering(systemPrompt, rules); }
+      result = await this.callLlmStreamFull(systemPrompt, userPrompt, state);
+      this.streamHandler.emitToken(this.nodeId, `  -> Step 4: Writing STP.md + STC.md...`, state.currentStreamId);
+      await this.writeWorkspaceFile(`documents/${state.ticketKey}/STP.md`, result);
+      this.streamHandler.emitToken(this.nodeId, `  -> Step 5: Exporting DOCX...`, state.currentStreamId);
+      const ver = (state.documents.stp?.version || 0) + 1;
+      await this.exportDocx(`documents/${state.ticketKey}/STP.md`, `STP-v${ver}-${state.ticketKey}`);
+      this.streamHandler.emitToken(this.nodeId, `  -> Step 6: KB ingest...`, state.currentStreamId);
+      await this.kbIngestFile(`documents/${state.ticketKey}/STP.md`, "DOCUMENT");
+      this.streamHandler.emitToken(this.nodeId, `  Done STP/STC pipeline`, state.currentStreamId);
+    } else {
+      result = await this.callMcp("invoke_sub_agent", { name: "qa-agent", prompt: `Tao STP va STC cho ${state.ticketKey}. PHAI tao draw.io diagrams.` });
+    }
+    const output: AgentOutput = { nodeId: this.nodeId, content: result, timestamp: new Date().toISOString(), metadata: { phase: "test_planning", docType: "STP/STC", usedLlm: llmAvailable, kbIngested: true } };
+    const documents = { ...state.documents };
+    documents.stp = { status: "done", version: (documents.stp?.version || 0) + 1, path: `documents/${state.ticketKey}/STP.md`, completedAt: new Date().toISOString() } satisfies DocumentState;
+    documents.stc = { status: "done", version: (documents.stc?.version || 0) + 1, path: `documents/${state.ticketKey}/STC.md`, completedAt: new Date().toISOString() } satisfies DocumentState;
+    return { agentOutputs: [output], documents };
+  }
+
+  private async executeTestExecution(state: PipelineState): Promise<Partial<PipelineState>> {
+    this.streamHandler.emitToken(this.nodeId, `[QA] Executing tests for ${state.ticketKey}...`, state.currentStreamId);
+    const llmAvailable = await this.isLlmAvailable();
+    let result: string;
+    if (llmAvailable) {
+      const reportTemplate = await this.readWorkspaceFile(QA_TEMPLATES.TEST_REPORT) || "";
+      const userPrompt = `Execute automated tests for ${state.ticketKey}.\n\nTEST REPORT TEMPLATE:\n\n${reportTemplate}\n\nRun ./gradlew test and report results.\nOutput: documents/${state.ticketKey}/TEST-REPORT-${state.ticketKey}.md`;
+      const workspaceRoot = this.getWorkspaceRoot();
+      let systemPrompt = await this.loadAgentPrompt("qa-agent", QA_SYSTEM_PROMPT_FALLBACK);
+      if (workspaceRoot) { const rules = await loadSteeringRules(workspaceRoot, "langgraph"); systemPrompt = injectSteering(systemPrompt, rules); }
+      result = await this.callLlmStreamFull(systemPrompt, userPrompt, state);
+      await this.writeWorkspaceFile(`documents/${state.ticketKey}/TEST-REPORT-${state.ticketKey}.md`, result);
+      await this.exportDocx(`documents/${state.ticketKey}/TEST-REPORT-${state.ticketKey}.md`, `TEST-REPORT-${state.ticketKey}`);
+      await this.kbIngestFile(`documents/${state.ticketKey}/TEST-REPORT-${state.ticketKey}.md`, "DOCUMENT");
+    } else {
+      result = await this.callMcp("invoke_sub_agent", { name: "qa-agent", prompt: `Chay automated tests cho ${state.ticketKey}. Run ./gradlew test.` });
+    }
+    return { agentOutputs: [{ nodeId: this.nodeId, content: result, timestamp: new Date().toISOString(), metadata: { phase: "testing", usedLlm: llmAvailable, kbIngested: true } }] };
+  }
+
+  private async executeUgVerification(state: PipelineState): Promise<Partial<PipelineState>> {
+    this.streamHandler.emitToken(this.nodeId, `[QA] Verifying User Guide for ${state.ticketKey}...`, state.currentStreamId);
+    const result = await this.callMcp("invoke_sub_agent", { name: "qa-agent", prompt: `Verify User Guide cho ${state.ticketKey}. Follow instructions, report PASS/FAIL.` });
+    return { agentOutputs: [{ nodeId: this.nodeId, content: result, timestamp: new Date().toISOString(), metadata: { phase: "user_guide", action: "ug_verification" } }], parallelResults: { qa_ug: result } };
+  }
+}

package/extension/src/langgraph/nodes/qa-prompts.ts

@@ -0,0 +1,35 @@
+/**
+ * QA Node prompts --- KSA-210, KSA-242
+ */
+
+export const QA_TEMPLATES = {
+  STP: "documents/templates/STP-TEMPLATE.md",
+  STC: "documents/templates/STC-TEMPLATE.md",
+  TEST_REPORT: "documents/templates/TEST-REPORT-TEMPLATE.md",
+} as const;
+
+export const QA_SYSTEM_PROMPT_FALLBACK = `You are a QA Engineer agent for an SDLC pipeline.
+Your responsibilities vary by phase:
+
+TEST PLANNING (Phase 4):
+- Create STP (Software Test Plan) with 6 test levels: PBT, UT, IT, E2E-API, E2E-UI, SIT
+- Create STC (Software Test Cases) with detailed test cases per level
+- Build RTM (Requirements Traceability Matrix) ensuring 100% BRD coverage
+- Generate test data CSV files for automation
+- Follow the provided template structure EXACTLY
+
+TESTING (Phase 6):
+- Execute automated tests (run ./gradlew test)
+- Review test code quality (verify IT tests use real integrations)
+- Report test results with pass/fail counts
+- Verify UG accuracy (Phase 5.5)
+- Use TEST-REPORT template for reporting
+
+DIAGRAM RULES (MANDATORY for test planning):
+- MUST create draw.io diagrams: test-coverage.drawio + test-execution-flow.drawio
+- All diagrams stored at documents/{TICKET}/diagrams/
+- Each diagram has both .drawio (source) and .png (rendered)
+- XML must start with <mxGraphModel>, NOT <mxfile>
+- Include Diagram Index table in appendix
+
+Always produce complete, production-ready documents in Markdown format.`;