scripts/build_life_streaming_cot.py

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import difflib
import json
import os
import random
import re
import shutil
import statistics
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any

import pandas as pd


DATASET_NAME = "LifeStreamingCoT"
REPO_ID = "skyzhou06/LifeStreamingCoT"
DATASET_VERSION = "v0.4"
GENERATION_METHOD = "source_grounded_rule_based_v0.4_quality_refined"
REASONING_POLICY = "selective_concise"
CHUNKING_METHOD = "semantic_sentence_split_v0.4_refined"
REFINEMENT_METHOD = "rule_based_quality_refinement_v0.4"
INSTRUCTION = "Help the user complete a real-life task based on gradually revealed information."
CACHE_DIR = Path(".lifesct_cache")
SOURCE_CACHE = CACHE_DIR / "v0_2_source_rows.jsonl"

BASE_FIELDS = [
    "id",
    "domain",
    "source_dataset",
    "instruction",
    "context",
    "context_chunks",
    "streaming_reasoning",
    "deep_reasoning",
    "answer",
    "response",
    "messages",
    "text",
    "num_chunks",
    "language",
    "split",
    "generation_method",
    "quality_flags",
    "version",
    "reasoning_policy",
    "chunking_method",
    "chunk_labels",
    "skip_chunks",
    "skip_reasons",
    "reasoning_token_budget",
    "original_num_chunks",
    "chunk_split_count",
]

V04_FIELDS = [
    "quality_score",
    "is_high_quality",
    "refinement_method",
    "llm_augmented",
    "llm_augmentation_model",
    "rejected_reason",
    "state_tracking_confidence",
]

REQUIRED_FIELDS = BASE_FIELDS + V04_FIELDS

REASONING_TOKEN_BUDGET = {
    "streaming_reasoning_max_words_per_chunk": 18,
    "deep_reasoning_max_words": 45,
    "answer_max_sentences": 3,
}

FORBIDDEN_GENERIC_PHRASES = [
    "the user is sharing everyday context",
    "the situation is about an everyday life situation",
    "the assistant should stay conversational",
    "the user is asking for help, clarification, or a next step",
    "support need centers on",
    "task_detail=noted",
    "emotion=positive; cause=",
    "emotion=negative; cause=",
    "given the full context",
    "tracked constraints so far",
]

BLOCKLIST = [
    "suicide",
    "self-harm",
    "self harm",
    "kill myself",
    "kill yourself",
    "sexual assault",
    "rape",
    "explicit sex",
    "porn",
    "build a gun",
    "make a bomb",
    "legal advice",
    "lawsuit",
    "attorney",
    "court case",
    "cocaine",
    "heroin",
    "methamphetamine",
    "credit card number",
    "social security number",
]

STOPWORDS = {
    "about",
    "after",
    "again",
    "also",
    "and",
    "are",
    "because",
    "before",
    "being",
    "but",
    "can",
    "could",
    "does",
    "doing",
    "for",
    "from",
    "get",
    "got",
    "good",
    "great",
    "had",
    "has",
    "have",
    "how",
    "into",
    "its",
    "it's",
    "just",
    "know",
    "later",
    "like",
    "more",
    "much",
    "need",
    "only",
    "please",
    "really",
    "should",
    "some",
    "sure",
    "that",
    "the",
    "their",
    "there",
    "these",
    "they",
    "thing",
    "things",
    "this",
    "time",
    "today",
    "want",
    "was",
    "were",
    "well",
    "what",
    "when",
    "where",
    "which",
    "with",
    "would",
    "yeah",
    "yes",
    "you",
    "your",
}

NUMBER_WORDS = {
    "one": 1,
    "two": 2,
    "three": 3,
    "four": 4,
    "five": 5,
    "six": 6,
    "seven": 7,
    "eight": 8,
    "nine": 9,
    "ten": 10,
}

SEVERE_FLAGS = {
    "generic_reasoning",
    "closing_mishandled",
    "possible_slot_error",
    "excessive_chunking",
    "fragment_chunk",
}

FLAG_PENALTIES = {
    "generic_reasoning": 0.20,
    "excessive_chunking": 0.15,
    "fragment_chunk": 0.15,
    "copied_source_response": 0.15,
    "closing_mishandled": 0.15,
    "short_answer": 0.10,
    "weak_context": 0.10,
    "low_specificity": 0.10,
    "possible_slot_error": 0.10,
    "too_many_skips": 0.05,
    "no_skip_labels": 0.05,
}


def clean_text(value: Any, max_chars: int = 420) -> str:
    if value is None:
        return ""
    if isinstance(value, (list, tuple)):
        value = " ".join(clean_text(item, max_chars=max_chars) for item in value)
    text = str(value)
    text = text.replace("_comma_", ",")
    text = text.replace("\r", " ").replace("\n", " ").replace("\t", " ")
    text = text.replace("\u2019", "'").replace("\u2018", "'")
    text = text.replace("\u201c", '"').replace("\u201d", '"')
    text = re.sub(r"<[^>]{1,40}>", " ", text)
    text = re.sub(r"\b(Mr|Mrs|Ms|Dr)\s+\.", r"\1.", text)
    text = re.sub(r"\b([A-Za-z])\s+'\s+([A-Za-z])", r"\1'\2", text)
    text = re.sub(r"\s+([,.!?;:])", r"\1", text)
    text = re.sub(r"\s+", " ", text).strip()
    text = re.sub(r"\b[\w.+-]+@[\w-]+\.[\w.-]+\b", "[email removed]", text)
    text = re.sub(r"\b(?:\+?\d[\d .()-]{7,}\d)\b", "[phone removed]", text)
    if len(text) > max_chars:
        cut = text[:max_chars].rsplit(" ", 1)[0].strip()
        text = f"{cut}."
    return text


def normalize(text: str) -> str:
    return re.sub(r"\W+", " ", text.lower()).strip()


def word_count(text: str) -> int:
    return len(re.findall(r"\b[\w'-]+\b", str(text)))


def tokenize_words(text: str) -> list[str]:
    return re.findall(r"[a-zA-Z][a-zA-Z'-]{2,}", text.lower())


def salient_terms(text: str, limit: int = 5) -> list[str]:
    terms: list[str] = []
    for word in tokenize_words(text):
        word = word.strip("'")
        if word not in STOPWORDS and word not in terms:
            terms.append(word)
        if len(terms) >= limit:
            break
    return terms


def compact_join(items: list[str], fallback: str = "") -> str:
    unique = [item for idx, item in enumerate(items) if item and item not in items[:idx]]
    if not unique:
        return fallback
    if len(unique) == 1:
        return unique[0]
    return ", ".join(unique[:-1]) + f", {unique[-1]}"


def finish_sentence(text: str) -> str:
    text = clean_text(text, max_chars=500)
    if text and text[-1] not in ".!?":
        text += "."
    return text


def read_jsonl(path: Path) -> list[dict[str, Any]]:
    rows: list[dict[str, Any]] = []
    if not path.exists():
        return rows
    with path.open("r", encoding="utf-8") as handle:
        for line in handle:
            line = line.strip()
            if line:
                rows.append(json.loads(line))
    return rows


def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as handle:
        for row in rows:
            handle.write(json.dumps(row, ensure_ascii=False) + "\n")


def parse_context_chunks(row: dict[str, Any]) -> list[str]:
    chunks = row.get("context_chunks")
    if isinstance(chunks, list):
        return [clean_text(chunk, max_chars=420) for chunk in chunks if clean_text(chunk)]
    parsed: list[str] = []
    for line in str(row.get("context") or "").splitlines():
        match = re.match(r"\s*Chunk\s+\d+\s*:\s*(.+)$", line)
        if match:
            parsed.append(clean_text(match.group(1), max_chars=420))
    return parsed


def load_source_rows(output_dir: Path) -> tuple[list[dict[str, Any]], list[dict[str, str]]]:
    CACHE_DIR.mkdir(parents=True, exist_ok=True)
    if SOURCE_CACHE.exists():
        return read_jsonl(SOURCE_CACHE), []
    local_rows = read_jsonl(output_dir / "data" / "train.jsonl") + read_jsonl(output_dir / "data" / "eval.jsonl")
    if local_rows:
        write_jsonl(SOURCE_CACHE, local_rows)
        return local_rows, [{"name": "local output", "reason": "v0.2 cache was missing; used local dataset rows"}]
    try:
        from datasets import load_dataset

        ds = load_dataset(REPO_ID)
        rows: list[dict[str, Any]] = []
        for split in ds:
            for row in ds[split]:
                rows.append(dict(row))
        if rows:
            write_jsonl(SOURCE_CACHE, rows)
            return rows, []
    except Exception as exc:  # noqa: BLE001
        return [], [{"name": REPO_ID, "reason": f"could not load existing dataset: {type(exc).__name__}"}]
    return [], [{"name": "source rows", "reason": "no local or remote source rows available"}]


def build_context(chunks: list[str]) -> str:
    return "\n".join(f"Chunk {idx}: {chunk}" for idx, chunk in enumerate(chunks, start=1))


def protect_abbreviations(text: str) -> str:
    for abbr in ["Mr.", "Mrs.", "Ms.", "Dr.", "Prof.", "St."]:
        text = text.replace(abbr, abbr.replace(".", "<prd>"))
    return text


