Document final route coverage and include supplemental preprocessing sources

LICENSES.md

@@ -13,3 +13,11 @@ Apache-2.0 license for the data.
 
 Text windows and media preprocessing are modifications for Inkling calibration.
 All source attributions, third-party rights and applicable source terms remain.
+
+The structured-dialog supplement additionally uses these exact revisions:
+
+- NVIDIA Nemotron Cascade SFT Stage 2: `54cfa23ba28c9d94aeae15142e73bde6f8d14d8b`, `tool_calling.jsonl`.
+- NVIDIA Nemotron SFT Instruction Following Chat v2: `1a9454ed054b8544503ab8d8c0a519d141a44c5b`, `data/reasoning_on.jsonl`.
+
+Their source terms remain applicable. GPL-3.0 and Apache-2.0 license texts
+are included in `licenses/`; the source links above identify other terms.

README.md

@@ -49,8 +49,10 @@ The primary balanced pass is:
 | Total | 1,462 | 1,049,129 | 100% |
 
 A subsequent coverage pass added 201 real structured reasoning/tool conversations
-(529,126 tokens, seed 3408, up to 4,096 tokens per sample). It addresses rare
-experts, including L41 expert 123 which was unobserved in the primary pass.
+(529,126 tokens, seed 3408, up to 4,096 tokens per sample). It probes rare
+experts, including L41 expert 123, which remained unobserved after both passes.
+The final model protects L40–41 with Q4_K; expert 123 uses ordinary Q4_K
+without fabricated importance data.
 These are normalized from the pinned NVIDIA Instruction-Following-Chat-v2
 reasoning_on and Cascade-SFT-Stage-2 tool_calling sources and rendered with actual
 Inkling thinking/tool syntax. Total actual input: **1,578,255 tokens**.
@@ -116,3 +118,16 @@ is recorded with the reproduction materials and model handoff.
 
 See [LICENSES.md](LICENSES.md). Source-specific licenses remain applicable;
 this collection does not relicense its constituent examples.
+
+## Rebuilding and replay
+
+For exact replay, download the published tensor packs and use the index above.
+`build_samples.py` reconstructs the primary pack from source media and the
+checksum-pinned K2 text pools; those historical pool files are retained in the
+owner’s earlier private handoff. `build_supplement.py` reconstructs the added
+structured dialogs; its two source dataset revisions and raw row hashes are
+in `manifest.json`. The normalizer helpers are under `refs/`.
+Set `INKLING_ROOT` to the prepared work tree, with tokenizer/processor files
+in `source/`, source media under `calibration/`, and the helpers in `refs/`.
+The pinned Transformers commit is in `provenance/toolchain.json`. Exact input
+replay does not require access to the private historical text pools.

