sdlc-agent-4-enterprise-server 1.0.0

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

@@ -0,0 +1,152 @@
+/**
+ * SaNode — KSA-210, KSA-242
+ * Solution Architect agent node. Full multi-step workflow:
+ * KB search → Code Intelligence → DB schema → Template read → LLM generate →
+ * Write file → Diagrams → PNG export → DOCX export → KB ingest.
+ */
+
+import { BaseNode } from "./base-node";
+import { PipelineState, AgentOutput, DocumentState } from "../state";
+import { loadSteeringRules, injectSteering } from "../steering-loader";
+
+const TDD_TEMPLATE = "documents/templates/TDD-TEMPLATE.md";
+
+const SA_SYSTEM_PROMPT_FALLBACK = `You are a Solution Architect agent for an SDLC pipeline.
+Your role is to create comprehensive Technical Design Documents (TDD) based on BRD and FSD.
+
+Responsibilities:
+- Analyze system architecture and define component design
+- Design API contracts (REST/GraphQL endpoints, request/response schemas)
+- Design database schema (tables, relationships, migrations)
+- Define class/module design with responsibilities
+- Create implementation checklist for developers
+- Define error handling and security design
+- Follow the provided template structure EXACTLY
+
+DIAGRAM RULES (MANDATORY):
+- MUST create draw.io diagrams: architecture.drawio + component.drawio + class-*.drawio
+- All diagrams stored at documents/{TICKET}/diagrams/
+- XML must start with <mxGraphModel>, NOT <mxfile>
+- Every edge uses expanded form with <mxGeometry relative="1" as="geometry"/>
+- Include Diagram Index table in appendix
+
+Always produce complete, production-ready documents in Markdown format.`;
+
+export class SaNode extends BaseNode {
+  async execute(state: PipelineState): Promise<Partial<PipelineState>> {
+    const ticketKey = state.ticketKey;
+
+    this.streamHandler.emitToken(
+      this.nodeId, `[SA] Starting TDD pipeline for ${ticketKey}...`, state.currentStreamId
+    );
+
+    const llmAvailable = await this.isLlmAvailable();
+    let result: string;
+
+    if (llmAvailable) {
+      result = await this.executeFullPipeline(state);
+    } else {
+      result = await this.callMcp("invoke_sub_agent", {
+        name: "sa-agent",
+        prompt: `Tao TDD cho ${ticketKey}. Doc code intelligence data va FSD. PHAI tao draw.io diagrams (architecture.drawio + component.drawio) va export PNG.`,
+      });
+    }
+
+    // KB ingest
+    await this.kbIngestFile(`documents/${ticketKey}/TDD.md`, "DOCUMENT");
+
+    const output: AgentOutput = {
+      nodeId: this.nodeId,
+      content: result,
+      timestamp: new Date().toISOString(),
+      metadata: { docType: "TDD", phase: "design", usedLlm: llmAvailable, kbIngested: true },
+    };
+
+    const documents = { ...state.documents };
+    documents.tdd = {
+      status: "done",
+      version: (documents.tdd?.version || 0) + 1,
+      path: `documents/${ticketKey}/TDD.md`,
+      completedAt: new Date().toISOString(),
+    } satisfies DocumentState;
+
+    return { agentOutputs: [output], documents, currentPhase: "design" };
+  }
+
+  private async executeFullPipeline(state: PipelineState): Promise<string> {
+    const ticketKey = state.ticketKey;
+
+    // Step 1: Read FSD and BRD from KB
+    this.streamHandler.emitToken(this.nodeId, `  → Step 1: Searching KB for FSD/BRD...`, state.currentStreamId);
+    let kbContext = "";
+    try {
+      kbContext = await this.kbSearch(`${ticketKey} FSD BRD requirements specification`);
+    } catch { /* continue */ }
+
+    // Step 2: Read Code Intelligence
+    this.streamHandler.emitToken(this.nodeId, `  → Step 2: Reading Code Intelligence...`, state.currentStreamId);
+    const codeIntel = await this.readCodeIntelligence() || "";
+
+    // Step 3: Read FSD file directly (fallback if KB incomplete)
+    let fsdContent = "";
+    const fsdPath = state.documents.fsd?.path || `documents/${ticketKey}/FSD.md`;
+    const fsdFile = await this.readWorkspaceFile(fsdPath);
+    if (fsdFile) fsdContent = fsdFile;
+
+    // Step 4: Read template
+    this.streamHandler.emitToken(this.nodeId, `  → Step 3: Reading TDD template...`, state.currentStreamId);
+    const template = await this.readWorkspaceFile(TDD_TEMPLATE) || "[Template not found]";
+
+    // Step 5: Generate TDD via LLM
+    this.streamHandler.emitToken(this.nodeId, `  → Step 4: Generating TDD...`, state.currentStreamId);
+    const userPrompt = this.buildPrompt(ticketKey, state, template, kbContext, codeIntel, fsdContent);
+
+    const workspaceRoot = this.getWorkspaceRoot();
+    let systemPrompt = await this.loadAgentPrompt("sa-agent", SA_SYSTEM_PROMPT_FALLBACK);
+    if (workspaceRoot) {
+      const rules = await loadSteeringRules(workspaceRoot, "langgraph");
+      systemPrompt = injectSteering(systemPrompt, rules);
+    }
+
+    const content = await this.callLlmStreamFull(systemPrompt, userPrompt, state);
+
+    // Step 6: Write file
+    this.streamHandler.emitToken(this.nodeId, `  → Step 5: Writing TDD.md...`, state.currentStreamId);
+    await this.writeWorkspaceFile(`documents/${ticketKey}/TDD.md`, content);
+
+    // Step 7: Export DOCX
+    this.streamHandler.emitToken(this.nodeId, `  → Step 6: Exporting DOCX...`, state.currentStreamId);
+    const version = (state.documents.tdd?.version || 0) + 1;
+    await this.exportDocx(`documents/${ticketKey}/TDD.md`, `TDD-v${version}-${ticketKey}`);
+
+    this.streamHandler.emitToken(this.nodeId, `  ✅ TDD pipeline complete`, state.currentStreamId);
+    return content;
+  }
+
+  private buildPrompt(
+    ticketKey: string, state: PipelineState, template: string,
+    kbContext: string, codeIntel: string, fsdContent: string
+  ): string {
+    const sections: string[] = [];
+    sections.push(`Create a TDD for ticket ${ticketKey}.`);
+    sections.push(`\n## TEMPLATE\n\n${template}`);
+
+    if (fsdContent) sections.push(`\n## FSD CONTENT\n\n${fsdContent.slice(0, 15000)}`);
+    if (kbContext) sections.push(`\n## KB CONTEXT\n\n${kbContext}`);
+    if (codeIntel) sections.push(`\n## CODE INTELLIGENCE\n\n${codeIntel}\n\nUse actual patterns, table names, API routes from above.`);
+
+    const chatContext = state.chatHistory.filter(m => m.role === "user").map(m => m.content).join("\n");
+    if (chatContext) sections.push(`\n## USER CONTEXT\n\n${chatContext}`);
+
+    sections.push(`\n## DIAGRAMS (MANDATORY)
+
+Generate draw.io XML for:
+1. documents/${ticketKey}/diagrams/architecture.drawio
+2. documents/${ticketKey}/diagrams/component.drawio
+3. documents/${ticketKey}/diagrams/class-main.drawio
+
+Rules: <mxGraphModel> root, expanded edges with <mxGeometry>, Diagram Index table.`);
+
+    return sections.join("\n");
+  }
+}

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

