added questionnaire

README.md

@@ -7,12 +7,24 @@ sdk: docker
 pinned: false
 ---
 
-# AI Consultant Chatbot
+# Stacklogix Consultant Chatbot
 
-A domain-agnostic consulting chatbot powered by LangGraph + Groq (Llama 3.3 70B).
+A consultant-style chatbot for **Stacklogix** that gathers client requirements and explains how Stacklogix will address their needs. Powered by LangGraph + Groq (Llama 3.3 70B). Designed to be embedded on the Stacklogix website where clients interact with it instead of a sales representative.
 
 ## Features
-- Multi-turn diagnostic conversations
-- 5-phase consulting flow (Discovery → Exploration → Constraints → Solution → Refinement)
-- Detailed, actionable final recommendations
-- Session management with SQLite persistence
+
+- **Dual mode**: Handles both **clear requests** (e.g. build a chatbot, build a dashboard) and **problems or vague situations** (e.g. inventory moving slowly, issues with an existing project).
+- **Structured requirement collection**: Asks relevant questions (e.g. type of deliverable, data and format, behavior, look and feel, constraints, expectations) in a natural, consultant-like flow.
+- **Consultant-style explanations**: Explains how the problem will be addressed, high-level implementation or solution steps, and what the company will do to deliver or resolve the issue (and, for problems, prevent recurrence).
+- **Domain-agnostic**: Works across technology, operations, business processes, inventory, and any other domain.
+- **5-phase flow**: Discovery → Exploration → Constraints → Solution → Refinement, with session management and SQLite persistence.
+
+## Flow
+
+1. **Discovery** — Understand what the client wants or what is going wrong.
+2. **Exploration** — Gather requirements: data, format, behavior, look, constraints, success criteria.
+3. **Constraints** — Confirm understanding and explain the proposed approach.
+4. **Solution** — Summarize needs, how you will address it, steps, and what you will deliver.
+5. **Refinement** — Full proposal, implementation steps, and next steps.
+
+Clients can start with a clear request (“we want to build X”) or a problem (“Y isn’t working”); the chatbot adapts its questions and explanations accordingly.

backend/app.py

@@ -40,15 +40,11 @@ from graph import run_consultation
 # ---------------------------------------------------------------------------
 
 GREETING_MESSAGE = (
-    "**Welcome! I'm your AI consultant.** 👋\n\n"
-    "I help people think through complex problems — whether it's "
-    "**business strategy, product design, technical architecture, operations, "
-    "or anything else.**\n\n"
-    "Here's how our conversation will work:\n"
-    "- You describe your challenge or goal\n"
-    "- I'll ask smart, targeted questions — and share insights along the way\n"
-    "- Together, we'll converge on a clear, actionable solution\n\n"
-    "**So — what's on your mind? What problem are you trying to solve?**"
+    "**Welcome to Stacklogix.** I'm your consultant for this session. 👋\n\n"
+    "Whether you have a **clear request** (e.g. build a product or fix an issue) or a **problem** "
+    "(e.g. something isn't working as you'd like), I'll ask a few questions to understand your needs. "
+    "Our team will then follow up with you.\n\n"
+    "**What would you like to achieve or what do you need help with?**"
 )
 
 
@@ -63,8 +59,8 @@ async def lifespan(app: FastAPI):
 
 
 app = FastAPI(
-    title="Consultant Chatbot API",
-    description="Domain-agnostic consulting chatbot powered by LangGraph + Groq",
+    title="Stacklogix Consultant Chatbot API",
+    description="Stacklogix requirement-collection chatbot — gathers client requirements and explains how Stacklogix will address them. LangGraph + Groq.",
     version="1.0.0",
     lifespan=lifespan,
 )
@@ -155,7 +151,7 @@ async def remove_session(session_id: str):
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy", "service": "consultant-chatbot"}
+    return {"status": "healthy", "service": "stacklogix-chatbot"}
 
 
 # ---------------------------------------------------------------------------

backend/graph.py

@@ -1,14 +1,14 @@
-"""LangGraph-based consultation state machine.
+"""LangGraph-based requirement-collection consultation state machine.
 
-Implements a 5-phase consulting flow controlled by a confidence score.
+Implements a 5-phase flow (Discovery → Exploration → Constraints → Solution → Refinement)
+controlled by confidence. Supports both clear requests (e.g. build X) and problems (e.g. Y is wrong).
 
 CODE-LEVEL QUALITY ENFORCEMENT:
