sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/langgraph/graphs/chat-graph-nodes.ts

@@ -0,0 +1,285 @@
+/**
+ * Chat Graph Node Implementations — extracted from chat-graph.ts
+ * Contains fetch_tools, agent_step, execute_tools, and synthesize node logic.
+ */
+
+import { PipelineState } from "../state";
+import { StreamHandler } from "../stream-handler";
+import { McpBridge } from "../mcp-bridge";
+import { ToolRegistry } from "../tool-registry";
+import type { McpToolDefinition } from "../tool-registry";
+import type { LlmProvider, LlmMessage } from "../llm-provider";
+import { VSCODE_TOOL_DEFINITIONS, isVscodeTool, executeVscodeTool } from "../vscode-tools";
+import { HookEngine } from "../hook-engine";
+import { debugLog, debugError } from "../../debug-logger";
+import { buildBudgetAwareMessages, estimateMessagesTokens, getDynamicToolResultLimits } from "../context-budget";
+
+const LLM_CALL_TIMEOUT_MS = 300_000;
+
+export function buildMessages(state: PipelineState, tools: McpToolDefinition[], systemPrompt: string): LlmMessage[] {
+  const contextBudget = state.maxContextTokens || 0;
+
+  // If no budget set (0), use original unbounded behavior
+  if (contextBudget <= 0) {
+    return buildMessagesUnbounded(state, tools, systemPrompt);
+  }
+
+  // Budget-aware path
+  let toolNudge: LlmMessage | undefined;
+  if ((!state.agentScratchpad || state.agentScratchpad.length === 0) && tools.length > 0) {
+    const lastUser = (state.chatHistory || []).filter(m => m.role === "user").pop();
+    if (lastUser && looksLikeCodeRequest(lastUser.content)) {
+      toolNudge = {
+        role: "user",
+        content: "[SYSTEM: You MUST call a tool now. Start with list_directory path=\".\" to see the project structure, then read relevant files. Do NOT respond with text yet.]",
+      };
+    }
+  }
+
+  const result = buildBudgetAwareMessages(
+    systemPrompt,
+    state.chatHistory || [],
+    state.agentScratchpad || [],
+    tools,
+    contextBudget,
+    toolNudge,
+  );
+
+  return result.messages;
+}
+
+/** Original unbounded buildMessages for providers with large/unknown context windows. */
+function buildMessagesUnbounded(state: PipelineState, tools: McpToolDefinition[], systemPrompt: string): LlmMessage[] {
+  const messages: LlmMessage[] = [{ role: "system", content: systemPrompt }];
+  for (const msg of (state.chatHistory || [])) {
+    if (msg.role === "user" || msg.role === "assistant") {
+      messages.push({ role: msg.role, content: msg.content });
+    }
+  }
+  for (const m of (state.agentScratchpad || [])) { messages.push(m); }
+
+  // If first iteration (no scratchpad) and tools available, nudge model to use tools
+  if ((!state.agentScratchpad || state.agentScratchpad.length === 0) && tools.length > 0) {
+    const lastUser = messages.filter(m => m.role === "user").pop();
+    if (lastUser && looksLikeCodeRequest(lastUser.content)) {
+      messages.push({
+        role: "user",
+        content: "[SYSTEM: You MUST call a tool now. Start with list_directory path=\".\" to see the project structure, then read relevant files. Do NOT respond with text yet.]",
+      });
+    }
+  }
+
+  return messages;
+}
+
+function looksLikeCodeRequest(text: string): boolean {
+  const lower = text.toLowerCase();
+  const keywords = ["review", "code", "source", "file", "read", "xem", "đọc", "kiểm tra", "check", "analyze", "phân tích"];
+  return keywords.some(k => lower.includes(k));
+}
+
+export function createFetchToolsNode(toolRegistry: ToolRegistry | null) {
+  return async (_state: PipelineState) => {
+    let mcpTools: McpToolDefinition[] = [];
+    if (toolRegistry) {
+      try { mcpTools = await toolRegistry.getTools(); } catch { mcpTools = []; }
+    }
+    const allTools = [...VSCODE_TOOL_DEFINITIONS, ...mcpTools];
+    debugLog(`[graph] fetch_tools: ${allTools.length} total tools`);
+    return { parallelResults: { toolsJson: JSON.stringify(allTools) }, lastUpdatedAt: new Date().toISOString() };
+  };
+}
+
+export function createAgentStepNode(
+  llmProvider: LlmProvider | undefined, streamHandler: StreamHandler, enrichedSystemPrompt: string
+) {
+  return async (state: PipelineState) => {
+    if (!llmProvider) {
+      return {
+        agentOutputs: [{ nodeId: "chat", content: "No LLM configured.", timestamp: new Date().toISOString() }],
+        pipelineStatus: "completed" as const, toolCalls: null, lastUpdatedAt: new Date().toISOString(),
+      };
+    }
+    const streamId = state.currentStreamId || `stream-chat-${Date.now()}`;
+    let tools: McpToolDefinition[] = [];
+    try { tools = JSON.parse(state.parallelResults?.toolsJson || "[]"); } catch { tools = []; }
+
+    if (llmProvider.chatWithTools && tools.length > 0) {
+      return await agentStepWithTools(state, llmProvider, streamHandler, streamId, tools.slice(0, 10), enrichedSystemPrompt);
+    }
+    return await agentStepStreaming(state, llmProvider, streamHandler, streamId, enrichedSystemPrompt, tools);
+  };
+}
+
+async function agentStepWithTools(
+  state: PipelineState, llm: LlmProvider, sh: StreamHandler,
+  streamId: string, tools: McpToolDefinition[], sysPrompt: string
+) {
+  try {
+    const messages = buildMessages(state, tools, sysPrompt);
+
+    // Log LLM request
+    debugLog(`[LLM-REQ] iteration=${state.agentIterations || 0}, messages=${messages.length}, tools=${tools.length}`);
+    for (const m of messages) {
+      const preview = m.content.slice(0, 150).replace(/\n/g, " ");
+      debugLog(`  [${m.role}] ${preview}${m.content.length > 150 ? "..." : ""}`);
+      if ((m as any).toolCalls) { debugLog(`  [assistant.toolCalls] ${JSON.stringify((m as any).toolCalls.map((tc: any) => tc.name))}`); }
+    }
+
+    const llmPromise = llm.chatWithTools!(messages, tools, { maxTokens: 8192 });
+    const timeoutPromise = new Promise<never>((_, rej) => { const t = setTimeout(() => rej(new Error("LLM timeout")), LLM_CALL_TIMEOUT_MS); if (t.unref) t.unref(); });
+    const response = await Promise.race([llmPromise, timeoutPromise]);
+
+    // Log LLM response
+    if (response.type === "text") {
+      debugLog(`[LLM-RES] type=text, length=${(response.text || "").length}`);
+      debugLog(`  preview: ${(response.text || "").slice(0, 200).replace(/\n/g, " ")}`);
+      sh.emitStatus("chat", "active", streamId);
+      sh.emitToken("chat", response.text || "", streamId);
+      sh.emitComplete("chat", 0, streamId);
+      // NOTE: Do NOT set working=false here — verify may loop back. Engine handler sets it on graph completion.
+      return { agentOutputs: [{ nodeId: "chat", content: response.text || "", timestamp: new Date().toISOString() }], pipelineStatus: "completed" as const, toolCalls: null, lastUpdatedAt: new Date().toISOString() };
+    }
+    debugLog(`[LLM-RES] type=tool_use, calls=${(response.toolCalls || []).map(tc => `${tc.name}(${JSON.stringify(tc.arguments).slice(0, 50)})`).join(", ")}`);
+    const tcJson = JSON.stringify((response.toolCalls || []).map(tc => ({ type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments })));
+    return { toolCalls: response.toolCalls || null, parallelResults: { lastToolCallsJson: tcJson }, lastUpdatedAt: new Date().toISOString() };
+  } catch (error) {
+    const errMsg = (error as Error).message;
+    debugLog(`[LLM-ERR] ${errMsg}`);
+    sh.emitError("chat", errMsg, streamId);
+    // Return a terminal error output so verify_response sees agentOutputs and routes to __end__
+    // instead of looping back to agent_step infinitely when LLM server is down.
+    const errorContent = `⚠️ LLM Error: ${errMsg}`;
+    return {
+      agentOutputs: [{ nodeId: "chat", content: errorContent, timestamp: new Date().toISOString() }],
+      errors: [{ nodeId: "chat", code: "LLM_ERROR", message: errMsg, timestamp: new Date().toISOString(), recoverable: false }],
+      pipelineStatus: "failed" as const,
+      toolCalls: null,
+      lastUpdatedAt: new Date().toISOString(),
+    };
+  }
+}
+
+async function agentStepStreaming(
+  state: PipelineState, llm: LlmProvider, sh: StreamHandler,
+  streamId: string, sysPrompt: string, tools: McpToolDefinition[]
+) {
+  sh.emitStatus("chat", "active", streamId);
+  try {
+    const messages = buildMessages(state, tools, sysPrompt);
+    let full = "";
+    for await (const token of llm.chatStream(messages, { maxTokens: 8192 })) { full += token; sh.emitToken("chat", token, streamId); }
+    sh.emitComplete("chat", 0, streamId);
+    return { agentOutputs: [{ nodeId: "chat", content: full, timestamp: new Date().toISOString() }], pipelineStatus: "completed" as const, toolCalls: null, lastUpdatedAt: new Date().toISOString() };
+  } catch (error) {
+    const errMsg = (error as Error).message;
+    sh.emitError("chat", errMsg, streamId);
+    const errorContent = `⚠️ LLM Error: ${errMsg}`;
+    return {
+      agentOutputs: [{ nodeId: "chat", content: errorContent, timestamp: new Date().toISOString() }],
+      errors: [{ nodeId: "chat", code: "LLM_ERROR", message: errMsg, timestamp: new Date().toISOString(), recoverable: false }],
+      pipelineStatus: "failed" as const,
+      toolCalls: null,
+      lastUpdatedAt: new Date().toISOString(),
+    };
+  }
+}
+
+export function createExecuteToolsNode(
+  mcpBridge: McpBridge | undefined, sh: StreamHandler, hookEngine: HookEngine | undefined, wsRoot: string
+) {
+  return async (state: PipelineState) => {
+    const streamId = state.currentStreamId || `stream-chat-${Date.now()}`;
+    const calls = state.toolCalls || [];
+    const results: Array<{ toolCallId: string; name: string; content: string }> = [];
+    sh.emitComplete("chat", 0, streamId);
+
+    for (const call of calls) {
+      const r = await executeSingleTool(call, mcpBridge, sh, streamId, hookEngine, wsRoot);
+      results.push(r);
+    }
+
+    const newEntries: LlmMessage[] = [
+      { role: "assistant", content: "", toolCalls: calls.map(c => ({ id: c.id, name: c.name, arguments: c.arguments })) } as any,
+    ];
+    // Dynamic tool result sizing based on context budget
+    const contextBudget = state.maxContextTokens || 0;
+    const currentUsage = estimateMessagesTokens(state.agentScratchpad || []);
+    const { dirLimit, fileLimit } = getDynamicToolResultLimits(contextBudget, currentUsage);
+
+    for (const r of results) {
+      let content = r.content;
+      const isFileContent = r.name === "read_file";
+      const limit = isFileContent ? fileLimit : dirLimit;
+      if (content.length > limit) {
+        content = content.slice(0, limit) + `\n\n[... truncated at ${limit} chars, ${r.content.length} total ...]`;
+      }
+      newEntries.push({ role: "tool", content, toolCallId: r.toolCallId, toolName: r.name });
+    }
+
+    // Accumulate scratchpad (reducer now replaces, so we must append here)
+    const scratchpad: LlmMessage[] = [...(state.agentScratchpad || []), ...newEntries];
+
+    return { toolResults: results, agentScratchpad: scratchpad, toolCalls: null, agentIterations: (state.agentIterations || 0) + 1, currentStreamId: `stream-chat-${Date.now()}`, lastUpdatedAt: new Date().toISOString() };
+  };
+}
+
+async function executeSingleTool(
+  call: { id: string; name: string; arguments: Record<string, unknown> },
+  mcpBridge: McpBridge | undefined, sh: StreamHandler, streamId: string,
+  hookEngine: HookEngine | undefined, wsRoot: string
+): Promise<{ toolCallId: string; name: string; content: string }> {
+  const tcId = call.id || `tc-${Date.now()}`;
+
+  if (hookEngine) {
+    try {
+      const pre = await hookEngine.firePreToolUse(call.name, call.arguments || {}, sh, streamId);
+      if (pre.denied) return { toolCallId: call.id, name: call.name, content: `Denied by hook "${pre.hookName}"` };
+    } catch (e) { debugError(`preToolUse hook error`, e as Error); }
+  }
+
+  sh.emitDirect({ type: "chat:toolCall", toolCall: { id: tcId, name: call.name, args: call.arguments, status: "running" } } as any);
+  const start = Date.now();
+
+  try {
+    let result: string;
+    if (call.name === "stream_write_file" && (!call.arguments?.file_path && !call.arguments?.path)) {
+      result = "Error: 'file_path' is required";
+    } else if (isVscodeTool(call.name)) {
+      result = await executeVscodeTool(call.name, call.arguments, wsRoot);
+    } else if (mcpBridge) {
+      result = await mcpBridge.callTool(call.name, call.arguments);
+    } else {
+      result = `Error: Tool '${call.name}' not available`;
+    }
+    const dur = Date.now() - start;
+    sh.emitDirect({ type: "chat:toolCallUpdate", id: tcId, status: "completed", result: result.slice(0, 500), duration: dur } as any);
+    if (hookEngine) { try { await hookEngine.firePostToolUse(call.name, call.arguments || {}, result, sh, streamId); } catch {} }
+    return { toolCallId: call.id, name: call.name, content: result };
+  } catch (error) {
+    sh.emitDirect({ type: "chat:toolCallUpdate", id: tcId, status: "failed", result: (error as Error).message, duration: Date.now() - start } as any);
+    return { toolCallId: call.id, name: call.name, content: `Error: ${(error as Error).message}` };
+  }
+}
+
+export function createSynthesizeNode(llm: LlmProvider | undefined, sh: StreamHandler, sysPrompt: string) {
+  return async (state: PipelineState) => {
+    const streamId = state.currentStreamId || `stream-chat-${Date.now()}`;
+    if (!llm) return { pipelineStatus: "completed" as const, lastUpdatedAt: new Date().toISOString() };
+    try {
+      const messages = buildMessages(state, [], sysPrompt);
+      messages.push({ role: "user", content: "Provide your final answer now. Do not call any more tools." });
+      sh.emitStatus("chat", "active", streamId);
+      let full = "";
+      if (llm.chatStream) { for await (const t of llm.chatStream(messages, { maxTokens: 8192 })) { full += t; sh.emitToken("chat", t, streamId); } }
+      else if (llm.chatWithTools) { const r = await llm.chatWithTools(messages, [], { maxTokens: 8192 }); full = r.text || ""; sh.emitToken("chat", full, streamId); }
+      sh.emitComplete("chat", 0, streamId);
+      sh.emitDirect({ type: "chat:workingStatus", working: false });
+      return { agentOutputs: [{ nodeId: "chat", content: full, timestamp: new Date().toISOString() }], pipelineStatus: "completed" as const, lastUpdatedAt: new Date().toISOString() };
+    } catch (error) {
+      sh.emitError("chat", (error as Error).message, streamId);
+      sh.emitDirect({ type: "chat:workingStatus", working: false });
+      return { pipelineStatus: "failed" as const, lastUpdatedAt: new Date().toISOString() };
+    }
+  };
+}