@@ -0,0 +1,94 @@
+/**
+ * SecurityNode — KSA-210, KSA-242
+ * Security review agent node. Performs security analysis on
+ * design documents and implementation code.
+ * KSA-242: Added template ref, steering injection.
+ */
+
+import { BaseNode } from "./base-node";
+import { PipelineState, AgentOutput } from "../state";
+import { loadSteeringRules, injectSteering } from "../steering-loader";
+
+/** Template path for Security Report */
+const SECURITY_REPORT_TEMPLATE = "documents/templates/SECURITY-REPORT-TEMPLATE.md";
+
+const SECURITY_SYSTEM_PROMPT_FALLBACK = `You are a Security Engineer agent for an SDLC pipeline.
+Your role is to review designs and code for security vulnerabilities.
+
+Review areas:
+- Authentication and authorization design
+- Input validation and sanitization
+- SQL injection, XSS, CSRF prevention
+- Secrets management (no hardcoded credentials)
+- API security (rate limiting, CORS, JWT handling)
+- Data encryption (at rest and in transit)
+- Dependency vulnerabilities (known CVEs)
+- OWASP Top 10 compliance
+- Least privilege principle
+- Secure error handling (no information leakage)
+
+Report findings with severity (Critical/High/Medium/Low) and remediation steps.
+Follow the provided Security Report template structure.`;
+
+export class SecurityNode extends BaseNode {
+  async execute(state: PipelineState): Promise<Partial<PipelineState>> {
+    this.streamHandler.emitToken(
+      this.nodeId,
+      `[Security] Reviewing security for ${state.ticketKey}...`,
+      state.currentStreamId
+    );
+
+    const llmAvailable = await this.isLlmAvailable();
+    let result: string;
+
+    if (llmAvailable) {
+      const userPrompt = `Perform security review for ${state.ticketKey}.
+
+TEMPLATE: ${SECURITY_REPORT_TEMPLATE}
+
+TDD: ${state.documents.tdd?.path || "documents/" + state.ticketKey + "/TDD.md"}
+FSD: ${state.documents.fsd?.path || "documents/" + state.ticketKey + "/FSD.md"}
+
+Review the design for:
+1. Authentication/Authorization gaps
+2. Input validation completeness
+3. Injection vulnerabilities (SQL, XSS, command)
+4. Secrets management approach
+5. API security (rate limits, CORS, tokens)
+6. Data protection (encryption, PII handling)
+7. Error handling (no info leakage)
+8. Dependency security
+
+Report each finding with:
+- Severity: Critical/High/Medium/Low
+- Location: which section/component
+- Description: what the issue is
+- Remediation: how to fix`;
+
+      // KSA-242: Inject steering rules
+      const workspaceRoot = require("vscode").workspace.workspaceFolders?.[0]?.uri.fsPath;
+      let systemPrompt = await this.loadAgentPrompt("security-agent", SECURITY_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: "security-agent",
+        prompt: `Security review cho ${state.ticketKey}. Review TDD va code. Report findings. Template: ${SECURITY_REPORT_TEMPLATE}`,
+      });
+    }
+
+    const output: AgentOutput = {
+      nodeId: this.nodeId,
+      content: result,
+      timestamp: new Date().toISOString(),
+      metadata: { phase: state.currentPhase, action: "security_review", usedLlm: llmAvailable },
+    };
+
+    return {
+      agentOutputs: [output],
+    };
+  }
+}

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

