Slayer1B 1.09: update cards and training files

DATA_CARD.md

@@ -7,51 +7,53 @@ task_categories:
 - text-generation
 tags:
 - pretraining
-- training-in-progress
+- training-paused
 ---
 
 # Slayer1B 1.09 — staged training data
 
 **Arkadiusz Słota, Anna Sieczka, Piotr Styła / Fabryka AI (SlayerLab)**
 
-**Training in progress, 9 November 2026; execution snapshot through 22:24 UTC.** Slot 1 started from scratch at 22:21:55 UTC on the byte-approved s01 v2 input. Three reference shards are approved, but the full 100B corpus is not prepared. The 1B model, 100B positions, approximately 20–30% Polish, 72 hours and USD 400 remain goals, not achieved results.
+**Revised CPT data plan, 9 November 2026; no clean CPT shard byte-approved yet.** The requested model continues 1.08 with diverse new data. The earlier from-scratch attempt is abandoned; its s01–s03 approvals do not make those replay-containing inputs eligible for this continuation. No completed 1.09 exposure, corpus or verified over-100B unique-history total is claimed.
 
 ## Target, units and exposure
 
-The full-corpus target is **100,000,000,000 native Slayer v6 TRAIN positions**, including document-ending EOS 0. The current nominal allocation is **21,370,000,000 PL / 78,630,000,000 other**, within the permitted approximate **20–30% Polish** range. These are targets, not retained or consumed counts. Source buckets do not prove document language. GPT-2, Llama, cl100k proxy, word and estimated v6 units cannot substitute for measured native positions.
+The request is to exceed **100B unique tokens after continuation**, with PL/EN recomputed and allowed to differ from the earlier 21.37% target. Report inherited unique-data contribution, retained new-data capacity and actually processed positions separately. Use a declared common tokenizer/unit, including EOS where counted; replay, epochs, old exposure totals, proxy tokenizers and source-language labels cannot establish the unique-history total.
 
-Provisional schedule: 95,000 updates × 1,048,576 positions = **99,614,720,000**, not 100B. Nineteen 5,000-update slots process **5,242,880,000 positions each** from input shards targeted at 5.3–5.4B. An owner-approved schedule must resolve the 100B mismatch.
+The selected new-source allocation is **20% PL / 80% EN** for a planned 80,000 updates, or **83,886,080,000 new positions**. These are recipe targets, not retained or consumed counts. The inherited language split and verified unique-history contribution remain separate unresolved quantities; an upper estimate of approximately 23B cannot prove the over-100B target.
 
-The observed run uses random-weight initialization with the existing tokenizer, not trained 1.07 weights. Rebalanced s01 v2 was rebuilt on the training host with its approved digest. Its **5,316,374,064 positions** comprise **4,180,222,380 English-source** and **1,136,151,684 Polish-source** positions, approximately 21.37% PL. These are input capacity, not completed exposure: its 5,000-update slot targets **5,242,880,000 processed positions**. Exact consumed language shares are unavailable.
+The abandoned schedule was 95,000 updates × 1,048,576 positions = **99,614,720,000**, not exactly 100B. It is not a newly approved CPT length or a count of distinct data already seen by the starting model.
 
-| Byte-approved reference | Input positions | TRAIN SHA256 |
+The earlier random-initialization attempt used s01 v2. The references below are **historical inputs, not approved fresh CPT shards**. s01 contains ancestry data; s02/s03 need replacement Polish inputs and complete ancestral deduplication checks on reusable English material. No consumed language ratio or recovered checkpoint is established by their capacities.
+
+| Historical reference, not a clean CPT shard | Input positions | Historical TRAIN SHA256 |
 |---|---:|---|
-| s01 v2; active slot-1 input | 5,316,374,064 | `2ab70797649947e0c14b8067161ed8a2541585428ca52c5ac8c9a744669bbb06` |
-| s02; host preparation pending | 5,302,913,370 | `b4df1406b88f131ac14a431108e33a68450fbd783a748a4978dc5a99a5886bb3` |
-| s03; host preparation pending | 5,284,760,292 | `b1091fbc7bcb1a677c829dd07b288f18c353c6b923d99dd0a85338deb5f727be` |
+| s01 v2; withdrawn from new CPT inputs | 5,316,374,064 | `2ab70797649947e0c14b8067161ed8a2541585428ca52c5ac8c9a744669bbb06` |
+| s02; rebuild/checks required for CPT | 5,302,913,370 | `b4df1406b88f131ac14a431108e33a68450fbd783a748a4978dc5a99a5886bb3` |
+| s03; rebuild/checks required for CPT | 5,284,760,292 | `b1091fbc7bcb1a677c829dd07b288f18c353c6b923d99dd0a85338deb5f727be` |
 
