Update LifeStreamingCoT to v0.3 selective concise reasoning

README.md

@@ -3,12 +3,13 @@ pretty_name: LifeStreamingCoT
 language:
 - en
 license: apache-2.0
-version: "0.2.0"
+version: "v0.3"
 task_categories:
 - text-generation
 tags:
 - streaming-reasoning
-- chain-of-thought
+- selective-reasoning
+- concise-reasoning
 - supervised-fine-tuning
 - sft
 - dialogue
@@ -21,136 +22,203 @@ size_categories:
 
 # LifeStreamingCoT
 
-Version: v0.2
+Version: v0.3
 
 ## Dataset Summary
 
-LifeStreamingCoT is a text-only, life-scenario adaptation of StreamingCoT-style data for StreamingThinker-style supervised fine-tuning. It turns source-grounded everyday dialogues, task-oriented conversations, and practical guidance snippets into an instruction/context/streaming_reasoning/deep_reasoning/answer format.
+LifeStreamingCoT is a text-only, life-scenario adaptation of StreamingCoT-style data for StreamingThinker-style supervised fine-tuning. It keeps a schema compatible with earlier LifeStreamingCoT releases while making the streaming rationale shorter and more realistic for low-latency interaction.
 
-The dataset is not purely generated from scratch. Each row is grounded in public text datasets loaded through Hugging Face `datasets` when available, then transformed with deterministic rule-based templates.
+## Version 0.3: Selective Concise Streaming Reasoning
 
-v0.2 improves the first release by making `streaming_reasoning` more specific to each chunk, composing assistant-style `answer` fields instead of copying the next dialogue utterance, adding domain-specific reasoning templates, and adding `quality_flags` for examples that may need extra review.
+v0.2 used source-grounded rule-based streaming reasoning. v0.3 introduces selective concise streaming reasoning:
 
-## Intended Use
+- Some trivial chunks are marked as `SKIP`.
+- Long utterances are split into shorter semantic chunks.
+- `streaming_reasoning` is state-update-like instead of paragraph-like.
+- `deep_reasoning` is short and practical.
+- The goal is to reduce reasoning token cost and make the dataset more realistic for low-latency streaming interaction.
 
-This dataset is intended for research and training experiments around streaming reasoning, context updates, and assistant responses to gradually revealed everyday situations. It is suitable for SFT formatting experiments where models learn to update concise synthetic rationale fields as new text chunks arrive.
+Before, v0.2 style often looked like:
 
-It is not a medical, legal, financial, or safety-critical advice dataset.
+```text
+After chunk 1, the user is asking for help...
+```
+
+v0.3 style:
 
-## Dataset Schema
+```text
+C1 goal=restaurant_search. C2 constraints+=cheap, Chinese. C3 [SKIP: thanks_only].
+```
+
+## Schema
 
 Each row contains:
 
-- `id`: stable row identifier
-- `domain`: life scenario domain
-- `source_dataset`: source dataset used for grounding
-- `instruction`: fixed assistant instruction
-- `context_chunks`: gradually revealed text chunks
-- `context`: numbered chunk rendering
-- `streaming_reasoning`: synthetic incremental rationale
-- `deep_reasoning`: synthetic full-context rationale
-- `answer`: final assistant response
-- `response`: combined training response
-- `messages`: chat-format user and assistant messages
-- `text`: simple chat template string
-- `num_chunks`, `language`, `split`, `generation_method`, `quality_flags`
-
-`quality_flags` may include `short_answer`, `generic_reasoning`, `weak_context`, or `copied_source_response`. Empty flags mean the rule-based checks did not detect those issues.
-
-## Data Construction Pipeline
-
-1. Load public text datasets with Hugging Face `datasets`.
-2. Extract life-oriented examples and skip unavailable sources gracefully.
-3. Convert dialogue turns or procedure steps into short context chunks.
-4. Generate StreamingThinker-compatible fields with rule-based templates.
-5. Compose assistant-style answers from the visible chunks and, when useful, short source facts.
-6. Add quality flags for weak context, short answers, generic reasoning, or copied source responses.
-7. Filter unsafe, overly short, duplicate, or personally identifying examples.
-8. Split into 80 percent train and 20 percent eval.
-9. Export JSONL, Parquet, and `samples_for_review.jsonl`.
+- `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`
+
+New v0.3 metadata fields include `version`, `reasoning_policy`, `chunking_method`, `chunk_labels`, `skip_chunks`, `skip_reasons`, `reasoning_token_budget`, `original_num_chunks`, and `chunk_split_count`.
 
 ## Source Datasets
 
 Used sources:
 
-- `b-mc2/wikihow_lists`: 640 rows, domain `how_to_guidance`
-- `pietrolesci/multiwoz_all_versions`: 2998 rows, domain `task_oriented_assistant`
+- `b-mc2/wikihow_lists`: 626 rows, domain `how_to_guidance`
+- `pietrolesci/multiwoz_all_versions`: 2997 rows, domain `task_oriented_assistant`
 - `pixelsandpointers/better_daily_dialog`: 3722 rows, domain `daily_dialogue`
 - `pixelsandpointers/empathetic_dialogues_for_lm`: 2000 rows, domain `emotional_support`
 
 Skipped sources:
 
-- `Siyong/taskmaster`: loaded but yielded no valid examples after filtering
+- None
 
 ## Splits
 
