feat: export lora training dataset

Co-authored-by: Codex <noreply@openai.com>

README.md

@@ -75,6 +75,13 @@ The `chapter` Gradio API endpoint and `Chapter` button export the public-facing
 one fate page per idea, each with verdict, score, targets, and closest cited pages. It is the shareable companion to
 the private Field Notes artifact.
 
+## LoRA Dataset Artifact
+
+The `lora_dataset` Gradio API endpoint and `LoRA` button export a compact chat JSONL dataset from successful session
+turns. Each included turn yields a tool-call example and an advisor-response example for `openbmb/MiniCPM5-1B`, with the
+selected targets, parsed XML tool call, tool observations, and score context preserved. This prepares the Well-Tuned
+path without claiming that the adapter has already been trained or published.
+
 ## Prize Ledger
 
 `/api/prize-ledger` and the in-app Prize Ledger panel expose submission evidence: the documented model stack, total

app.py

@@ -12,6 +12,7 @@ from hackathon_advisor.agent import AdvisorEngine
 from hackathon_advisor.chapter import build_chapter_markdown
 from hackathon_advisor.data import ProjectIndex
 from hackathon_advisor.field_notes import build_field_notes_markdown
+from hackathon_advisor.lora_dataset import build_lora_dataset_jsonl
 from hackathon_advisor.prize_ledger import prize_ledger
 from hackathon_advisor.tool_contracts import resolve_tool_call, tool_schemas
 from hackathon_advisor.tools import TARGETS
@@ -134,6 +135,21 @@ def chapter_artifact(session_json: str = "{}") -> str:
     )
 
 
+@app.api(name="lora_dataset", concurrency_limit=8)
+def lora_dataset_artifact(session_json: str = "{}") -> str:
+    try:
+        session = json.loads(session_json or "{}")
+    except json.JSONDecodeError:
+        session = {}
+    return build_lora_dataset_jsonl(
+        session,
+        {
+            **trace_metadata(index),
+            "project_count": len(index.projects),
+        },
+    )
+
+
 @app.api(name="agent_turn", concurrency_limit=4, stream_every=0.04)
 def agent_turn(message: str, session_json: str = "{}") -> Iterator[str]:
     try:

hackathon_advisor/lora_dataset.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+from typing import Any
+
+
+LORA_DATASET_SCHEMA_VERSION = 1
+BASE_MODEL = "openbmb/MiniCPM5-1B"
+ADAPTER_TASK = "hackathon_advisor_tool_call_and_voice"
+
+TOOL_CALL_SYSTEM_PROMPT = (
+    "You are Mothback, the Build Small Hackathon advisor. Choose exactly one validated tool call for the user's "
+    "project-advice request. Return only the XML function call."
+)
+
+RESPONSE_SYSTEM_PROMPT = (
+    "You are Mothback, the Build Small Hackathon advisor. Write concise, evidence-grounded advice from the tool "
+    "observations, cited pages, score, and selected prize targets."
+)
+
+
+def build_lora_dataset_jsonl(session: dict[str, Any], metadata: dict[str, Any]) -> str:
+    trace = _list_of_dicts(session.get("trace"))
+    ideas = _list_of_dicts(session.get("ideas"))
+    targets = [str(target) for target in session.get("targets") or []]
+    examples = _examples(trace, targets)
+    records = [
+        {
+            "type": "lora_sft_manifest",
+            "schema_version": LORA_DATASET_SCHEMA_VERSION,
+            "generated_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+            "app": "hackathon-advisor",
+            "base_model": BASE_MODEL,
+            "adapter_task": ADAPTER_TASK,
+            "format": "chat-jsonl",
+            "record_kinds": ["tool_call", "advisor_response"],
+            "source": "exact_session_trace",
+            "idea_count": len(ideas),
+            "turn_count": len(trace),
+            "included_turn_count": len({example["turn_index"] for example in examples}),
+            "example_count": len(examples),
+            "index": _index_metadata(metadata),
+        }
+    ]
+    records.extend(examples)
+    return "\n".join(json.dumps(record, ensure_ascii=False, sort_keys=True) for record in records) + "\n"
+
+
+def _examples(trace: list[dict[str, Any]], targets: list[str]) -> list[dict[str, Any]]:
+    examples: list[dict[str, Any]] = []
+    for turn_index, event in enumerate(trace, start=1):
+        if not _is_successful_turn(event):
+            continue
+        input_text = _clean(event.get("input"))
+        response = _clean(event.get("response"))
+        if not input_text or not response:
+            continue
+        tool_call = _tool_call(event)
+        if not tool_call["name"]:
+            continue
+        shared = {
+            "type": "lora_sft_example",
+            "schema_version": LORA_DATASET_SCHEMA_VERSION,
+            "base_model": BASE_MODEL,
+            "adapter_task": ADAPTER_TASK,
+            "turn_index": turn_index,
+            "targets": targets,
+            "score": _score(event),
+            "tool_call": tool_call,
+            "tool_observations": _tool_observations(event),
+        }
+        examples.append(
+            {
+                **shared,
+                "example_index": len(examples) + 1,
+                "example_kind": "tool_call",
+                "messages": [
+                    {"role": "system", "content": TOOL_CALL_SYSTEM_PROMPT},
+                    {"role": "user", "content": input_text},
+                    {"role": "assistant", "content": _tool_call_xml(tool_call)},
+                ],
+            }
+        )
+        examples.append(
+            {
+                **shared,
+                "example_index": len(examples) + 1,
+                "example_kind": "advisor_response",
+                "messages": [
+                    {"role": "system", "content": RESPONSE_SYSTEM_PROMPT},
+                    {"role": "user", "content": _response_context(input_text, event, tool_call)},
+                    {"role": "assistant", "content": response},
+                ],
+            }
+        )
+    return examples
+
+
+def _is_successful_turn(event: dict[str, Any]) -> bool:
+    resolution = event.get("tool_resolution") if isinstance(event.get("tool_resolution"), dict) else {}
+    return str(resolution.get("status") or "") == "valid"
+
+
+def _tool_call(event: dict[str, Any]) -> dict[str, Any]:
+    resolution = event.get("tool_resolution") if isinstance(event.get("tool_resolution"), dict) else {}
+    call = resolution.get("call") if isinstance(resolution.get("call"), dict) else {}
+    arguments = call.get("arguments") if isinstance(call.get("arguments"), dict) else {}
+    return {
+        "name": _clean(call.get("name")),
+        "arguments": arguments,
+    }
+
+
+def _tool_call_xml(tool_call: dict[str, Any]) -> str:
+    arguments = json.dumps(tool_call["arguments"], ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    return f'<function name="{tool_call["name"]}">{arguments}</function>'
+
+
+def _response_context(input_text: str, event: dict[str, Any], tool_call: dict[str, Any]) -> str:
+    observations = _tool_observations(event)
+    lines = [
+        input_text,
+        "",
+        f"Tool call: {_tool_call_xml(tool_call)}",
+        "Tool observations:",
+    ]
+    if observations:
+        for observation in observations:
+            lines.append(f"- {observation['name']}: {observation['summary']}")
+    else:
+        lines.append("- none")
+
+    score = _score(event)
+    verdict = score["verdict"] or "n/a"
+    overall = score["overall"] if score["overall"] is not None else "n/a"
+    lines.extend(
+        [
+            f"Verdict: {verdict}",
+            f"Overall: {overall}",
+            f"Plan steps: {score['plan_steps']}",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def _tool_observations(event: dict[str, Any]) -> list[dict[str, str]]:
+    observations = []
+    for tool in _list_of_dicts(event.get("tools")):
+        name = _clean(tool.get("name"))
+        summary = _clean(tool.get("summary"))
+        if name or summary:
+            observations.append({"name": name, "summary": summary})
+    return observations
+
+
+def _score(event: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "verdict": _clean(event.get("verdict")),
+        "overall": event.get("overall"),
+        "plan_steps": int(event.get("plan_steps") or 0),
+    }
+
+
+def _index_metadata(metadata: dict[str, Any]) -> dict[str, str]:
+    return {
+        "algorithm": _clean(metadata.get("index_algorithm")),
+        "snapshot_generated_at": _clean(metadata.get("snapshot_generated_at")),
+        "index_generated_at": _clean(metadata.get("index_generated_at")),
+        "snapshot_digest": _clean(metadata.get("snapshot_digest")),
+    }
+
+
+def _list_of_dicts(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    return [item for item in value if isinstance(item, dict)]
+
+
+def _clean(value: Any) -> str:
+    if value is None:
+        return ""
+    return " ".join(str(value).split())

hackathon_advisor/prize_ledger.py

@@ -63,8 +63,8 @@ BADGE_LEDGER = [
     },
     {
         "name": "Well-Tuned",
-        "status": "planned",
-        "evidence": "Plan includes a MiniCPM5 LoRA path; adapter publication remains a separate build milestone.",
+        "status": "dataset-ready",
+        "evidence": "LoRA SFT dataset export is generated from exact session traces; adapter publication remains a separate build milestone.",
     },
     {
         "name": "Llama Champion",
@@ -74,6 +74,17 @@ BADGE_LEDGER = [
 ]
 
 
+TRAINING_ARTIFACTS = [
+    {
+        "name": "MiniCPM5 LoRA SFT dataset",
+        "status": "export-ready",
+        "endpoint": "lora_dataset",
+        "format": "chat-jsonl",
+        "base_model": "openbmb/MiniCPM5-1B",
+    }
+]
+
+
 def prize_ledger(runtime: dict[str, Any]) -> dict[str, Any]:
     total_params = round(sum(float(item["params_b"]) for item in MODEL_STACK), 2)
     largest = max(MODEL_STACK, key=lambda item: float(item["params_b"]))
@@ -88,4 +99,5 @@ def prize_ledger(runtime: dict[str, Any]) -> dict[str, Any]:
         "tiny_titan_limit_b": 4.0,
         "tiny_titan_eligible": total_params <= 4.0 and float(largest["params_b"]) <= 4.0,
         "badges": BADGE_LEDGER,
+        "training_artifacts": TRAINING_ARTIFACTS,
     }

static/app.js

@@ -22,6 +22,7 @@ const exportButton = document.querySelector("#export-artifact");
 const exportTraceButton = document.querySelector("#export-trace");
 const exportNotesButton = document.querySelector("#export-notes");
 const exportChapterButton = document.querySelector("#export-chapter");
+const exportLoraButton = document.querySelector("#export-lora");
 const resetButton = document.querySelector("#reset-session");
 
 const SESSION_STORAGE_KEY = "hackathon-advisor-session-v1";
@@ -66,6 +67,10 @@ exportChapterButton.addEventListener("click", async () => {
   await exportChapter();
 });
 
+exportLoraButton.addEventListener("click", async () => {
+  await exportLoraDataset();
+});
+
 resetButton.addEventListener("click", () => {
   clearSavedSession();
   window.location.reload();
@@ -183,6 +188,7 @@ function renderRestoredSession(data) {
   exportTraceButton.disabled = !(session.trace?.length);
   exportNotesButton.disabled = !(session.trace?.length);
   exportChapterButton.disabled = !(session.ideas?.length);
+  exportLoraButton.disabled = !(session.trace?.length);
 }
 
 function readSavedSession() {
@@ -297,6 +303,21 @@ function renderPrizeLedger(ledger) {
     badges.append(item);
   }
   prizeLedgerEl.append(header, badges);
+  if (ledger.training_artifacts?.length) {
+    const artifacts = document.createElement("div");
+    artifacts.className = "training-artifact-list";
+    for (const artifact of ledger.training_artifacts.slice(0, 3)) {
+      const item = document.createElement("div");
+      item.className = "training-artifact";
+      item.title = artifact.endpoint || artifact.name;
+      item.innerHTML = `
+        <strong>${escapeHtml(artifact.name)}</strong>
+        <span>${escapeHtml(artifact.status)} · ${escapeHtml(artifact.format || "jsonl")}</span>
+      `;
+      artifacts.append(item);
+    }
+    prizeLedgerEl.append(artifacts);
+  }
 }
 
 function handleEvent(event) {
@@ -350,6 +371,7 @@ function handleEvent(event) {
     exportTraceButton.disabled = !(session.trace?.length);
     exportNotesButton.disabled = !(session.trace?.length);
     exportChapterButton.disabled = !(session.ideas?.length);
+    exportLoraButton.disabled = !(session.trace?.length);
     saveSession();
   }
 }
@@ -525,12 +547,14 @@ function setCommandDisabled(disabled) {
     const isTrace = button.id === "export-trace";
     const isNotes = button.id === "export-notes";
     const isChapter = button.id === "export-chapter";
+    const isLora = button.id === "export-lora";
     button.disabled =
       disabled ||
       (isArtifact && !currentArtifact) ||
       (isTrace && !session.trace?.length) ||
       (isNotes && !session.trace?.length) ||
-      (isChapter && !session.ideas?.length);
+      (isChapter && !session.ideas?.length) ||
+      (isLora && !session.trace?.length);
   });
 }
 
@@ -594,6 +618,15 @@ async function exportChapter() {
   downloadText("hackathon-advisor-chapter.md", String(data || ""), "text/markdown;charset=utf-8");
 }
 
+async function exportLoraDataset() {
+  const client = await clientPromise;
+  const result = await client.predict("/lora_dataset", {
+    session_json: JSON.stringify(session),
+  });
+  const data = Array.isArray(result.data) ? result.data[0] : result.data;
+  downloadText("hackathon-advisor-lora-sft.jsonl", String(data || ""));
+}
+
 function exportArtifact(artifact) {
   const canvas = document.createElement("canvas");
   canvas.width = 1200;

static/index.html

@@ -35,6 +35,7 @@
               <button type="button" id="export-trace" title="Export the tool trace" disabled>JSONL</button>
               <button type="button" id="export-notes" title="Export Field Notes" disabled>Notes</button>
               <button type="button" id="export-chapter" title="Export the Almanac chapter" disabled>Chapter</button>
+              <button type="button" id="export-lora" title="Export the LoRA SFT dataset" disabled>LoRA</button>
               <button type="button" id="export-artifact" title="Export the current fate page" disabled>PNG</button>
               <button type="button" id="reset-session" title="Clear the saved session">Reset</button>
             </div>

static/styles.css

@@ -313,7 +313,8 @@ button:disabled {
 .idea,
 .trace,
 .target-toggle,
-.profile-field {
+.profile-field,
+.training-artifact {
   border-left: 3px solid rgba(80, 47, 22, 0.48);
   padding: 8px 10px;
   background: rgba(255, 241, 196, 0.34);
@@ -468,6 +469,10 @@ button:disabled {
   border-left-color: var(--gold);
 }
 
+.badge-item.dataset-ready {
+  border-left-color: #5f6d38;
+}
+
 .badge-item.planned {
   border-left-color: var(--muted-ink);
 }
@@ -478,6 +483,31 @@ button:disabled {
   text-transform: uppercase;
 }
 
+.training-artifact-list {
+  display: grid;
+  gap: 7px;
+}
+
+.training-artifact {
+  display: grid;
+  gap: 4px;
+  min-width: 0;
+}
+
+.training-artifact strong {
+  color: #2a170d;
+  font-size: 0.82rem;
+  line-height: 1.25;
+}
+
+.training-artifact span {
+  color: var(--muted-ink);
+  font-size: 0.72rem;
+  line-height: 1.25;
+  font-weight: 900;
+  overflow-wrap: anywhere;
+}
+
 .wood-map-field {
   position: relative;
   min-height: 138px;

tests/test_app.py

@@ -7,6 +7,7 @@ from app import (
     field_notes_artifact,
     health,
     index,
+    lora_dataset_artifact,
     prize_ledger_endpoint,
     runtime,
     tool_contract_check,
@@ -76,6 +77,23 @@ def test_chapter_endpoint_exports_markdown() -> None:
     assert "Closest inked pages:" in payload
 
 
+def test_lora_dataset_endpoint_exports_sft_jsonl() -> None:
+    state = engine.turn(
+        "A local-first archive cartographer for family photos",
+        {"targets": ["Well-Tuned"]},
+    ).state
+    state = engine.turn("make a build plan", state).state
+
+    payload = lora_dataset_artifact(json.dumps(state))
+    lines = [json.loads(line) for line in payload.splitlines()]
+
+    assert lines[0]["type"] == "lora_sft_manifest"
+    assert lines[0]["example_count"] == len(lines) - 1
+    assert lines[1]["example_kind"] == "tool_call"
+    assert lines[1]["base_model"] == "openbmb/MiniCPM5-1B"
+    assert lines[2]["example_kind"] == "advisor_response"
+
+
 def test_tool_contracts_endpoint_exposes_schemas() -> None:
     payload = tool_contracts()
 
@@ -104,3 +122,4 @@ def test_prize_ledger_endpoint_reports_submission_evidence() -> None:
     assert payload["runtime"]["backend"] == "rules"
     assert payload["tiny_titan_eligible"] is True
     assert any(badge["name"] == "Sharing is Caring" for badge in payload["badges"])
+    assert payload["training_artifacts"][0]["endpoint"] == "lora_dataset"

tests/test_lora_dataset.py

@@ -0,0 +1,49 @@
+import json
+from pathlib import Path
+
+from hackathon_advisor.agent import AdvisorEngine
+from hackathon_advisor.data import ProjectIndex
+from hackathon_advisor.lora_dataset import BASE_MODEL, build_lora_dataset_jsonl
+from hackathon_advisor.trace_export import trace_metadata
+
+
+def test_lora_dataset_exports_tool_call_and_response_examples() -> None:
+    index = ProjectIndex.from_files(Path("data/projects.json"), Path("data/project_index.json"))
+    engine = AdvisorEngine(index)
+    state = {"targets": ["Well-Tuned", "Field Notes"]}
+    state = engine.turn("A local-first archive cartographer for family photos", state).state
+    state = engine.turn("make a build plan", state).state
+
+    lines = [json.loads(line) for line in build_lora_dataset_jsonl(state, trace_metadata(index)).splitlines()]
+    manifest = lines[0]
+    examples = lines[1:]
+
+    assert manifest["type"] == "lora_sft_manifest"
+    assert manifest["base_model"] == BASE_MODEL
+    assert manifest["record_kinds"] == ["tool_call", "advisor_response"]
+    assert manifest["example_count"] == len(examples)
+    assert manifest["included_turn_count"] == 2
+    assert manifest["index"]["algorithm"] == "tfidf-sparse-v1"
+    assert {example["example_kind"] for example in examples} == {"tool_call", "advisor_response"}
+    assert examples[0]["messages"][2]["content"].startswith('<function name="save_idea">')
+    assert examples[0]["targets"] == ["Well-Tuned", "Field Notes"]
+    assert examples[1]["messages"][1]["content"].startswith("A local-first archive")
+    assert "Tool observations:" in examples[1]["messages"][1]["content"]
+    assert examples[1]["messages"][2]["content"]
+
+
+def test_empty_lora_dataset_only_exports_manifest() -> None:
+    payload = build_lora_dataset_jsonl(
+        {},
+        {
+            "index_algorithm": "tfidf-sparse-v1",
+            "snapshot_generated_at": "2026-06-06T00:00:00+00:00",
+            "index_generated_at": "2026-06-06T01:00:00+00:00",
+            "snapshot_digest": "abc",
+        },
+    )
+    lines = [json.loads(line) for line in payload.splitlines()]
+
+    assert len(lines) == 1
+    assert lines[0]["example_count"] == 0
+    assert lines[0]["turn_count"] == 0

tests/test_prize_ledger.py

@@ -10,4 +10,5 @@ def test_prize_ledger_tracks_param_budget_and_badges() -> None:
     assert payload["largest_model"]["model"] == "openbmb/MiniCPM5-1B"
     badges = {badge["name"]: badge["status"] for badge in payload["badges"]}
     assert badges["Off the Grid"] == "ready"
-    assert badges["Well-Tuned"] == "planned"
+    assert badges["Well-Tuned"] == "dataset-ready"
+    assert payload["training_artifacts"][0]["base_model"] == "openbmb/MiniCPM5-1B"