def restore_abbreviations(text: str) -> str:
    return text.replace("<prd>", ".")


def split_plain_sentences(text: str) -> list[str]:
    text = clean_text(text, max_chars=700)
    if not text:
        return []
    protected = protect_abbreviations(text)
    pieces = re.split(r"(?<=[.!?])\s+|;\s+", protected)
    out: list[str] = []
    for piece in pieces:
        piece = restore_abbreviations(piece)
        piece = clean_text(piece, max_chars=320).strip(" ,;")
        if piece:
            out.append(finish_sentence(piece))
    return out or [finish_sentence(text)]


def skip_reason_for_text(text: str) -> str | None:
    lower = normalize(text)
    raw = text.lower()
    if not lower:
        return "low_information"
    strong_info = re.search(
        r"\b(address|phone|postcode|post code|reference|book|booking|reserve|restaurant|hotel|train|taxi|attraction|museum|cost|fee|travel time|can i|get|could you|would you)\b",
        raw,
    )
    if re.search(r"\b(that'?s all|that is all|that will be all|all i need(?:ed)?|everything i need(?:ed)?|that should be it|will be all|that was all i needed)\b", raw):
        return None if strong_info else "closing_only"
    if lower in {"hi", "hello", "hey", "good morning", "good afternoon", "good evening"}:
        return "greeting_only"
    if re.fullmatch(r"(great\s+)?thanks( so much)?( a lot)?( for your help( today)?)?", lower):
        return "thanks_only"
    if re.match(r"^(thank you|thanks|no thanks|no thank you|awesome thanks|great thanks)\b", lower) and not strong_info:
        return "thanks_only"
    if lower in {"goodbye", "bye", "see you", "see you later", "have a nice day", "have a great day"}:
        return "closing_only"
    if lower in {"ok", "okay", "alright", "sure", "sounds good", "fine", "got it", "really", "who", "what", "wow"}:
        return "backchannel_only" if lower in {"ok", "okay", "alright", "sure", "sounds good", "fine", "got it"} else "low_information"
    if lower in {"um", "uh", "hmm", "well", "let me see"}:
        return "filler_only"
    if lower in {"youre welcome", "you re welcome", "you're welcome", "you are welcome"}:
        return "acknowledgement_only"
    if re.fullmatch(r"(please|sorry|excuse me)[.!]?", raw.strip()):
        return "politeness_only"
    if word_count(text) <= 2 and not re.search(r"\b(book|yes|no|where|when|phone|address|cost|fee)\b", raw):
        return "low_information"
    return None


def is_closing_or_thanks(text: str) -> bool:
    return skip_reason_for_text(text) in {"thanks_only", "closing_only", "politeness_only"}


def is_meaningful_short_chunk(text: str) -> bool:
    lower = normalize(text)
    return lower in {"yes", "no", "ok", "okay", "thanks", "bye", "hello", "hi"} or bool(re.search(r"\b(stop|wait|leave|book|call|go|pay|wash|rinse|wipe|unplug)\b", lower))


def is_fragment_chunk(text: str) -> bool:
    stripped = clean_text(text, max_chars=80).strip()
    if not stripped:
        return True
    wc = word_count(stripped)
    if wc == 0:
        return True
    if wc <= 2 and re.fullmatch(r"[\W_]+", stripped):
        return True
    if re.fullmatch(r"(Mr|Mrs|Ms|Dr|Prof)\.?", stripped):
        return True
    if normalize(stripped) == "macmillan":
        return True
    if skip_reason_for_text(stripped) or is_meaningful_short_chunk(stripped):
        return False
    if wc <= 2 and re.fullmatch(r"[A-Z][a-z]+\.?", stripped):
        return True
    return False


def merge_fragments(chunks: list[str]) -> tuple[list[str], bool]:
    merged: list[str] = []
    changed = False
    prefix = ""
    for chunk in chunks:
        chunk = clean_text(chunk, max_chars=360)
        if not chunk:
            continue
        if is_fragment_chunk(chunk):
            changed = True
            if merged:
                merged[-1] = finish_sentence(merged[-1].rstrip(".!?") + " " + chunk.strip())
            else:
                prefix = f"{prefix} {chunk}".strip()
            continue
        if prefix:
            chunk = finish_sentence(prefix + " " + chunk)
            prefix = ""
        if word_count(chunk) < 4 and merged and not is_meaningful_short_chunk(chunk):
            changed = True
            merged[-1] = finish_sentence(merged[-1].rstrip(".!?") + " " + chunk)
        else:
            merged.append(finish_sentence(chunk))
    if prefix and merged:
        merged[-1] = finish_sentence(merged[-1].rstrip(".!?") + " " + prefix)
    return merged, changed


def split_on_conjunctions(text: str, domain: str) -> list[str]:
    text = clean_text(text, max_chars=700)
    if word_count(text) <= 30:
        return [finish_sentence(text)]
    patterns = [r",\s+and\s+I\s+", r"\s+and\s+I\s+", r",\s+then\s+", r"\s+then\s+", r"\s+before\s+"]
    if domain == "emotional_support":
        patterns.extend([r"\s+because\s+", r",\s+but\s+", r"\s+but\s+"])
    regex = "|".join(f"(?:{pattern})" for pattern in patterns)
    pieces = [clean_text(piece, max_chars=260).strip(" ,;") for piece in re.split(regex, text) if clean_text(piece)]
    if len(pieces) <= 1:
        return [finish_sentence(text)]
    merged, _ = merge_fragments([finish_sentence(piece) for piece in pieces if word_count(piece) >= 3])
    return merged or [finish_sentence(text)]


def contains_term(text: str, term: str) -> bool:
    if " " in term:
        return term in text
    return bool(re.search(rf"\b{re.escape(term)}\b", text))


