Publish open router-curriculum reproducibility package

README.md

@@ -0,0 +1,55 @@
+---
+license: apache-2.0
+tags:
+  - code
+  - tool-use
+  - reasoning
+  - preference-data
+  - expert-routing
+  - reproducibility
+  - autonoma
+---
+
+# Autonoma Fable router curriculum — reproducibility package
+
+This public repository documents and reproduces the router-only curriculum for an experimental LFM2.5-2.6B Fable hybrid. It intentionally does **not** redistribute records derived from a source whose license is unknown.
+
+## Included
+
+- `fable-router-curriculum.v2.json`: immutable training/data policy.
+- `build_fable_router_curriculum.py`: deterministic local builder.
+- `REPRODUCIBILITY_MANIFEST.json`: pinned sources, input/output hashes, row counts, exclusions, and build command.
+
+Given independently authorized access to the two public sources, these files reproduce the exact materialized artifacts by SHA-256. They also expose the split, deduplication, overflow, anti-loop, duplicate-tool, benefit-gated routing, and anti-collapse decisions for review.
+
+## Materialized result
+
+The internally verified build produced:
+
+| File | Rows | SHA-256 |
+|---|---:|---|
+| `sft-train.jsonl` | 6,084 | `10a72911887aa642339b78c11ed12f3540ada2076a81dc13fc99566bf522bd13` |
+| `sft-validation.jsonl` | 341 | `b2925d1699a83ea48649905a6e922e311f34e355bdbf22b0b573692358643e66` |
+| `sft-test.jsonl` | 330 | `7ddd0e5865ba54c12d1aca9ca8b87fa078742d2a115ab56137125757ac343421` |
+| `preference-train.jsonl` | 4,099 | `9924541e4a5b40710e14a370119d7571e71bb2f881433b6bd5807cc1c76dc8a4` |
+
+The split unit is normalized prompt hash for reasoning data and immutable source trajectory SHA-256 for agent/coding data. No identity crosses a split. Frozen evaluation prompts and answers are excluded from the builder.
+
+## Source policy
+
+- [`greghavens/fable-5-coding-and-debugging-traces`](https://huggingface.co/datasets/greghavens/fable-5-coding-and-debugging-traces) at `c63e82adec30798edcbd6e1dcb0014d2b15de236` declares CC-BY-4.0.
+- [`HelioAI/Claude-Fable-5-5500x`](https://huggingface.co/datasets/HelioAI/Claude-Fable-5-5500x) at `440267fbdb1b00a40216e7233dbce25530a0ed09` declares `license: unknown` and explicitly tells users to verify compliance before redistribution or derivative training.
+
+Public availability is not itself a redistribution license. Accordingly, this public package contains references and reproducibility code, not copied Fable reasoning records. The materialized artifacts remain in a private companion repository pending a compatible license or a rebuild without that source.
+
+## Reproduction
+
+Place the pinned source files at the paths declared in the builder, provide the pinned Fable tokenizer, then run:
+
+```bash
+python scripts/bench/build_fable_router_curriculum.py
+```
+
+The builder rejects malformed or overlong examples, deduplicates reasoning prompts, samples cumulative agent prefixes by immutable trajectory, creates train-only anti-loop preference pairs, and writes a provenance-bound `result.json`. Final training must retokenize with the actual chat template and reject overflow above 2,048 tokens rather than truncate it.
+
+Publication of this package does not authorize training, routing, deployment, or promotion in Autonoma.

REPRODUCIBILITY_MANIFEST.json

@@ -0,0 +1,67 @@
+{
+  "schema": "AutonomaFableRouterCurriculumReproducibility.v1",
+  "status": "public_reproducibility_package_nonrouting",
+  "nonRouting": true,
+  "trainingAuthorized": false,
+  "contract": {
+    "path": "fable-router-curriculum.v2.json",
+    "sha256": "0a0acbb0ab144b6c454f60ddbb047b00b781070992526fd5783a7d655ca514f0"
+  },
+  "sources": [
+    {
+      "repo": "HelioAI/Claude-Fable-5-5500x",
+      "revision": "440267fbdb1b00a40216e7233dbce25530a0ed09",
+      "file": "Fable-5-Distill-5500x.jsonl",
+      "sha256": "a9440e7d3c28b3fd3a41d75b7c0bc3c470bf1652a9b045c30fd4aaf74f9477e8",
+      "declaredLicense": "unknown",
+      "redistributedHere": false
+    },
+    {
+      "repo": "greghavens/fable-5-coding-and-debugging-traces",
+      "revision": "c63e82adec30798edcbd6e1dcb0014d2b15de236",
+      "manifestSha256": "0ccc75412c9d3934d09e2fc8fd9b0c0d9fb2ef911ef10a7902afba60218156e2",
+      "declaredLicense": "cc-by-4.0",
+      "redistributedHere": false
+    },
+    {
+      "repo": "ermiaazarkhalili/LFM2.5-2.6B-SFT-Fable5",
+      "revision": "72d68fc",
+      "file": "tokenizer.json",
+      "sha256": "695be7802a0e4b8a81048f0ff5ebb7fc811a0ba5a6be63dbb24deb5a81096f41",
+      "purpose": "admission token counts"
+    }
+  ],
+  "outputs": [
+    {
+      "path": "sft-train.jsonl",
+      "rows": 6084,
+      "bytes": 24082936,
+      "sha256": "10a72911887aa642339b78c11ed12f3540ada2076a81dc13fc99566bf522bd13"
+    },
+    {
+      "path": "sft-validation.jsonl",
+      "rows": 341,
+      "bytes": 1303115,
+      "sha256": "b2925d1699a83ea48649905a6e922e311f34e355bdbf22b0b573692358643e66"
+    },
+    {
+      "path": "sft-test.jsonl",
+      "rows": 330,
+      "bytes": 1300315,
+      "sha256": "7ddd0e5865ba54c12d1aca9ca8b87fa078742d2a115ab56137125757ac343421"
+    },
+    {
+      "path": "preference-train.jsonl",
+      "rows": 4099,
+      "bytes": 17933901,
+      "sha256": "9924541e4a5b40710e14a370119d7571e71bb2f881433b6bd5807cc1c76dc8a4"
+    }
+  ],
+  "excluded": {
+    "interaction_pattern_overflow": 759,
+    "reasoning_empty_or_overflow": 2082,
+    "verified_expert_overflow": 140
+  },
+  "splitIsolationVerified": true,
+  "frozenEvaluationRead": false
+}

build_fable_router_curriculum.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""Build deterministic, provenance-bound router training records without sealed-eval leakage."""
+
+from __future__ import annotations
+
+import argparse
+from collections import defaultdict
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[2]
+REASONING = ROOT / "downloads/datasets/_acquisition/fable-reasoning-440267f/Fable-5-Distill-5500x.jsonl"
+CODING = ROOT / "downloads/datasets/_acquisition/fable-agent-coding-c63e82a/data"
+TOKENIZER = ROOT / "downloads/models/_acquisition/lfm25-fable5-72d68fc/tokenizer.json"
+CONTRACT = ROOT / "config/benching/fable-router-curriculum.v2.json"
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def identity(text: str) -> str:
+    return hashlib.sha256(text.strip().encode("utf-8")).hexdigest()
+
+
+def stable_split(value: str) -> str:
+    bucket = int(hashlib.sha256(value.encode("utf-8")).hexdigest()[:8], 16) % 1000
+    return "train" if bucket < 900 else "validation" if bucket < 950 else "test"
+
+
+def flattened_message_text(messages: list[dict[str, Any]]) -> str:
+    chunks: list[str] = []
+    for message in messages:
+        chunks.extend([str(message.get("role") or ""), str(message.get("reasoning_content") or ""),
+                       str(message.get("content") or "")])
+        for call in message.get("tool_calls") or []:
+            function = call.get("function") or {}
+            chunks.extend([str(function.get("name") or ""), str(function.get("arguments") or "")])
+    return "\n".join(chunks)
+
+
+def token_count(tokenizer: Any, text: str) -> int:
+    return len(tokenizer.encode(text).ids)
+
+
+def choose_shortest(rows: list[dict[str, str]], tokenizer: Any, maximum: int) -> tuple[dict[str, str] | None, int]:
+    candidates = []
+    for row in rows:
+        if not all((row.get(key) or "").strip() for key in ("prompt", "reasoning", "answer")):
+            continue
+        count = token_count(tokenizer, "\n".join([row["prompt"], row["reasoning"], row["answer"]]))
+        if count <= maximum:
+            candidates.append((count, len(row["reasoning"]) + len(row["answer"]), row))
+    if not candidates:
+        return None, 0
+    count, _, selected = min(candidates, key=lambda item: (item[0], item[1], identity(item[2]["answer"])))
+    return selected, count
+
+
+def target_message(row: dict[str, Any]) -> dict[str, Any]:
+    messages = row.get("messages") or []
+    if not messages or messages[-1].get("role") != "assistant":
+        raise ValueError("cumulative prefix does not end in an assistant target")
+    return messages[-1]
+
+
+def has_tool_target(row: dict[str, Any]) -> bool:
+    return bool(target_message(row).get("tool_calls"))
+
+
+def select_historical_prefixes(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    ordered = sorted(rows, key=lambda row: (int(row["assistant_step"]), int(row["target_message_index"])))
+    selected = []
+    first_tool = next((row for row in ordered if has_tool_target(row)), None)
+    if first_tool is not None:
+        selected.append(first_tool)
+    if not selected or selected[-1] is not ordered[-1]:
+        selected.append(ordered[-1])
+    return selected
+
+
+def rejected_target(target: dict[str, Any]) -> tuple[str, dict[str, Any]] | None:
+    calls = target.get("tool_calls") or []
+    if calls:
+        rejected = dict(target)
+        rejected["tool_calls"] = calls + calls
+        return "duplicate_tool_call", rejected
+    content = str(target.get("content") or "").strip()
+    reasoning = str(target.get("reasoning_content") or "").strip()
+    if not content and not reasoning:
+        return None
+    rejected = dict(target)
+    if content:
+        rejected["content"] = content + "\n\n" + content
+    else:
+        rejected["reasoning_content"] = reasoning + "\n\n" + reasoning
+    return "repeated_completion", rejected
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    with path.open("w", encoding="utf-8", newline="\n") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output-root", type=Path)
+    parser.add_argument("--maximum-tokens-before-template", type=int, default=1900)
+    args = parser.parse_args()
+    if not 256 <= args.maximum_tokens_before_template <= 2048:
+        raise SystemExit("maximum token count must be between 256 and 2048")
+    from tokenizers import Tokenizer
+    try:
+        import polars as pl
+    except ImportError as exc:
+        raise SystemExit("polars is required") from exc
+
+    tokenizer = Tokenizer.from_file(str(TOKENIZER))
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    output = (args.output_root or ROOT / "downloads/audits" / f"fable-router-curriculum-data-{stamp}").resolve()
+    output.mkdir(parents=True, exist_ok=False)
+    sft: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    preferences: list[dict[str, Any]] = []
+    excluded = defaultdict(int)
+
+    reasoning_groups: dict[str, list[dict[str, str]]] = defaultdict(list)
+    with REASONING.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            row = json.loads(line)
+            reasoning_groups[identity(row.get("prompt") or "")].append(row)
+    for prompt_id, rows in sorted(reasoning_groups.items()):
+        chosen, tokens = choose_shortest(rows, tokenizer, args.maximum_tokens_before_template)
+        if chosen is None:
+            excluded["reasoning_empty_or_overflow"] += 1
+            continue
+        split = stable_split(prompt_id)
+        sft[split].append({
+            "schema": "AutonomaFableRouterRecord.v2", "id": f"reasoning:{prompt_id}", "split": split,
+            "lane": "host_preservation", "routerEligibility": "preserve", "lossPolicyKey": "host_preservation",
+            "messages": [{"role": "user", "content": chosen["prompt"]},
+                         {"role": "assistant", "reasoning_content": chosen["reasoning"], "content": chosen["answer"]}],
+            "tokensBeforeTemplate": tokens,
+            "source": {"repo": "HelioAI/Claude-Fable-5-5500x", "revision": "440267fbdb1b00a40216e7233dbce25530a0ed09",
+                       "promptSha256": prompt_id, "duplicateCandidates": len(rows)}
+        })
+
+    frames = [pl.read_parquet(path) for path in sorted(CODING.glob("*.parquet"))]
+    grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for row in pl.concat(frames, how="vertical_relaxed").to_dicts():
+        grouped[str(row["source_trajectory_sha256"])].append(row)
+    for trajectory_id, rows in sorted(grouped.items()):
+        attested = [row for row in rows if row.get("model_attested") and str(row.get("verifier") or "").strip()]
+        chosen_rows = sorted(attested, key=lambda row: int(row["assistant_step"])) if attested else select_historical_prefixes(rows)
+        lane = "verified_expert" if attested else "interaction_pattern"
+        eligibility = "expert" if attested else "conditional"
+        for row in chosen_rows:
+            messages = row.get("messages") or []
+            tokens = token_count(tokenizer, flattened_message_text(messages))
+            if tokens > args.maximum_tokens_before_template:
+                excluded[f"{lane}_overflow"] += 1
+                continue
+            split = stable_split(trajectory_id)
+            record_id = f"agent:{trajectory_id}:{int(row['assistant_step'])}"
+            sft[split].append({
+                "schema": "AutonomaFableRouterRecord.v2", "id": record_id, "split": split,
+                "lane": lane, "routerEligibility": eligibility, "lossPolicyKey": lane, "messages": messages,
+                "tokensBeforeTemplate": tokens,
+                "target": {"assistantStep": int(row["assistant_step"]), "toolCall": has_tool_target(row),
+                           "terminal": not has_tool_target(row)},
+                "source": {"repo": "greghavens/fable-5-coding-and-debugging-traces",
+                           "revision": "c63e82adec30798edcbd6e1dcb0014d2b15de236",
+                           "trajectorySha256": trajectory_id, "task": row.get("task"), "verifier": row.get("verifier"),
+                           "modelAttested": bool(row.get("model_attested")), "derivation": row.get("derivation")}
+            })
+            if split == "train":
+                negative = rejected_target(target_message(row))
+                if negative:
+                    kind, rejected = negative
+                    preferences.append({
+                        "schema": "AutonomaFableRouterPreference.v2", "id": record_id + ":" + kind,
+                        "split": "train", "lane": "loop_negative", "routerEligibility": eligibility,
+                        "lossPolicyKey": "loop_negative", "context": messages[:-1], "chosen": messages[-1],
+                        "rejected": rejected, "negativeType": kind, "sourceRecordId": record_id
+                    })
+
+    files = []
+    for split in ("train", "validation", "test"):
+        rows = sorted(sft[split], key=lambda row: row["id"])
+        path = output / f"sft-{split}.jsonl"
+        write_jsonl(path, rows)
+        files.append({"path": path.name, "rows": len(rows), "bytes": path.stat().st_size, "sha256": sha256(path),
+                      "lanes": {lane: sum(row["lane"] == lane for row in rows) for lane in sorted({r["lane"] for r in rows})}})
+    preference_path = output / "preference-train.jsonl"
+    write_jsonl(preference_path, sorted(preferences, key=lambda row: row["id"]))
+    files.append({"path": preference_path.name, "rows": len(preferences), "bytes": preference_path.stat().st_size,
+                  "sha256": sha256(preference_path),
+                  "negativeTypes": {kind: sum(row["negativeType"] == kind for row in preferences)
+                                    for kind in sorted({r["negativeType"] for r in preferences})}})
+    result = {
+        "schema": "AutonomaFableRouterCurriculumBuild.v2", "status": "curriculum_built_nonrouting",
+        "nonRouting": True, "trainingAuthorized": False, "createdAt": datetime.now(timezone.utc).isoformat(),
+        "contract": {"path": str(CONTRACT), "sha256": sha256(CONTRACT)},
+        "sources": [{"path": str(REASONING), "sha256": sha256(REASONING)},
+                    {"path": str(TOKENIZER), "sha256": sha256(TOKENIZER)},
+                    {"path": str(CODING.parent / "dataset-manifest.json"),
+                     "sha256": sha256(CODING.parent / "dataset-manifest.json")}],
+        "maximumTokensBeforeTemplate": args.maximum_tokens_before_template,
+        "finalTrainerRetokenizationRequired": True, "files": files, "excluded": dict(sorted(excluded.items())),
+        "frozenEvaluationRead": False
+    }
+    result_path = output / "result.json"
+    result_path.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
+    print(result_path)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fable-router-curriculum.v2.json

@@ -0,0 +1,197 @@
+{
+  "schema": "AutonomaFableRouterCurriculum.v2",
+  "status": "data_contract_frozen_training_not_authorized_nonrouting",
+  "nonRouting": true,
+  "trainingAuthorized": false,
+  "goalOrder": [
+    "capability",
+    "succinctness_and_termination",
+    "expert_efficiency",
+    "throughput"
+  ],
+  "immutableSources": {
+    "host": {
+      "repo": "ermiaazarkhalili/LFM2.5-2.6B-SFT-Fable5",
+      "revision": "72d68fc"
+    },
+    "reasoning": {
+      "repo": "HelioAI/Claude-Fable-5-5500x",
+      "revision": "440267fbdb1b00a40216e7233dbce25530a0ed09"
+    },
+    "agentCoding": {
+      "repo": "greghavens/fable-5-coding-and-debugging-traces",
+      "revision": "c63e82adec30798edcbd6e1dcb0014d2b15de236"
+    },
+    "selectedBanks": {
+      "path": "config/benching/fable-donor-selected-banks.v1.json",
+      "sha256": "158689cca0679423925cfe3c2eefbd6a248045ed01d2f7dad4d74e05e3ad0d81"
+    }
+  },
+  "dataPolicy": {
+    "splitIdentity": {
+      "reasoning": "sha256(trimmed prompt)",
+      "agentCoding": "source_trajectory_sha256"
+    },
+    "splitBuckets": {
+      "train": "0..899",
+      "validation": "900..949",
+      "test": "950..999"
+    },
+    "reasoningDeduplication": "retain the shortest admitted non-empty completion per normalized prompt",
+    "historicalTrajectorySampling": "at most the first tool-producing prefix plus the final prefix",
+    "attestedTrajectorySampling": "retain all verifier-attested assistant decisions",
+    "maximumTokensBeforeTemplate": 1900,
+    "finalTemplateMaximumTokens": 2048,
+    "finalTrainerMustRetokenizeAndRejectOverflow": true,
+    "frozenEvaluationIsolation": "never read sealed/frozen evaluation prompts or answers while building or training"
+  },
+  "lanes": {
+    "host_preservation": {
+      "routerEligibility": "preserve",
+      "sftWeight": 1.0,
+      "baseFableKlWeight": 1.0,
+      "expertActivityTarget": "zero unless routed loss beats frozen host by the benefit margin"
+    },
+    "verified_expert": {
+      "routerEligibility": "expert",
+      "sftWeight": 1.0,
+      "baseFableKlWeight": 0.25,
+      "requires": "model_attested=true and non-empty verifier"
+    },
+    "interaction_pattern": {
+      "routerEligibility": "conditional",
+      "sftWeight": 0.1,
+      "baseFableKlWeight": 0.5,
+      "purpose": "tool topology and recovery only; not correctness supervision"
+    },
+    "loop_negative": {
+      "routerEligibility": "inherit_positive",
+      "preferenceWeight": 0.5,
+      "purpose": "reject repeated completions and duplicate identical tool calls"
+    }
+  },
+  "routingObjective": {
+    "counterfactual": "compare frozen-host token NLL with independently explored routed token NLL; never rely only on the router's current choice",
+    "offClass": "host-only is an explicit route target when no sampled expert helps",
+    "exploration": {
+      "expertScaleDuringDiscovery": "initialize at 0.005 and cap at 0.025 so incorrect trials cannot materially override the host",
+      "oracleProbeScales": [
+        0.025,
+        0.05,
+        0.1
+      ],
+      "probeIsolation": "counterfactual probe branches are detached from the served/main output; only the low-scale chosen branch can affect host logits during discovery",
+      "candidateExpertsPerEligibleToken": 4,
+      "sampling": "stratified without replacement across steps and layers, independent of router logits; half uniform coverage and half frozen-profile-prior sampling",
+      "coverageBeforePruning": "every selected expert must receive counterfactual trials on validation-eligible token classes",
+      "forcedExplorationProbability": {
+        "initial": 0.25,
+        "final": 0.05,
+        "annealSteps": 300
+      },
+      "eligibleTokenEntropyBonus": {
+        "initial": 0.01,
+        "final": 0.0,
+        "annealSteps": 300
+      },
+      "minimumEligibleRouteMass": {
+        "initial": 0.15,
+        "final": 0.0,
+        "annealSteps": 300,
+        "scope": "expert-eligible tokens only; never host-preservation tokens"
+      },
+      "positiveDiscoveryReplay": "retain positive-benefit token/expert pairs in a bounded balanced replay buffer"
+    },
+    "routerSupervision": {
+      "target": "best sampled positive-benefit expert, with host-only off as a competing class",
+      "loss": "benefit-weighted ranking/classification plus end-to-end token NLL",
+      "negativeExperts": "sampled wrong experts teach relative ranking without requiring their high-impact activation",
+      "allOffProtection": "ranking targets and the temporary eligible-token route floor provide gradients even when current router logits prefer off"
+    },
+    "benefitMarginNats": 0.02,
+    "benefitMarginSchedule": "0.0 during discovery, anneal to 0.02 nats over steps 100..300",
+    "routeActivation": "after discovery, reward only when routed NLL improves beyond the annealed margin",
+    "routeCost": {
+      "expertScaleL1": 0.015,
+      "activeExpertPenalty": 0.005,
+      "targetActiveExpertsPerEligibleToken": "1..2",
+      "schedule": "zero for the first 100 discovery steps, then linearly anneal to full weight by step 300"
+    },
+    "conditionalLoadBalance": {
+      "weight": 0.01,
+      "applyOnlyTo": "expert-eligible tokens that pass the benefit gate",
+      "neverApplyTo": [
+        "host_preservation tokens",
+        "tokens where the host-only path is equal or better"
+      ]
+    },
+    "antiDeadExpert": {
+      "measurement": "usage and marginal NLL improvement per layer, expert, lane, and donor bank",
+      "minimumUse": "no global quota; require coverage only among positive-benefit eligible tokens",
+      "pruneRule": "remove experts only after completed stratified exploration finds no validation-set marginal benefit; router non-use alone is not evidence",
+      "collapseGate": "reject checkpoints that choose off for all eligible tokens while the oracle replay buffer contains positive-benefit routes"
+    }
+  },
+  "behaviorObjective": {
+    "stopBoundaryLoss": 0.25,
+    "loopUnlikelihood": 0.5,
+    "duplicateToolCallPenalty": 0.75,
+    "maximumRepeatedNgramRateRegression": 0.0,
+    "maximumMedianAnswerLengthRegression": 0.05,
+    "maximumToolCallsAcrossFrozenSuite": 24,
+    "reject": [
+      "verbatim answer repetition",
+      "duplicate identical tool calls without an intervening result",
+      "continued reasoning after a valid terminal answer",
+      "expert activation without measured token-level benefit"
+    ]
+  },
+  "curriculum": [
+    {
+      "stage": "A-host-anchor",
+      "steps": 200,
+      "mixture": {
+        "host_preservation": 0.75,
+        "verified_expert": 0.2,
+        "interaction_pattern": 0.05
+      },
+      "routerScaleMaximum": 0.025
+    },
+    {
+      "stage": "B-benefit-gated-routing",
+      "steps": 600,
+      "mixture": {
+        "host_preservation": 0.3,
+        "verified_expert": 0.6,
+        "interaction_pattern": 0.1
+      },
+      "routerScaleMaximum": 0.1
+    },
+    {
+      "stage": "C-succinct-calibration",
+      "steps": 200,
+      "mixture": {
+        "host_preservation": 0.55,
+        "verified_expert": 0.35,
+        "interaction_pattern": 0.1
+      },
+      "loopNegativeRatio": 0.25,
+      "routerScaleMaximum": 0.1
+    }
+  ],
+  "checkpointSelection": {
+    "order": [
+      "verified coding and tool correctness",
+      "host capability non-regression",
+      "succinctness and clean termination",
+      "expert-use efficiency",
+      "decode throughput"
+    ],
+    "rejectOn": [
+      "any sealed correctness regression beyond the predeclared tolerance",
+      "loop or duplicate-tool regression",
+      "median verbosity regression above 5%",
+      "expert traffic without positive marginal validation benefit"
+    ]
+  }
+}