igel-qe-core 1.0.3 → 1.0.7

package/src/agents/testcase_agent.py

@@ -0,0 +1,163 @@
+import json
+import logging
+from typing import List, Dict, Any
+from src.core.llm_executor import get_executor, executor_enabled_for
+from src.core.orchestration_contracts import GenerationContext, LLMRequest
+from src.config import cfg
+from src.models.test_requirement import (
+    TestRequirement, 
+    ScenarioWithRules,
+    GeneratedTestCase,
+    ManualTestStep,
+    BusinessRule
+)
+from src.agents.requirement_agent import _get_llm_client
+
+from src.core.prompt_builder import PromptBuilder
+from src.prompts.prompt_loader import load_prompt
+
+logger = logging.getLogger(__name__)
+
+_ROLE = "You are an expert IGEL Quality Engineering Architect. IGEL OS12 only."
+
+_BEHAVIORAL_INSTRUCTIONS = load_prompt(
+    "test_case_generator.md",
+    fallback=(
+        "Generate a detailed manual test case for the supplied business rule. "
+        "Do not invent behavior outside provided context."
+    ),
+)
+
+_TEMPLATE = """
+Output MUST be valid JSON matching this schema:
+{
+  "title": "string",
+  "priority": "critical" | "high" | "medium" | "low",
+  "preconditions": ["string"],
+  "steps": [
+    {
+      "step_number": 1,
+      "action": "string",
+      "data": "string",
+      "expected_result": "string"
+    }
+  ]
+}
+"""
+
+def generate_test_case(requirement: TestRequirement, scenario_rules: ScenarioWithRules, rule: BusinessRule) -> GeneratedTestCase:
+    """Generate a specific test case from a business rule."""
+    executor = get_executor()
+    use_executor = executor_enabled_for("TestCaseAgent")
+    client = None if use_executor else _get_llm_client()
+    
+    # Construct context package
+    context_package = {
+        "requirement_summary": requirement.summary,
+        "scenario_action": scenario_rules.scenario.action,
+        "business_rule": {
+            "type": rule.rule_type,
+            "description": rule.description
+        }
+    }
+    
+    final_system_prompt = PromptBuilder.build(
+        role=_ROLE,
+        behavioral_instructions=_BEHAVIORAL_INSTRUCTIONS,
+        template=_TEMPLATE,
+        context_package=context_package
+    )
+    
+    # User prompt is now just the trigger
+    user_prompt = "Generate the test case."
+
+    try:
+        if use_executor:
+            result = executor.execute(
+                LLMRequest(
+                    system_prompt=final_system_prompt,
+                    user_prompt=user_prompt,
+                    task_type="testcase_generation",
+                    agent_name="TestCaseAgent",
+                    temperature=0.2,
+                    max_tokens=2000,
+                    response_format={"type": "json_object"},
+                    context=GenerationContext(
+                        jira_key=requirement.jira_key,
+                        task_type="testcase_generation",
+                        agent_name="TestCaseAgent",
+                        query=requirement.summary,
+                        metadata={
+                            "scenario_step": scenario_rules.scenario.step_number,
+                            "rule_type": rule.rule_type,
+                        },
+                    ),
+                )
+            )
+            content = result.content or "{}"
+        else:
+            response = client.chat.completions.create(
+                model=cfg.AZURE_DEPLOYMENT,
+                messages=[
+                    {"role": "system", "content": final_system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+                response_format={"type": "json_object"},
+                temperature=0.2,
+                max_tokens=2000,
+            )
+            content = response.choices[0].message.content or "{}"
+
+        data = json.loads(content)
+        
+        # Build manual steps
+        steps = []
+        for s in data.get("steps", []):
+            if isinstance(s, dict) and "action" in s and "expected_result" in s:
+                steps.append(ManualTestStep(
+                    step_number=s.get("step_number", len(steps) + 1),
+                    action=s["action"],
+                    data=s.get("data", ""),
+                    expected_result=s["expected_result"]
+                ))
+                
+        tc_ref = f"TC_{requirement.jira_key}_S{scenario_rules.scenario.step_number:02d}_{rule.rule_type[:1].upper()}"
+        
+        tc = GeneratedTestCase(
+            tc_reference=tc_ref,
+            business_rule=rule,
+            title=data.get("title", f"Test for {rule.description}"),
+            test_type=rule.rule_type,
+            priority=data.get("priority", "medium"),
+            preconditions=data.get("preconditions", []),
+            steps=steps,
+            confidence_score=0.0,
+            confidence_metrics={}
+        )
+        logger.info(f"Generated test case {tc_ref} with {len(steps)} steps")
+        return tc
+        
+    except Exception as e:
+        logger.error(f"Failed to generate test case for rule '{rule.description}': {e}")
+        # Return a stubbed TC on failure
+        return GeneratedTestCase(
+            tc_reference=f"TC_{requirement.jira_key}_ERR",
+            business_rule=rule,
+            title="Failed to generate",
+            test_type=rule.rule_type,
+            priority="low",
+            preconditions=[],
+            steps=[],
+            confidence_score=0.0,
+            confidence_metrics={}
+        )
+
+def generate_cases_for_scenario(requirement: TestRequirement, scenario_rules: ScenarioWithRules) -> List[GeneratedTestCase]:
+    """Generate test cases for all business rules in a scenario."""
+    cases = []
+    # Enumerate to make refs unique if there are multiple of same type
+    for i, rule in enumerate(scenario_rules.business_rules):
+        tc = generate_test_case(requirement, scenario_rules, rule)
+        tc.tc_reference = f"{tc.tc_reference}{i+1:02d}"
+        cases.append(tc)
+    return cases

package/{knowledge_base → src}/agents/validation_agent.py

@@ -1,6 +1,6 @@
 import logging
 from typing import Tuple, List
-from knowledge_base.models.test_requirement import GeneratedTestCase, ScenarioWithRules, TestRequirement
+from src.models.test_requirement import GeneratedTestCase, ScenarioWithRules, TestRequirement
 
 logger = logging.getLogger(__name__)
 

package/src/agents/workflow_engine.py

@@ -0,0 +1,109 @@
+import logging
+from pathlib import Path
+from typing import List, Tuple
+
+from src.models.test_requirement import TestRequirement, GeneratedTestCase, TestCaseWithConfidence
+from src.agents.requirement_agent import extract_understanding
+from src.agents.scenario_agent import generate_all_scenarios
+from src.agents.testcase_agent import generate_cases_for_scenario
+from src.agents.validation_agent import run_validation_pipeline
+from src.agents.confidence_agent import compute_two_level_confidence
+from src.agents.automation_design_agent import design_automation_plan, AutomationPlan
+from src.agents.script_generator_agent import generate_script
+from src.agents.execution_validation_agent import ExecutionValidationAgent
+from src.core.context_engine import ContextEngine, SourceReport
+from src.core.evidence_resolver import EvidenceResolver, ResolvedContext
+from src.config.policy_config import get_policy
+
+logger = logging.getLogger(__name__)
+
+class WorkflowEngine:
+    """Predictable orchestration engine replacing the bottleneck Queen Agent."""
+    
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+        self.exec_validator = ExecutionValidationAgent(repo_path)
+        
+    def run_requirement_flow(
+        self, req: TestRequirement
+    ) -> Tuple[TestRequirement, List, ResolvedContext, SourceReport]:
+        """Requirement -> Understanding -> Context Retrieval/Resolution -> Scenario -> Business Rules"""
+        logger.info(f"Starting requirement flow for {req.jira_key}")
+
+        # 1. Understanding Layer
+        understanding = extract_understanding(req)
+        req.understanding = understanding
+
+        # 2. Scenario & Business Rules Layer
+        scenarios_with_rules = generate_all_scenarios(req)
+
+        # 3. Context Retrieval + Evidence Resolution (once per requirement)
+        query = f"{req.summary or ''}\n{req.description or ''}".strip()
+        unified_context = ContextEngine().build(req.jira_key, query)
+        resolved_context = EvidenceResolver().resolve(unified_context)
+        source_report = unified_context.source_report
+
+        # In reality, you'd persist `scenarios_with_rules` to DB here
+        return req, scenarios_with_rules, resolved_context, source_report
+        
+    def run_testcase_flow(
+        self, 
+        req: TestRequirement, 
+        scenarios_with_rules: List, 
+        resolved_context: ResolvedContext, 
+        source_report: SourceReport
+    ) -> List[TestCaseWithConfidence]:
+        """Business Rules -> Test Cases -> Validation -> Confidence"""
+        logger.info(f"Starting test case flow for {req.jira_key}")
+        all_cases = []
+        policy = get_policy()
+        
+        for sr in scenarios_with_rules:
+            # 1. Generate Test Cases
+            tcs = generate_cases_for_scenario(req, sr)
+            
+            for tc in tcs:
+                # 2. Structural/Traceability Validation
+                ok, errs = run_validation_pipeline(tc, sr)
+                    
+                # 3. Deterministic Confidence Scoring
+                tc_conf = compute_two_level_confidence(tc, sr, resolved_context, source_report, policy)
+                all_cases.append(tc_conf)
+                
+        # Persist to igel_generated_testcases handled by PersistenceEngine now
+        return all_cases
+        
+    def run_script_flow(
+        self,
+        req: TestRequirement,
+        test_cases: List[TestCaseWithConfidence],
+        output_path: Path,
+        plan: AutomationPlan = None,
+    ) -> Tuple[bool, str, AutomationPlan]:
+        """Approved Test Cases -> (Automation Design) -> Script -> Execution Validation"""
+        logger.info(f"Starting script flow for {req.jira_key}")
+
+        # Filter for approved
+        approved = [tc for tc in test_cases if tc.is_approved]
+        if not approved:
+            return False, "No approved test cases available for automation.", None
+
+        # 1. Automation Design Agent (reuse a supplied plan if present)
+        if plan is None:
+            plan = design_automation_plan(test_cases)
+
+        # 2. Script Generator
+        ok, code, err = generate_script(test_cases, plan, output_path)
+        if not ok:
+            return False, err, plan
+
+        # 3. Execution Validation Pipeline
+        ok, status, err = self.exec_validator.validate_pipeline(code, output_path)
+
+        # Persist to igel_automation_scripts here
+
+        if not ok:
+            logger.warning(f"Execution validation failed ({status}): {err}")
+            return False, err, plan
+
+        return True, "Script successfully generated and validated.", plan

package/{knowledge_base → src}/alembic/README.md

@@ -12,7 +12,7 @@ This directory contains Alembic migrations for the IGEL Knowledge Base database
    ```
 
 2. **Configure database connection**:
-   Ensure your `.env` file has PostgreSQL credentials:
+   Export PostgreSQL credentials in your runtime environment:
    ```
    DB_HOST=192.168.204.65
    DB_PORT=5432
@@ -23,7 +23,7 @@ This directory contains Alembic migrations for the IGEL Knowledge Base database
 
 3. **Initialize database** (if needed):
    ```bash
-   python -m knowledge_base.db.schema  # Creates base tables
+   python -m src.db.schema  # Creates base tables
    ```
 
 ## Running Migrations
@@ -66,7 +66,7 @@ alembic revision --autogenerate -m "Add new column to feedback_events"
 alembic revision -m "Custom schema change"
 ```
 
-Then edit the generated file in `knowledge_base/alembic/versions/`.
+Then edit the generated file in `src/alembic/versions/`.
 
 ## Migration Files
 
@@ -91,7 +91,7 @@ The table may have been created by `schema.py`. Options:
 2. Or mark migration as applied: `alembic stamp 001_phase0_feedback`
 
 ### Database connection error
-- Check `.env` file has correct credentials
+- Check runtime environment has correct DB_* values
 - Verify PostgreSQL is running: `psql -U genai -d AI_Led_QE -h 192.168.204.65`
 - Check network connectivity to DB server
 

package/{knowledge_base → src}/alembic/env.py

@@ -15,7 +15,7 @@ from pathlib import Path
 # Add parent directory to path
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
-from knowledge_base.config import cfg
+from src.config import cfg
 
 # Alembic Config object
 config = context.config

package/{knowledge_base → src}/alembic/script.py.mako

@@ -1,5 +1,5 @@
 """
 Alembic migration script placeholder.
 =====================================
-Place migration scripts in knowledge_base/alembic/versions/
+Place migration scripts in src/alembic/versions/
 """

package/{knowledge_base → src}/api/middleware.py

@@ -8,9 +8,9 @@ from collections import defaultdict, deque
 from fastapi import HTTPException, Request
 from starlette.middleware.base import BaseHTTPMiddleware
 
-from knowledge_base.core.metrics import metrics
-from knowledge_base.core.request_context import get_request_id, hash_api_key, new_request_id
-from knowledge_base.config import cfg
+from src.core.metrics import metrics
+from src.core.request_context import get_request_id, hash_api_key, new_request_id
+from src.config import cfg
 
 
 class RequestTracingMiddleware(BaseHTTPMiddleware):

package/{knowledge_base → src}/api/server.py

@@ -2,7 +2,7 @@
 IGEL Test Case Generation — Always-Running REST API
 =====================================================
 Start:
-    uvicorn knowledge_base.api.server:app --host 0.0.0.0 --port 8000
+    uvicorn src.api.server:app --host 0.0.0.0 --port 8000
 
 Endpoints:
     POST /query      — Ask any test-case-related question; returns detailed KB-grounded steps
@@ -30,29 +30,29 @@ import anyio
 from fastapi import FastAPI, HTTPException, Depends, Header, Request
 from pydantic import BaseModel, Field, model_validator, field_validator
 
-from knowledge_base.config import cfg
-from knowledge_base.db.client import init_pool, test_connection, close_pool, get_conn
-from knowledge_base.db.schema import create_schema, get_stats, ensure_knowledge_graph_tables
-from knowledge_base.db.feedback_schema import ensure_feedback_tables
-from knowledge_base.feedback.handler import capture_feedback
-from knowledge_base.retrieval.unified_query import unified_query
-from knowledge_base.core.logging_setup import configure_logging
-from knowledge_base.core.metrics import metrics, Timer
-from knowledge_base.core.request_context import (
+from src.config import cfg
+from src.db.client import init_pool, test_connection, close_pool, get_conn
+from src.db.schema import create_schema, get_stats, ensure_knowledge_graph_tables
+from src.db.feedback_schema import ensure_feedback_tables
+from src.feedback.handler import capture_feedback
+from src.retrieval.unified_query import unified_query
+from src.core.logging_setup import configure_logging
+from src.core.metrics import metrics, Timer
+from src.core.request_context import (
     api_key_scope_var,
     get_request_id,
     hash_api_key,
     resolve_scope,
 )
-from knowledge_base.api.middleware import RequestTracingMiddleware, RateLimitMiddleware
-from knowledge_base.generation.prompts import (
+from src.api.middleware import RequestTracingMiddleware, RateLimitMiddleware
+from src.generation.prompts import (
     PromptContext,
     build_system_prompt,
     build_markdown_user_prompt,
     format_kb_retrieval_references_markdown,
     kb_trace_lines,
 )
-from knowledge_base.generation.test_generator import (
+from src.generation.test_generator import (
     generate_test_cases,
     _infer_feature_area,
     _call_gpt,
@@ -85,7 +85,7 @@ async def lifespan(app: FastAPI):
     init_pool()
     try:
         if not test_connection():
-            raise RuntimeError("Cannot connect to PostgreSQL — check knowledge_base/.env")
+            raise RuntimeError("Cannot connect to PostgreSQL — check runtime DB environment/MCP configuration")
 
         create_schema()
         ensure_knowledge_graph_tables()
@@ -98,14 +98,14 @@ async def lifespan(app: FastAPI):
             stats.get("kg_nodes", 0), stats.get("kg_edges", 0),
         )
         if stats["documents"] == 0:
-            logger.warning("  KB is EMPTY — run: python -m knowledge_base.ingestion.ingest")
+            logger.warning("  KB is EMPTY — run: python -m src.ingestion.ingest")
         orphans = stats.get("kg_orphan_parents (no KG entity)", 0)
         if orphans > 0:
-            logger.warning("  %d parent chunks have no KG entity — run: python -m knowledge_base.ingestion.ingest --enrich-orphans", orphans)
+            logger.warning("  %d parent chunks have no KG entity — run: python -m src.ingestion.ingest --enrich-orphans", orphans)
 
         if cfg.RERANKER_BACKEND == "local":
             try:
-                from knowledge_base.retrieval.reranker import warm_start_reranker
+                from src.retrieval.reranker import warm_start_reranker
                 warm_start_reranker()
                 logger.info("  Reranker model pre-loaded")
             except Exception as exc:
@@ -332,7 +332,7 @@ async def health():
 
     reranker_ok = True
     try:
-        from knowledge_base.retrieval.reranker import is_reranker_loaded
+        from src.retrieval.reranker import is_reranker_loaded
         reranker_ok = is_reranker_loaded()
     except Exception:
         reranker_ok = False
@@ -341,7 +341,7 @@ async def health():
 
     redis_ok = None
     try:
-        from knowledge_base.core.cache import _redis
+        from src.core.cache import _redis
         r = _redis()
         redis_ok = r is not None and r.ping()
     except Exception:
@@ -472,7 +472,7 @@ async def generate_full_test(req: GenerateRequest):
     mode = (req.generation_mode or cfg.DEFAULT_GENERATION_MODE or "pipeline").lower()
 
     if mode == "agentic" and cfg.AGENTIC_ENABLED:
-        from knowledge_base.agents.graph import generate_agentic
+        from src.agents.graph import generate_agentic
         result = generate_agentic(
             effective_topic,
             product=req.product,
@@ -586,7 +586,7 @@ async def generate_agentic(req: AgenticGenerateRequest):
     if not cfg.AGENTIC_ENABLED:
         raise HTTPException(503, detail="Agentic pipeline disabled (AGENTIC_ENABLED=false)")
 
-    from knowledge_base.agents.graph import generate_agentic
+    from src.agents.graph import generate_agentic
 
     try:
         result = generate_agentic(
@@ -622,28 +622,28 @@ async def generate_agentic(req: AgenticGenerateRequest):
 @app.post("/rca", dependencies=[Depends(require_scope("admin"))])
 async def run_rca(req: RCARequest):
     """Root cause analysis for test failures (Phase 7)."""
-    from knowledge_base.agents.rca_agent import analyze_failure
+    from src.agents.rca_agent import analyze_failure
     return analyze_failure(req.test_id, req.failure_log)
 
 
 @app.post("/heal", dependencies=[Depends(require_scope("admin"))])
 async def heal_test(req: HealRequest):
     """Propose script fix for flaky test (Phase 7)."""
-    from knowledge_base.agents.healing_agent import propose_fix
+    from src.agents.healing_agent import propose_fix
     return propose_fix(req.test_id, req.flaky_history)
 
 
 @app.post("/impact-analysis", dependencies=[Depends(require_scope("admin"))])
 async def analyze_impact(req: ImpactAnalysisRequest):
     """Regression impact analysis from changed files (Phase 7)."""
-    from knowledge_base.agents.regression_agent import impact_analysis
+    from src.agents.regression_agent import impact_analysis
     return impact_analysis(req.changed_files)
 
 
 @app.get("/feedback/report", dependencies=[Depends(require_scope("admin"))])
 async def feedback_report(days: int = 7):
     """Weekly feedback analytics report (Phase 2)."""
-    from knowledge_base.feedback.analytics import generate_weekly_report
+    from src.feedback.analytics import generate_weekly_report
     return generate_weekly_report(days=days)
 
 
@@ -753,13 +753,13 @@ def _next_test_id() -> str:
 def _component_health(component: str) -> Optional[dict]:
     try:
         if component == "neo4j":
-            from knowledge_base.graph_db.neo4j_client import get_neo4j_client
+            from src.graph_db.neo4j_client import get_neo4j_client
             return get_neo4j_client().health_check()
         if component == "cognee":
-            from knowledge_base.memory.cognee_client import get_cognee_client
+            from src.memory.cognee_client import get_cognee_client
             return get_cognee_client().health_check()
         if component == "graphiti":
-            from knowledge_base.graph_db.graphiti_client import get_graphiti_client
+            from src.graph_db.graphiti_client import get_graphiti_client
             return get_graphiti_client().health_check()
     except Exception as e:
         return {"status": "error", "error": str(e)}

package/{knowledge_base → src}/chunking/chunker.py

@@ -16,8 +16,8 @@ from typing import Generator
 
 import tiktoken
 
-from knowledge_base.parsers.markdown_parser import Section
-from knowledge_base.chunking.validators import (
+from src.parsers.markdown_parser import Section
+from src.chunking.validators import (
     ValidationResult,
     validate_chunk,
     validate_coverage,
@@ -26,7 +26,7 @@ from knowledge_base.chunking.validators import (
     detect_product,
     CHUNK_TOKEN_LIMITS,
 )
-from knowledge_base.config import cfg
+from src.config import cfg
 
 _ENCODER = tiktoken.get_encoding("cl100k_base")
 

package/{knowledge_base → src}/cli/feedback_cli.py

@@ -1,11 +1,11 @@
 """CLI for feedback curation — Phase 2.
 
 Usage:
-    python -m knowledge_base.cli.feedback_cli curate --status pending --limit 10
-    python -m knowledge_base.cli.feedback_cli approve --id <uuid> --curator qe1 --notes "verified"
-    python -m knowledge_base.cli.feedback_cli reject --id <uuid> --curator qe1
-    python -m knowledge_base.cli.feedback_cli apply --limit 5
-    python -m knowledge_base.cli.feedback_cli report
+    python -m src.cli.feedback_cli curate --status pending --limit 10
+    python -m src.cli.feedback_cli approve --id <uuid> --curator qe1 --notes "verified"
+    python -m src.cli.feedback_cli reject --id <uuid> --curator qe1
+    python -m src.cli.feedback_cli apply --limit 5
+    python -m src.cli.feedback_cli report
 """
 from __future__ import annotations
 
@@ -13,11 +13,11 @@ import argparse
 import json
 import sys
 
-from knowledge_base.db.client import init_pool, close_pool
-from knowledge_base.db.feedback_schema import ensure_feedback_tables
-from knowledge_base.feedback.applier import apply_curated_feedback, apply_pending_promotions
-from knowledge_base.feedback.analytics import generate_weekly_report
-from knowledge_base.feedback.curator import approve, get_event, list_pending, reject
+from src.db.client import init_pool, close_pool
+from src.db.feedback_schema import ensure_feedback_tables
+from src.feedback.applier import apply_curated_feedback, apply_pending_promotions
+from src.feedback.analytics import generate_weekly_report
+from src.feedback.curator import approve, get_event, list_pending, reject
 
 
 def cmd_curate(args: argparse.Namespace) -> int:

package/{knowledge_base → src}/cli/generate.py

@@ -2,16 +2,16 @@
 IGEL Test Case Generator — CLI Entry Point
 ==========================================
 Usage:
-  python -m knowledge_base.cli.generate "Entra ID SSO login validation"
-  python -m knowledge_base.cli.generate "UMS profile assignment" --product UMS --format py
-  python -m knowledge_base.cli.generate "Device factory reset" --format md --test-id TC015
-  python -m knowledge_base.cli.generate --interactive
-  python -m knowledge_base.cli.generate --batch "SSO login,UMS profile,factory reset" --format both
-  python -m knowledge_base.cli.generate "SSO topic" --debug
-  python -m knowledge_base.cli.generate "QCAPPS-429 chromium" --source-tc-file Manual_tcs/export.csv --detail-level detailed
+  python -m src.cli.generate "Entra ID SSO login validation"
+  python -m src.cli.generate "UMS profile assignment" --product UMS --format py
+  python -m src.cli.generate "Device factory reset" --format md --test-id TC015
+  python -m src.cli.generate --interactive
+  python -m src.cli.generate --batch "SSO login,UMS profile,factory reset" --format both
+  python -m src.cli.generate "SSO topic" --debug
+  python -m src.cli.generate "QCAPPS-429 chromium" --source-tc-file Manual_tcs/export.csv --detail-level detailed
 
 Operator guide (how generation uses the DB, topic phrasing, executable steps): see
-`knowledge_base/TEST_GENERATION_GUIDE.md` in this repo.
+`src/TEST_GENERATION_GUIDE.md` in this repo.
 """
 from __future__ import annotations
 import argparse
@@ -23,8 +23,8 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
-from knowledge_base.db.client import init_pool, test_connection, close_pool
-from knowledge_base.generation.test_generator import (
+from src.db.client import init_pool, test_connection, close_pool
+from src.generation.test_generator import (
     generate_test_cases,
     batch_generate,
     DEFAULT_OUTPUT_DIR,
@@ -112,7 +112,7 @@ def main() -> None:
     init_pool()
     if not test_connection():
         console.print("[red]FAILED[/red]")
-        console.print("[red]Cannot reach DB. Check knowledge_base/.env settings.[/red]")
+        console.print("[red]Cannot reach DB. Check runtime DB environment/MCP configuration.[/red]")
         sys.exit(1)
 
     # ── Dispatch mode ─────────────────────────────────────────────────────────