igel-qe-core 1.0.0

package/knowledge_base/db/feedback_schema.py

@@ -0,0 +1,548 @@
+"""
+Feedback Event Schema for IGEL KB System
+=========================================
+Captures user feedback on generated test cases for continuous learning.
+
+Two-Step Feedback Flow:
+1. CAPTURE: User provides feedback → stored as event
+2. CURATE: QE engineer reviews → decides if/how to improve system
+3. PROMOTE: Approved feedback becomes training signal
+
+Never auto-edit based on raw feedback — human curation is mandatory gate.
+"""
+from __future__ import annotations
+
+from knowledge_base.config import cfg
+from knowledge_base.db.client import get_conn
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Feedback Events Table
+# ─────────────────────────────────────────────────────────────────────────────
+
+_FEEDBACK_SCHEMA_SQL = """
+-- Feedback events: user corrections, ratings, edits to generated test cases
+CREATE TABLE IF NOT EXISTS feedback_events (
+    id                  UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    
+    -- Source query and generation
+    query               TEXT NOT NULL,
+    generated_output    JSONB NOT NULL,             -- full response (markdown, python, chunks)
+    generation_metadata JSONB DEFAULT '{}'::jsonb,   -- retrieval scores, model params, etc.
+    
+    -- User feedback
+    feedback_type       TEXT NOT NULL,               -- rating, correction, edit, rejection
+    feedback_data       JSONB NOT NULL,              -- structured feedback payload
+    user_id             TEXT,                        -- optional user identifier
+    session_id          TEXT,                        -- session/request tracking
+    
+    -- Curation status (two-step gate)
+    status              TEXT NOT NULL DEFAULT 'pending',  -- pending, reviewed, approved, rejected, applied
+    curator_id          TEXT,                        -- QE engineer who reviewed
+    curator_notes       TEXT,                        -- why approved/rejected
+    curated_at          TIMESTAMP,
+    
+    -- Application tracking (if approved and promoted)
+    applied_action      TEXT,                        -- added_to_training, updated_kg, refined_prompt
+    applied_at          TIMESTAMP,
+    
+    -- Timestamps
+    created_at          TIMESTAMP DEFAULT NOW(),
+    
+    -- Source precedence context (Gold TC > Jira > Confluence > Docs)
+    source_context      JSONB DEFAULT '{}'::jsonb    -- which docs were retrieved, precedence applied
+);
+
+-- Indexes for feedback queries
+CREATE INDEX IF NOT EXISTS idx_feedback_status ON feedback_events(status);
+CREATE INDEX IF NOT EXISTS idx_feedback_type ON feedback_events(feedback_type);
+CREATE INDEX IF NOT EXISTS idx_feedback_created ON feedback_events(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_feedback_curator ON feedback_events(curator_id);
+CREATE INDEX IF NOT EXISTS idx_feedback_query ON feedback_events USING gin(to_tsvector('english', query));
+
+
+-- ─────────────────────────────────────────────────────────────────────────────
+-- Evaluation Runs Table
+-- ─────────────────────────────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS eval_runs (
+    id                  UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    
+    -- Run identification
+    run_id              TEXT UNIQUE NOT NULL,        -- human-readable ID (e.g., "baseline", "phase2_v1")
+    run_type            TEXT NOT NULL,               -- baseline, regression, comparison, manual
+    
+    -- Aggregate scores (5 dimensions + overall)
+    avg_retrieval       DOUBLE PRECISION,
+    avg_domain          DOUBLE PRECISION,
+    avg_structural      DOUBLE PRECISION,
+    avg_executability   DOUBLE PRECISION,
+    avg_publish         DOUBLE PRECISION,
+    avg_overall         DOUBLE PRECISION,
+    pass_rate           DOUBLE PRECISION,
+    
+    -- Metadata
+    query_count         INT NOT NULL,
+    duration_seconds    DOUBLE PRECISION,
+    system_version      TEXT,                        -- git commit, phase identifier, etc.
+    metadata            JSONB DEFAULT '{}'::jsonb,
+    
+    -- Timestamps
+    created_at          TIMESTAMP DEFAULT NOW()
+);
+
+-- Indexes for eval runs
+CREATE INDEX IF NOT EXISTS idx_eval_runs_id ON eval_runs(run_id);
+CREATE INDEX IF NOT EXISTS idx_eval_runs_type ON eval_runs(run_type);
+CREATE INDEX IF NOT EXISTS idx_eval_runs_created ON eval_runs(created_at DESC);
+
+
+-- ─────────────────────────────────────────────────────────────────────────────
+-- Evaluation Results Table (detailed per-query results)
+-- ─────────────────────────────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS eval_results (
+    id                  UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    
+    -- Parent run
+    eval_run_id         UUID NOT NULL REFERENCES eval_runs(id) ON DELETE CASCADE,
+    
+    -- Query
+    query_id            TEXT NOT NULL,               -- query identifier from queries_50.json
+    query               TEXT NOT NULL,
+    
+    -- Generated output
+    generated_output    JSONB NOT NULL,              -- full response
+    
+    -- 5-dimensional scores
+    retrieval_score     DOUBLE PRECISION,
+    retrieval_feedback  TEXT[],
+    domain_score        DOUBLE PRECISION,
+    domain_feedback     TEXT[],
+    structural_score    DOUBLE PRECISION,
+    structural_feedback TEXT[],
+    executability_score DOUBLE PRECISION,
+    executability_feedback TEXT[],
+    publish_score       DOUBLE PRECISION,
+    publish_feedback    TEXT[],
+    overall_score       DOUBLE PRECISION,
+    passed              BOOLEAN,
+    
+    -- Metadata
+    duration_seconds    DOUBLE PRECISION,
+    metadata            JSONB DEFAULT '{}'::jsonb,
+    
+    created_at          TIMESTAMP DEFAULT NOW()
+);
+
+-- Indexes for eval results
+CREATE INDEX IF NOT EXISTS idx_eval_results_run ON eval_results(eval_run_id);
+CREATE INDEX IF NOT EXISTS idx_eval_results_passed ON eval_results(passed);
+CREATE INDEX IF NOT EXISTS idx_eval_results_overall ON eval_results(overall_score DESC);
+
+
+-- ─────────────────────────────────────────────────────────────────────────────
+-- Feedback Promotions (curated feedback approved for operational memory)
+-- ─────────────────────────────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS feedback_promotions (
+    id                  UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    feedback_event_id   UUID NOT NULL REFERENCES feedback_events(id) ON DELETE CASCADE,
+    curator_id          TEXT NOT NULL,
+    curator_notes       TEXT,
+    promoted_content    JSONB NOT NULL DEFAULT '{}'::jsonb,
+    status              TEXT NOT NULL DEFAULT 'pending',  -- pending, applied, rejected
+    applied_at          TIMESTAMP,
+    created_at          TIMESTAMP DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_feedback_promotions_status ON feedback_promotions(status);
+CREATE INDEX IF NOT EXISTS idx_feedback_promotions_event ON feedback_promotions(feedback_event_id);
+
+
+-- ─────────────────────────────────────────────────────────────────────────────
+-- Feedback Audit Trail (lifecycle tracking for promoted items)
+-- ─────────────────────────────────────────────────────────────────────────────
+
+CREATE TABLE IF NOT EXISTS feedback_audit_trail (
+    id                  UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    promotion_id        UUID REFERENCES feedback_promotions(id) ON DELETE SET NULL,
+    feedback_event_id   UUID REFERENCES feedback_events(id) ON DELETE SET NULL,
+    action              TEXT NOT NULL,
+    actor_id            TEXT,
+    details             JSONB DEFAULT '{}'::jsonb,
+    created_at          TIMESTAMP DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_feedback_audit_promotion ON feedback_audit_trail(promotion_id);
+CREATE INDEX IF NOT EXISTS idx_feedback_audit_event ON feedback_audit_trail(feedback_event_id);
+CREATE INDEX IF NOT EXISTS idx_feedback_audit_created ON feedback_audit_trail(created_at DESC);
+"""
+
+
+def ensure_feedback_tables() -> None:
+    """Create feedback and evaluation tables if they don't exist."""
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(_FEEDBACK_SCHEMA_SQL)
+    print("  Feedback tables ready (feedback_events, eval_runs, eval_results, feedback_promotions, feedback_audit_trail)")
+
+
+def insert_feedback_event(
+    query: str,
+    generated_output: dict,
+    feedback_type: str,
+    feedback_data: dict,
+    generation_metadata: dict | None = None,
+    user_id: str | None = None,
+    session_id: str | None = None,
+    source_context: dict | None = None,
+) -> str:
+    """Insert a new feedback event. Returns event ID."""
+    import json
+    
+    sql = """
+    INSERT INTO feedback_events 
+        (query, generated_output, generation_metadata, feedback_type, feedback_data, 
+         user_id, session_id, source_context)
+    VALUES (%s, %s::jsonb, %s::jsonb, %s, %s::jsonb, %s, %s, %s::jsonb)
+    RETURNING id
+    """
+    
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, (
+                query,
+                json.dumps(generated_output),
+                json.dumps(generation_metadata or {}),
+                feedback_type,
+                json.dumps(feedback_data),
+                user_id,
+                session_id,
+                json.dumps(source_context or {}),
+            ))
+            return str(cur.fetchone()[0])
+
+
+def update_feedback_curation(
+    event_id: str,
+    status: str,
+    curator_id: str,
+    curator_notes: str | None = None,
+) -> None:
+    """Update curation status of a feedback event (reviewed, approved, rejected)."""
+    sql = """
+    UPDATE feedback_events
+    SET status = %s,
+        curator_id = %s,
+        curator_notes = %s,
+        curated_at = NOW()
+    WHERE id = %s
+    """
+    
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, (status, curator_id, curator_notes, event_id))
+
+
+def mark_feedback_applied(
+    event_id: str,
+    applied_action: str,
+) -> None:
+    """Mark feedback as applied to the system."""
+    sql = """
+    UPDATE feedback_events
+    SET status = 'applied',
+        applied_action = %s,
+        applied_at = NOW()
+    WHERE id = %s
+    """
+    
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, (applied_action, event_id))
+
+
+def insert_eval_run(
+    run_id: str,
+    run_type: str,
+    avg_scores: dict,
+    pass_rate: float,
+    query_count: int,
+    duration_seconds: float,
+    system_version: str | None = None,
+    metadata: dict | None = None,
+) -> str:
+    """Insert an evaluation run summary. Returns eval_run UUID."""
+    import json
+    
+    sql = """
+    INSERT INTO eval_runs
+        (run_id, run_type, avg_retrieval, avg_domain, avg_structural, 
+         avg_executability, avg_publish, avg_overall, pass_rate, 
+         query_count, duration_seconds, system_version, metadata)
+    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s::jsonb)
+    RETURNING id
+    """
+    
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, (
+                run_id,
+                run_type,
+                avg_scores.get("retrieval"),
+                avg_scores.get("domain"),
+                avg_scores.get("structural"),
+                avg_scores.get("executability"),
+                avg_scores.get("publish"),
+                avg_scores.get("overall"),
+                pass_rate,
+                query_count,
+                duration_seconds,
+                system_version,
+                json.dumps(metadata or {}),
+            ))
+            return str(cur.fetchone()[0])
+
+
+def insert_eval_results_batch(eval_run_uuid: str, results: list[dict]) -> None:
+    """Batch insert detailed per-query evaluation results."""
+    import json
+    
+    sql = """
+    INSERT INTO eval_results
+        (eval_run_id, query_id, query, generated_output, 
+         retrieval_score, retrieval_feedback, domain_score, domain_feedback,
+         structural_score, structural_feedback, executability_score, executability_feedback,
+         publish_score, publish_feedback, overall_score, passed,
+         duration_seconds, metadata)
+    VALUES (%s, %s, %s, %s::jsonb, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s::jsonb)
+    """
+    
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            for r in results:
+                cur.execute(sql, (
+                    eval_run_uuid,
+                    r["query_id"],
+                    r["query"],
+                    json.dumps(r["generated_output"]),
+                    r["retrieval_score"],
+                    r["retrieval_feedback"],
+                    r["domain_score"],
+                    r["domain_feedback"],
+                    r["structural_score"],
+                    r["structural_feedback"],
+                    r["executability_score"],
+                    r["executability_feedback"],
+                    r["publish_score"],
+                    r["publish_feedback"],
+                    r["overall_score"],
+                    r["passed"],
+                    r.get("duration_seconds"),
+                    json.dumps(r.get("metadata", {})),
+                ))
+
+
+def insert_feedback_promotion(
+    feedback_event_id: str,
+    curator_id: str,
+    promoted_content: dict,
+    curator_notes: str | None = None,
+) -> str:
+    """Create a promotion record for curated feedback. Returns promotion UUID."""
+    import json
+
+    sql = """
+    INSERT INTO feedback_promotions
+        (feedback_event_id, curator_id, curator_notes, promoted_content, status)
+    VALUES (%s, %s, %s, %s::jsonb, 'pending')
+    RETURNING id
+    """
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, (
+                feedback_event_id,
+                curator_id,
+                curator_notes,
+                json.dumps(promoted_content),
+            ))
+            promotion_id = str(cur.fetchone()[0])
+            insert_feedback_audit(
+                promotion_id=promotion_id,
+                feedback_event_id=feedback_event_id,
+                action="promotion_created",
+                actor_id=curator_id,
+                details={"status": "pending"},
+                cursor=cur,
+            )
+            return promotion_id
+
+
+def mark_promotion_applied(promotion_id: str, actor_id: str | None = None) -> None:
+    """Mark a promotion as applied to the system."""
+    sql = """
+    UPDATE feedback_promotions
+    SET status = 'applied', applied_at = NOW()
+    WHERE id = %s
+    RETURNING feedback_event_id
+    """
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, (promotion_id,))
+            row = cur.fetchone()
+            if row:
+                insert_feedback_audit(
+                    promotion_id=promotion_id,
+                    feedback_event_id=str(row[0]),
+                    action="promotion_applied",
+                    actor_id=actor_id,
+                    details={"status": "applied"},
+                    cursor=cur,
+                )
+
+
+def insert_feedback_audit(
+    action: str,
+    promotion_id: str | None = None,
+    feedback_event_id: str | None = None,
+    actor_id: str | None = None,
+    details: dict | None = None,
+    cursor=None,
+) -> str:
+    """Record an audit trail entry for feedback lifecycle events."""
+    import json
+
+    sql = """
+    INSERT INTO feedback_audit_trail
+        (promotion_id, feedback_event_id, action, actor_id, details)
+    VALUES (%s, %s, %s, %s, %s::jsonb)
+    RETURNING id
+    """
+    params = (
+        promotion_id,
+        feedback_event_id,
+        action,
+        actor_id,
+        json.dumps(details or {}),
+    )
+    if cursor is not None:
+        cursor.execute(sql, params)
+        return str(cursor.fetchone()[0])
+
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, params)
+            return str(cur.fetchone()[0])
+
+
+def list_feedback_events(
+    status: str = "pending",
+    limit: int = 10,
+    offset: int = 0,
+) -> list[dict]:
+    """List feedback events by curation status."""
+    import json
+
+    sql = """
+    SELECT id::text, query, feedback_type, status, created_at,
+           generated_output, feedback_data, curator_notes
+    FROM feedback_events
+    WHERE status = %s
+    ORDER BY created_at DESC
+    LIMIT %s OFFSET %s
+    """
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, (status, limit, offset))
+            rows = cur.fetchall()
+
+    results = []
+    for row in rows:
+        results.append({
+            "id": row[0],
+            "query": row[1],
+            "feedback_type": row[2],
+            "status": row[3],
+            "created_at": row[4].isoformat() if row[4] else None,
+            "generated_output": row[5] if isinstance(row[5], dict) else json.loads(row[5] or "{}"),
+            "feedback_data": row[6] if isinstance(row[6], dict) else json.loads(row[6] or "{}"),
+            "curator_notes": row[7],
+        })
+    return results
+
+
+def get_feedback_event(event_id: str) -> dict | None:
+    """Fetch a single feedback event by UUID."""
+    import json
+
+    sql = """
+    SELECT id::text, query, feedback_type, status, created_at, curated_at,
+           generated_output, feedback_data, generation_metadata, source_context,
+           curator_id, curator_notes, applied_action, applied_at
+    FROM feedback_events WHERE id = %s
+    """
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, (event_id,))
+            row = cur.fetchone()
+
+    if not row:
+        return None
+
+    def _j(val):
+        if val is None:
+            return {}
+        return val if isinstance(val, dict) else json.loads(val)
+
+    return {
+        "id": row[0],
+        "query": row[1],
+        "feedback_type": row[2],
+        "status": row[3],
+        "created_at": row[4].isoformat() if row[4] else None,
+        "curated_at": row[5].isoformat() if row[5] else None,
+        "generated_output": _j(row[6]),
+        "feedback_data": _j(row[7]),
+        "generation_metadata": _j(row[8]),
+        "source_context": _j(row[9]),
+        "curator_id": row[10],
+        "curator_notes": row[11],
+        "applied_action": row[12],
+        "applied_at": row[13].isoformat() if row[13] else None,
+    }
+
+
+def list_promotions(status: str = "pending", limit: int = 20) -> list[dict]:
+    """List feedback promotions by status."""
+    import json
+
+    sql = """
+    SELECT p.id::text, p.feedback_event_id::text, p.curator_id, p.curator_notes,
+           p.promoted_content, p.status, p.applied_at, p.created_at,
+           e.query, e.feedback_type
+    FROM feedback_promotions p
+    JOIN feedback_events e ON e.id = p.feedback_event_id
+    WHERE p.status = %s
+    ORDER BY p.created_at DESC
+    LIMIT %s
+    """
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(sql, (status, limit))
+            rows = cur.fetchall()
+
+    out = []
+    for row in rows:
+        out.append({
+            "id": row[0],
+            "feedback_event_id": row[1],
+            "curator_id": row[2],
+            "curator_notes": row[3],
+            "promoted_content": row[4] if isinstance(row[4], dict) else json.loads(row[4] or "{}"),
+            "status": row[5],
+            "applied_at": row[6].isoformat() if row[6] else None,
+            "created_at": row[7].isoformat() if row[7] else None,
+            "query": row[8],
+            "feedback_type": row[9],
+        })
+    return out

