Update main.py

main.py

@@ -336,21 +336,63 @@ def _build_doc_section_index(best_doc: str) -> Dict[str, Optional[str]]:
 
 def _cut_at_next_boundary_generic(section_text: str, best_doc: str, current_action: Optional[str]) -> str:
     """
-    Stop when we hit any known section heading in the same doc.
-    If current_action is set, stop only when the next heading belongs to a different action_tag.
-    Fully generic: no hard-coded SOP words.
+    Stop when we hit:
+      1) Any known section heading (from KB metadata) that belongs to a *different* action_tag, OR
+      2) Any heading-like OR numbered line that contains generic action keywords for a *different* action family.
+
+    Generic & future-proof: no SOP-specific terms.
     """
     if not (section_text or "").strip():
         return section_text
 
-    index = _build_doc_section_index(best_doc)
+    # Build metadata-based index: {lower(section_title): lower(action_tag or None)}
+    index: Dict[str, Optional[str]] = {}
+    for d in bm25_docs:
+        m = d.get("meta", {}) or {}
+        if m.get("filename") == best_doc and m.get("intent_tag") == "steps":
+            sec = (m.get("section") or "").strip()
+            tag = (m.get("action_tag") or "").strip().lower() or None
+            if sec:
+                index[sec.lower()] = tag
+
     known_headings = set(index.keys())
+
+    # Generic action families (no SOP-specific words)
+    ACTION_FAMILIES = {
+        "create": ("create", "creation", "new"),
+        "update": ("update", "updation", "reschedule", "edit", "modify", "change"),
+        "delete": ("delete", "deletion", "cancel", "remove", "void"),
+    }
+
+    STEP_PREFIX_RX = re.compile(r"^\s*(?:[\u2460-\u2473]|\d+\s*[.)]|[-*•])")
+
+    def detect_action_family_in_line(line_low: str) -> Optional[str]:
+        for fam, toks in ACTION_FAMILIES.items():
+            for t in toks:
+                if re.search(rf"\b{re.escape(t)}\b", line_low, flags=re.IGNORECASE):
+                    return fam
+        return None
+
+    def is_heading_like(raw_line: str, line_low: str) -> bool:
+        if (":" in raw_line) or ("–" in raw_line) or re.match(r"^\s*[-–]\s*", raw_line):
+            return True
+        if any(h in line_low for h in known_headings):
+            return True
+        # Simple title-style heuristic
+        if len(raw_line.strip()) <= 140:
+            words = re.findall(r"[A-Za-z][A-Za-z]+", raw_line)
+            cap_ratio = sum(1 for w in words if (w[0].isupper() or w.isupper())) / (len(words) or 1)
+            if cap_ratio >= 0.40:
+                return True
+        return False
+
     lines = [ln for ln in (section_text or "").splitlines() if ln.strip()]
     out: List[str] = []
 
     for ln in lines:
         low = ln.lower().strip()
 
+        # 1) Metadata heading boundary (best case)
         matched_heading = None
         for h in known_headings:
             if h in low:
@@ -362,6 +404,13 @@ def _cut_at_next_boundary_generic(section_text: str, best_doc: str, current_acti
             if (current_action and next_action and next_action != current_action) or (current_action is None):
                 break
 
+        # 2) Generic action boundary (works even if visible text != metadata title)
+        fam = detect_action_family_in_line(low)
+        if current_action and fam and fam != current_action:
+            # treat heading-like OR numbered lines as boundaries
+            if is_heading_like(ln, low) or STEP_PREFIX_RX.match(ln):
+                break
+
         out.append(ln)
 
     return "\n".join(out).strip()