@@ -0,0 +1,35 @@
+/**
+ * SmNode — KSA-210
+ * Scrum Master routing node. Analyzes ticket context via MCP mem_search
+ * and determines which agent should execute next.
+ */
+
+import { BaseNode } from "./base-node";
+import { PipelineState, AgentOutput } from "../state";
+
+export class SmNode extends BaseNode {
+  async execute(state: PipelineState): Promise<Partial<PipelineState>> {
+    // Fetch ticket context from KB
+    const contextResult = await this.callMcp("mem_search", {
+      query: `${state.ticketKey} context requirements`,
+    });
+
+    this.streamHandler.emitToken(
+      this.nodeId,
+      `[SM] Routing pipeline for ${state.ticketKey} — phase: ${state.currentPhase}`,
+      state.currentStreamId
+    );
+
+    const output: AgentOutput = {
+      nodeId: this.nodeId,
+      content: contextResult || `SM routed ${state.ticketKey} to phase: ${state.currentPhase}`,
+      timestamp: new Date().toISOString(),
+      metadata: { phase: state.currentPhase, ticketKey: state.ticketKey },
+    };
+
+    return {
+      agentOutputs: [output],
+      pipelineStatus: "running",
+    };
+  }
+}

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

@@ -0,0 +1,113 @@
+/**
+ * TaNode — KSA-210, KSA-242
+ * Technical Analyst agent node.
+ * Reviews and enriches FSD with technical depth:
+ * API contracts, integration specs, pseudocode, NFR quantification.
+ * KSA-242: Added steering injection, KB ingest.
+ */
+
+import { BaseNode } from "./base-node";
+import { PipelineState, AgentOutput, DocumentState } from "../state";
+import { loadSteeringRules, injectSteering } from "../steering-loader";
+
+const TA_SYSTEM_PROMPT_FALLBACK = `You are a Technical Analyst agent for an SDLC pipeline.
+Your role is to review and ENRICH existing FSD (Functional Specification Document) with technical depth.
+
+You do NOT create the FSD from scratch — the BA has already written the business sections.
+Your job is to:
+1. Review Use Cases — add missing Alternative/Exception flows
+2. Add/detail API Contracts — ensure developers can implement (request/response schemas)
+3. Add Integration Requirements — full API contracts with schemas
+4. Add pseudocode for complex business logic
+5. Review Data Model — ensure consistency with actual codebase
+6. Add Non-Functional Requirements with quantified targets
+7. Flag Open Issues for unresolved technical decisions
+
+Always modify the existing FSD.md in place. Never rewrite it from scratch.
+Output your enrichments clearly marked with section headers.`;
+
+export class TaNode extends BaseNode {
+  async execute(state: PipelineState): Promise<Partial<PipelineState>> {
+    this.streamHandler.emitToken(
+      this.nodeId,
+      `[TA] Enriching FSD for ${state.ticketKey}...`,
+      state.currentStreamId
+    );
+
+    const llmAvailable = await this.isLlmAvailable();
+    let result: string;
+
+    if (llmAvailable) {
+      const userPrompt = this.buildUserPrompt(state);
+      // KSA-242: Inject steering rules
+      const workspaceRoot = require("vscode").workspace.workspaceFolders?.[0]?.uri.fsPath;
+      let systemPrompt = await this.loadAgentPrompt("ta-agent", TA_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: "ta-agent",
+        prompt: `Review va bo sung FSD cho ${state.ticketKey}. Doc code intelligence data. Bo sung API contracts, integration specs, pseudocode.`,
+      });
+    }
+
+    // KSA-242: Ingest enriched FSD into KB
+    try {
+      await this.callMcp("mem_ingest", {
+        content: result,
+        type: "DOCUMENT",
+        source: "langgraph-ta-fsd-enriched",
+        tags: [state.ticketKey, "FSD", "ta-agent", "enriched", "langgraph"],
+        scope: "USER",
+      });
+    } catch {
+      // KB ingest failure is non-blocking
+    }
+
+    const output: AgentOutput = {
+      nodeId: this.nodeId,
+      content: result,
+      timestamp: new Date().toISOString(),
+      metadata: { phase: "specification", action: "enrich_fsd", usedLlm: llmAvailable, kbIngested: true },
+    };
+
+    const documents = { ...state.documents };
+    documents.fsd = {
+      status: "done",
+      version: (documents.fsd?.version || 0) + 1,
+      path: `documents/${state.ticketKey}/FSD.md`,
+      completedAt: new Date().toISOString(),
+    } satisfies DocumentState;
+
+    return {
+      agentOutputs: [output],
+      documents,
+    };
+  }
+
+  private buildUserPrompt(state: PipelineState): string {
+    const ticketKey = state.ticketKey;
+    const fsdPath = state.documents.fsd?.path || `documents/${ticketKey}/FSD.md`;
+    const brdPath = state.documents.brd?.path || `documents/${ticketKey}/BRD.md`;
+
+    return `Enrich the FSD for ticket ${ticketKey}.
+
+FSD location: ${fsdPath}
+BRD reference: ${brdPath}
+
+Review the existing FSD and add:
+1. Missing Alternative/Exception flows in Use Cases
+2. Detailed API Contracts (request/response JSON schemas, HTTP methods, status codes)
+3. Integration Requirements with external systems
+4. Pseudocode for complex business logic
+5. Data Model consistency check
+6. Quantified Non-Functional Requirements (response time, throughput, availability)
+7. Open Issues / Technical Decisions needed
+
+Do NOT rewrite the FSD — only ADD and ENRICH existing content.
+Mark your additions clearly so they can be reviewed.`;
+  }
+}

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

