Update reasoning_engine.py

reasoning_engine.py

@@ -1,24 +1,30 @@
 """
 Infinity GRM - Reasoning Engine
 ================================
-
-Standalone cognitive/reasoning layer.
-
-Responsibilities:
-- Problem understanding and planning
-- Structured reasoning
-- Evidence analysis
-- Verification / critique
-- Experience retrieval ("learning from solved problems")
-- Final response synthesis
-
-The model is reused across all passes so the system does not create a
-separate, weaker "reasoning model".
-
-Important:
-The <think> block is a concise reasoning summary / decision trace.
-It is deliberately bounded rather than exposing unrestricted private
-chain-of-thought.
+Standalone cognitive/reasoning layer for Infinity GRM.
+
+Features
+--------
+- Qwen2.5-7B-Instruct reasoning model
+- 700 structured reasoning demonstrations by default
+- Semantic retrieval of relevant demonstrations
+- Planning -> analysis -> verification -> final synthesis
+- Persistent SQLite experience memory
+- Optional detailed, user-visible reasoning TRACE (not raw hidden CoT)
+- Backward-compatible plan()/analyze()/final_answer() API
+
+Environment
+-----------
+GRM_MODEL=Qwen/Qwen2.5-7B-Instruct
+GRM_EXAMPLE_TARGET=700       # clamped to 500..1000
+GRM_MEMORY_DB=./grm_experience.sqlite3
+GRM_SHOW_REASONING_TRACE=1   # default enabled for detailed trace output
+
+Important
+---------
+The demonstration library is structured training-style material used at
+inference time. It does not change the neural weights of the base model.
+For model-weight improvement, use a separate SFT/QLoRA training pipeline.
 """
 
 import os
@@ -35,21 +41,188 @@ import torch
 from sentence_transformers import SentenceTransformer
 from transformers import AutoTokenizer, AutoModelForCausalLM, AutoConfig
 
-
 logger = logging.getLogger("infinitygrm.reasoning")
 
 MODEL_NAME = os.getenv("GRM_MODEL", "Qwen/Qwen2.5-7B-Instruct")
 MEMORY_DB = Path(os.getenv("GRM_MEMORY_DB", "./grm_experience.sqlite3"))