package/extension/src/langgraph/graphs/chat-graph.ts

@@ -0,0 +1,177 @@
+/**
+ * Chat Subgraph — ReAct Agent Loop with Full MCP Tool Calling
+ * Flow: __start__ -> fetch_tools -> agent_step -> [route]
+ *   - tool_use -> execute_tools -> [route] -> agent_step (loop) or synthesize
+ *   - text -> verify_response -> [COMPLETE] -> __end__
+ *                              -> [INCOMPLETE] -> agent_step (retry)
+ *                              -> [TOOL_NEEDED] -> execute_tools
+ */
+
+import { StateGraph, END } from "@langchain/langgraph";
+import { PipelineAnnotation, PipelineState } from "../state";
+import { StreamHandler } from "../stream-handler";
+import { McpBridge } from "../mcp-bridge";
+import { ToolRegistry } from "../tool-registry";
+import type { LlmProvider } from "../llm-provider";
+import { loadSteeringRules, injectSteering } from "../steering-loader";
+import { HookEngine } from "../hook-engine";
+import { debugLog } from "../../debug-logger";
+import {
+  createFetchToolsNode, createAgentStepNode,
+  createExecuteToolsNode, createSynthesizeNode,
+} from "./chat-graph-nodes";
+import { createVerifyResponseNode, routeAfterVerify } from "./verify-node";
+import {
+  createRetrieveEvaluatorNode, createHallucinationGraderNode,
+  routeAfterHallucinationGrade, getDefaultRagGraderConfig,
+} from "./rag-grader-nodes";
+
+const MAX_AGENT_ITERATIONS = 25;
+
+const AGENT_SYSTEM_PROMPT = `You are a coding assistant with access to workspace tools. You can read files, search code, and list directories.
+
+## CRITICAL RULES:
+1. ALWAYS use tools FIRST before answering questions about code or the project
+2. NEVER say "please provide a file path" — use list_directory and read_file yourself
+3. When user asks about code: call list_directory to find files, then read_file to read them
+4. When user asks to review code: read the code first, THEN give your review
+5. After list_directory results: IMMEDIATELY call read_file on source files you found. Do NOT respond with text asking for clarification.
+
+## AVAILABLE TOOLS:
+- list_directory: List files in a directory (use path="." for project root, path="src" for source)
+- read_file: Read file content by path
+- write_file: Write/create files (path + content)
+- search_text: Search for text patterns across files
+- get_diagnostics: Check for errors in files
+
+## WORKFLOW:
+1. User asks question → call list_directory(path=".") to see TOP-LEVEL only
+2. See folder names → call list_directory(path="src") or specific subfolder
+3. See files → call read_file with start_line/end_line for RELEVANT SECTION ONLY
+4. Have enough info → synthesize response
+5. NEVER read entire large files. Use line ranges: read_file(path="x", start_line=1, end_line=80)
+6. You CAN call tools multiple times — each call gives you more context
+
+## AFTER list_directory: WHAT TO DO NEXT
+- See "src/" or "backend/" folder? → read_file on entry point (index.ts, main.ts, extension.ts, app.ts)
+- See specific .ts/.js/.kt/.py files? → read_file on 2-3 most important ones
+- Not sure which file? → grep_search for "export" or "class" to find key modules
+- NEVER say "which file do you want me to review" — just pick the main source files
+
+## RESPONSE STYLE:
+- Keep responses concise (5-15 sentences)
+- Use bullet points
+- Respond in same language as user
+- After reading code: give specific feedback with line references`;
+
+function routeAgentStep(state: PipelineState): string {
+  // Circuit breaker: if pipeline already failed (e.g., LLM crash/context exceeded), stop immediately
+  if (state.pipelineStatus === "failed") {
+    debugLog(`[graph] routeAgentStep: pipeline FAILED -> verify_response (will route to __end__)`);
+    return "verify_response";
+  }
+  if (state.toolCalls && state.toolCalls.length > 0) {
+    debugLog(`[graph] routeAgentStep: ${state.toolCalls.length} toolCalls -> execute_tools`);
+    return "execute_tools";
+  }
+  debugLog(`[graph] routeAgentStep: text response -> verify_response`);
+  return "verify_response";
+}
+
+function routeAfterToolExec(state: PipelineState): string {
+  // Stop if pipeline failed (LLM crash during tool execution cycle)
+  if (state.pipelineStatus === "failed") return "synthesize";
+  if ((state.agentIterations || 0) >= MAX_AGENT_ITERATIONS) return "synthesize";
+  return "agent_step";
+}
+
+export async function buildChatSubgraph(
+  streamHandler: StreamHandler,
+  llmProvider?: LlmProvider,
+  mcpBridge?: McpBridge,
+  workspaceRoot?: string,
+  hookEngine?: HookEngine
+) {
+  const toolRegistry = mcpBridge ? new ToolRegistry(mcpBridge) : null;
+  const wsRoot = workspaceRoot || require("vscode").workspace.workspaceFolders?.[0]?.uri.fsPath || "";
+
+  // Detect context window for budget-aware message building
+  const contextWindow = llmProvider?.getContextWindow() || 0;
+  if (contextWindow > 0) {
+    debugLog(`[chat-graph] Context window detected: ${contextWindow} tokens`);
+  }
+
+  let enrichedSystemPrompt = AGENT_SYSTEM_PROMPT;
+  try {
+    if (wsRoot) {
+      const rules = await loadSteeringRules(wsRoot, "langgraph");
+      enrichedSystemPrompt = injectSteering(enrichedSystemPrompt, rules);
+      if (rules.length > 0 && streamHandler) {
+        const ruleNames = rules.map(r => r.meta.title || r.filePath).join(", ");
+        streamHandler.emitDirect({
+          type: "chat:toolCall",
+          toolCall: {
+            id: `steering-${Date.now()}`, name: "steering_rules_loaded",
+            args: { count: rules.length, rules: ruleNames.slice(0, 200) },
+            status: "completed", result: `${rules.length} steering rules injected`, duration: 0,
+          },
+        } as any);
+      }
+    }
+  } catch { /* fallback to base prompt */ }
+
+  const verifyNode = createVerifyResponseNode(llmProvider, streamHandler);
+
+  // Create a budget-injecting fetch_tools node that also sets maxContextTokens
+  const fetchToolsBase = createFetchToolsNode(toolRegistry);
+  const fetchToolsWithBudget = async (state: PipelineState) => {
+    const baseResult = await fetchToolsBase(state);
+    // Inject context budget into state if provider reports it
+    if (contextWindow > 0 && !state.maxContextTokens) {
+      return { ...baseResult, maxContextTokens: contextWindow };
+    }
+    return baseResult;
+  };
+
+  // RAG grading config — enabled for small models only
+  const ragConfig = getDefaultRagGraderConfig(contextWindow);
+  if (ragConfig.enableHallucinationGrade) {
+    debugLog(`[chat-graph] Corrective RAG enabled (contextWindow=${contextWindow}): retrieve-eval + hallucination-grader`);
+  }
+
+  if (ragConfig.enableHallucinationGrade) {
+    // Graph with Corrective RAG nodes for small models
+    const graph = new StateGraph(PipelineAnnotation)
+      .addNode("fetch_tools", fetchToolsWithBudget)
+      .addNode("agent_step", createAgentStepNode(llmProvider, streamHandler, enrichedSystemPrompt))
+      .addNode("execute_tools", createExecuteToolsNode(mcpBridge, streamHandler, hookEngine, wsRoot))
+      .addNode("verify_response", verifyNode)
+      .addNode("synthesize", createSynthesizeNode(llmProvider, streamHandler, enrichedSystemPrompt))
+      .addNode("hallucination_grader", createHallucinationGraderNode(llmProvider, streamHandler, ragConfig))
+      .addEdge("__start__", "fetch_tools")
+      .addEdge("fetch_tools", "agent_step")
+      .addConditionalEdges("agent_step", routeAgentStep, { execute_tools: "execute_tools", verify_response: "verify_response" })
+      .addConditionalEdges("execute_tools", routeAfterToolExec, { agent_step: "agent_step", synthesize: "synthesize" })
+      .addConditionalEdges("verify_response", routeAfterVerify, { execute_tools: "execute_tools", agent_step: "agent_step", __end__: "hallucination_grader" })
+      .addConditionalEdges("hallucination_grader", routeAfterHallucinationGrade, { agent_step: "agent_step", __end__: END })
+      .addEdge("synthesize", END);
+
+    return graph.compile();
+  }
+
+  // Standard graph without RAG grading (large models)
+  const graph = new StateGraph(PipelineAnnotation)
+    .addNode("fetch_tools", fetchToolsWithBudget)
+    .addNode("agent_step", createAgentStepNode(llmProvider, streamHandler, enrichedSystemPrompt))
+    .addNode("execute_tools", createExecuteToolsNode(mcpBridge, streamHandler, hookEngine, wsRoot))
+    .addNode("verify_response", verifyNode)
+    .addNode("synthesize", createSynthesizeNode(llmProvider, streamHandler, enrichedSystemPrompt))
+    .addEdge("__start__", "fetch_tools")
+    .addEdge("fetch_tools", "agent_step")
+    .addConditionalEdges("agent_step", routeAgentStep, { execute_tools: "execute_tools", verify_response: "verify_response" })
+    .addConditionalEdges("verify_response", routeAfterVerify, { execute_tools: "execute_tools", agent_step: "agent_step", __end__: END })
+    .addConditionalEdges("execute_tools", routeAfterToolExec, { agent_step: "agent_step", synthesize: "synthesize" })
+    .addEdge("synthesize", END);
+
+  return graph.compile();
+}