def extract_task_details(text: str) -> dict[str, list[str]]:
    if is_closing_or_thanks(text):
        return {}
    lower = text.lower()
    details: dict[str, list[str]] = defaultdict(list)
    domain_terms = {
        "restaurant": ["restaurant", "food", "eat", "dinner", "lunch", "breakfast", "cuisine"],
        "hotel": ["hotel", "guesthouse", "guest house", "room", "stay", "lodging"],
        "taxi": ["taxi", "cab", "pickup", "pick me up"],
        "train": ["train", "rail", "station"],
        "attraction": ["museum", "park", "theatre", "theater", "attraction", "gallery", "college", "arts"],
        "hospital": ["hospital", "clinic"],
    }
    for label, terms in domain_terms.items():
        if any(contains_term(lower, term) for term in terms):
            details["domain"].append(label)
    if re.search(r"\b(find|looking for|look for|need|want|search|assist|help|getting|get me)\b", lower):
        details["goal"].append("search")
    if re.search(r"\b(book|booking|reservation|reserve)\b", lower):
        details["goal"].append("booking")
    if re.search(r"\b(recommend|suggest|favorite|what about|how about)\b", lower):
        details["goal"].append("recommendation")
    if re.search(r"\b(different|another|alternative|instead|else)\b", lower):
        details["goal"].append("compare_alternative")
    if re.search(r"\b(change|switch|make it|same price|same pricerange|same area)\b", lower):
        details["goal"].append("modify_constraint")
    if re.search(r"\b(can i|get|give me|tell me|what is|what's|how much|phone|address|postcode|reference|travel time|fee|cost)\b", lower):
        details["goal"].append("request_info")
    if re.search(r"\b(yes|that works|perfect|sounds good|that will be fine)\b", lower) and re.search(r"\b(book|reservation|option|one)\b", lower):
        details["goal"].append("confirm_booking")
    for price in ["cheap", "moderate", "expensive", "affordable", "budget", "not too expensive", "same pricerange", "same price"]:
        if price in lower:
            details["price"].append("affordable" if price == "budget" else price.replace("same pricerange", "same price range"))
    for area in ["north", "south", "east", "west", "centre", "center", "downtown", "campus"]:
        if re.search(rf"\b{re.escape(area)}\b", lower):
            details["area"].append("centre" if area == "center" else area)
    for cuisine in ["italian", "chinese", "indian", "korean", "thai", "french", "mexican", "japanese", "british", "vegetarian", "seafood", "danish", "persian", "european", "turkish"]:
        if re.search(rf"\b{cuisine}\b", lower):
            details["food"].append(cuisine)
    for day in ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday", "tomorrow"]:
        if re.search(rf"\b{day}\b", lower):
            details["day"].append(day)
    if re.search(r"\btoday\b", lower) and not is_closing_or_thanks(text):
        details["day"].append("today")
    for match in re.finditer(r"\b\d{1,2}(?::\d{2})?\s?(?:am|pm)?\b", lower):
        token = match.group(0).strip()
        window = lower[max(0, match.start() - 28) : min(len(lower), match.end() + 28)]
        if ":" in token or "am" in token or "pm" in token or re.search(r"\b(at|after|before|around|by|leave|arrive|time|starting)\b", window):
            details["time"].append(token)
    people_match = re.search(r"\b(?:for|party of|it would be|there will be|we are)\s+(\d+)\s+(?:people|guests|persons)\b", lower)
    if people_match:
        details["party_size"].append(f"{people_match.group(1)} people")
    else:
        bare_people_match = re.search(r"\b(\d+)\s+(?:people|guests|persons)\b", lower)
        if bare_people_match:
            details["party_size"].append(f"{bare_people_match.group(1)} people")
    if not details.get("party_size"):
        phrase_match = re.search(r"\bfor\s+the\s+(\w+)\s+of\s+us\b", lower)
        if phrase_match and phrase_match.group(1) in NUMBER_WORDS:
            details["party_size"].append(f"{NUMBER_WORDS[phrase_match.group(1)]} people")
    if not details.get("party_size"):
        for word, number in NUMBER_WORDS.items():
            if re.search(rf"\b{word}\b[^.?!]{{0,20}}\b(people|guests|of us)\b", lower):
                details["party_size"].append(f"{number} people")
                break
    stay_match = re.search(r"\b(\d+)\s+nights?\b", lower)
    if stay_match:
        details["stay_length"].append(f"{stay_match.group(1)} nights")
    star_match = re.search(r"\b(\d+)\s*stars?\b", lower)
    if star_match:
        details["stars"].append(f"{star_match.group(1)} stars")
    for amenity in ["parking", "wifi", "internet", "free parking", "pool", "breakfast"]:
        if amenity in lower:
            details["amenities"].append(amenity)
    if "guesthouse" in lower or "guest house" in lower:
        details["hotel_type"].append("guesthouse")
    if "hotel" in lower:
        details["hotel_type"].append("hotel")
    route_match = re.search(r"\bfrom\s+(.+?)\s+(?:to|going to)\s+([^,.?]+)", lower)
    if route_match:
        details["departure"].append(re.sub(r"\b(going|on|at|after|before)\b.*$", "", route_match.group(1)).strip())
        destination = re.sub(r"\b(on|at|after|before)\b.*$", "", route_match.group(2)).strip()
        details["destination"].append(destination)
    depart_match = re.search(r"\bdepart(?:ing)? from\s+([^,.?]+)", lower)
    if depart_match:
        details["departure"].append(depart_match.group(1).strip())
    dest_match = re.search(r"\b(?:going to|heading to|arrive at|to)\s+([A-Z]?[a-z][^,.?]{2,40})", text)
    if dest_match and " from " not in lower and " to " not in lower[:8]:
        candidate = clean_text(dest_match.group(1), max_chars=60).lower()
        if not any(stop in candidate for stop in ["get ", "see ", "help", "book"]):
            details["destination"].append(candidate)
    if "no area preference" in lower or "any area" in lower:
        details["area"].append("any")
    if re.search(r"\bpark\b", lower):
        details["domain"].append("attraction")
        details["type"].append("park")
    info_map = [
        ("address", "address"),
        ("phone", "phone"),
        ("telephone", "phone"),
        ("postcode", "postcode"),
        ("post code", "postcode"),
        ("postal code", "postcode"),
        ("reference", "reference_number"),
        ("travel time", "travel_time"),
        ("entrance fee", "entrance_fee"),
        ("admission", "entrance_fee"),
        ("cost", "price"),
        ("price", "price"),
        ("recommendation", "recommendation"),
    ]
    requestish = bool(re.search(r"\b(can you|could you|tell me|give me|what is|what's|how much|how long|need|need a|need an|i'll need|get a|get the)\b", lower))
    for needle, label in info_map:
        if re.search(rf"\b{re.escape(needle)}\b", lower):
            always_info = label in {"phone", "address", "postcode", "reference_number", "travel_time", "entrance_fee"}
            if always_info or requestish:
                details["requested_info"].append(label)
    if re.search(r"\bhow long\b.*\b(journey|trip|travel|take)\b|\bjourney take\b", lower):
        details["requested_info"].append("travel_time")
    if re.search(r"\bfine arts?\b", lower):
        details["type"].append("fine_arts_museum")
    if re.search(r"\bsports?\b", lower):
        details["type"].append("sports")
    return {key: list(dict.fromkeys(values)) for key, values in details.items()}


def semantic_split_task(text: str) -> list[str]:
    if is_closing_or_thanks(text):
        return split_plain_sentences(text)
    details = extract_task_details(text)
    slot_count = sum(len(values) for key, values in details.items() if key not in {"goal"})
    if word_count(text) >= 18 and slot_count >= 4:
        chunks: list[str] = []
        domains = details.get("domain", [])
        if "restaurant" in domains:
            desc = " ".join(part for part in [details.get("price", [""])[0], details.get("food", [""])[0], "restaurant"] if part)
            chunks.append(f"I want to find a {desc}.")
        elif "hotel" in domains:
            desc = " ".join(part for part in [details.get("price", [""])[0], details.get("hotel_type", ["hotel"])[0]] if part)
            chunks.append(f"I want to find a {desc}.")
        elif domains:
            chunks.append(f"I need help with {domains[0]}.")
        if details.get("area"):
            chunks.append(f"It should be in the {details['area'][0]} part of town.")
        if details.get("party_size"):
            chunks.append(f"It is for {details['party_size'][0]}.")
        if details.get("day") or details.get("time"):
            when = compact_join(details.get("day", []) + details.get("time", []))
            chunks.append(f"The time is {when}.")
        if details.get("goal") and "booking" in details["goal"]:
            chunks.append("Please make a booking.")
        for info in details.get("requested_info", []):
            chunks.append(f"I also need the {info.replace('_', ' ')}.")
        if len(chunks) >= 2:
            return chunks
    out: list[str] = []
    for sentence in split_plain_sentences(text):
        if word_count(sentence) > 30:
            out.extend(split_on_conjunctions(sentence, "task_oriented_assistant"))
        else:
            out.append(sentence)
    return out


def semantic_split_emotional(text: str) -> list[str]:
    text = clean_text(text, max_chars=700)
    if word_count(text) <= 25:
        return split_plain_sentences(text)
    pieces = re.split(r"(?<=[.!?])\s+|,\s+and\s+I\s+|\s+and\s+I\s+|,\s+because\s+|\s+because\s+|,\s+but\s+|\s+but\s+", text, flags=re.IGNORECASE)
    pieces = [finish_sentence(piece.strip(" ,;")) for piece in pieces if word_count(piece) >= 4]
    return pieces if len(pieces) > 1 else split_plain_sentences(text)


def semantic_split_daily(text: str) -> list[str]:
    out: list[str] = []
    for sentence in split_plain_sentences(text):
        if word_count(sentence) > 30:
            out.extend(split_on_conjunctions(sentence, "daily_dialogue"))
        else:
            out.append(sentence)
    return out


def semantic_split_how_to(text: str) -> list[str]:
    text = clean_text(text, max_chars=700)
    if text.lower().startswith("task:") or word_count(text) <= 30:
        return [finish_sentence(text)]
    pieces = re.split(r"(?<=[.!?])\s+|;\s+|,\s+then\s+|,\s+before\s+|\s+then\s+|\s+before\s+", text, flags=re.IGNORECASE)
    pieces = [finish_sentence(piece.strip(" ,;")) for piece in pieces if word_count(piece) >= 4]
    return pieces if len(pieces) > 1 else [finish_sentence(text)]


def semantic_split_utterance(text: str, domain: str) -> tuple[list[str], bool]:
    text = clean_text(text, max_chars=700)
    if not text:
        return [], False
    if domain == "task_oriented_assistant":
        chunks = semantic_split_task(text)
    elif domain == "emotional_support":
        chunks = semantic_split_emotional(text)
    elif domain == "how_to_guidance":
        chunks = semantic_split_how_to(text)
    else:
        chunks = semantic_split_daily(text)
    merged, changed = merge_fragments(chunks)
    return merged or [finish_sentence(text)], changed


def detect_emotion(text: str) -> str:
    lower = text.lower()
    rules = [
        ("proud", ["proud", "accomplished", "achievement", "graduated", "promotion"]),
        ("happy", ["happy", "excited", "glad", "thrilled", "relieved", "wonderful"]),
        ("stressed", ["stressed", "stress", "overwhelmed", "burned out", "too much", "busy"]),
        ("anxious", ["anxious", "nervous", "panic", "afraid", "scared", "scary", "freaked", "embarrassing", "embarrassed"]),
        ("worried", ["worried", "worry", "concerned"]),
        ("sad", ["sad", "upset", "cry", "heartbroken", "grief"]),
        ("disappointed", ["disappointed", "let down", "failed", "badly", "poorly"]),
        ("frustrated", ["frustrated", "furious", "angry", "mad", "annoyed"]),
        ("lonely", ["lonely", "alone", "miss her", "miss him", "miss them"]),
        ("confused", ["confused", "unsure", "not sure", "don't know", "dont know"]),
    ]
    for label, words in rules:
        if any(word in lower for word in words):
            return label
    return "neutral"


def clean_cause_phrase(phrase: str) -> str:
    phrase = clean_text(phrase, max_chars=180).strip(" .")
    phrase = re.sub(r"^(i am|i'm|i feel|i felt|i get|i was|because|when|after)\s+", "", phrase, flags=re.IGNORECASE)
    phrase = re.sub(r"\b(stressed|anxious|worried|sad|happy|excited|disappointed|frustrated|furious|angry|lonely|confused|proud|scared|scary|embarrassed|embarrassing)\b", "", phrase, flags=re.IGNORECASE)
    phrase = re.sub(r"\bi\s+(?:was|am|feel|felt)\s*$", "", phrase, flags=re.IGNORECASE)
    phrase = re.sub(r"\s+", " ", phrase).strip(" ,.")
    words = phrase.split()
    if len(words) > 12:
        phrase = " ".join(words[:12])
    return phrase