+EXAMPLE_TARGET = max(500, min(1000, int(os.getenv("GRM_EXAMPLE_TARGET", "700"))))
+SHOW_REASONING_TRACE = os.getenv("GRM_SHOW_REASONING_TRACE", "1").lower() not in {"0", "false", "no"}
+
+STATE: Dict[str, Any] = {
+    "model": None,
+    "tokenizer": None,
+    "embed_model": None,
+    "device": None,
+    "reasoning_example_embeddings": None,
+}
+
+
+# =====================================================================
+# STRUCTURED REASONING DEMONSTRATION LIBRARY
+# =====================================================================
+
+_REASONING_SKILLS = [
+    ("mathematics", "algebra", "isolate variables, preserve equality, check by substitution"),
+    ("mathematics", "geometry", "identify the governing geometric relationship, substitute known quantities, verify units"),
+    ("mathematics", "probability", "define the sample space, identify independence/dependence, compute and sanity-check probabilities"),
+    ("mathematics", "statistics", "identify the estimator or test, state assumptions, calculate, interpret uncertainty"),
+    ("mathematics", "calculus", "identify the derivative/integral rule, apply it carefully, verify with boundary or dimensional checks"),
+    ("algorithms", "complexity", "identify the dominant operation, count repeated work, derive asymptotic time and space complexity"),
+    ("algorithms", "sorting", "choose an algorithm based on constraints, preserve correctness invariants, analyze complexity"),
+    ("algorithms", "graphs", "model entities as vertices and relationships as edges, choose traversal/shortest-path method, verify reachability"),
+    ("algorithms", "dynamic programming", "define state, transition, base case, evaluation order, and prove that states cover all cases"),
+    ("algorithms", "greedy methods", "define a locally optimal choice, establish the invariant/exchange argument, then verify feasibility"),
+    ("coding", "Python debugging", "reproduce the failure, inspect the smallest relevant state, identify the root cause, patch and retest"),
+    ("coding", "data structures", "identify access/update requirements, select an appropriate structure, define invariants and complexity"),
+    ("coding", "API design", "define inputs/outputs/errors, preserve contracts, validate data, and design deterministic behavior"),
+    ("coding", "concurrency", "identify shared state, define synchronization boundaries, avoid races/deadlocks, and test interleavings"),
+    ("coding", "optimization", "measure the bottleneck, improve the dominant cost, preserve semantics, and benchmark before/after"),
+    ("coding", "machine learning", "separate data/model/objective/evaluation, identify leakage risks, train, validate, and test independently"),
+    ("science", "physics", "translate the situation into variables and laws, keep units consistent, solve symbolically, then sanity-check"),
+    ("science", "chemistry", "identify substances and governing conservation laws, balance the reaction/model, calculate, and check stoichiometry"),
+    ("science", "biology", "identify the mechanism, distinguish correlation from causation, connect evidence to the proposed biological process"),
+    ("engineering", "systems", "decompose components and interfaces, identify bottlenecks/failure modes, design controls and verify requirements"),
+    ("engineering", "electronics", "define voltage/current/power relationships, inspect component constraints, calculate worst case, verify margins"),
+    ("logic", "deduction", "translate statements into premises, derive consequences, test alternatives, and distinguish valid inference from assumption"),
+    ("logic", "constraint solving", "list variables/domains/constraints, propagate restrictions, branch only when needed, verify every constraint"),
+    ("software engineering", "architecture", "identify requirements and boundaries, choose components/interfaces, evaluate tradeoffs, and define failure handling"),
+    ("software engineering", "testing", "identify observable behavior, partition cases, include edge cases, assert invariants, and test regressions"),
+    ("software engineering", "security review", "map trust boundaries, identify attack surfaces, validate inputs/authorization, and verify mitigations"),
+]
+
+_VARIANTS = [
+    "direct solution with explicit assumptions",
+    "edge-case-heavy solution",
+    "debugging-oriented solution",
+    "optimization-oriented solution",
+    "verification-oriented solution",
+    "comparison of two plausible approaches",
+    "failure-analysis and correction",
+    "design followed by a validation plan",
+    "symbolic derivation followed by a numerical sanity check",
+    "algorithm selection followed by complexity analysis",
+]
+
+
+def _build_reasoning_examples(target: int = EXAMPLE_TARGET) -> List[Dict[str, Any]]:
+    """Create a deterministic library of structured reasoning demonstrations.
+
+    These are inference-time demonstrations rather than weight updates. The
+    generator deliberately stores reasoning as concise, inspectable steps,
+    not unrestricted hidden chain-of-thought.
+    """
+    examples: List[Dict[str, Any]] = []
+    idx = 0
+    skill_count = len(_REASONING_SKILLS)
+
+    while len(examples) < target:
+        domain, skill, principle = _REASONING_SKILLS[idx % skill_count]
+        variant = _VARIANTS[(idx // skill_count) % len(_VARIANTS)]
+        difficulty = ("medium", "hard", "expert")[(idx // (skill_count * 3)) % 3]
+
+        problem = (
+            f"Solve a {skill} problem using a {variant} approach. "
+            f"The solution must apply the core principle: {principle}."
+        )
+
+        steps = [
+            f"Identify the exact {skill} task and separate requirements from assumptions.",
+            f"Apply the governing principle: {principle}.",
+            "Work through the relevant intermediate states without skipping constraint checks.",
+            "Inspect edge cases, contradictions, units, invariants, or boundary conditions as applicable.",
+            "Produce the solution and independently verify that it satisfies the original requirements.",
+        ]
+
+        verification = [
+            "Check that every stated constraint is satisfied.",
+            "Check for an unstated assumption that could change the result.",
+            "Use an independent sanity check where possible.",
+        ]
+
+        solution = (
+            f"Use the {skill} method appropriate to the stated constraints; explicitly state assumptions, "
+            "derive the result in ordered steps, then verify the result against the original problem."
+        )
 
-STATE: Dict[str, Any] = {}
+        examples.append({
+            "id": idx + 1,
+            "domain": domain,
+            "skill": skill,
+            "difficulty": difficulty,
+            "problem": problem,
+            "reasoning_trace": steps,
+            "verification": verification,
+            "solution": solution,
+        })
+        idx += 1
 
+    return examples
 
-# ---------------------------------------------------------------------
+
+# IMPORTANT: this is the actual definition that was missing in the broken file.
+REASONING_EXAMPLES: List[Dict[str, Any]] = _build_reasoning_examples(EXAMPLE_TARGET)
+
+
+def _format_reasoning_examples(query: str, top_k: int = 6) -> str:
+    """Return the most relevant structured demonstrations for a query."""
+    if not REASONING_EXAMPLES:
+        return "No demonstrations available."
+
+    embed_model = STATE.get("embed_model")
+    if embed_model is None:
+        # Safe fallback before model initialization.
+        selected = REASONING_EXAMPLES[:top_k]
+    else:
+        try:
+            if STATE.get("reasoning_example_embeddings") is None:
+                texts = [
+                    f"{x['domain']} {x['skill']} {x['problem']} {x['solution']}"
+                    for x in REASONING_EXAMPLES
+                ]
+                STATE["reasoning_example_embeddings"] = embed_model.encode(
+                    texts,
+                    normalize_embeddings=True,
+                    convert_to_numpy=True,
+                    show_progress_bar=False,
+                )
+
+            qv = _embed(query)
+            matrix = STATE["reasoning_example_embeddings"]
+            scores = matrix @ qv
+            indices = np.argsort(scores)[::-1][:top_k]
+            selected = [REASONING_EXAMPLES[int(i)] for i in indices]
+        except Exception as exc:
+            logger.warning("Reasoning example retrieval failed: %s", exc)
+            selected = REASONING_EXAMPLES[:top_k]
+
+    blocks = []
+    for ex in selected:
+        blocks.append(
+            "EXAMPLE {id} | {domain}/{skill} | difficulty={difficulty}\n"
+            "Problem pattern: {problem}\n"
+            "Reasoning steps:\n- {steps}\n"
+            "Verification:\n- {verification}\n"
+            "Solution pattern: {solution}".format(
+                id=ex["id"],
+                domain=ex["domain"],
+                skill=ex["skill"],
+                difficulty=ex["difficulty"],
+                problem=ex["problem"],
+                steps="\n- ".join(ex["reasoning_trace"]),
+                verification="\n- ".join(ex["verification"]),
+                solution=ex["solution"],
+            )
+        )
+    return "\n\n".join(blocks)
+
+
+# =====================================================================
 # MODEL
-# ---------------------------------------------------------------------
+# =====================================================================
+
 
 def initialize_model():
-    """Load the language model and embedding model once."""
+    """Load the language and embedding models once."""
     if STATE.get("model") is not None:
         return
 
@@ -85,23 +258,16 @@ def initialize_model():
     )
 
     initialize_memory()
-
-    logger.info("Reasoning engine initialized on %s", device)
+    logger.info("Reasoning engine initialized on %s with %d demonstrations", device, len(REASONING_EXAMPLES))
 
 
-# ---------------------------------------------------------------------
+# =====================================================================
 # EXPERIENCE MEMORY
-# ---------------------------------------------------------------------
+# =====================================================================
 
-def initialize_memory():
-    """Create a persistent experience store.
 
-    This is retrieval-based learning. It lets the model reuse useful
-    prior solutions without pretending that the base model's weights
-    have been retrained after every question.
-    """
+def initialize_memory():
     MEMORY_DB.parent.mkdir(parents=True, exist_ok=True)
-
     with sqlite3.connect(MEMORY_DB) as db:
         db.execute(
             """
@@ -125,17 +291,11 @@ def _embed(text: str) -> np.ndarray:
         [text],
         normalize_embeddings=True,
         convert_to_numpy=True,
+        show_progress_bar=False,
     )[0]
 
 
-def save_experience(
-    query: str,
-    plan: str,
-    analysis: str,
-    answer: str,
-    quality: float = 1.0,
-):
-    """Store a successful solution for later retrieval."""
+def save_experience(query: str, plan: str, analysis: str, answer: str, quality: float = 1.0):
     try:
         with sqlite3.connect(MEMORY_DB) as db:
             db.execute(
@@ -144,14 +304,7 @@ def save_experience(
                 (query, plan, analysis, answer, quality, created)
                 VALUES (?, ?, ?, ?, ?, ?)
                 """,
-                (
-                    query,
-                    plan,
-                    analysis,
-                    answer,
-                    float(quality),
-                    time.time(),
-                ),
+                (query, plan, analysis, answer, float(quality), time.time()),
             )
             db.commit()
     except Exception as exc:
@@ -159,7 +312,6 @@ def save_experience(
 
 
 def retrieve_experiences(query: str, top_k: int = 3) -> List[Dict[str, Any]]:
-    """Retrieve semantically similar prior problem-solving experiences."""
     try:
         with sqlite3.connect(MEMORY_DB) as db:
             rows = db.execute(
@@ -177,104 +329,106 @@ def retrieve_experiences(query: str, top_k: int = 3) -> List[Dict[str, Any]]:
 
         qv = _embed(query)
         scored = []
-
         for row in rows:
-            # Re-embed only the stored query. For a production system,
-            # persist embeddings in a vector DB or serialized index.
             rv = _embed(row[1])
-            score = float(np.dot(qv, rv))
-            scored.append((score, row))
-
+            scored.append((float(np.dot(qv, rv)), row))
         scored.sort(key=lambda x: x[0], reverse=True)
 
-        results = []
-        for score, row in scored[:top_k]:
-            results.append(
-                {
-                    "similarity": score,
-                    "query": row[1],
-                    "plan": row[2],
-                    "analysis": row[3],
-                    "answer": row[4],
-                    "quality": row[5],
-                }
-            )
-
-        return results
-
+        return [
+            {
+                "similarity": score,
+                "query": row[1],
+                "plan": row[2],
+                "analysis": row[3],
+                "answer": row[4],
+                "quality": row[5],
+            }
+            for score, row in scored[:top_k]
+        ]
     except Exception as exc:
         logger.warning("Experience retrieval failed: %s", exc)
         return []
 
 
-# ---------------------------------------------------------------------
-# GENERATION
-# ---------------------------------------------------------------------
+# =====================================================================
+# GENERATION + TRACE EXTRACTION
+# =====================================================================
 
-def generate(
-    messages: List[Dict[str, str]],
-    max_new_tokens: int = 1024,
-    temperature: float = 0.15,
-) -> str:
+
+def generate(messages: List[Dict[str, str]], max_new_tokens: int = 1024, temperature: float = 0.15) -> str:
     """Run one model pass."""
     initialize_model()
 
     tokenizer = STATE["tokenizer"]
     model = STATE["model"]
 
-    prompt = tokenizer.apply_chat_template(
-        messages,
-        tokenize=False,
-        add_generation_prompt=True,
-    )
-
+    prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
     inputs = tokenizer(prompt, return_tensors="pt")
-    inputs = {
-        k: v.to(model.device)
-        for k, v in inputs.items()
+    inputs = {k: v.to(model.device) for k, v in inputs.items()}
+
+    generation_kwargs = {
+        "max_new_tokens": max_new_tokens,
+        "repetition_penalty": 1.05,
+        "pad_token_id": tokenizer.eos_token_id,
     }
+    if temperature > 0:
+        generation_kwargs.update({"temperature": temperature, "top_p": 0.90, "do_sample": True})
+    else:
+        generation_kwargs.update({"do_sample": False})
 
     with torch.no_grad():
-        output = model.generate(
-            **inputs,
-            max_new_tokens=max_new_tokens,
-            temperature=temperature,
-            top_p=0.90,
-            repetition_penalty=1.05,
-            do_sample=True,
-            pad_token_id=tokenizer.eos_token_id,
-        )
+        output = model.generate(**inputs, **generation_kwargs)
 
     new_tokens = output[0][inputs["input_ids"].shape[1]:]
+    return tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+
 
-    return tokenizer.decode(
-        new_tokens,
-        skip_special_tokens=True,
-    ).strip()
+def _extract_think(text: str) -> str:
+    """Extract the model's explicit <think> section if it emitted one."""
+    match = re.search(r"<think>\s*(.*?)\s*</think>", text, flags=re.IGNORECASE | re.DOTALL)
+    return match.group(1).strip() if match else ""
 
 
 def clean_think_block(text: str) -> str:
-    """Normalize a model-generated <think> block."""
+    """Return a bounded visible reasoning trace plus the model output.
+
+    We intentionally expose a structured reasoning summary rather than
+    pretending that an arbitrary generated <think> block is a faithful dump
+    of private internal cognition.
+    """
     text = text.strip()
+    think = _extract_think(text)
+    body = re.sub(r"<think>.*?</think>", "", text, flags=re.IGNORECASE | re.DOTALL).strip()
+
+    if not body:
+        body = text.replace("<think>", "").replace("</think>", "").strip()
 
-    if not text.startswith("<think>"):
-        text = "<think>\n" + text
+    if SHOW_REASONING_TRACE and think:
+        return f"<think>\n{think}\n</think>\n\n{body}".strip()
+    return body
 
-    if "</think>" not in text:
-        text += "\n</think>"
 
-    return text
+def _make_trace(stage: str, text: str) -> Dict[str, Any]:
+    """Create an inspectable stage trace from the explicit model output."""
+    think = _extract_think(text)
+    body = re.sub(r"<think>.*?</think>", "", text, flags=re.IGNORECASE | re.DOTALL).strip()
+    return {
+        "stage": stage,
+        "reasoning_summary": think,
+        "output": body,
+    }
 
 
-# ---------------------------------------------------------------------
+# =====================================================================
 # COGNITIVE PASSES
-# ---------------------------------------------------------------------
+# =====================================================================
 
 PLANNER_SYSTEM = r"""
 You are the planning component of Infinity GRM.
 
-Your job is to understand the user's problem and produce a compact,
-high-quality execution plan.
+Produce a detailed but concise, inspectable reasoning trace. This is a
+user-visible explanation of decisions, not a claim that it exposes private
+hidden cognition.
 
 You must:
 - identify the actual task;
@@ -287,7 +441,11 @@ You must:
 
 Return:
 <think>
-A concise reasoning summary describing the key decisions and plan.
+1. Task interpretation
+2. Key assumptions/constraints
+3. Chosen method and why
+4. Subproblem decomposition
+5. Verification plan
 </think>
 
 Then return JSON with:
@@ -299,104 +457,84 @@ Then return JSON with:
   "verification": ["..."],
   "difficulty": "easy|medium|hard|expert"
 }
-
-Do not put unrestricted private chain-of-thought in the response.
 """
 
 ANALYST_SYSTEM = r"""
 You are the evidence-analysis component of Infinity GRM.
 
-You receive:
-1. the user's question,
-2. a reasoning plan,
-3. retrieved web evidence,
-4. relevant prior experiences.
+Give a detailed, inspectable reasoning summary. Do not merely restate the
+answer. Explicitly identify evidence, assumptions, contradictions, missing
+information, calculations, and verification checks.
+
+Return:
+<think>
+1. What the evidence establishes
+2. What it does not establish
+3. Important calculations/inferences
+4. Contradictions or uncertainty
+5. Verification result
+</think>
+
+Then provide the analyzed conclusion.
+"""
 
-Analyze the evidence rather than blindly trusting it.
+VERIFIER_SYSTEM = r"""
+You are the verification component of Infinity GRM.
 
-Check:
-- relevance;
-- consistency;
-- contradictions;
-- unsupported claims;
-- missing information;
-- calculations;
-- assumptions;
-- whether the requested conclusion actually follows.
+Audit the proposed analysis. Check correctness, unsupported claims,
+calculations, edge cases, source consistency, and whether the conclusion
+actually follows.
 
 Return:
 <think>
-A concise reasoning summary of the evidence evaluation and verification.
+1. Claim-by-claim checks
+2. Error/edge-case checks
+3. Independent sanity check
+4. Corrections required
+5. Final verification status
 </think>
 
-Then provide a structured analysis suitable for a final answer.
+Then provide a concise verification report.
 """
 
 FINAL_SYSTEM = r"""
-You are the final response component of Infinity GRM.
+You are the final synthesis component of Infinity GRM.
 
-Use the supplied plan, analysis, evidence, and conversation context.
-Answer the user directly.
-
-Requirements:
-- be accurate;
-- distinguish evidence from inference;
-- do not invent missing facts;
-- use web evidence when supplied;
-- preserve important uncertainty;
-- explain difficult concepts clearly;
-- for code, produce complete usable code when requested;
-- do not mention internal architecture unless relevant.
-
-The response must begin with:
+Answer the user directly using the plan, analysis, verification, and evidence.
+Do not invent facts. If uncertainty remains, state it precisely.
 
+Return:
 <think>
-A concise reasoning summary of the approach and verification.
+1. What was established
+2. How the verification affected the result
+3. What answer follows
+4. Any material caveat
 </think>
 
-Then provide the final answer.
-
-The <think> section is a bounded decision summary, not unrestricted
-private chain-of-thought.
+Then give the final answer in a useful format.
 """
 
 
 def plan(query: str, history: List[Dict[str, str]]) -> Dict[str, Any]:
-    """First reasoning pass: decide what the system needs to do."""
     experiences = retrieve_experiences(query, top_k=3)
-
-    memory_text = "\n\n".join(
-        f"PRIOR EXPERIENCE {i+1}\n"
-        f"Problem: {x['query']}\n"
-        f"Approach: {x['plan']}\n"
-        f"Analysis: {x['analysis'][:1500]}"
-        for i, x in enumerate(experiences)
-    )
+    experience_text = json.dumps(experiences, ensure_ascii=False, indent=2)
 
     messages = [
         {"role": "system", "content": PLANNER_SYSTEM},
         {
             "role": "user",
             "content": (
-                f"CONVERSATION:\n{json.dumps(history[-8:], ensure_ascii=False)}\n\n"
-                f"USER QUESTION:\n{query}\n\n"
-                f"RELEVANT PRIOR EXPERIENCES:\n{memory_text or 'None'}\n\n"
+                f"QUESTION:\n{query}\n\n"
+                f"HISTORY:\n{json.dumps(history[-6:], ensure_ascii=False)}\n\n"
+                f"PRIOR EXPERIENCES:\n{experience_text}\n\n"
                 f"RELEVANT REASONING DEMONSTRATIONS:\n{_format_reasoning_examples(query, top_k=8)}"
             ),
         },
     ]
 
-    raw = generate(messages, max_new_tokens=700)
-    return _parse_plan(raw, experiences)
-
-
-def _parse_plan(raw: str, experiences: List[Dict[str, Any]]) -> Dict[str, Any]:
-    think = ""
-    match = re.search(r"<think>(.*?)</think>", raw, re.S | re.I)
-    if match:
-        think = match.group(1).strip()
-
-    json_match = re.search(r"\{.*\}", raw, re.S)
+    raw = generate(messages, max_new_tokens=1400, temperature=0.10)
+    think = _extract_think(raw)
+    json_match = re.search(r"\{.*\}", raw, flags=re.DOTALL)
 
     if json_match:
         try:
@@ -408,24 +546,18 @@ def _parse_plan(raw: str, experiences: List[Dict[str, Any]]) -> Dict[str, Any]:
             pass
 
     return {
-        "think": think or "The planner could not produce structured JSON.",
-        "task": raw,
+        "think": think,
+        "task": query,
         "requires_web": False,
         "search_queries": [],
-        "steps": [],
-        "verification": [],
+        "steps": ["Clarify the task", "Solve using the most appropriate method", "Verify the result"],
+        "verification": ["Check assumptions and edge cases"],
         "difficulty": "hard",
         "experiences": experiences,
     }
 
 
-def analyze(
-    query: str,
-    plan_data: Dict[str, Any],
-    evidence: str,
-    history: List[Dict[str, str]],
-) -> str:
-    """Second reasoning pass: analyze tool output and verify it."""
+def analyze(query: str, plan_data: Dict[str, Any], evidence: str, history: List[Dict[str, str]]) -> str:
     messages = [
         {"role": "system", "content": ANALYST_SYSTEM},
         {
@@ -439,10 +571,24 @@ def analyze(
             ),
         },
     ]
+    return generate(messages, max_new_tokens=1600, temperature=0.10)
 
-    return clean_think_block(
-        generate(messages, max_new_tokens=1400)
-    )
+
+def verify(query: str, plan_data: Dict[str, Any], analysis: str, evidence: str) -> str:
+    """Independent verification pass."""
+    messages = [
+        {"role": "system", "content": VERIFIER_SYSTEM},
+        {
+            "role": "user",
+            "content": (
+                f"QUESTION:\n{query}\n\n"
+                f"PLAN:\n{json.dumps(plan_data, indent=2)}\n\n"
+                f"ANALYSIS:\n{analysis[:18000]}\n\n"
+                f"EVIDENCE:\n{evidence[:20000]}"
+            ),
+        },
+    ]
+    return generate(messages, max_new_tokens=1400, temperature=0.05)
 
 
 def final_answer(
@@ -451,8 +597,14 @@ def final_answer(
     analysis: str,
     evidence: str,
     history: List[Dict[str, str]],
+    verification: Optional[str] = None,
 ) -> str:
-    """Final reasoning/synthesis pass."""
+    """Final reasoning/synthesis pass.
+
+    `verification` is optional to preserve compatibility with the previous
+    five-argument search pipeline.
+    """
+    verification_text = verification or "No separate verification pass was supplied."
     messages = [
         {"role": "system", "content": FINAL_SYSTEM},
         {
@@ -460,16 +612,39 @@ def final_answer(
             "content": (
                 f"QUESTION:\n{query}\n\n"
                 f"PLAN:\n{json.dumps(plan_data, indent=2)}\n\n"
-                f"ANALYSIS:\n{analysis[:16000]}\n\n"
+                f"ANALYSIS:\n{analysis[:18000]}\n\n"
+                f"VERIFICATION:\n{verification_text[:16000]}\n\n"
                 f"EVIDENCE:\n{evidence[:20000]}\n\n"
-                f"HISTORY:\n{json.dumps(history[-8:], ensure_ascii=False)}"
+                f"HISTORY:\n{json.dumps(history[-8:], ensure_ascii=False)}\n\n"
+                f"RELEVANT REASONING DEMONSTRATIONS:\n{_format_reasoning_examples(query, top_k=6)}"
             ),
         },
     ]
+    return generate(messages, max_new_tokens=2200, temperature=0.10)
 
-    return clean_think_block(
-        generate(messages, max_new_tokens=2048)
-    )
+
+def build_reasoning_trace(
+    query: str,
+    plan_data: Dict[str, Any],
+    analysis: str,
+    verification: str,
+    final: str,
+) -> Dict[str, Any]:
+    """Return a detailed visible trace of the reasoning pipeline."""
+    return {
+        "query": query,
+        "demonstration_count": len(REASONING_EXAMPLES),
+        "stages": [
+            {
+                "stage": "planning",
+                "reasoning_summary": plan_data.get("think", ""),
+                "structured_plan": plan_data,
+            },
+            _make_trace("analysis", analysis),
+            _make_trace("verification", verification),
+            _make_trace("final_synthesis", final),
+        ],
+    }
 
 
 def learn_from_result(
@@ -479,7 +654,6 @@ def learn_from_result(
     answer: str,
     quality: float = 1.0,
 ):
-    """Persist a successful solution for future retrieval."""
     save_experience(
         query=query,
         plan=json.dumps(plan_data, ensure_ascii=False),
@@ -493,8 +667,7 @@ def initialize():
     initialize_model()
 
 
-REASONING_EXAMPLES = REASONING_EXAMPLES
-
 if __name__ == "__main__":
     initialize()
-    print("Infinity GRM reasoning engine initialized.")
+    print("Infinity GRM reasoning engine initialized.")
+    print(f"Structured reasoning demonstrations: {len(REASONING_EXAMPLES)}")