convert.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Lossless source-layout GGUF container plus per-role GGML quantization.
+
+Names and interleaved gate/up row ordering remain identical to the source.
+No row permutation, expert removal, or implicit precision fallback is allowed.
+"""
+import argparse, collections, ctypes, hashlib, json, math, re, time
+from pathlib import Path
+import numpy as np
+import gguf
+
+ROOT=Path(__import__('os').environ.get('INKLING_ROOT', '/inkling'))
+LAYOUT={'BF16':(30,1,2),'F32':(0,1,4),'Q8_0':(8,32,34),'IQ2_XXS':(16,256,66),'Q2_K':(10,256,84),'Q4_K':(12,256,144)}
+
+def policy(name, dtype, variant):
+    if variant=='BF16' or name.startswith('model.mtp.'):
+        return dtype
+    if '.mlp.experts.' in name:
+        if variant=='Q8_0': return 'Q8_0'
+        if int(name.split('.')[3])==2: return dtype
+        if variant=='MQ89' and int(name.split('.')[3])>=40: return 'Q4_K'
+        return 'IQ2_XXS' if 'w13' in name else 'Q2_K'
+    if name in ('model.llm.embed.weight','model.llm.unembed.weight') or '.mlp.shared_experts.' in name or re.search(r'layers\.[01]\.mlp\.w',name):
+        return 'Q8_0'
+    return dtype
+
+def inventory(variant, mtp=False):
+    meta=json.load(open(ROOT/'refs/safetensors-metadata.json'))
+    out=[]
+    for file, fm in meta['files_metadata'].items():
+        for name,t in fm['tensors'].items():
+            if name.startswith('model.mtp.') != mtp: continue
+            typ=policy(name,t['dtype'],variant); code,block,size=LAYOUT[typ]
+            if typ not in ('BF16','F32'): assert t['shape'][-1]%block==0, name
+            out.append(dict(name=name,shape=t['shape'],dtype=t['dtype'],type=typ,file=file,source_offsets=t['data_offsets'],bytes=math.prod(t['shape'])//block*size))
+    return sorted(out,key=lambda t:t['name'])
+
+def header_size(path):
+    with open(path,'rb') as f: return int.from_bytes(f.read(8),'little')+8
+
+def source_array(t, source):
+    return np.memmap(source/t['file'],mode='r',dtype='<u2' if t['dtype']=='BF16' else '<f4',offset=header_size(source/t['file'])+t['source_offsets'][0],shape=tuple(t['shape']))
+
+def main():
+    p=argparse.ArgumentParser(); p.add_argument('--variant',choices=['BF16','Q8_0','MQ85','MQ89'],required=True); p.add_argument('--mtp',action='store_true'); p.add_argument('--plan',action='store_true');p.add_argument('--threads',type=int,default=64);p.add_argument('--imatrix',type=Path);args=p.parse_args()
+    ts=inventory(args.variant,args.mtp); tag='MTP-BF16' if args.mtp else args.variant
+    outdir=ROOT/'artifacts'/tag;outdir.mkdir(exist_ok=True)
+    counts=collections.Counter()
+    for t in ts: counts[t['type']]+=t['bytes']
+    plan={'variant':tag,'tensor_count':len(ts),'payload_bytes':sum(counts.values()),'payload_gib':sum(counts.values())/2**30,'type_bytes':dict(counts),'tensors':ts}
+    (outdir/'tensor-plan.json').write_text(json.dumps(plan,indent=2));print(json.dumps({k:v for k,v in plan.items() if k!='tensors'}),flush=True)
+    if args.plan:return
+    if list(outdir.glob('*.gguf')):raise RuntimeError('Output exists; refusing overwrite')
+    if args.variant in ('MQ85','MQ89') and not args.imatrix:raise RuntimeError('Measured imatrix required')
+    imp=np.load(args.imatrix) if args.imatrix else None
+    writer=gguf.GGUFWriter(outdir/f'Inkling-Small-{tag}.gguf','inkling',split_max_size=16*2**30)
+    writer.add_name(f'Inkling-Small {tag}')
+    writer.add_string('inkling.tensor_layout','source-interleaved-v1')
+    writer.add_string('inkling.config.json',(ROOT/'source/config.json').read_text())
+    writer.add_string('inkling.quantization.recipe',tag)
+    writer.add_string('general.source.huggingface.repository','thinkingmachines/Inkling-Small')
+    writer.add_string('general.source.huggingface.revision',json.load(open(ROOT/'refs/source-manifest.json'))['revision'])
+    writer.add_string('inkling.tokenizer.json',(ROOT/'source/tokenizer.json').read_text())
+    writer.add_string('inkling.tokenizer_config.json',(ROOT/'source/tokenizer_config.json').read_text())
+    writer.add_chat_template((ROOT/'source/chat_template.jinja').read_text())
+    writer.add_string('inkling.processor_config.json',(ROOT/'source/processor_config.json').read_text())
+    writer.add_bool('inkling.mtp.sidecar',args.mtp)
+    if imp:
+        writer.add_string('inkling.imatrix.sha256',hashlib.sha256(args.imatrix.read_bytes()).hexdigest())
+    for t in ts:
+        writer.add_tensor_info(t['name'],t['shape'],np.dtype('float32'),t['bytes'],raw_dtype=gguf.GGMLQuantizationType(LAYOUT[t['type']][0]))
+    writer.write_header_to_file();writer.write_kv_data_to_file();writer.write_ti_data_to_file()
+    lib=ctypes.CDLL(str(ROOT/'artifacts/libinkling_quant.so'));fn=lib.quant_bf16
+    fn.argtypes=[ctypes.c_void_p,ctypes.c_void_p,ctypes.c_int64,ctypes.c_int64,ctypes.c_int64,ctypes.c_int,ctypes.c_void_p,ctypes.c_int];fn.restype=ctypes.c_int
+    started=time.time();fallbacks=[]
+    for i,t in enumerate(ts):
+        src=source_array(t,ROOT/'source')
+        if t['type'] in ('BF16','F32'):data=src
+        else:
+            assert t['dtype']=='BF16'
+            shape=t['shape']; experts=math.prod(shape[:-2]);rows,cols=shape[-2:]
+            importance=None
+            if t['type'] in ('IQ2_XXS','Q2_K','Q4_K'):
+                importance=np.ascontiguousarray(imp[t['name']],dtype=np.float32)
+                assert importance.shape==(experts,cols), (t['name'],importance.shape)
+                assert np.isfinite(importance).all() and (importance>=0).all(),t['name']
+                observed=(importance.sum(-1)>0)
+                assert ((importance>0).all(-1)|~observed).all(),t['name']
+                if not observed.all():assert t['type']=='Q4_K' and int(t['name'].split('.')[3])>=40,t['name']
+            data=np.empty(t['bytes'],dtype=np.uint8)
+            if importance is not None and not observed.all():
+                for e in range(experts):
+                    iptr=importance[e].ctypes.data if observed[e] else None
+                    assert fn(src[e].ctypes.data,data.ctypes.data+e*(t['bytes']//experts),1,rows,cols,LAYOUT[t['type']][0],iptr,args.threads)==0
+                    if not observed[e]:fallbacks.append({'tensor':t['name'],'expert':e,'type':'Q4_K','importance':'none; unobserved, higher-precision quantization'})
+            else:
+                assert fn(src.ctypes.data,data.ctypes.data,experts,rows,cols,LAYOUT[t['type']][0],importance.ctypes.data if importance is not None else None,args.threads)==0
+        writer.write_tensor_data(data)
+        print(f'{i+1}/{len(ts)} {t["name"]} {t["type"]} {t["bytes"]} elapsed={time.time()-started:.1f}',flush=True)
+        del src,data
+    writer.close()
+    (outdir/'conversion-complete.json').write_text(json.dumps({'seconds':time.time()-started,'tensor_count':len(ts),'unobserved_q4_fallbacks':fallbacks},indent=2))
+
+if __name__=='__main__':main()

refs/motif-3-handoff/reproduction/calibration/build_calibration.py

@@ -0,0 +1,465 @@
+#!/usr/bin/env python3
+"""Build Motif 3 imatrix text from the audited Solar mixed-quant composition.
+
+The source buckets, files, revisions, shares, and seed are fixed. Records are
+normalized with the checksum-pinned Healing Mix normalizer, then rendered by
+the official Motif 3 chat template and counted with the official tokenizer.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import random
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import requests
+from huggingface_hub import HfApi, get_token, hf_hub_url
+
+SOURCE_MODEL = "Motif-Technologies/Motif-3"
+SOURCE_REVISION = "ccceb1a5fd7b5eb32e47841216b3caf5666c07bc"
+REFERENCE_DATASET = "Baekpica/Solar-Open2-120B-A15B-REAM-148E-Healing-Mix"
+REFERENCE_REVISION = "1931f3a40cc3463217f9c7d25906f80ded029264"
+NORMALIZER_SHA256 = "677274f0d6a93326aa3d76e99e0d251d499317fa455dfb7eefed8fbc93ad1b93"
+MIN_BUCKET_COVERAGE = 0.98
+
+
+@dataclass(frozen=True)
+class Bucket:
+    name: str
+    repo: str
+    revision: str
+    files: tuple[str, ...]
+    share: float
+
+
+BUCKETS = (
+    Bucket(
+        "if_chat",
+        "nvidia/Nemotron-SFT-Instruction-Following-Chat-v2",
+        "1a9454ed054b8544503ab8d8c0a519d141a44c5b",
+        ("data/reasoning_on.jsonl", "data/reasoning_off.jsonl"),
+        0.22,
+    ),
+    Bucket(
+        "cascade1_reasoning",
+        "nvidia/Nemotron-Cascade-SFT-Stage-1",
+        "e59a356b107737562f064ec252e6adacbc737899",
+        ("general.jsonl", "science.jsonl", "math/math_1.jsonl", "code/code_1.jsonl"),
+        0.16,
+    ),
+    Bucket(
+        "cascade2_reasoning",
+        "nvidia/Nemotron-Cascade-SFT-Stage-2",
+        "54cfa23ba28c9d94aeae15142e73bde6f8d14d8b",
+        (
+            "instruction-following.jsonl",
+            "tool_calling.jsonl",
+            "general/general_1.jsonl",
+            "math/math_1.jsonl",
+            "science.jsonl",
+            "swe_repair.jsonl",
+            "swe_localization.jsonl",
+        ),
+        0.16,
+    ),
+    Bucket(
+        "ko",
+        "nvidia/Nemotron-SFT-Multilingual-v2",
+        "971a252224b75414b1b67c55dbe0446d8b6606a0",
+        (
+            "ultra-v3_math_ko_translated_final.jsonl",
+            "ultra-v3_code_ko_translated_final.jsonl",
+            "ultra-v3_stem_ko_translated_postedit_final.jsonl",
+        ),
+        0.16,
+    ),
+    Bucket(
+        "multilingual_other",
+        "nvidia/Nemotron-SFT-Multilingual-v2",
+        "971a252224b75414b1b67c55dbe0446d8b6606a0",
+        tuple(
+            f"ultra-v3_{domain}_{language}_{suffix}.jsonl"
+            for language in ("ja", "pt", "hi")
+            for domain, suffix in (
+                ("math", "translated_final"),
+                ("code", "translated_final"),
+                ("stem", "translated_postedit_final"),
+            )
+        ),
+        0.12,
+    ),
+    Bucket(
+        "finance",
+        "nvidia/Nemotron-SpecializedDomains-Finance-v1",
+        "5a21b106168facb96ced11b883c2a9b4788ee939",
+        ("data/train.jsonl",),
+        0.06,
+    ),
+    Bucket(
+        "swe_agentic",
+        "nvidia/Nemotron-SFT-SWE-v2",
+        "bd151f3f2d89c4804dda0083d912bd9f6a0a9fb7",
+        ("data/agentless.jsonl",),
+        0.06,
+    ),
+    Bucket(
+        "code_algo",
+        "nvidia/Nemotron-SFT-Competitive-Programming-v2",
+        "778afc98a9e027e10b3cd78020c120e93e142ef2",
+        (
+            "data/exercism.jsonl",
+            "data/text_to_sql.jsonl",
+            "data/competitive_programming_python_00.jsonl",
+        ),
+        0.06,
+    ),
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--out", type=Path, required=True)
+    parser.add_argument("--tokenizer", type=Path, required=True)
+    parser.add_argument("--normalizer", type=Path, required=True)
+    parser.add_argument("--total-tokens", type=int, default=4_000_000)
+    parser.add_argument("--seed", type=int, default=1234)
+    return parser.parse_args()
+
+
+def file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def load_normalizer(path: Path) -> Any:
+    digest = file_sha256(path)
+    if digest != NORMALIZER_SHA256:
+        raise RuntimeError(f"reference normalizer hash mismatch: {digest}")
+    spec = importlib.util.spec_from_file_location("healing_mix_normalizer", path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"cannot load normalizer: {path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def canonical_to_messages(canonical: dict[str, Any]) -> tuple[list[dict], list[dict] | None]:
+    messages: list[dict] = []
+    if canonical.get("system"):
+        messages.append({"role": "system", "content": canonical["system"]})
+    for turn in canonical["turns"]:
+        role = turn["role"]
+        if role == "assistant":
+            message: dict[str, Any] = {
+                "role": "assistant",
+                "content": turn.get("content", ""),
+            }
+            if turn.get("reasoning"):
+                message["reasoning_content"] = turn["reasoning"]
+            if turn.get("tool_calls"):
+                message["tool_calls"] = [
+                    {
+                        "id": call["id"],
+                        "type": "function",
+                        "function": {
+                            "name": call["name"],
+                            "arguments": call["arguments"],
+                        },
+                    }
+                    for call in turn["tool_calls"]
+                ]
+            messages.append(message)
+        elif role == "tool":
+            messages.append(
+                {
+                    "role": "tool",
+                    "content": turn.get("content", ""),
+                    "tool_call_id": turn.get("tool_call_id"),
+                }
+            )
+        else:
+            messages.append({"role": role, "content": turn.get("content", "")})
+    tools = canonical.get("tools")
+    if tools:
+        tools = [{"type": "function", "function": tool} for tool in tools]
+    return messages, tools
+
+
+def render_record(record: dict[str, Any], normalizer: Any, tokenizer: Any) -> str | None:
+    if isinstance(record.get("messages"), list):
+        try:
+            canonical = normalizer.normalize(record)
+            messages, tools = canonical_to_messages(canonical)
+            rendered = tokenizer.apply_chat_template(
+                messages,
+                tools=tools,
+                tokenize=False,
+                add_generation_prompt=False,
+                enable_thinking=True,
+            )
+            if len(rendered) >= 150:
+                return rendered
+        except normalizer.SkipRecord:
+            pass
+        except (TypeError, ValueError, KeyError, AttributeError):
+            pass
+
+    for key in ("text", "content", "problem", "question", "prompt"):
+        value = record.get(key)
+        if isinstance(value, str) and len(value.strip()) >= 100:
+            return tokenizer.apply_chat_template(
+                [{"role": "user", "content": value.strip()}],
+                tokenize=False,
+                add_generation_prompt=True,
+                enable_thinking=True,
+            )
+    return None
+
+
+class Sampler:
+    def __init__(self, seed: int, tokenizer: Any, normalizer: Any) -> None:
+        token = get_token()
+        self.session = requests.Session()
+        if token:
+            self.session.headers["Authorization"] = f"Bearer {token}"
+        self.session.headers["Accept-Encoding"] = "identity"
+        self.api = HfApi(token=token)
+        self.seed = seed
+        self.tokenizer = tokenizer
+        self.normalizer = normalizer
+        self.file_sizes: dict[tuple[str, str, str], int] = {}
+
+    def file_size(self, bucket: Bucket, filename: str) -> int:
+        key = (bucket.repo, bucket.revision, filename)
+        if key not in self.file_sizes:
+            info = self.api.dataset_info(
+                bucket.repo, revision=bucket.revision, files_metadata=True
+            )
+            if info.sha != bucket.revision:
+                raise RuntimeError(
+                    f"dataset revision mismatch for {bucket.repo}: {info.sha}"
+                )
+            for sibling in info.siblings:
+                self.file_sizes[(bucket.repo, bucket.revision, sibling.rfilename)] = (
+                    sibling.size or 0
+                )
+        return self.file_sizes.get(key, 0)
+
+    def sample_jsonl(
+        self, bucket: Bucket, filename: str, want_tokens: int, *, salt: int
+    ) -> list[tuple[str, int]]:
+        size = self.file_size(bucket, filename)
+        if size <= 0 or want_tokens <= 0:
+            return []
+        url = hf_hub_url(
+            bucket.repo,
+            filename,
+            repo_type="dataset",
+            revision=bucket.revision,
+        )
+        windows = 8
+        window_bytes = max(
+            1 << 20,
+            min(6 << 20, (want_tokens * 12 + windows - 1) // windows),
+        )
+        rng = random.Random(self.seed + salt)
+        starts = [
+            min(size - 1, int(size * (index + rng.random() * 0.7) / windows))
+            for index in range(windows)
+        ]
+        documents: list[tuple[str, int]] = []
+        tokens = 0
+        for start in starts:
+            if tokens >= want_tokens:
+                break
+            end = min(size - 1, start + window_bytes - 1)
+            if end <= start:
+                continue
+            try:
+                response = self.session.get(
+                    url,
+                    headers={"Range": f"bytes={start}-{end}"},
+                    timeout=300,
+                    stream=True,
+                )
+                if response.status_code != 206:
+                    response.close()
+                    print(
+                        f"    rejected unbounded response for {filename}: "
+                        f"HTTP {response.status_code}",
+                        file=sys.stderr,
+                    )
+                    continue
+                payload = response.content
+                response.close()
+            except requests.RequestException as exc:
+                print(
+                    f"    range failure {filename}: {type(exc).__name__}",
+                    file=sys.stderr,
+                )
+                continue
+
+            lines = payload.decode("utf-8", "ignore").splitlines()
+            if start > 0 and lines:
+                lines = lines[1:]
+            if end < size - 1 and lines:
+                lines = lines[:-1]
+            for line in lines:
+                try:
+                    record = json.loads(line)
+                except (json.JSONDecodeError, TypeError):
+                    continue
+                if not isinstance(record, dict):
+                    continue
+                rendered = render_record(record, self.normalizer, self.tokenizer)
+                if not rendered:
+                    continue
+                rendered = rendered[:32_000]
+                count = len(
+                    self.tokenizer.encode(rendered, add_special_tokens=False)
+                )
+                if count == 0:
+                    continue
+                documents.append((rendered, count))
+                tokens += count
+                if tokens >= want_tokens:
+                    break
+        return documents
+
+
+def main() -> None:
+    args = parse_args()
+    if args.total_tokens <= 0:
+        raise SystemExit("--total-tokens must be positive")
+    if abs(sum(bucket.share for bucket in BUCKETS) - 1.0) > 1e-9:
+        raise RuntimeError("calibration shares must sum to 1.0")
+    if not args.tokenizer.is_dir():
+        raise SystemExit(f"official tokenizer directory missing: {args.tokenizer}")
+    if not args.normalizer.is_file():
+        raise SystemExit(f"reference normalizer missing: {args.normalizer}")
+
+    from transformers import AutoTokenizer
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.tokenizer,
+        local_files_only=True,
+        trust_remote_code=True,
+    )
+    if tokenizer.vocab_size != 220_160:
+        raise RuntimeError(f"Motif tokenizer vocab mismatch: {tokenizer.vocab_size}")
+    normalizer = load_normalizer(args.normalizer)
+    sampler = Sampler(args.seed, tokenizer, normalizer)
+
+    corpus: list[str] = []
+    buckets_report: list[dict[str, Any]] = []
+    for bucket_index, bucket in enumerate(BUCKETS):
+        wanted = int(args.total_tokens * bucket.share)
+        per_file = max(1, wanted // len(bucket.files))
+        sampled: list[tuple[str, int]] = []
+        print(
+            f"[{bucket.name}] target {wanted / 1e6:.3f}M Motif tokens "
+            f"from {bucket.repo}@{bucket.revision[:8]}",
+            flush=True,
+        )
+        for file_index, filename in enumerate(bucket.files):
+            sampled.extend(
+                sampler.sample_jsonl(
+                    bucket,
+                    filename,
+                    per_file,
+                    salt=bucket_index * 101 + file_index,
+                )
+            )
+        documents = [document for document, _ in sampled]
+        actual_tokens = sum(count for _, count in sampled)
+        actual_chars = sum(len(document) for document in documents)
+        corpus.extend(documents)
+        report = {
+            "bucket": bucket.name,
+            "share": bucket.share,
+            "repo": bucket.repo,
+            "revision": bucket.revision,
+            "files": list(bucket.files),
+            "target_tokens": wanted,
+            "tokens": actual_tokens,
+            "chars": actual_chars,
+            "documents": len(documents),
+            "coverage": actual_tokens / wanted,
+            "status": (
+                "ok" if actual_tokens >= wanted * MIN_BUCKET_COVERAGE else "shortfall"
+            ),
+        }
+        buckets_report.append(report)
+        print(
+            f"    {len(documents)} docs, {actual_tokens / 1e6:.3f}M tokens, "
+            f"coverage={report['coverage']:.3f}",
+            flush=True,
+        )
+
+    shortfalls = [row["bucket"] for row in buckets_report if row["status"] != "ok"]
+    if shortfalls:
+        raise SystemExit(
+            "calibration buckets below 98% of target: " + ", ".join(shortfalls)
+        )
+
+    random.Random(args.seed).shuffle(corpus)
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(
+        "\n\n".join(document.replace("\r", "") for document in corpus) + "\n",
+        encoding="utf-8",
+    )
+
+    template_path = args.tokenizer / "chat_template.jinja"
+    tokenizer_path = args.tokenizer / "tokenizer.json"
+    composition = {
+        "schema_version": 1,
+        "output": str(args.out),
+        "output_sha256": file_sha256(args.out),
+        "bytes": args.out.stat().st_size,
+        "documents": len(corpus),
+        "seed": args.seed,
+        "requested_tokens": args.total_tokens,
+        "actual_tokens": sum(row["tokens"] for row in buckets_report),
+        "source_model": {"repo": SOURCE_MODEL, "revision": SOURCE_REVISION},
+        "reference_mix": {
+            "dataset": REFERENCE_DATASET,
+            "revision": REFERENCE_REVISION,
+            "normalizer_sha256": NORMALIZER_SHA256,
+            "reuse": "bucket shares, source files, source revisions, record normalization",
+        },
+        "tokenizer": {
+            "class": type(tokenizer).__name__,
+            "vocab_size": tokenizer.vocab_size,
+            "tokenizer_json_sha256": file_sha256(tokenizer_path),
+        },
+        "rendering": {
+            "template": "official Motif-3 chat_template.jinja",
+            "template_sha256": file_sha256(template_path),
+            "enable_thinking": True,
+            "tools": "preserved where present",
+        },
+        "buckets": buckets_report,
+    }
+    composition_path = args.out.with_suffix(".composition.json")
+    composition_path.write_text(
+        json.dumps(composition, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    print(
+        f"wrote {args.out}: {len(corpus)} docs, "
+        f"{args.out.stat().st_size / 1e6:.2f} MB"
+    )
+    print(f"composition -> {composition_path}")
+
+
+if __name__ == "__main__":
+    main()

refs/solar-data/scripts/solar_format.py

@@ -0,0 +1,305 @@
+"""Nemotron 계열 SFT 레코드를 Solar Open 2 chat template 문자열로 렌더하고
+assistant 토큰만 학습 대상으로 남기는 정규화/렌더러.
+
+렌더러는 v1 레포의 chat_template.jinja를 그대로 옮긴 것이며
+(provider_system_prompt=false, think_render_option="interleaved",
+add_generation_prompt=false), verify_renderer.py가 jinja 출력과
+바이트 단위 일치를 검증한다.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+
+THINK_RE = re.compile(r"^\s*<think>(.*?)</think>\s*", re.DOTALL)
+TOOL_CALL_RE = re.compile(r"<tool_call>\s*(\{.*?\})\s*</tool_call>", re.DOTALL)
+TOOL_RESP_RE = re.compile(r"^\s*<tool_response>(.*?)</tool_response>\s*$", re.DOTALL)
+QWEN_TOOLS_RE = re.compile(r"<tools>\s*(.*?)\s*</tools>", re.DOTALL)
+QWEN_TOOL_SECTION_RE = re.compile(
+    r"\n*#+ *Tools\b.*?(?=\Z)", re.DOTALL | re.IGNORECASE
+)
+
+
+class SkipRecord(Exception):
+    """정규화할 수 없는 레코드."""
+
+
+# --------------------------------------------------------------------------
+# 정규화: 소스별 방언 -> 단일 canonical 레코드
+# --------------------------------------------------------------------------
+def _extract_reasoning(msg: dict) -> tuple[str | None, str]:
+    """assistant 메시지에서 (reasoning, content) 분리."""
+    content = msg.get("content") or ""
+    reasoning = msg.get("reasoning_content") or msg.get("reasoning") or None
+    if reasoning is None:
+        m = THINK_RE.match(content)
+        if m:
+            reasoning = m.group(1).strip()
+            content = content[m.end():]
+    if reasoning is not None:
+        reasoning = reasoning.strip()
+        if not reasoning:
+            reasoning = None
+    return reasoning, content
+
+
+def _extract_tool_calls(msg: dict, content: str) -> tuple[list[dict], str]:
+    """OpenAI tool_calls 필드 또는 Qwen <tool_call> 인라인 블록을 파싱."""
+    calls: list[dict] = []
+    native = msg.get("tool_calls")
+    if native:
+        for i, tc in enumerate(native):
+            fn = tc.get("function", tc)
+            args = fn.get("arguments")
+            if isinstance(args, str):
+                try:
+                    args = json.loads(args)
+                except json.JSONDecodeError:
+                    args = {"_raw": args}
+            if not isinstance(args, dict):
+                args = {"_raw": str(args)}
+            calls.append({
+                "id": tc.get("id") or f"call_{i}",
+                "name": fn.get("name") or "unknown",
+                "arguments": args,
+            })
+        return calls, content
+
+    for i, m in enumerate(TOOL_CALL_RE.finditer(content)):
+        try:
+            obj = json.loads(m.group(1))
+        except json.JSONDecodeError:
+            continue
+        args = obj.get("arguments", {})
+        if isinstance(args, str):
+            try:
+                args = json.loads(args)
+            except json.JSONDecodeError:
+                args = {"_raw": args}
+        if not isinstance(args, dict):
+            args = {"_raw": str(args)}
+        calls.append({
+            "id": f"call_{i}",
+            "name": obj.get("name") or "unknown",
+            "arguments": args,
+        })
+    if calls:
+        content = TOOL_CALL_RE.sub("", content).strip()
+    return calls, content
+
+
+def _parse_qwen_system_tools(system: str) -> tuple[list[dict] | None, str]:
+    """Qwen 스타일 `<tools>` 선언을 OpenAI tool 스펙 리스트로 뽑고 시스템 텍스트에서 제거."""
+    m = QWEN_TOOLS_RE.search(system)
+    if not m:
+        return None, system
+    tools = []
+    for line in m.group(1).splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            obj = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if "function" in obj:
+            tools.append(obj["function"])
+        elif "name" in obj:
+            tools.append(obj)
+    if not tools:
+        return None, system
+    cleaned = QWEN_TOOL_SECTION_RE.sub("", system).strip()
+    return tools, cleaned
+
+
+def normalize(record: dict) -> dict:
+    """소스 레코드 -> {system, tools, turns[]}."""
+    messages = record.get("messages")
+    if not messages:
+        raise SkipRecord("no messages")
+
+    system_parts: list[str] = []
+    turns: list[dict] = []
+    for msg in messages:
+        role = msg.get("role")
+        if role == "system":
+            text = (msg.get("content") or "").strip()
+            if text:
+                system_parts.append(text)
+        elif role == "user":
+            content = (msg.get("content") or "").strip()
+            if not content:
+                raise SkipRecord("empty user turn")
+            turns.append({"role": "user", "content": content})
+        elif role == "assistant":
+            reasoning, content = _extract_reasoning(msg)
+            calls, content = _extract_tool_calls(msg, content)
+            content = content.strip()
+            if not content and not calls and not reasoning:
+                raise SkipRecord("empty assistant turn")
+            turns.append({
+                "role": "assistant",
+                "content": content,
+                "reasoning": reasoning,
+                "tool_calls": calls,
+            })
+        elif role in ("tool", "function"):
+            content = msg.get("content") or ""
+            m = TOOL_RESP_RE.match(content)
+            if m:
+                content = m.group(1)
+            turns.append({
+                "role": "tool",
+                "content": content.strip(),
+                "tool_call_id": msg.get("tool_call_id"),
+            })
+        else:
+            raise SkipRecord(f"unknown role {role}")
+
+    system = "\n\n".join(system_parts)
+    tools = record.get("tools")
+    if tools:
+        tools = [t.get("function", t) for t in tools]
+    else:
+        parsed, system = _parse_qwen_system_tools(system)
+        tools = parsed
+
+    # tool 응답에 id가 없으면 직전 assistant tool_call id를 순서대로 붙인다
+    for i, turn in enumerate(turns):
+        if turn["role"] != "tool" or turn.get("tool_call_id"):
+            continue
+        j = i - 1
+        while j >= 0 and turns[j]["role"] == "tool":
+            j -= 1
+        if j >= 0 and turns[j]["role"] == "assistant" and turns[j]["tool_calls"]:
+            offset = i - j - 1
+            calls = turns[j]["tool_calls"]
+            turn["tool_call_id"] = calls[min(offset, len(calls) - 1)]["id"]
+        else:
+            raise SkipRecord("orphan tool response")
+
+    if not any(t["role"] == "assistant" for t in turns):
+        raise SkipRecord("no assistant turn")
+    return {"system": system, "tools": tools, "turns": turns}
+
+
+# --------------------------------------------------------------------------
+# 렌더링: canonical -> (piece, is_target) 리스트
+# --------------------------------------------------------------------------
+def _render_tool_arguments(arguments: dict) -> str:
+    out = []
+    for key, value in arguments.items():
+        rendered = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False)
+        out.append(f"<|tool_arg:start|>{key}<|tool_arg:value|>{rendered}<|tool_arg:end|>\n")
+    return "".join(out)
+
+
+def render_pieces(rec: dict) -> list[tuple[str, bool]]:
+    """(text, is_loss_target) 조각 리스트. 특수 토큰 경계에서만 분할되므로
+    조각별 인코딩 후 이어붙여도 BPE 경계 문제가 없다."""
+    system, tools, turns = rec["system"], rec["tools"], rec["turns"]
+    pieces: list[tuple[str, bool]] = []
+    buf: list[str] = []
+
+    def emit(text: str):
+        buf.append(text)
+
+    def flush():
+        if buf:
+            pieces.append(("".join(buf), False))
+            buf.clear()
+
+    # ---- system block ----
+    if system or tools:
+        emit("<|im:start|>system<|im:content|>")
+        first = True
+        if system:
+            emit("## System Prompt\n\n" + system)
+            first = False
+        if tools:
+            if not first:
+                emit("\n\n")
+            emit("## Tools\n- You may invoke one or more tools to assist with the user's query.")
+            emit("\n\n### Available Tools\n")
+            for tool in tools:
+                emit("<|tool:start|>" + json.dumps(tool, ensure_ascii=False) + "<|tool:end|>\n")
+            emit("\n### Tool Call Instruction\n")
+            emit("- If using a tool, any reasoning must strictly precede the call. Do not append any text after the tool call.\n")
+            emit("- If no tool is required, answer directly from your knowledge without ever mentioning the availability or absence of tools.\n")
+            emit("- Each tool call MUST use this following format: <|tool_call:start|>{example-tool-name}\n<|tool_arg:start|>{example-key-name-1}<|tool_arg:value|>{example-value-1}<|tool_arg:end|>\n<|tool_arg:start|>{example-key-name-2}<|tool_arg:value|>{example-value-2}<|tool_arg:end|>\n<|tool_call:end|>\n")
+        emit("<|im:end|>\n")
+
+    last_user_idx = max(
+        (i for i, t in enumerate(turns) if t["role"] == "user"), default=-1
+    )
+
+    i = 0
+    while i < len(turns):
+        turn = turns[i]
+        if turn["role"] == "user":
+            emit(f"<|im:start|>user<|im:content|>{turn['content']}<|im:end|>\n")
+            i += 1
+        elif turn["role"] == "tool":
+            # 연속된 tool 응답은 하나의 tool 블록으로 병합 (직전 assistant의 호출 순서 기준)
+            block = [turns[i]]
+            j = i + 1
+            while j < len(turns) and turns[j]["role"] == "tool":
+                block.append(turns[j])
+                j += 1
+            emit("<|im:start|>tool<|im:content|>")
+            prev = turns[i - 1] if i > 0 else None
+            ordered, rendered_ids = [], set()
+            if prev and prev["role"] == "assistant" and prev.get("tool_calls"):
+                for call in prev["tool_calls"]:
+                    for msg in block:
+                        if msg.get("tool_call_id") == call["id"]:
+                            ordered.append(msg)
+                            rendered_ids.add(msg["tool_call_id"])
+                for msg in block:
+                    if msg.get("tool_call_id") not in rendered_ids:
+                        ordered.append(msg)
+            else:
+                ordered = block
+            emit("\n".join(
+                f"<|tool_response:start|>{m['content']}<|tool_response:end|>" for m in ordered
+            ))
+            emit("\n<|im:end|>\n")
+            i = j
+        else:  # assistant
+            flush()
+            pieces.append(("<|im:start|>assistant<|im:content|>", False))
+            out = []
+            reasoning = turn.get("reasoning")
+            if reasoning and i > last_user_idx:
+                out.append(f"<|think:start|>{reasoning}<|think:end|>")
+            else:
+                out.append("<|think:start|><|think:end|>")
+            if turn.get("content"):
+                out.append(turn["content"])
+            if turn.get("tool_calls"):
+                for k, call in enumerate(turn["tool_calls"]):
+                    if k:
+                        out.append("\n")
+                    out.append(f"<|tool_call:start|>{call['name']}\n")
+                    out.append(_render_tool_arguments(call["arguments"]))
+                    out.append("<|tool_call:end|>")
+                out.append("\n")
+            out.append("<|im:end|>\n")
+            pieces.append(("".join(out), True))
+            i += 1
+
+    flush()
+    return pieces
+
+
+def render_text(rec: dict) -> str:
+    return "".join(p for p, _ in render_pieces(rec))
+
+
+def truncate_turns(rec: dict, keep: int) -> dict:
+    """turn 단위로 앞에서 keep개만 남기고, 마지막이 assistant가 되도록 자른다."""
+    turns = rec["turns"][:keep]
+    while turns and turns[-1]["role"] != "assistant":
+        turns.pop()
+    return {"system": rec["system"], "tools": rec["tools"], "turns": turns}