def extract_emotional_cause(text: str) -> str:
    lower = text.lower()
    if re.search(r"\b(that must have been|i bet you|you'll be fine|did they|what game|what language|would'?ve freaked|would have freaked)\b", lower):
        return ""
    won_match = re.search(r"\bwhen\s+(.+?)\s+i\s+(?:was|felt)\s+(?:happy|excited|proud|glad|thrilled)\b", text, flags=re.IGNORECASE)
    if won_match:
        phrase = clean_cause_phrase(won_match.group(1))
        if word_count(phrase) >= 3:
            return phrase
    patterns = [
        r"\bbecause\s+(.+?)(?:[.!?]|$)",
        r"\bafter\s+(.+?)(?:[.!?]|$)",
        r"\bwhen\s+(.+?)(?:[.!?]|$)",
        r"\babout\s+(.+?)(?:[.!?]|$)",
    ]
    for pattern in patterns:
        match = re.search(pattern, text, flags=re.IGNORECASE)
        if match:
            phrase = clean_cause_phrase(match.group(1))
            if word_count(phrase) >= 3:
                return phrase
    if re.search(r"\bstudied\b.*\b(exam|test)\b", lower):
        return "studied hard but the exam went poorly"
    if re.search(r"\bcar\b.{0,40}\b(died|broke down|stopped)\b", lower):
        return "car broke down at night"
    if re.search(r"\btripped\b", lower):
        return "tripped in front of other people"
    if re.search(r"\bforeign language class\b", lower):
        return "worried about a required foreign language class"
    if re.search(r"\bspeak it in front of others\b", lower):
        return "worried about speaking in front of others"
    if re.search(r"\btime\b.*\b(flying|goes by|faster)\b", lower):
        return "time seems to be passing quickly"
    if re.search(r"\bvacation request\b", lower):
        return "vacation request may be denied"
    if re.search(r"\b(passed away|died)\b", lower) and not re.search(r"\b(car|phone|battery|engine|lights?)\b", lower):
        return "someone important passed away"
    if re.search(r"\bfriend|relationship|family|brother|sister|parent|grandmother|grandpa\b", lower):
        return clean_cause_phrase(text) or "a relationship or family situation"
    phrase = clean_cause_phrase(text)
    if word_count(phrase) >= 3 and re.search(r"\b(i|my|we|our)\b", lower) and detect_emotion(text) != "neutral":
        return phrase
    return ""


def detect_user_need(text: str, emotion: str, cause: str) -> str:
    lower = text.lower()
    if re.search(r"\b(what should|how do|how can|advice|help me|catch up|plan)\b", lower):
        return "planning_help" if "plan" in lower or "catch up" in lower else "practical_next_step"
    if "?" in text:
        return "clarification"
    if emotion in {"happy", "proud"}:
        return "celebration"
    if emotion in {"anxious", "worried", "confused"}:
        return "reassurance"
    if emotion in {"sad", "disappointed", "frustrated", "lonely", "stressed"}:
        return "validation"
    return "encouragement" if cause else "validation"


def classify_chunk(chunk: str, previous_chunks: list[str], domain: str, state: dict[str, Any]) -> tuple[str, str]:
    lower = chunk.lower().strip()
    base_skip = skip_reason_for_text(chunk)
    if re.fullmatch(r"(okay|ok)[.!]?", lower):
        return "skip", base_skip or "backchannel_only"
    if re.fullmatch(r"(yes|yeah|yep|sure|sounds good)[.!]?", lower):
        if state.get("proposal_pending") or state.get("booking_intent") or "book" in " ".join(previous_chunks).lower():
            return "reason", "booking_confirmation" if domain == "task_oriented_assistant" else "decision_point"
        return "skip", base_skip or "acknowledgement_only"
    if re.fullmatch(r"(no|nope|nah)[.!]?", lower):
        if state.get("proposal_pending") or state.get("booking_intent") or re.search(r"\b(anything else|more|book|confirm)\b", " ".join(previous_chunks).lower()):
            return "reason", "decision_point"
        return "skip", "acknowledgement_only"
    if base_skip:
        return "skip", base_skip
    terms = salient_terms(chunk, 5)
    seen = set(state.get("seen_terms", []))
    if terms and set(terms).issubset(seen) and word_count(chunk) <= 26:
        return "skip", "repeated_information"
    if domain == "task_oriented_assistant":
        details = extract_task_details(chunk)
        if details.get("goal") or details.get("domain") or details.get("requested_info"):
            return "reason", details.get("goal", ["new_constraint"])[0]
        return "reason", "new_constraint"
    if domain == "emotional_support":
        emotion = detect_emotion(chunk)
        if emotion != "neutral":
            return "reason", "new_emotion"
        if extract_emotional_cause(chunk):
            return "reason", "new_cause"
        return "reason", "new_request" if "?" in chunk else "task_progress_update"
    if domain == "how_to_guidance":
        return "reason", "safety_or_order_constraint" if re.search(r"\b(turn off|unplug|avoid|careful|before|do not|don't)\b", lower) else "task_progress_update"
    return "reason", "daily_state_update"


def state_add(state: dict[str, Any], key: str, values: list[str]) -> list[str]:
    state.setdefault(key, [])
    added: list[str] = []
    for value in values:
        if value and value not in state[key]:
            state[key].append(value)
            added.append(value)
    return added


def update_seen_terms(state: dict[str, Any], chunk: str) -> None:
    seen = state.setdefault("seen_terms", [])
    for term in salient_terms(chunk, 5):
        if term not in seen:
            seen.append(term)


def task_update(chunk: str, state: dict[str, Any]) -> str:
    details = extract_task_details(chunk)
    if is_closing_or_thanks(chunk):
        state["closing_detected"] = True
        return "goal=closing"
    pieces: list[str] = []
    for key in ["domain", "goal", "area", "food", "price", "time", "day", "party_size", "stay_length", "hotel_type", "stars", "amenities", "destination", "departure", "requested_info", "type"]:
        added = state_add(state, key, details.get(key, []))
        if not added:
            continue
        label = "cuisine" if key == "food" else key
        if key == "goal" and "booking" in added:
            state["booking_intent"] = True
        if key == "requested_info":
            pieces.append(f"requested_info+={compact_join(added)}")
        elif key == "domain":
            pieces.append(f"domain={added[-1]}")
        elif key == "goal":
            pieces.append(f"goal={added[-1]}")
        else:
            pieces.append(f"{label}+={compact_join(added)}")
    if re.search(r"\b(yes|perfect|sounds good|that works|that will be fine)\b", chunk.lower()):
        if state.get("booking_intent"):
            pieces.append("goal=confirm_booking")
        else:
            pieces.append("acceptance=selected_option")
    if "not picky" in chunk.lower() or "isn't important" in chunk.lower():
        pieces.append("preference=flexible")
    if not pieces:
        if "?" in chunk:
            pieces.append("goal=request_info")
        elif re.search(r"\b(no|not|instead|second thought)\b", chunk.lower()):
            pieces.append("goal=modify_constraint")
        else:
            pieces.append("intent=context_update")
    return "; ".join(pieces)


def emotional_update(chunk: str, state: dict[str, Any]) -> str:
    emotion = detect_emotion(chunk)
    cause = extract_emotional_cause(chunk)
    need = detect_user_need(chunk, emotion, cause)
    pieces: list[str] = []
    if emotion != "neutral":
        state["emotion"] = emotion
        pieces.append(f"emotion={emotion}")
    if cause and (not state.get("cause") or emotion != "neutral" or cause.startswith("worried about speaking")):
        state["cause"] = cause
        if emotion in {"happy", "proud"}:
            pieces.append(f"event={cause}")
        else:
            pieces.append(f"cause={cause}")
    stable_needs = {"reassurance", "celebration", "planning_help", "practical_next_step"}
    if (
        need
        and need != state.get("user_need")
        and (emotion != "neutral" or cause or not state.get("user_need"))
        and not (emotion == "neutral" and state.get("user_need") in stable_needs and need in {"encouragement", "validation"})
    ):
        state["user_need"] = need
        pieces.append(f"need={need}")
    if not pieces:
        return "support_signal=received"
    return "; ".join(pieces)