@@ -0,0 +1,93 @@
+/**
+ * UiNode — KSA-210, KSA-242
+ * UI Designer agent node. Creates wireframes and UI specifications
+ * based on FSD UI sections (Phase 2.5).
+ * KSA-242: Added template ref, steering injection, diagram requirements.
+ */
+
+import { BaseNode } from "./base-node";
+import { PipelineState, AgentOutput } from "../state";
+import { loadSteeringRules, injectSteering } from "../steering-loader";
+
+/** Template path for UI Spec */
+const UI_SPEC_TEMPLATE = "documents/templates/UI-SPEC-TEMPLATE.md";
+
+const UI_SYSTEM_PROMPT_FALLBACK = `You are a UI Designer agent for an SDLC pipeline.
+Your role is to create wireframes and detailed UI specifications based on the FSD.
+
+Responsibilities:
+- Create wireframe layouts for each screen/page
+- Define component hierarchy and interactions
+- Specify responsive breakpoints
+- Define color schemes, typography, spacing
+- Create UI flow diagrams (navigation paths)
+- Annotate accessibility requirements (ARIA labels, keyboard nav)
+- Follow the provided UI-SPEC template structure EXACTLY
+
+DIAGRAM RULES (MANDATORY):
+- Output wireframes in draw.io format
+- 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
+
+Output wireframes in draw.io format and UI specs in Markdown.`;
+
+export class UiNode extends BaseNode {
+  async execute(state: PipelineState): Promise<Partial<PipelineState>> {
+    this.streamHandler.emitToken(
+      this.nodeId,
+      `[UI] Creating wireframes for ${state.ticketKey}...`,
+      state.currentStreamId
+    );
+
+    const llmAvailable = await this.isLlmAvailable();
+    let result: string;
+
+    if (llmAvailable) {
+      const userPrompt = `Create UI wireframes and specifications for ${state.ticketKey}.
+
+TEMPLATE: Read and follow ${UI_SPEC_TEMPLATE}
+
+FSD: ${state.documents.fsd?.path || "documents/" + state.ticketKey + "/FSD.md"}
+
+Based on the FSD UI Specifications section, create:
+1. Wireframe layouts for each screen (describe in detail)
+2. Component hierarchy
+3. Interaction patterns (hover, click, transitions)
+4. Responsive behavior
+5. Accessibility annotations
+6. Navigation flow
+
+DIAGRAMS (MANDATORY):
+- Create wireframe .drawio files for each screen
+- Create documents/${state.ticketKey}/diagrams/ui-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("ui-agent", UI_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: "ui-agent",
+        prompt: `Tao wireframes cho ${state.ticketKey}. Doc FSD de hieu UI specs. Template: ${UI_SPEC_TEMPLATE}. PHAI tao draw.io wireframes va export PNG.`,
+      });
+    }
+
+    const output: AgentOutput = {
+      nodeId: this.nodeId,
+      content: result,
+      timestamp: new Date().toISOString(),
+      metadata: { phase: "specification", action: "create_wireframes", usedLlm: llmAvailable },
+    };
+
+    return {
+      agentOutputs: [output],
+    };
+  }
+}

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

@@ -0,0 +1,158 @@
+/**
+ * VerifyNode — KSA-233
+ * Dedicated graph node that validates agent output quality against
+ * configurable criteria. Placed after each agent node in the graph.
+ *
+ * Implements: UC-2 (Output Verification), BR-8 through BR-12
+ */
+
+import { BaseNode } from "./base-node";
+import { McpBridge } from "../mcp-bridge";
+import { StreamHandler } from "../stream-handler";
+import { PipelineState, AgentOutput } from "../state";
+import { getVerifyCriteria, VerifyCriteria } from "../config/verify-criteria";
+import type { LlmProvider } from "../llm-provider";
+
+export class VerifyNode extends BaseNode {
+  /** The agent nodeId whose output this verify node evaluates */
+  private readonly targetNodeId: string;
+
+  constructor(
+    nodeId: string,
+    targetNodeId: string,
+    mcpBridge: McpBridge,
+    streamHandler: StreamHandler,
+    llmProvider?: LlmProvider
+  ) {
+    super(nodeId, mcpBridge, streamHandler, llmProvider);
+    this.targetNodeId = targetNodeId;
+  }
+
+  /**
+   * Evaluate the last agent output against verification criteria.
+   *
+   * Processing (FSD 6.2):
+   * 1. Extract last agentOutput for targetNodeId
+   * 2. Load criteria for currentPhase
+   * 3. Evaluate via LLM or rule-based check
+   * 4. Return verify result in state
+   */
+  async execute(state: PipelineState): Promise<Partial<PipelineState>> {
+    try {
+      // Step 1: Extract agent output (EF-5: handle empty)
+      const lastOutput = this.getLastAgentOutput(state);
+      if (!lastOutput || !lastOutput.content) {
+        return this.buildVerifyFailure(state, "No output produced by agent node");
+      }
+
+      // Step 2: Load criteria (EF-6: skip if not configured)
+      const criteria = getVerifyCriteria(state.currentPhase);
+      if (!criteria) {
+        return this.buildVerifyPass(state);
+      }
+
+      // Step 3: Evaluate output against criteria
+      const evaluation = await this.evaluateOutput(lastOutput, criteria, state);
+
+      // Step 4-5: Return result
+      if (evaluation.passed) {
+        return this.buildVerifyPass(state);
+      } else {
+        return this.buildVerifyFailure(state, evaluation.feedback);
+      }
+    } catch (error) {
+      // EF-4: VerifyNode itself errors -> treat as pass (BR-12: fail-open)
+      console.warn(`VerifyNode '${this.nodeId}' error, treating as pass:`, error);
+      return this.buildVerifyPass(state);
+    }
+  }
+
+  /** Evaluate agent output against criteria using LLM */
+  private async evaluateOutput(
+    output: AgentOutput,
+    criteria: VerifyCriteria,
+    _state: PipelineState
+  ): Promise<{ passed: boolean; feedback: string }> {
+    const systemPrompt = [
+      "You are a quality verification agent.",
+      "Evaluate the following output against the given criteria.",
+      "Respond with JSON: { \"passed\": true/false, \"feedback\": \"specific feedback\" }",
+      "If passed, feedback can be empty. If failed, feedback MUST be specific and actionable.",
+    ].join(" ");
+
+    const checksText = criteria.checks.map((c) => "- " + c).join("\n");
+    const userPrompt = [
+      "## Criteria",
+      criteria.description,
+      "",
+      "## Checks",
+      checksText,
+      "",
+      "## Agent Output (from node: " + this.targetNodeId + ")",
+      output.content.substring(0, 10000),
+    ].join("\n");
+
+    const response = await this.callLlm(systemPrompt, userPrompt);
+    return this.parseVerifyResponse(response);
+  }
+
+  /** Parse LLM response into pass/fail + feedback */
+  private parseVerifyResponse(response: string): { passed: boolean; feedback: string } {
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return { passed: Boolean(parsed.passed), feedback: parsed.feedback || "" };
+      }
+    } catch {
+      /* fall through */
+    }
+    // If parsing fails, treat as pass (fail-open)
+    return { passed: true, feedback: "" };
+  }
+
+  /** Build state for verification pass */
+  private buildVerifyPass(state: PipelineState): Partial<PipelineState> {
+    this.streamHandler.emitVerify(
+      this.nodeId,
+      true,
+      null,
+      (state.verifyAttempts?.[this.targetNodeId] ?? 0) + 1,
+      state.currentStreamId
+    );
+    return {
+      verifyPassed: true,
+      verifyFeedback: null,
+      lastUpdatedAt: new Date().toISOString(),
+    };
+  }
+
+  /** Build state for verification failure */
+  private buildVerifyFailure(state: PipelineState, feedback: string): Partial<PipelineState> {
+    const currentAttempts = (state.verifyAttempts?.[this.targetNodeId] ?? 0) + 1;
+    this.streamHandler.emitVerify(
+      this.nodeId,
+      false,
+      feedback,
+      currentAttempts,
+      state.currentStreamId
+    );
+    return {
+      verifyPassed: false,
+      verifyFeedback: feedback,
+      verifyAttempts: { ...state.verifyAttempts, [this.targetNodeId]: currentAttempts },
+      lastUpdatedAt: new Date().toISOString(),
+    };
+  }
+
+  /** Get the last agent output from state */
+  private getLastAgentOutput(state: PipelineState): AgentOutput | null {
+    const outputs = state.agentOutputs || [];
+    for (let i = outputs.length - 1; i >= 0; i--) {
+      if (outputs[i].nodeId === this.targetNodeId) {
+        return outputs[i];
+      }
+    }
+    return null;
+  }
+}