package/extension/src/langgraph/graphs/code-review-graph.ts

@@ -0,0 +1,112 @@
+/**
+ * Code Review Subgraph — PR/Code Review Pipeline
+ * Automated code review with security scanning and quality assessment.
+ *
+ * Flow: __start__ → fetch_context → security_scan → quality_review → report → __end__
+ */
+
+import { StateGraph, END } from "@langchain/langgraph";
+import { PipelineAnnotation, PipelineState } from "../state";
+import { McpBridge } from "../mcp-bridge";
+import { StreamHandler } from "../stream-handler";
+import type { LlmProvider } from "../llm-provider";
+import { SecurityNode } from "../nodes/security-node";
+import { QaNode } from "../nodes/qa-node";
+
+/**
+ * Build the code review subgraph.
+ */
+export async function buildCodeReviewSubgraph(
+  mcpBridge: McpBridge,
+  streamHandler: StreamHandler,
+  llmProvider?: LlmProvider
+) {
+  const securityNode = new SecurityNode("security_scan", mcpBridge, streamHandler, llmProvider);
+  const qaNode = new QaNode("quality_review", mcpBridge, streamHandler, llmProvider);
+
+  const graph = new StateGraph(PipelineAnnotation)
+    // Fetch PR/diff context
+    .addNode("fetch_context", async (state: PipelineState) => {
+      const streamId = state.currentStreamId || `stream-review-${Date.now()}`;
+      streamHandler.emitStatus("fetch_context", "active", streamId);
+
+      const lastMessage = state.chatHistory?.[state.chatHistory.length - 1];
+      const reviewRequest = lastMessage?.content || "";
+
+      // Attempt to fetch diff via MCP tools
+      let context = `Review request: ${reviewRequest}`;
+      try {
+        const diffResult = await mcpBridge.callTool("read_file", { path: reviewRequest }, 30_000);
+        if (diffResult) {
+          context = diffResult;
+        }
+      } catch {
+        // Continue with available context
+      }
+
+      streamHandler.emitComplete("fetch_context", 0, streamId);
+
+      return {
+        agentOutputs: [{
+          nodeId: "fetch_context",
+          content: context,
+          timestamp: new Date().toISOString(),
+          metadata: { action: "fetch_pr_context" },
+        }],
+        lastUpdatedAt: new Date().toISOString(),
+      };
+    })
+
+    // Security scan for vulnerabilities
+    .addNode("security_scan", (state: PipelineState) => securityNode.run(state))
+
+    // Code quality review
+    .addNode("quality_review", (state: PipelineState) => qaNode.run(state))
+
+    // Generate review summary report
+    .addNode("report", async (state: PipelineState) => {
+      const streamId = state.currentStreamId || `stream-review-${Date.now()}`;
+      streamHandler.emitStatus("report", "active", streamId);
+
+      const outputs = state.agentOutputs || [];
+      const securityFindings = outputs.find(o => o.nodeId === "security_scan")?.content || "No security issues found.";
+      const qualityFindings = outputs.find(o => o.nodeId === "quality_review")?.content || "No quality issues found.";
+
+      let report = `## Code Review Report\n\n### Security\n${securityFindings}\n\n### Quality\n${qualityFindings}`;
+
+      if (llmProvider) {
+        try {
+          report = await llmProvider.chat(
+            [
+              { role: "system", content: "Summarize security and quality findings into a concise code review report. Use markdown format. Highlight critical issues first." },
+              { role: "user", content: `Security findings:\n${securityFindings}\n\nQuality findings:\n${qualityFindings}` },
+            ],
+            { temperature: 0.3, maxTokens: 2048 }
+          );
+        } catch {
+          // Use basic report
+        }
+      }
+
+      streamHandler.emitComplete("report", 0, streamId);
+
+      return {
+        agentOutputs: [{
+          nodeId: "report",
+          content: report,
+          timestamp: new Date().toISOString(),
+          metadata: { action: "review_report" },
+        }],
+        pipelineStatus: "completed" as const,
+        lastUpdatedAt: new Date().toISOString(),
+      };
+    })
+
+    .addEdge("__start__", "fetch_context")
+    .addEdge("fetch_context", "security_scan")
+    .addEdge("security_scan", "quality_review")
+    .addEdge("quality_review", "report")
+    .addEdge("report", END);
+
+  return graph.compile();
+}