def daily_label_and_value(chunk: str, state: dict[str, Any]) -> str:
    lower = chunk.lower()
    if re.search(r"\b(drive safely|safe drive|icy roads?|ice on the roads?|be careful)\b", lower):
        state["safety_reminder"] = True
        return "safety_reminder=icy_roads" if "ice" in lower or "icy" in lower else "safety_reminder=true"
    if re.search(r"\b(have to|must|had better|need to)\s+(go|leave|head off|be going)\b|\bi'?m afraid i have to go\b", lower):
        state["closing"] = True
        return "leaving_reason=needs_to_go"
    dinner_plan = re.search(r"\b(?:i'?m|i am|we'?re|we are)\s+(?:meeting|going to meet)\s+(.+?)\s+for\s+dinner\b", lower)
    if dinner_plan:
        person = clean_text(dinner_plan.group(1), max_chars=50).replace("my ", "")
        state["plan_update"] = True
        return f"plan_update=dinner_with_{normalize(person).replace(' ', '_') or 'someone'}"
    if re.search(r"\b(would you like(?:\s+to|\s+a|\s+some)?|do you want to|want to come|invite you|join me|come with me)\b", lower):
        state["proposal_pending"] = True
        state["invitation"] = True
        return "invitation=true"
    if re.search(r"\b(can you|could you|may i|would you)\b", lower) or "?" in chunk:
        state["question"] = True
        return "question=true"
    if re.search(r"\b(i'll keep it in mind|keep that in mind|thanks for the advice|advice)\b", lower):
        state["advice_received"] = True
        return "advice_received=true"
    if re.search(r"\b(can't|cannot|busy|appointment|schedule conflict|have to work|at work|in class)\b", lower):
        state["schedule_conflict"] = True
        return "schedule_conflict=true"
    if re.search(r"\b(yes|sure|sounds good|why not|ok|okay)\b", lower) and state.get("proposal_pending"):
        state["acceptance"] = True
        return "acceptance=true"
    if re.search(r"\b(no|can't|cannot|not possible)\b", lower) and state.get("proposal_pending"):
        state["refusal"] = True
        return "refusal=true"
    if re.search(r"\b(prefer|like|would rather|favorite)\b", lower):
        state["preference"] = True
        return "preference=true"
    if is_closing_or_thanks(chunk):
        state["closing"] = True
        return "closing=true"
    terms = salient_terms(chunk, 3)
    state_add(state, "casual_terms", terms[:2])
    return f"casual_comment={compact_join(terms[:2], 'context')}"


def action_label(chunk: str) -> str:
    text = re.sub(r"^Task:\s*", "", clean_text(chunk, max_chars=180), flags=re.IGNORECASE)
    text = re.sub(r"[•*]+", " ", text)
    words = text.strip(" .").split()
    if not words:
        return "continue"
    return "_".join(re.sub(r"[^a-z0-9]+", "", word.lower()) for word in words[:4]).strip("_") or "continue"


def action_text(chunk: str, max_words: int = 10) -> str:
    text = re.sub(r"^Task:\s*", "", clean_text(chunk, max_chars=260), flags=re.IGNORECASE)
    text = re.sub(r"[•*]+", " ", text)
    text = re.sub(r"\([^)]{0,80}\)", " ", text)
    text = re.sub(r"\s+", " ", text).strip(" .;:-")
    return " ".join(text.split()[:max_words]) or "continue"


def how_to_update(chunk: str, state: dict[str, Any], idx: int) -> str:
    lower = chunk.lower()
    if lower.startswith("task:") or (idx == 1 and not state.get("task")):
        state["task"] = action_label(chunk)
        state["task_text"] = action_text(chunk, 8)
        return f"task={state['task']}"
    label = action_label(chunk)
    state_add(state, "steps", [label])
    state_add(state, "step_texts", [action_text(chunk)])
    if re.search(r"\b(turn off|unplug|avoid|careful|before|do not|don't|must)\b", lower):
        state_add(state, "safety", [label])
        return f"step={label}; safety=true"
    return f"step={label}"


def build_reasoning(domain: str, chunks: list[str]) -> tuple[str, str, list[str], list[int], dict[str, str], dict[str, Any]]:
    state: dict[str, Any] = {}
    parts: list[str] = []
    labels: list[str] = []
    skip_chunks: list[int] = []
    skip_reasons: dict[str, str] = {}
    previous: list[str] = []
    for idx, chunk in enumerate(chunks, start=1):
        label, reason = classify_chunk(chunk, previous, domain, state)
        if label == "skip":
            labels.append("skip")
            skip_chunks.append(idx)
            skip_reasons[str(idx)] = reason
            if reason in {"closing_only", "thanks_only"}:
                state["closing_detected" if domain == "task_oriented_assistant" else "closing"] = True
            parts.append(f"C{idx} [SKIP: {reason}].")
        else:
            labels.append("reason")
            if domain == "task_oriented_assistant":
                update = task_update(chunk, state)
            elif domain == "emotional_support":
                update = emotional_update(chunk, state)
            elif domain == "how_to_guidance":
                update = how_to_update(chunk, state, idx)
            else:
                update = daily_label_and_value(chunk, state)
            parts.append(f"C{idx} {update}.")
        update_seen_terms(state, chunk)
        previous.append(chunk)
    streaming = " ".join(parts)
    deep = build_deep_reasoning(domain, state, chunks)
    return streaming, deep, labels, skip_chunks, skip_reasons, state


def build_deep_reasoning(domain: str, state: dict[str, Any], chunks: list[str]) -> str:
    if domain == "task_oriented_assistant":
        bits: list[str] = []
        if state.get("domain"):
            bits.append(f"domain={compact_join(state['domain'])}")
        if state.get("goal"):
            bits.append(f"goal={compact_join(state['goal'])}")
        for key in ["area", "food", "price", "party_size", "stay_length", "stars", "amenities", "destination", "departure", "requested_info"]:
            if state.get(key):
                bits.append(f"{key}={compact_join(state[key])}")
        when = state.get("day", []) + state.get("time", [])
        if when:
            bits.append(f"when={compact_join(when)}")
        if state.get("closing_detected"):
            bits.append("closing_detected")
        return "Need " + "; ".join(bits) + "." if bits else "Need more concrete task details before acting."
    if domain == "emotional_support":
        emotion = state.get("emotion", "neutral")
        cause = state.get("cause", "the situation")
        need = state.get("user_need", "validation")
        if emotion == "neutral":
            return f"User is processing {cause} and needs {need}."
        if emotion in {"happy", "proud"}:
            return f"User feels {emotion} because {cause} and needs {need}."
        return f"User feels {emotion} after {cause} and needs {need}."
    if domain == "how_to_guidance":
        task = state.get("task_text") or (state.get("task") or action_label(chunks[0] if chunks else "task")).replace("_", " ")
        steps = compact_join(state.get("step_texts", [])[:5], "ordered steps")
        safety = "; keep safety/order constraints" if state.get("safety") else ""
        return f"Procedure for {task}: {steps}{safety}."
    if state.get("safety_reminder"):
        return "Conversation is closing with a safety reminder; answer politely and acknowledge caution."
    if state.get("closing"):
        return "Conversation is closing; answer politely without adding a new task."
    daily_bits: list[str] = []
    if state.get("invitation"):
        daily_bits.append("invitation")
    if state.get("question"):
        daily_bits.append("question")
    if state.get("plan_update"):
        daily_bits.append("plan update")
    if state.get("schedule_conflict"):
        daily_bits.append("schedule conflict")
    if state.get("preference"):
        daily_bits.append("preference")
    if state.get("advice_received"):
        daily_bits.append("advice received")
    topic = compact_join(state.get("casual_terms", [])[:4], "current topic")
    if daily_bits:
        return f"Dialogue state: {compact_join(daily_bits)} around {topic}; respond briefly."
    return f"Dialogue state: casual exchange about {topic}; respond briefly."


def missing_task_slots(state: dict[str, Any]) -> list[str]:
    domains = set(state.get("domain", []))
    missing: list[str] = []
    if "restaurant" in domains:
        for key, label in [("area", "area"), ("food", "cuisine"), ("price", "price range")]:
            if not state.get(key):
                missing.append(label)
    if "hotel" in domains:
        for key, label in [("area", "area"), ("price", "price range"), ("day", "date"), ("party_size", "guests")]:
            if not state.get(key):
                missing.append(label)
    if domains & {"taxi", "train"}:
        for key, label in [("destination", "destination"), ("departure", "departure"), ("day", "date"), ("time", "time")]:
            if not state.get(key):
                missing.append(label)
    return missing[:2]


def build_task_answer(state: dict[str, Any]) -> str:
    if state.get("closing_detected"):
        return "You're welcome. Glad I could help; have a great day."
    if state.get("requested_info"):
        return f"I can help with that and include the {compact_join(state['requested_info']).replace('_', ' ')} once I find the matching option."
    missing = missing_task_slots(state)
    if missing:
        return f"What {compact_join(missing)} should I use for the search?"
    pieces = []
    if state.get("domain"):
        pieces.append(compact_join(state["domain"]))
    for key in ["area", "food", "price", "party_size"]:
        if state.get(key):
            pieces.append(compact_join(state[key]))
    if state.get("day") or state.get("time"):
        pieces.append(compact_join(state.get("day", []) + state.get("time", [])))
    return f"Got it. I will use {compact_join(pieces, 'those details')} and move the task forward."


def build_emotional_answer(state: dict[str, Any]) -> str:
    emotion = state.get("emotion", "neutral")
    cause = state.get("cause", "what happened")
    need = state.get("user_need", "validation")
    if emotion == "neutral":
        return f"That sounds like a lot to process, especially with {cause}. Start with one small next step and give yourself room to sort it out."
    if emotion in {"happy", "proud"}:
        return f"That is worth celebrating, especially because {cause}. Take a moment to enjoy it and share the good news with someone who will be happy for you."
    if need in {"planning_help", "practical_next_step"}:
        return f"That is frustrating, especially after {cause}. Start with one concrete next step, then focus your energy on the part you can control today."
    if need == "reassurance":
        return f"It makes sense to feel {emotion} after {cause}. Slow down, check what is actually known, and take one small step before deciding what comes next."
    return f"It makes sense to feel {emotion} after {cause}. Give yourself a moment, then choose one manageable action instead of trying to solve everything at once."


