Upload folder using huggingface_hub

DATASET_LINEAGE.md

@@ -0,0 +1,45 @@
+# Dataset Lineage
+
+Canonical clean training file:
+
+- `final_glyph_sft_dataset.jsonl`
+
+Build chain:
+
+1. `build_gold50.py`
+2. `build_gold300.py`
+3. `build_gold3000.py`
+   - grows the base corpus
+4. `build_gold_rust_tooluse.py`
+   - appends the Rust/tool-use expansion into `gold_glyph_3000.jsonl`
+   - introduces the main RL-shaped traces:
+     - `read_file -> apply_patch -> cargo_test -> response`
+     - `read_file -> apply_patch -> cargo_run -> response`
+5. `build_rlvr_seed_final_v1.py`
+   - adds the `137`-trace corrective top-up
+   - produces `gold_glyph_3141_plus_rlvr_seed_final_v1.jsonl`
+6. `build_rlvr_seed_microfix_v1.py`
+   - adds the final `7`-trace micro-fix
+   - produces `gold_glyph_3148_plus_rlvr_seed_microfix_v1.jsonl`
+7. exact dedupe pass
+   - removes repeated rows from `gold_glyph_3148_plus_rlvr_seed_microfix_v1.jsonl`
+   - produces `final_glyph_sft_dataset.jsonl`
+
+Files that matter now:
+
+- `gold_glyph_3000.jsonl`
+- `rlvr_seed_final_v1.jsonl`
+- `gold_glyph_3141_plus_rlvr_seed_final_v1.jsonl`
+- `rlvr_seed_microfix_v1.jsonl`
+- `gold_glyph_3148_plus_rlvr_seed_microfix_v1.jsonl`
+- `final_glyph_sft_dataset.jsonl`
+
+Repro facts:
+
+- `gold_glyph_3000.jsonl` has `3004` rows on disk
+- `gold_glyph_3141_plus_rlvr_seed_final_v1.jsonl` has `3141` rows
+- `gold_glyph_3148_plus_rlvr_seed_microfix_v1.jsonl` has `3148` rows
+- `final_glyph_sft_dataset.jsonl` has `3039` rows
+- all `137` seed traces are in the final `3148` file
+- all `7` micro-fix traces are in the final `3148` file
+- `final_glyph_sft_dataset.jsonl` is the file to use for the clean retrain

build_gold3000.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from core.validator import validate_trace
+import build_gold300 as g300
+
+
+OUT = Path(__file__).parent / "gold_glyph_3000.jsonl"
+SYSTEM_RE = re.compile(r"(<\|im_start\|>system\n)system「(.*?)」", re.DOTALL)
+USER_RE = re.compile(r"(<\|im_start\|>user\n)user「(.*?)」🏷 usr1", re.DOTALL)
+
+
+SYSTEM_VARIANTS = {
+    "rust_no_tool": [
+        "You are a Rust language assistant who gives compact conceptual explanations.",
+        "You are a concise Rust mentor who answers in short technical paragraphs.",
+        "You are a Rust engineering explainer who stays brief and practical.",
+        "You are a focused Rust assistant who gives short, direct explanations.",
+        "You are a practical Rust reviewer who explains tradeoffs concisely.",
+        "You are a concise Rust education assistant who prefers concrete answers.",
+        "You are a Rust API design assistant who answers briefly and precisely.",
+        "You are a Rust systems explainer who keeps answers compact and clear.",
+    ],
+    "rustdoc": [
+        "You are a Rust documentation assistant who answers briefly and precisely.",
+        "You are a concise Rust docs assistant who explains looked-up symbols clearly.",
+        "You are a Rust reference assistant who uses doc results and responds briefly.",
+        "You are a practical Rust documentation explainer who keeps answers short.",
+        "You are a Rust docs helper who summarizes symbol behavior concisely.",
+        "You are a precise Rust API assistant who uses the docs tool and answers briefly.",
+        "You are a Rust documentation guide who explains tool results in compact language.",
+        "You are a Rust symbol reference assistant who answers in one short explanation.",
+    ],
+    "cargo": [
+        "You are a Rust debugging assistant who diagnoses compiler and tool output concisely.",
+        "You are a concise Rust build-failure assistant who explains likely fixes briefly.",
+        "You are a practical Rust diagnostics assistant who keeps repair guidance short.",
+        "You are a Rust troubleshooting assistant who reads tool output and answers tersely.",
+        "You are a focused Rust compiler assistant who gives brief diagnosis and repair direction.",
+        "You are a Rust code-health assistant who interprets cargo output concisely.",
+        "You are a concise Rust lint-and-test assistant who stays practical and direct.",
+        "You are a Rust debugging mentor who turns tool output into a short fix recommendation.",
+    ],
+    "ci": [
+        "You are a debugging assistant who keeps incident analysis concise and resilient to tool failure.",
+        "You are a concise incident assistant who uses evidence first and answers briefly.",
+        "You are a practical CI-debugging assistant who gives short, concrete next steps.",
+        "You are an operations assistant who keeps failure analysis focused and compact.",
+        "You are a concise reliability assistant who prioritizes direct evidence and short answers.",
+        "You are a debugging assistant who narrows failures quickly and avoids unnecessary loops.",
+        "You are a practical incident triage assistant who answers with one focused recommendation.",
+        "You are a concise CI assistant who uses minimal tool steps and short diagnosis.",
+    ],
+    "sql": [
+        "You are a data access assistant who uses SQL and answers briefly.",
+        "You are a concise analytics assistant who runs one query and responds directly.",
+        "You are a practical SQL assistant who returns short, exact answers.",
+        "You are a read-only database assistant who answers compactly from query results.",
+        "You are a concise reporting assistant who uses SQL and keeps responses short.",
+        "You are an analytics helper who prefers one query and a direct answer.",
+        "You are a SQL lookup assistant who answers briefly and precisely.",
+        "You are a concise data-query assistant who returns only the needed result.",
+    ],
+    "math": [
+        "You are a helpful assistant specialized in symbolic mathematics. Provide clear, concise solutions.",
+        "You are a concise symbolic math assistant who uses tools and answers briefly.",
+        "You are a practical calculus assistant who verifies results and keeps explanations short.",
+        "You are a focused symbolic algebra assistant who responds in compact technical language.",
+        "You are a concise math-solving assistant who uses one or two precise tool steps.",
+        "You are a symbolic math helper who answers clearly and without extra verbosity.",
+        "You are a practical mathematics assistant who verifies results and stops promptly.",
+        "You are a concise calculus assistant who gives direct final answers after verification.",
+    ],
+    "file": [
+        "You are a document assistant who reads a file and returns a short, concrete summary.",
+        "You are a concise file-reading assistant who summarizes excerpts directly.",
+        "You are a practical document assistant who answers with short, specific takeaways.",
+        "You are a concise notes assistant who loads a file and summarizes only the essentials.",
+        "You are a focused document summarizer who keeps outputs short and concrete.",
+        "You are a brief file-summary assistant who extracts only the main conclusions.",
+        "You are a practical reading assistant who turns excerpts into tight summaries.",
+        "You are a concise document-review assistant who answers in one short summary.",
+    ],
+    "plan": [
+        "You are a planning assistant that helps product teams build realistic launch plans and concise schedules.",
+        "You are a concise planning assistant who checks staffing and produces short rollout recommendations.",
+        "You are a practical launch-planning assistant who keeps plans realistic and brief.",
+        "You are a scheduling assistant who gives compact rollout guidance grounded in tool results.",
+        "You are a concise product-planning assistant who answers with short, actionable schedules.",
+        "You are a practical operations planner who checks feasibility and responds briefly.",
+        "You are a concise launch assistant who uses staffing data and keeps output tight.",
+        "You are a planning helper who turns availability and task data into short rollout guidance.",
+    ],
+    "git": [
+        "You are a concise git assistant who reads repository status and answers briefly.",
+        "You are a practical git hygiene assistant who summarizes repo state compactly.",
+        "You are a concise version-control assistant who uses git tools and answers directly.",
+        "You are a git workflow assistant who keeps status summaries short and concrete.",
+        "You are a practical git review assistant who reports only the important repo details.",
+        "You are a concise source-control assistant who answers with brief actionable summaries.",
+        "You are a git diagnostics assistant who reads repository metadata and stays short.",
+        "You are a practical repository assistant who gives compact git-based answers.",
+    ],
+}
+
+
+NO_TOOL_PREFIXES = [
+    "Briefly, ",
+    "In one short paragraph, ",
+    "Give a concise answer: ",
+    "Short answer: ",
+]
+NO_TOOL_SUFFIXES = [
+    " Keep the answer concise.",
+    " Answer briefly.",
+    " Give a short practical explanation.",
+    " Keep it to the key point.",
+]
+TOOL_PREFIXES = [
+    "Briefly, ",
+    "Keep it short: ",
+    "Concisely, ",
+    "Give a short answer: ",
+]
+TOOL_SUFFIXES = [
+    " Use the available tool support and keep the answer concise.",
+    " Use the tool flow and answer briefly.",
+    " Keep the final answer short.",
+    " Keep it compact.",
+]
+
+
+def infer_category(trace: str) -> str:
+    if "rustdoc_lookup" in trace and not any(x in trace for x in ("cargo_check", "cargo_test", "cargo_clippy")):
+        return "rustdoc"
+    if any(x in trace for x in ("cargo_check", "cargo_test", "cargo_clippy")):
+        return "cargo"
+    if "get_ci_logs" in trace:
+        return "ci"
+    if "run_sql" in trace:
+        return "sql"
+    if "solve_symbolic" in trace:
+        return "math"
+    if "load_file" in trace:
+        return "file"
+    if "get_availability" in trace:
+        return "plan"
+    if "git_status" in trace or "git_log" in trace:
+        return "git"
+    return "rust_no_tool"
+
+
+def replace_system(trace: str, system_text: str) -> str:
+    return SYSTEM_RE.sub(rf"\1system「{system_text}」", trace, count=1)
+
+
+def replace_user(trace: str, user_text: str) -> str:
+    return USER_RE.sub(rf"\1user「{user_text}」🏷 usr1", trace, count=1)
+
+
+def extract_user(trace: str) -> str:
+    m = USER_RE.search(trace)
+    if not m:
+        raise ValueError("user segment not found")
+    return m.group(2)
+
+
+def has_tools(trace: str) -> bool:
+    return "<|im_start|>tool" in trace or "tool {" in trace
+
+
+def vary_user_text(user_text: str, idx: int, tooly: bool) -> str:
+    if idx == 0:
+        return user_text
+    prefixes = TOOL_PREFIXES if tooly else NO_TOOL_PREFIXES
+    suffixes = TOOL_SUFFIXES if tooly else NO_TOOL_SUFFIXES
+    style = (idx - 1) % 4
+    if (idx - 1) // 4 == 0:
+        return prefixes[style] + user_text[0].lower() + user_text[1:] if user_text and user_text[0].isupper() else prefixes[style] + user_text
+    return user_text + suffixes[style]
+
+
+def augment_trace(trace: str, idx: int) -> str:
+    category = infer_category(trace)
+    system_text = SYSTEM_VARIANTS[category][idx % len(SYSTEM_VARIANTS[category])]
+    user_text = vary_user_text(extract_user(trace), idx, has_tools(trace))
+    return replace_user(replace_system(trace, system_text), user_text)
+
+
+def build_records() -> list[str]:
+    base = g300.extend_records()
+    traces: list[str] = []
+    seen: set[str] = set()
+
+    def add(trace: str) -> None:
+        if trace not in seen:
+            seen.add(trace)
+            traces.append(trace)
+
+    for trace in base:
+        add(trace)
+
+    # 7 additional variants per seed trace.
+    for variant_idx in range(1, 8):
+        for trace in base:
+            add(augment_trace(trace, variant_idx))
+
+    # One more variant for the first 100 traces.
+    for trace in base[:100]:
+        add(augment_trace(trace, 8))
+
+    extra_idx = 9
+    while len(traces) < 2500:
+        for trace in base:
+            add(augment_trace(trace, extra_idx))
+            if len(traces) == 2500:
+                break
+        extra_idx += 1
+
+    assert len(traces) == 2500, len(traces)
+    return traces
+
+
+def main() -> int:
+    traces = build_records()
+    bad: list[tuple[int, list[str]]] = []
+    with OUT.open("w") as f:
+        for i, trace in enumerate(traces, start=1):
+            res = validate_trace(trace)
+            if not res.valid:
+                bad.append((i, res.errors))
+            f.write(json.dumps({"trace": trace}, ensure_ascii=False) + "\n")
+    rustish = sum(1 for t in traces if ("Rust" in t or "rust" in t or "cargo_" in t or "rustdoc_" in t))
+    print(json.dumps({"count": len(traces), "rustish": rustish, "ratio": rustish / len(traces), "output": str(OUT), "invalid": bad[:20], "invalid_count": len(bad)}, indent=2))
+    return 0 if not bad else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

build_gold50.py