-Their combined **15,904,047,726 positions** are prepared reference capacity, not consumed tokens or a full 100B manifest. The active one-slot queue has SHA256 `6e06f0979f27c60e524852d89660bb2febef59a8b5f21f846e0618af1235715d`. Follow actual exposure on the [separate 1.09 Track run](https://track.fabryka.ai/run/08cf77cf-e995-5ee1-b843-05cbb96e4f4b).
+Their **15,904,047,726 positions** are historical reference capacity, **not ready fresh CPT data**. Queue `6e06f0979f27c60e524852d89660bb2febef59a8b5f21f846e0618af1235715d` belongs to the abandoned attempt. Its [old Track run](https://track.fabryka.ai/run/08cf77cf-e995-5ee1-b843-05cbb96e4f4b) last received update 450 / 471,859,200 positions; these must not be relabelled as CPT from 1.08. The proper continuation needs a separate history.
 
-Earlier models' material is reused as data, not weights. Used documents are recorded for exclusion from later shards, with exact token-sequence deduplication between inputs. This is not a guarantee of semantic uniqueness or absence of near-duplicates.
+The reported ancestry inventory starts 1.00 from random weights, then continues through 1.06 on `slayer-pl-8x3b@d50df04a`, 1.07 on `slayer-1.07-pretrain@6a337bbf`, and 1.08 on R1 TRAIN `b73a69ea` (including Logika and English Technical). The conservative exclusion reference covers the union of these inputs, **not a claim that every reference document was actually trained on**. Known gaps include unavailable shared-history train digests for pack-04–07 and uncertain consumed tails/partial 1.08 coverage. Used-document exclusion, exact token deduplication and normalized-text fingerprints do not prove semantic uniqueness or a lower count of inherited exposure.
 
 ## Proposed source catalog
 
-The 18:19 EN allocation supersedes the earlier category proposal: **38B FineWeb-Edu, 10B StackExchange, 8B peS2o, 3B arXiv, 3B PubMed, 6B Wikimedia, 6B FineMath, 3.63B FinePDFs-Edu, 1B OER/books = 78.63B**. Dedicated code is zero; StackExchange code/QA is not a 12B pure-code corpus. Final domain shares require actual document classification after filtering.
+The fresh PL/EN/domain allocation is being rebuilt from eligible sources and post-filter counts. The earlier 78.63B EN category allocation and fixed 21.37% PL recipe are not the revised mixture. No candidate capacity, extrapolation or conversion is presented as retained fresh data.
 
 Linked public cards describe upstream material, not approval of every document:
 
 | Candidate | Published unit / selection condition |
 |---|---|
-| [GoLLeM PL](https://huggingface.co/datasets/SlayerLab/gollem-corpus-16b-pl), `17f9d37a` | Principal PL candidate: 16.58B published V32k tokens, including 14.62B HPLT web; not retained v6 counts. Web `CC0-1.0` labels HPLT packaging, not text rights: web texts use separately reviewed TDM. Curated records require their own `license`/`is_share_alike` checks |
-| [FinePDFs-Edu](https://huggingface.co/datasets/HuggingFaceFW/finepdfs-edu), `9cfabe21`, PL/EN | PL pool approximately 8.3B v6 is an estimate, not retained size; ODC-By/Common Crawl terms; deduplicate against Logika |
-| [PL Logika](https://huggingface.co/datasets/SlayerLab/slayer-pl-logika-2b), `e24c8b71` | Published 1,911,918,958 native positions including EOS; earlier filtered reference approximately 1.63B, not a new 1.09 measurement; mixed terms/provenance |
-| [English Technical](https://huggingface.co/datasets/SlayerLab/english-technical-1b), `3b833d36`; [1.07 replay](https://huggingface.co/datasets/SlayerLab/slayer-1.07-pretrain), `6a337bbf` | Published technical TRAIN 899,001,323 native tokens before EOS; replay 8,891,005,707 EOS-inclusive positions; not s01 retained totals |
+| [GoLLeM PL](https://huggingface.co/datasets/SlayerLab/gollem-corpus-16b-pl), `17f9d37a` | Candidate only after ancestral checks, including HPLT overlap with 1.06/1.07. Published 16.58B V32k / 14.62B web are not fresh retained v6 counts. Web `CC0-1.0` labels HPLT packaging, not text rights; web TDM and curated per-record rights are reviewed separately |
+| [FinePDFs-Edu](https://huggingface.co/datasets/HuggingFaceFW/finepdfs-edu), `9cfabe21`, PL/EN | Candidate requiring measured retained v6 counts, provenance, rights and ancestral overlap checks; ODC-By/Common Crawl terms are not blanket text redistribution rights |
+| [PL Logika](https://huggingface.co/datasets/SlayerLab/slayer-pl-logika-2b), `e24c8b71` | Previously used by 1.08: reference for exclusion and existing evaluations, **not fresh CPT training input** |
+| [English Technical](https://huggingface.co/datasets/SlayerLab/english-technical-1b), `3b833d36`; [1.07 replay](https://huggingface.co/datasets/SlayerLab/slayer-1.07-pretrain), `6a337bbf` | Previously seen ancestry material: deduplication references, not eligible novel training capacity |
 | Common Pile [peS2o](https://huggingface.co/datasets/common-pile/peS2o_filtered), [PubMed](https://huggingface.co/datasets/common-pile/pubmed_filtered), [arXiv](https://huggingface.co/datasets/common-pile/arxiv_papers_filtered) | Published text sizes: 182.6/147.1/19 UTF-8 GB; per-document open-license allowlist, not blanket permission |
 | Common Pile [StackExchange](https://huggingface.co/datasets/common-pile/stackexchange_filtered), [Wikimedia](https://huggingface.co/datasets/common-pile/wikimedia_filtered) | 89.7/57.4 UTF-8 GB; preserve attribution and applicable CC BY-SA terms |
 | Common Pile [DOAB](https://huggingface.co/datasets/common-pile/doab_filtered), [PressBooks](https://huggingface.co/datasets/common-pile/pressbooks_filtered), [LibreTexts](https://huggingface.co/datasets/common-pile/libretexts_filtered), [OERCommons](https://huggingface.co/datasets/common-pile/oercommons_filtered) | 12/0.6/3.6/0.05 UTF-8 GB; per-document licensing; exclude LibreTexts GFDL material |
 | [FineMath](https://huggingface.co/datasets/HuggingFaceTB/finemath), [FineWeb-Edu](https://huggingface.co/datasets/HuggingFaceFW/fineweb-edu) | FineMath-4+ reports 9.6B Llama tokens; FineWeb-Edu samples use GPT-2; ODC-By plus Common Crawl terms |
 
-PL reserves include FineWeb2-HQ-Plus, Polish Dynaword (6.65B cl100k, not v6) and 1.07 replay; overlap and post-filter yields remain unmeasured. No conversion establishes 21.37B retained PL. peS2o's card says `metadata.license`, while the inventory identifies `metadata.oa_license`; use the actual pinned schema.
+Additional candidates include FineWeb2-HQ-Plus and other separately approved diverse sources; none supplies a verified retained amount or final PL share by its name alone. Replay from 1.07 is not a reserve of new data. peS2o's card says `metadata.license`, while the inventory identifies `metadata.oa_license`; use the actual pinned schema.
 
 ## Admission, isolation and byte approval
 
@@ -59,10 +61,10 @@ Use a per-document allowlist: CC0/public domain, eligible CC BY/CC BY-SA, ODC-By
 
 For new material reserve 1% of documents per group **before TRAIN/sharding**, grouping source-book identities; this is not 1% of tokens. Preserve existing evaluation partitions. Apply exact/near-deduplication and 13-gram plus 8-gram-template decontamination with positive controls, including GSM8K/MATH/ARC/panels.
 
-**Legacy s01 exception:** approved 1.07 bins may train before scanning against later held-outs. Before 1.09 evaluations, scan decoded bins; exclude hit items for both compared models, leave bins unchanged and report removals and resulting denominators. Do not describe all inputs as pre-decontaminated.
+The old s01 training exception does **not** authorize replay in this revised CPT. Retrospective scans of the inherited training history against later benchmarks must report hit items and evaluation exclusions for the compared models; they cannot remove already learned exposure. New benchmarks remain descriptive until those checks are complete.
 
-GoLLeM reports LLMzSzŁ variants for 1,662/18,820 items (8.83%); exclude affected items if evaluated. Its card conflicts about PoQuAD exclusion versus partition inclusion: do not use PoQuAD without decontamination. The separate 1.07 replay retains its reported near-deduplication and EWoK omissions; these do not disappear with random-weight initialization.
+GoLLeM reports LLMzSzŁ variants for 1,662/18,820 items (8.83%); exclude affected items if evaluated. Its card conflicts about PoQuAD exclusion versus partition inclusion: do not use PoQuAD without decontamination. The ancestry's reported near-deduplication and EWoK omissions remain inherited concerns; filtering new data does not erase them from the starting weights.
 
 Whole-document PII DROP changes coverage; document-drop fraction is not token-loss fraction. Independent residual checks, post-filter document/native-token counts, deduplication losses and final pins remain pending. Identifiers, extraction damage, bias and incorrect reasoning may survive.
 
-Conditional content/code GREEN is **not byte GREEN**. Each tranche needs configuration, manifest, byte-derived SHA approval and queue-prefix/resume identity. Rebalanced s01 v2 received byte approval with TRAIN SHA256 `2ab70797649947e0c14b8067161ed8a2541585428ca52c5ac8c9a744669bbb06`; that does not approve all 100B. Tokenizer v6 SHA256: `0640d3bd3674d7a6e59c540d945a2ad275a12e1bcaeb6007c37a90751f9815dd`. Publication separately needs rights, attribution and egress GREEN. Full-corpus manifests, final pins and aggregate language audit remain pending.
+Content/code approval is **not byte approval**. The revised CPT currently has **zero byte-approved complete fresh shards**; old s01 SHA256 `2ab70797649947e0c14b8067161ed8a2541585428ca52c5ac8c9a744669bbb06` is historical, not approval for its reuse. Each new tranche needs its own config, byte-derived digests, manifest and sampler identity. Tokenizer v6 SHA256 remains `0640d3bd3674d7a6e59c540d945a2ad275a12e1bcaeb6007c37a90751f9815dd`. Rights, attribution and egress are separate publication conditions.

README.md

@@ -8,30 +8,43 @@ tags:
 - polish
 - causal-lm
 - pretraining
-- training-in-progress
+- continued-pretraining
+- training-paused
 ---
 
 # Slayer1B 1.09
 
 **Arkadiusz Słota, Anna Sieczka, Piotr Styła / Fabryka AI (SlayerLab)**
 
-**Training in progress, 9 November 2026; execution snapshot through 22:24 UTC.** From-scratch training started at 22:21:55 UTC on eight B200 GPUs; preflight and the first 30 updates were observed. This is not a completed 100B run, an accepted successor or an inference-ready weight release. No 1.09 quality scores or checkpoint publication are claimed here.
+**Corrected plan: continued pretraining from 1.08; not started.** The 9 November 2026 decision at 23:23–23:24 UTC supersedes the earlier from-scratch interpretation. That initial attempt was interrupted and abandoned; it is not the intended 1.09 continuation. No completed 1.09 model, recovered checkpoint, new quality results or inference-ready weight release is claimed.
 
 ## Objective and starting point
 
-The objective is a roughly 1B-parameter causal language model trained on **100 billion native v6 token positions, including document EOS 0, within 72 hours and USD 400 total**. The requested balance is approximate: **20–30% Polish**, with the remainder mainly English. The current selected recipe remains near **21.37% / 78.63%**; a later adjustment requires an explicit shard decision. These are targets, not completed exposure. Base-model training takes priority over instruction tuning.
+The requested 1.09 continues the existing 1B model with **diverse, new, deduplicated data**, aiming for **more than 100B unique tokens after continuation**. The inherited unique-data contribution, additional exposure needed and PL/EN balance must be recomputed; neither replayed training exposure nor the old 95,000-update default proves this target. The earlier fixed 21.37% addition is no longer a requirement. The deadline and approved budget remain constraints, not achieved results.
 
-The run uses **random-weight, from-scratch initialization** with the existing v6 tokenizer, not continuation from trained 1.07 weights. The operator's step-zero preflight and early training establish this starting state. Reusing a tokenizer does not mean inheriting trained model weights.
+The intended starting weights are **[SlayerLab/Slayer1B-1.08](https://huggingface.co/SlayerLab/Slayer1B-1.08/tree/5f854a0cc7160594d54d1788d37a44e8ebabe16c)**, not random initialization and not the abandoned attempt's checkpoint. The selected v5 launcher explicitly initializes those weights with fresh optimizer state and a new output history. Its code review is complete; clean-data bytes, hardware control and actual execution remain prerequisites.
 
 The unchanged architecture is specified as **1,073,912,851 parameters**, 20 layers, width 2,048, 16 heads, SwiGLU, RMSNorm, RoPE base 500,000, QK normalization and value residuals. The reused v6 tokenizer has vocabulary 32,768 and pin `0640d3bd3674d7a6e59c540d945a2ad275a12e1bcaeb6007c37a90751f9815dd`.
 
-Architecture and tokenizer lineage: [SlayerLab/Slayer1B-1.07](https://huggingface.co/SlayerLab/Slayer1B-1.07/blob/a090b54e658fb57dc5166c1fcc90cc6bf5c80106/README.md), revision `a090b54e658fb57dc5166c1fcc90cc6bf5c80106`. This identifies the predecessor, not a weight initialization or 1.09 checkpoint.
+Architecture and tokenizer lineage includes [SlayerLab/Slayer1B-1.07](https://huggingface.co/SlayerLab/Slayer1B-1.07/blob/a090b54e658fb57dc5166c1fcc90cc6bf5c80106/README.md). The selected 1.08 base was published as an experiment with an **ARC-Easy retention-guard FAIL**; choosing it for further training does not erase that verdict or establish a successful 1.09.
 
-The [training configuration](TRAINING_CONFIGURATION.md) identifies exact code digests and separates the saved, actually used 1.08 flags from this selected 1.09 recipe.
+The [training configuration](TRAINING_CONFIGURATION.md) preserves exact evidence for completed 1.08 and the abandoned first attempt, explicitly separated from the revised CPT plan.
 
-## Active recipe, not completed training
+## Selected CPT plan — reviewed, not executed
 
-| Setting | Selected run configuration |
+| Setting | Operator-selected plan |
+|---|---|
+| New training | 80,000 updates × 1,048,576 = **83,886,080,000 positions**, sixteen 5,000-update slots |
+| New-source allocation | **20% PL / 80% EN target**; not a measured cumulative model-language ratio |
+| Optimizer / schedule | Muon 0.02 plus AdamW peak 0.0006; 2,000-update warmup; final 20% WSD decay to 0.00006 |
+| Checkpoints | Full state every 200 updates; slot-end weight milestones; local workstation copies |
+| Code | Launcher v5 SHA256 `796c71016c1e167bfd3ca98b78518f91c3502a96eac233dd7186ef6639fcc656`; exact command and converter pins in the configuration document |
+
+The reported inherited approximately 23B is an **upper estimate**, useful for conservative exclusion of previously seen data, not a verified lower count. Even if all planned new positions are unique and processed once, exceeding 100B requires supported inherited exposure **above 16,113,920,000 unique positions**. Approximately 107B is therefore a conditional estimate, not an established result.
+
+## Archived from-scratch attempt — not the CPT recipe
+
+| Setting | Abandoned first-attempt configuration |
 |---|---|
 | Trainer / optimizer | Existing r24.2; Muon with AdamW; fresh optimizer |
 | Batch / context | 256 × 4,096 = 1,048,576 positions per update |
@@ -40,34 +53,38 @@ The [training configuration](TRAINING_CONFIGURATION.md) identifies exact code di
 | WSD | 2,000 warmup updates; constant LR 0.0006, Muon 0.02; final 20% uses 1−sqrt decay to nonzero LR floor 0.00006 |
 | Checkpoints | Every 500 updates and retained slot-end milestones |
 
-**95,000 × 1,048,576 = 99,614,720,000 positions (99.61472B), not 100B.** Each 5,000-update slot processes 5.24288B positions; planned input shards are larger, about 5.3–5.4B. The 385,280,000-position shortfall needs an approved step/batch policy; no correction is selected here.
+The abandoned plan's **95,000 × 1,048,576 = 99,614,720,000 positions** was not exactly 100B and is **not the approved length of the revised continuation**. Its nineteen planned 5,000-update slots are historical configuration, not a measured unique-history count or evidence that those updates completed.
 
-Queue mode uses append-only shards, manifest ranges and SHA-256 identities. Resume must preserve existing prefixes and earlier steps; new byte ranges must match tranche approval before use. Reported CPU smoke matched slotwise and continuous training bit-for-bit, including two-process DDP. The reviewed launcher is now running slot 1 on GPUs; this does not approve unverified later shards or establish completion.
+Slot-1 GPU execution was observed before the interruption. **Do not resume that from-scratch state as the requested CPT.** The continuation needs a separate output history and Track run; historical points must not be relabelled as training from 1.08. Any future queue still requires approved byte ranges, manifest digests and preserved sampler identity within that particular experiment.
 
-## Early execution evidence
+## Archived first-attempt evidence — not CPT progress
 
 The [public Track run](https://track.fabryka.ai/run/08cf77cf-e995-5ee1-b843-05cbb96e4f4b) is separate from 1.08. At update 30 it records training loss **10.3959**, interval throughput **576,593 positions/s** and **31,457,280 processed positions** (30 × 1,048,576). This is an early interval, not end-to-end billed throughput or a quality evaluation. The first slot targets 5,000 updates; its completion is not claimed.
 
-The resumed host's numerical equivalence check against 1.07 is still pending. Review allowed slot 1 to start on the matching hardware/software, but requires that check before slot 2; a difference above 0.001 bits/byte requires a stop and investigation. Do not describe that pending check as passed.
+The last received public sample before the pause is update **450**, training loss **4.3910**, with **471,859,200 processed positions**. Its ingestion timestamp is 22:36:50 UTC. It is not a live GPU reading, a final exposure count or proof of a checkpoint at update 500. The trainer's recoverable step must be checked from the saved state, not inferred from elapsed time or the tracker label.
+
+Numerical control on the resumed hardware remains pending and is required before the new CPT launch. The earlier permission to start the abandoned slot does not establish that control, approve initialization from 1.08 or approve new data bytes.
+
+Checkpoint copies are currently directed to a trusted local workstation, **not Hugging Face**. The retention plan is slot-end weight milestones plus the latest full optimizer checkpoint. That plan does not prove a successful local copy or recovery; publication of documents and code does not imply publication of model weights.
 
 ## Data and exposure
 
-The latest English source allocation replaces the earlier web/code/category proposal: educational web is combined with science, wiki, QA, mathematics and books. No dedicated code corpus is currently selected. Post-filter counts and source-language assignments remain necessary; see [the data card](DATA_CARD.md).
+No complete new-data shard is yet byte-approved for CPT from 1.08. Existing s01–s03 references contain already-seen data; their old approvals do not satisfy the revised freshness requirement. Reusable English portions still need the complete ancestry checks, and the Polish portions must be rebuilt; see [the data card](DATA_CARD.md).
 
-The selected recipe currently targets **21.37% PL / 78.63% other** in each shard rather than alternating language-heavy slots. The user allows an approximate 20–30% Polish range; this is not a requirement to rebuild already-approved input or silently change domains.
+The PL/EN balance will follow the approved fresh-data inventory. The user explicitly allows a different ratio; source buckets still do not establish the language share of actually consumed windows. Missing ancestral data must be reported as a limitation, not silently counted as verified unique exposure.
 
-New material requires per-document licensing, PII filtering, contamination scans and grouped held-outs before sharding. A 1% document holdout is not necessarily 1% of tokens. Legacy inputs have a separate pre-evaluation contamination condition. The selected pipeline records used documents and excludes them from later shards; exact deduplication does not establish semantic uniqueness. Prepared bucket shares do not establish the language share of consumed windows.
+New material requires licensing, PII filtering, contamination scans, grouped held-outs and deduplication against the base model's full data ancestry. A 1% document holdout is not necessarily 1% of tokens. Historical exposure in the starting weights cannot be undone by filtering new inputs; retrospective benchmark hits must be handled explicitly in evaluation denominators.
 
 ## Evaluation and acceptance
 
-Compare fixed **FINAL**, not a retrospectively selected milestone, with 1.07 on matching hardware: Polish H bits/byte, grouped held-outs, mathematics, ARC-Easy, BLiMP, ARC-Easy-PL and MultiBLiMP-PL. Final preregistration details await approval.
+The expanded evaluation plan includes 1.07 and 1.08 reference measurements before future 1.09 milestones. Protocols, model/data digests and denominators must accompany published aggregates; the revised continuation's final acceptance protocol must be established before its results are interpreted.
 
-Proposed final guards inherit 1.08 thresholds: H increase at most 0.005 bits/byte; each of the four panels at least −1 percentage point versus 1.07. Separately, milestone H increase above 0.02 or Polish-panel losses exceeding 2 points are **operator alarms, not automatic stops or final guards**.
+New benchmarks remain **descriptive, contamination check pending** until the retrospective checks are complete. No old threshold, early training-loss decrease or retrospectively chosen checkpoint is presented here as acceptance of the revised continuation.
 
 Comparison is descriptive: no replay-only control is budgeted, and initialization, exposure and schedule differ. No causal dataset benefit or multi-seed significance can be claimed.
 
 ## Cost, licensing and limitations
 
-USD 400 remains the **authorized total-session budget**, including preparation, restarts, evaluation and interruptions, not just steady-state training. Early interval speed is measured above; sustained end-to-end speed and final billed expense are not established. Budget and deadline compliance remain unverified; this card does not approve a larger budget or a shortened run as completed 100B training.
+The declared 1.09 budget is USD 400, including preparation, restarts and evaluation, not just steady-state training. The additional work needed depends on verified inherited and new unique-data counts; the old 95,000-update plan is not a completed budget calculation. Final expense, sustainable throughput and deadline compliance remain unverified.
 
-1.07 declares Apache-2.0; this does not assign a license to future 1.09 weights or source texts. Release and publication rights require separate approval. Privacy filters are heuristic; generated text may be inaccurate, biased, offensive or personal. No reasoning quality, instruction-following ability or professional reliability has been demonstrated for 1.09.
+The selected 1.08 base declares Apache-2.0; source-text rights and future publication still require separate approval. Privacy filters are heuristic; generated text may be inaccurate, biased, offensive or personal. No reasoning quality, instruction-following ability or professional reliability has been demonstrated for the revised 1.09.

TRAINING_CONFIGURATION.md

@@ -2,13 +2,44 @@
 
 Fabryka AI / SlayerLab
 
-**1.08 is a completed continued-pretraining experiment; 1.09 is the separate from-scratch 100B-target run, now training.** The operator reports a 22:21:55 UTC start on 9 November 2026, step-zero preflight and the first 30 updates. The [public 1.09 run](https://track.fabryka.ai/run/08cf77cf-e995-5ee1-b843-05cbb96e4f4b) confirms early metrics, not completed training. This record distinguishes saved 1.08 arguments from the active 1.09 recipe.
+**Current intent: 1.09 is continued pretraining from 1.08, not a new from-scratch model.** The user corrected the interpretation on 9 November 2026 at 23:20–23:24 UTC. The v5 recipe below is selected and reviewed, but CPT has not started: clean input bytes and numerical control are still required. Later sections preserve completed 1.08 and the abandoned first attempt separately.
 
-## Code identities
+## Required separation for the revised continuation
+
+The selected base is [SlayerLab/Slayer1B-1.08 at 5f854a0cc7160594d54d1788d37a44e8ebabe16c](https://huggingface.co/SlayerLab/Slayer1B-1.08/tree/5f854a0cc7160594d54d1788d37a44e8ebabe16c). Use a new output history and Track identity; do not resume the random-initialized attempt or relabel its points as CPT. The launcher pins model SHA256 `1c510d9a59d3b9e62360d1db57e08fa450fb9b09df849df7f2eef132ea6715a4` and config SHA256 `c4c56250100cbb26e1394977ecb613fd41bdb239128592b12a13b30613fa6a94`.
+
+The archived v3 invocation reference later in this document is historical evidence only. The reviewed v5 command below is the selected continuation recipe, **not evidence of execution**. Checkpoints are currently destined for the local workstation, not a public weight upload.
+
+## Selected v5 CPT command — not yet executed
+
+| Component | Pinned identity |
+|---|---|
+| Trainer | `train_gpt_ref_r24_2.py`, SHA256 `46f83b51fcec18ffc3273d80fb9eab29e182c52d8667800dab27b80f7ff18afc` |
+| Launcher | `uruchom_109.sh` v5, SHA256 `796c71016c1e167bfd3ca98b78518f91c3502a96eac233dd7186ef6639fcc656` |
+| Required HF-to-training converter | `hf_do_ckpt.py`, SHA256 `4990a1c2bc664417ea964a5235d702cad12bff0dc53ce08211ff9a84cbcfed64` |
+
+With those files installed at the explicit paths, pinned base files already fetched and a newly approved clean CPT data directory:
+
+```bash
+START=108 GPU=B200 S=5000 KROKI=80000 CKPT_EVERY=200 NCCL_P2P_DISABLE=0 \
+HF=/workspace/hf108 INIT=/workspace/init/init_108.pt \
+T=/workspace/kod/train_gpt_ref_r24_2.py CONV=/workspace/kod/hf_do_ckpt.py \
+D=/workspace/dane109cl O=/workspace/runs/109cl \
+PY=/workspace/venv/bin/python TORCHRUN=/workspace/venv/bin/torchrun \
+bash /workspace/kod/uruchom_109.sh
+```
+
+**Set all three overrides:** `KROKI=80000`, `S=5000`, `CKPT_EVERY=200`; v5 retains different historical defaults. `START=108` requires `--init-from` and a 2,000-update warmup. The converter passes weights/config only, not optimizer state; `--resume` recovers only this new experiment. A new output directory plus step-zero `INIT-FROM` preflight are mandatory before calling this actual CPT.
+
+Shared architecture/batch/optimizer peaks below are unchanged: eight B200 ranks, microbatch8 × accumulation4, context4096, Muon0.02/AdamW0.0006. The selected 80,000-update plan decays in its last20% to0.00006. Target new-source mix is20%PL/80%EN, not a measured cumulative language ratio.
+
+80,000 updates correspond to83,886,080,000 new positions. The inherited approximately23B is an upper estimate, not proof of the lower unique-history count needed for the over100B goal; final counts and exposure must verify that separately. No old95,000 default or repeated source material supplies that proof.
+
+## Historical code identities
 
 | Component | Identity |
 |---|---|
-| Actual training implementation, both recipes | `train_gpt_ref_r24_2.py`, SHA256 `46f83b51fcec18ffc3273d80fb9eab29e182c52d8667800dab27b80f7ff18afc` |
+| Training implementation for completed 1.08 and abandoned first 1.09 attempt | `train_gpt_ref_r24_2.py`, SHA256 `46f83b51fcec18ffc3273d80fb9eab29e182c52d8667800dab27b80f7ff18afc` |
 | First 1.09 launch attempt | `uruchom_109.sh`, SHA256 `dfee11522be49c938f169ca6992cf181f86a3c4e0d26fd5b5fa3646535dc890f` |
 | Launcher used for observed 1.09 slot 1 | `uruchom_109.sh` v3, SHA256 `c0a2699d1a2d7ce4cddd873ad92ff5ab5bb0dbcecc6e47d6bce01ee9b848895c` |
 | Saved, actually used 1.08 argument file | SHA256 `d283bcb836e9bb89d5bf7dfa60487055086cf04620ad5c5dd36fe3435f2766a9` |
@@ -17,9 +48,9 @@ The older public `train_gpt_ref_r23.py` is **not the identity of this training i
 
 The recipes use one eight-GPU B200 node, PyTorch 2.8/CUDA 12.8 and DDP. They are not a four-RTX-4090 configuration. Compute uses bf16 on the verified hardware; `--dtype uint16` below describes **stored token IDs**, not model arithmetic.
 
-## Shared explicit learning arguments
+## Historical shared learning arguments
 
-These arguments occur in the saved 1.08 invocation and the selected 1.09 launcher:
+These arguments occur in the saved 1.08 invocation and the abandoned from-scratch 1.09 launcher. They are not a new CPT specification:
 
 ```text
 --batch 256 --grad-accum 4 --block 4096 --dtype uint16 --vocab 32768
@@ -34,9 +65,9 @@ These arguments occur in the saved 1.08 invocation and the selected 1.09 launche
 
 Global batch is 256 sequences: eight ranks × microbatch 8 × accumulation 4. Activation checkpointing is disabled. Each update processes 1,048,576 token positions. Muon handles matrix parameters; AdamW handles the remaining parameter groups.
 
-## Differences that change the experiment
+## Historical differences between the two observed experiments
 
-| Setting | 1.08: saved arguments / completed run | 1.09: selected recipe, not completion |
+| Setting | 1.08: saved arguments / completed run | Abandoned 1.09 from-scratch attempt |
 |---|---|---|
 | Weight initialization | `--init-from` the public 1.07 weights, fresh optimizer | `START=zero`; no `--init-from` |
 | Total updates | `--steps 1709` | `--steps 95000` by default |
@@ -53,27 +84,21 @@ Both argument sets contain `--resume` for automatic recovery. That flag does **n
 
 Output directories, run IDs, data directories, the queue manifest and `--events-jsonl` are operational arguments, not omitted learning choices. For 1.08 they identify `slayer1b_108_r1`; 1.09 uses a separate output history. Do not share output directories between experiments.
 
-## Observed 1.09 slot-1 invocation
+## Historical invocation reference — not for CPT
 
-On the allocated, verified node, with the pinned trainer and launcher already installed and an approved data directory:
+The [archived slot-1 invocation](https://huggingface.co/SlayerLab/Slayer1B-1.09/blob/89f701851c57acea4bece4de11194fac60f66a8b/TRAINING_CONFIGURATION.md) records the abandoned random-initialization attempt. It is not the current operator command, and recovery of its checkpoint is not initialization from 1.08.
 
-```bash
-START=zero GPU=B200 S=5000 KROKI=95000 NCCL_P2P_DISABLE=0 \
-D=/workspace/dane109 O=/workspace/runs/109 \
-PY=/workspace/venv/bin/python TORCHRUN=/workspace/venv/bin/torchrun \
-bash /workspace/kod/uruchom_109.sh
-```
 
-**Set `S=5000` explicitly:** the selected launcher retains a different historical default. Its manifest must agree. Use a fresh environment without access tokens; do not bypass hardware, checksum or preflight guards. H200 support in launcher v3 is a capability, **not evidence that this experiment ran on H200**. A hardware change requires its own numerical control and truthful run metadata.
+The historical call explicitly set `S=5000` because v3 retained a different default. H200 support was a capability, not evidence of execution on H200. A future hardware change still requires numerical control and truthful metadata.
 
-The directory contains `train.bin`, `val.bin` and `man.json`. Add approved shard bytes **before** publishing the matching manifest ranges and SHA256 values. Keep the existing prefix and sampler history; do not replace an epoch-sampled file mid-run. `CIAGLE=1` is allowed only once every required slot is present. Otherwise each invocation runs one slot, saves its endpoint and waits for the next approved input.
+A future approved queue must publish new shard bytes before matching manifest ranges and digests. Old queue `6e06f097` and the replay-containing s01–s03 references do not satisfy the revised freshness requirement; new CPT inputs need new approval. Preserve sampler identity only within the same experiment, never by reusing the abandoned output history.
 
-Recovery uses the same output directory and arguments. Full optimizer state remains in `ckpt.pt`; v3 retains weights-only milestone files separately and can reclaim already-consumed shard ranges without changing offsets. Audit then relies on approved input digests and reconstruction recipes, not a claim that reclaimed bytes can still be reread.
+Recovery with the same output directory is valid only within one approved experiment. The new CPT must not inherit the abandoned attempt's optimizer or random-weight checkpoint. Full optimizer snapshots and weights-only milestones are distinct artifacts; the actual CPT optimizer and recovery policy must be recorded with its reviewed launcher.
 
-Launcher v3 permits a total-step adjustment only before both the old and new decay boundaries. This technical capability is **not permission to report a shorter run as completed 100B training**: any changed length must be authorized, recorded and converted to actual processed positions.
+Historical v3 could adjust total steps before decay boundaries. That capability neither selects a length for the new CPT nor turns exposure into unique-source tokens. Recompute the required addition from supported historical/new-data counts and the approved budget before publishing a definitive schedule.
 
 ## What this does not claim
 
-The 1.08 argument file is direct execution evidence. The 1.09 slot-1 launch, preflight and early public metrics establish partial execution of the reviewed v3 recipe; checkpoints and final counters must establish later progress and completion. Steady interval throughput is not end-to-end billed throughput, especially when checkpoint and validation schedules differ.
+The saved 1.08 arguments and first-attempt preflight establish those historical executions only. The old [Track run](https://track.fabryka.ai/run/08cf77cf-e995-5ee1-b843-05cbb96e4f4b) records from-scratch metrics through update 450, not CPT progress or a verified recovered checkpoint. No actual revised CPT execution or quality result is established.
 
-Exact execution also requires the approved data bytes, manifest and filtering artifacts. The full 100B corpus is being assembled; public code inspection alone does not supply those data or protected evaluation material. No held-out questions, gold answers, generated evaluation outputs or private row-exclusion lists belong in this public bundle. See the [model card](README.md) and [data card](DATA_CARD.md) for status, source rights and limitations.
+The revised continuation also requires its newly approved data bytes, manifest, full-ancestry overlap controls and filtering artifacts. Public code inspection does not supply those data or protected evaluation material. No held-out questions, gold answers, generated evaluation outputs or private exclusion lists belong in this public bundle. See the [model card](README.md) and [data card](DATA_CARD.md) for current scope and limitations.

hf_do_ckpt.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""hf_do_ckpt.py (Hart, 09.11) — wagi HF Slayer1B 1.07 -> ckpt trenera r24.2 dla --init-from (bieg Slayer1B 1.08, 8xB200).
+
+Eksport (eksport_hf_1b.py): stan modelu fp32 z kluczami trenera, BEZ head.weight (wiązanie z tok.weight),
+config.json = ckpt["config"] + metadane. Tu odwrotność: head.weight = tok.weight, zapis {"model", "config", "step"}.
+Bez sieci, bez optymalizatora (--init-from i tak bierze tylko wagi: r24.2 :1128-1140).
+
+Kontrole (STOP przy rozjeździe):
+  1. sha256 model.safetensors / config.json / trenera = piny;
+  2. wiązanie w config.json = {"tok.weight": "head.weight"} i brak head.weight w safetensors;
+  3. strict load do klasy GPT trenera (jak nauczyciel KD, r24.2 :1160-1161) + te same klucze configu, które sprawdza --init-from;
+  4. po zapisie: ponowny torch.load(weights_only=True) i każdy tensor == safetensors bit w bit.
+Użycie (węzeł): python hf_do_ckpt.py --pkg <katalog HF 1.07> --trainer train_gpt_ref_r24_2.py --out init_107.pt
+"""
+import argparse
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+import types
+
+import torch
+from safetensors.torch import load_file
+
+SHA_MODEL = "d826b4a11bf4eaccee10fe43ec19a4f6d515dfc5f3e5c859adb631f1a0b76ad5"   # HF Slayer1B-1.07 model.safetensors
+SHA_CONFIG = "9e2062501a87d0b87d7ef75ba8bc5484f3b1afdf42081e727a74dc02f5a4afce"  # jego config.json
+SHA_TRENER = "46f83b51fcec18ffc3273d80fb9eab29e182c52d8667800dab27b80f7ff18afc"  # train_gpt_ref_r24_2.py
+KLUCZE_INIT = ("vocab", "n_layer", "n_embd", "n_head")                            # r24.2 :1131-1133
+KLUCZE_DFLT = (("loop", 1), ("xsa", 0), ("rope_dims", 0), ("ffn", "gelu"), ("imha_t", 0), ("kv_heads", 0))  # :1134-1138
+
+
+def stop(msg):
+    print(f"STOP: {msg}", file=sys.stderr)
+    sys.exit(2)
+
+
+def sha(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1 << 24), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("--pkg", required=True, help="katalog z model.safetensors i config.json")
+    ap.add_argument("--trainer", required=True, help="train_gpt_ref_r24_2.py")
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--sha-model", default=SHA_MODEL)
+    ap.add_argument("--sha-config", default=SHA_CONFIG)
+    ap.add_argument("--sha-trener", default=SHA_TRENER)
+    a = ap.parse_args()
+
+    if os.path.exists(a.out):
+        stop(f"{a.out} istnieje")
+    model_p, config_p = os.path.join(a.pkg, "model.safetensors"), os.path.join(a.pkg, "config.json")
+    for path, want in ((model_p, a.sha_model), (config_p, a.sha_config), (a.trainer, a.sha_trener)):
+        got = sha(path)
+        if got != want:
+            stop(f"{path}: sha {got[:12]} != pin {want[:12]}")
+
+    sd = load_file(model_p, device="cpu")
+    with open(config_p, encoding="utf-8") as f:
+        cfg = json.load(f)
+    if cfg.get("tied_weights") != {"tok.weight": "head.weight"} or "head.weight" in sd or "tok.weight" not in sd:
+        stop("nieoczekiwane wiązanie wag (oczekiwane tied_weights tok.weight -> head.weight, bez head.weight w pliku)")
+    for key in KLUCZE_INIT:
+        if cfg.get(key) is None:
+            stop(f"config.json bez '{key}' (wymagane przez --init-from)")
+    sd["head.weight"] = sd["tok.weight"]
+
+    spec = importlib.util.spec_from_file_location("trener_r24_2", a.trainer)
+    trener = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(trener)  # moduł ma straż __main__: import nie startuje treningu
+    with torch.random.fork_rng(devices=[]):
+        model = trener.GPT(cfg["vocab"], cfg["n_layer"], cfg["n_embd"], cfg["n_head"], cfg["block"],
+                           types.SimpleNamespace(**cfg))
+    model.load_state_dict(sd, strict=True)
+
+    state = {"model": model.state_dict(), "config": cfg, "step": int(cfg.get("step", 0)),
+             "hf_init": {"model_sha256": a.sha_model, "config_sha256": a.sha_config}}
+    tmp = a.out + ".tmp"
+    torch.save(state, tmp)
+    try:
+        ck = torch.load(tmp, map_location="cpu", weights_only=True)
+        c0 = ck["config"]
+        for key in KLUCZE_INIT:
+            if c0[key] != cfg[key]:
+                stop(f"config po zapisie: {key} {c0[key]} != {cfg[key]}")
+        dflt = {key: c0.get(key, d) for key, d in KLUCZE_DFLT}
+        if set(ck["model"]) != set(sd):
+            stop(f"klucze po zapisie != safetensors+head ({len(ck['model'])} vs {len(sd)})")
+        rozne = [k for k, v in sd.items() if not torch.equal(ck["model"][k], v)]
+        if rozne:
+            stop(f"tensory po zapisie różne od safetensors: {rozne[:5]}")
+    except SystemExit:
+        os.remove(tmp)
+        raise
+    os.replace(tmp, a.out)
+    n = sum(v.numel() for k, v in sd.items() if k != "head.weight")
+    print(f"HF->CKPT OK {a.out} sha {sha(a.out)} | krok {state['step']} | P {n:,} | klucze {len(sd)} | "
+          f"config --init-from {dict((k, cfg[k]) for k in KLUCZE_INIT)} {dflt}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

uruchom_109.sh

@@ -6,7 +6,7 @@
 #   START=zero NCCL_P2P_DISABLE=0 bash uruchom_109.sh        # każde wywołanie = następny slot (S kroków), potem SLOT DONE
 #   CIAGLE=1 START=zero NCCL_P2P_DISABLE=0 bash uruchom_109.sh   # bez --queue-one-slot: tylko gdy manifest ma WSZYSTKIE sloty
 #
-# Wymagane env: START (zero = od zera | 107 = --init-from wag HF 1.07), NCCL_P2P_DISABLE (0|1).
+# Wymagane env: START (zero = od zera | 107 / 108 = --init-from wag HF 1.07 / 1.08, trening kontynuowany), NCCL_P2P_DISABLE.
 # D = katalog z train.bin (shardy sklejone, uint16), val.bin, man.json {steps_per_shard, shards{id:{lo,hi,sha256,source}},
 # rotations}. Kolejność dopisania shardu: NAJPIERW bajty na koniec train.bin (po GREEN W4 bajtów), POTEM manifest.
 # sha256 shardu = sha256 bajtów train.bin [2·lo, 2·hi). Ograniczenia trenera (smoke): brak slotu w manifeście = trener
@@ -16,19 +16,30 @@ unset HF_TOKEN HUGGING_FACE_HUB_TOKEN HUGGINGFACE_HUB_TOKEN PYTHONPATH
 export HF_HUB_OFFLINE=1 HF_DATASETS_OFFLINE=1 CUDA_DEVICE_ORDER=PCI_BUS_ID OMP_NUM_THREADS=8 PYTHONUNBUFFERED=1 \
   PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
 die() { echo "STOP: $*" >&2; exit 2; }
-: "${START:?START = zero|107}"; [[ $START = zero || $START = 107 ]] || die "START musi być zero albo 107"
+: "${START:?START = zero|107|108}"; [[ $START = zero || $START = 107 || $START = 108 ]] || die "START musi być zero, 107 albo 108"
 : "${NCCL_P2P_DISABLE:?jawnie NCCL_P2P_DISABLE=0|1 (B200 z NVLink: 0)}"
 CIAGLE=${CIAGLE:-0}; [[ $CIAGLE = 0 || $CIAGLE = 1 ]] || die "CIAGLE = 0|1"
 # Typ kart (plan B przy braku spot B200, Latarnik 19:33): ta sama matematyka i te same argumenty trenera, inna arch.
 GPU=${GPU:-B200}
 case $GPU in B200) ARCH=sm_100;; H200) ARCH=sm_90;; *) die "GPU musi być B200 albo H200";; esac
 
-WS=${WS:-/workspace}; T=${T:-$WS/kod/train_gpt_ref_r24_2.py}; HF=${HF:-$WS/hf107}; CONV=${CONV:-$WS/kod/hf_do_ckpt.py}
-D=${D:-$WS/dane109}; O=${O:-$WS/runs/109}; INIT=${INIT:-$WS/init/init_107.pt}; MAN=$D/man.json
+WS=${WS:-/workspace}; T=${T:-$WS/kod/train_gpt_ref_r24_2.py}; HF=${HF:-$WS/hf$START}; CONV=${CONV:-$WS/kod/hf_do_ckpt.py}
+D=${D:-$WS/dane109}; O=${O:-$WS/runs/109}; INIT=${INIT:-$WS/init/init_$START.pt}; MAN=$D/man.json
+# Piny wag startowych (publiczne paczki HF): 1.07 = SlayerLab/Slayer1B-1.07, 1.08 = SlayerLab/Slayer1B-1.08 @5f854a0c.
+case $START in
+  107) PIN_M=d826b4a11bf4eaccee10fe43ec19a4f6d515dfc5f3e5c859adb631f1a0b76ad5; PIN_C=9e2062501a87d0b87d7ef75ba8bc5484f3b1afdf42081e727a74dc02f5a4afce;;
+  108) PIN_M=1c510d9a59d3b9e62360d1db57e08fa450fb9b09df849df7f2eef132ea6715a4; PIN_C=c4c56250100cbb26e1394977ecb613fd41bdb239128592b12a13b30613fa6a94;;
+esac
 PY=${PY:-python3}; TORCHRUN=${TORCHRUN:-torchrun}; PORT=${PORT:-29551}
 NGPU=8; BLOCK=4096; BATCH=256; VOCAB=32768; MICRO=8; GA=4               # pomiar 581 775 tok/s, bez act-ckpt
-KROKI=${KROKI:-95000}; S=${S:-9500}; DECAY=0.2; DATA_SEED=20261110; CKPT_EVERY=500
-if [[ $START = zero ]]; then WARMUP=2000; else WARMUP=1000; fi
+KROKI=${KROKI:-95000}; S=${S:-9500}; DECAY=0.2; DATA_SEED=20261110
+# Co ile kroków pełny ckpt (wznowienie po wywłaszczeniu). Nie zmienia matematyki treningu, więc wolno go zmieniać między
+# wywołaniami (np. 100 przy częstych wywłaszczeniach spot) - poza porównaniem argumentów.
+CKPT_EVERY=${CKPT_EVERY:-500}
+[[ $CKPT_EVERY =~ ^[0-9]+$ && $CKPT_EVERY -ge 50 && $CKPT_EVERY -le 5000 ]] || die "CKPT_EVERY poza 50-5000"
+# Rozgrzewka: od zera 2000; z 1.07 (stały LR, niewygaszony) 1000; z 1.08 (wygaszony do 6e-5) 2000 - łagodniejsze
+# podniesienie LR po wygaszeniu (GoLLeM S12: skok straty przy szybkim powrocie do szczytu).
+case $START in zero|108) WARMUP=2000;; 107) WARMUP=1000;; esac
 SHA_TRENER=46f83b51fcec18ffc3273d80fb9eab29e182c52d8667800dab27b80f7ff18afc   # Hart/imha/train_gpt_ref_r24_2.py
 SHA_CONV=4990a1c2bc664417ea964a5235d702cad12bff0dc53ce08211ff9a84cbcfed64     # hf_do_ckpt.py (LF)
 RUN_ID=slayer1b_109_$START
@@ -108,10 +119,11 @@ for g in $(seq 0 $((NGPU - 1))); do
 done
 "$PY" -c "import torch,sys; sys.exit(0 if sys.argv[1] in torch.cuda.get_arch_list() else 3)" "$ARCH" || die "torch bez $ARCH"
 
-if [[ $START = 107 && $K = 0 && ! -s $INIT ]]; then
+if [[ $START != zero && $K = 0 && ! -s $INIT ]]; then
   [[ $(tr -d '\r' < "$CONV" | sha256sum | cut -c1-64) = "$SHA_CONV" ]] || die "sha hf_do_ckpt.py != 4990a1c2"
-  echo "== init: wagi HF 1.07 -> ckpt trenera (hf_do_ckpt.py, piny d826b4a1 / 9e206250 / 46f83b51)"
-  mkdir -p "$(dirname "$INIT")"; "$PY" "$CONV" --pkg "$HF" --trainer "$T" --out "$INIT"
+  echo "== init: wagi HF $START -> ckpt trenera (hf_do_ckpt.py, piny ${PIN_M:0:8} / ${PIN_C:0:8} / 46f83b51)"
+  mkdir -p "$(dirname "$INIT")"
+  "$PY" "$CONV" --pkg "$HF" --trainer "$T" --out "$INIT" --sha-model "$PIN_M" --sha-config "$PIN_C"
 fi
 
 ARGS=(--data-dir "$D" --out-dir "$O" --run-id "$RUN_ID" --queue "$MAN" --resume --steps "$KROKI"
@@ -121,27 +133,29 @@ ARGS=(--data-dir "$D" --out-dir "$O" --run-id "$RUN_ID" --queue "$MAN" --resume
       --optimizer muon --lr 6e-4 --min-lr 6e-5 --muon-lr 0.02 --wd 0.1 --grad-clip 1.0
       --schedule wsd --decay-frac "$DECAY" --warmup "$WARMUP" --rewarm-steps 0
       --seed 1 --data-seed "$DATA_SEED" --loss-chunk 1024 --compile
-      --log-every 10 --eval-every 1000 --eval-iters 20 --ckpt-every "$CKPT_EVERY"
+      --log-every 10 --eval-every 1000 --eval-iters 20
       --events-jsonl "$O/events.jsonl")
-if [[ $START = 107 ]]; then ARGS+=(--init-from "$INIT"); fi
+if [[ $START != zero ]]; then ARGS+=(--init-from "$INIT"); fi
 # Te same argumenty przy każdym slocie. Wyjątek: KROKI (= --steps, długość całości) wolno zmienić TYLKO przed początkiem
 # wygaszania wg starej i nowej długości - w fazie stałej WSD LR nie zależy od --steps, więc kroki < K są te same.
+bez_ckpt() { sed -E 's/--ckpt-every [0-9]+ //'; }      # args.txt z v3 zawiera --ckpt-every 500 - porównujemy bez niego
 NOWE_ARGS=$(printf '%q ' "${ARGS[@]}")
 if [[ -s $O/args.txt ]]; then
   STARE_K=$(cat "$O/kroki.txt" 2>/dev/null || echo "$KROKI")
   if [[ $STARE_K != "$KROKI" ]]; then
-    [[ "${NOWE_ARGS/--steps $KROKI /--steps $STARE_K }" = "$(cat "$O/args.txt")" ]] \
+    [[ "${NOWE_ARGS/--steps $KROKI /--steps $STARE_K }" = "$(bez_ckpt < "$O/args.txt")" ]] \
       || die "zmiana KROKI $STARE_K -> $KROKI, ale inne argumenty też się różnią"
     GRAN=$("$PY" -c "import sys; a,b,d=int(sys.argv[1]),int(sys.argv[2]),float(sys.argv[3]); print(min(int(a*(1-d)), int(b*(1-d))))" "$STARE_K" "$KROKI" "$DECAY")
     [[ $K -lt $GRAN ]] || die "zmiana KROKI po początku wygaszania (krok $K >= $GRAN) - niedozwolona"
     echo "ZMIANA KROKI $STARE_K -> $KROKI przy kroku $K (wygaszanie od $(( KROKI * 8 / 10 )))"
     printf '%s' "$NOWE_ARGS" > "$O/args.txt"; echo "$KROKI" > "$O/kroki.txt"
   fi
-  [[ "$NOWE_ARGS" = "$(cat "$O/args.txt")" ]] || die "argumenty inne niż przy pierwszym slocie ($O/args.txt)"
+  [[ "$NOWE_ARGS" = "$(bez_ckpt < "$O/args.txt")" ]] || die "argumenty inne niż przy pierwszym slocie ($O/args.txt)"
 else
   printf '%s' "$NOWE_ARGS" > "$O/args.txt"; echo "$KROKI" > "$O/kroki.txt"
 fi
 [[ $CIAGLE = 1 ]] || ARGS+=(--queue-one-slot)
+ARGS+=(--ckpt-every "$CKPT_EVERY")
 
 echo "== torchrun $NGPU × r24.2 ($RUN_ID): kroki $K -> $E"
 L0=0; [[ ! -f $O/train.log ]] || L0=$(wc -l < "$O/train.log")
@@ -157,7 +171,7 @@ preflight() {   # przed 1. linią kroku: world, P, kolejka od kroku K; K=0: bez
         || { echo "pre-flight: kolejka nie od kroku $K / inny manifest"; return 1; }
       if [[ $K = 0 ]]; then
         ! nowe | grep -q 'RESUME @' || { echo "pre-flight: RESUME przy kroku 0"; return 1; }
-        if [[ $START = 107 ]]; then nowe | grep -q 'INIT-FROM ' || { echo "pre-flight: brak INIT-FROM"; return 1; }
+        if [[ $START != zero ]]; then nowe | grep -q 'INIT-FROM ' || { echo "pre-flight: brak INIT-FROM"; return 1; }
         else ! nowe | grep -q 'INIT-FROM ' || { echo "pre-flight: INIT-FROM przy START=zero"; return 1; }; fi
       else
         nowe | grep -qE "RESUME @ $K\$" || { echo "pre-flight: brak RESUME @ $K"; return 1; }