def build_how_to_answer(state: dict[str, Any], chunks: list[str]) -> str:
    task = state.get("task_text") or (state.get("task") or action_label(chunks[0] if chunks else "task")).replace("_", " ")
    steps = state.get("step_texts", [])[:4] or [action_text(chunk) for chunk in chunks[:4]]
    caution = " Keep the order and pause if a step seems unsafe." if state.get("safety") else ""
    return f"For {task}, follow the steps in order: {compact_join(steps)}.{caution}".strip()


def build_daily_answer(state: dict[str, Any], chunks: list[str]) -> str:
    if state.get("safety_reminder"):
        return "Thanks, I'll be careful. See you next time."
    if state.get("closing"):
        return "Sounds good. Take care, and see you next time."
    joined = " ".join(chunks).lower()
    if state.get("invitation"):
        return "That sounds nice. I can join; what time should I be there?"
    if state.get("question"):
        topic = compact_join(salient_terms(" ".join(chunks), 4), "the situation")
        return f"Good question. The main topic is {topic}, so I would answer that directly first."
    if "dinner" in joined and "meeting" in joined:
        return "Thanks, I should head out for dinner now. See you next time."
    topic = compact_join(salient_terms(" ".join(chunks), 4), "the situation")
    return f"Got it. The main point is {topic}, so I will keep the reply brief and clear."


def build_answer(domain: str, state: dict[str, Any], chunks: list[str]) -> str:
    if domain == "task_oriented_assistant":
        answer = build_task_answer(state)
    elif domain == "emotional_support":
        answer = build_emotional_answer(state)
    elif domain == "how_to_guidance":
        answer = build_how_to_answer(state, chunks)
    else:
        answer = build_daily_answer(state, chunks)
    return " ".join(re.split(r"(?<=[.!?])\s+", finish_sentence(answer))[:3]).strip()


def copied_ratio(answer: str, source_answer: str | None) -> float:
    source = normalize(source_answer or "")
    generated = normalize(answer)
    if not source or not generated:
        return 0.0
    if source in generated or generated in source:
        return 1.0
    return difflib.SequenceMatcher(None, source, generated).ratio()


def has_forbidden_phrase(*texts: str) -> bool:
    joined = "\n".join(texts).lower()
    return any(phrase in joined for phrase in FORBIDDEN_GENERIC_PHRASES)


def is_safe_example(chunks: list[str], answer: str) -> bool:
    joined = " ".join(chunks + [answer]).lower()
    if any(term in joined for term in BLOCKLIST):
        return False
    if "[email removed]" in joined or "[phone removed]" in joined:
        return False
    return sum(word_count(chunk) for chunk in chunks) >= 8 and word_count(answer) >= 3


def is_undesired_how_to(chunks: list[str]) -> bool:
    joined = " ".join(chunks).lower()
    off_topic = [
        "windows movie maker",
        "movie maker",
        "inshot",
        "pinterest",
        "ipod",
        "jailbreak",
        "slackline",
        "bonfire",
        "lighter fluid",
        "synthetic coon",
        "manga",
        "runescape",
        "minecraft",
        "photoshop",
        "illustrator",
        "html",
        "css",
        "javascript",
        "server",
        "login",
        "paypal",
        "twitter",
        "instagram",
        "tiktok",
    ]
    return any(term in joined for term in off_topic)


def compute_quality_flags(
    domain: str,
    chunks: list[str],
    labels: list[str],
    state: dict[str, Any],
    source_answer: str | None,
    streaming_reasoning: str,
    deep_reasoning: str,
    answer: str,
    merged_fragments: bool,
) -> list[str]:
    flags: list[str] = []
    if word_count(streaming_reasoning) > 160:
        flags.append("long_streaming_reasoning")
    if word_count(deep_reasoning) > 60:
        flags.append("long_deep_reasoning")
    if any(skip_reason_for_text(chunk) for chunk in chunks) and "skip" not in labels:
        flags.append("no_skip_labels")
    if labels and labels.count("skip") / len(labels) > 0.70:
        flags.append("too_many_skips")
    avg_chunk_words = statistics.mean(word_count(chunk) for chunk in chunks) if chunks else 0
    if avg_chunk_words < 4 or len(chunks) > 12:
        flags.append("excessive_chunking")
    if any(is_fragment_chunk(chunk) for chunk in chunks):
        flags.append("fragment_chunk")
    if merged_fragments:
        flags.append("merged_fragments")
    if has_forbidden_phrase(streaming_reasoning, deep_reasoning, answer):
        flags.append("generic_reasoning")
    if copied_ratio(answer, source_answer) >= 0.72:
        flags.append("copied_source_response")
    if word_count(answer) < 5:
        flags.append("short_answer")
    if len(chunks) < 2 or sum(word_count(chunk) for chunk in chunks) < 12:
        flags.append("weak_context")
    if is_closing_or_thanks(" ".join(chunks)) and "today" in state.get("day", []):
        flags.append("possible_slot_error")
    if (state.get("closing_detected") or state.get("closing")) and re.search(r"\?|please confirm|what .*should|share .*", answer.lower()):
        flags.append("closing_mishandled")
    if domain == "task_oriented_assistant" and not any(state.get(key) for key in ["domain", "goal", "requested_info", "destination", "departure"]):
        flags.append("low_specificity")
    if domain == "emotional_support" and re.search(r"\b[a-z]+,\s+[a-z]+,\s+[a-z]+", deep_reasoning.lower()):
        flags.append("generic_reasoning")
    return list(dict.fromkeys(flags))


def compute_state_tracking_confidence(domain: str, state: dict[str, Any], flags: list[str]) -> float:
    score = 0.85
    if domain == "task_oriented_assistant":
        if state.get("domain"):
            score += 0.06
        if state.get("goal"):
            score += 0.05
        if state.get("requested_info"):
            score += 0.03
    elif domain == "emotional_support":
        if state.get("emotion") and state.get("emotion") != "neutral":
            score += 0.06
        if state.get("cause"):
            score += 0.05
        if state.get("user_need"):
            score += 0.03
    elif domain == "daily_dialogue":
        if state.get("closing") or state.get("safety_reminder") or state.get("proposal_pending"):
            score += 0.04
    else:
        if state.get("steps"):
            score += 0.06
    score -= 0.05 * len([flag for flag in flags if flag in SEVERE_FLAGS])
    return round(max(0.0, min(1.0, score)), 3)


def compute_quality_score(flags: list[str], streaming_reasoning: str, deep_reasoning: str) -> float:
    score = 1.0
    for flag in set(flags):
        score -= FLAG_PENALTIES.get(flag, 0.0)
    if word_count(streaming_reasoning) > 120:
        score -= 0.05
    if word_count(deep_reasoning) > 45:
        score -= 0.05
    return round(max(0.0, min(1.0, score)), 3)


def is_high_quality_row(row: dict[str, Any]) -> bool:
    flags = set(row.get("quality_flags", []))
    return (
        row.get("quality_score", 0) >= 0.85
        and not (flags & SEVERE_FLAGS)
        and word_count(row.get("streaming_reasoning", "")) <= 120
        and word_count(row.get("deep_reasoning", "")) <= 45
        and not has_forbidden_phrase(row.get("streaming_reasoning", ""), row.get("deep_reasoning", ""), row.get("answer", ""))
    )


def make_response(streaming_reasoning: str, deep_reasoning: str, answer: str) -> str:
    return f"Streaming reasoning: {streaming_reasoning}\n\nDeep reasoning: {deep_reasoning}\n\nAnswer: {answer}"


def make_messages(instruction: str, context: str, response: str) -> list[dict[str, str]]:
    return [
        {"role": "user", "content": f"Instruction: {instruction}\n\nContext:\n{context}"},
        {"role": "assistant", "content": response},
    ]


def make_text(messages: list[dict[str, str]]) -> str:
    return f"<|user|>\n{messages[0]['content']}\n<|assistant|>\n{messages[1]['content']}"