-- Train: 7488
-- Eval: 1872
-- Total: 9360
+- Train: 7476
+- Eval: 1869
+- Total: 9345
+
+## Statistics
+
+- Average chunks: 7.55
+- Average original chunks: 4.75
+- Average chunk split count: 2.80
+- Average streaming reasoning words: 27.51
+- Average deep reasoning words: 14.96
+- Skip chunk ratio: 0.1914
+- Examples with at least one skip: 6587
 
 ## Quality Flags
 
-- `copied_source_response`: 423
-- `generic_reasoning`: 4
-- `short_answer`: 809
-- `weak_context`: 454
+- `copied_source_response`: 457
+- `excessive_chunking`: 640
+- `low_specificity`: 308
+- `no_skip_labels`: 4
+- `possible_slot_error`: 42
+- `too_many_skips`: 18
+- `weak_context`: 16
+
+v0.3 quality flags may include `long_streaming_reasoning`, `long_deep_reasoning`, `no_skip_labels`, `too_many_skips`, `excessive_chunking`, `generic_reasoning`, `copied_source_response`, `short_answer`, `weak_context`, `possible_slot_error`, `closing_mishandled`, and `low_specificity`.
 
-The file `samples_for_review.jsonl` contains 50 diverse examples sampled across domains for manual inspection.
+## Recommended Filtering
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("skyzhou06/LifeStreamingCoT")
+clean = ds.filter(lambda x: len(x["quality_flags"]) == 0)
+concise = ds.filter(lambda x: "long_streaming_reasoning" not in x["quality_flags"])
+reason_only = ds.filter(lambda x: x["reasoning_policy"] == "selective_concise")
+```
 
 ## Example
 
 ```json
 {
-  "id": "life_task_oriented_assistant_000001",
-  "domain": "task_oriented_assistant",
-  "source_dataset": "pietrolesci/multiwoz_all_versions",
-  "instruction": "Respond helpfully to the user based on gradually revealed real-life context.",
-  "context": "Chunk 1: Are there any Danish restaurants on the east side of town?\nChunk 2: What about Chinese?\nChunk 3: Book it! Friday, 13:15, 3 people.\nChunk 4: I am also looking for the hotel, Autumn House. Do you know of it?\nChunk 5: Yes, that would be great. Please book for the three of us for 3 nights starting on Friday.\nChunk 6: Thanks so much for your help today. That's all I need. Goodbye.",
+  "id": "life_daily_dialogue_000001",
+  "domain": "daily_dialogue",
+  "source_dataset": "pixelsandpointers/better_daily_dialog",
+  "instruction": "Help the user complete a real-life task based on gradually revealed information.",
+  "context": "Chunk 1: Thanks for the advice , Mr .\nChunk 2: Macmillan .\nChunk 3: I'll keep it in mind .\nChunk 4: I had better head off though .\nChunk 5: I ’ m meeting my husband for dinner .\nChunk 6: Sure , I'm heading out myself .\nChunk 7: Enjoy your evening .\nChunk 8: Thanks , sir .\nChunk 9: You too .\nChunk 10: Drive safely , I hear there ’ s a lot ice on the roads .",
   "context_chunks": [
-    "Are there any Danish restaurants on the east side of town?",
-    "What about Chinese?",
-    "Book it! Friday, 13:15, 3 people.",
-    "I am also looking for the hotel, Autumn House. Do you know of it?",
-    "Yes, that would be great. Please book for the three of us for 3 nights starting on Friday.",
-    "Thanks so much for your help today. That's all I need. Goodbye."
+    "Thanks for the advice , Mr .",
+    "Macmillan .",
+    "I'll keep it in mind .",
+    "I had better head off though .",
+    "I ’ m meeting my husband for dinner .",
+    "Sure , I'm heading out myself .",
+    "Enjoy your evening .",
+    "Thanks , sir .",
+    "You too .",
+    "Drive safely , I hear there ’ s a lot ice on the roads ."
   ],
-  "streaming_reasoning": "After chunk 1 ('Are there any Danish restaurants on the east side of...'), the user adds goal=restaurant; area=east. Tracked constraints so far: goal=restaurant; area=east. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 2 ('What about Chinese?'), the user adds food=chinese. Tracked constraints so far: goal=restaurant; food=chinese; area=east. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 3 ('Book it! Friday, 13:15, 3 people.'), the user adds day=friday; time=13:15; requested action=booking. Tracked constraints so far: goal=restaurant; food=chinese; area=east; day=friday; time=13:15; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 4 ('I am also looking for the hotel, Autumn House. Do...'), the user adds goal=hotel. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday; time=13:15; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 5 ('Yes, that would be great. Please book for the three...'), the user adds goal=restaurant; day=friday; party=3 people; requested action=booking. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday; time=13:15; party=3 people; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 6 ('Thanks so much for your help today. That's all I...'), the user adds day=today. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action.",
-  "deep_reasoning": "Given the full context, this is a task-oriented request with these tracked details: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. A useful response should restate the useful constraints, move the task forward, and ask a concise clarification only when a required slot is still missing.",
-  "answer": "I can help with that. So far I have: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. To move this forward, please confirm the price range.",
-  "response": "Streaming reasoning: After chunk 1 ('Are there any Danish restaurants on the east side of...'), the user adds goal=restaurant; area=east. Tracked constraints so far: goal=restaurant; area=east. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 2 ('What about Chinese?'), the user adds food=chinese. Tracked constraints so far: goal=restaurant; food=chinese; area=east. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 3 ('Book it! Friday, 13:15, 3 people.'), the user adds day=friday; time=13:15; requested action=booking. Tracked constraints so far: goal=restaurant; food=chinese; area=east; day=friday; time=13:15; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 4 ('I am also looking for the hotel, Autumn House. Do...'), the user adds goal=hotel. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday; time=13:15; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 5 ('Yes, that would be great. Please book for the three...'), the user adds goal=restaurant; day=friday; party=3 people; requested action=booking. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday; time=13:15; party=3 people; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 6 ('Thanks so much for your help today. That's all I...'), the user adds day=today. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action.\n\nDeep reasoning: Given the full context, this is a task-oriented request with these tracked details: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. A useful response should restate the useful constraints, move the task forward, and ask a concise clarification only when a required slot is still missing.\n\nAnswer: I can help with that. So far I have: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. To move this forward, please confirm the price range.",
+  "streaming_reasoning": "C1 [SKIP: thanks_only]. C2 [SKIP: low_information]. C3 topic=i'll, keep. C4 topic=better, head. C5 social_intent=invitation. C6 agreement=true. C7 topic=enjoy, evening. C8 [SKIP: thanks_only]. C9 [SKIP: low_information]. C10 topic=drive, safely.",
+  "deep_reasoning": "Conversation is closing after a simple social exchange; answer politely.",
+  "answer": "Sounds good. Take care, and see you next time.",
+  "response": "Streaming reasoning: C1 [SKIP: thanks_only]. C2 [SKIP: low_information]. C3 topic=i'll, keep. C4 topic=better, head. C5 social_intent=invitation. C6 agreement=true. C7 topic=enjoy, evening. C8 [SKIP: thanks_only]. C9 [SKIP: low_information]. C10 topic=drive, safely.\n\nDeep reasoning: Conversation is closing after a simple social exchange; answer politely.\n\nAnswer: Sounds good. Take care, and see you next time.",
   "messages": [
     {
       "role": "user",
-      "content": "Instruction: Respond helpfully to the user based on gradually revealed real-life context.\n\nContext:\nChunk 1: Are there any Danish restaurants on the east side of town?\nChunk 2: What about Chinese?\nChunk 3: Book it! Friday, 13:15, 3 people.\nChunk 4: I am also looking for the hotel, Autumn House. Do you know of it?\nChunk 5: Yes, that would be great. Please book for the three of us for 3 nights starting on Friday.\nChunk 6: Thanks so much for your help today. That's all I need. Goodbye."
+      "content": "Instruction: Help the user complete a real-life task based on gradually revealed information.\n\nContext:\nChunk 1: Thanks for the advice , Mr .\nChunk 2: Macmillan .\nChunk 3: I'll keep it in mind .\nChunk 4: I had better head off though .\nChunk 5: I ’ m meeting my husband for dinner .\nChunk 6: Sure , I'm heading out myself .\nChunk 7: Enjoy your evening .\nChunk 8: Thanks , sir .\nChunk 9: You too .\nChunk 10: Drive safely , I hear there ’ s a lot ice on the roads ."
     },
     {
       "role": "assistant",
-      "content": "Streaming reasoning: After chunk 1 ('Are there any Danish restaurants on the east side of...'), the user adds goal=restaurant; area=east. Tracked constraints so far: goal=restaurant; area=east. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 2 ('What about Chinese?'), the user adds food=chinese. Tracked constraints so far: goal=restaurant; food=chinese; area=east. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 3 ('Book it! Friday, 13:15, 3 people.'), the user adds day=friday; time=13:15; requested action=booking. Tracked constraints so far: goal=restaurant; food=chinese; area=east; day=friday; time=13:15; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 4 ('I am also looking for the hotel, Autumn House. Do...'), the user adds goal=hotel. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday; time=13:15; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 5 ('Yes, that would be great. Please book for the three...'), the user adds goal=restaurant; day=friday; party=3 people; requested action=booking. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday; time=13:15; party=3 people; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 6 ('Thanks so much for your help today. That's all I...'), the user adds day=today. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action.\n\nDeep reasoning: Given the full context, this is a task-oriented request with these tracked details: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. A useful response should restate the useful constraints, move the task forward, and ask a concise clarification only when a required slot is still missing.\n\nAnswer: I can help with that. So far I have: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. To move this forward, please confirm the price range."
+      "content": "Streaming reasoning: C1 [SKIP: thanks_only]. C2 [SKIP: low_information]. C3 topic=i'll, keep. C4 topic=better, head. C5 social_intent=invitation. C6 agreement=true. C7 topic=enjoy, evening. C8 [SKIP: thanks_only]. C9 [SKIP: low_information]. C10 topic=drive, safely.\n\nDeep reasoning: Conversation is closing after a simple social exchange; answer politely.\n\nAnswer: Sounds good. Take care, and see you next time."
     }
   ],
-  "text": "<|user|>\nInstruction: Respond helpfully to the user based on gradually revealed real-life context.\n\nContext:\nChunk 1: Are there any Danish restaurants on the east side of town?\nChunk 2: What about Chinese?\nChunk 3: Book it! Friday, 13:15, 3 people.\nChunk 4: I am also looking for the hotel, Autumn House. Do you know of it?\nChunk 5: Yes, that would be great. Please book for the three of us for 3 nights starting on Friday.\nChunk 6: Thanks so much for your help today. That's all I need. Goodbye.\n<|assistant|>\nStreaming reasoning: After chunk 1 ('Are there any Danish restaurants on the east side of...'), the user adds goal=restaurant; area=east. Tracked constraints so far: goal=restaurant; area=east. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 2 ('What about Chinese?'), the user adds food=chinese. Tracked constraints so far: goal=restaurant; food=chinese; area=east. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 3 ('Book it! Friday, 13:15, 3 people.'), the user adds day=friday; time=13:15; requested action=booking. Tracked constraints so far: goal=restaurant; food=chinese; area=east; day=friday; time=13:15; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 4 ('I am also looking for the hotel, Autumn House. Do...'), the user adds goal=hotel. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday; time=13:15; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 5 ('Yes, that would be great. Please book for the three...'), the user adds goal=restaurant; day=friday; party=3 people; requested action=booking. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday; time=13:15; party=3 people; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action. After chunk 6 ('Thanks so much for your help today. That's all I...'), the user adds day=today. Tracked constraints so far: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. The assistant should preserve these slots and ask only for missing information needed for the next action.\n\nDeep reasoning: Given the full context, this is a task-oriented request with these tracked details: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. A useful response should restate the useful constraints, move the task forward, and ask a concise clarification only when a required slot is still missing.\n\nAnswer: I can help with that. So far I have: goal=restaurant, and hotel; food=chinese; area=east; day=friday, and today; time=13:15; party=3 people; requested action=booking. To move this forward, please confirm the price range.",
-  "num_chunks": 6,
+  "text": "<|user|>\nInstruction: Help the user complete a real-life task based on gradually revealed information.\n\nContext:\nChunk 1: Thanks for the advice , Mr .\nChunk 2: Macmillan .\nChunk 3: I'll keep it in mind .\nChunk 4: I had better head off though .\nChunk 5: I ’ m meeting my husband for dinner .\nChunk 6: Sure , I'm heading out myself .\nChunk 7: Enjoy your evening .\nChunk 8: Thanks , sir .\nChunk 9: You too .\nChunk 10: Drive safely , I hear there ’ s a lot ice on the roads .\n<|assistant|>\nStreaming reasoning: C1 [SKIP: thanks_only]. C2 [SKIP: low_information]. C3 topic=i'll, keep. C4 topic=better, head. C5 social_intent=invitation. C6 agreement=true. C7 topic=enjoy, evening. C8 [SKIP: thanks_only]. C9 [SKIP: low_information]. C10 topic=drive, safely.\n\nDeep reasoning: Conversation is closing after a simple social exchange; answer politely.\n\nAnswer: Sounds good. Take care, and see you next time.",
+  "num_chunks": 10,
   "language": "en",
   "split": "train",
-  "generation_method": "source_grounded_rule_based_v0.2",
-  "quality_flags": []
+  "generation_method": "source_grounded_rule_based_v0.3_selective_concise",
+  "quality_flags": [],
+  "version": "v0.3",
+  "reasoning_policy": "selective_concise",
+  "chunking_method": "semantic_sentence_split_v0.3",
+  "chunk_labels": [
+    "skip",
+    "skip",
+    "reason",
+    "reason",
+    "reason",
+    "reason",
+    "reason",
+    "skip",
+    "skip",
+    "reason"
+  ],
+  "skip_chunks": [
+    1,
+    2,
+    8,
+    9
+  ],
+  "skip_reasons": {
+    "1": "thanks_only",
+    "2": "low_information",
+    "8": "thanks_only",
+    "9": "low_information"
+  },
+  "reasoning_token_budget": {
+    "streaming_reasoning_max_words_per_chunk": 18,
+    "deep_reasoning_max_words": 45,
+    "answer_max_sentences": 3
+  },
+  "original_num_chunks": 3,
+  "chunk_split_count": 7
 }
 ```
 
-## Quality Filtering
-
-The build script removes exact duplicate training texts, filters obvious personal contact information, skips unsafe categories such as self-harm, explicit sexual content, weapon construction, illegal drugs, and safety-critical expert-advice situations, and keeps chunks short to avoid long copied passages.
-
-The `streaming_reasoning` field is synthetic supervised rationale data for research and training. It is concise, task-focused, and generated by deterministic templates rather than by exposing hidden reasoning from a proprietary model.
-
 ## Limitations
 
-The dataset uses rule-based transformations and therefore may contain generic rationales, imperfect domain labels, or source responses that are conversational rather than ideal assistant answers. It should be inspected before use in high-stakes or production systems.
-
-## Ethical Considerations
-
-LifeStreamingCoT is designed for general-purpose everyday assistance. It should not be used as a source of professional medical, legal, financial, mental health, emergency, or safety-critical advice. Source dataset licensing and usage terms should be reviewed before redistribution or commercial use.
+- The dataset uses rule-based transformations and should be inspected before high-stakes or production use.
+- Skip labels and semantic chunks are heuristic and can be imperfect.
+- It is not a medical, legal, financial, emergency, or safety-critical advice dataset.
 
 ## Citation / Acknowledgements
 
-This dataset acknowledges the public source datasets used during construction, including available DailyDialog, MultiWOZ, Taskmaster, WikiHow-style, and related life-dialogue datasets. The format is inspired by StreamingCoT and intended for StreamingThinker-style SFT research.
+This dataset acknowledges the public source datasets used during construction, including DailyDialog-style, MultiWOZ, EmpatheticDialogues-style, WikiHow-style, and related life-dialogue datasets. The format is inspired by StreamingCoT and intended for StreamingThinker-style SFT research.

data/eval.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:da8128a6139dc8ec3c8100b80980cb1c10a79efb01e9410920f7f5a5282e4626
-size 18551628
+oid sha256:a9a97c0e41aafa1b290c093da7c54a5107bc8ce3463949be277376c521d23935
+size 8519696

data/eval.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bea63fc31c84b9641451033f4459ae98e61ebc52e0c1d6114bbaea45153b8fdf
-size 4448204
+oid sha256:3d2e13f821434508c216b3b4053c7c5e0393e1d1651f4d242e28a47a876a00fa
+size 2582829

data/train.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7d969ca8f0cd020cdab428e0e9f31b0748e6f5186d66b05064fd3436be6a2bf7
-size 74440584
+oid sha256:49736fffbeb3080fafea97199d430691f78944aa56a186b629066f20cba61232
+size 34143912

data/train.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cdfc2268183a548ecf4a2cae1cea831f1cc7b765b2315848be2e4af494ee29fd
-size 17565483
+oid sha256:d37f1f49c70dcec8ead84f96fe4d7462eefc961f309e8f3a2e3a129258c9c69b
+size 10174551

dataset_info.json

@@ -1,37 +1,49 @@
 {
   "dataset_name": "LifeStreamingCoT",
   "repo_id": "skyzhou06/LifeStreamingCoT",
-  "version": "0.2.0",
+  "version": "v0.3",
   "created_by": "skyzhou06 with Codex",
+  "generation_method": "source_grounded_rule_based_v0.3_selective_concise",
+  "reasoning_policy": "selective_concise",
+  "chunking_method": "semantic_sentence_split_v0.3",
   "schema": {
-    "id": "string",
-    "domain": "string",
-    "source_dataset": "string",
-    "instruction": "string",
-    "context": "string",
-    "context_chunks": "list[string]",
-    "streaming_reasoning": "string",
-    "deep_reasoning": "string",
-    "answer": "string",
-    "response": "string",
-    "messages": "list[{role: string, content: string}]",
-    "text": "string",
-    "num_chunks": "int",
-    "language": "string",
-    "split": "train|eval",
-    "generation_method": "string",
-    "quality_flags": "list[string]"
+    "id": "required",
+    "domain": "required",
+    "source_dataset": "required",
+    "instruction": "required",
+    "context": "required",
+    "context_chunks": "required",
+    "streaming_reasoning": "required",
+    "deep_reasoning": "required",
+    "answer": "required",
+    "response": "required",
+    "messages": "required",
+    "text": "required",
+    "num_chunks": "required",
+    "language": "required",
+    "split": "required",
+    "generation_method": "required",
+    "quality_flags": "required",
+    "version": "required",
+    "reasoning_policy": "required",
+    "chunking_method": "required",
+    "chunk_labels": "required",
+    "skip_chunks": "required",
+    "skip_reasons": "required",
+    "reasoning_token_budget": "required",
+    "original_num_chunks": "required",
+    "chunk_split_count": "required"
   },
   "source_datasets_used": [
     {
       "name": "b-mc2/wikihow_lists",
       "domain": "how_to_guidance",
-      "rows": 640
+      "rows": 626
     },
     {
       "name": "pietrolesci/multiwoz_all_versions",
       "domain": "task_oriented_assistant",
-      "rows": 2998
+      "rows": 2997
     },
     {
       "name": "pixelsandpointers/better_daily_dialog",
@@ -44,32 +56,37 @@
       "rows": 2000
     }
   ],
-  "skipped_source_datasets": [
-    {
-      "name": "Siyong/taskmaster",
-      "reason": "loaded but yielded no valid examples after filtering"
-    }
-  ],
-  "total_rows": 9360,
-  "train_rows": 7488,
-  "eval_rows": 1872,
+  "skipped_source_datasets": [],
+  "total_rows": 9345,
+  "train_rows": 7476,
+  "eval_rows": 1869,
   "domains": {
-    "task_oriented_assistant": 2998,
-    "emotional_support": 2000,
     "daily_dialogue": 3722,
-    "how_to_guidance": 640
+    "emotional_support": 2000,
+    "how_to_guidance": 626,
+    "task_oriented_assistant": 2997
   },
-  "generation_method": "source_grounded_rule_based_v0.2",
-  "quality_flag_counts": {
-    "copied_source_response": 423,
-    "generic_reasoning": 4,
-    "short_answer": 809,
-    "weak_context": 454
+  "average_num_chunks": 7.553237025147138,
+  "average_original_num_chunks": 4.748314606741573,
+  "average_chunk_split_count": 2.8049224184055643,
+  "average_streaming_reasoning_words": 27.512038523274477,
+  "average_deep_reasoning_words": 14.956233279828785,
+  "skip_chunk_ratio": 0.1913579372387901,
+  "examples_with_at_least_one_skip": 6587,
+  "quality_flags_distribution": {
+    "copied_source_response": 457,
+    "excessive_chunking": 640,
+    "low_specificity": 308,
+    "no_skip_labels": 4,
+    "possible_slot_error": 42,
+    "too_many_skips": 18,
+    "weak_context": 16
   },
-  "review_samples_file": "samples_for_review.jsonl",
   "limitations": [
-    "Rule-based rationale generation may still be imperfect even after v0.2 specificity improvements.",
+    "v0.3 uses deterministic, source-grounded transformations rather than human-authored rationales.",
+    "Semantic chunking is heuristic and can still over-split or under-split unusual utterances.",
     "The dataset is not intended for medical, legal, financial, emergency, or safety-critical advice.",
     "Source dataset licenses and terms should be reviewed before downstream redistribution or commercial use."
-  ]
+  ],
+  "samples_for_review": "samples_for_review.jsonl"
 }

scripts/upload_to_hf.py

@@ -2,10 +2,12 @@
 from __future__ import annotations
 
 import argparse
+import json
 import sys
 from pathlib import Path
 
-from huggingface_hub import HfApi, create_repo
+from huggingface_hub import HfApi
+from huggingface_hub.utils import RepositoryNotFoundError
 
 
 def main() -> None:
@@ -19,22 +21,46 @@ def main() -> None:
         print(f"Dataset folder does not exist: {folder}", file=sys.stderr)
         sys.exit(1)
 
+    info_path = folder / "dataset_info.json"
+    if not info_path.exists():
+        print(f"Missing dataset_info.json in {folder}", file=sys.stderr)
+        sys.exit(1)
+    info = json.loads(info_path.read_text(encoding="utf-8"))
+    if info.get("version") != "v0.3":
+        print("Refusing upload: dataset_info.json is not version v0.3.", file=sys.stderr)
+        sys.exit(1)
+    if args.repo_id != "skyzhou06/LifeStreamingCoT":
+        print("Refusing upload: use the existing repo skyzhou06/LifeStreamingCoT.", file=sys.stderr)
+        sys.exit(1)
+
     api = HfApi()
     try:
         api.whoami()
-    except Exception:  # noqa: BLE001 - avoid printing auth internals or tokens
+    except Exception:  # noqa: BLE001 - do not print auth internals or tokens
         print("Hugging Face authentication is missing or invalid.")
         print("Run this command, then rerun the upload:")
         print("huggingface-cli login")
         sys.exit(2)
 
-    create_repo(repo_id=args.repo_id, repo_type="dataset", exist_ok=True)
+    try:
+        api.repo_info(repo_id=args.repo_id, repo_type="dataset")
+    except RepositoryNotFoundError:
+        print(f"Refusing upload: dataset repo does not exist: {args.repo_id}", file=sys.stderr)
+        sys.exit(1)
+
     api.upload_folder(
         repo_id=args.repo_id,
         repo_type="dataset",
         folder_path=str(folder),
         path_in_repo=".",
-        commit_message="Upload LifeStreamingCoT dataset",
+        commit_message="Update LifeStreamingCoT to v0.3 selective concise reasoning",
+        ignore_patterns=[
+            ".DS_Store",
+            "*/.DS_Store",
+            "__pycache__",
+            "*/__pycache__/*",
+            "*.pyc",
+        ],
     )
     print(f"https://huggingface.co/datasets/{args.repo_id}")
 

scripts/validate_dataset.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import argparse
 import json
 import sys
+from collections import Counter
 from pathlib import Path
 from typing import Any
 
@@ -28,6 +29,15 @@ REQUIRED_FIELDS = [
     "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",
 ]
 
 REQUIRED_STRING_FIELDS = [
@@ -44,8 +54,44 @@ REQUIRED_STRING_FIELDS = [
     "language",
     "split",
     "generation_method",
+    "version",
+    "reasoning_policy",
+    "chunking_method",
 ]
 
+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",
+    "given the full context",
+    "visible signal",
+    "tracked constraints so far",
+]
+
+TRIVIAL_MARKERS = [
+    "thanks",
+    "thank you",
+    "thanks so much",
+    "thanks for your help",
+    "thanks for your help today",
+    "goodbye",
+    "bye",
+    "see you",
+    "see you later",
+    "that's all i need",
+    "that is all i need",
+    "hello",
+    "hi",
+    "okay",
+    "ok",
+    "sounds good",
+]
+
+
+def word_count(text: str) -> int:
+    return len(str(text).split())
+
 
 def read_jsonl(path: Path) -> list[dict[str, Any]]:
     rows: list[dict[str, Any]] = []
@@ -61,6 +107,25 @@ def read_jsonl(path: Path) -> list[dict[str, Any]]:
     return rows
 
 
+def forbidden_phrase_hits(row: dict[str, Any]) -> int:
+    text = f"{row.get('streaming_reasoning', '')}\n{row.get('deep_reasoning', '')}".lower()
+    return sum(text.count(phrase) for phrase in FORBIDDEN_GENERIC_PHRASES)
+
+
+def has_obvious_trivial_chunk(chunks: list[str]) -> bool:
+    for chunk in chunks:
+        normalized = " ".join(str(chunk).lower().strip(" .!?").split())
+        if normalized in TRIVIAL_MARKERS:
+            return True
+        if normalized.startswith("thanks") and len(normalized.split()) <= 6:
+            return True
+        if normalized.startswith("thank you") and len(normalized.split()) <= 6:
+            return True
+        if "that's all i need" in normalized or "that is all i need" in normalized:
+            return True
+    return False
+
+
 def validate_row(row: dict[str, Any], expected_split: str, idx: int) -> list[str]:
     errors: list[str] = []
     row_id = row.get("id", f"row-{idx}")
@@ -70,6 +135,14 @@ def validate_row(row: dict[str, Any], expected_split: str, idx: int) -> list[str
     for field in REQUIRED_STRING_FIELDS:
         if not isinstance(row.get(field), str) or not row.get(field, "").strip():
             errors.append(f"{row_id}: empty or non-string field {field}")
+
+    if row.get("version") != "v0.3":
+        errors.append(f"{row_id}: version must be v0.3")
+    if row.get("reasoning_policy") != "selective_concise":
+        errors.append(f"{row_id}: reasoning_policy must be selective_concise")
+    if not str(row.get("chunking_method", "")).strip():
+        errors.append(f"{row_id}: chunking_method is required")
+
     chunks = row.get("context_chunks")
     if not isinstance(chunks, list) or not chunks or not all(isinstance(chunk, str) and chunk.strip() for chunk in chunks):
         errors.append(f"{row_id}: context_chunks must be a non-empty list of strings")
@@ -80,6 +153,40 @@ def validate_row(row: dict[str, Any], expected_split: str, idx: int) -> list[str
             errors.append(f"{row_id}: context does not contain chunk text: {chunk[:80]}")
     if row.get("num_chunks") != len(chunks):
         errors.append(f"{row_id}: num_chunks does not match context_chunks length")
+
+    chunk_labels = row.get("chunk_labels")
+    if not isinstance(chunk_labels, list) or len(chunk_labels) != len(chunks):
+        errors.append(f"{row_id}: chunk_labels length must equal num_chunks")
+        chunk_labels = []
+    else:
+        bad_labels = [label for label in chunk_labels if label not in {"reason", "skip"}]
+        if bad_labels:
+            errors.append(f"{row_id}: chunk_labels can only contain reason or skip")
+
+    skip_chunks = row.get("skip_chunks")
+    skip_reasons = row.get("skip_reasons")
+    if not isinstance(skip_chunks, list) or not all(isinstance(item, int) for item in skip_chunks):
+        errors.append(f"{row_id}: skip_chunks must be a list of ints")
+        skip_chunks = []
+    if not isinstance(skip_reasons, dict):
+        errors.append(f"{row_id}: skip_reasons must be a dict")
+        skip_reasons = {}
+    if chunk_labels:
+        expected_skips = [i + 1 for i, label in enumerate(chunk_labels) if label == "skip"]
+        if skip_chunks != expected_skips:
+            errors.append(f"{row_id}: skip_chunks must correspond to skip labels")
+        for chunk_index in expected_skips:
+            if str(chunk_index) not in skip_reasons:
+                errors.append(f"{row_id}: missing skip_reasons entry for chunk {chunk_index}")
+
+    budget = row.get("reasoning_token_budget")
+    if not isinstance(budget, dict) or not budget:
+        errors.append(f"{row_id}: reasoning_token_budget must be a non-empty dict")
+    if not isinstance(row.get("original_num_chunks"), int) or row.get("original_num_chunks", 0) <= 0:
+        errors.append(f"{row_id}: original_num_chunks must be a positive int")
+    if not isinstance(row.get("chunk_split_count"), int) or row.get("chunk_split_count", -1) < 0:
+        errors.append(f"{row_id}: chunk_split_count must be a non-negative int")
+
     messages = row.get("messages")
     if not isinstance(messages, list) or len(messages) != 2:
         errors.append(f"{row_id}: messages must contain exactly one user and one assistant message")
@@ -88,6 +195,7 @@ def validate_row(row: dict[str, Any], expected_split: str, idx: int) -> list[str
             errors.append(f"{row_id}: messages roles must be user then assistant")
         if not messages[0].get("content") or not messages[1].get("content"):
             errors.append(f"{row_id}: message content cannot be empty")
+
     response = row.get("response", "")
     for marker in ["Streaming reasoning:", "Deep reasoning:", "Answer:"]:
         if marker not in response:
@@ -100,6 +208,8 @@ def validate_row(row: dict[str, Any], expected_split: str, idx: int) -> list[str
         errors.append(f"{row_id}: quality_flags must be a list")
     elif not all(isinstance(flag, str) and flag.strip() for flag in row.get("quality_flags", [])):
         errors.append(f"{row_id}: quality_flags must contain only non-empty strings")
+    if has_obvious_trivial_chunk(chunks) and chunk_labels and "skip" not in chunk_labels:
+        errors.append(f"{row_id}: obvious trivial chunk has no skip label")
     return errors
 
 
@@ -110,8 +220,10 @@ def validate(data_dir: Path) -> int:
     train_parquet = data_dir / "data" / "train.parquet"
     eval_parquet = data_dir / "data" / "eval.parquet"
     samples_path = data_dir / "samples_for_review.jsonl"
+    info_path = data_dir / "dataset_info.json"
 
-    for path in [train_jsonl, eval_jsonl, train_parquet, eval_parquet, data_dir / "README.md", data_dir / "dataset_info.json", samples_path]:
+    required_paths = [train_jsonl, eval_jsonl, train_parquet, eval_parquet, data_dir / "README.md", info_path, samples_path]
+    for path in required_paths:
         if not path.exists():
             errors.append(f"missing required file: {path}")
     if errors:
@@ -126,19 +238,18 @@ def validate(data_dir: Path) -> int:
         errors.append("train.jsonl is empty")
     if not eval_rows:
         errors.append("eval.jsonl is empty")
-    if len(sample_rows) != 50:
-        errors.append(f"samples_for_review.jsonl must contain 50 rows, found {len(sample_rows)}")
+    if len(train_rows) + len(eval_rows) >= 100 and len(sample_rows) < 100:
+        errors.append(f"samples_for_review.jsonl must contain at least 100 rows, found {len(sample_rows)}")
 
     for idx, row in enumerate(train_rows, start=1):
         errors.extend(validate_row(row, "train", idx))
     for idx, row in enumerate(eval_rows, start=1):
         errors.extend(validate_row(row, "eval", idx))
-    sample_ids = set()
     for idx, row in enumerate(sample_rows, start=1):
-        if row.get("split") not in {"train", "eval"}:
+        split = row.get("split", "")
+        if split not in {"train", "eval"}:
             errors.append(f"sample row {idx}: split must be train or eval")
-        errors.extend(validate_row(row, row.get("split", ""), idx))
-        sample_ids.add(row.get("id"))
+        errors.extend(validate_row(row, split, idx))
 
     all_rows = train_rows + eval_rows
     ids = [row.get("id") for row in all_rows]
@@ -149,6 +260,7 @@ def validate(data_dir: Path) -> int:
         errors.append(f"duplicate ids found: {sorted(list(duplicate_ids))[:5]}")
     if duplicate_texts:
         errors.append(f"duplicate text fields found: {len(duplicate_texts)} duplicates")
+    sample_ids = {row.get("id") for row in sample_rows}
     missing_samples = sample_ids - set(ids)
     if missing_samples:
         errors.append(f"samples_for_review.jsonl contains ids not present in train/eval: {sorted(list(missing_samples))[:5]}")
@@ -165,17 +277,58 @@ def validate(data_dir: Path) -> int:
         if field not in eval_df.columns:
             errors.append(f"eval.parquet missing column {field}")
 
+    try:
+        info = json.loads(info_path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        errors.append(f"dataset_info.json invalid JSON: {exc}")
+        info = {}
+    if info.get("version") != "v0.3":
+        errors.append("dataset_info.json version must be v0.3")
+    if info.get("repo_id") != "skyzhou06/LifeStreamingCoT":
+        errors.append("dataset_info.json repo_id must be skyzhou06/LifeStreamingCoT")
+    if info.get("generation_method") != "source_grounded_rule_based_v0.3_selective_concise":
+        errors.append("dataset_info.json generation_method is incorrect")
+    if info.get("reasoning_policy") != "selective_concise":
+        errors.append("dataset_info.json reasoning_policy is incorrect")
+
+    total_chunks = sum(row.get("num_chunks", 0) for row in all_rows)
+    skip_chunks = sum(len(row.get("skip_chunks", [])) for row in all_rows)
+    rows_with_skip = sum(1 for row in all_rows if row.get("skip_chunks"))
+    forbidden_count = sum(forbidden_phrase_hits(row) for row in all_rows)
+    if all_rows and rows_with_skip / len(all_rows) < 0.10:
+        errors.append("fewer than 10% of examples contain at least one skip chunk")
+    if forbidden_count:
+        errors.append(f"forbidden generic phrase count must be 0, found {forbidden_count}")
+
+    domains = Counter(row.get("domain") for row in all_rows)
+    avg_chunks = sum(row.get("num_chunks", 0) for row in all_rows) / len(all_rows) if all_rows else 0
+    avg_original = sum(row.get("original_num_chunks", 0) for row in all_rows) / len(all_rows) if all_rows else 0
+    avg_split = sum(row.get("chunk_split_count", 0) for row in all_rows) / len(all_rows) if all_rows else 0
+    avg_stream = sum(word_count(row.get("streaming_reasoning", "")) for row in all_rows) / len(all_rows) if all_rows else 0
+    avg_deep = sum(word_count(row.get("deep_reasoning", "")) for row in all_rows) / len(all_rows) if all_rows else 0
+    quality_flags = Counter(flag for row in all_rows for flag in row.get("quality_flags", []))
+
     print("Validation summary")
+    print(f"total rows: {len(all_rows)}")
     print(f"train rows: {len(train_rows)}")
     print(f"eval rows: {len(eval_rows)}")
+    print(f"domains: {dict(sorted(domains.items()))}")
+    print(f"average num_chunks: {avg_chunks:.2f}")
+    print(f"average original_num_chunks: {avg_original:.2f}")
+    print(f"average chunk_split_count: {avg_split:.2f}")
+    print(f"average streaming_reasoning words: {avg_stream:.2f}")
+    print(f"average deep_reasoning words: {avg_deep:.2f}")
+    print(f"skip chunk ratio: {skip_chunks / total_chunks if total_chunks else 0:.4f}")
+    print(f"examples with at least one skip: {rows_with_skip}")
+    print(f"quality_flags distribution: {dict(sorted(quality_flags.items()))}")
+    print(f"forbidden phrase count: {forbidden_count}")
     print(f"review sample rows: {len(sample_rows)}")
-    print(f"total rows: {len(all_rows)}")
     print(f"errors: {len(errors)}")
     if errors:
-        for error in errors[:100]:
+        for error in errors[:120]:
             print(f"ERROR: {error}")
-        if len(errors) > 100:
-            print(f"ERROR: ... {len(errors) - 100} more")
+        if len(errors) > 120:
+            print(f"ERROR: ... {len(errors) - 120} more")
         return 1
     print("validation passed")
     return 0