Scaffold-Agent SFT final: 19652 records, 6792 sessions, 898.7M trainable tokens

.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
+scaffold_agent_sft_final.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,78 @@
+---
+license: cc-by-4.0
+task_categories:
+- text-generation
+language:
+- en
+tags:
+- chain-of-thought
+- reasoning
+- sft
+- tool-use
+- coding-agent
+- multi-turn
+size_categories:
+- 10K<n<100K
+configs:
+- config_name: default
+  data_files: "scaffold_agent_sft_final.jsonl"
+---
+
+# Scaffold-Agent
+
+Long, multi-turn agentic coding sessions for supervised fine-tuning. 19,652
+records from 6,792 sessions (1,005.1M tokens, 898.7M trainable after masks).
+Every assistant action is preceded by a Scaffold-CoT reasoning block
+(Inventory → Interaction → Execution) in `reasoning_content`. Sessions cover
+editing real repositories and building from scratch, including recovery from
+errors and demanding simulated users. Sessions run 10 to 100+ turns.
+
+Built from the ScaffoldAgent Experiment 2 generation pipeline (teacher:
+`stealth/space-bunny-alpha` through a scaffold-reframing gateway; harness: Pi
+0.81.1). See `training_sft_config.yaml` in this repo for the documented
+multi-turn SFT setup (sample definition, role/loss mapping, splits).
+
+## Fields
+
+Every row is one compaction segment (1–8 per session, each ≤ 64k tokens) and is
+a self-contained training sample — do not join segments of a session.
+
+| Field | Contents |
+| --- | --- |
+| `id` | `{session}-s{segment}` record id |
+| `session` | Session id (`repo-…` = live-repo work, `scratch-…` = from-scratch work) |
+| `segment` / `segments_in_session` | Position of this record within its session |
+| `tokens` / `chars` | o200k_base token count and character count of the record |
+| `tools` | Function definitions available in this segment (render to tool schema; never train as text) |
+| `messages` | Ordered chat messages: `system` (once), `user` (task + simulated user), `assistant` (with `tool_calls`, `reasoning_content`, and per-message `loss`), `tool` (execution results) |
+
+Assistant messages carry `loss: {content, reasoning}`. Train content only when
+`loss.content` is true and reasoning only when `loss.reasoning` is true;
+everything else is context. The main shard (~916M tokens) is masked by a
+two-judge turn filter (~3.4% of content, ~30.9% of reasoning masked as
+contradicted or unfaithful). The campaign22 shard (~89M tokens) was admitted
+under relaxed gates (verification only, no grade bar) and is fully unmasked.
+
+## Build
+
+Selected by hidden-test verification plus a senior-reviewer code grade
+(mergeable verdict, correctness/readability/idiom/scope floors, no test
+gaming; from-scratch bug claims checked by execution). Main shard: 6,444
+sessions. Campaign22 shard: 348 verified sessions. Per-message loss masks from
+two independent turn judgments on the main shard. Split train/val by session
+id, never by record — segments of one session share history.
+
+## Loading
+
+```python
+from datasets import load_dataset
+ds = load_dataset("Specific-Labs/Scaffold-Agent", split="train")
+rec = ds[0]
+trainable = [m for m in rec["messages"]
+             if m["role"] == "assistant" and (m["loss"]["content"] or m["loss"]["reasoning"])]
+```
+
+Each record trains standalone: system prompt, tool definitions, and message
+history are all present in the row. Render `reasoning_content` through the
+model's reasoning channel, or flatten as `<think>…</think>` for plain chat
+models, following `loss.reasoning` either way.

scaffold_agent_sft_final.jsonl

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

training_set_final.json

@@ -0,0 +1,10 @@
+{
+  "selected_sessions": 6792,
+  "built_sessions": 6792,
+  "records": 19652,
+  "tokens": 1005069419,
+  "masked_tokens": 106397845,
+  "trainable_tokens": 898671574,
+  "assistant_messages": 796826,
+  "note": "main shard masked by two-judge filter; c22 shard unmasked per relaxed-gates owner decision 2026-10-05"
+}

training_set_final_c22.json

@@ -0,0 +1,11 @@
+{
+  "selected_sessions": 348,
+  "built_sessions": 348,
+  "records": 1752,
+  "tokens": 88698480,
+  "masked_tokens": 0,
+  "trainable_tokens": 88698480,
+  "assistant_messages": 62397,
+  "content_masked_share": 0.0,
+  "reasoning_masked_share": 0.0
+}

training_set_final_main.json

@@ -0,0 +1,11 @@
+{
+  "selected_sessions": 6444,
+  "built_sessions": 6444,
+  "records": 17900,
+  "tokens": 916370939,
+  "masked_tokens": 106397845,
+  "trainable_tokens": 809973094,
+  "assistant_messages": 734429,
+  "content_masked_share": 0.034434914743290364,
+  "reasoning_masked_share": 0.30928381096062385
+}

training_sft_config.yaml