package/knowledge_base/db/igel_schema.py

@@ -0,0 +1,150 @@
+"""
+Enterprise Schema for IGEL QE Agent
+===================================
+Manages tables for the AI Platform Layer:
+- Automation Asset Registry (Code Intelligence)
+- Requirement Tracking (Xray integration)
+- Granular Feedback (4-level precision)
+- Regression Intelligence (Impact mappings)
+"""
+from __future__ import annotations
+
+import logging
+from knowledge_base.db.client import get_conn
+from knowledge_base.config import cfg
+
+logger = logging.getLogger(__name__)
+
+_IGEL_SCHEMA_SQL = f"""
+-- Enable extensions if not already present
+CREATE EXTENSION IF NOT EXISTS vector;
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+-- ==========================================
+-- 1. Automation Asset Registry
+-- ==========================================
+CREATE TABLE IF NOT EXISTS igel_asset_registry (
+    id              UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    asset_type      TEXT NOT NULL, -- 'page_object', 'fixture', 'utility', 'api_client', 'base_class'
+    name            TEXT NOT NULL,
+    file_path       TEXT NOT NULL,
+    description     TEXT,          -- Docstring or AI summary
+    signature       TEXT,          -- Class/Function signature
+    dependencies    JSONB DEFAULT '[]'::jsonb, -- Other assets this depends on
+    embedding       VECTOR({cfg.EMBEDDING_DIM}),
+    file_hash       TEXT,
+    last_indexed    TIMESTAMP DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS asset_type_idx ON igel_asset_registry(asset_type);
+
+-- ==========================================
+-- 2. Requirement Modeling & Understanding
+-- ==========================================
+CREATE TABLE IF NOT EXISTS igel_requirements (
+    id              UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    jira_key        TEXT UNIQUE NOT NULL,
+    summary         TEXT NOT NULL,
+    description     TEXT,
+    labels          JSONB DEFAULT '[]'::jsonb,
+    components      JSONB DEFAULT '[]'::jsonb,
+    status          TEXT,
+    created_at      TIMESTAMP DEFAULT NOW()
+);
+
+-- AI Extracted Understanding
+CREATE TABLE IF NOT EXISTS igel_requirement_understanding (
+    id              UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    requirement_id  UUID NOT NULL REFERENCES igel_requirements(id) ON DELETE CASCADE,
+    actors          JSONB DEFAULT '[]'::jsonb,
+    entities        JSONB DEFAULT '[]'::jsonb,
+    validations     JSONB DEFAULT '[]'::jsonb,
+    constraints     JSONB DEFAULT '[]'::jsonb,
+    dependencies    JSONB DEFAULT '[]'::jsonb,
+    analyzed_at     TIMESTAMP DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS igel_scenarios (
+    id              UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    requirement_id  UUID NOT NULL REFERENCES igel_requirements(id) ON DELETE CASCADE,
+    step_number     INT NOT NULL,
+    action          TEXT NOT NULL,
+    test_data       TEXT,
+    expected_result TEXT,
+    created_at      TIMESTAMP DEFAULT NOW(),
+    UNIQUE(requirement_id, step_number)
+);
+
+CREATE TABLE IF NOT EXISTS igel_business_rules (
+    id              UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    scenario_id     UUID NOT NULL REFERENCES igel_scenarios(id) ON DELETE CASCADE,
+    rule_type       TEXT NOT NULL, -- 'positive', 'negative', 'edge'
+    description     TEXT NOT NULL,
+    created_at      TIMESTAMP DEFAULT NOW()
+);
+
+-- ==========================================
+-- 3. Test Cases & Generation Artifacts
+-- ==========================================
+CREATE TABLE IF NOT EXISTS igel_generated_testcases (
+    id              UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    tc_reference    TEXT UNIQUE NOT NULL, -- e.g., 'TC_IGEL-1234_S01_B01'
+    business_rule_id UUID NOT NULL REFERENCES igel_business_rules(id) ON DELETE CASCADE,
+    title           TEXT NOT NULL,
+    test_type       TEXT NOT NULL,
+    priority        TEXT NOT NULL,
+    preconditions   JSONB DEFAULT '[]'::jsonb,
+    steps           JSONB DEFAULT '[]'::jsonb,
+    confidence_score FLOAT NOT NULL,
+    confidence_metrics JSONB NOT NULL, -- Breakdown (coverage, traceability, etc.)
+    status          TEXT DEFAULT 'pending_review', -- 'pending_review', 'approved', 'rejected'
+    created_at      TIMESTAMP DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS igel_automation_scripts (
+    id              UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    requirement_id  UUID NOT NULL REFERENCES igel_requirements(id) ON DELETE CASCADE,
+    script_path     TEXT NOT NULL,
+    automation_plan JSONB NOT NULL, -- The JSON plan from Design Agent
+    code_content    TEXT NOT NULL,
+    validation_status TEXT DEFAULT 'pending', -- 'pending', 'syntax_failed', 'import_failed', 'passed'
+    created_at      TIMESTAMP DEFAULT NOW()
+);
+
+-- ==========================================
+-- 4. Regression Intelligence (Impact Analysis)
+-- ==========================================
+CREATE TABLE IF NOT EXISTS igel_asset_mappings (
+    id              UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    requirement_id  UUID NOT NULL REFERENCES igel_requirements(id) ON DELETE CASCADE,
+    asset_id        UUID NOT NULL REFERENCES igel_asset_registry(id) ON DELETE CASCADE,
+    mapping_type    TEXT NOT NULL, -- 'required_for_test', 'used_in_script'
+    created_at      TIMESTAMP DEFAULT NOW()
+);
+
+-- ==========================================
+-- 5. Granular Human Feedback
+-- ==========================================
+CREATE TABLE IF NOT EXISTS igel_granular_feedback (
+    id              UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    level           TEXT NOT NULL, -- 'requirement', 'scenario', 'testcase', 'teststep'
+    target_id       TEXT NOT NULL, -- The UUID of the target entity
+    feedback_type   TEXT NOT NULL, -- 'correction', 'rejection', 'enhancement', 'approval'
+    user_comment    TEXT,
+    corrected_data  JSONB,         -- The explicit fix applied by the user
+    applied         BOOLEAN DEFAULT FALSE,
+    created_at      TIMESTAMP DEFAULT NOW()
+);
+"""
+
+def ensure_igel_tables():
+    """Create IGEL enterprise tables if they don't exist."""
+    try:
+        with get_conn() as conn:
+            with conn.cursor() as cur:
+                cur.execute(_IGEL_SCHEMA_SQL)
+            conn.commit()
+        logger.info("IGEL Enterprise DB schema verified.")
+    except Exception as e:
+        logger.error(f"Failed to create IGEL schema: {{e}}")
+        raise