-- Simplified question category tracker (3 categories instead of 6)
-- Anti-repetition engine: detects sentence overlap and forces re-generation
-- Anti-hallucination check: verifies claims against conversation history
-- Deferral counter: tracks "I don't know" responses and switches to advice mode
-- Turn-aware instructions: adjusts behavior based on conversation stage
-- Understanding validation: ensures the LLM doesn't fabricate facts
+- Requirement-oriented question categories (scope, what they have, behavior/look, success)
+- Anti-repetition: sentence overlap detection and re-generation
+- Anti-hallucination: verifies claims against conversation history
+- Deferral counter: "I don't know" → switch to proposal mode
+- Turn-aware instructions and understanding validation
 """
 
 from __future__ import annotations
@@ -22,7 +22,28 @@ from langchain_core.messages import HumanMessage, SystemMessage
 
 from llm import llm
 from models import Message, Phase, SessionState, PHASE_ORDER, PHASE_THRESHOLDS
-from prompts import PHASE_PROMPTS
+from prompts import PHASE_PROMPTS, QUESTIONNAIRE_SECTIONS, CURRENT_SECTION_PLACEHOLDER
+
+
+# ---------------------------------------------------------------------------
+# Questionnaire-driven section progression (same intent → same question order)
+# ---------------------------------------------------------------------------
+
+def _current_section_index(questions_asked: int) -> int:
+    """Section index 0..10 from number of questions asked. ~2 questions per section."""
+    return min(questions_asked // 2, len(QUESTIONNAIRE_SECTIONS) - 1)
+
+
+def _build_section_block(section_index: int) -> str:
+    """Build the 'Current section' block to inject into the prompt."""
+    num, title, intents = QUESTIONNAIRE_SECTIONS[section_index]
+    intents_str = "\n".join(f"- {i}" for i in intents)
+    return (
+        f"Current section: Section {num} — {title}\n"
+        f"Question intents to cover (adapt to domain and conversation):\n"
+        f"{intents_str}\n"
+        f"If the client has ALREADY answered these intents earlier in the conversation, skip this section or ask only what's missing, then move to the next section.\n"
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -39,79 +60,20 @@ class GraphState(TypedDict):
 
 
 # ---------------------------------------------------------------------------
-# Question Category Tracking System (SIMPLIFIED)
+# Wrap-up guidance (when to ask "Is there anything else?")
 # ---------------------------------------------------------------------------
 
-# Only 3 broad categories — enough to guide without forcing deep dives
-QUESTION_CATEGORIES = {
-    "business_basics": {
-        "label": "Business Basics",
-        "description": "What they do, what they sell/offer, rough scale",
-        "keywords": ["sell", "product", "service", "business", "store", "shop",
-                     "company", "revenue", "team", "employee", "people",
-                     "industry", "offer", "work", "startup", "project"],
-        "prompt": "You could ask about their business basics — what they do, how big the operation is.",
-    },
-    "problem_details": {
-        "label": "Problem Details",
-        "description": "What exactly is going wrong, since when, how bad",
-        "keywords": ["problem", "issue", "challenge", "slow", "decline",
-                     "month", "year", "since", "affect", "impact",
-                     "drop", "worse", "bad", "struggle", "difficult"],
-        "prompt": "You could ask more about the problem — what exactly is happening, how long, how bad.",
-    },
-    "data_and_attempts": {
-        "label": "Data & Past Attempts",
-        "description": "Where their data lives and what they've tried already",
-        "keywords": ["data", "excel", "spreadsheet", "track", "record",
-                     "tried", "attempt", "before", "already", "didn't work",
-                     "keep", "stored", "written", "noted", "logged"],
-        "prompt": "IMPORTANT: You haven't asked where they keep their data yet. Ask how they track or record their business info (Excel, notebook, software, etc.).",
-    },
-}
-
-
-def _detect_covered_categories(messages: list[Message]) -> dict[str, bool]:
-    """Analyze conversation to determine which question categories have been covered."""
-    covered = {cat: False for cat in QUESTION_CATEGORIES}
-
-    all_text = " ".join(msg.content.lower() for msg in messages)
-
-    for cat_id, cat_info in QUESTION_CATEGORIES.items():
-        keyword_hits = sum(1 for kw in cat_info["keywords"] if kw in all_text)
-        # Need at least 2 keyword hits to consider a category covered
-        if keyword_hits >= 2:
-            covered[cat_id] = True
-
-    return covered
-
-
-def _build_category_guidance(covered: dict[str, bool], turn_number: int) -> str:
-    """Build a SOFT guidance block — suggestions, not demands."""
-    uncovered = [
-        QUESTION_CATEGORIES[cat]["prompt"]
-        for cat, is_covered in covered.items()
-        if not is_covered
-    ]
-
-    if not uncovered:
-        return "\nYou've gathered enough info. Focus on giving RECOMMENDATIONS now.\n"
-
-    # Soft suggestion — max 1 at a time to avoid overwhelming
-    guidance = "\n💡 Suggestion — if relevant, you might want to ask about:\n"
-    guidance += f"  → {uncovered[0]}\n"
-
-    covered_list = [
-        QUESTION_CATEGORIES[cat]["label"]
-        for cat, is_covered in covered.items()
-        if is_covered
-    ]
-    if covered_list:
-        guidance += f"\n🚫 ALREADY COVERED (do NOT ask about these again): {', '.join(covered_list)}\n"
-
-    guidance += "\nBut ONLY ask if it naturally follows from what the client just said. Do NOT force it.\n"
-
-    return guidance
+def _build_wrap_up_guidance(questions_asked: int, messages: list[Message], section_index: int) -> str:
+    """Tell the bot when to keep gathering vs when to ask 'Is there anything else?'"""
+    if _can_wrap_up(questions_asked, messages):
+        return "\nYou've gathered enough info. Ask: 'Is there anything else you'd like to add?' Only that — no proposal or solution.\n"
+    section_num = section_index + 1
+    total_sections = len(QUESTIONNAIRE_SECTIONS)
+    return (
+        f"\nKeep gathering. You are on section {section_num} of {total_sections} (follow the questionnaire in order). "
+        f"Do NOT ask 'Is there anything else?' until you have gone through ALL 11 sections (through Section 11 - Open Ends) "
+        f"and asked at least {MIN_QUESTIONS_BEFORE_WRAP_UP} questions. You have asked {questions_asked} so far.\n"
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -184,8 +146,6 @@ def _has_asked_about_data(messages: list[Message]) -> bool:
     for msg in messages:
         if msg.role == "assistant" and "?" in msg.content:
             content_lower = msg.content.lower()
-            # Check each question sentence specifically
-            # Split on ? to get question fragments
             question_parts = content_lower.split("?")
             for part in question_parts:
                 for pattern in DATA_STORAGE_QUESTION_PATTERNS:
@@ -194,6 +154,39 @@ def _has_asked_about_data(messages: list[Message]) -> bool:
     return False
 
 
+# Require ALL 11 sections before wrap-up
+MIN_QUESTIONS_BEFORE_WRAP_UP = 22  # ~2 per section so we reach Section 11
+MIN_SECTION_BEFORE_WRAP_UP = 10    # Section 11 (Open Ends) — must complete all sections
+
+
+def _can_wrap_up(questions_asked: int, messages: list[Message]) -> bool:
+    """True only after we've gone through ALL 11 questionnaire sections (no early exit)."""
+    section_index = _current_section_index(questions_asked)
+    # Must reach Section 11 (Open Ends, index 10) and ask at least 22 questions
+    return (
+        questions_asked >= MIN_QUESTIONS_BEFORE_WRAP_UP
+        and section_index >= MIN_SECTION_BEFORE_WRAP_UP
+    )
+
+
+def _user_has_said_where_data_is(messages: list[Message]) -> bool:
+    """True if the user has already said where they keep their data (spreadsheet, database, etc.)."""
+    data_location_words = [
+        "spreadsheet", "database", "excel", "notebook", "paper", "software",
+        "app", "system", "cloud", "computer", "file", "files",
+    ]
+    for msg in messages:
+        if msg.role != "user":
+            continue
+        lower = msg.content.lower().strip()
+        # Short reply that looks like an answer (e.g. "spreadsheet", "database")
+        if len(lower) < 80 and any(w in lower for w in data_location_words):
+            return True
+        if any(w in lower for w in data_location_words) and ("keep" in lower or "store" in lower or "track" in lower or "use" in lower or "in " in lower):
+            return True
+    return False
+
+
 def _check_repetition(new_reply: str, previous_replies: list[str]) -> float:
     """Check sentence-level overlap with previous replies. Returns 0.0-1.0."""
     if not previous_replies:
@@ -235,39 +228,37 @@ def _check_repetition(new_reply: str, previous_replies: list[str]) -> float:
 # Reply quality enforcement (code-level, can't be bypassed by LLM)
 # ---------------------------------------------------------------------------
 