def transform_row(row: dict[str, Any]) -> dict[str, Any] | None:
    domain = str(row.get("domain") or "daily_dialogue")
    source_dataset = str(row.get("source_dataset") or "local_source")
    original_chunks = parse_context_chunks(row)
    if len(original_chunks) < 2:
        return None
    chunks: list[str] = []
    merged_fragments = False
    for chunk in original_chunks:
        split_chunks, changed = semantic_split_utterance(chunk, domain)
        chunks.extend(split_chunks)
        merged_fragments = merged_fragments or changed
    chunks, changed = merge_fragments(chunks)
    merged_fragments = merged_fragments or changed
    chunks = [clean_text(chunk, max_chars=340) for chunk in chunks if clean_text(chunk)]
    if len(chunks) < 2:
        return None
    if len(chunks) > 13:
        chunks = chunks[:13]
    if domain == "how_to_guidance" and is_undesired_how_to(chunks):
        return None
    streaming, deep, labels, skip_chunks, skip_reasons, state = build_reasoning(domain, chunks)
    answer = build_answer(domain, state, chunks)
    if not is_safe_example(chunks, answer):
        return None
    flags = compute_quality_flags(domain, chunks, labels, state, row.get("answer"), streaming, deep, answer, merged_fragments)
    quality_score = compute_quality_score(flags, streaming, deep)
    confidence = compute_state_tracking_confidence(domain, state, flags)
    context = build_context(chunks)
    response = make_response(streaming, deep, answer)
    messages = make_messages(INSTRUCTION, context, response)
    example = {
        "id": "",
        "domain": domain,
        "source_dataset": source_dataset,
        "instruction": INSTRUCTION,
        "context": context,
        "context_chunks": chunks,
        "streaming_reasoning": streaming,
        "deep_reasoning": deep,
        "answer": answer,
        "response": response,
        "messages": messages,
        "text": make_text(messages),
        "num_chunks": len(chunks),
        "language": "en",
        "split": "",
        "generation_method": GENERATION_METHOD,
        "quality_flags": flags,
        "version": DATASET_VERSION,
        "reasoning_policy": REASONING_POLICY,
        "chunking_method": CHUNKING_METHOD,
        "chunk_labels": labels,
        "skip_chunks": skip_chunks,
        "skip_reasons": skip_reasons,
        "reasoning_token_budget": REASONING_TOKEN_BUDGET,
        "original_num_chunks": len(original_chunks),
        "chunk_split_count": max(0, len(chunks) - len(original_chunks)),
        "quality_score": quality_score,
        "is_high_quality": False,
        "refinement_method": REFINEMENT_METHOD,
        "llm_augmented": False,
        "llm_augmentation_model": None,
        "rejected_reason": None,
        "state_tracking_confidence": confidence,
    }
    example["is_high_quality"] = is_high_quality_row(example)
    return example


def select_source_rows(rows: list[dict[str, Any]], max_examples: int, seed: int) -> list[dict[str, Any]]:
    groups: dict[str, list[dict[str, Any]]] = defaultdict(list)
    for row in rows:
        groups[str(row.get("domain") or "daily_dialogue")].append(row)
    rng = random.Random(seed)
    for group in groups.values():
        rng.shuffle(group)
    selected: list[dict[str, Any]] = []
    domains = sorted(groups)
    index = 0
    while len(selected) < max_examples:
        added = False
        for domain in domains:
            if index < len(groups[domain]):
                selected.append(groups[domain][index])
                added = True
                if len(selected) >= max_examples:
                    break
        if not added:
            break
        index += 1
    return selected


