Add Coding Intelligence MCTS sample (10K traces) with README, SCHEMA, parquet, JSONL

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+coding_intel_sample.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,167 @@
+---
+license: cc-by-4.0
+task_categories:
+  - text-generation
+  - text-classification
+  - reinforcement-learning
+language:
+  - en
+  - code
+tags:
+  - synthetic
+  - coding-agent
+  - mcts
+  - reasoning-traces
+  - process-reward-model
+  - rlhf
+  - dpo
+  - agentic-ai
+  - tool-use
+  - code-generation
+  - llm-training
+  - ucb
+  - reward-modeling
+pretty_name: Coding Agent MCTS Reasoning Trace Pack
+size_categories:
+  - 10K<n<100K
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path: coding_intel_sample.parquet
+---
+
+# Coding Agent MCTS Reasoning Trace Pack (Sample)
+
+**A synthetic Monte Carlo Tree Search reasoning-trace dataset for autonomous coding agents.** Each row is a complete reasoning lifecycle — initial context analysis → draft exploration → test feedback → prune-or-anchor → final outcome — labeled with a reasoning phenotype (TEST_DRIVEN, HACKER, DEEP_THINK, SECURITY_FIRST, REFACTOR_HEAVY) and carrying UCB scores at every step and explicit rewards at terminal actions.
+
+Built by [SolsticeAI](https://www.solsticestudio.ai/datasets) as a free sample of a larger commercial pack. 100% synthetic. No real code, no proprietary repos — task titles and descriptions are generic archetypes drawn from canonical library patterns.
+
+## What is included
+
+| File | Rows | Format | Purpose |
+|---|---:|---|---|
+| `coding_intel_sample.parquet` | 10,000 | Parquet | Columnar, typed, best for analytics and RL training |
+| `coding_intel_sample.jsonl` | 10,000 | JSON Lines | Streaming / LLM training friendly |
+
+**Source pack:** 2.5M-trace corpus  
+**This sample:** 10,000 reasoning traces, stratified 2,000 per reasoning phenotype  
+**Reasoning phenotypes (5):** `TEST_DRIVEN`, `HACKER`, `DEEP_THINK`, `SECURITY_FIRST`, `REFACTOR_HEAVY`  
+**Task types (3):** `bugfix`, `feature`, `refactor` (~3,300 each)  
+**Languages (4):** `python`, `rust`, `go`, `typescript` (~2,500 each)  
+**Production impact tiers:** `LOW`, `MEDIUM`, `HIGH`, `CRITICAL` (~2,500 each)
+
+## Record structure
+
+Each record is one reasoning lifecycle with 7 top-level fields:
+
+| Field | Type | Contents |
+|---|---|---|
+| `schema_version` | string | Pack schema version (`1.0.0-coding-intel-sample`) |
+| `event` | struct | `task_id`, `task_type`, `language`, `title`, `description` |
+| `risk_context` | struct | `test_coverage_baseline`, `cyclomatic_complexity`, `production_impact` |
+| `agent_reasoning` | list<struct> | Ordered reasoning steps: `action` (`analyze_context`, `write_draft`, `run_tests`, `lethe_prune`, `prometheus_anchor`), `depth`, `ucb_score` (null at root / terminal), `reward` (populated on terminal actions only), `thought` (natural-language rationale) |
+| `correlated_telemetry` | struct | `linter_warnings_initial`, `linter_warnings_final`, `test_runtime_ms`, `ci_status` |
+| `execution_summary` | struct | `files_changed`, `lines_added`, `lines_removed`, `time_to_resolution_sec` |
+| `genetic_optimizer_feedback` | struct | `final_reward`, `lethe_prunes_triggered`, `nodes_expanded`, `phenotype_used` |
+
+See [SCHEMA.md](./SCHEMA.md) for the full nested field breakdown.
+
+## Why this dataset is useful
+
+Most public coding datasets (HumanEval, SWE-bench, MBPP) only give you the *final answer* and the task description. They don't capture the reasoning tree the agent walked through — the wrong paths, the prunes, the anchor points. This pack is shaped around what modern agent-training pipelines actually need:
+
+- **Explicit exploration vs exploitation.** Traces include both successful and pruned branches — `lethe_prune` events with negative reward, `prometheus_anchor` events with positive reward. Roughly 30% of traces carry a failed exploration branch before reaching the golden timeline.
+- **Reward signals embedded at every step.** UCB scores at each non-terminal step, explicit rewards at terminal actions — directly usable for RL, DPO, and process-reward-model training.
+- **Phenotype labels on every trace.** Train a `SECURITY_FIRST` coder specifically; run phenotype-transfer studies; build strategy-aware evaluation harnesses.
+- **Correlated telemetry.** Linter-warning deltas, test runtime, and CI status correlated to reasoning outcome — grounds the trace in observable signals.
+- **Compact.** Parquet fits in 340 KB, JSONL in 12.5 MB — you can pull this into a notebook in seconds and iterate.
+
+## Typical use cases
+
+- MCTS-based coding agent architecture training
+- Process reward model (PRM) training
+- Reasoning-chain evaluation benchmarks
+- Agent self-improvement via trace replay
+- Strategy-conditional code-generation research
+- Curriculum learning with task-difficulty ladders
+- LLM fine-tuning on structured reasoning narratives
+- Benchmarking UCB-based exploration policies
+
+## Quick start
+
+```python
+import pandas as pd
+import pyarrow.parquet as pq
+
+df = pq.read_table("coding_intel_sample.parquet").to_pandas()
+
+# Phenotype distribution (stratified balanced)
+print(df["genetic_optimizer_feedback"].apply(lambda g: g["phenotype_used"]).value_counts())
+
+# Average final reward by phenotype
+df["pheno"] = df["genetic_optimizer_feedback"].apply(lambda g: g["phenotype_used"])
+df["reward"] = df["genetic_optimizer_feedback"].apply(lambda g: g["final_reward"])
+print(df.groupby("pheno")["reward"].mean().round(2))
+
+# Prune rate by task type
+df["task"] = df["event"].apply(lambda e: e["task_type"])
+df["prunes"] = df["genetic_optimizer_feedback"].apply(lambda g: g["lethe_prunes_triggered"])
+print(df.groupby("task")["prunes"].mean().round(2))
+
+# Pull one full reasoning chain
+row = df.iloc[0]
+for step in row["agent_reasoning"]:
+    print(f"  d={step['depth']:<2} {step['action']:<20} ucb={step['ucb_score']} reward={step['reward']}: {step['thought']}")
+```
+
+Streaming form:
+
+```python
+import json
+
+with open("coding_intel_sample.jsonl") as f:
+    for line in f:
+        trace = json.loads(line)
+        # one MCTS reasoning trace per line
+```
+
+## Notes and limitations
+
+- **Reasoning traces use canned action templates rather than live-executed code.** This pack is designed for agent-architecture training, not end-to-end SWE-bench-style evaluation.
+- **`ci_status` is `SUCCESS` for every row in this sample** — the production pack includes `FAILURE` / `FLAKY` / `TIMEOUT` variants; this free sample is restricted to golden-timeline anchored traces to keep a clean reward surface.
+- **UCB scores at root nodes use positive infinity** (serialized as `"Infinity"` in JSONL), following the standard MCTS convention.
+- Phenotype distribution is uniform; production licensing supports custom phenotype mixes.
+
+## Responsible use
+
+This dataset is intended for **agent-training, process-reward-model, and MCTS research**. It contains synthesized reasoning narratives and action templates — it does **not** contain real code, real commit history, or proprietary repository content. Models trained on this data will learn reasoning structure and phenotype-conditional behavior; downstream code-generation quality still depends on training with real-code supervision from appropriately licensed corpora.
+
+## License
+
+Released under **CC BY 4.0**. Use freely for research, agent prototyping, education, and commercial development with attribution.
+
+## Get the full pack
+
+This Hugging Face repo is a **10K-trace sample**. The production pack scales to 2.5M+ traces with wider CI-outcome distribution (FAILURE / FLAKY / TIMEOUT), additional languages (C++, Java, Kotlin, Swift, C#), AST-diff variants, tool-call graph traces, multi-turn user-interaction sequences, custom phenotype mixes, and buyer-specific variants.
+
+**Self-serve (Stripe checkout):**
+- [**Sample Scale tier — $5,000**](https://buy.stripe.com/7sY5kD2j85QTfSb5lfeEo03) — ~25K records, one subject, 72-hour delivery.
+
+**Full pack + enterprise scope:**
+- [www.solsticestudio.ai/datasets](https://www.solsticestudio.ai/datasets) — per-SKU pricing across Starter / Professional / Enterprise tiers, plus commercial licensing, custom generation, and buyer-specific variants.
+
+**Procurement catalog:**
+- [SolsticeAI Data Storefront](https://solsticeai.mydatastorefront.com) — available via Datarade / Monda.
+
+## Citation
+
+```bibtex
+@dataset{solstice_coding_intel_pack_2026,
+  title        = {Coding Agent MCTS Reasoning Trace Pack (Sample)},
+  author       = {SolsticeAI},
+  year         = {2026},
+  publisher    = {Hugging Face},
+  url          = {https://huggingface.co/datasets/solsticestudioai/coding-intel-pack}
+}
+```

SCHEMA.md

@@ -0,0 +1,92 @@
+# Coding Agent MCTS Reasoning Trace Pack — Schema
+
+One row = one complete MCTS reasoning lifecycle. All records share the same seven top-level fields.
+
+Schema version: `1.0.0-coding-intel-sample`
+
+## Top-level fields
+
+### `schema_version` — string
+Schema identifier. Constant within a sample release.
+
+### `event` — struct
+Task identity and description.
+
+| Field | Type | Notes |
+|---|---|---|
+| `task_id` | string | Stable task identifier, e.g., `TASK-D8DFB752`. UUID-derived. |
+| `task_type` | string | `bugfix`, `feature`, `refactor`. |
+| `language` | string | `python`, `rust`, `go`, `typescript`. |
+| `title` | string | Generic task title (e.g., `Fix off-by-one error`, `Refactor the parser`, `Add retry logic`). |
+| `description` | string | Short user-intent statement. |
+
+### `risk_context` — struct
+Baseline code-health signals for the task target.
+
+| Field | Type | Notes |
+|---|---|---|
+| `test_coverage_baseline` | double | Percent test coverage at task start (0–100). |
+| `cyclomatic_complexity` | int | Baseline cyclomatic complexity score. |
+| `production_impact` | string | `LOW`, `MEDIUM`, `HIGH`, `CRITICAL`. |
+
+### `agent_reasoning` — list<struct>
+Ordered MCTS reasoning steps. One struct per step.
+
+Step struct:
+
+| Field | Type | Notes |
+|---|---|---|
+| `action` | string | Step type: `analyze_context` (root), `write_draft`, `run_tests`, `lethe_prune` (failed branch), `prometheus_anchor` (golden timeline). |
+| `depth` | int | Tree depth of this step (root = 0). |
+| `ucb_score` | double | UCB score at this step. `Infinity` at root nodes, `null` at terminal actions. |
+| `reward` | double | Terminal reward. Populated only on `lethe_prune` (negative) or `prometheus_anchor` (positive); `null` elsewhere. |
+| `thought` | string | Natural-language rationale for the step. |
+
+### `correlated_telemetry` — struct
+Observable signals correlated to the reasoning outcome.
+
+| Field | Type | Notes |
+|---|---|---|
+| `linter_warnings_initial` | int | Linter warnings before the task. |
+| `linter_warnings_final` | int | Linter warnings after the golden timeline commit. |
+| `test_runtime_ms` | int | Runtime of the test suite at anchor time, ms. |
+| `ci_status` | string | `SUCCESS` in this sample (production pack includes `FAILURE`, `FLAKY`, `TIMEOUT`). |
+
+### `execution_summary` — struct
+Diff-level metrics at the golden timeline commit.
+
+| Field | Type | Notes |
+|---|---|---|
+| `files_changed` | int | Files touched. |
+| `lines_added` | int | Lines added. |
+| `lines_removed` | int | Lines removed. |
+| `time_to_resolution_sec` | double | End-to-end lifecycle duration (seconds). |
+
+### `genetic_optimizer_feedback` — struct
+Outer-loop optimizer metrics used to tune future MCTS policies.
+
+| Field | Type | Notes |
+|---|---|---|
+| `final_reward` | double | Terminal reward attributed to the golden timeline. |
+| `lethe_prunes_triggered` | int | Count of `lethe_prune` actions in the trace. |
+| `nodes_expanded` | int | Total MCTS nodes expanded during the trace. |
+| `phenotype_used` | string | `TEST_DRIVEN`, `HACKER`, `DEEP_THINK`, `SECURITY_FIRST`, `REFACTOR_HEAVY`. |
+
+## Distribution of this sample
+
+- 10,000 traces, stratified 2,000 per reasoning phenotype across all five phenotypes.
+- Task type: balanced (~3,300 each across bugfix / feature / refactor).
+- Language: balanced (~2,500 each across python / rust / go / typescript).
+- Production impact: balanced (~2,500 each across LOW / MEDIUM / HIGH / CRITICAL).
+- CI status is `SUCCESS` for every row in this sample; production pack includes failure variants.
+
+## Sanitization notes
+
+- Task IDs are UUID-derived synthetic identifiers (e.g., `TASK-D8DFB752`).
+- Task titles and descriptions are generic archetypes (e.g., `Fix off-by-one error`, `Add retry logic`) — no real commit messages, PRs, or issue descriptions are present.
+- No real code content, no diffs, no actual linter output.
+- `ucb_score` uses the IEEE-754 infinity representation at root nodes. Parquet preserves this natively; JSONL serializes as the string `"Infinity"`.
+
+## Relationship to the full pack
+
+The production pack scales to 2.5M+ traces with wider CI-outcome distribution (`FAILURE`, `FLAKY`, `TIMEOUT`), additional languages (C++, Java, Kotlin, Swift, C#), AST-diff variants, tool-call graph traces, multi-turn user-interaction sequences, and custom phenotype mixes. See the pack card for commercial access.

coding_intel_sample.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45f45fcc7411b192ebcc5d15abb8372d26ea88afa6592ca529a118d63956a855
+size 12525896

coding_intel_sample.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfcd2f90bd6cccb91036983ddb735bdbb297e2d6bc4173c67e42bf2d6d542229
+size 338690