-# Patterns that indicate the bot is asking the client to solve their own problem
-SELF_SOLVING_PATTERNS = [
-    r"what do you think is (?:the |)(?:main |primary |root |)(?:reason|cause|issue)",
-    r"what do you (?:think|believe|feel) (?:is |might be |could be |)",
-    r"how do you think .+ could help",
-    r"what would you (?:like|want|suggest|recommend)",
-    r"do you have any (?:idea|thoughts|theories) (?:on |about |why )",
-    r"why do you think",
-    r"what do you attribute .+ to",
-    r"have you (?:considered|thought about) (?:the role of|how|why|whether)",
-    r"have you (?:considered|thought about) (?:offering|changing|trying|implementing)",
-    # Catch ANY question with "you think" in it
-    r"\?.*you think",
-    r"you think.+\?",
-    r"(?:reason|cause)\s+you\s+think",
-    r"what role (?:do you think |does |)",
-    # "What are your thoughts/take/opinion on" patterns
-    r"what (?:are |)your (?:thoughts|take|opinion) on",
-    r"your thoughts on .+\?",
+# Budget / timeline — NEVER ask (policy)
+BUDGET_TIMELINE_PATTERNS = [
+    r"budget",
+    r"timeline",
+    r"when (?:do you |would you |)need (?:it|this|the)",
+    r"deadline",
+    r"how (?:much |long |)(?:time|money)",
+    r"expected (?:timeline|date|duration)",
+    r"time (?:frame|line|scale)",
+    r"(?:within|in) (?:how many|what) (?:weeks|months|days)",
+    r"expectations? (?:for|about) (?:the )?timeline",
 ]
 
-# Patterns that suggest causes disguised as questions
-CAUSE_SUGGESTING_PATTERNS = [
-    r"have you noticed any changes in .+(?:demand|market|trend|preference|competition)",
-    r"could (?:it|this) be (?:related to|because of|due to)",
-    r"do you think .+(?:might be|could be) (?:causing|contributing|leading)",
-    r"is it possible that .+(?:demand|pricing|competition|market)",
-    r"(?:the role of|due to) (?:pricing|marketing|product presentation|competition)",
-    r"(?:external factors|market trends|consumer behavior).+(?:impact|affect|contribut)",
-    r"(?:changes in|shifts in) (?:consumer|customer|market|buying) (?:behavior|preference|demand|pattern)",
-    # Listing generic causes
-    r"(?:such as|like|including) (?:low |high |ineffective |poor ).*(?:demand|pric|market|competit)",
-    r"(?:due to|because of) (?:various|several|multiple) factors",
+# Policy-only checks: budget/timeline and tech. All other behavior is guided by prompts and LLM context.
+# Non-tech client: no "involvement", "development", "implementation", "progress updates", "system design"
+TECH_PROCESS_PATTERNS = [
+    r"involved in (?:the |)(?:development|implementation)",
+    r"involvement in (?:development|implementation|design)",
+    r"progress updates?",
+    r"regular (?:meetings?|updates?)",
+    r"system design",
+    r"input on (?:system |)(?:design|implementation)",
+    r"project management (?:portal|tool)",
+    r"preferred method for (?:receiving|getting) (?:updates?|progress)",
+    r"receiving (?:progress )?updates?",
+    r"providing input on",
+    r"implementation (?:of the |)(?:system|solution)",
+    r"development and implementation",
+    r"first meeting to discuss (?:project|details|expectations)",
+    r"ready to proceed",
+    r"prioritize .*(?:goals?|objectives?)",
 ]
 
 # Filler SENTENCES that should be stripped from ANYWHERE in the response
@@ -279,16 +270,15 @@ FILLER_SENTENCES = [
     # "I'd love to" filler
     r"i'd love to (?:learn|help|explore|understand|hear|know|dig)",
     r"i'd like to (?:learn|help|explore|understand|hear|know|dig)",
-    # Restating the problem robotically
-    r"a slow[- ]moving inventory (?:of|can be)",
+    # Restating the problem robotically (domain-agnostic)
     r"(?:can be|is) a (?:challenging|significant|difficult|tough|particularly challenging|common) (?:issue|problem|situation|challenge)",
     r"(?:this|it) can be a (?:common|challenging|significant) (?:issue|problem|situation)",
-    r"especially (?:given|with) the (?:high value|constantly changing|luxury|competitive)",
-    r"especially given the high value and luxury nature",
-    r"(?:diamond|jewelry) (?:rings? (?:are|is)|market can be) (?:often |)(?:purchased|subject to|a high)",
-    r"are often purchased for special occasions",
-    r"the quality and characteristics of the diamonds",
-    r"the diamond (?:market|ring market|industry) can be",
+    r"especially (?:given|with) the (?:high value|constantly changing|competitive)",
+    r"especially given the (?:high value|unique|complex) (?:nature|aspects)",
+    r"(?:market|industry) can be (?:often |)(?:subject to|a (?:high|competitive))",
+    r"are often (?:purchased|used|needed) for (?:special |)(?:occasions|reasons)",
+    r"the (?:quality and )?characteristics of the",
+    r"the (?:market|industry) can be",
     r"it's likely that this is affecting",
     r"this (?:can|may|might) (?:be|also be) (?:affecting|impacting|taking)",
     # Robotic transitions
@@ -308,6 +298,11 @@ FILLER_SENTENCES = [
     r"given the (?:specifics|broad range|unique aspects|diverse nature|complexity)",
     r"to better understand (?:the scope|your situation|the issue|your)",
     r"this (?:is a good starting point|indicates you have)",
+    r"it'?s possible that .+(?:could be|might be|is)",
+    r"(?:could be|might be) (?:impacting|affecting|contributing)",
+    r"(?:understanding|this information) (?:the specifics|helps us understand)",
+    r"can (?:help|provide) (?:identify|valuable insights)",
+    r"understanding the (?:current state|specifics) .+ (?:can provide|can help)",
     r"i'm excited to learn more",
     r"i'm looking forward to",
     r"understanding (?:your|the) specific",
@@ -336,6 +331,14 @@ FILLER_SENTENCES = [
     r"it(?:'s| is) great that you(?:'ve| have)",
     # "You've just started our conversation"
     r"you(?:'ve| have) just started",
+    # Solution pitching — requirement gathering only
+    r"our approach (?:at |)stacklogix (?:involves|would involve|will involve)",
+    r"stacklogix will (?:develop|implement|provide|deliver)",
+    r"how we will address (?:it|this)",
+    r"what we will deliver",
+    r"implementation (?:of a |)(?:robust |)(?:management |)system",
+    r"key components? of the solution",
+    r"we will (?:develop|implement|provide|schedule|work closely)",
 ]
 
 # Section headers that create robotic formatting
@@ -347,31 +350,28 @@ RECAP_HEADERS = [
 
 
 def _detect_bad_question_patterns(reply: str) -> str | None:
-    """Detect self-solving and cause-suggesting questions.
+    """Detect self-solving, cause-suggesting, budget/timeline, or technical process questions.
     
     Returns a correction instruction if bad patterns found, None otherwise.
     """
     reply_lower = reply.lower()
     
-    for pattern in SELF_SOLVING_PATTERNS:
+    # Only enforce hard policy via patterns; let the LLM handle the rest from conversation context.
+    for pattern in BUDGET_TIMELINE_PATTERNS:
         if re.search(pattern, reply_lower):
             return (
-                "⚠️ You asked the client to diagnose their own problem. "
-                "YOU are the consultant — YOU figure out the cause. "
-                "Instead, ask a SPECIFIC diagnostic question that helps you "
-                "narrow down the cause yourself. For example, ask about "
-                "specifics of the problem, not what they think is causing it."
+                "⚠️ You must NOT ask about budget or timeline. "
+                "Remove any question about when they need it, deadlines, or cost. Ask something else from the questionnaire in plain words."
             )
-    
-    for pattern in CAUSE_SUGGESTING_PATTERNS:
+
+    for pattern in TECH_PROCESS_PATTERNS:
         if re.search(pattern, reply_lower):
             return (
-                "⚠️ You suggested possible causes IN your question. "
-                "Don't lead the client toward causes you've assumed. "
-                "Ask a NEUTRAL question that lets them describe their "
-                "situation without your bias."
+                "⚠️ The client is non-technical. Do NOT ask about involvement in development, "
+                "progress updates, system design, project management, or implementation. "
+                "Ask a simple, plain-language question from the current section."
             )
-    
+
     return None
 
 
@@ -469,6 +469,85 @@ def _break_wall_of_text(reply: str) -> str:
     return "\n\n".join(result)
 
 
+def _strip_observation_blocks(reply: str) -> str:
+    """Remove 'Key Observations', 'Understanding the situation', and similar blocks with bullet lists.
+    
+    Keep only short acknowledgment and questions. Skip until we see a question line.
+    """
+    lines = reply.split("\n")
+    result = []
+    in_observation_block = False
+    
+    for line in lines:
+        stripped = line.strip()
+        # Start of an observation/recap block (bold header, no question)
+        if re.match(r"^\*\*(?:key observations?|understanding the situation|key points?|current (?:understanding|situation)|summary)\s*", stripped, re.IGNORECASE) and "?" not in stripped:
+            in_observation_block = True
+            continue
+        # While in block: skip bullets and any non-question line (transition sentences, etc.)
+        if in_observation_block:
+            if stripped.startswith("-") or stripped.startswith("*") or re.match(r"^[\d]+[.)]\s", stripped):
+                continue
+            if "?" not in stripped:
+                continue
+            in_observation_block = False
+        result.append(line)
+    
+    text = "\n".join(result)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def _extract_question_sentences(text: str) -> list[str]:
+    """Get lines or sentence fragments that contain a question mark (normalized for comparison)."""
+    questions = []
+    for line in text.split("\n"):
+        part = line.strip().lower()
+        if "?" in part and len(part) > 15:
+            questions.append(part)
+    return questions
+
+
+def _check_question_repetition(new_reply: str, previous_replies: list[str]) -> bool:
+    """True if the new reply asks something very similar to a previous reply's question."""
+    new_qs = _extract_question_sentences(new_reply)
+    if not new_qs:
+        return False
+    all_prev_qs = []
+    for prev in previous_replies:
+        all_prev_qs.extend(_extract_question_sentences(prev))
+    if not all_prev_qs:
+        return False
+    for nq in new_qs:
+        for pq in all_prev_qs:
+            if SequenceMatcher(None, nq, pq).ratio() > 0.55:
+                return True
+    return False
+
+
+def _ensure_text_before_questions(reply: str) -> str:
+    """If the reply starts with a question (no preceding acknowledgment), prepend a short line."""
+    stripped = reply.strip()
+    if not stripped:
+        return reply
+    # Find first line that contains ?
+    lines = stripped.split("\n")
+    first_question_idx = None
+    for i, line in enumerate(lines):
+        if "?" in line and len(line.strip()) > 5:
+            first_question_idx = i
+            break
+    if first_question_idx is None:
+        return reply
+    # Is there any non-empty, non-question text before the first question?
+    text_before = "\n".join(lines[:first_question_idx]).strip()
+    text_before = re.sub(r"\*\*[^*]+\*\*", "", text_before).strip()  # remove bold markers for length check
+    if len(text_before) < 50:  # require at least ~2 sentences of context before first question
+        lines.insert(0, "Thanks for sharing that.")
+        return "\n".join(lines).strip()
+    return reply
+
+
 def _format_questions(reply: str) -> str:
     """Ensure each question is on its own paragraph with blank lines around it.
     
@@ -618,12 +697,17 @@ def _build_message_list(state: SessionState, user_message: str) -> list:
             # Keep the conversation history but mark the new topic
             state.understanding = state.understanding + f"\n\n--- NEW TOPIC: {user_message} ---\n" if state.understanding else ""
 
-    # --- HARD PHASE FORCING — guarantee we reach recommendations ---
-    # Use RELATIVE turn count (turns since current topic started)
+    # --- HARD PHASE FORCING — require minimum 10 questions (or lots of client info) before wrap-up ---
     topic_turns = turn_number - state.topic_start_turn
     current_phase = state.phase
     current_confidence = state.confidence
-    if topic_turns >= 12 and current_phase != Phase.REFINEMENT:
+    if not _can_wrap_up(questions_asked, state.messages) and current_phase in (Phase.SOLUTION, Phase.REFINEMENT):
+        # Keep in EXPLORATION until we've asked at least 10 questions (or client gave lots of info)
+        current_phase = Phase.EXPLORATION
+        current_confidence = min(current_confidence, 0.5)
+        state.phase = current_phase
+        state.confidence = current_confidence
+    elif topic_turns >= 12 and current_phase != Phase.REFINEMENT:
         current_phase = Phase.REFINEMENT
         current_confidence = max(current_confidence, 0.85)
         state.phase = current_phase
@@ -640,56 +724,66 @@ def _build_message_list(state: SessionState, user_message: str) -> list:
         phase_prompt = TURN_1_PROMPT
     else:
         phase_prompt = PHASE_PROMPTS[current_phase].format(confidence=current_confidence)
+        # Inject current questionnaire section so the same intent leads to the same question order
+        section_index = _current_section_index(questions_asked)
+        if current_phase in (Phase.DISCOVERY, Phase.EXPLORATION, Phase.CONSTRAINTS):
+            phase_prompt = phase_prompt.replace(CURRENT_SECTION_PLACEHOLDER, _build_section_block(section_index))
+        else:
+            phase_prompt = phase_prompt.replace(CURRENT_SECTION_PLACEHOLDER, "(Wrapping up — ask if there is anything else.)")
 
     # Add understanding context (validated)
     if state.understanding:
         phase_prompt += (
-            f"\n\nCLIENT INFO (for YOUR reference only — do NOT summarize or repeat this back to the client):"
+            f"\n\nCLIENT INFO (for YOUR reference only — do NOT copy this back to the client):"
             f"\n{state.understanding}\n"
-            f"IMPORTANT: Do NOT start your response by restating what you know about the client. "
-            f"Jump STRAIGHT into new insights, analysis, or questions.\n"
+            f"Do NOT list 'Key Points', 'Summary', or 'How we will address it'. Just ask your next question(s) in simple words.\n"
         )
+    # Remind LLM to use the full conversation (messages below) to adapt and improve
+    if turn_number > 1:
+        phase_prompt += "\nThe messages below are the full conversation. Use them to understand what the client said and what you already asked; avoid repeating, infer context, and choose the next 1–2 questions that add the most value.\n"
 
     # --- CONVERSATION STATS ---
     stats = f"\nTurn {turn_number} | {questions_asked} questions asked so far | {deferral_count} deferrals\n"
+    sec_idx = _current_section_index(questions_asked)
+    if not _can_wrap_up(questions_asked, state.messages):
+        stats += f"Follow the questionnaire: you are on section {sec_idx + 1} of {len(QUESTIONNAIRE_SECTIONS)}. Do NOT ask 'Is there anything else?' until you have completed ALL 11 sections and asked at least {MIN_QUESTIONS_BEFORE_WRAP_UP} questions.\n"
     phase_prompt += stats
 
-    # --- HARD DATA QUESTION ENFORCEMENT ---
-    # If the bot hasn't asked about data storage by turn 2, force it
-    if turn_number >= 3 and not _has_asked_about_data(state.messages):
+    # --- ANTI-REPEAT REMINDER --- Follow the current section only; do not repeat past topics
+    if turn_number >= 4:
+        phase_prompt += "\n⚠️ Do NOT repeat questions from earlier sections. Ask only from the current section above. If the client already answered or said 'I don't know', move to the next intent in the section or the next section.\n"
+    # --- "I ALREADY ANSWERED" --- Do not re-ask; move to next intent or section
+    if re.search(r"already (?:answered|said|mentioned|told)|i (?:already )?said (?:that )?(?:already )?|said (?:that )?already", user_msg_lower):
+        phase_prompt += "\n⚠️ The client said they already answered. Acknowledge briefly (e.g. 'Got it.') and move to the NEXT intent or next section. Do NOT ask the same or a similar question again.\n"
+
+    # --- DATA: do not repeat once they've said where data is (questionnaire Section 4 covers this) ---
+    if _user_has_said_where_data_is(state.messages):
         phase_prompt += """
-⚠️ MANDATORY: You have NOT yet asked where the client keeps their business data.
-ONE of your questions MUST be about how they track or record their business
-information. For example: "How do you keep track of all this — in a spreadsheet,
-a notebook, or some software?" This is critical for your recommendations.
-"""
-    elif turn_number > 1:
-        covered = _detect_covered_categories(state.messages)
-        category_guidance = _build_category_guidance(covered, turn_number)
-        phase_prompt += category_guidance
+⚠️ The client has ALREADY said where they keep their data (e.g. spreadsheet, database, notebook). Do NOT ask again about where it's stored, what it looks like, or where the file is. Continue with the current section or move on.\n"""
+    # --- WRAP-UP GUIDANCE (questionnaire sections drive what to ask; this only says when to end) ---
+    if turn_number > 1:
+        sec_idx = _current_section_index(questions_asked)
+        wrap_guidance = _build_wrap_up_guidance(questions_asked, state.messages, sec_idx)
+        phase_prompt += wrap_guidance
 
     # --- DYNAMIC BEHAVIORAL OVERRIDES ---
     if deferral_count >= 2:
         phase_prompt += """
-⚠️ THE USER SAID "I DON'T KNOW" MULTIPLE TIMES. They cannot answer more questions.
-SWITCH TO ADVICE MODE IMMEDIATELY:
-- STOP asking diagnostic questions. Give at most 1 simple yes/no question.
-- LEAD with YOUR specific recommendations: "Based on what you've told me, here's what I'd suggest..."
-- Make reasonable assumptions and state them.
-- Be SPECIFIC: name tools, methods, steps. No generic advice like "review your pricing".
-- You are the EXPERT — the client is paying YOU to figure it out.
+⚠️ THE USER SAID "I DON'T KNOW" MULTIPLE TIMES. Move on — do not keep asking that.
+- Skip that topic. Ask about a DIFFERENT requirement (e.g. where they keep their data, or what they want in simple terms).
+- Do NOT pitch a solution or explain "how we will address it". Just gather what you can and then ask "Is there anything else?"
 """
 
     # Question count limits only apply during diagnostic phases
     # In solution/final phases, the prompt itself handles question limits
     if state.phase in (Phase.DISCOVERY, Phase.EXPLORATION):
         if questions_asked >= 20:
-            phase_prompt += "\n⚠️ STOP ASKING. Give your recommendation NOW. Zero questions.\n"
+            phase_prompt += "\n⚠️ STOP ASKING. Ask only: 'Is there anything else you'd like to add?' Nothing else. No proposal.\n"
         elif questions_asked >= 14:
-            phase_prompt += "\nYou've asked enough questions. Shift to mostly advice, at most 1 question.\n"
+            phase_prompt += "\nYou've asked enough. Ask: 'Is there anything else you'd like to add?' Only that — no solution or approach.\n"
 
         if turn_number >= 8:
-            phase_prompt += "\n⚠️ Turn 8+. Give CONCRETE recommendations now. Reference details they shared.\n"
+            phase_prompt += "\n⚠️ Turn 8+. Ask 'Is there anything else you'd like to add?' Do NOT give a proposal or solution.\n"
 
     messages = [SystemMessage(content=phase_prompt)]
 
@@ -794,6 +888,38 @@ def _determine_phase(confidence: float) -> Phase:
     return Phase.DISCOVERY
 
 
+# Thank-you message when client says "no" to "Is there anything else?"
+THANK_YOU_MESSAGE = (
+    "Thank you. We have everything we need. Our team at Stacklogix will be in touch with you shortly."
+)
+
+# User said "no" / "nothing else" / "bye" to "Is there anything else?" — respond with thank-you ONCE, do not ask again
+ANYTHING_ELSE_NO_PATTERNS = [
+    r"^\s*no\s*$", r"^\s*nope\s*$", r"^\s*nothing\s*$",
+    r"^\s*that'?s? (?:all|it)\s*$", r"^\s*that is all\s*$",
+    r"^\s*no\s*,?\s*thanks?\s*$", r"^\s*thanks?\s*,?\s*that'?s? all\s*$",
+    r"^\s*(?:we'?re|i'?m) good\s*$", r"^\s*all good\s*$",
+    r"^\s*not really\s*$", r"^\s*nothing else\s*$",
+    r"^\s*no\s+not\s+at\s+all\s*$", r"^\s*not\s+at\s+all\s*$",
+    r"^\s*bye\s*$", r"^\s*i'?m\s+good\s*$", r"^\s*that'?s\s+it\s*$",
+]
+
+
+def _last_bot_asked_anything_else(messages: list[Message]) -> bool:
+    """True if the last assistant message asks 'anything else'."""
+    for msg in reversed(messages):
+        if msg.role == "assistant":
+            lower = msg.content.lower()
+            return "anything else" in lower or "anything more" in lower
+    return False
+
+
+def _user_said_no_to_anything_else(user_message: str) -> bool:
+    """True if user is saying no / nothing else."""
+    stripped = user_message.strip().lower()
+    return any(re.search(p, stripped, re.IGNORECASE) for p in ANYTHING_ELSE_NO_PATTERNS)
+
+
 # ---------------------------------------------------------------------------
 # Main graph execution
 # ---------------------------------------------------------------------------
@@ -801,6 +927,19 @@ def _determine_phase(confidence: float) -> Phase:
 async def run_consultation(session_state: SessionState, user_message: str) -> GraphState:
     """Run one turn of the consultation with quality enforcement."""
 
+    # 0. If bot just asked "Is there anything else?" and user said no → thank you and end
+    if session_state.messages and _last_bot_asked_anything_else(session_state.messages) and _user_said_no_to_anything_else(user_message):
+        session_state.messages.append(Message(role="user", content=user_message))
+        session_state.messages.append(Message(role="assistant", content=THANK_YOU_MESSAGE))
+        return GraphState(
+            session_state=session_state,
+            user_message=user_message,
+            assistant_reply=THANK_YOU_MESSAGE,
+            new_confidence=1.0,
+            new_understanding=session_state.understanding,
+            new_phase=Phase.REFINEMENT,
+        )
+
     # 1. Build messages with intelligence injection
     messages = _build_message_list(session_state, user_message)
     turn_number = _get_turn_number(session_state.messages)
@@ -809,17 +948,17 @@ async def run_consultation(session_state: SessionState, user_message: str) -> Gr
     response = await llm.ainvoke(messages)
     parsed = _parse_llm_output(response.content)
 
-    # 3. Anti-repetition check
+    # 3. Anti-repetition check (content and questions)
     previous_replies = _get_previous_bot_responses(session_state.messages)
     overlap = _check_repetition(parsed["reply"], previous_replies)
+    question_repeat = _check_question_repetition(parsed["reply"], previous_replies)
 
-    if overlap > 0.35 and previous_replies:
+    if (overlap > 0.35 or question_repeat) and previous_replies:
         anti_repeat_msg = SystemMessage(content=(
-            "⚠️ YOUR RESPONSE IS TOO SIMILAR TO A PREVIOUS ONE. The user will see "
-            "repeated content. Write something COMPLETELY DIFFERENT:\n"
-            "- Different opening, different observations, different questions\n"
-            "- Share a NEW insight you haven't mentioned\n"
-            "- Ask about a DIFFERENT topic entirely"
+            "⚠️ You are REPEATING yourself. Either your content or your questions are too similar to what you already asked.\n"
+            "The client has already answered (or said 'I don't know') to topics you've covered. Do NOT ask about those again.\n"
+            "Reply with ONLY 1-2 short sentences, then ask about something you have NOT asked yet (from the current questionnaire section), OR ask: 'Is there anything else you'd like to add?'\n"
+            "No 'Key Observations' or bullet lists. Just a short acknowledgment and one new question."
         ))
         messages.insert(-1, anti_repeat_msg)
         response = await llm.ainvoke(messages)
@@ -865,36 +1004,21 @@ async def run_consultation(session_state: SessionState, user_message: str) -> Gr
     non_q_lines = [line for line in reply_text.split("\n") if "?" not in line]
     non_q_content = "\n".join(non_q_lines).strip()
     
-    # SOLUTION/REFINEMENT phases need MUCH longer responses (detailed action plans)
+    # SOLUTION/REFINEMENT = only "Is there anything else?" — keep it short
     is_final_phase = session_state.phase in (Phase.SOLUTION, Phase.REFINEMENT)
-    min_length = 500 if is_final_phase else 200
+    min_length = 80 if is_final_phase else 120  # require at least 2-3 sentences before questions
     
     if len(non_q_content) < min_length:
         if is_final_phase:
             expand_msg = SystemMessage(content=(
-                "⚠️ Your response is FAR TOO SHORT for a final recommendation.\n"
-                "The client has been answering your questions — now DELIVER VALUE.\n"
-                "Your response MUST include ALL of these:\n"
-                "1. **Problem Summary** — 2-3 sentences about their specific situation\n"
-                "2. **Root Cause Analysis** — what you believe is causing the problem\n"
-                "3. **Step-by-Step Action Plan** with NUMBERED steps organized by timeline:\n"
-                "   - **Immediate (This Week):** 2-3 quick wins\n"
-                "   - **Short-Term (Next 2-4 Weeks):** 3-4 tactical changes\n"
-                "   - **Medium-Term (1-3 Months):** 2-3 strategic initiatives\n"
-                "4. **Expected Outcomes** — what results they can expect\n"
-                "Each step must name SPECIFIC tools, methods, platforms. NOT vague advice.\n"
-                "This response should be LONG and DETAILED — at least 300 words."
+                "⚠️ You must ONLY ask: 'Is there anything else you'd like to add?'\n"
+                "Do NOT give a summary, proposal, or 'how we will address it'. Requirement gathering only. Short reply with that one question."
             ))
         else:
             expand_msg = SystemMessage(content=(
-                "⚠️ Your response is TOO SHORT. The client is paying for expert analysis.\n"
-                "EXPAND your response to include:\n"
-                "- 1-2 opening sentences reacting to what they said\n"
-                "- A **bold header** like '**Key Observations**' followed by 3-4 bullet points\n"
-                "  with specific insights, industry knowledge, or patterns you've noticed\n"
-                "- 1-2 sentences of concrete recommendation or context\n"
-                "- THEN your question(s)\n"
-                "Total response before questions should be at least 5-8 sentences."
+                "⚠️ Your response is too short. You MUST include 2-3 sentences of acknowledgment before your question(s). "
+                "Briefly reflect what they said and why it matters for understanding their needs. Then ask your question(s). "
+                "Do NOT add 'Key Observations' or bullet lists. No single-line intros."
             ))
         messages.insert(-1, expand_msg)
         response = await llm.ainvoke(messages)
@@ -912,10 +1036,16 @@ async def run_consultation(session_state: SessionState, user_message: str) -> Gr
     # 3.9. Strip leading filler sentences (no LLM call)
     parsed["reply"] = _strip_filler_sentences(parsed["reply"])
 
-    # 3.10. Break wall-of-text responses into readable paragraphs
+    # 3.10. Strip "Key Observations" and similar observation/recap blocks
+    parsed["reply"] = _strip_observation_blocks(parsed["reply"])
+
+    # 3.10b. Ensure there is some text before the first question (no bare questions)
+    parsed["reply"] = _ensure_text_before_questions(parsed["reply"])
+
+    # 3.11. Break wall-of-text responses into readable paragraphs
     parsed["reply"] = _break_wall_of_text(parsed["reply"])
 
-    # 3.11. Ensure questions are properly formatted for frontend box styling
+    # 3.12. Ensure questions are properly formatted for frontend box styling
     parsed["reply"] = _format_questions(parsed["reply"])
 
     # 4. Confidence progression
@@ -933,12 +1063,17 @@ async def run_consultation(session_state: SessionState, user_message: str) -> Gr
     # 5. Route phase
     new_phase = _determine_phase(new_confidence)
 
-    # Phase forcing — use topic-relative turn count
+    # Phase forcing — require at least 10 questions (or lots of client info) before wrap-up
     topic_turns = turn_number - session_state.topic_start_turn
-    if topic_turns >= 12:
+    questions_after_this_turn = _count_bot_questions(session_state.messages) + parsed["reply"].count("?")
+    messages_incl_current = session_state.messages + [Message(role="user", content=user_message)]
+    if not _can_wrap_up(questions_after_this_turn, messages_incl_current) and new_phase in (Phase.SOLUTION, Phase.REFINEMENT):
+        new_phase = Phase.EXPLORATION
+        new_confidence = min(new_confidence, 0.5)
+    elif topic_turns >= 12 and _can_wrap_up(questions_after_this_turn, messages_incl_current):
         new_phase = Phase.REFINEMENT
         new_confidence = max(new_confidence, 0.85)
-    elif topic_turns >= 10 and new_phase in (Phase.DISCOVERY, Phase.EXPLORATION):
+    elif topic_turns >= 10 and _can_wrap_up(questions_after_this_turn, messages_incl_current) and new_phase in (Phase.DISCOVERY, Phase.EXPLORATION):
         new_phase = Phase.SOLUTION
         new_confidence = max(new_confidence, 0.65)
     # 6. Update understanding (with validation)

backend/prompts.py

@@ -1,106 +1,100 @@
-"""System prompts for each consultation phase.
+"""System prompts for requirement gathering only (no solution pitching).
 
 DESIGN PRINCIPLES:
-- Keep prompts short — the LLM follows fewer rules better
-- Ground every question in what the CLIENT actually said
-- Never let the bot invent facts the client didn't mention
-- Let the LLM generate questions naturally — no hardcoded examples
+- Pure requirement gathering: ask questions only. Do NOT explain approach, solution, or what Stacklogix will do.
+- Always cover DATA when relevant: where it is or would be stored, what form it is in (e.g. list, spreadsheet, paper, software) — adapt to the client's situation (any domain).
+- Never ask about budget or timeline.
+- Client is typically non-technical: ask simple, plain-language questions only. No "system design", "implementation", "progress updates", "involved in development".
+- When you have gathered enough, ask "Is there anything else you'd like to add?" If they say no, a thank-you will be sent.
 """
 
 from __future__ import annotations
 
 # ---------------------------------------------------------------------------
-# Core persona — short, strict, grounded
+# Universal questionnaire — fixed order (no budget/timeline). Same intent → same flow.
 # ---------------------------------------------------------------------------
 
-_PERSONA = """You are an expert business consultant — sharp, insightful, warm.
-
-STRICT RULES (violating ANY of these = failure):
-
-1. GROUNDING — NEVER invent, assume, or state facts the client hasn't told you.
-   If you don't know something, ASK — don't guess.
-
-2. QUESTION PRIORITY — Focus on understanding the PROBLEM first.
-   Before asking about operations, team, or processes, make sure you deeply
-   understand WHAT is going wrong and WHY. Dig into the problem itself:
-   - WHICH specific items/products/areas are affected?
-   - HOW MUCH — quantities, amounts, scale of the issue?
-   - SINCE WHEN — how long has this been happening?
-   - WHAT CHANGED — did something trigger it?
-   Ask these specifics BEFORE asking about how they track data or run operations.
-
-3. ASK SIMPLE QUESTIONS — Your questions must be easy for a non-technical person
-   to answer. Avoid jargon, technical terms, or metrics they wouldn't know.
-   Base your questions naturally on what the client just told you.
-
-4. NEVER ask the client to solve their own problem. YOU are the consultant —
-   it's YOUR job to diagnose, analyze, and recommend. Don't ask things like
-   "what do you think is causing this?" or "how do you think X could help?"
-
-5. Ask EXACTLY 1-2 questions per response. NEVER more than 2 question marks total.
-
-6. BANNED PHRASES — NEVER use these (instant failure):
-   - "I'm glad you shared" / "I'm glad you told me"
-   - "I'd love to learn more" / "I'd love to help"
-   - "a challenging issue to tackle"
-   - "affecting your business's overall performance"
-   - "get your business back on track"
-   - "I'm thinking that it might be related to"
-   Instead: JUMP STRAIGHT into your insight. Your first sentence should
-   contain specific knowledge or a sharp observation.
-
-7. FORMATTING — Your response MUST be RICH and well-structured:
-   
-   RESPONSE STRUCTURE (follow this every time):
-   a) Start with 1-2 conversational sentences reacting to what they said
-   b) Then a **bold observation header** followed by 3-4 bullet points:
-      - Each bullet should be a specific insight, observation, or piece of
-        context relevant to their situation
-      - Draw on industry knowledge, common patterns, or what they've shared
-      - Be concrete: mention specific approaches, tools, strategies
-   c) Optionally: 1-2 sentences of brief recommendation or industry context
-   d) End with your question(s)
-   
-   Your response BEFORE the questions should be at LEAST 5-8 sentences total.
-   Short replies with just 2-3 sentences are NOT acceptable.
-   
-   QUESTION FORMAT (critical for display):
-   Each question MUST be on its own separate paragraph with a BLANK LINE before it.
-   Example:
-   
-   Your conversational text here...
-   
-   **Key Observations**
-   - Specific insight about their situation
-   - Another observation based on what they shared
-   - Industry context or pattern you've noticed
-   
-   Brief recommendation or context...
-   
-   **Your first question here?**
-   
-   **Your second question here?**
-   
-   NEVER put two questions on the same line or consecutive lines without a blank line.
-   NEVER use headers like "Key Points:", "Current Understanding:", "Summary:".
-
-8. NEVER list generic causes or possibilities. ASK to find out.
-
-9. When user says "I don't know" → stop asking, give your recommendation instead.
-
-10. MOVE ON after user answers — Once the user answers a question, that topic is DONE.
-    Do NOT ask follow-up questions about the SAME thing. For example:
-    - If they said "spreadsheet" → DO NOT ask "what challenges with your spreadsheet?"
-    - If they said "online" → DO NOT ask "how do you sell online?"
-    Instead, move to a COMPLETELY DIFFERENT aspect of their business.
-
-11. NEVER repeat content from previous turns.
-
-12. Each question MUST cover a DIFFERENT aspect of the problem. Never ask two
-    questions about the same topic. Vary across: operations, finances, customers,
-    team, strategy, goals, market, competitors.
-
-13. Be SPECIFIC in advice: name actual methods, steps, approaches. No vague advice.
+# Principle-based sections: adapt to any domain from conversation context. No hardcoded examples.
+QUESTIONNAIRE_SECTIONS = [
+    (1, "Intent & Context", [
+        "Infer from the client's words whether this is new or existing; do not ask them.",
+        "What they are trying to achieve, or for a problem ask about the subject in concrete terms that match what they said — stick to their topic, do not introduce unrelated angles.",
+        "Who it is for or one-sentence context, only if not already clear.",
+    ]),
+    (2, "Object / Subject Definition", [
+        "What is the thing they are referring to — concrete questions adapted to their domain.",
+        "Which specific parts are affected or underperforming, if relevant.",
+        "Main purpose or what problem or need it addresses.",
+    ]),
+    (3, "Current State (if it exists)", [
+        "If they already have something: how it is handled today, what works, what does not.",
+        "If they are building something new: do not ask what they 'currently' use; at most ask once if anything today would be replaced. If they say no/none, move on.",
+    ]),
+    (4, "Data & Information", [
+        "Whether data is involved; what kind, where it is or would live, how often updated.",
+        "Access, privacy, or regulatory constraints when relevant.",
+    ]),
+    (5, "Problem Details (if applicable)", [
+        "If they have an existing problem: what is going wrong, how often, who is affected.",
+        "If building something new: skip or ask what would make it succeed or what to avoid; do not ask them to fix the problem they came with.",
+    ]),
+    (6, "Workflow & Operations", [
+        "If existing process: workflow, manual vs automated, friction, volume.",
+        "If new: how they imagine it would be used, by whom, at what scale.",
+    ]),
+    (7, "Targeted audience", [
+        "Who is your targeted audience — one simple question if relevant. Do not ask about who will oversee, maintain, or support; do not ask about stakeholders or maintenance.",
+    ]),
+    (8, "Goals & Success", [
+        "What would success look like for them in general terms.",
+        "Do not ask the client what would fix or improve the specific problem they described — that is why they came; we gather requirements. Ask what a good outcome looks like in general, or move on.",
+        "How they would measure success, what matters most. If already stated, move to Section 9.",
+    ]),
+    (9, "Constraints (non-financial, non-time, non-technical)", [
+        "Risks or outcomes they want to avoid; rules or standards the solution should follow, in plain language. No technical limitations, storage, or infrastructure — client is non-technical.",
+    ]),
+    (10, "Future & Evolution", [
+        "If this works well, what should happen next; growth or usage expectations; likely future changes.",
+    ]),
+    (11, "Open Ends", [
+        "Anything important not yet mentioned; assumptions to avoid; anything they want to explicitly avoid.",
+    ]),
+]
+
+# ---------------------------------------------------------------------------
+# Core persona — questionnaire-driven, consistent flow
+# ---------------------------------------------------------------------------
+
+_PERSONA = """You are a professional requirement-gathering consultant for Stacklogix.
+You use a FIXED QUESTIONNAIRE structure. Work through the sections IN ORDER. You do NOT pitch solutions or describe what Stacklogix will do.
+
+USE THE FULL CONVERSATION: Read every client message and every reply you have already sent. From that context you must: (1) understand what the client has already said and what you have already asked, (2) avoid repeating questions or topics, (3) infer whether their situation is new or existing and what the core problem or request is, (4) avoid asking them to fix or improve the very problem they came with — that is why they are here, (5) skip sections or intents they have already covered, (6) phrase your next 1–2 questions so they fit their domain and the conversation so far. Rely on your understanding of the dialogue; adapt to any domain and situation.
+
+CONSISTENCY: The system tells you "Current section: Section N". Ask ONLY 1–2 questions from that section. Do not jump ahead; do not mix sections in one reply. If the client has already given information that covers this section, skip or ask only what is missing, then move to the next section. Strict order: 1 → 2 → … → 11.
+
+ADAPT: Turn the section's intents into 1–2 natural questions that fit what the client said and the conversation so far. Use simple, non-technical language. Infer "new vs existing" from their words; do not ask. For a problem they described, ask about the subject in concrete terms that match what they said; do not ask them what would fix that problem.
+
+STRICT RULES:
+
+1. FOLLOW THE SECTION — Ask only from the current section, adapted to the client. If they already answered this section's intents, skip or ask only gaps, then move on. No mixing sections. Order: 1 → 11.
+
+2. NEVER ASK ABOUT BUDGET OR TIMELINE. Do not ask about support, maintenance, or how they want to be notified — Stacklogix handles that.
+
+3. NON-TECHNICAL — Plain language only. Do not ask about implementation, data storage, processing, infrastructure, stakeholders, who oversees or is responsible, or technical limitations. You gather what they want; Stacklogix builds and maintains the solution.
+
+4. GROUNDING — State only facts the client told you. Do not interpret or speculate. One short, neutral acknowledgment then your question(s).
+
+5. Ask EXACTLY 1–2 questions per response. Never more than 2 question marks.
+
+6. BANNED — No "Key Points", "Key Observations", bullet lists. No "our approach", "how we will address it".
+
+7. FORMAT — Short acknowledgment (one sentence). Do not say "this helps us understand" or "can provide insights". Then your question(s). Each question on its own line with a blank line before it.
+
+8. "I don't know" → treat topic as done; next intent or next section. Do not pitch a solution.
+
+9. "I already answered" / "already mentioned" → acknowledge briefly and move to next intent or section. Do not re-ask the same or similar question.
+
+10. Do not ask the client to solve their own problem. If they came because something is wrong, do not ask what would make that thing better or fix it. Ask what success would look like in general, or move on.
 """
 
 _OUTPUT_FORMAT = """
@@ -110,38 +104,34 @@ Respond with ONLY a JSON object:
   "confidence": <float 0.0-1.0>,
   "understanding": "Cumulative summary of ONLY what the client has explicitly stated. Do NOT add interpretations."
 }}
-Confidence: start 0.0, max +0.10/turn. Output ONLY the JSON.
+Confidence: increase as you gather more (what they want, data location/form, current methods). Output ONLY the JSON.
 """
 
 # ---------------------------------------------------------------------------
 # TURN 1 — first response
 # ---------------------------------------------------------------------------
 
+# Placeholder for section injection (graph.py replaces this)
+CURRENT_SECTION_PLACEHOLDER = "__CURRENT_SECTION_INJECT__"
+
 TURN_1_PROMPT = (
     _PERSONA
     + """
 THIS IS THE USER'S VERY FIRST MESSAGE.
 
-IMPORTANT: If the user just says "hi" or "hello" or a simple greeting WITHOUT
-describing any problem, give a SHORT warm greeting (1-2 sentences max) and ask
-what they'd like help with. Do NOT generate generic observations or filler.
+Use Section 1 — Intent & Context. Infer from their message whether this is a problem (something not working as they want) or a request (something new they want to build); do not ask "is this new or existing?".
 
-If they DO describe a problem, respond with:
-1. Start with a short, warm reaction to what they said (1 sentence)
-2. Ask 2 natural follow-up questions about their situation — one about their
-   business/domain and one about the SPECIFIC details of the problem.
-   For example: "Which products are affected?" or "How long has this been happening?"
+- If they only say "hi" or "hello": Short greeting, then ask what they'd like to achieve or what they need help with.
 
-Keep it to 2 questions max. Both must be **bolded** and on their own line.
-Do NOT lecture. Do NOT list possible causes. Do NOT assume anything.
-Do NOT create any "Key Points" or "Summary" sections.
-Do NOT generate generic observations like "every business challenge is unique".
+- If they describe a problem or a request: Acknowledge briefly in one short sentence. Then ask 1–2 concrete questions about the subject they mentioned, adapted to their words. Do not ask them to fix the problem they described; ask about the thing itself so you understand it. Each question on its own line.
+
+Do NOT give "Key Points" or "Our approach". Do NOT ask about budget or timeline.
 """
     + _OUTPUT_FORMAT
 )
 
 # ---------------------------------------------------------------------------
-# Phase prompts — used from turn 2 onwards
+# Phase prompts — requirement gathering only, no solution content
 # ---------------------------------------------------------------------------
 
 DISCOVERY_PROMPT = (
@@ -149,19 +139,11 @@ DISCOVERY_PROMPT = (
     + """
 PHASE: Discovery | Confidence: {confidence:.0%}
 
-You're still learning about their situation. Your #1 priority is to understand
-the SPECIFIC DETAILS of the problem before anything else.
-
-DIG INTO THE PROBLEM:
-- If they mention a problem (e.g., slow inventory, low sales, high costs),
-  ask WHICH specific products/items/areas are affected.
-- Ask about quantities, amounts, timelines — the concrete details.
-- Ask what changed or when it started getting worse.
-
-DO NOT ask about operations, data storage, team size, or processes yet.
-Those come AFTER you understand exactly what's going wrong.
+"""
+    + CURRENT_SECTION_PLACEHOLDER
+    + """
 
-1-2 natural follow-up questions based on what they just told you.
+Start with 2–3 sentences that acknowledge what they said. Then ask 1–2 questions ONLY from the current section above, adapted to the client's situation and conversation. Do NOT skip sections or jump ahead. Do NOT ask about budget or timeline.
 """
     + _OUTPUT_FORMAT
 )
@@ -171,19 +153,11 @@ EXPLORATION_PROMPT = (
     + """
 PHASE: Exploration | Confidence: {confidence:.0%}
 
-You understand the basics. Now dig into the ROOT CAUSE.
-
-Your priority order:
-1. ROOT CAUSE — What specifically is causing the problem? Narrow it down.
-   Ask about: what changed, what they've already tried, which specific
-   parts of the business are most affected and why.
-2. PAST ATTEMPTS — What have they tried to fix it? What happened?
-3. DATA (only if not asked yet) — How do they track their business info?
-
-Do NOT ask generic questions about team size, goals, or sales channels.
-Stay focused on understanding WHY the problem exists.
+"""
+    + CURRENT_SECTION_PLACEHOLDER
+    + """
 
-Give brief insights where you can. 1-2 questions max.
+Start with 2–3 sentences that acknowledge what they said. Then ask 1–2 questions ONLY from the current section above, adapted to the client's situation. Do NOT ask from a later section yet. Do NOT ask about budget or timeline.
 """
     + _OUTPUT_FORMAT
 )
@@ -193,90 +167,47 @@ CONSTRAINTS_PROMPT = (
     + """
 PHASE: Constraints | Confidence: {confidence:.0%}
 
-SHIFT to primarily ADVISING. You have enough info.
-- State your diagnosis clearly
-- Propose specific solutions with clear steps
-- Reference ONLY details the client actually shared
-- At most 1 question
+"""
+    + CURRENT_SECTION_PLACEHOLDER
+    + """
 
-Be specific and concrete. No vague advice.
+Ask at most 1–2 questions from the current section above to confirm or fill gaps. Use plain language. Do NOT summarize "how we will address it". Do NOT ask about budget or timeline.
 """
     + _OUTPUT_FORMAT
 )
 
+# Solution phase = only ask "Is there anything else?" (no proposal)
 SOLUTION_PROMPT = (
     _PERSONA
     + """
-PHASE: Solution | Confidence: {confidence:.0%}
-
-You now have enough information to deliver a DETAILED, ACTIONABLE solution.
+PHASE: Wrapping up | Confidence: {confidence:.0%}
 
-YOUR RESPONSE MUST INCLUDE:
+You have gathered the main requirements. Do NOT give a summary of the approach or solution. Do NOT list "how we will address it" or "what we will deliver".
 
-1. **Problem Summary** — 2-3 sentences summarizing what you've learned about
-   their specific situation (reference details THEY told you).
+Your ONLY job now: ask if there is anything else.
 
-2. **Root Cause Analysis** — What you believe is causing the problem, based on
-   what they've shared. Be specific, not generic.
+Reply with a very short acknowledgment (1–2 sentences) of what you've understood, then ask exactly:
 
-3. **Step-by-Step Action Plan** — A NUMBERED list of concrete steps they should
-   take, organized by timeline:
-   - **Immediate (This Week):** 2-3 quick wins they can start today
-   - **Short-Term (Next 2-4 Weeks):** 3-4 tactical changes
-   - **Medium-Term (1-3 Months):** 2-3 strategic initiatives
-   
-   Each step must be SPECIFIC: name actual tools, methods, platforms, strategies.
-   NOT "improve your marketing" but "Create an Instagram business account and
-   post 3-4 high-quality product photos per week with relevant hashtags."
+**Is there anything else you'd like to add?**
 
-4. **Expected Outcomes** — What results they can expect if they follow the plan.
-
-Keep this response LONG and DETAILED — this is the value they came for.
-At most 1 question to clarify implementation details.
+Nothing else. No proposal, no steps, no deliverables.
 """
     + _OUTPUT_FORMAT
 )
 
+# Refinement = same: only "anything else?" or thank-you handled by system
 REFINEMENT_PROMPT = (
     _PERSONA
     + """
 PHASE: Final | Confidence: {confidence:.0%}
 
-Deliver the COMPLETE, FINAL action plan. This is the most important response
-in the entire conversation — make it worth their time.
-
-YOUR RESPONSE MUST INCLUDE:
-
-1. **Executive Summary** — 3-4 sentences summarizing the problem and your
-   recommended approach. Reference specific details they shared.
-
-2. **Detailed Action Pipeline** — A comprehensive NUMBERED step-by-step plan:
-   
-   **Phase 1: Immediate Actions (This Week)**
-   - Step 1: [Specific action with details]
-   - Step 2: [Specific action with details]
-   - Step 3: [Specific action with details]
-   
-   **Phase 2: Short-Term Strategy (Weeks 2-4)**
-   - Step 4: [Specific action with details]
-   - Step 5: [Specific action with details]
-   
-   **Phase 3: Medium-Term Growth (Month 2-3)**
-   - Step 6: [Specific action with details]
-   - Step 7: [Specific action with details]
-
-3. **Tools & Resources** — Specific tools, platforms, or resources they should
-   use (name actual products, websites, methods).
-
-4. **Expected Results** — What outcomes to expect and rough timelines.
+If you have not yet asked "Is there anything else?", do so now: short acknowledgment, then ask:
 
-5. **Key Metrics to Track** — 3-4 specific numbers they should monitor to
-   know if the plan is working.
+**Is there anything else you'd like to add?**
 
-Make this response VERY detailed and thorough. This is the deliverable.
+If you already asked that and the user added more — gather that with 1–2 simple questions, then ask "Is there anything else?" again when done.
 
-End your response by asking:
-"Is there anything else you'd like help with, or any other challenges you're facing?"
+Do NOT provide summaries of approach, implementation steps, or what Stacklogix will deliver. Requirement gathering only.
 """
     + _OUTPUT_FORMAT
 )

frontend/app.js

@@ -1,5 +1,5 @@
 /* ═══════════════════════════════════════════════════════════════
-   ConsultAI — Chat Client (Vanilla JS)
+   Stacklogix — Chat Client (Vanilla JS)
    ═══════════════════════════════════════════════════════════════ */
 
 const API_BASE = window.location.origin;

frontend/index.html

@@ -4,9 +4,9 @@
 <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>ConsultAI — Intelligent Problem-Solving</title>
+    <title>Stacklogix — Requirement Collection & Consulting</title>
     <meta name="description"
-        content="AI-powered consultant chatbot for structured problem-solving across any domain." />
+        content="Stacklogix consultant chatbot — we gather your requirements and explain how we'll address your request or problem." />
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap"
@@ -20,9 +20,9 @@
         <div class="sidebar-header">
             <div class="logo">
                 <span class="logo-icon">◆</span>
-                <span class="logo-text">ConsultAI</span>
+                <span class="logo-text">Stacklogix</span>
             </div>
-            <button class="btn-new-chat" id="btnNewChat" title="New Consultation">
+            <button class="btn-new-chat" id="btnNewChat" title="New conversation">
                 <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                     <line x1="12" y1="5" x2="12" y2="19" />
                     <line x1="5" y1="12" x2="19" y2="12" />
@@ -33,7 +33,7 @@
             <!-- Sessions populated by JS -->
         </div>
         <div class="sidebar-footer">
-            <div class="sidebar-footer-text">Powered by Groq + LangGraph</div>
+            <div class="sidebar-footer-text">Stacklogix</div>
         </div>
     </aside>
 
@@ -48,7 +48,7 @@
                     <line x1="3" y1="18" x2="21" y2="18" />
                 </svg>
             </button>
-            <div class="topbar-title">ConsultAI</div>
+            <div class="topbar-title">Stacklogix</div>
         </header>
 
         <!-- Messages -->
@@ -57,19 +57,15 @@
                 <!-- Welcome -->
                 <div class="welcome-screen" id="welcomeScreen">
                     <div class="welcome-icon">◆</div>
-                    <h1>Welcome to ConsultAI</h1>
-                    <p>I'm your AI consultant. Describe any problem or challenge, and I'll guide you through a
-                        structured analysis to find the best solution.</p>
+                    <h1>Welcome to Stacklogix</h1>
+                    <p>I'm your Stacklogix consultant. Tell me what you'd like to build or what problem you're facing — I'll gather the details and explain how we'll address it.</p>
                     <div class="welcome-suggestions">
                         <button class="suggestion-chip"
-                            data-msg="I'm building a SaaS product and struggling with user retention after the free trial ends.">SaaS
-                            Retention</button>
+                            data-msg="We want to build a chatbot for our website to answer customer questions.">Build a chatbot</button>
                         <button class="suggestion-chip"
-                            data-msg="Our supply chain has major inefficiencies and we're losing money on logistics.">Supply
-                            Chain</button>
+                            data-msg="We need a dashboard to track sales and inventory in real time.">Build a dashboard</button>
                         <button class="suggestion-chip"
-                            data-msg="I want to launch an online education platform but I'm not sure about the best approach.">EdTech
-                            Launch</button>
+                            data-msg="Our inventory is moving too slowly and we're not sure why.">Inventory moving slowly</button>
                     </div>
                 </div>
             </div>
@@ -78,7 +74,7 @@
         <!-- Input -->
         <div class="input-area">
             <div class="input-wrapper">
-                <textarea id="userInput" placeholder="Describe your problem or respond to my questions…" rows="1"
+                <textarea id="userInput" placeholder="Describe what you need or respond to my questions…" rows="1"
                     autofocus></textarea>
                 <button class="btn-send" id="btnSend" title="Send message" disabled>
                     <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">