def deduplicate(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
    seen_texts: set[str] = set()
    unique: list[dict[str, Any]] = []
    for row in rows:
        key = normalize(row["text"])
        if not key or key in seen_texts:
            continue
        seen_texts.add(key)
        unique.append(row)
    return unique


def assign_ids_and_splits(rows: list[dict[str, Any]], seed: int) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
    rng = random.Random(seed)
    rng.shuffle(rows)
    split_at = max(1, int(len(rows) * 0.8))
    train_rows = rows[:split_at]
    eval_rows = rows[split_at:]
    if not eval_rows and len(train_rows) > 1:
        eval_rows = [train_rows.pop()]
    domain_counts: Counter[str] = Counter()
    for split_name, split_rows in [("train", train_rows), ("eval", eval_rows)]:
        for row in split_rows:
            domain_counts[row["domain"]] += 1
            slug = re.sub(r"[^a-z0-9]+", "_", row["domain"].lower()).strip("_")
            row["id"] = f"life_{slug}_{domain_counts[row['domain']]:06d}"
            row["split"] = split_name
            row["messages"] = make_messages(row["instruction"], row["context"], row["response"])
            row["text"] = make_text(row["messages"])
    return train_rows, eval_rows


def select_review_samples(rows: list[dict[str, Any]], sample_size: int = 120) -> list[dict[str, Any]]:
    by_domain: dict[str, list[dict[str, Any]]] = defaultdict(list)
    for row in rows:
        by_domain[row["domain"]].append(row)
    selected: list[dict[str, Any]] = []
    seen: set[str] = set()
    per_domain = 30
    for domain in ["task_oriented_assistant", "emotional_support", "daily_dialogue", "how_to_guidance"]:
        candidates = by_domain.get(domain, [])
        buckets = [
            [row for row in candidates if row.get("is_high_quality")],
            [row for row in candidates if row.get("skip_chunks")],
            [row for row in candidates if row.get("quality_flags")],
            candidates,
        ]
        picked = 0
        for bucket in buckets:
            for row in bucket:
                if row["id"] in seen:
                    continue
                selected.append(row)
                seen.add(row["id"])
                picked += 1
                if picked >= per_domain:
                    break
            if picked >= per_domain:
                break
    for row in rows:
        if len(selected) >= sample_size:
            break
        if row["id"] not in seen:
            selected.append(row)
            seen.add(row["id"])
    sample_fields = [
        "id",
        "domain",
        "context_chunks",
        "chunk_labels",
        "skip_reasons",
        "streaming_reasoning",
        "deep_reasoning",
        "answer",
        "quality_flags",
        "quality_score",
        "is_high_quality",
        "refinement_method",
        "split",
    ]
    return [{field: row.get(field) for field in sample_fields} for row in selected[:sample_size]]


def write_parquet(path: Path, rows: list[dict[str, Any]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    pd.DataFrame(rows, columns=REQUIRED_FIELDS).to_parquet(path, index=False)


def source_summary(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
    counts = Counter(row["source_dataset"] for row in rows)
    domains: dict[str, set[str]] = defaultdict(set)
    for row in rows:
        domains[row["source_dataset"]].add(row["domain"])
    return [{"name": source, "domain": ",".join(sorted(domains[source])), "rows": count} for source, count in sorted(counts.items())]


def quality_counts(rows: list[dict[str, Any]]) -> dict[str, int]:
    return dict(sorted(Counter(flag for row in rows for flag in row.get("quality_flags", [])).items()))


def avg(values: list[float]) -> float:
    return statistics.mean(values) if values else 0.0


def build_dataset_info(train_rows: list[dict[str, Any]], eval_rows: list[dict[str, Any]], hq_train: list[dict[str, Any]], hq_eval: list[dict[str, Any]], skipped_sources: list[dict[str, str]]) -> dict[str, Any]:
    rows = train_rows + eval_rows
    total_chunks = sum(row["num_chunks"] for row in rows)
    skip_chunks = sum(len(row["skip_chunks"]) for row in rows)
    return {
        "dataset_name": DATASET_NAME,
        "repo_id": REPO_ID,
        "version": DATASET_VERSION,
        "created_by": "skyzhou06 with Codex",
        "generation_method": GENERATION_METHOD,
        "reasoning_policy": REASONING_POLICY,
        "chunking_method": CHUNKING_METHOD,
        "refinement_method": REFINEMENT_METHOD,
        "schema": {field: "required" for field in REQUIRED_FIELDS},
        "source_datasets_used": source_summary(rows),
        "skipped_source_datasets": skipped_sources,
        "total_rows": len(rows),
        "train_rows": len(train_rows),
        "eval_rows": len(eval_rows),
        "high_quality_train_rows": len(hq_train),
        "high_quality_eval_rows": len(hq_eval),
        "domains": dict(sorted(Counter(row["domain"] for row in rows).items())),
        "average_num_chunks": avg([row["num_chunks"] for row in rows]),
        "average_chunk_length": avg([word_count(chunk) for row in rows for chunk in row["context_chunks"]]),
        "average_original_num_chunks": avg([row["original_num_chunks"] for row in rows]),
        "average_chunk_split_count": avg([row["chunk_split_count"] for row in rows]),
        "average_streaming_reasoning_words": avg([word_count(row["streaming_reasoning"]) for row in rows]),
        "average_deep_reasoning_words": avg([word_count(row["deep_reasoning"]) for row in rows]),
        "average_quality_score": avg([row["quality_score"] for row in rows]),
        "high_quality_percentage": (len(hq_train) + len(hq_eval)) / len(rows) if rows else 0,
        "skip_chunk_ratio": skip_chunks / total_chunks if total_chunks else 0,
        "examples_with_at_least_one_skip": sum(1 for row in rows if row["skip_chunks"]),
        "quality_flags_distribution": quality_counts(rows),
        "llm_augmented_count": sum(1 for row in rows if row.get("llm_augmented")),
        "limitations": [
            "v0.4 is primarily rule-based unless optional LLM augmentation is run.",
            "The high-quality subset is recommended for serious SFT experiments.",
            "Some source datasets are dialogue-style and may not perfectly match ideal assistant behavior.",
            "The dataset is not intended for expert medical, legal, financial, emergency, or safety-critical advice.",
        ],
        "samples_for_review": "samples_for_review.jsonl",
    }


def dataset_card(info: dict[str, Any], example: dict[str, Any] | None) -> str:
    used = "\n".join(f"- `{item['name']}`: {item['rows']} rows, domain `{item['domain']}`" for item in info["source_datasets_used"]) or "- None"
    skipped = "\n".join(f"- `{item['name']}`: {item['reason']}" for item in info["skipped_source_datasets"]) or "- None"
    flags = "\n".join(f"- `{flag}`: {count}" for flag, count in info["quality_flags_distribution"].items()) or "- None"
    example_json = json.dumps(example or {}, ensure_ascii=False, indent=2)
    schema = "\n".join(f"- `{field}`" for field in REQUIRED_FIELDS)
    return f"""---
pretty_name: LifeStreamingCoT
language:
- en
license: apache-2.0
version: "{DATASET_VERSION}"
task_categories:
- text-generation
tags:
- streaming-reasoning
- selective-reasoning
- quality-refined
- supervised-fine-tuning
- sft
- dialogue
- task-oriented-dialogue
- life-assistant
- streamingthinker
size_categories:
- 1K<n<10K
---

# LifeStreamingCoT

Current version: v0.4: Quality-Refined Selective Streaming Reasoning

LifeStreamingCoT is a text-only, life-scenario adaptation of StreamingCoT-style data for StreamingThinker-style supervised fine-tuning. It keeps compatibility with earlier LifeStreamingCoT schemas while adding quality metadata and high-quality subset files.

## Version 0.4: Quality Refinement

v0.3 introduced selective concise streaming reasoning, semantic chunk splitting, skip labels, and chunk-level metadata. v0.4 improves quality by fixing keyword-stitching in emotional support examples, reducing daily-dialogue intent mistakes, replacing vague task-oriented updates, reducing fragment chunks, and adding `quality_score` plus `is_high_quality`.

v0.4 also provides high-quality subset files:

- `data/train_high_quality.jsonl`
- `data/eval_high_quality.jsonl`
- `data/train_high_quality.parquet`
- `data/eval_high_quality.parquet`

## Version History

| Version | Summary |
| --- | --- |
| v0.1 | Schema-complete source-grounded baseline |
| v0.2 | More specific rule-based reasoning and quality flags |
| v0.3 | Selective concise reasoning, skip labels, semantic chunking |
| v0.4 | Quality refinement, quality scores, high-quality subset |

## Recommended Usage

Full dataset:

```python
from datasets import load_dataset
ds = load_dataset("skyzhou06/LifeStreamingCoT")
```

Quality filtering:

```python
clean = ds.filter(lambda x: x["is_high_quality"] and x["quality_score"] >= 0.85)
```

Removing flagged data:

```python
clean = ds.filter(lambda x: len(x["quality_flags"]) == 0)
```

## Schema

{schema}

## Source Datasets

Used sources:

{used}

Skipped sources:

{skipped}

## Splits

- Train: {info['train_rows']}
- Eval: {info['eval_rows']}
- Total: {info['total_rows']}
- High-quality train: {info['high_quality_train_rows']}
- High-quality eval: {info['high_quality_eval_rows']}

## Statistics

- Average chunks: {info['average_num_chunks']:.2f}
- Average chunk length: {info['average_chunk_length']:.2f}
- Average streaming reasoning words: {info['average_streaming_reasoning_words']:.2f}
- Average deep reasoning words: {info['average_deep_reasoning_words']:.2f}
- Average quality score: {info['average_quality_score']:.3f}
- High-quality percentage: {info['high_quality_percentage']:.2%}
- Skip chunk ratio: {info['skip_chunk_ratio']:.4f}
- LLM augmented rows: {info['llm_augmented_count']}

## Quality Flags

{flags}

## Example

```json
{example_json}
```

## Limitations

- Still primarily rule-based unless optional LLM augmentation is run.
- Not expert advice.
- Some source datasets are dialogue-style and may not perfectly match assistant behavior.
- The high-quality subset is recommended for serious SFT experiments.
"""


def print_stats(rows: list[dict[str, Any]], train_rows: list[dict[str, Any]], eval_rows: list[dict[str, Any]], hq_train: list[dict[str, Any]], hq_eval: list[dict[str, Any]], skipped: list[dict[str, str]], llm_status: str) -> None:
    total_chunks = sum(row["num_chunks"] for row in rows)
    skip_chunks = sum(len(row["skip_chunks"]) for row in rows)
    print("\nBuild stats")
    print(f"total examples: {len(rows)}")
    print(f"train examples: {len(train_rows)}")
    print(f"eval examples: {len(eval_rows)}")
    print(f"high-quality train examples: {len(hq_train)}")
    print(f"high-quality eval examples: {len(hq_eval)}")
    print(f"domains: {dict(sorted(Counter(row['domain'] for row in rows).items()))}")
    print(f"source datasets: {dict(Counter(row['source_dataset'] for row in rows))}")
    print(f"average chunks: {avg([row['num_chunks'] for row in rows]):.2f}")
    print(f"average chunk length: {avg([word_count(chunk) for row in rows for chunk in row['context_chunks']]):.2f}")
    print(f"average streaming reasoning words: {avg([word_count(row['streaming_reasoning']) for row in rows]):.2f}")
    print(f"average deep reasoning words: {avg([word_count(row['deep_reasoning']) for row in rows]):.2f}")
    print(f"average quality score: {avg([row['quality_score'] for row in rows]):.3f}")
    print(f"high-quality percentage: {(len(hq_train) + len(hq_eval)) / len(rows) if rows else 0:.2%}")
    print(f"skip chunk ratio: {skip_chunks / total_chunks if total_chunks else 0:.4f}")
    print(f"quality flags: {quality_counts(rows)}")
    print(f"llm augmentation: {llm_status}")
    print(f"skipped source datasets: {skipped}")


def sync_scripts_to_dataset(output_dir: Path) -> None:
    script_dir = Path(__file__).resolve().parent
    target = output_dir / "scripts"
    target.mkdir(parents=True, exist_ok=True)
    for name in ["build_life_streaming_cot.py", "validate_dataset.py", "upload_to_hf.py", "augment_with_llm.py", "analyze_quality.py"]:
        src = script_dir / name
        if src.exists():
            shutil.copy2(src, target / name)


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--output-dir", default="life_streaming_cot_dataset")
    parser.add_argument("--max-examples", type=int, default=10000)
    parser.add_argument("--smoke-test", action="store_true")
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--llm-augment", action="store_true", help="Reserved hook for optional LLM augmentation.")
    args = parser.parse_args()

    output_dir = Path(args.output_dir)
    data_dir = output_dir / "data"
    data_dir.mkdir(parents=True, exist_ok=True)
    max_examples = min(args.max_examples, 300 if args.smoke_test else args.max_examples)

    source_rows, skipped_sources = load_source_rows(output_dir)
    if not source_rows:
        raise RuntimeError("No source rows were available.")
    source_rows = select_source_rows(source_rows, max_examples=max_examples * 5, seed=args.seed)

    rows: list[dict[str, Any]] = []
    for source_row in source_rows:
        example = transform_row(source_row)
        if example:
            rows.append(example)
            if len(rows) >= max_examples:
                break
    rows = deduplicate(rows)
    if len(rows) > max_examples:
        rows = rows[:max_examples]
    if len(rows) < min(5000, max_examples) and not args.smoke_test:
        raise RuntimeError(f"Only {len(rows)} examples were produced; expected at least {min(5000, max_examples)}.")
    if len(rows) < 10:
        raise RuntimeError("Fewer than 10 examples were produced.")

    llm_available = bool(os.getenv("OPENAI_API_KEY") or os.getenv("OPENAI_BASE_URL") or os.getenv("LOCAL_LLM_BASE_URL"))
    if args.llm_augment and llm_available:
        llm_status = "available but not run in build script; use scripts/augment_with_llm.py for explicit augmentation"
    elif args.llm_augment:
        llm_status = "skipped: no supported API key or local model endpoint found"
    else:
        llm_status = "skipped: optional LLM augmentation was not requested"

    train_rows, eval_rows = assign_ids_and_splits(rows, args.seed)
    all_rows = train_rows + eval_rows
    hq_train = [row for row in train_rows if row["is_high_quality"]]
    hq_eval = [row for row in eval_rows if row["is_high_quality"]]

    write_jsonl(data_dir / "train.jsonl", train_rows)
    write_jsonl(data_dir / "eval.jsonl", eval_rows)
    write_jsonl(data_dir / "train_high_quality.jsonl", hq_train)
    write_jsonl(data_dir / "eval_high_quality.jsonl", hq_eval)
    write_parquet(data_dir / "train.parquet", train_rows)
    write_parquet(data_dir / "eval.parquet", eval_rows)
    write_parquet(data_dir / "train_high_quality.parquet", hq_train)
    write_parquet(data_dir / "eval_high_quality.parquet", hq_eval)
    write_jsonl(output_dir / "samples_for_review.jsonl", select_review_samples(all_rows, sample_size=120))

    info = build_dataset_info(train_rows, eval_rows, hq_train, hq_eval, skipped_sources)
    (output_dir / "dataset_info.json").write_text(json.dumps(info, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    (output_dir / "README.md").write_text(dataset_card(info, hq_train[0] if hq_train else train_rows[0]), encoding="utf-8")
    (output_dir / "requirements.txt").write_text(Path("requirements.txt").read_text(encoding="utf-8"), encoding="utf-8")
    sync_scripts_to_dataset(output_dir)
    print_stats(all_rows, train_rows, eval_rows, hq_train, hq_eval, skipped_sources, llm_status)


if __name__ == "__main__":
    main()