@@ -0,0 +1,103 @@
+# Multi-turn SFT training configuration for the ScaffoldAgent final dataset.
+# This file is documentation-first: every setting explains what the data looks
+# and why the setting is shaped that way. Values under `training:` are
+# starting points for the trainer you are building, not tuned prescriptions.
+#
+# DATASET
+#   Records (JSONL, one per line): Data_Out/training/scaffold_agent_sft_final.jsonl
+#   Volume: 19,652 records / 6,792 sessions / 1,005.1M o200k tokens,
+#           898.7M trainable after masks (see Results/training_set_final.json).
+#   Split by shard: main 6,444 sessions (two-judge masked) + campaign22 348
+#           sessions (relaxed gates, fully unmasked, owner decision 2026-10-05).
+#
+# SAMPLE DEFINITION (this is the core of the setup -- read carefully)
+#   One record == one training sample. A record is one compaction segment
+#   (segment / segments_in_session, 1-8 per session, each <= 64k o200k).
+#   Each record is SELF-CONTAINED: it re-opens with the system prompt, the
+#   tool definitions, and the full message history since the last compaction
+#   (later segments open with the compaction summary as context). Training
+#   per-record matches inference: the agent always acts on compacted context.
+#   Do NOT join segments of one session into a single sample: that duplicates
+#   system/tools, can exceed the context window, and breaks the invariant the
+#   data was generated under. Do NOT split a record: tool_call_id references
+#   and scaffold-to-action adjacency would break.
+#
+# MESSAGE MAP (observed in the bytes, shard_main.jsonl + shard_c22.jsonl)
+#   system    x1 per record. Never trained. Keep verbatim (it names the tools).
+#   user      task prompts + simulated-user turns. Never trained. `content` is
+#             a string or a [{type: text, ...}] list -- normalize lists to text.
+#   assistant tool-calling turns AND final text turns. The ONLY trained role,
+#             gated per message by its `loss` object (see MASKS).
+#             `content` may be null on pure tool-call turns (train the call).
+#             `reasoning_content` holds the Scaffold-CoT scaffold
+#             (Inventory -> Interaction -> Execution). `tool_calls` holds the
+#             OpenAI-style calls the scaffold justifies.
+#   tool      execution results ({role, tool_call_id, content}). Never trained;
+#             they are the environment's voice. Keep as context.
+#   tools[]   (top-level) function definitions, repeated per record. Render
+#             into the model's tool schema; do not train them as text.
+#
+# MASKS (per assistant message: loss: {content: bool, reasoning: bool})
+#   Train content only when loss.content, reasoning only when loss.reasoning.
+#   Everything else (system/user/tool, and any assistant message with both
+#   false) is context-only. Masked text STAYS in the sequence -- it is not
+#   deleted. Main shard: ~3.4% content and ~30.9% reasoning masked by the
+#   two-judge filter (contradicted claims / unfaithful scaffolds). C22 shard:
+#   0% masked by owner decision -- its imperfect turns train as-is.
+#
+# REASONING CHANNEL (pick one; do not mix within a run)
+#   A) Native: feed reasoning_content through the model's reasoning channel
+#      (the format the teacher API used). Preferred when the target model has
+#      an explicit reasoning role or channel.
+#   B) Flattened: render as <think>...</think> prefix of the assistant message
+#      (the README's documented flattening). Preferred for plain chat models.
+#   Either way, loss on reasoning tokens follows loss.reasoning exactly.
+#
+# SPLITS
+#   Hold out by SESSION (session id), never by record: segments of one session
+#   share history, so a record-level split leaks across train/val. Suggested:
+#   98/1/1 by session, stratified by kind (repo/scratch) and shard (main/c22).
+#
+# ACCEPTANCE (run before any training launch -- falsifiable)
+#   1. Loader parses all 19,652 lines as JSON with messages/tools intact.
+#   2. Masked-token share recomputed by the loader matches the summary within
+#      1% (content ~3.4%, reasoning ~30.9% on the main shard; 0% on c22).
+#   3. Zero loss falls on system/user/tool tokens (assert on one batch).
+#   4. No sample exceeds the model's context in TARGET tokenizer tokens
+#      (records are <= 64k o200k; your tokenizer differs -- measure, and SKIP
+#      (don't truncate) the few overflows so tool references stay intact).
+#   5. Val sessions share zero session ids with train.
+
+dataset:
+  path: "../Data_Out/training/scaffold_agent_sft_final.jsonl"
+  format: "openai-chat-messages + reasoning_content + loss masks + tools"
+  sample_unit: "one record (one compaction segment)"
+  join_segments: false
+  split_segments: false
+  split_by: "session"
+  val_sessions: 68 # ~1% of 6,792; stratify by kind and shard
+  test_sessions: 68
+
+mapping:
+  system: { train: false, keep: "verbatim" }
+  user: { train: false, normalize_content_list: true }
+  assistant:
+    train_content_when: "loss.content == true"
+    train_reasoning_when: "loss.reasoning == true"
+    reasoning_channel: "native" # or "think-tags"; see REASONING CHANNEL
+    train_tool_calls_when: "loss.content == true"
+  tool: { train: false, keep: "as context" }
+  tools: { train: false, render: "model tool schema" }
+
+sequence:
+  max_tokens_target_tokenizer: 65536 # measure; records are <= 64k o200k
+  overflow_policy: "skip record, never truncate history"
+  packing: "optional; whole records only, never split a record"
+  shuffle: "by record; session-aware batching optional"
+
+training: # starting points only -- tune on val loss
+  objective: "causal LM with per-token loss mask from mapping above"
+  learning_rate: 1.0e-5
+  warmup_ratio: 0.03
+  epochs: 2
+  batch_tokens: 1048576 # 1M-token batches; scale to hardware