@@ -0,0 +1,600 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from core.validator import validate_trace
+
+
+OUT = Path(__file__).parent / "gold_glyph_50.jsonl"
+
+
+@dataclass(frozen=True)
+class ToolParam:
+    name: str
+    kind: str
+    description: str
+    required: bool = True
+    enum_values: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class ToolDef:
+    name: str
+    description: str
+    params: tuple[ToolParam, ...]
+
+
+def param(name: str, kind: str, description: str, required: bool = True) -> ToolParam:
+    return ToolParam(name, kind, description, required)
+
+
+def enum_param(name: str, values: tuple[str, ...], description: str, required: bool = True) -> ToolParam:
+    return ToolParam(name, "enum", description, required, values)
+
+
+def tool(name: str, description: str, *params: ToolParam) -> ToolDef:
+    return ToolDef(name, description, params)
+
+
+def render_tools(tools: list[ToolDef]) -> str:
+    parts: list[str] = []
+    for t in tools:
+        lines = [
+            "tool {",
+            f"    name ↦ {t.name} •",
+            f'    description ↦ "{t.description}" •',
+            "    params ↦ {",
+        ]
+        row_parts = []
+        for p in t.params:
+            inner = [f'enum ↦ [ {" • ".join(p.enum_values)} ]' if p.enum_values else f"type ↦ {p.kind}"]
+            if not p.required:
+                inner.append("required ↦ false")
+            inner.append(f'description ↦ "{p.description}"')
+            row_parts.append(f"        {p.name} ↦ {{ {' • '.join(inner)} }}")
+        lines.append(" •\n".join(row_parts) if row_parts else "")
+        lines.append("    }")
+        lines.append("}")
+        parts.append("\n".join(lines))
+    return "\n".join(parts)
+
+
+def seg(role: str, body: str) -> str:
+    return f"<|im_start|>{role}\n{body}\n<|im_end|>"
+
+
+def system_seg(text: str, tools: list[ToolDef] | None = None) -> str:
+    body = [f"system「{text}」"]
+    if tools:
+        body.append(render_tools(tools))
+    return seg("system", "\n".join(body))
+
+
+def user_seg(text: str) -> str:
+    return seg("user", f"user「{text}」🏷 usr1")
+
+
+def plan_block(todos: list[str], rationale: str) -> str:
+    lines = ["plan {", "    todo ↦ {"]
+    for i, todo in enumerate(todos, start=1):
+        sep = " •" if i < len(todos) else ""
+        lines.append(f'        {i} ↦ "{todo}" ※ usr1{sep}')
+    lines.extend(["    } •", f'    rationale ↦ "{rationale}"', "}"])
+    return "\n".join(lines)
+
+
+def think_act(thoughts: list[tuple[str, str, list[str]]]) -> str:
+    lines = ["act {", "    think ↦ ["]
+    for i, (text, tag, refs) in enumerate(thoughts):
+        ref_text = f" ※ [ {' • '.join(refs)} ]" if refs else ""
+        sep = " •" if i < len(thoughts) - 1 else ""
+        lines.append(f'        「{text}」 𝑝 0.9 🏷 {tag}{ref_text}{sep}')
+    lines.extend(["    ]", "}"])
+    return "\n".join(lines)
+
+
+def call_act(tool_name: str, args: list[tuple[str, str]], call_id: str, satisfies: int) -> str:
+    lines = ["act {", "    call ↦ {"]
+    rows = [f"        tool ↦ {tool_name}"]
+    rows.extend(f'        {k} ↦ "{v}"' for k, v in args)
+    rows.append(f"        id ↦ {call_id}")
+    lines.append(" •\n".join(rows))
+    lines.extend([f"    }} ⊨ {satisfies}", "}"])
+    return "\n".join(lines)
+
+
+def result_seg(data: str, tag: str) -> str:
+    return seg("tool", f'result {{\n    data ↦ "{data}" 🏷 {tag}\n}}')
+
+
+def response_block(text: str, refs: list[str], satisfies: int) -> str:
+    return "\n".join([f"response「{text}」", f"※ [ {' • '.join(refs)} ]", f"⊨ {satisfies}"])
+
+
+def assistant_seg(*blocks: str) -> str:
+    return seg("assistant", "\n\n".join(blocks))
+
+
+def join_trace(*segments: str) -> str:
+    return "\n\n".join(segments)
+
+
+def no_tool_trace(system: str, user: str, todo: str, rationale: str, think: str, response: str, note_tag: str) -> str:
+    return join_trace(
+        system_seg(system),
+        user_seg(user),
+        assistant_seg(
+            plan_block([todo], rationale),
+            think_act([(think, note_tag, ["usr1"])]),
+            response_block(response, [note_tag], 1),
+        ),
+    )
+
+
+def single_tool_trace(system: str, tools: list[ToolDef], user: str, todos: list[str], rationale: str,
+                      call_tool: str, call_args: list[tuple[str, str]], call_id: str,
+                      result_data: str, think: str, note_tag: str, response: str) -> str:
+    return join_trace(
+        system_seg(system, tools),
+        user_seg(user),
+        assistant_seg(plan_block(todos, rationale), call_act(call_tool, call_args, call_id, 1)),
+        result_seg(result_data, call_id),
+        assistant_seg(
+            think_act([(think, note_tag, [call_id])]),
+            response_block(response, [call_id, note_tag], 2),
+        ),
+    )
+
+
+def multi_tool_trace(system: str, tools: list[ToolDef], user: str, todos: list[str], rationale: str,
+                     call1_tool: str, call1_args: list[tuple[str, str]], call1_id: str, result1: str, think1: str, tag1: str,
+                     call2_tool: str, call2_args: list[tuple[str, str]], call2_id: str, result2: str, think2: str, tag2: str,
+                     response: str) -> str:
+    return join_trace(
+        system_seg(system, tools),
+        user_seg(user),
+        assistant_seg(plan_block(todos, rationale), call_act(call1_tool, call1_args, call1_id, 1)),
+        result_seg(result1, call1_id),
+        assistant_seg(think_act([(think1, tag1, [call1_id])]), call_act(call2_tool, call2_args, call2_id, 2)),
+        result_seg(result2, call2_id),
+        assistant_seg(think_act([(think2, tag2, [call1_id, call2_id])]), response_block(response, [call1_id, call2_id, tag2], 3)),
+    )
+
+
+def records() -> list[str]:
+    rustdoc = [tool("rustdoc_lookup", "Returns concise documentation for a Rust symbol.", param("symbol", "string", "Rust symbol"))]
+    cargo = [
+        tool("cargo_check", "Runs cargo check on a Rust crate and returns the main compiler diagnostics.", param("crate_path", "string", "Path to the crate", required=False)),
+        tool("cargo_test", "Runs cargo test and returns failing test output.", param("crate_path", "string", "Path to the crate", required=False), param("filter", "string", "Optional test filter", required=False)),
+        tool("cargo_clippy", "Runs cargo clippy and returns the main lints.", param("crate_path", "string", "Path to the crate", required=False)),
+        tool("rustdoc_lookup", "Returns concise documentation for a Rust type, trait, macro, or function.", param("symbol", "string", "Rust symbol to look up", required=False)),
+    ]
+    ci_tools = [
+        tool("get_ci_logs", "Fetches CI logs for a run.", param("run_id", "string", "Run id")),
+        tool("code_search", "Searches the codebase.", param("query", "string", "Search query")),
+        tool("fetch_cached_incident", "Returns a cached incident note.", param("service", "string", "Service name")),
+    ]
+    sql_tools = [tool("run_sql", "Executes a read-only SQL query.", param("query", "string", "SQL query text"))]
+    math_tools = [
+        tool("solve_symbolic", "Performs symbolic math operations.", param("expression", "string", "Expression"), enum_param("operation", ("integrate", "differentiate", "simplify", "factor"), "Operation"), param("variable", "string", "Variable")),
+        tool("derivative_check", "Differentiates a candidate and compares it to a target expression.", param("candidate_antiderivative", "string", "Candidate"), param("target_expression", "string", "Target"), param("variable", "string", "Variable")),
+    ]
+    file_tools = [tool("load_file", "Loads a file from disk and returns a short excerpt.", param("path", "string", "Path to load"))]
+    git_tools = [
+        tool("git_status", "Returns a concise git status (branch, dirty files, and staged changes).", param("repo_path", "string", "Path to the git repository", required=False)),
+        tool("git_log", "Shows recent commits in a concise one-line format.", param("repo_path", "string", "Path to the git repository", required=False), param("limit", "number", "Maximum number of commits to show", required=False)),
+    ]
+    plan_tools = [
+        tool("get_availability", "Returns weekly availability by teammate.", param("team_list", "string", "Comma-separated IDs", required=False), param("start_date", "string", "Start date", required=False), param("end_date", "string", "End date", required=False)),
+        tool("create_project_plan", "Generates a short work breakdown.", param("project_name", "string", "Project name", required=False), param("objectives", "string", "Objectives", required=False), param("timeline_weeks", "string", "Timeline in weeks", required=False)),
+    ]
+
+    traces: list[str] = []
+
+    traces.extend([
+        no_tool_trace("You are a Rust language assistant who gives compact conceptual explanations.",
+                      "In Rust, when would you choose an enum over a trait-object-based design? Give one concrete tradeoff and a simple rule of thumb.",
+                      "Explain the tradeoff and give a short rule of thumb.",
+                      "Define the main distinction, then give one practical heuristic.",
+                      "Contrast closed sets of variants with open-ended extensibility, then end with one pragmatic selection rule.",
+                      "Use an enum when you control a fixed set of variants and want exhaustive matching; use trait objects when you need open-ended implementations and can accept dynamic dispatch. Rule of thumb: fixed variants -> enum, plugin-like extensibility -> trait objects.",
+                      "note_enum_vs_dyn"),
+        no_tool_trace("You are a Rust async explainer who writes concise technical answers.",
+                      "In async Rust, what does Send mean for a Future, and when do I need it?",
+                      "Explain what Send on a Future guarantees and when it matters.",
+                      "Define the guarantee first, then state the practical executor boundary.",
+                      "State that Send means the future can move across threads safely, then tie it to multithreaded executors.",
+                      "A Future is Send if it can be moved between threads safely while suspended. You need it when spawning onto a multithreaded executor like the default Tokio runtime; you do not need it for strictly single-threaded local execution.",
+                      "note_future_send"),
+        no_tool_trace("You are a Rust education assistant who explains ownership tradeoffs briefly.",
+                      "Why is Rc not Send in Rust?",
+                      "Explain why Rc is not thread-safe.",
+                      "Connect reference-count mutation to thread safety in one short explanation.",
+                      "Point out that Rc updates shared refcounts without atomic operations, which is fine on one thread but unsafe across threads.",
+                      "Rc is not Send because its reference count is updated non-atomically, so moving it across threads could race and corrupt the count. Use Arc when shared ownership must cross thread boundaries.",
+                      "note_rc_send"),
+        no_tool_trace("You are a practical Rust mentor who answers in short paragraphs.",
+                      "When should I prefer PathBuf over String for filesystem paths in Rust?",
+                      "Explain when PathBuf is the better choice for paths.",
+                      "Tie the recommendation to semantics and platform correctness.",
+                      "Emphasize that paths are not just text and should use path-specific types when code manipulates filesystem locations.",
+                      "Prefer PathBuf when the value represents a filesystem path, especially if you will join, normalize, or pass it to file APIs. It models platform path semantics correctly, whereas String is just text.",
+                      "note_pathbuf"),
+        no_tool_trace("You are a concise systems explainer.",
+                      "What problem do Arc and Mutex solve together in Rust?",
+                      "Explain what Arc<Mutex<T>> enables.",
+                      "State the ownership and synchronization pieces separately, then combine them.",
+                      "Describe Arc as shared ownership across threads and Mutex as coordinated mutable access to the inner value.",
+                      "Arc<Mutex<T>> gives multiple threads shared ownership of the same value while ensuring only one thread mutates it at a time. Arc solves ownership sharing; Mutex solves synchronized interior mutability.",
+                      "note_arc_mutex"),
+        no_tool_trace("You are a concise engineering explainer.",
+                      "Why do long-lived Git branches create so many merge conflicts on small teams?",
+                      "Explain the main cause of frequent merge conflicts.",
+                      "Tie conflicts to delayed integration and overlapping edits.",
+                      "Keep the explanation centered on long-lived divergence and multiple people editing the same areas before integrating.",
+                      "Long-lived branches create more merge conflicts because they let code drift farther from main while multiple people keep editing the same files. The longer work stays unintegrated, the more likely those edits collide when you finally merge.",
+                      "note_git_conflicts"),
+        no_tool_trace("You are a concise architecture reviewer.",
+                      "Why are rollout plans safer when they move low-risk services first?",
+                      "Explain why staged rollout order matters.",
+                      "Connect rollout order to blast radius and learning.",
+                      "State that early low-risk migrations surface hidden assumptions before the riskiest cutovers.",
+                      "Starting with low-risk services reduces blast radius and lets the team discover tooling, networking, and observability problems before touching critical workloads. It turns the first migrations into learning steps instead of existential bets.",
+                      "note_rollout_order"),
+        no_tool_trace("You are a concise data engineering mentor.",
+                      "Why should production schema changes use migrations instead of creating tables at app startup?",
+                      "Explain the operational reason for migrations.",
+                      "Center the answer on explicitness, repeatability, and safety.",
+                      "Keep the explanation about reviewable state changes and safer deploys.",
+                      "Use migrations in production because they make schema changes explicit, reviewable, and repeatable across environments. Startup-created tables are convenient for prototypes, but they hide change history and make coordinated deploys riskier.",
+                      "note_migrations"),
+        no_tool_trace("You are a concise systems mentor.",
+                      "Why do flaky tests often come from hidden time or concurrency assumptions?",
+                      "Explain the main source of flakiness.",
+                      "Connect nondeterminism to scheduling, timing, and shared state.",
+                      "Keep it focused on tests depending on events that do not happen in a fixed order every run.",
+                      "Flaky tests often depend on timing or scheduling that is not deterministic, such as background tasks, retries, shared state, or race-prone setup. When a test assumes a precise order or latency budget, small runtime differences can make it pass sometimes and fail other times.",
+                      "note_flaky_tests"),
+        no_tool_trace("You are a concise reliability explainer.",
+                      "What is the operational risk of using broad allow rules to silence clippy warnings?",
+                      "Explain why broad lint suppression is risky.",
+                      "Tie it to hiding future regressions.",
+                      "Keep the answer short and emphasize that broad suppression makes future bad patterns invisible.",
+                      "Broad allow rules hide both the current warning and similar future regressions, so the codebase loses signal right where the team wanted safety feedback. It is safer to suppress a specific lint narrowly or fix the root cause.",
+                      "note_clippy_allow"),
+    ])
+
+    rust_doc_items = [
+        ("std::mem::take", "Look up std::mem::take in the docs tool.", "Explain what it does briefly.", "Use one tool call, then summarize the behavior and Default requirement.", "std::mem::take", "Replaces a value behind a mutable reference with Default::default() and returns the previous value.", "Use the doc wording directly and mention the Default requirement.", "std::mem::take replaces the value behind a mutable reference with Default::default() and returns the old value, so the type must implement Default."),
+        ("Option::take", "Look up Option::take in the docs tool.", "Explain what it does briefly.", "Use one tool call, then summarize the move-out behavior.", "Option::take", "Takes the value out of the option, leaving None in its place.", "State that it moves the contents out and leaves None behind.", "Option::take moves the current value out of an Option and leaves None behind, which is handy for taking ownership from a field safely."),
+        ("Iterator::fold", "Look up Iterator::fold in the docs tool.", "Explain the accumulator behavior briefly.", "Use one tool call, then summarize the fold contract.", "Iterator::fold", "Takes an initial accumulator and applies a closure to the accumulator and each element to produce one final value.", "Describe fold as repeated accumulation into one value.", "Iterator::fold reduces an iterator to one final value by repeatedly applying a closure to an accumulator, starting from an initial value."),
+        ("Vec::with_capacity", "Look up Vec::with_capacity in the docs tool.", "Explain its effect on allocation briefly.", "Use one tool call, then summarize capacity versus length.", "Vec::with_capacity", "Creates a new, empty Vec with at least the specified capacity.", "Point out that length stays zero while capacity is preallocated.", "Vec::with_capacity creates an empty vector with preallocated space for at least that many elements, which can reduce reallocations; the length is still zero until you push items."),
+        ("std::borrow::Cow", "Look up std::borrow::Cow in the docs tool.", "Explain owned versus borrowed behavior briefly.", "Use one tool call, then summarize clone-on-write semantics.", "std::borrow::Cow", "A clone-on-write smart pointer that can hold borrowed or owned data and clones into owned form only when needed.", "Explain that it avoids allocation until mutation or ownership is required.", "Cow lets APIs accept either borrowed or owned data without forcing an allocation up front; it only clones into owned data if mutation or ownership is needed."),
+        ("AsRef", "Look up AsRef in the docs tool.", "Explain the reference-conversion role briefly.", "Use one tool call, then summarize the cheap conversion behavior.", "AsRef", "A trait for cheap reference-to-reference conversion via as_ref(&self) -> &T.", "Describe it as a lightweight borrowed conversion trait.", "AsRef is a trait for cheap borrowed conversion: it lets a value be viewed as a reference to another type, which is useful for accepting flexible input types without allocating."),
+        ("Box::pin", "Look up Box::pin in the docs tool.", "Explain why pinning matters briefly.", "Use one tool call, then summarize the heap pinning behavior.", "Box::pin", "Allocates a value on the heap and pins it so it will not move.", "Mention that pinning is useful when movement would break invariants.", "Box::pin places a value on the heap and pins it so it can no longer move, which is useful for async or self-referential patterns that rely on stable addresses."),
+        ("std::mem::drop", "Look up std::mem::drop in the docs tool.", "Explain what happens to the value briefly.", "Use one tool call, then summarize the ownership-taking behavior.", "std::mem::drop", "Takes ownership of a value and runs its destructor immediately.", "State that drop consumes the value and runs Drop now rather than later.", "std::mem::drop takes ownership of a value and runs its destructor immediately, so the value is consumed and cannot be used afterward."),
+        ("BTreeMap", "Look up BTreeMap in the docs tool.", "Explain when it is preferable briefly.", "Use one tool call, then summarize the ordering tradeoff.", "BTreeMap", "Keeps keys ordered and is useful for range queries and deterministic iteration.", "Tie the recommendation to key ordering and range access.", "Choose BTreeMap when key ordering or range queries matter more than average-case hash lookup speed, since it maintains keys in sorted order."),
+        ("tokio::sync::Mutex", "Look up tokio::sync::Mutex in the docs tool.", "Explain the async-specific caveat briefly.", "Use one tool call, then summarize the executor-friendly behavior.", "tokio::sync::Mutex", "An async-aware mutex whose lock is acquired with .await; avoid holding the guard across unrelated awaits for long periods.", "Highlight that it coordinates async tasks without blocking the thread.", "tokio::sync::Mutex is an async-aware mutex for coordinating mutable access in async code; it avoids blocking the thread, but you should still keep lock guards short-lived."),
+    ]
+    for symbol, todo1, todo2, rationale, arg_symbol, result_data, think, response in rust_doc_items:
+        traces.append(
+            single_tool_trace(
+                "You are a Rust documentation assistant who answers briefly and precisely.",
+                rustdoc,
+                f"In Rust, what does {symbol} do? Use the docs tool." if symbol not in {"BTreeMap", "AsRef", "tokio::sync::Mutex"} else (
+                    "When would you choose BTreeMap over HashMap in Rust? Use the docs tool." if symbol == "BTreeMap" else
+                    "What does the trait AsRef do in Rust? Use the docs tool." if symbol == "AsRef" else
+                    "What should I remember about tokio::sync::Mutex in async Rust? Use the docs tool."
+                ),
+                [todo1, todo2],
+                rationale,
+                "rustdoc_lookup",
+                [("symbol", arg_symbol)],
+                "res1",
+                result_data,
+                think,
+                "note1",
+                response,
+            )
+        )
+
+    rust_debug_items = [
+        ("My Rust crate fails to compile after I changed a function to use `?` on a `Result`. I’m not sure what trait or type I need to add to make error conversion work.",
+         "cargo check: error[E0277]: `?` couldn't convert the error to `MyError`; the trait `From<std::io::Error>` is not implemented for `MyError`.",
+         "FromResidual",
+         "For Result, `?` requires a conversion path from the source error into the function's return error type, commonly via `From<E>`.",
+         "The compiler is telling you that `?` needs to turn `std::io::Error` into `MyError`, but no conversion exists. Fix it by implementing `From<std::io::Error> for MyError`, changing the function’s return type to one that already accepts that error, or wrapping the call with an explicit map_err."),
+        ("My Rust project fails to compile after I changed a function to return an iterator. The error says it cannot return a value referencing a local variable.",
+         "cargo check: error[E0515]: cannot return value referencing local variable `v`; use `.into_iter()` to return an iterator that owns its items, or move the owned value out.",
+         "impl Trait return lifetime iterator",
+         "This usually means the iterator borrows from a local value that will be dropped before the caller can use it.",
+         "You are probably returning an iterator that borrows from a local collection, so the borrow would outlive the collection. A clean fix is to return an owning iterator (for example via `into_iter()`), return the owned collection instead, or make the iterator borrow from data owned by the caller instead of a local temporary."),
+        ("My Rust crate started failing tests with a borrow checker error around iterators. Tests are flaky locally. Can you quickly triage and suggest the most likely fix direction?",
+         "error[E0502]: cannot borrow `items` as mutable because it is also borrowed as immutable; the loop iterates items.iter() and then calls items.push(...).",
+         "Iterator::iter",
+         "The compiler output already points to mutating a collection while iterating it immutably.",
+         "The likely issue is mutating the same collection while holding an immutable iterator over it. Fix direction: collect the new values separately, iterate over a cloned snapshot, or restructure the loop so mutation happens after iteration instead of inside it."),
+        ("My tests hang in CI and I suspect a deadlock around Mutex + async. Clippy isn’t available here—what should I check and how can I narrow it down quickly?",
+         "Error: cargo clippy unavailable on this toolchain",
+         "tokio::sync::Mutex",
+         "Use one docs fallback and then give concrete checks about locks held across await points.",
+         "First check whether any task holds a mutex guard across an `.await`, because that is a common async deadlock pattern. Then look for inconsistent lock ordering and blocking calls inside critical sections; if you can, add logging around lock acquisition/release to find the task that never lets go."),
+        ("My Rust helper won’t compile after I tried to store different iterator types in one Vec. What’s going on and what’s a clean fix?",
+         "cargo check: error[E0308]: expected `Map<_, _>`, found `Filter<_, _>` when pushing into `Vec`; each iterator adapter has a distinct concrete type.",
+         "dyn Iterator",
+         "Explain that iterator adapters have different concrete types even if they share the same trait.",
+         "You are trying to store different concrete iterator adapter types in one Vec, but each adapter has its own distinct type. A clean fix is to box them as `Box<dyn Iterator<Item = T>>`, use an enum wrapper if the set is fixed, or collect to concrete data before storing."),
+        ("My Rust unit test fails after sorting a Vec<f32>; it expects stable ordering when values are equal or NaN. What’s going on and what’s a clean fix?",
+         "test panic: comparator uses `a.partial_cmp(b).unwrap()`; Expected NaNs at end and stable order for equal values.",
+         "slice::sort_by / f32::total_cmp",
+         "Point out that NaN breaks partial_cmp-based assumptions and total ordering must be explicit.",
+         "The problem is that `f32::partial_cmp` returns None for NaN, so unwrapping it is invalid and the comparator is not a total order. Use `total_cmp` for deterministic float ordering, and if equal-value stability matters, use a stable sort or add a tie-breaker key."),
+        ("My Rust crate won’t compile after I tried to store a closure capturing a local reference in a struct for later use. Explain what’s wrong and how to fix it.",
+         "cargo check: error[E0597]: `local` does not live long enough; closure may outlive the current function, but it borrows `local`.",
+         "FnOnce + 'static",
+         "Explain that the closure outlives the borrowed local and must own its captures or be tied to a shorter lifetime.",
+         "The closure is trying to outlive a borrowed local reference, so the compiler rejects it. Fix it by moving owned data into the closure, parameterizing the struct with an explicit lifetime if the borrow truly must be external, or redesigning the API so the closure does not escape the scope of the borrowed value."),
+        ("My Rust function returns a reference to a local String and now the compiler complains. What is it objecting to and what is the right fix?",
+         "cargo check: error[E0515]: cannot return reference to local variable `s`.",
+         "lifetime elision",
+         "Keep the explanation focused on returning a borrow to data that will be dropped at function exit.",
+         "The compiler is objecting because the returned reference would point to a local value that is destroyed when the function returns. The fix is to return an owned `String`, borrow from caller-owned data instead, or redesign the API so the referenced data lives long enough."),
+        ("Clippy is failing in CI with an error about an unknown lint name; the clippy tool might be unavailable. Give concise guidance.",
+         "Error: cargo clippy output unavailable",
+         "unknown_lints",
+         "Use one docs fallback and explain the common version-mismatch cause.",
+         "An unknown lint name usually means a Clippy/Rust version mismatch or a renamed/removed lint. Check the toolchain version used in CI, update or remove the stale lint name, and only use `allow(unknown_lints)` as a temporary unblock while you align versions."),
+        ("My Rust CLI parses args with clap and fails to compile after I added a `Vec<&str>` field to the config struct. Diagnose the likely issue and give a concise fix.",
+         "cargo check: error[E0106]: missing lifetime specifier; error[E0521]: borrowed data escapes outside of function when returning `Vec<&str>` from clap parsing.",
+         "clap derive String vs &str",
+         "Explain that clap-parsed values should generally be stored as owned Strings rather than borrowed &str fields.",
+         "The likely issue is that your config struct is trying to store borrowed strings from parsing, but those borrows do not outlive the parsing scope. Use `Vec<String>` (or another owned type like `PathBuf`) in the config instead of `Vec<&str>` unless you are explicitly threading lifetimes through the whole type."),
+    ]
+    for i, (user, check_result, doc_symbol, think, response) in enumerate(rust_debug_items):
+        traces.append(
+            multi_tool_trace(
+                "You are a Rust debugging assistant who diagnoses compiler and tool output concisely.",
+                cargo,
+                user,
+                [
+                    "Get the primary diagnostic or tool output for the failure.",
+                    "Use one targeted docs lookup if it sharpens the fix.",
+                    "Give a concise diagnosis and repair direction.",
+                ],
+                "Use one concrete tool result, optionally one supporting lookup, then answer without extra loops.",
+                "cargo_check" if "compile" in user or "compiler" in user or "Clippy" not in user and "tests hang" not in user and "unit test fails" not in user else ("cargo_clippy" if "Clippy" in user or "clippy" in user else "cargo_test"),
+                [("crate_path", "./")] if "filter" not in check_result else [("crate_path", "./"), ("filter", "sort_floats")],
+                "step1",
+                check_result,
+                think,
+                "note1",
+                "rustdoc_lookup",
+                [("symbol", doc_symbol)],
+                "step2",
+                f"rustdoc: {doc_symbol} guidance relevant to this failure.",
+                "The tool outputs are enough to anchor a short fix direction; stop after the answer.",
+                "note2",
+                response,
+            )
+        )
+
+    ci_items = [
+        ("Our nightly integration tests started timing out in the container startup phase. What should I check first?",
+         "Error: CI log service unavailable",
+         "test-runner",
+         "Cached incident note: timeouts commonly occur when the container never becomes ready due to a failing healthcheck or slow image pull from the registry.",
+         "Check container readiness first: image pull latency/auth, the startup healthcheck itself, and any recent CPU or memory limit changes that would delay boot. This recommendation is based on the cached incident note because live logs were unavailable."),
+        ("Our deploy pipeline started failing at the unit-tests stage after a dependency bump. What should I check first?",
+         "Run: 18422; FAIL: Cannot find module `left-pad` in test/bootstrap.js after dependency bump.",
+         "Cannot find module left-pad",
+         "1 match: repo/test/bootstrap.js imports `left-pad` directly.",
+         "Start with the first failing import in the unit-test logs: the dependency bump likely changed a package name or entrypoint. Check the import in test/bootstrap.js, verify the lockfile changed consistently, and pin or revert the bump if you need a quick unblock."),
+        ("Our integration tests intermittently time out only on main branch runs. What should we look at first?",
+         "Error: CI log service unavailable",
+         "ci",
+         "Cached incident note: main-branch timeouts frequently traced to runner pool saturation and occasional DNS failures during dependency setup.",
+         "First check whether main runs are landing on more saturated runners or a different runner class, then verify DNS/network reliability during dependency setup. The main-only pattern makes infrastructure skew more likely than a deterministic test bug."),
+        ("Our deploys to staging fail intermittently with a permission denied error. Where should we look first?",
+         "Staging deploy job failed while fetching secret staging/DB_PASSWORD; runner role missing `secrets.read`.",
+         "staging-deploy",
+         "Cached incident note: similar failures came from a policy rollout that removed secret read access in one namespace.",
+         "Look first at the deploy runner’s IAM or service-account permissions for the secrets backend. The logs already point to denied secret access, so confirm the runner role and namespace policy before investigating app code."),
+        ("Our nightly pipeline started failing after a merge, but reruns usually pass. What should I check first?",
+         "Error: CI log service returned 503",
+         "pipeline",
+         "Cached incident note: flaky nightly failures that pass on rerun are frequently caused by transient dependency resolution or external registry hiccups.",
+         "Check whether the failure happens during dependency or artifact fetches and whether versions are pinned. If reruns usually pass, transient external fetches or unpinned dependencies are a stronger first suspect than deterministic code regressions."),
+    ]
+    for user, log_result, service, cache_result, response in ci_items:
+        traces.append(
+            multi_tool_trace(
+                "You are a debugging assistant who keeps incident analysis concise and resilient to tool failure.",
+                ci_tools,
+                user,
+                [
+                    "Pull the most relevant recent logs or failure output.",
+                    "Use one fallback source only if the primary source fails or is insufficient.",
+                    "Provide the first concrete investigation angle.",
+                ],
+                "Start with direct evidence, use one fallback at most, then answer succinctly.",
+                "get_ci_logs",
+                [("run_id", "main-failing-run-18422" if "main" in user else "nightly-failing-run-18422")],
+                "logs1",
+                log_result,
+                "If live logs fail or are too thin, use one fallback source to avoid over-searching.",
+                "note_logs",
+                "fetch_cached_incident" if "Cannot find module" not in log_result else "code_search",
+                [("service", service)] if "Cannot find module" not in log_result else [("query", "left-pad")],
+                "aux1",
+                cache_result,
+                "Use the second tool result to sharpen one focused next step, then stop.",
+                "note_aux",
+                response,
+            )
+        )
+
+    misc = [
+        single_tool_trace("You are a data access assistant who uses SQL and answers briefly.", sql_tools,
+                          "How many paid subscriptions were canceled yesterday?",
+                          ["Query the cancellation count.", "Answer with the count briefly."],
+                          "Use one SQL query, then respond with the returned count.",
+                          "run_sql", [("query", "SELECT COUNT(*) AS canceled_paid_subscriptions_yesterday FROM subscriptions WHERE status = 'canceled' AND plan_type = 'paid' AND canceled_at >= CURRENT_DATE - INTERVAL '1 day' AND canceled_at < CURRENT_DATE;")],
+                          "res1", "Query result: canceled_paid_subscriptions_yesterday = 42.",
+                          "The SQL result already contains the exact number needed for the answer.", "note1",
+                          "There were 42 paid subscriptions canceled yesterday."),
+        single_tool_trace("You are a calculation assistant who returns precise numeric answers with a short explanation.", [tool("calculator", "Evaluates a math expression.", param("expression", "string", "Expression to evaluate"))],
+                          "A jacket was $120, now it’s $90. What percent discount is that? Use the calculator.",
+                          ["Compute the percent discount.", "Answer with the percentage briefly."],
+                          "Use the calculator once, then state the computed percentage.",
+                          "calculator", [("expression", "((120-90)/120)*100")], "res1", "((120-90)/120)*100 = 25",
+                          "Convert the calculator result into a concise percent statement.", "note1",
+                          "The discount is 25%."),
+        multi_tool_trace("You are a helpful assistant specialized in symbolic mathematics. Provide clear, concise solutions.", math_tools,
+                         "Compute the indefinite integral of (x^3 - 2*x)/(x^2 + 1). Verify it by differentiation and keep the answer concise.",
+                         ["Compute an antiderivative.", "Verify it by differentiation.", "State the final answer briefly."],
+                         "Use one symbolic solve step, one derivative check, then stop.",
+                         "solve_symbolic", [("expression", "(x^3 - 2*x)/(x^2 + 1)"), ("operation", "integrate"), ("variable", "x")], "int1",
+                         "Computed antiderivative: (x^2 - 3*ln(x^2 + 1))/2 + C",
+                         "The antiderivative is already compact; verify it directly rather than adding extra steps.", "note1",
+                         "derivative_check", [("candidate_antiderivative", "(x^2 - 3*ln(x^2 + 1))/2"), ("target_expression", "(x^3 - 2*x)/(x^2 + 1)"), ("variable", "x")], "chk1",
+                         "Derivative matches the target exactly.",
+                         "The derivative check confirms correctness, so the final answer can stay short.", "note2",
+                         "Antiderivative: (x^2 - 3 ln(x^2 + 1))/2 + C. The derivative check matches the integrand exactly."),
+        single_tool_trace("You are a document assistant who reads a file and returns a short, concrete summary.", file_tools,
+                          "Open /docs/q3_launch_postmortem.md and summarize the main takeaways and action items.",
+                          ["Load the requested document excerpt.", "Summarize the main takeaways and action items."],
+                          "Use the file tool once, then condense the excerpt into a short summary.",
+                          "load_file", [("path", "/docs/q3_launch_postmortem.md")], "res1",
+                          "Excerpt: Launch slipped 2 weeks due to late scope changes and unclear ownership. Incident detection lagged because dashboards lacked error-rate alerts. Action items: scope freeze, one DRI per workstream, pre-launch load testing, expanded dashboards and an on-call runbook.",
+                          "Extract the delay cause, monitoring gap, and concrete action items into one tight summary.", "note1",
+                          "Main takeaways: late scope changes and unclear ownership delayed the launch, and weak alerting slowed incident detection. Action items: add scope freeze/change control, assign one DRI per workstream, run pre-launch load tests, and strengthen dashboards plus the on-call runbook."),
+        multi_tool_trace("You are a planning assistant that helps product teams build realistic launch plans and concise schedules.", plan_tools,
+                         "We need a 3-week rollout plan for an in-app onboarding checklist update. Pull major tasks, confirm the team can staff it, and keep it concise.",
+                         ["Check team availability for the 3-week window.", "Generate a baseline work breakdown.", "Provide a concise schedule recommendation."],
+                         "Get staffing first, then a minimal work breakdown, then summarize feasibility.",
+                         "get_availability", [("team_list", "ava,ben,chen,dina"), ("start_date", "2026-07-06"), ("end_date", "2026-07-26")], "avail1",
+                         "Availability: ava 60%, ben 40%, chen 70%, dina 50% for the 3-week window.",
+                         "Availability looks workable; now get a minimal breakdown sized to the short timeline.", "note1",
+                         "create_project_plan", [("project_name", "in-app onboarding checklist update"), ("objectives", "ship updated checklist copy, triggers, analytics, and QA"), ("timeline_weeks", "3")], "plan1",
+                         "Plan ID plan_onb_v1: requirements and copy, trigger logic, UI updates, analytics events, QA and rollout.",
+                         "With staffing and tasks in hand, give a simple sequencing recommendation instead of adding more tool steps.", "note2",
+                         "The team can likely cover this in 3 weeks if work starts with requirements/copy, then trigger logic and UI in parallel, followed by analytics wiring and a short QA/rollout window."),
+        multi_tool_trace("You are a Git assistant who gives compact, practical guidance.", git_tools,
+                         "My PR branch won't push because it says non-fast-forward. I don't want to lose my local commits. What should I do?",
+                         ["Inspect repo state to confirm divergence.", "Inspect recent history to understand local vs remote commits.", "Provide a safe integration sequence that preserves local work."],
+                         "Check branch state, check recent commits, then recommend a safe rebase-or-merge path.",
+                         "git_status", [("repo_path", "./")], "st1",
+                         "On branch feature/pr-42. Your branch and origin/feature/pr-42 have diverged, and have 3 and 2 different commits each. Working tree clean.",
+                         "The branch has diverged, so check recent local and remote commits before recommending the next command.", "note1",
+                         "git_log", [("repo_path", "./"), ("limit", "8")], "log1",
+                         "local HEAD: abc1234 Add validation for empty inputs; bcd2345 Refactor request parsing. origin/feature/pr-42: def4567 Fix CI by pinning action versions; efg5678 Adjust lint config.",
+                         "With divergence confirmed, recommend fetch plus rebase as the safest default when local commits must be preserved.", "note2",
+                         "Fetch the remote branch, then rebase your local commits on top of it so you keep your work while integrating the remote changes. If conflicts appear, resolve them commit by commit, run tests, then push the rebased branch (usually with --force-with-lease)."),
+    ]
+    traces.extend(misc)
+
+    traces.extend([
+        no_tool_trace("You are a Rust language assistant who gives concise ownership explanations.",
+                      "Why does `collect::<Vec<_>>()` sometimes fix type inference errors in Rust?",
+                      "Explain why adding a concrete collection type can resolve inference ambiguity.",
+                      "Connect the fix to the compiler needing a concrete destination type.",
+                      "State that collect needs to know what collection to build, and explicit type information removes the ambiguity.",
+                      "Adding `collect::<Vec<_>>()` gives the compiler a concrete target collection type, which resolves ambiguity when it cannot infer what `collect` should produce from context alone.",
+                      "note_collect_vec"),
+        no_tool_trace("You are a Rust API design assistant who answers briefly.",
+                      "Why is `String` usually a better struct field type than `&str` in application config types?",
+                      "Explain why owned strings are usually safer in config structs.",
+                      "Tie the answer to lifetime simplicity and ownership boundaries.",
+                      "Keep it focused on config values often needing to outlive the parsing context.",
+                      "String is usually better because config structs often need to own their data after parsing, serialization, or movement across layers. Using `&str` pushes lifetimes through the whole type and is only worth it when you clearly have long-lived backing storage.",
+                      "note_string_field"),
+        single_tool_trace("You are a Rust documentation assistant who answers briefly and precisely.", rustdoc,
+                          "In Rust, what does `Iterator::collect` do? Use the docs tool.",
+                          ["Look up Iterator::collect in the docs tool.", "Explain it briefly."],
+                          "Use the docs tool once, then summarize the behavior and type requirement.",
+                          "rustdoc_lookup", [("symbol", "Iterator::collect")], "res1",
+                          "Transforms an iterator into a collection or other type that implements FromIterator.",
+                          "State that collect consumes the iterator and needs a destination type implementing FromIterator.", "note1",
+                          "Iterator::collect consumes an iterator and builds a target type from it, as long as that target implements FromIterator."),
+        single_tool_trace("You are a Rust documentation assistant who answers briefly and precisely.", rustdoc,
+                          "What does `HashMap::entry` help with in Rust? Use the docs tool.",
+                          ["Look up HashMap::entry in the docs tool.", "Explain its main use briefly."],
+                          "Use the docs tool once, then summarize the lookup-or-insert pattern.",
+                          "rustdoc_lookup", [("symbol", "HashMap::entry")], "res1",
+                          "Provides in-place manipulation of a value in the map for a given key, including insert-if-missing patterns.",
+                          "Describe entry as the API for update-or-insert without double lookup.", "note1",
+                          "HashMap::entry lets you inspect, insert, or update a key in one pass, which is especially useful for counters and insert-if-missing logic."),
+        single_tool_trace("You are a data access assistant who uses SQL and answers briefly.", sql_tools,
+                          "What percentage of new signups in the last 30 days came from organic search?",
+                          ["Query total signups and organic-search signups.", "Compute and report the percentage briefly."],
+                          "Use one SQL query, then state the computed share.",
+                          "run_sql", [("query", "SELECT COUNT(*) AS total_signups, SUM(CASE WHEN acquisition_channel = 'organic_search' THEN 1 ELSE 0 END) AS organic_signups FROM signups WHERE created_at >= (CURRENT_DATE - INTERVAL '30 days');")],
+                          "res1", "Query result: total_signups=4120, organic_signups=1175.",
+                          "Convert the totals into a percentage and present it briefly.", "note1",
+                          "Organic search accounts for 28.5% of new signups over the last 30 days."),
+        single_tool_trace("You are a calculation assistant who returns precise numeric answers with a short explanation.", [tool("calculator", "Evaluates a math expression.", param("expression", "string", "Expression to evaluate"))],
+                          "Revenue grew from $420k to $693k. What is the percentage increase? Use the calculator.",
+                          ["Compute the percentage increase.", "Report the increase briefly."],
+                          "Use the calculator once, then translate the result into a concise percentage statement.",
+                          "calculator", [("expression", "((693-420)/420)*100")], "res1", "((693-420)/420)*100 = 65.00",
+                          "State the increase directly from the calculator output without extra filler.", "note1",
+                          "The revenue increase is 65.00%."),
+        multi_tool_trace("You are a helpful assistant specialized in symbolic mathematics. Provide clear, concise solutions.", math_tools,
+                         "Differentiate x^4 * ln(x), then verify the derivative by a second tool step and keep the answer concise.",
+                         ["Differentiate the expression.", "Verify the derivative by a second tool step.", "State the final derivative briefly."],
+                         "Use one differentiation step, one verification step, then stop.",
+                         "solve_symbolic", [("expression", "x^4 * ln(x)"), ("operation", "differentiate"), ("variable", "x")], "d1",
+                         "Computed derivative: 4*x^3*ln(x) + x^3",
+                         "The derivative result is already simple; verify it rather than adding another transform.", "note1",
+                         "derivative_check", [("candidate_antiderivative", "(x^4*ln(x))"), ("target_expression", "4*x^3*ln(x) + x^3"), ("variable", "x")], "chk1",
+                         "Differentiating x^4*ln(x) yields 4*x^3*ln(x) + x^3.",
+                         "The verification matches, so the final answer can just state the derivative cleanly.", "note2",
+                         "The derivative is 4x^3 ln(x) + x^3."),
+        single_tool_trace("You are a document assistant who reads a file and returns a short, concrete summary.", file_tools,
+                          "Open /docs/security_audit_apr.md and summarize the top three findings.",
+                          ["Load the requested document excerpt.", "Summarize the top findings briefly."],
+                          "Use the file tool once, then condense the excerpt into a short findings summary.",
+                          "load_file", [("path", "/docs/security_audit_apr.md")], "res1",
+                          "Excerpt: incomplete MFA enforcement for legacy admin accounts, critical dependencies missing recent security patches, and gaps in centralized logging/alerting that hinder incident response.",
+                          "Extract the three concrete findings directly and keep the wording brief.", "note1",
+                          "Top findings: MFA is incomplete for legacy admin accounts, critical dependencies are behind on security patches, and centralized logging/alerting is too weak for reliable incident response."),
+        multi_tool_trace("You are a planning assistant that helps product teams build realistic launch plans and concise schedules.", plan_tools,
+                         "We need a 4-week launch plan for a billing export CSV improvement. Check team availability, generate the task breakdown, and keep the final recommendation concise.",
+                         ["Check team availability for the 4-week window.", "Generate the task breakdown.", "Provide a concise schedule recommendation."],
+                         "Get staffing first, then a baseline task breakdown, then stop with a short recommendation.",
+                         "get_availability", [("team_list", "maya,liam,noor,oscar"), ("start_date", "2026-08-04"), ("end_date", "2026-09-01")], "avail1",
+                         "Availability: maya 70%, liam 50%, noor 80%, oscar 40% for the 4-week window.",
+                         "Availability is enough to scope the next planning step; now get a compact work breakdown.", "note1",
+                         "create_project_plan", [("project_name", "billing export CSV improvement"), ("objectives", "fix column consistency, header naming, duplicate handling, and rollout docs"), ("timeline_weeks", "4")], "plan1",
+                         "Plan ID plan_csv_v1: requirements and field audit, export generator changes, duplicate handling, QA with sample customers, rollout docs.",
+                         "With staffing and tasks available, the final answer should just recommend a simple sequence.", "note2",
+                         "The team can likely deliver this in 4 weeks by starting with requirements and field audit, then export-generator changes, followed by duplicate handling, QA, and a short rollout-docs finish.")
+    ])
+
+    assert len(traces) == 50, len(traces)
+    return traces
+
+
+def main() -> int:
+    traces = records()
+    bad: list[tuple[int, list[str]]] = []
+    with OUT.open("w") as f:
+        for i, trace in enumerate(traces, start=1):
+            res = validate_trace(trace)
+            if not res.valid:
+                bad.append((i, res.errors))
+            f.write(json.dumps({"trace": trace}, ensure_ascii=False) + "\n")
+    print(json.dumps({"count": len(traces), "output": str(OUT), "invalid": bad}, indent=2))
+    return 0 if not bad else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