package/extension/src/langgraph/graphs/docs-graph.ts

@@ -0,0 +1,89 @@
+/**
+ * Docs Subgraph — Documentation Generation Pipeline
+ * Routes to the appropriate agent based on document type.
+ *
+ * Flow: __start__ → detect_doc_type → [BA|DEV|DevOps] → qa_verify → __end__
+ */
+
+import { StateGraph, END } from "@langchain/langgraph";
+import { PipelineAnnotation, PipelineState } from "../state";
+import { McpBridge } from "../mcp-bridge";
+import { StreamHandler } from "../stream-handler";
+import type { LlmProvider } from "../llm-provider";
+import { BaNode } from "../nodes/ba-node";
+import { DevNode } from "../nodes/dev-node";
+import { DevOpsNode } from "../nodes/devops-node";
+import { QaNode } from "../nodes/qa-node";
+
+/**
+ * Build the docs subgraph for document generation.
+ */
+export async function buildDocsSubgraph(
+  mcpBridge: McpBridge,
+  streamHandler: StreamHandler,
+  llmProvider?: LlmProvider
+) {
+  const baNode = new BaNode("ba_docs", mcpBridge, streamHandler, llmProvider);
+  const devNode = new DevNode("dev_docs", mcpBridge, streamHandler, llmProvider);
+  const devopsNode = new DevOpsNode("devops_docs", mcpBridge, streamHandler, llmProvider);
+  const qaNode = new QaNode("qa_verify_docs", mcpBridge, streamHandler, llmProvider);
+
+  const graph = new StateGraph(PipelineAnnotation)
+    // Detect what type of document is requested
+    .addNode("detect_doc_type", async (state: PipelineState) => {
+      const lastMessage = state.chatHistory?.[state.chatHistory.length - 1];
+      const request = (lastMessage?.content || "").toLowerCase();
+
+      let docType: string;
+      if (/\b(ug|user\s*guide)\b/i.test(request)) {
+        docType = "dev"; // User Guide → DEV
+      } else if (/\b(dpg|deploy|deployment\s*guide|release\s*note|rln)\b/i.test(request)) {
+        docType = "devops"; // Deployment Guide → DevOps
+      } else if (/\b(brd|fsd|business|requirement|specification)\b/i.test(request)) {
+        docType = "ba"; // Business docs → BA
+      } else {
+        docType = "dev"; // Default to DEV for general docs
+      }
+
+      return {
+        parallelResults: { docType },
+        lastUpdatedAt: new Date().toISOString(),
+      };
+    })
+
+    // BA generates business documents
+    .addNode("ba_generate", (state: PipelineState) => baNode.run(state))
+
+    // DEV generates technical documents (UG, API docs)
+    .addNode("dev_generate", (state: PipelineState) => devNode.run(state))
+
+    // DevOps generates deployment documents
+    .addNode("devops_generate", (state: PipelineState) => devopsNode.run(state))
+
+    // QA verifies the document
+    .addNode("qa_verify_docs", (state: PipelineState) => qaNode.run(state))
+
+    .addEdge("__start__", "detect_doc_type")
+
+    // Route to appropriate agent
+    .addConditionalEdges("detect_doc_type", (state: PipelineState) => {
+      const docType = state.parallelResults?.docType || "dev";
+      switch (docType) {
+        case "ba": return "ba_generate";
+        case "devops": return "devops_generate";
+        default: return "dev_generate";
+      }
+    }, {
+      ba_generate: "ba_generate",
+      dev_generate: "dev_generate",
+      devops_generate: "devops_generate",
+    })
+
+    // All generators feed into QA verification
+    .addEdge("ba_generate", "qa_verify_docs")
+    .addEdge("dev_generate", "qa_verify_docs")
+    .addEdge("devops_generate", "qa_verify_docs")
+    .addEdge("qa_verify_docs", END);
+
+  return graph.compile();
+}