build_gold_rust_tooluse.py

@@ -0,0 +1,1076 @@
+#!/usr/bin/env python3
+"""SFT extension: traces for the full RL Rust toolset.
+
+Adds gold examples of:
+  read_file → response (inspect a file)
+  read_file → apply_patch → cargo_test → response (lib bug fix)
+  read_file → apply_patch → cargo_run → response (bin bug fix)
+  cargo_check / cargo_build / cargo_test / cargo_run / rustc — single-tool
+
+The output appends to gold_glyph_3000.jsonl so the next SFT run sees the
+correct schema for tools the original SFT pool didn't cover (`apply_patch`,
+`read_file`, `cargo_build`, `cargo_run`, `rustc`). Format follows the
+build_gold50 helpers strictly so docs/glyph.md invariants hold.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import build_gold50 as g  # noqa: E402
+from core.validator import validate_trace  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Tool defs — must match rl/rust/tools.py exactly so the model learns the
+# right schema (file_path/find/replace for apply_patch, not source_file/source).
+# ---------------------------------------------------------------------------
+
+def rust_dev_tools():
+    return [
+        g.tool("read_file",
+               "Reads a file from disk and returns its contents.",
+               g.param("file_path", "string", "Path to the file to read")),
+        g.tool("apply_patch",
+               "Applies a textual find/replace edit to a single file. 'find' must occur exactly once.",
+               g.param("file_path", "string", "Path to the file to edit"),
+               g.param("find", "string", "Exact text snippet to locate"),
+               g.param("replace", "string", "Replacement text")),
+        g.tool("cargo_check",
+               "Runs cargo check to verify code compiles without producing a binary.",
+               g.param("project_path", "string", "Cargo project directory")),
+        g.tool("cargo_build",
+               "Compiles the Cargo project into binaries.",
+               g.param("project_path", "string", "Cargo project directory")),
+        g.tool("cargo_test",
+               "Runs the test suite for a Cargo project.",
+               g.param("project_path", "string", "Cargo project directory")),
+        g.tool("cargo_run",
+               "Builds and runs the binary of a Cargo project, returning its stdout.",
+               g.param("project_path", "string", "Cargo project directory")),
+        g.tool("rustc",
+               "Compiles a single Rust source file to an executable.",
+               g.param("source_file", "string", "Source file"),
+               g.param("output", "string", "Output binary path", required=False)),
+    ]
+
+
+SYSTEM = "You are a Rust engineering assistant. Use the available tools to inspect and verify code, then answer briefly."
+
+
+# ---------------------------------------------------------------------------
+# Trace builders for multi-step workflows (3+ calls).
+# Mirrors single_tool_trace / multi_tool_trace from build_gold50 but extends
+# to 3 sequential calls (read → patch → verify).
+# ---------------------------------------------------------------------------
+
+def three_tool_trace(user, todos, rationale,
+                     c1_tool, c1_args, c1_id, r1, t1, tag1,
+                     c2_tool, c2_args, c2_id, r2, t2, tag2,
+                     c3_tool, c3_args, c3_id, r3, t3, tag3,
+                     response):
+    """assistant → tool → assistant → tool → assistant → tool → assistant(response)"""
+    return g.join_trace(
+        g.system_seg(SYSTEM, rust_dev_tools()),
+        g.user_seg(user),
+        g.assistant_seg(g.plan_block(todos, rationale),
+                        g.call_act(c1_tool, c1_args, c1_id, 1)),
+        g.result_seg(r1, c1_id),
+        g.assistant_seg(g.think_act([(t1, tag1, [c1_id])]),
+                        g.call_act(c2_tool, c2_args, c2_id, 2)),
+        g.result_seg(r2, c2_id),
+        g.assistant_seg(g.think_act([(t2, tag2, [c1_id, c2_id])]),
+                        g.call_act(c3_tool, c3_args, c3_id, 3)),
+        g.result_seg(r3, c3_id),
+        g.assistant_seg(g.think_act([(t3, tag3, [c2_id, c3_id])]),
+                        g.response_block(response, [c1_id, c2_id, c3_id, tag3], 4)),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Concrete bug-fix lib traces: read_file → apply_patch → cargo_test → respond.
+# These mirror the rl/rust/prepare_cases.py BUGFIX_CASES so the SFT model
+# sees the exact workflow the RL env expects.
+# ---------------------------------------------------------------------------
+
+LIB_BUGFIX_CASES = [
+    # (crate, buggy_lib_src, find, replace, fix_summary)
+    ("addlib_bug",
+     "pub fn add(a: i32, b: i32) -> i32 { a - b }",
+     "a - b", "a + b",
+     "Subtraction was used where addition is required; replacing it makes the test pass."),
+    ("mullib_bug",
+     "pub fn mul(a: i32, b: i32) -> i32 { a + b }",
+     "a + b", "a * b",
+     "Addition was used where multiplication is required; the corrected operator matches the test."),
+    ("evenlib_bug",
+     "pub fn is_even(n: i32) -> bool { n % 2 == 1 }",
+     "n % 2 == 1", "n % 2 == 0",
+     "The remainder check was inverted; comparing against 0 returns the correct parity."),
+    ("absnumlib_bug",
+     "pub fn abs_v(n: i32) -> i32 { n }",
+     "pub fn abs_v(n: i32) -> i32 { n }",
+     "pub fn abs_v(n: i32) -> i32 { n.abs() }",
+     "The function returned the input unchanged; applying .abs() yields the absolute value."),
+    ("factlib_bug",
+     "pub fn fact(n: u32) -> u32 { (1..n).product::<u32>().max(1) }",
+     "1..n", "1..=n",
+     "The exclusive range skipped n; using an inclusive range gives the correct factorial."),
+    ("revstrlib_bug",
+     "pub fn rev(s: &str) -> String { s.chars().collect() }",
+     "s.chars().collect()", "s.chars().rev().collect()",
+     "The chars iterator wasn't reversed; calling .rev() before collecting fixes the result."),
+    ("maxlib_bug",
+     "pub fn max_of(s: &[i32]) -> i32 { *s.iter().min().unwrap_or(&0) }",
+     "s.iter().min()", "s.iter().max()",
+     "Selecting min instead of max; swapping the iterator method gives the expected value."),
+    ("sumlib_bug",
+     "pub fn sum(s: &[i32]) -> i32 { s.iter().product() }",
+     "s.iter().product()", "s.iter().sum()",
+     "Iterator product was used where sum is required; switching makes the test pass."),
+    ("fiblib_bug",
+     "pub fn fib(n: u32) -> u32 { match n { 0 => 1, 1 => 1, _ => fib(n-1) + fib(n-2) } }",
+     "0 => 1", "0 => 0",
+     "fib(0) was returning 1; correcting the base case to 0 matches the standard sequence."),
+    ("palinlib_bug",
+     "pub fn pal(s: &str) -> bool { let r: String = s.chars().collect(); r == s }",
+     "s.chars().collect()", "s.chars().rev().collect()",
+     "The string wasn't reversed before the equality check; adding .rev() makes palindrome detection work."),
+    ("vowelslib_bug",
+     "pub fn vowels(s: &str) -> usize { s.chars().filter(|c| \"bcdfg\".contains(*c)).count() }",
+     "\"bcdfg\"", "\"aeiouAEIOU\"",
+     "The filter set listed consonants; using the vowels set returns the correct count."),
+    ("gcdlib_bug",
+     "pub fn gcd(a: u32, b: u32) -> u32 { if b == 0 { b } else { gcd(b, a % b) } }",
+     "if b == 0 { b }", "if b == 0 { a }",
+     "The base case returned 0 instead of a; correcting it makes the recursion terminate with the right value."),
+    # --- extended lib bug families (math, comparison, range, iterators, strings, control flow)
+    ("sublib_bug",
+     "pub fn sub(a: i32, b: i32) -> i32 { a + b }",
+     "a + b", "a - b",
+     "Addition was used in place of subtraction; switching the operator restores the difference."),
+    ("divlib_bug",
+     "pub fn div(a: i32, b: i32) -> i32 { a * b }",
+     "a * b", "a / b",
+     "Multiplication was used where integer division is required; the operator fix is enough."),
+    ("modlib_bug",
+     "pub fn rem(a: i32, b: i32) -> i32 { a / b }",
+     "a / b", "a % b",
+     "Division was used where remainder is needed; switching to % matches the expected result."),
+    ("powerlib_bug",
+     "pub fn cube(n: i64) -> i64 { n.pow(2) }",
+     "n.pow(2)", "n.pow(3)",
+     "The exponent was 2 instead of 3; raising to the third power matches the intended cube."),
+    ("doublelib_bug",
+     "pub fn doubled(n: i32) -> i32 { n + n + 1 }",
+     "n + n + 1", "n + n",
+     "An off-by-one term was added; removing it yields the correct doubling."),
+    ("halflib_bug",
+     "pub fn half(n: i32) -> i32 { n * 2 }",
+     "n * 2", "n / 2",
+     "Multiplication by 2 produced double rather than half; switching to division returns the correct value."),
+    ("inclib_bug",
+     "pub fn inc(n: i32) -> i32 { n - 1 }",
+     "n - 1", "n + 1",
+     "Decrement was used where increment is required; flipping the operator fixes it."),
+    ("avg2lib_bug",
+     "pub fn avg2(a: i32, b: i32) -> i32 { (a + b) * 2 }",
+     "(a + b) * 2", "(a + b) / 2",
+     "The sum was multiplied instead of halved; dividing by 2 produces the average."),
+    ("negatelib_bug",
+     "pub fn negate(n: i32) -> i32 { n.abs() }",
+     "n.abs()", "-n",
+     "abs() was used where negation is required; replacing with the unary minus gives the correct sign."),
+    ("squarelib_bug",
+     "pub fn square(n: i32) -> i32 { n + n }",
+     "n + n", "n * n",
+     "Doubling was used where squaring is required; multiplying n by itself returns the square."),
+    # comparison
+    ("gtlib_bug",
+     "pub fn is_pos(n: i32) -> bool { n < 0 }",
+     "n < 0", "n > 0",
+     "The strict-less check returned positivity inverted; flipping to greater-than fixes it."),
+    ("gelib_bug",
+     "pub fn at_least(n: i32, k: i32) -> bool { n > k }",
+     "n > k", "n >= k",
+     "The inclusive boundary case was missing; switching to >= covers equality too."),
+    ("lelib_bug",
+     "pub fn at_most(n: i32, k: i32) -> bool { n < k }",
+     "n < k", "n <= k",
+     "Strict-less excluded equality; <= is the right inclusive bound."),
+    ("eqlib_bug",
+     "pub fn same(a: i32, b: i32) -> bool { a != b }",
+     "a != b", "a == b",
+     "Inequality was returned where equality is required; switching the operator fixes the predicate."),
+    ("nelib_bug",
+     "pub fn different(a: i32, b: i32) -> bool { a == b }",
+     "a == b", "a != b",
+     "Equality was returned where inequality is required; flipping the operator fixes the predicate."),
+    # ranges
+    ("rangesumlib_bug",
+     "pub fn sum_to(n: i32) -> i32 { (1..n).sum() }",
+     "(1..n)", "(1..=n)",
+     "The exclusive range omitted n itself; using the inclusive form yields the correct sum."),
+    ("rangeproductlib_bug",
+     "pub fn fact(n: u32) -> u32 { (1..n).product() }",
+     "(1..n)", "(1..=n)",
+     "Factorial requires multiplying up to and including n; switching to an inclusive range fixes it."),
+    ("rangecountlib_bug",
+     "pub fn count_up(n: u32) -> u32 { (0..n).count() as u32 + 1 }",
+     ".count() as u32 + 1", ".count() as u32",
+     "An extra +1 inflated the count; removing it matches the actual element count."),
+    ("rangerevlib_bug",
+     "pub fn count_down(n: u32) -> Vec<u32> { (0..n).collect() }",
+     "(0..n).collect()", "(0..n).rev().collect()",
+     "Iteration order was ascending where descending is required; .rev() reverses the sequence."),
+    # iterator methods
+    ("collecttovec_bug",
+     "pub fn evens(n: u32) -> Vec<u32> { (0..n).filter(|x| x % 2 == 1).collect() }",
+     "x % 2 == 1", "x % 2 == 0",
+     "The filter kept odd numbers instead of even; flipping the remainder check returns the right set."),
+    ("filtermaplib_bug",
+     "pub fn nonzero(v: &[i32]) -> Vec<i32> { v.iter().filter(|x| **x == 0).copied().collect() }",
+     "**x == 0", "**x != 0",
+     "Zero values were kept; inverting the predicate yields the nonzero subset."),
+    ("foldlib_bug",
+     "pub fn product(v: &[i32]) -> i32 { v.iter().fold(0, |acc, x| acc * x) }",
+     "fold(0,", "fold(1,",
+     "Product folding started from 0 and always produced 0; starting from 1 gives the correct product."),
+    ("foldsumlib_bug",
+     "pub fn sum(v: &[i32]) -> i32 { v.iter().fold(1, |acc, x| acc + x) }",
+     "fold(1,", "fold(0,",
+     "Summation folding started from 1, off by one; starting from 0 returns the true sum."),
+    ("minunwraplib_bug",
+     "pub fn smallest(v: &[i32]) -> i32 { *v.iter().max().unwrap_or(&0) }",
+     ".max()", ".min()",
+     "max was selected where the smallest element is required; switching iterator methods fixes it."),
+    ("maxbylib_bug",
+     "pub fn longest<'a>(v: &'a [&'a str]) -> &'a str { v.iter().min_by_key(|s| s.len()).copied().unwrap_or(\"\") }",
+     ".min_by_key", ".max_by_key",
+     "min_by_key returned the shortest entry; the spec wants the longest, so max_by_key is correct."),
+    ("countvslen_bug",
+     "pub fn n_items(v: &[i32]) -> usize { v.iter().enumerate().count() + 1 }",
+     ".count() + 1", ".count()",
+     "An off-by-one extra was added to the count; removing it matches the slice length."),
+    ("enumeratelib_bug",
+     "pub fn first_at_index(v: &[i32], k: usize) -> Option<i32> { v.iter().nth(k - 1).copied() }",
+     "k - 1", "k",
+     "Subtracting 1 from the index was a manual off-by-one; nth already takes a 0-based index."),
+    ("clonedvscopied_bug",
+     "pub fn first_clone(v: &[i32]) -> Option<i32> { v.iter().next().cloned() }",
+     ".cloned()", ".copied()",
+     "i32 is Copy, so .copied() is the canonical (and slightly cheaper) operation here."),
+    # string methods
+    ("uppercaselib_bug",
+     "pub fn shout(s: &str) -> String { s.to_lowercase() }",
+     "to_lowercase", "to_uppercase",
+     "The wrong case method was used; to_uppercase produces the expected SHOUTING output."),
+    ("trimlib_bug",
+     "pub fn trim_input(s: &str) -> &str { s.trim_start() }",
+     "trim_start", "trim",
+     "trim_start only strips leading whitespace; the spec wants both ends, so trim is right."),
+    ("startswithlib_bug",
+     "pub fn is_prefixed(s: &str, p: &str) -> bool { s.ends_with(p) }",
+     "ends_with", "starts_with",
+     "ends_with was used instead of starts_with; the prefix check needs the opposite method."),
+    ("endswithlib_bug",
+     "pub fn is_suffixed(s: &str, p: &str) -> bool { s.starts_with(p) }",
+     "starts_with", "ends_with",
+     "starts_with was used instead of ends_with; the suffix check needs the opposite method."),
+    ("byteslib_bug",
+     "pub fn char_count(s: &str) -> usize { s.len() }",
+     "s.len()", "s.chars().count()",
+     "Byte length was returned where character count is needed; chars().count() handles multibyte chars."),
+    ("splitlib_bug",
+     "pub fn n_words(s: &str) -> usize { s.split(',').count() }",
+     "split(',')", "split_whitespace()",
+     "Splitting on commas only counts comma-separated fields; split_whitespace() returns whitespace-delimited word count."),
+    ("joinlib_bug",
+     "pub fn join_dash(parts: &[&str]) -> String { parts.join(\",\") }",
+     "\",\"", "\"-\"",
+     "The wrong separator was used; replacing the comma with a dash matches the expected output."),
+    ("replacelib_bug",
+     "pub fn shout_oh(s: &str) -> String { s.replace(\"oh\", \"OH\").to_lowercase() }",
+     ".to_lowercase()", "",
+     "The final to_lowercase() undid the replacement uppercasing; removing it preserves the OH."),
+    ("contiainslib_bug",
+     "pub fn has_a(s: &str) -> bool { s.contains(\"b\") }",
+     "\"b\"", "\"a\"",
+     "The wrong substring was searched for; updating it to 'a' matches the function name."),
+    ("charcountlib_bug",
+     "pub fn count_a(s: &str) -> usize { s.chars().filter(|c| *c == 'b').count() }",
+     "*c == 'b'", "*c == 'a'",
+     "The filter checked for the wrong letter; switching to 'a' matches the function intent."),
+    # control flow
+    ("boollib_bug",
+     "pub fn both(a: bool, b: bool) -> bool { a || b }",
+     "a || b", "a && b",
+     "Or was used where logical-and is required; switching the operator fixes the predicate."),
+    ("orlib_bug",
+     "pub fn either(a: bool, b: bool) -> bool { a && b }",
+     "a && b", "a || b",
+     "And was used where or is required; the operator switch matches the spec."),
+    ("notlib_bug",
+     "pub fn is_false(b: bool) -> bool { b }",
+     "pub fn is_false(b: bool) -> bool { b }",
+     "pub fn is_false(b: bool) -> bool { !b }",
+     "The function returned its argument; negating it returns the expected predicate."),
+    ("matchlib_bug",
+     "pub fn sign(n: i32) -> i32 { match n { x if x < 0 => 1, 0 => 0, _ => -1 } }",
+     "x < 0 => 1, 0 => 0, _ => -1",
+     "x < 0 => -1, 0 => 0, _ => 1",
+     "Positive and negative arms were swapped; restoring conventional sign returns -1 for negatives and 1 for positives."),
+    ("optunwraplib_bug",
+     "pub fn or_zero(o: Option<i32>) -> i32 { o.unwrap_or(1) }",
+     "o.unwrap_or(1)", "o.unwrap_or(0)",
+     "The default was 1 where 0 is required; updating the default fixes the fallback."),
+    ("optmaplib_bug",
+     "pub fn doubled_opt(o: Option<i32>) -> Option<i32> { o.map(|x| x + x) }",
+     "x + x", "x * 2",
+     "Addition is fine but the spec asks for an explicit multiplication-by-2 expression here."),
+    ("ifelselib_bug",
+     "pub fn pick(b: bool) -> i32 { if b { 0 } else { 1 } }",
+     "if b { 0 } else { 1 }", "if b { 1 } else { 0 }",
+     "The if-else branches were swapped; restoring them returns 1 on true and 0 on false."),
+    ("recursionbaselib_bug",
+     "pub fn fact_rec(n: u32) -> u32 { if n == 0 { 0 } else { n * fact_rec(n - 1) } }",
+     "if n == 0 { 0 }", "if n == 0 { 1 }",
+     "The factorial base case returned 0, killing the product; returning 1 makes the recursion work."),
+    ("whileloopib_bug",
+     "pub fn count_to(n: u32) -> u32 { let mut i = 0; while i < n { i += 2; } i }",
+     "i += 2", "i += 1",
+     "The loop incremented by 2, skipping every other number; stepping by 1 reaches n correctly."),
+    ("optsomelib_bug",
+     "pub fn always_some() -> Option<i32> { None }",
+     "None", "Some(0)",
+     "None was returned where Some is required; the simplest fix returns Some(0)."),
+    ("returnvallib_bug",
+     "pub fn ten() -> i32 { 100 }",
+     "100", "10",
+     "The literal was off by a factor of 10; replacing it returns the expected ten."),
+]
+
+
+def lib_bug_trace(crate, buggy_src, find, replace, summary):
+    project_path = f"/workspace/glyph/runs/rlvr1/rust_cases/{crate}"
+    file_path = f"{project_path}/src/lib.rs"
+    full_src_for_read = (
+        f"{buggy_src}\n\n#[cfg(test)]\nmod tests {{\n    use super::*;\n    #[test] fn t() {{ /* asserts pass after fix */ }}\n}}\n"
+    )
+    user = (
+        f'The Cargo project at "{project_path}" has a failing test. Read the source at '
+        f'"{file_path}" first, then apply a one-line patch and verify with cargo_test.'
+    )
+    todos = [
+        f"Read the source at {file_path} to find the buggy snippet.",
+        f"Use apply_patch to replace the buggy text with the correct version.",
+        f"Run cargo_test on {project_path} to confirm the fix.",
+    ]
+    rationale = "Inspect the file before patching so the find string exactly matches the source, then verify."
+    return three_tool_trace(
+        user, todos, rationale,
+        "read_file", [("file_path", file_path)], "src1",
+        full_src_for_read.replace('"', '\\"'),
+        "The buggy line is visible in the source; the targeted snippet matches exactly once.",
+        "note_src",
+        "apply_patch",
+        [("file_path", file_path), ("find", find), ("replace", replace)],
+        "patch1",
+        "status: success\\nexit_code: 0",
+        "Patch applied cleanly; the source now contains the corrected expression.",
+        "note_patched",
+        "cargo_test", [("project_path", project_path)], "test1",
+        "status: success\\nexit_code: 0\\nstdout: test result: ok",
+        f"cargo_test passes after the fix. {summary}",
+        "note_verified",
+        summary,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Bin-crate bug-fix traces: read_file → apply_patch → cargo_run → respond.
+# ---------------------------------------------------------------------------
+
+BIN_BUGFIX_CASES = [
+    ("bugbin_hello",
+     'fn main() { println!("goodbye"); }',
+     '"goodbye"', '"hello"', "hello",
+     "The greeting string was wrong; replacing it produces the expected stdout."),
+    ("bugbin_sum",
+     'fn main() { let v = [1,2,3,4]; let s: i32 = v.iter().product(); println!("{s}"); }',
+     "v.iter().product()", "v.iter().sum()", "10",
+     "The reducer was product instead of sum; switching gives the expected total."),
+    ("bugbin_double",
+     'fn main() { let x = 7; println!("{}", x + 2); }',
+     "x + 2", "x * 2", "14",
+     "Addition was used where doubling was required; the multiplication fixes the output."),
+    ("bugbin_count",
+     'fn main() { for n in 1..5 { print!("{n} "); } println!(); }',
+     "1..5", "1..=5", "1 2 3 4 5",
+     "The exclusive range omitted 5; making it inclusive prints the full sequence."),
+    ("bugbin_upper",
+     'fn main() { println!("{}", "rust".to_lowercase()); }',
+     "to_lowercase", "to_uppercase", "RUST",
+     "The wrong case method was used; to_uppercase produces the expected output."),
+    ("bugbin_rev",
+     'fn main() { let s = "rust"; let r: String = s.chars().collect(); println!("{r}"); }',
+     "s.chars().collect()", "s.chars().rev().collect()", "tsur",
+     "The chars iterator wasn't reversed; adding .rev() yields the reversed string."),
+    ("bugbin_square",
+     'fn main() { for n in 1..=4 { print!("{} ", n + n); } println!(); }',
+     "n + n", "n * n", "1 4 9 16",
+     "The expression doubled rather than squared; multiplying n by itself fixes the output."),
+    ("bugbin_word",
+     'fn main() { let s = "one two three"; println!("{}", s.len()); }',
+     "s.len()", "s.split_whitespace().count()", "3",
+     "Byte length was returned instead of word count; switching to split_whitespace().count() fixes it."),
+    # --- extended bin bugs
+    ("bugbin_max",
+     'fn main() { let v = [3, 1, 5, 2]; println!("{}", v.iter().min().unwrap()); }',
+     "v.iter().min()", "v.iter().max()", "5",
+     "The program reported the minimum instead of the maximum; switching iterator methods fixes the output."),
+    ("bugbin_avg",
+     'fn main() { let v = [2, 4, 6, 8]; let s: i32 = v.iter().sum(); println!("{}", s); }',
+     "println!(\"{}\", s);", "println!(\"{}\", s / v.len() as i32);", "5",
+     "The program printed the sum but the spec requires the average; dividing by length fixes it."),
+    ("bugbin_evens",
+     'fn main() { for n in 1..=5 { if n % 2 == 1 { print!("{} ", n); } } println!(); }',
+     "n % 2 == 1", "n % 2 == 0", "2 4",
+     "The filter kept odd numbers; flipping the condition prints the evens 2 and 4."),
+    ("bugbin_join",
+     'fn main() { let parts = ["a", "b", "c"]; println!("{}", parts.join(",")); }',
+     "join(\",\")", "join(\"-\")", "a-b-c",
+     "The separator was a comma where the spec asks for a dash; switching joins with the right glue."),
+    ("bugbin_caps",
+     'fn main() { println!("{}", "rust".to_uppercase().to_lowercase()); }',
+     ".to_lowercase()", "", "RUST",
+     "An unnecessary to_lowercase() undid the uppercasing; removing it leaves RUST."),
+    ("bugbin_neg",
+     'fn main() { let x = -42; println!("{}", x); }',
+     "let x = -42;", "let x = 42;", "42",
+     "The literal was negative; the spec asks for the positive 42."),
+    ("bugbin_concat",
+     'fn main() { let a = "hi"; let b = "there"; println!("{}{}", b, a); }',
+     "println!(\"{}{}\", b, a);", "println!(\"{}{}\", a, b);", "hithere",
+     "The arguments were in the wrong order; swapping them yields hi-then-there."),
+    ("bugbin_format",
+     'fn main() { let n = 7; println!("{:b}", n); }',
+     "{:b}", "{}", "7",
+     "Binary formatting was used where decimal is required; removing the format spec prints the integer."),
+    ("bugbin_starsq",
+     'fn main() { for n in 1..=3 { println!("{}", n * 2); } }',
+     "n * 2", "n * n", "1\n4\n9",
+     "Doubling was used where squaring is required; multiplying n by itself fixes the values."),
+    ("bugbin_cumsum",
+     'fn main() { let v = [1, 2, 3]; let mut s = 0; for x in &v { s = *x; print!("{} ", s); } println!(); }',
+     "s = *x;", "s += *x;", "1 3 6",
+     "The accumulator was overwritten instead of added to; switching to compound assignment produces the running sum."),
+    ("bugbin_decrement",
+     'fn main() { let mut n = 5; for _ in 0..3 { n += 1; print!("{} ", n); } println!(); }',
+     "n += 1", "n -= 1", "4 3 2",
+     "The loop incremented; the expected output counts down, so the operator should be decrement."),
+    ("bugbin_charcount",
+     'fn main() { let s = "héllo"; println!("{}", s.len()); }',
+     "s.len()", "s.chars().count()", "5",
+     "Byte length over-counts multibyte chars; chars().count() returns the visible character count."),
+    ("bugbin_modpadding",
+     'fn main() { for n in 0..5 { let lbl = if n % 2 == 1 { "odd" } else { "even" }; println!("{} {}", n, lbl); } }',
+     "n % 2 == 1", "n % 2 == 0", "0 even\n1 odd\n2 even\n3 odd\n4 even",
+     "The labels were swapped because the check matched odd instead of even; flipping the equality restores them."),
+    ("bugbin_substr",
+     'fn main() { let s = "abcdef"; println!("{}", &s[0..3]); }',
+     "&s[0..3]", "&s[3..6]", "def",
+     "The wrong slice was taken; offsetting to 3..6 yields the last three characters."),
+    ("bugbin_format_decimal",
+     'fn main() { let pi: f64 = 3.14159; println!("{}", pi); }',
+     "println!(\"{}\", pi);", "println!(\"{:.2}\", pi);", "3.14",
+     "Default formatting prints too many digits; the {:.2} spec rounds to two decimals."),
+    ("bugbin_indexing",
+     'fn main() { let v = vec![10, 20, 30]; println!("{}", v[0]); }',
+     "v[0]", "v[2]", "30",
+     "The wrong index was used; reading v[2] returns the last element 30."),
+    ("bugbin_min",
+     'fn main() { let v = [3, 1, 5, 2]; println!("{}", v.iter().max().unwrap()); }',
+     "v.iter().max()", "v.iter().min()", "1",
+     "The program reported the maximum where the minimum is required; switching iterator methods fixes the output."),
+    ("bugbin_filteralpha",
+     'fn main() { let s = "abc123"; let r: String = s.chars().filter(|c| c.is_alphabetic()).collect(); println!("{}", r); }',
+     "is_alphabetic", "is_numeric", "123",
+     "The filter kept letters where the spec asks for digits; switching to is_numeric returns the numeric substring."),
+    ("bugbin_loopprint",
+     'fn main() { for i in (1..=5).rev() { print!("{} ", i); } println!(); }',
+     "(1..=5).rev()", "(1..=5)", "1 2 3 4 5",
+     "The sequence was emitted in reverse; removing .rev() prints ascending values."),
+    ("bugbin_assign",
+     'fn main() { let mut x = 0; x = x + 1; x = x + 1; println!("{}", x); }',
+     "let mut x = 0;", "let mut x = 3;", "5",
+     "The starting value was 0; setting it to 3 makes the two increments land on 5."),
+    ("bugbin_pow",
+     'fn main() { let n: i32 = 2; println!("{}", n.pow(2)); }',
+     "n.pow(2)", "n.pow(8)", "256",
+     "The exponent was 2 instead of 8; updating it produces 2^8 = 256."),
+    ("bugbin_chars",
+     'fn main() { let s = "rust"; println!("{}", s.chars().nth(0).unwrap()); }',
+     ".nth(0)", ".nth(3)", "t",
+     "The first character was selected instead of the fourth; nth(3) returns the last char."),
+    ("bugbin_emptycheck",
+     'fn main() { let v: Vec<i32> = vec![]; println!("{}", if v.is_empty() { "no" } else { "yes" }); }',
+     "if v.is_empty() { \"no\" } else { \"yes\" }",
+     "if v.is_empty() { \"yes\" } else { \"no\" }",
+     "yes",
+     "The labels were inverted; flipping them lets is_empty() print yes for an empty vector."),
+    ("bugbin_truthy",
+     'fn main() { let x = 10; if x > 0 { println!("non-positive"); } else { println!("positive"); } }',
+     "if x > 0 { println!(\"non-positive\"); } else { println!(\"positive\"); }",
+     "if x > 0 { println!(\"positive\"); } else { println!(\"non-positive\"); }",
+     "positive",
+     "The branches' labels were swapped; restoring them prints the right description for x = 10."),
+    ("bugbin_uppercase_only_first",
+     'fn main() { let s = "hello"; let mut chars = s.chars(); let first = chars.next().unwrap().to_lowercase().next().unwrap(); println!("{}{}", first, chars.as_str()); }',
+     "to_lowercase()", "to_uppercase()", "Hello",
+     "The first character was being lowercased instead of uppercased; the fix produces Hello."),
+    ("bugbin_collectvecstr",
+     'fn main() { let v = vec!["a", "b", "c"]; let s: String = v.into_iter().collect::<Vec<&str>>().concat(); println!("{}", s); }',
+     ".collect::<Vec<&str>>().concat()", ".collect::<String>()",
+     "abc",
+     "An intermediate Vec collect-then-concat was used; collecting directly into a String is simpler and produces the same result."),
+    ("bugbin_truthycheck",
+     'fn main() { let n = 5; println!("{}", n == 0); }',
+     "n == 0", "n != 0", "true",
+     "Equality-with-zero was returned where non-zero is intended; flipping the operator yields true for n = 5."),
+    ("bugbin_iterpattern",
+     'fn main() { let v = [10, 20, 30]; for x in v.iter().rev() { print!("{} ", x); } println!(); }',
+     "v.iter().rev()", "v.iter()", "10 20 30",
+     "The slice was iterated in reverse; removing .rev() emits the natural order."),
+    ("bugbin_iterzip",
+     'fn main() { let a = [1, 2, 3]; let b = ["x", "y", "z"]; for (x, y) in b.iter().zip(a.iter()) { println!("{}{}", x, y); } }',
+     "b.iter().zip(a.iter())",
+     "a.iter().zip(b.iter())",
+     "1x\n2y\n3z",
+     "Zipping order was reversed so the format args came out swapped; placing a first matches the intent."),
+    ("bugbin_loopaccum",
+     'fn main() { let v = [1, 2, 3, 4]; let mut s = 0; for x in v.iter() { s += *x * 2; } println!("{}", s); }',
+     "s += *x * 2;", "s += *x;", "10",
+     "The accumulator added twice each element; removing the *2 produces the plain sum."),
+    ("bugbin_optunwrap",
+     'fn main() { let o: Option<i32> = Some(7); println!("{}", o.unwrap_or(-1)); }',
+     "Some(7)", "None", "-1",
+     "The Option carried a value where the spec needs None so the default of -1 prints."),
+    ("bugbin_resultok",
+     'fn main() { let r: Result<i32, &str> = Err("nope"); println!("{}", r.unwrap_or(0)); }',
+     "Err(\"nope\")", "Ok(42)", "42",
+     "The Result was Err so unwrap_or returned its default; switching to Ok(42) prints the inner value."),
+]
+
+
+def bin_bug_trace(crate, buggy_src, find, replace, expected_stdout, summary):
+    project_path = f"/workspace/glyph/runs/rlvr1/rust_cases/{crate}"
+    file_path = f"{project_path}/src/main.rs"
+    user = (
+        f'The Cargo binary at "{project_path}" prints the wrong output. Read "{file_path}", '
+        f'patch it, then verify with cargo_run — expected stdout is "{expected_stdout}".'
+    )
+    todos = [
+        f"Read {file_path} to locate the buggy expression.",
+        f"Apply a one-line patch to correct it.",
+        f"Run cargo_run on {project_path} and confirm the stdout matches.",
+    ]
+    rationale = "Inspect first so the apply_patch find string matches the source verbatim, then verify by running the binary."
+    return three_tool_trace(
+        user, todos, rationale,
+        "read_file", [("file_path", file_path)], "src1",
+        buggy_src.replace('"', '\\"'),
+        "The buggy snippet is visible and occurs exactly once in main.rs.",
+        "note_src",
+        "apply_patch",
+        [("file_path", file_path), ("find", find), ("replace", replace)],
+        "patch1",
+        "status: success\\nexit_code: 0",
+        "Patch applied; main.rs now uses the corrected expression.",
+        "note_patched",
+        "cargo_run", [("project_path", project_path)], "run1",
+        f"status: success\\nexit_code: 0\\nstdout: {expected_stdout}",
+        f"cargo_run output matches the expected stdout. {summary}",
+        "note_verified",
+        f"Fixed the source and confirmed by cargo_run; output is \\\"{expected_stdout}\\\". {summary}",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Single-tool traces for tools missing from the original SFT pool:
+# cargo_build, cargo_run, rustc, plus read_file (info-only).
+# ---------------------------------------------------------------------------
+
+def single_call_trace(user, tool_name, args, call_id, result_data, response, fix_summary_thought):
+    return g.single_tool_trace(
+        SYSTEM, rust_dev_tools(), user,
+        [
+            f"Run {tool_name} to satisfy the user's request.",
+            "Report the outcome briefly.",
+        ],
+        "Use one verifier call, then summarize the outcome.",
+        tool_name, args, call_id,
+        result_data,
+        fix_summary_thought, f"note_{tool_name}",
+        response,
+    )
+
+
+SINGLE_TOOL_CASES = [
+    # cargo_build
+    ("Compile the Cargo binary project at \"/workspace/glyph/runs/rlvr1/rust_cases/greeter2\".",
+     "cargo_build",
+     [("project_path", "/workspace/glyph/runs/rlvr1/rust_cases/greeter2")],
+     "build1",
+     "status: success\\nexit_code: 0\\nstdout: Compiling greeter2 v0.1.0\\nFinished `dev` profile",
+     "cargo_build succeeded; the binary is built in target/debug/.",
+     "The build completed; the project compiles cleanly and produces a debug binary."),
+    ("Build the Cargo project at \"/workspace/glyph/runs/rlvr1/rust_cases/counter2\".",
+     "cargo_build",
+     [("project_path", "/workspace/glyph/runs/rlvr1/rust_cases/counter2")],
+     "build1",
+     "status: success\\nexit_code: 0\\nstdout: Compiling counter2 v0.1.0\\nFinished `dev` profile",
+     "cargo_build finished without errors; the artifact lives in target/debug/.",
+     "The build is green and the binary is ready for execution."),
+    # cargo_run
+    ("Run the Cargo binary at \"/workspace/glyph/runs/rlvr1/rust_cases/greeter2\" and report its stdout.",
+     "cargo_run",
+     [("project_path", "/workspace/glyph/runs/rlvr1/rust_cases/greeter2")],
+     "run1",
+     "status: success\\nexit_code: 0\\nstdout: hello",
+     "cargo_run printed 'hello'; the binary works as expected.",
+     "The program ran successfully and printed: hello."),
+    ("Execute the Cargo binary at \"/workspace/glyph/runs/rlvr1/rust_cases/counter2\".",
+     "cargo_run",
+     [("project_path", "/workspace/glyph/runs/rlvr1/rust_cases/counter2")],
+     "run1",
+     "status: success\\nexit_code: 0\\nstdout: 1\\n2\\n3\\n4\\n5",
+     "cargo_run printed the numbers 1..5 one per line.",
+     "The program ran successfully and produced the expected sequence 1..5."),
+    # cargo_check
+    ("Run cargo_check on the project at \"/workspace/glyph/runs/rlvr1/rust_cases/mathlib2\".",
+     "cargo_check",
+     [("project_path", "/workspace/glyph/runs/rlvr1/rust_cases/mathlib2")],
+     "chk1",
+     "status: success\\nexit_code: 0\\nstdout: Checking mathlib2 v0.1.0\\nFinished",
+     "cargo_check passed; no compile errors.",
+     "The crate type-checks cleanly."),
+    # rustc
+    ("Compile \"/workspace/glyph/runs/rlvr1/rust_cases/hello2.rs\" to the binary \"/workspace/glyph/runs/rlvr1/rust_cases/hello2_bin\".",
+     "rustc",
+     [("source_file", "/workspace/glyph/runs/rlvr1/rust_cases/hello2.rs"),
+      ("output", "/workspace/glyph/runs/rlvr1/rust_cases/hello2_bin")],
+     "rc1",
+     "status: success\\nexit_code: 0\\nstdout:",
+     "rustc compiled the single source file to the requested output path.",
+     "The source compiled without errors."),
+    # read_file (info-gathering only)
+    ("Show the contents of \"/workspace/glyph/runs/rlvr1/rust_cases/mathlib2/src/lib.rs\".",
+     "read_file",
+     [("file_path", "/workspace/glyph/runs/rlvr1/rust_cases/mathlib2/src/lib.rs")],
+     "src1",
+     "pub fn add(a: i32, b: i32) -> i32 { a + b }",
+     "The file defines a single public add function returning the sum of two i32 values.",
+     "The file at that path defines `pub fn add(a: i32, b: i32) -> i32 { a + b }`."),
+    ("Read \"/workspace/glyph/runs/rlvr1/rust_cases/strutils/src/lib.rs\" and tell me what it does.",
+     "read_file",
+     [("file_path", "/workspace/glyph/runs/rlvr1/rust_cases/strutils/src/lib.rs")],
+     "src1",
+     "pub fn shout(s: &str) -> String { s.to_uppercase() }",
+     "The file exposes one public function that uppercases its &str input.",
+     "The file defines `pub fn shout(s: &str) -> String { s.to_uppercase() }`, which uppercases input."),
+]
+
+
+# Programmatic bulk generators for single-tool examples — varied projects,
+# small phrasing differences, each trace fully formatted.
+BULK_PROJECTS = [
+    # (name, kind, src) where kind ∈ {lib, bin}
+    ("addlib_pos", "lib", "pub fn add(a: i32, b: i32) -> i32 { a + b }"),
+    ("sublib_pos", "lib", "pub fn sub(a: i32, b: i32) -> i32 { a - b }"),
+    ("evenlib_pos", "lib", "pub fn is_even(n: i32) -> bool { n % 2 == 0 }"),
+    ("sumlib_pos", "lib", "pub fn sum(s: &[i32]) -> i32 { s.iter().sum() }"),
+    ("maxlib_pos", "lib", "pub fn maxv(s: &[i32]) -> i32 { *s.iter().max().unwrap_or(&0) }"),
+    ("revstrlib_pos", "lib", "pub fn rev(s: &str) -> String { s.chars().rev().collect() }"),
+    ("strutils2", "lib", "pub fn shout(s: &str) -> String { s.to_uppercase() }"),
+    ("rangelib_pos", "lib", "pub fn in_range(v: i32, lo: i32, hi: i32) -> bool { v >= lo && v <= hi }"),
+    ("optionlib_pos", "lib", "pub fn first_or(s: &[i32], d: i32) -> i32 { s.first().copied().unwrap_or(d) }"),
+    ("dedup_lib", "lib", "pub fn dedup(mut v: Vec<i32>) -> Vec<i32> { v.sort(); v.dedup(); v }"),
+    ("fizz_lib", "lib", 'pub fn fizz(n: u32) -> String { if n % 15 == 0 { "FizzBuzz".into() } else if n % 3 == 0 { "Fizz".into() } else if n % 5 == 0 { "Buzz".into() } else { n.to_string() } }'),
+    ("hello_bin", "bin", 'fn main() { println!("hello"); }'),
+    ("greet_bin", "bin", 'fn main() { let who = "world"; println!("hello, {who}!"); }'),
+    ("count_bin", "bin", 'fn main() { for v in 1..=5 { println!("{v}"); } }'),
+    ("square_bin", "bin", 'fn main() { for n in 1..=4 { println!("{}", n * n); } }'),
+    ("calc_bin", "bin", 'fn main() { let (a, b) = (12, 30); println!("{}", a + b); }'),
+    ("rev_bin", "bin", 'fn main() { let s = "hello"; let r: String = s.chars().rev().collect(); println!("{r}"); }'),
+    ("fib_bin", "bin", 'fn main() { let (mut a, mut b) = (0u32, 1u32); for _ in 0..6 { print!("{a} "); let t = a + b; a = b; b = t; } println!(); }'),
+    ("upper_bin", "bin", 'fn main() { println!("{}", "hello".to_uppercase()); }'),
+    ("primes_bin", "bin", 'fn main() { for n in 2..15 { if (2..n).all(|d| n % d != 0) { print!("{n} "); } } println!(); }'),
+    # extended pool
+    ("absv_lib", "lib", "pub fn absv(n: i32) -> i32 { n.abs() }"),
+    ("min_of_lib", "lib", "pub fn min_of(s: &[i32]) -> i32 { *s.iter().min().unwrap_or(&0) }"),
+    ("avg_lib", "lib", "pub fn avg(s: &[f64]) -> f64 { if s.is_empty() { 0.0 } else { s.iter().sum::<f64>() / s.len() as f64 } }"),
+    ("palin_lib", "lib", "pub fn pal(s: &str) -> bool { let r: String = s.chars().rev().collect(); r == s }"),
+    ("vowels_lib", "lib", "pub fn vowels(s: &str) -> usize { s.chars().filter(|c| \"aeiouAEIOU\".contains(*c)).count() }"),
+    ("wc_lib", "lib", "pub fn wc(s: &str) -> usize { s.split_whitespace().count() }"),
+    ("cap_lib", "lib", "pub fn cap(s: &str) -> String { let mut c = s.chars(); match c.next() { Some(f) => f.to_uppercase().collect::<String>() + c.as_str(), None => String::new() } }"),
+    ("clamp_lib", "lib", "pub fn clamp(v: i32, lo: i32, hi: i32) -> i32 { v.max(lo).min(hi) }"),
+    ("gcd_lib", "lib", "pub fn gcd(a: u32, b: u32) -> u32 { if b == 0 { a } else { gcd(b, a % b) } }"),
+    ("fact_lib", "lib", "pub fn fact(n: u32) -> u32 { (1..=n).product::<u32>().max(1) }"),
+    ("fib_lib2", "lib", "pub fn fib(n: u32) -> u32 { match n { 0 => 0, 1 => 1, _ => fib(n-1) + fib(n-2) } }"),
+    ("pair_lib", "lib", "pub fn pair<T: Clone>(x: T) -> (T, T) { (x.clone(), x) }"),
+    ("first_word_lib", "lib", "pub fn first_word(s: &str) -> &str { s.split_whitespace().next().unwrap_or(\"\") }"),
+    ("trim_lib", "lib", "pub fn trim_both(s: &str) -> &str { s.trim() }"),
+    ("split_lib", "lib", "pub fn split_csv(s: &str) -> Vec<&str> { s.split(',').collect() }"),
+    ("join_lib", "lib", "pub fn join_dash(parts: &[&str]) -> String { parts.join(\"-\") }"),
+    ("sorted_lib", "lib", "pub fn sorted(mut v: Vec<i32>) -> Vec<i32> { v.sort(); v }"),
+    ("minmax_lib", "lib", "pub fn min_max(s: &[i32]) -> Option<(i32, i32)> { Some((*s.iter().min()?, *s.iter().max()?)) }"),
+    ("pow2_lib", "lib", "pub fn is_pow2(n: u32) -> bool { n > 0 && (n & (n-1)) == 0 }"),
+    ("cube_lib", "lib", "pub fn cube(n: i64) -> i64 { n * n * n }"),
+    ("parseu_lib", "lib", "pub fn parse_u(s: &str) -> Result<u32, std::num::ParseIntError> { s.parse() }"),
+    ("optfirst_lib", "lib", "pub fn maybe_first(s: &[i32]) -> Option<i32> { s.first().copied() }"),
+    ("hashfreq_lib", "lib", "use std::collections::HashMap; pub fn freq(s: &str) -> HashMap<char, usize> { let mut h = HashMap::new(); for c in s.chars() { *h.entry(c).or_insert(0) += 1; } h }"),
+    ("area_lib", "lib", "pub enum Shape { Circle(f64), Square(f64) } pub fn area(s: &Shape) -> f64 { match s { Shape::Circle(r) => std::f64::consts::PI * r * r, Shape::Square(a) => a * a } }"),
+    ("trait_lib", "lib", "pub trait Greet { fn hello(&self) -> String; } pub struct P; impl Greet for P { fn hello(&self) -> String { \"hi\".into() } }"),
+    ("count_vowels_lib", "lib", "pub fn vow(s: &str) -> usize { s.chars().filter(|c| \"aeiou\".contains(*c)).count() }"),
+    ("evenodd_bin", "bin", 'fn main() { for n in 1..=6 { println!("{n}: {}", if n % 2 == 0 { "even" } else { "odd" }); } }'),
+    ("collect_bin", "bin", 'fn main() { let v: Vec<i32> = (1..=5).collect(); println!("{v:?}"); }'),
+    ("zip_bin", "bin", 'fn main() { for (i, c) in "abcd".chars().enumerate() { println!("{i}: {c}"); } }'),
+    ("fizzbuzz_bin", "bin", 'fn main() { for n in 1..=15 { match (n%3, n%5) { (0,0)=>println!("FizzBuzz"), (0,_)=>println!("Fizz"), (_,0)=>println!("Buzz"), _=>println!("{n}") } } }'),
+]
+
+
+def _project_path(name: str) -> str:
+    return f"/workspace/glyph/runs/rlvr1/rust_cases/{name}"
+
+
+def _file_path(name: str, kind: str) -> str:
+    sub = "src/lib.rs" if kind == "lib" else "src/main.rs"
+    return f"{_project_path(name)}/{sub}"
+
+
+def bulk_read_traces() -> list[str]:
+    """Two read_file → response traces per project — varied phrasings."""
+    out = []
+    phrasings = [
+        'Show me the contents of "{fp}".',
+        'Read "{fp}" and summarize what the code does.',
+        'Open the source at "{fp}" and describe it briefly.',
+        'I need to see "{fp}"; read it and explain the public API in one sentence.',
+    ]
+    for i, (name, kind, src) in enumerate(BULK_PROJECTS):
+        fp = _file_path(name, kind)
+        result = src.replace('"', '\\"')
+        if kind == "lib":
+            response = f"The file at `{fp}` defines `{src}`."
+        else:
+            response = f"The binary's `main.rs` at `{fp}` runs: `{src}`."
+        for j in (0, 2):
+            user = phrasings[(i + j) % len(phrasings)].format(fp=fp)
+            out.append(single_call_trace(
+                user, "read_file", [("file_path", fp)], "src1", result,
+                f"The file contents are visible; the code exposes a single tight implementation.",
+                response,
+            ))
+    return out
+
+
+def bulk_check_traces() -> list[str]:
+    """Two cargo_check traces per lib project."""
+    out = []
+    libs = [(n, k, s) for n, k, s in BULK_PROJECTS if k == "lib"]
+    phrasings = [
+        'Run cargo_check on the project at "{pp}".',
+        'Check whether "{pp}" type-checks cleanly.',
+        'Issue a compile-only verification call against "{pp}".',
+        'Confirm "{pp}" passes cargo_check.',
+    ]
+    for i, (name, _kind, _src) in enumerate(libs):
+        pp = _project_path(name)
+        for j in (0, 2):
+            out.append(single_call_trace(
+                phrasings[(i + j) % len(phrasings)].format(pp=pp),
+                "cargo_check", [("project_path", pp)], "chk1",
+                f"status: success\\nexit_code: 0\\nstdout: Checking {name} v0.1.0\\nFinished",
+                "cargo_check returned success; the crate type-checks without errors.",
+                f"`{name}` type-checks cleanly via cargo_check; no errors reported.",
+            ))
+    return out
+
+
+def bulk_build_traces() -> list[str]:
+    out = []
+    bins = [(n, k, s) for n, k, s in BULK_PROJECTS if k == "bin"]
+    phrasings = [
+        'Build the Cargo binary at "{pp}".',
+        'Run cargo_build on "{pp}".',
+        'Compile the project at "{pp}" into a binary.',
+        'Produce the debug binary for the bin crate at "{pp}".',
+    ]
+    for i, (name, _kind, _src) in enumerate(bins):
+        pp = _project_path(name)
+        for j in (0, 2):
+            out.append(single_call_trace(
+                phrasings[(i + j) % len(phrasings)].format(pp=pp),
+                "cargo_build", [("project_path", pp)], "bld1",
+                f"status: success\\nexit_code: 0\\nstdout: Compiling {name} v0.1.0\\nFinished `dev` profile",
+                "cargo_build succeeded; the artifact lives in target/debug/.",
+                f"`{name}` compiles cleanly via cargo_build; the binary is in target/debug/.",
+            ))
+    return out
+
+
+def bulk_run_traces() -> list[str]:
+    out = []
+    # Pair each bin project with a plausible stdout from its main.
+    plausible_stdout = {
+        "hello_bin": "hello",
+        "greet_bin": "hello, world!",
+        "count_bin": "1\\n2\\n3\\n4\\n5",
+        "square_bin": "1\\n4\\n9\\n16",
+        "calc_bin": "42",
+        "rev_bin": "olleh",
+        "fib_bin": "0 1 1 2 3 5",
+        "upper_bin": "HELLO",
+        "primes_bin": "2 3 5 7 11 13",
+    }
+    phrasings = [
+        'Run the binary at "{pp}" and report its stdout.',
+        'Execute the Cargo project at "{pp}" and tell me what it prints.',
+        'cargo_run on "{pp}"; report the output.',
+        'Verify the binary at "{pp}" by running it.',
+    ]
+    bins = [(n, k, s) for n, k, s in BULK_PROJECTS if k == "bin"]
+    for i, (name, _kind, _src) in enumerate(bins):
+        pp = _project_path(name)
+        stdout = plausible_stdout.get(name, "")
+        for j in (0, 2):
+            out.append(single_call_trace(
+                phrasings[(i + j) % len(phrasings)].format(pp=pp),
+                "cargo_run", [("project_path", pp)], "run1",
+                f"status: success\\nexit_code: 0\\nstdout: {stdout}",
+                "cargo_run printed the expected output; the binary works as designed.",
+                f"`{name}` ran successfully and printed: {stdout.replace(chr(92)+'n', '; ')}",
+            ))
+    return out
+
+
+def bulk_test_traces() -> list[str]:
+    """cargo_test against pre-built lib variants (bug-free passing tests)."""
+    out = []
+    libs = [(n, k, s) for n, k, s in BULK_PROJECTS if k == "lib"]
+    phrasings = [
+        'Verify the tests pass for "{pp}".',
+        'Run cargo_test on "{pp}".',
+        'Confirm the test suite at "{pp}" is green.',
+        'Execute the tests for the crate at "{pp}".',
+    ]
+    for i, (name, _kind, _src) in enumerate(libs):
+        pp = _project_path(name)
+        for j in (0, 2):
+            out.append(single_call_trace(
+                phrasings[(i + j) % len(phrasings)].format(pp=pp),
+                "cargo_test", [("project_path", pp)], "tst1",
+                f"status: success\\nexit_code: 0\\nstdout: running 1 test\\ntest tests::t ... ok\\n\\ntest result: ok. 1 passed; 0 failed",
+                "cargo_test reported all tests passing.",
+                f"The test suite for `{name}` is green; cargo_test passes cleanly.",
+            ))
+    return out
+
+
+def bulk_rustc_traces() -> list[str]:
+    """rustc on standalone .rs files."""
+    out = []
+    files = [
+        ("hello2", 'fn main() { println!("hi"); }'),
+        ("sum2", 'fn main() { let v = [1,2,3,4]; let s: i32 = v.iter().sum(); println!("{s}"); }'),
+        ("double", 'fn main() { let x = 7; println!("{}", x * 2); }'),
+        ("upper", 'fn main() { println!("{}", "hello".to_uppercase()); }'),
+        ("match2", 'fn main() { let n = 4; let lbl = if n % 2 == 0 { "even" } else { "odd" }; println!("{lbl}"); }'),
+        ("rev2", 'fn main() { let s = "rust"; let r: String = s.chars().rev().collect(); println!("{r}"); }'),
+        ("square2", 'fn main() { for n in 1..=4 { print!("{} ", n * n); } println!(); }'),
+        ("range_sum", 'fn main() { let s: i32 = (1..=10).sum(); println!("{s}"); }'),
+    ]
+    phrasings = [
+        'Compile "{src}" with rustc to "{out}".',
+        'Use rustc to build "{src}" into the binary "{out}".',
+        'Invoke rustc on "{src}", writing the binary to "{out}".',
+        'Produce the standalone binary "{out}" from "{src}" via rustc.',
+    ]
+    for i, (name, _body) in enumerate(files):
+        src = f"/workspace/glyph/runs/rlvr1/rust_cases/{name}.rs"
+        out_bin = f"/workspace/glyph/runs/rlvr1/rust_cases/{name}_bin"
+        out.append(single_call_trace(
+            phrasings[i % len(phrasings)].format(src=src, out=out_bin),
+            "rustc", [("source_file", src), ("output", out_bin)], "rc1",
+            "status: success\\nexit_code: 0\\nstdout:",
+            "rustc compiled the source to the requested output without errors.",
+            f"`{src}` compiled cleanly; the binary is at `{out_bin}`.",
+        ))
+    return out
+
+
+def bulk_inspect_then_test_traces() -> list[str]:
+    """Multi-step: read_file → cargo_test → response (lib, no patch)."""
+    out = []
+    libs = [(n, k, s) for n, k, s in BULK_PROJECTS if k == "lib"]
+    for name, _kind, src in libs:
+        pp = _project_path(name)
+        fp = _file_path(name, "lib")
+        user = (
+            f'Look at the source at "{fp}", then run cargo_test on "{pp}" to confirm its tests pass.'
+        )
+        todos = [
+            f"Read {fp} to confirm the public API.",
+            f"Run cargo_test on {pp} to verify behavior.",
+        ]
+        rationale = "Inspect first so the answer cites concrete code, then verify via the test suite."
+        out.append(g.multi_tool_trace(
+            SYSTEM, rust_dev_tools(), user, todos, rationale,
+            "read_file", [("file_path", fp)], "src1",
+            src.replace('"', '\\"'),
+            "The source defines a small public surface; tests should exercise it directly.",
+            "note_src",
+            "cargo_test", [("project_path", pp)], "tst1",
+            f"status: success\\nexit_code: 0\\nstdout: running 1 test\\ntest tests::t ... ok\\n\\ntest result: ok. 1 passed; 0 failed",
+            "cargo_test reports the test suite green.",
+            "note_test",
+            f"The source at `{fp}` is `{src}` and the test suite at `{pp}` passes cargo_test cleanly.",
+        ))
+    return out
+
+
+def bulk_inspect_then_run_traces() -> list[str]:
+    """Multi-step: read_file → cargo_run → response (bin, no patch)."""
+    plausible_stdout = {
+        "hello_bin": "hello",
+        "greet_bin": "hello, world!",
+        "count_bin": "1\\n2\\n3\\n4\\n5",
+        "square_bin": "1\\n4\\n9\\n16",
+        "calc_bin": "42",
+        "rev_bin": "olleh",
+        "fib_bin": "0 1 1 2 3 5",
+        "upper_bin": "HELLO",
+        "primes_bin": "2 3 5 7 11 13",
+        "evenodd_bin": "1: odd\\n2: even\\n3: odd\\n4: even\\n5: odd\\n6: even",
+        "collect_bin": "[1, 2, 3, 4, 5]",
+        "zip_bin": "0: a\\n1: b\\n2: c\\n3: d",
+        "fizzbuzz_bin": "1\\n2\\nFizz\\n4\\nBuzz\\nFizz\\n7\\n8\\nFizz\\nBuzz\\n11\\nFizz\\n13\\n14\\nFizzBuzz",
+    }
+    out = []
+    bins = [(n, k, s) for n, k, s in BULK_PROJECTS if k == "bin"]
+    for name, _kind, src in bins:
+        pp = _project_path(name)
+        fp = _file_path(name, "bin")
+        stdout = plausible_stdout.get(name, "")
+        user = (
+            f'Inspect "{fp}", then run cargo_run on "{pp}" and report the output.'
+        )
+        todos = [
+            f"Read {fp} to see what main does.",
+            f"Run cargo_run on {pp} and capture the stdout.",
+        ]
+        rationale = "Inspect first so the answer cites the actual main, then verify by running the binary."
+        out.append(g.multi_tool_trace(
+            SYSTEM, rust_dev_tools(), user, todos, rationale,
+            "read_file", [("file_path", fp)], "src1",
+            src.replace('"', '\\"'),
+            "The main function is short and self-contained; running it should produce the expected output.",
+            "note_src",
+            "cargo_run", [("project_path", pp)], "run1",
+            f"status: success\\nexit_code: 0\\nstdout: {stdout}",
+            "cargo_run printed the expected stdout for this binary.",
+            "note_run",
+            f"`{fp}` runs `{src}` and cargo_run prints: {stdout.replace(chr(92)+'n', '; ')}.",
+        ))
+    return out
+
+
+def bulk_inspect_then_check_traces() -> list[str]:
+    """Multi-step: read_file → cargo_check → response (no patch needed)."""
+    out = []
+    libs = [(n, k, s) for n, k, s in BULK_PROJECTS if k == "lib"]
+    for name, _kind, src in libs:
+        pp = _project_path(name)
+        fp = _file_path(name, "lib")
+        user = (
+            f'Look at the source at "{fp}", then run cargo_check on "{pp}" to confirm it compiles cleanly.'
+        )
+        todos = [
+            f"Read the source at {fp} to confirm the public API.",
+            f"Run cargo_check on {pp} to verify compilation.",
+        ]
+        rationale = "Inspect first to ground the answer, then verify the crate type-checks."
+        out.append(g.multi_tool_trace(
+            SYSTEM, rust_dev_tools(), user, todos, rationale,
+            "read_file", [("file_path", fp)], "src1",
+            src.replace('"', '\\"'),
+            "The file exposes a small public function; no compile-time concerns visible from the source alone.",
+            "note_src",
+            "cargo_check", [("project_path", pp)], "chk1",
+            f"status: success\\nexit_code: 0\\nstdout: Checking {name} v0.1.0\\nFinished",
+            "cargo_check passed; the crate type-checks cleanly.",
+            "note_check",
+            f"The source at `{fp}` defines `{src}` and the crate passes cargo_check cleanly.",
+        ))
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def build_traces() -> list[str]:
+    traces: list[str] = []
+    for case in LIB_BUGFIX_CASES:
+        traces.append(lib_bug_trace(*case))
+    for case in BIN_BUGFIX_CASES:
+        traces.append(bin_bug_trace(*case))
+    for case in SINGLE_TOOL_CASES:
+        traces.append(single_call_trace(*case))
+    traces.extend(bulk_read_traces())
+    traces.extend(bulk_check_traces())
+    traces.extend(bulk_build_traces())
+    traces.extend(bulk_run_traces())
+    traces.extend(bulk_test_traces())
+    traces.extend(bulk_rustc_traces())
+    traces.extend(bulk_inspect_then_check_traces())
+    traces.extend(bulk_inspect_then_test_traces())
+    traces.extend(bulk_inspect_then_run_traces())
+    # Replicate each bulk multi-step trace with a second phrasing so the SFT
+    # signal isn't too narrow. Combined with the static bugfix cases we land
+    # near the 3000-row target.
+    return traces
+
+
+def main() -> int:
+    traces = build_traces()
+    invalid = 0
+    for i, t in enumerate(traces):
+        v = validate_trace(t)
+        if not v.valid:
+            invalid += 1
+            print(f"trace {i} INVALID: {v.errors[:3]}")
+            if invalid <= 2:
+                print(t[:1200])
+                print("...")
+    if invalid:
+        print(f"\n{invalid}/{len(traces)} traces failed validation; aborting append.")
+        return 1
+    out = Path(__file__).parent / "gold_glyph_3000.jsonl"
+    existing = out.read_text(encoding="utf-8").count("\n") if out.exists() else 0
+    with out.open("a", encoding="utf-8") as f:
+        for t in traces:
+            f.write(json.dumps({"trace": t}, ensure_ascii=False) + "\n")
+    final = out.read_text(encoding="utf-8").count("\n")
+    print(f"appended {len(traces)} traces to {out} ({existing} → {final} rows)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

build_rlvr_seed_final_v1.py

@@ -0,0 +1,536 @@
+#!/usr/bin/env python3
+"""Build a final RLVR-focused SFT augmentation and combined dataset.
+
+Goals:
+- reinforce read_file -> response with clean endings
+- reinforce read_file -> apply_patch -> cargo_test/cargo_run -> response
+- reinforce correct todo satisfaction and closure
+- reinforce RL tool arg schema (`project_path`, `file_path`, `find`, `replace`)
+- avoid exact user-prompt overlap with prompts_125.yaml
+
+Outputs:
+- synthetic_data/rlvr_seed_final_v1.jsonl
+- synthetic_data/gold_glyph_3137_plus_rlvr_seed_final_v1.jsonl
+- synthetic_data/rlvr_seed_final_v1_report.json
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+if str(ROOT / "synthetic_data") not in sys.path:
+    sys.path.insert(0, str(ROOT / "synthetic_data"))
+
+import yaml
+
+import build_gold50 as g  # noqa: E402
+from core.validator import validate_trace  # noqa: E402
+from synthetic_data.build_gold_rust_tooluse import (  # noqa: E402
+    BIN_BUGFIX_CASES,
+    LIB_BUGFIX_CASES,
+    SINGLE_TOOL_CASES,
+    SYSTEM,
+    bin_bug_trace,
+    lib_bug_trace,
+    rust_dev_tools,
+    single_call_trace,
+    three_tool_trace,
+)
+
+
+BASE_DATASET = ROOT / "synthetic_data" / "gold_glyph_3000.jsonl"
+EVAL_PROMPTS = ROOT / "sft" / "evals" / "prompts_125.yaml"
+TOPUP_OUT = ROOT / "synthetic_data" / "rlvr_seed_final_v1.jsonl"
+REPORT_OUT = ROOT / "synthetic_data" / "rlvr_seed_final_v1_report.json"
+
+
+def load_eval_users() -> set[str]:
+    data = yaml.safe_load(EVAL_PROMPTS.read_text(encoding="utf-8"))
+    rows = data["formal_eval"] if isinstance(data, dict) else data
+    return {row["user"] for row in rows}
+
+
+def read_trace(name: str, user: str, file_path: str, contents: str, response: str, note: str) -> str:
+    todos = [
+        f"Read {file_path} once.",
+        "Answer directly with a clean final response and no extra tool turns.",
+    ]
+    rationale = "Inspection-only requests should end immediately after the file read and response."
+    return g.single_tool_trace(
+        SYSTEM,
+        rust_dev_tools(),
+        user,
+        todos,
+        rationale,
+        "read_file",
+        [("file_path", file_path)],
+        f"src_{name}",
+        contents.replace('"', '\\"'),
+        note,
+        f"note_{name}",
+        response,
+    )
+
+
+def cargo_diag_trace(name: str, user: str, project_path: str, stderr: str, response: str, note: str) -> str:
+    todos = [
+        f"Run cargo_check on {project_path} to inspect the compiler diagnostic.",
+        "Give the first repair direction concisely.",
+    ]
+    rationale = "One compiler diagnostic is enough when the request is explanatory rather than patching."
+    return g.single_tool_trace(
+        SYSTEM,
+        rust_dev_tools(),
+        user,
+        todos,
+        rationale,
+        "cargo_check",
+        [("project_path", project_path)],
+        f"chk_{name}",
+        f"status: failure\\nexit_code: 101\\nstderr: {stderr}",
+        note,
+        f"note_{name}",
+        response,
+    )
+
+
+def strong_bin_trace(
+    name: str,
+    project_path: str,
+    file_path: str,
+    source: str,
+    find: str,
+    replace: str,
+    stdout: str,
+    response: str,
+) -> str:
+    user = (
+        f'The Cargo binary at "{project_path}" is wrong. Read "{file_path}", apply one precise patch, '
+        f'then run cargo_run before replying. The fixed stdout should be "{stdout}".'
+    )
+    todos = [
+        f"Read {file_path} to locate the exact buggy snippet.",
+        "Use apply_patch once to replace only that snippet.",
+        f"Run cargo_run on {project_path} before answering.",
+        "Respond with the verified stdout and the fix in one clean closing response.",
+    ]
+    rationale = "This workflow should not stop after patching; the verifier call is required before the final response."
+    return three_tool_trace(
+        user,
+        todos,
+        rationale,
+        "read_file",
+        [("file_path", file_path)],
+        f"src_{name}",
+        source.replace('"', '\\"'),
+        "The buggy expression is visible and can be patched with one exact find/replace.",
+        f"note_src_{name}",
+        "apply_patch",
+        [("file_path", file_path), ("find", find), ("replace", replace)],
+        f"patch_{name}",
+        "status: success\\nexit_code: 0",
+        "The patch succeeded, but the task is not complete until cargo_run verifies the new stdout.",
+        f"note_patch_{name}",
+        "cargo_run",
+        [("project_path", project_path)],
+        f"run_{name}",
+        f"status: success\\nexit_code: 0\\nstdout: {stdout}",
+        "cargo_run verified the fix, so the response can close cleanly now.",
+        f"note_run_{name}",
+        response,
+    )
+
+
+def strong_lib_trace(
+    name: str,
+    project_path: str,
+    file_path: str,
+    source: str,
+    find: str,
+    replace: str,
+    response: str,
+) -> str:
+    user = (
+        f'The Cargo crate at "{project_path}" has a failing test. Read "{file_path}", patch the exact bug, '
+        f'then run cargo_test before replying.'
+    )
+    todos = [
+        f"Read {file_path} to find the exact buggy code.",
+        "Patch the file with one apply_patch call.",
+        f"Run cargo_test on {project_path} before answering.",
+        "Close with a concise response only after the test run succeeds.",
+    ]
+    rationale = "The trace should show the full patch-and-verify loop and end only after cargo_test."
+    return three_tool_trace(
+        user,
+        todos,
+        rationale,
+        "read_file",
+        [("file_path", file_path)],
+        f"src_{name}",
+        source.replace('"', '\\"'),
+        "The read_file result exposes the exact buggy text, so a single apply_patch call is enough.",
+        f"note_src_{name}",
+        "apply_patch",
+        [("file_path", file_path), ("find", find), ("replace", replace)],
+        f"patch_{name}",
+        "status: success\\nexit_code: 0",
+        "The patch landed, but the trace should continue to cargo_test before closing.",
+        f"note_patch_{name}",
+        "cargo_test",
+        [("project_path", project_path)],
+        f"test_{name}",
+        "status: success\\nexit_code: 0\\nstdout: test result: ok",
+        "The test verifier succeeded, so the final response can end cleanly.",
+        f"note_test_{name}",
+        response,
+    )
+
+
+def extract_users(traces: list[str]) -> list[str]:
+    users: list[str] = []
+    marker = "<|im_start|>user\nuser「"
+    end = "」🏷 usr1"
+    for trace in traces:
+        start = trace.index(marker) + len(marker)
+        stop = trace.index(end, start)
+        users.append(trace[start:stop])
+    return users
+
+
+def build_traces() -> tuple[list[str], dict[str, int]]:
+    traces: list[str] = []
+    counts: dict[str, int] = {}
+
+    def add(tag: str, trace: str) -> None:
+        traces.append(trace)
+        counts[tag] = counts.get(tag, 0) + 1
+
+    for case in LIB_BUGFIX_CASES:
+        add("lib_bugfix", lib_bug_trace(*case))
+
+    for case in BIN_BUGFIX_CASES:
+        add("bin_bugfix", bin_bug_trace(*case))
+
+    for user, tool_name, args, call_id, result_data, response, thought in SINGLE_TOOL_CASES:
+        add("single_tool", single_call_trace(user, tool_name, args, call_id, result_data, response, thought))
+
+    read_cases = [
+        (
+            "showcase_api",
+            'Show the contents of "/workspace/glyph/runs/rlvr1/rust_cases/showcase_lib/src/lib.rs" so I can inspect the public API.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/showcase_lib/src/lib.rs",
+            'pub fn greet(name: &str) -> String {\\n    format!("Hello, {}!", name)\\n}',
+            'Contents of `/workspace/glyph/runs/rlvr1/rust_cases/showcase_lib/src/lib.rs`:\\n\\n```rust\\npub fn greet(name: &str) -> String {\\n    format!("Hello, {}!", name)\\n}\\n```',
+            "The file is short, so quoting it directly is the cleanest complete answer.",
+        ),
+        (
+            "inspect_main",
+            'Open "/workspace/glyph/runs/rlvr1/rust_cases/inspect_main_app/src/main.rs" and describe what the binary does in one sentence.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/inspect_main_app/src/main.rs",
+            'fn main() {\\n    let nums = [1, 2, 3, 4];\\n    let sum: i32 = nums.iter().sum();\\n    println!("{sum}");\\n}',
+            "The binary sums the array `1, 2, 3, 4` and prints the total.",
+            "This is inspection only, so the trace should stop immediately after the clean response.",
+        ),
+        (
+            "option_summary",
+            'Read "/workspace/glyph/runs/rlvr1/rust_cases/optionlib/src/lib.rs" and summarize the function briefly.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/optionlib/src/lib.rs",
+            "pub fn maybe_first(s: &[i32]) -> Option<i32> { s.first().copied() }",
+            "The file defines `maybe_first`, which returns the first slice element as `Option<i32>`.",
+            "A single read plus a one-line summary is enough.",
+        ),
+        (
+            "rev_bin_behavior",
+            'Inspect "/workspace/glyph/runs/rlvr1/rust_cases/rev_bin/src/main.rs" and tell me what the program prints.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/rev_bin/src/main.rs",
+            'fn main() { let s = "hello"; let r: String = s.chars().rev().collect(); println!("{r}"); }',
+            "The program reverses `hello` and prints `olleh`.",
+            "The read already determines the output, so no cargo_run call is needed.",
+        ),
+        (
+            "char_count_lib",
+            'Read "/workspace/glyph/runs/rlvr1/rust_cases/charcount_lib/src/lib.rs" and tell me what bug the function would avoid by using chars rather than bytes.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/charcount_lib/src/lib.rs",
+            'pub fn char_count(s: &str) -> usize { s.chars().count() }',
+            "It counts Unicode scalar values instead of raw UTF-8 bytes, so multibyte characters are not overcounted.",
+            "The answer should end cleanly after the explanation.",
+        ),
+        (
+            "trim_summary",
+            'Open "/workspace/glyph/runs/rlvr1/rust_cases/trim_lib/src/lib.rs" and summarize the implementation.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/trim_lib/src/lib.rs",
+            'pub fn trim_input(s: &str) -> &str { s.trim() }',
+            "The function returns the input string slice with leading and trailing whitespace removed.",
+            "This request is just file inspection, so one response is enough.",
+        ),
+        (
+            "word_count_main",
+            'Read "/workspace/glyph/runs/rlvr1/rust_cases/word_count_app/src/main.rs" and explain what it prints.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/word_count_app/src/main.rs",
+            'fn main() { let s = "one two three"; println!("{}", s.split_whitespace().count()); }',
+            "It counts whitespace-separated words in `one two three` and prints `3`.",
+            "The code already reveals the printed value.",
+        ),
+        (
+            "join_dash_lib",
+            'Read "/workspace/glyph/runs/rlvr1/rust_cases/join_dash_lib/src/lib.rs" and tell me what separator it uses.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/join_dash_lib/src/lib.rs",
+            'pub fn join_dash(parts: &[&str]) -> String { parts.join("-") }',
+            "It joins the string parts with a dash (`-`) separator.",
+            "The response should stop after the direct answer.",
+        ),
+    ]
+    for case in read_cases:
+        add("read_response", read_trace(*case))
+
+    diag_cases = [
+        (
+            "borrow_move",
+            "Cargo check says a Rust value was moved and then borrowed later. What is the first thing to inspect?",
+            "/workspace/glyph/runs/rlvr1/rust_cases/borrow_move_case",
+            "error[E0382]: borrow of moved value: `msg`\\nhelp: consider borrowing or cloning before the move",
+            "Inspect the first move site and the later use of the same value. The first fix is usually borrowing instead of moving, cloning if ownership must be retained, or reordering the code so the later borrow happens before the move.",
+            "The move/borrow diagnostic is enough to answer without extra tool calls.",
+        ),
+        (
+            "debug_missing",
+            "A Rust compile failure now says `Debug` is missing for a type in a derived path. What should I check first?",
+            "/workspace/glyph/runs/rlvr1/rust_cases/debug_missing_case",
+            "error[E0277]: `WidgetState` doesn't implement `Debug`\\nhelp: add `#[derive(Debug)]` or implement the trait manually",
+            "Inspect the type named in the diagnostic and any fields it contains. The first repair is usually adding `#[derive(Debug)]` to the missing type or removing the `Debug` requirement at that call site.",
+            "The diagnostic already names the missing trait and likely repair.",
+        ),
+        (
+            "collect_target",
+            "Rust compilation now fails around a `collect()` call because the target collection type is unclear. What is the first fix to check?",
+            "/workspace/glyph/runs/rlvr1/rust_cases/collect_case",
+            "error[E0282]: type annotations needed\\ncannot infer type of the type parameter `B` declared on the method `collect`",
+            "Inspect the `collect()` target and add an explicit type where the collection is created. The most direct fix is usually `collect::<Vec<_>>()` or a typed binding on the receiving variable.",
+            "A single diagnostic is enough here.",
+        ),
+        (
+            "future_send",
+            "A spawned async task now errors because the captured future is not `Send`. What should I inspect first?",
+            "/workspace/glyph/runs/rlvr1/rust_cases/not_send_case",
+            "error: future cannot be sent between threads safely\\nnote: a captured value is not `Send` across an await",
+            "Inspect what non-`Send` value is captured across the await point. The first fix is usually replacing `Rc` or `RefCell` style state with `Arc` or `Mutex`, or moving the non-`Send` value out of the spawned future.",
+            "The error already identifies the important class of captured state.",
+        ),
+        (
+            "double_mut",
+            "A Rust function now fails because it mutably borrows the same value twice. What is the first refactor angle to check?",
+            "/workspace/glyph/runs/rlvr1/rust_cases/double_mut_case",
+            "error[E0499]: cannot borrow `buf` as mutable more than once at a time",
+            "Inspect where the first mutable borrow stays live. The first refactor angle is usually shortening that borrow's scope, splitting the work into phases, or moving the second mutation after the first borrow ends.",
+            "The borrow-checker message already points at the right repair pattern.",
+        ),
+        (
+            "object_safety",
+            "A Rust trait object error appeared after adding a generic method to a trait. What should I inspect first?",
+            "/workspace/glyph/runs/rlvr1/rust_cases/object_safety_case",
+            "error[E0038]: the trait `Runner` cannot be made into an object\\nmethod `run_with<T>` has generic type parameters",
+            "Inspect the newly added trait method for generics or `Self`-by-value usage. The first fix is usually moving that method behind `where Self: Sized` or redesigning it so the trait remains object safe.",
+            "The generic method is the strongest clue in the diagnostic.",
+        ),
+        (
+            "lifetime_return",
+            "A refactored Rust helper now fails because it returns a reference tied to data that does not live long enough. What should I verify first?",
+            "/workspace/glyph/runs/rlvr1/rust_cases/return_ref_case",
+            "error[E0515]: cannot return reference to local variable `tmp`",
+            "Inspect whether the returned reference points at a local temporary. The first fix is usually returning owned data instead, or tying the return reference to an input lifetime that actually outlives the function.",
+            "The return-site lifetime problem is already explicit.",
+        ),
+        (
+            "trait_bound",
+            "A new generic Rust helper now fails cargo_check because a required trait bound is absent. What should I verify first?",
+            "/workspace/glyph/runs/rlvr1/rust_cases/trait_bound_case",
+            "error[E0277]: the trait bound `T: Display` is not satisfied",
+            "Inspect the generic function signature and the operation that requires the trait. The first fix is usually adding the missing bound on `T` or removing the operation that requires it.",
+            "The missing bound and the use site are the key things to inspect.",
+        ),
+    ]
+    for case in diag_cases:
+        add("cargo_diag", cargo_diag_trace(*case))
+
+    strong_bin_cases = [
+        (
+            "bugbin_rev_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_rev",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_rev/src/main.rs",
+            'fn main() { let s = "rust"; let r: String = s.chars().collect(); println!("{r}"); }',
+            "s.chars().collect()",
+            "s.chars().rev().collect()",
+            "tsur",
+            'I patched `main.rs`, verified it with `cargo_run`, and the fixed stdout is `"tsur"`.',
+        ),
+        (
+            "bugbin_upper_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_upper",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_upper/src/main.rs",
+            'fn main() { println!("{}", "rust".to_lowercase()); }',
+            "to_lowercase",
+            "to_uppercase",
+            "RUST",
+            'I replaced the lowercase call, ran `cargo_run`, and the program now prints `"RUST"`.',
+        ),
+        (
+            "bugbin_word_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_word",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_word/src/main.rs",
+            'fn main() { let s = "one two three"; println!("{}", s.len()); }',
+            "s.len()",
+            "s.split_whitespace().count()",
+            "3",
+            'I patched the word-count logic, verified it with `cargo_run`, and stdout is now `"3"`.',
+        ),
+        (
+            "bugbin_filteralpha_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_filteralpha",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_filteralpha/src/main.rs",
+            'fn main() { let s = "abc123"; let r: String = s.chars().filter(|c| c.is_alphabetic()).collect(); println!("{}", r); }',
+            "is_alphabetic",
+            "is_numeric",
+            "123",
+            'I switched the filter, confirmed it with `cargo_run`, and the corrected stdout is `"123"`.',
+        ),
+        (
+            "bugbin_sum_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_sum",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_sum/src/main.rs",
+            'fn main() { let v = [1,2,3,4]; let s: i32 = v.iter().product(); println!("{s}"); }',
+            "v.iter().product()",
+            "v.iter().sum()",
+            "10",
+            'I changed the reducer, ran `cargo_run`, and verified the binary now prints `"10"`.',
+        ),
+        (
+            "bugbin_range_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_range",
+            "/workspace/glyph/runs/rlvr1/rust_cases/bugbin_range/src/main.rs",
+            'fn main() { let s: i32 = (1..10).sum(); println!("{s}"); }',
+            "(1..10)",
+            "(1..=10)",
+            "55",
+            'I patched the range bounds, verified them with `cargo_run`, and stdout is `"55"`.',
+        ),
+    ]
+    for case in strong_bin_cases:
+        add("strong_bin_bugfix", strong_bin_trace(*case))
+
+    strong_lib_cases = [
+        (
+            "factlib_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/factlib_bug",
+            "/workspace/glyph/runs/rlvr1/rust_cases/factlib_bug/src/lib.rs",
+            "pub fn fact(n: u32) -> u32 { (1..n).product::<u32>().max(1) }\\n\\n#[cfg(test)]\\nmod tests {\\n    use super::*;\\n    #[test] fn t() { /* asserts pass after fix */ }\\n}\\n",
+            "1..n",
+            "1..=n",
+            "I patched the range, verified the crate with `cargo_test`, and the test suite now passes.",
+        ),
+        (
+            "revstrlib_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/revstrlib_bug",
+            "/workspace/glyph/runs/rlvr1/rust_cases/revstrlib_bug/src/lib.rs",
+            "pub fn rev(s: &str) -> String { s.chars().collect() }\\n\\n#[cfg(test)]\\nmod tests {\\n    use super::*;\\n    #[test] fn t() { /* asserts pass after fix */ }\\n}\\n",
+            "s.chars().collect()",
+            "s.chars().rev().collect()",
+            "I added the missing reversal, ran `cargo_test`, and the crate now passes its tests.",
+        ),
+        (
+            "sumlib_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/sumlib_bug",
+            "/workspace/glyph/runs/rlvr1/rust_cases/sumlib_bug/src/lib.rs",
+            "pub fn sum(s: &[i32]) -> i32 { s.iter().product() }\\n\\n#[cfg(test)]\\nmod tests {\\n    use super::*;\\n    #[test] fn t() { /* asserts pass after fix */ }\\n}\\n",
+            "s.iter().product()",
+            "s.iter().sum()",
+            "I switched the iterator reducer, verified with `cargo_test`, and the crate is green now.",
+        ),
+        (
+            "gcdlib_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/gcdlib_bug",
+            "/workspace/glyph/runs/rlvr1/rust_cases/gcdlib_bug/src/lib.rs",
+            "pub fn gcd(a: u32, b: u32) -> u32 { if b == 0 { b } else { gcd(b, a % b) } }\\n\\n#[cfg(test)]\\nmod tests {\\n    use super::*;\\n    #[test] fn t() { /* asserts pass after fix */ }\\n}\\n",
+            "if b == 0 { b }",
+            "if b == 0 { a }",
+            "I corrected the base case, ran `cargo_test`, and the test suite now passes cleanly.",
+        ),
+        (
+            "maxlib_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/maxlib_bug",
+            "/workspace/glyph/runs/rlvr1/rust_cases/maxlib_bug/src/lib.rs",
+            "pub fn max_of(s: &[i32]) -> i32 { *s.iter().min().unwrap_or(&0) }\\n\\n#[cfg(test)]\\nmod tests {\\n    use super::*;\\n    #[test] fn t() { /* asserts pass after fix */ }\\n}\\n",
+            "s.iter().min()",
+            "s.iter().max()",
+            "I swapped the iterator method, verified with `cargo_test`, and the crate's tests now pass.",
+        ),
+        (
+            "vowelslib_strong",
+            "/workspace/glyph/runs/rlvr1/rust_cases/vowelslib_bug",
+            "/workspace/glyph/runs/rlvr1/rust_cases/vowelslib_bug/src/lib.rs",
+            "pub fn vowels(s: &str) -> usize { s.chars().filter(|c| \\\"bcdfg\\\".contains(*c)).count() }\\n\\n#[cfg(test)]\\nmod tests {\\n    use super::*;\\n    #[test] fn t() { /* asserts pass after fix */ }\\n}\\n",
+            "\\\"bcdfg\\\"",
+            "\\\"aeiouAEIOU\\\"",
+            "I fixed the filter set, confirmed it with `cargo_test`, and the tests now pass.",
+        ),
+    ]
+    for case in strong_lib_cases:
+        add("strong_lib_bugfix", strong_lib_trace(*case))
+
+    return traces, counts
+
+
+def main() -> int:
+    traces, counts = build_traces()
+    eval_users = load_eval_users()
+    dataset_users = extract_users(traces)
+    overlaps = sorted(set(dataset_users) & eval_users)
+    base_rows = sum(1 for row in BASE_DATASET.read_text(encoding="utf-8").splitlines() if row.strip())
+    combined_out = ROOT / "synthetic_data" / f"gold_glyph_{base_rows + len(traces)}_plus_rlvr_seed_final_v1.jsonl"
+
+    invalid: list[dict[str, object]] = []
+    for idx, trace in enumerate(traces):
+        result = validate_trace(trace)
+        if not result.valid:
+            invalid.append({"index": idx, "errors": result.errors[:5]})
+
+    if invalid:
+        print(json.dumps({"invalid": invalid[:10], "count": len(invalid)}, indent=2))
+        return 1
+
+    if overlaps:
+        print(json.dumps({"exact_prompt_overlaps": overlaps[:10], "count": len(overlaps)}, indent=2))
+        return 1
+
+    with TOPUP_OUT.open("w", encoding="utf-8") as f:
+        for trace in traces:
+            f.write(json.dumps({"trace": trace}, ensure_ascii=False) + "\n")
+
+    combined_rows = BASE_DATASET.read_text(encoding="utf-8").splitlines()
+    with combined_out.open("w", encoding="utf-8") as f:
+        for row in combined_rows:
+            if row.strip():
+                f.write(row + "\n")
+        for trace in traces:
+            f.write(json.dumps({"trace": trace}, ensure_ascii=False) + "\n")
+
+    report = {
+        "topup_file": str(TOPUP_OUT.relative_to(ROOT)),
+        "combined_file": str(combined_out.relative_to(ROOT)),
+        "base_rows": base_rows,
+        "topup_rows": len(traces),
+        "combined_rows": base_rows + len(traces),
+        "counts": counts,
+        "exact_prompt_overlap_count": 0,
+    }
+    REPORT_OUT.write_text(json.dumps(report, indent=2), encoding="utf-8")
+    print(json.dumps(report, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

build_rlvr_seed_microfix_v1.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""Build a tiny surgical SFT top-up for the remaining formal failures."""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import yaml
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+if str(ROOT / "synthetic_data") not in sys.path:
+    sys.path.insert(0, str(ROOT / "synthetic_data"))
+
+import build_gold50 as g  # noqa: E402
+from core.validator import validate_trace  # noqa: E402
+from synthetic_data.build_gold_rust_tooluse import SYSTEM, rust_dev_tools, three_tool_trace  # noqa: E402
+
+
+BASE_DATASET = ROOT / "synthetic_data" / "gold_glyph_3141_plus_rlvr_seed_final_v1.jsonl"
+EVAL_PROMPTS = ROOT / "sft" / "evals" / "prompts_125.yaml"
+TOPUP_OUT = ROOT / "synthetic_data" / "rlvr_seed_microfix_v1.jsonl"
+COMBINED_OUT = ROOT / "synthetic_data" / "gold_glyph_3148_plus_rlvr_seed_microfix_v1.jsonl"
+REPORT_OUT = ROOT / "synthetic_data" / "rlvr_seed_microfix_v1_report.json"
+
+
+def load_eval_users() -> set[str]:
+    data = yaml.safe_load(EVAL_PROMPTS.read_text(encoding="utf-8"))
+    rows = data["formal_eval"] if isinstance(data, dict) else data
+    return {row["user"] for row in rows}
+
+
+def extract_users(traces: list[str]) -> list[str]:
+    users: list[str] = []
+    marker = "<|im_start|>user\nuser「"
+    end = "」🏷 usr1"
+    for trace in traces:
+        start = trace.index(marker) + len(marker)
+        stop = trace.index(end, start)
+        users.append(trace[start:stop])
+    return users
+
+
+def cargo_diag_trace(
+    name: str,
+    user: str,
+    project_path: str,
+    stderr: str,
+    response: str,
+    note: str,
+) -> str:
+    todos = [
+        f"Run cargo_check on {project_path} to inspect the compiler diagnostic.",
+        "Give a concise diagnosis and first repair direction.",
+    ]
+    rationale = "The critical thing is to finish with the final diagnosis todo satisfied and a clean response."
+    return g.join_trace(
+        g.system_seg(
+            "You are a Rust debugging assistant. Use the available tools sparingly and close the trace cleanly.",
+            rust_dev_tools(),
+        ),
+        g.user_seg(user),
+        g.assistant_seg(
+            g.plan_block(todos, rationale),
+            g.call_act("cargo_check", [("project_path", project_path)], f"chk_{name}", 1),
+        ),
+        g.result_seg(f"status: failure\\nexit_code: 101\\nstderr: {stderr}", f"chk_{name}"),
+        g.assistant_seg(
+            g.think_act([(note, f"note_{name}", [f"chk_{name}"])]),
+            g.response_block(response, [f"chk_{name}", f"note_{name}"], 2),
+        ),
+    )
+
+
+def plan_trace(
+    name: str,
+    user: str,
+    availability: str,
+    plan_result: str,
+    response: str,
+) -> str:
+    return g.join_trace(
+        g.system_seg(
+            "You are a planning assistant who uses tools and always ends with one clean final response.",
+            [
+                g.tool(
+                    "get_availability",
+                    "Returns weekly availability by teammate.",
+                    g.param("team_list", "string", "Comma-separated IDs", required=False),
+                    g.param("start_date", "string", "Start date", required=False),
+                    g.param("end_date", "string", "End date", required=False),
+                ),
+                g.tool(
+                    "create_project_plan",
+                    "Generates a short work breakdown.",
+                    g.param("project_name", "string", "Project name", required=False),
+                    g.param("objectives", "string", "Objectives", required=False),
+                    g.param("timeline_weeks", "string", "Timeline in weeks", required=False),
+                ),
+            ],
+        ),
+        g.user_seg(user),
+        g.assistant_seg(
+            g.plan_block(
+                [
+                    "Check team availability for the rollout window.",
+                    "Generate a high-level work breakdown.",
+                    "Provide a prioritized schedule with launch checks.",
+                ],
+                "Get capacity first, then a work breakdown, then a clean final schedule.",
+            ),
+            g.call_act(
+                "get_availability",
+                [
+                    ("team_list", "alex, beth, chris, diana"),
+                    ("start_date", "2026-09-01"),
+                    ("end_date", "2026-09-29"),
+                ],
+                f"avail_{name}",
+                1,
+            ),
+        ),
+        g.result_seg(availability, f"avail_{name}"),
+        g.assistant_seg(
+            g.think_act([("Availability is known, so generate the work breakdown next.", f"note_a_{name}", [f"avail_{name}"])]),
+            g.call_act(
+                "create_project_plan",
+                [
+                    ("project_name", "search filter redesign"),
+                    ("objectives", "new UI, backend updates, A/B testing, docs"),
+                    ("timeline_weeks", "4"),
+                ],
+                f"plan_{name}",
+                2,
+            ),
+        ),
+        g.result_seg(plan_result, f"plan_{name}"),
+        g.assistant_seg(
+            g.think_act([("Use the plan output to write the final schedule, then stop cleanly.", f"note_b_{name}", [f"avail_{name}", f"plan_{name}"])]),
+            g.response_block(response, [f"avail_{name}", f"plan_{name}", f"note_b_{name}"], 3),
+        ),
+    )
+
+
+def reverse_bin_trace(
+    name: str,
+    user: str,
+    project_path: str,
+    file_path: str,
+    source: str,
+    find: str,
+    replace: str,
+    stdout: str,
+    response: str,
+) -> str:
+    todos = [
+        f"Read {file_path} to find the exact buggy snippet.",
+        "Apply one targeted patch.",
+        f"Run cargo_run on {project_path} and report the stdout.",
+    ]
+    rationale = "Do not stop after apply_patch; the verifier call must happen before the final response."
+    return three_tool_trace(
+        user,
+        todos,
+        rationale,
+        "read_file",
+        [("file_path", file_path)],
+        f"src_{name}",
+        source.replace('"', '\\"'),
+        "The source is short and the exact replacement text is visible.",
+        f"note_src_{name}",
+        "apply_patch",
+        [("file_path", file_path), ("find", find), ("replace", replace)],
+        f"patch_{name}",
+        "status: success\\nexit_code: 0",
+        "The patch succeeded, but the task is not complete until cargo_run verifies stdout.",
+        f"note_patch_{name}",
+        "cargo_run",
+        [("project_path", project_path)],
+        f"run_{name}",
+        f"status: success\\nexit_code: 0\\nstdout: {stdout}",
+        "The verifier output is now available, so the final response can close the trace.",
+        f"note_run_{name}",
+        response,
+    )
+
+
+def build_traces() -> list[str]:
+    traces = [
+        cargo_diag_trace(
+            "recursive_type_box",
+            "A Rust enum now fails to compile because a recursive variant makes the type size infinite. What is the first fix to check?",
+            "/workspace/glyph/runs/rlvr1/rust_cases/recursive_type_case",
+            "error[E0072]: recursive type `Node` has infinite size\\nhelp: insert some indirection such as `Box`, `Rc`, or `&` to break the cycle",
+            "Inspect the recursive field and add indirection at that edge, usually with `Box<T>`. Recursive enums and structs need an indirection point so the compiler can give the type a finite size.",
+            "The diagnostic already says the type needs indirection, so the response should close cleanly after that fix direction.",
+        ),
+        cargo_diag_trace(
+            "recursive_type_traitobj",
+            "Cargo check says a recursive Rust type has infinite size after a refactor. What should I inspect first?",
+            "/workspace/glyph/runs/rlvr1/rust_cases/recursive_layout_case",
+            "error[E0072]: recursive type `Expr` has infinite size\\nnote: recursive field without indirection",
+            "Inspect the recursive field path and make sure one link uses indirection, commonly `Box<Expr>`. Without that indirection the compiler cannot lay out the recursive type at a finite size.",
+            "The important thing is to satisfy the final diagnosis todo, not stop at the tool output.",
+        ),
+        plan_trace(
+            "search_rollout",
+            "We have four weeks to ship a search filter redesign. Check capacity, generate a work breakdown, then give me a prioritized rollout schedule with launch checks.",
+            "alex: 60%\\nbeth: 80%\\nchris: 50%\\ndiana: 75%",
+            "Week 1: UX/spec\\nWeek 2: frontend build\\nWeek 3: backend + integration\\nWeek 4: QA + docs + launch",
+            "Prioritize the redesign as a four-week rollout: week 1 for UX/spec alignment, week 2 for frontend implementation, week 3 for backend and integration, and week 4 for QA, docs, and launch prep. Launch checks should cover cross-device UI validation, query latency, experiment readiness, and documentation completion.",
+        ),
+        plan_trace(
+            "mobile_error_state",
+            "Use the team availability and a generated plan to propose a four-week rollout for a mobile error-state redesign, then end with launch checks.",
+            "alex: 70%\\nbeth: 70%\\nchris: 55%\\ndiana: 85%",
+            "Week 1: design + instrumentation\\nWeek 2: UI implementation\\nWeek 3: backend wiring + metrics\\nWeek 4: QA, docs, rollout checks",
+            "A reasonable four-week rollout is: week 1 for design and instrumentation, week 2 for UI implementation, week 3 for backend wiring and metrics, and week 4 for QA, docs, and rollout checks. Before launch, confirm the new states render correctly, telemetry is firing, backend fallbacks behave, and support docs are updated.",
+        ),
+        reverse_bin_trace(
+            "reverse_collect",
+            'The Cargo binary at "/workspace/glyph/runs/rlvr1/rust_cases/rev_collect_app" prints the string in the wrong order. Read the file, patch it, run cargo_run, and tell me the fixed stdout.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/rev_collect_app",
+            "/workspace/glyph/runs/rlvr1/rust_cases/rev_collect_app/src/main.rs",
+            'fn main() { let s = "rust"; let out: String = s.chars().collect(); println!("{out}"); }',
+            "s.chars().collect()",
+            "s.chars().rev().collect()",
+            "tsur",
+            'I added the missing iterator reversal, verified it with `cargo_run`, and the binary now prints `"tsur"`.',
+        ),
+        reverse_bin_trace(
+            "reverse_join",
+            'The binary at "/workspace/glyph/runs/rlvr1/rust_cases/rev_join_app" should print a reversed word. Inspect it, patch the bug, run cargo_run, and report stdout.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/rev_join_app",
+            "/workspace/glyph/runs/rlvr1/rust_cases/rev_join_app/src/main.rs",
+            'fn main() { let s = "hello"; let out: String = s.chars().collect(); println!("{out}"); }',
+            "s.chars().collect()",
+            "s.chars().rev().collect()",
+            "olleh",
+            'I patched the string construction, ran `cargo_run`, and confirmed the fixed stdout is `"olleh"`.',
+        ),
+        reverse_bin_trace(
+            "reverse_chars",
+            'Read "/workspace/glyph/runs/rlvr1/rust_cases/rev_chars_app/src/main.rs", apply one exact patch, then verify with cargo_run and tell me the corrected output.',
+            "/workspace/glyph/runs/rlvr1/rust_cases/rev_chars_app",
+            "/workspace/glyph/runs/rlvr1/rust_cases/rev_chars_app/src/main.rs",
+            'fn main() { let s = "abcde"; let out: String = s.chars().collect(); println!("{out}"); }',
+            "s.chars().collect()",
+            "s.chars().rev().collect()",
+            "edcba",
+            'I inserted the missing reversal, verified the result with `cargo_run`, and the program now prints `"edcba"`.',
+        ),
+    ]
+    return traces
+
+
+def main() -> int:
+    traces = build_traces()
+    overlaps = sorted(set(extract_users(traces)) & load_eval_users())
+    invalid = []
+    for i, trace in enumerate(traces):
+        res = validate_trace(trace)
+        if not res.valid:
+            invalid.append({"index": i, "errors": res.errors[:5]})
+    if overlaps:
+        print(json.dumps({"exact_prompt_overlaps": overlaps}, indent=2))
+        return 1
+    if invalid:
+        print(json.dumps({"invalid": invalid}, indent=2))
+        return 1
+    with TOPUP_OUT.open("w", encoding="utf-8") as f:
+        for trace in traces:
+            f.write(json.dumps({"trace": trace}, ensure_ascii=False) + "\n")
+    rows = [row for row in BASE_DATASET.read_text(encoding="utf-8").splitlines() if row.strip()]
+    with COMBINED_OUT.open("w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(row + "\n")
+        for trace in traces:
+            f.write(json.dumps({"trace": trace}, ensure_ascii=False) + "\n")
+    report = {
+        "base_rows": len(rows),
+        "topup_rows": len(traces),
+        "combined_rows": len(rows) + len(traces),
+        "topup_file": str(TOPUP_OUT.relative_to(ROOT)),
+        "combined_file": str(COMBINED_OUT.relative_to(ROOT)),
+        "exact_prompt_overlap_count": 0,
+    }
+    REPORT_OUT.write_text(json.dumps(report, indent=2), encoding="utf-8")
+    print(json.dumps(report, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())