nemotron(signed-corpus): add missing ingest/corpus/verify modules (race fix)

Direct HF commit of the three modules that the prior commit raced with the GitHub->HF backend mirror. Dockerfile COPY already references them. ADDITIVE; honest SAMPLE corpus; CC BY 4.0 NVIDIA attribution.

szl_nemo_verify.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11/v12
+# Authored by the NEMOTRON SIGNED-TRAJECTORY build team. Co-Authored-By: Perplexity Computer Agent.
+"""
+szl_nemo_verify — standalone verifier for the SZL-Nemo signed-trajectory corpus.
+
+Anyone can run this against a downloaded corpus JSONL to independently check:
+  1. CONTENT INTEGRITY — recompute each step's sha256 step_hash and compare.
+  2. SIGNATURE  — if a step carries a DSSE signature, verify it against the
+     published SZLHOLDINGS cosign public key (cosign.pub).
+
+USAGE:
+    python szl_nemo_verify.py path/to/corpus.jsonl
+    cat corpus.jsonl | python szl_nemo_verify.py -
+
+EXIT CODE: 0 if every present signature verifies AND every hash matches; else 1.
+
+HONEST: when the corpus was emitted in an environment without the private signing
+key, the receipts are UNSIGNED (signatures: []) — this verifier reports that
+transparently and does NOT treat "unsigned" as a pass of the signature check. The
+hash check still applies and proves content integrity / tamper-evidence.
+
+Prefers the shipped szl_trajectory_sign + szl_dsse modules when importable (full
+DSSE verification). Falls back to a self-contained hash-only check if they are not
+on the path, so the script still runs standalone. NO network required.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import sys
+
+
+def _canon(obj) -> bytes:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":"),
+                      ensure_ascii=False).encode("utf-8")
+
+
+def _step_hash(action, observation, restraint_verdict: str) -> str:
+    body = _canon({"action": action, "observation": observation,
+                   "restraint_verdict": restraint_verdict})
+    return "sha256:" + hashlib.sha256(body).hexdigest()
+
+
+def _verify_full(text: str):
+    """Full verification using the shipped modules (DSSE + hash)."""
+    import szl_trajectory_sign as sts  # type: ignore
+    return sts.verify_jsonl(text)
+
+
+def _verify_hash_only(text: str):
+    """Self-contained hash-only fallback (no DSSE module on path)."""
+    results = []
+    for ln in text.splitlines():
+        ln = ln.strip()
+        if not ln:
+            continue
+        try:
+            d = json.loads(ln)
+        except Exception as exc:
+            results.append({"parse_error": str(exc)})
+            continue
+        recomputed = _step_hash(d.get("action"), d.get("observation", ""),
+                                d.get("restraint_verdict", "ALLOW"))
+        env = d.get("signature") or {}
+        sigs = env.get("signatures") or []
+        results.append({
+            "trajectory_id": d.get("trajectory_id"),
+            "step": d.get("step"),
+            "hash_ok": recomputed == d.get("step_hash"),
+            "signed": bool(sigs),
+            "sig_ok": False,  # cannot DSSE-verify without the module
+        })
+    total = len(results)
+    hash_ok = sum(1 for r in results if r.get("hash_ok"))
+    signed = sum(1 for r in results if r.get("signed"))
+    return {
+        "total_steps": total, "hash_ok": hash_ok, "signed": signed, "sig_ok": 0,
+        "all_hash_ok": hash_ok == total and total > 0,
+        "all_sig_ok": False, "results": results,
+        "note": "hash-only fallback (szl_dsse not importable; signatures not checked)",
+    }
+
+
+def main(argv) -> int:
+    if len(argv) < 2:
+        print(__doc__)
+        return 2
+    src = argv[1]
+    text = sys.stdin.read() if src == "-" else open(src, encoding="utf-8").read()
+    try:
+        res = _verify_full(text)
+        mode = "full (DSSE + hash)"
+    except Exception:
+        res = _verify_hash_only(text)
+        mode = "hash-only fallback"
+    summary = {k: res[k] for k in ("total_steps", "hash_ok", "signed", "sig_ok",
+                                   "all_hash_ok", "all_sig_ok") if k in res}
+    summary["verify_mode"] = mode
+    print(json.dumps(summary, indent=2))
+    # PASS iff every hash matches AND (no signatures present OR all verify).
+    hashes_ok = res.get("all_hash_ok", False)
+    sig_present = res.get("signed", 0) > 0
+    sigs_ok = res.get("sig_ok", 0) == res.get("signed", 0)
+    ok = hashes_ok and (not sig_present or sigs_ok)
+    print("RESULT:", "PASS" if ok else "FAIL")
+    if sig_present and not sigs_ok:
+        print("  (signatures present but not all verified)")
+    if not sig_present:
+        print("  (no signatures present — UNSIGNED corpus; hash integrity only)")
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

szl_nemotron_corpus.py

@@ -0,0 +1,406 @@
+# SPDX-License-Identifier: Apache-2.0
+# © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11/v12
+# Authored by the NEMOTRON SIGNED-TRAJECTORY build team. Co-Authored-By: Perplexity Computer Agent.
+"""
+szl_nemotron_corpus — served SIGNED-CORPUS tab + verify/stats endpoints for a11oy.
+
+WHAT THIS SERVES (honest framing — read before extending):
+    A single, self-contained "Signed Corpus" surface that lets anyone:
+      1. SEE sample DSSE-signed agent-trajectory receipts (one JSONL line per
+         agent step: action / observation / restraint_verdict / step_hash /
+         signature), mapped from nvidia/Nemotron-Agentic-v1 (CC BY 4.0, NVIDIA).
+      2. RUN a signature/integrity check IN-BROWSER against any pasted JSONL,
+         calling POST /api/a11oy/v1/nemo/verify (server-side szl_dsse verify).
+      3. READ honest corpus stats (counts, verdict/pattern mix, signing status).
+
+    Routes (all registered BEFORE the SPA catch-all so explicit paths win):
+      GET  /signed-corpus                         -> premium HTML tab
+      GET  /api/a11oy/v1/nemo/stats               -> corpus stats JSON
+      GET  /api/a11oy/v1/nemo/sample              -> the sample signed JSONL (text)
+      POST /api/a11oy/v1/nemo/verify              -> {jsonl} -> aggregate verify JSON
+
+    A small idempotent nav-injection middleware appends a floating "Signed Corpus"
+    link to every served HTML surface (so the tab is reachable from the console
+    without editing the React SPA). Additive, never rewrites page content.
+
+HONEST LABELS (Doctrine gates — never weaken):
+    - "QLoRA-ready corpus; training = ROADMAP (needs 2x80GB GPU)."
+    - DATASET property, NOT a model claim. Not an Ultra reproduction. Not from
+      scratch. Trust is never 100%. Data labeled LIVE / SAMPLE / MODELED.
+    - CC BY 4.0 attribution to NVIDIA is shown on the page and in /stats.
+    - Real ECDSA-P256 signatures only when SZL_COSIGN_PRIVATE_KEY_PEM is present;
+      else honest UNSIGNED — the verifier reports this transparently.
+
+ADDITIVE · FastAPI + szl_trajectory_sign + szl_nemotron_ingest · 0 runtime CDN.
+"""
+from __future__ import annotations
+
+import html as _html
+import json
+from typing import Any, Dict, Optional
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse
+
+import szl_trajectory_sign as sts
+import szl_nemotron_ingest as ingest
+
+LEAN_SHA = "c7c0ba17"
+DOCTRINE = {"version": "v11/v12", "counts": "749/14/163", "lambda": "Conjecture 1"}
+
+# Build the SAMPLE corpus ONCE at import (CPU-only, deterministic content).
+try:
+    _CORPUS = ingest.build_sample_corpus(label="SAMPLE")
+except Exception as _exc:  # never crash registration
+    _CORPUS = {"trajectories": [], "jsonl": "", "stats": {
+        "label": "SAMPLE", "trajectory_count": 0, "total_steps": 0,
+        "verdict_counts": {}, "pattern_counts": {},
+        "signing_available": False, "attribution": ingest.ATTRIBUTION,
+        "build_error": f"{type(_exc).__name__}: {_exc}"}}
+
+
+def _stats() -> Dict[str, Any]:
+    st = dict(_CORPUS["stats"])
+    # Verify the shipped sample so /stats reports honest live integrity numbers.
+    v = sts.verify_jsonl(_CORPUS["jsonl"])
+    st["verify"] = {k: v[k] for k in
+                    ("total_steps", "hash_ok", "signed", "sig_ok",
+                     "all_hash_ok", "all_sig_ok")}
+    st["doctrine"] = DOCTRINE
+    st["step_schema"] = sts.STEP_SCHEMA
+    st["payload_type"] = sts.STEP_PAYLOAD_TYPE
+    st["source_total_samples"] = ingest.SOURCE_TOTAL
+    st["honesty"] = (
+        "QLoRA-ready signed-trajectory corpus (DATASET property, not a model claim). "
+        "Actual QLoRA/GRPO training = ROADMAP (needs 2x80GB GPU). Not an Ultra "
+        "reproduction; not trained from scratch. SAMPLE shown is a representative "
+        "schema-faithful mapping of nvidia/Nemotron-Agentic-v1 (CC BY 4.0, NVIDIA); "
+        "the full 335,122 samples are re-derivable locally from the open source."
+    )
+    return st
+
+
+# --------------------------------------------------------------------------- #
+# HTML tab
+# --------------------------------------------------------------------------- #
+def _sample_cards() -> str:
+    cards = []
+    for traj in _CORPUS["trajectories"]:
+        prov = traj["provenance"]
+        steps = traj["steps"]
+        rows = []
+        for s in steps:
+            act = s.get("action")
+            act_str = json.dumps(act) if not isinstance(act, str) else act
+            if len(act_str) > 140:
+                act_str = act_str[:140] + "…"
+            obs = s.get("observation") or ""
+            if len(obs) > 100:
+                obs = obs[:100] + "…"
+            verdict = s.get("restraint_verdict", "ALLOW")
+            vclass = {"ALLOW": "ok", "HOLD": "warn", "MONITOR": "exp",
+                      "DECLINE": "bad"}.get(verdict, "exp")
+            corr = " ⟲ correction" if s.get("is_correction") else ""
+            rows.append(f"""
+            <tr>
+              <td class="num">{s.get('step')}</td>
+              <td><span class="pat">{_html.escape(s.get('pattern',''))}</span>{corr}</td>
+              <td class="role">{_html.escape(s.get('role',''))}</td>
+              <td class="act"><code>{_html.escape(act_str)}</code></td>
+              <td class="obs">{_html.escape(obs)}</td>
+              <td><span class="badge {vclass}">{_html.escape(verdict)}</span></td>
+              <td class="hash"><code>{_html.escape((s.get('step_hash') or '')[:18])}…</code></td>
+            </tr>""")
+        signed_badge = ('<span class="badge ok">SIGNED</span>'
+                        if prov.get("all_signed")
+                        else '<span class="badge warn">UNSIGNED (no key in env — honest)</span>')
+        cards.append(f"""
+        <article class="tcard">
+          <header>
+            <h3>trajectory {_html.escape(prov.get('trajectory_id','')[:8])}…</h3>
+            <span class="label">{_html.escape(prov.get('label','SAMPLE'))}</span>
+            {signed_badge}
+          </header>
+          <p class="task">📋 {_html.escape(str(prov.get('task',''))[:160])}</p>
+          <p class="meta">source: <b>{_html.escape(prov.get('source',''))}</b> ·
+             steps: {prov.get('total_steps')} · corrections: {prov.get('corrections')} ·
+             reasoning: {_html.escape(str(prov.get('reasoning_mode','')))} ·
+             used_in: {_html.escape(json.dumps(prov.get('used_in',[])))}</p>
+          <table class="steps">
+            <thead><tr><th>#</th><th>pattern</th><th>role</th><th>action</th>
+              <th>observation</th><th>verdict</th><th>step_hash</th></tr></thead>
+            <tbody>{''.join(rows)}</tbody>
+          </table>
+        </article>""")
+    return "\n".join(cards)
+
+
+def _page_html(ns: str = "a11oy") -> str:
+    st = _stats()
+    attr = st["attribution"]
+    vc = st.get("verdict_counts", {})
+    pc = st.get("pattern_counts", {})
+    verify = st.get("verify", {})
+    sample_jsonl = _CORPUS["jsonl"]
+    chips = "".join(
+        f'<span class="chip">{_html.escape(k)}: <b>{v}</b></span>'
+        for k, v in {**vc, **{f"pat:{p}": n for p, n in pc.items()}}.items())
+    return f"""<!doctype html>
+<html lang="en"><head>
+<meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+<title>A11oy — Signed Corpus (SZL-Nemo)</title>
+<style>
+  :root {{ --bg:#0a0f1e; --panel:#111a2e; --ink:#e8eef7; --muted:#8aa0bd;
+           --indigo:#4d8fcc; --terra:#c8643c; --gold:#d8a23c; --ok:#3fae7a;
+           --warn:#c8893c; --bad:#cc5a5a; --exp:#9fb0e6; }}
+  * {{ box-sizing:border-box; }}
+  body {{ margin:0; font-family:ui-sans-serif,system-ui,Segoe UI,Roboto,sans-serif;
+          background:radial-gradient(1200px 600px at 70% -10%, #16223c, var(--bg)); color:var(--ink); }}
+  .wrap {{ max-width:1180px; margin:0 auto; padding:2.5rem 1.25rem 4rem; }}
+  .plaque {{ font-family:ui-monospace,monospace; font-size:.72rem; letter-spacing:.12em;
+             color:var(--muted); text-transform:uppercase; }}
+  .plaque b {{ color:var(--gold); }}
+  h1 {{ font-size:clamp(1.8rem,4vw,2.6rem); margin:.4rem 0 .2rem; }}
+  h1 .accent {{ color:var(--terra); }}
+  .sub {{ color:var(--muted); max-width:74ch; line-height:1.55; }}
+  .honest {{ background:rgba(200,137,60,.10); border:1px solid rgba(200,137,60,.35);
+             border-radius:10px; padding:.8rem 1rem; margin:1.1rem 0; color:#e7c98f;
+             font-size:.85rem; line-height:1.5; }}
+  .attr {{ background:rgba(77,143,204,.08); border:1px solid rgba(77,143,204,.3);
+           border-radius:10px; padding:.7rem 1rem; margin:.8rem 0; font-size:.8rem; color:#bcd; }}
+  .attr a {{ color:var(--indigo); }}
+  .chips {{ display:flex; flex-wrap:wrap; gap:.45rem; margin:1rem 0; }}
+  .chip {{ background:var(--panel); border:1px solid #21304d; border-radius:999px;
+           padding:.3rem .7rem; font-size:.74rem; color:var(--muted); }}
+  .chip b {{ color:var(--ink); }}
+  .bignum {{ display:flex; gap:1.4rem; flex-wrap:wrap; margin:1.2rem 0; }}
+  .bignum .n {{ font-size:2rem; font-weight:800; color:var(--gold); line-height:1; }}
+  .bignum .l {{ font-size:.72rem; color:var(--muted); text-transform:uppercase; letter-spacing:.08em; }}
+  .tcard {{ background:var(--panel); border:1px solid #21304d; border-radius:12px;
+            padding:1.1rem 1.15rem; margin:1rem 0; box-shadow:0 18px 40px -28px #000; }}
+  .tcard header {{ display:flex; align-items:center; gap:.6rem; flex-wrap:wrap; }}
+  .tcard h3 {{ margin:0; font-family:ui-monospace,monospace; color:var(--indigo); font-size:1rem; }}
+  .label {{ font-size:.62rem; padding:.18rem .5rem; border-radius:999px; background:rgba(216,162,60,.16);
+            color:var(--gold); border:1px solid rgba(216,162,60,.4); letter-spacing:.08em; }}
+  .task {{ color:var(--ink); font-size:.86rem; margin:.6rem 0 .2rem; }}
+  .meta {{ color:var(--muted); font-size:.76rem; margin:.1rem 0 .7rem; }}
+  table.steps {{ width:100%; border-collapse:collapse; font-size:.74rem; }}
+  table.steps th {{ text-align:left; color:var(--muted); font-weight:600; border-bottom:1px solid #21304d;
+                    padding:.3rem .4rem; text-transform:uppercase; font-size:.64rem; letter-spacing:.06em; }}
+  table.steps td {{ padding:.32rem .4rem; border-bottom:1px solid #16213a; vertical-align:top; }}
+  td.num {{ color:var(--muted); }} td.act code {{ color:#bcd; word-break:break-word; }}
+  td.obs {{ color:var(--muted); }} td.hash code {{ color:var(--gold); font-size:.68rem; }}
+  .pat {{ color:var(--indigo); font-weight:600; }} .role {{ color:var(--muted); }}
+  .badge {{ font-size:.6rem; padding:.16rem .45rem; border-radius:999px; letter-spacing:.05em; }}
+  .badge.ok {{ background:rgba(63,174,122,.16); color:var(--ok); border:1px solid rgba(63,174,122,.4); }}
+  .badge.warn {{ background:rgba(200,137,60,.16); color:var(--warn); border:1px solid rgba(200,137,60,.4); }}
+  .badge.exp {{ background:rgba(120,140,210,.16); color:var(--exp); border:1px solid rgba(120,140,210,.45); }}
+  .badge.bad {{ background:rgba(204,90,90,.16); color:var(--bad); border:1px solid rgba(204,90,90,.45); }}
+  h2 {{ margin-top:2.2rem; font-size:1.25rem; }}
+  textarea {{ width:100%; min-height:140px; background:#070c17; border:1px solid #1a2742; border-radius:8px;
+              color:#bcd; font-family:ui-monospace,monospace; font-size:.72rem; padding:.7rem; }}
+  button.verify {{ background:var(--terra); color:#0a0f1e; border:0; border-radius:8px; padding:.5rem .9rem;
+                   font-weight:700; cursor:pointer; font-size:.85rem; margin-top:.6rem; }}
+  button.verify:hover {{ filter:brightness(1.08); }}
+  pre.out {{ background:#070c17; border:1px solid #1a2742; border-radius:8px; padding:.7rem; margin-top:.7rem;
+             font-size:.74rem; color:#bcd; overflow:auto; max-height:300px; white-space:pre-wrap; }}
+  a.back {{ color:var(--muted); text-decoration:none; font-size:.85rem; }}
+  code.ep {{ color:var(--gold); }}
+</style></head>
+<body>
+  <main class="wrap" id="main">
+    <div class="plaque">SZL HOLDINGS / A11OY / SZL-NEMO / DOCTRINE <b>{DOCTRINE['version']} · LOCKED</b>
+      / {DOCTRINE['counts']} / Λ = CONJECTURE 1 / SLSA L1 (L2/L3 ROADMAP)</div>
+    <h1>The <span class="accent">signed corpus</span> is verifiable.</h1>
+    <p class="sub">A cryptographically-signed, provenance-attested agent-trajectory corpus.
+       Each JSONL line is one agent step — <code>action</code>, <code>observation</code>,
+       <code>restraint_verdict</code>, <code>step_hash</code>, <code>signature</code> — emitted by
+       instrumenting the SZL ReAct + Reflexion + Restraint + Auto-Review loop. Anyone can verify
+       every signature below. <a class="back" href="/">← back to console</a></p>
+
+    <div class="honest">⚖️ <b>Honest scope:</b> {_html.escape(st['honesty'])}</div>
+
+    <div class="attr">📚 <b>Attribution (CC BY 4.0):</b> sample trajectories are a schema-faithful
+       mapping of <a href="{_html.escape(attr['url'])}" target="_blank" rel="noopener">{_html.escape(attr['source_dataset'])}</a>
+       © {_html.escape(attr['source_owner'])}, licensed {_html.escape(attr['license_full'])}.
+       Source totals: {attr['subsets']['interactive_agent']:,} interactive_agent +
+       {attr['subsets']['tool_calling']:,} tool_calling = {attr['total_source_samples']:,} samples.
+       Attribution is required and does not imply endorsement.</div>
+
+    <div class="bignum">
+      <div><div class="n">{st['trajectory_count']}</div><div class="l">sample trajectories</div></div>
+      <div><div class="n">{st['total_steps']}</div><div class="l">signed steps</div></div>
+      <div><div class="n">{verify.get('hash_ok',0)}/{verify.get('total_steps',0)}</div><div class="l">hash-verified</div></div>
+      <div><div class="n">{'YES' if st['signing_available'] else 'NO'}</div><div class="l">private key in env</div></div>
+      <div><div class="n">{ingest.SOURCE_TOTAL:,}</div><div class="l">source samples (CC BY 4.0)</div></div>
+    </div>
+    <div class="chips">{chips}</div>
+
+    <h2>Sample signed trajectories</h2>
+    {_sample_cards()}
+
+    <h2>Verify it yourself</h2>
+    <p class="sub">Paste signed-trajectory JSONL (or use the loaded sample) and run the integrity +
+       signature check. It calls <code class="ep">POST /api/{ns}/v1/nemo/verify</code> server-side,
+       which recomputes each <code>step_hash</code> and verifies each DSSE envelope against the
+       published <code>cosign.pub</code>. Honest: with no private key in this environment the receipts
+       are UNSIGNED and the verifier says so — it never fabricates a pass.</p>
+    <textarea id="jsonl"></textarea>
+    <div>
+      <button class="verify" id="run">Verify signatures &amp; hashes</button>
+      <button class="verify" id="load" style="background:var(--indigo);">Load sample JSONL</button>
+    </div>
+    <pre class="out" id="out" hidden></pre>
+  </main>
+<script>
+const NS = {json.dumps(ns)};
+const SAMPLE = {json.dumps(sample_jsonl)};
+document.getElementById('load').addEventListener('click', function() {{
+  document.getElementById('jsonl').value = SAMPLE;
+}});
+document.getElementById('run').addEventListener('click', async function() {{
+  const out = document.getElementById('out');
+  const jsonl = document.getElementById('jsonl').value || SAMPLE;
+  out.hidden = false; out.textContent = 'verifying …';
+  try {{
+    const r = await fetch('/api/' + NS + '/v1/nemo/verify', {{
+      method: 'POST', headers: {{ 'Content-Type': 'application/json' }},
+      body: JSON.stringify({{ jsonl: jsonl }})
+    }});
+    const t = await r.text();
+    try {{ out.textContent = '[' + r.status + '] ' + JSON.stringify(JSON.parse(t), null, 2); }}
+    catch (e) {{ out.textContent = '[' + r.status + '] ' + t.slice(0, 1200); }}
+  }} catch (e) {{ out.textContent = 'error: ' + e; }}
+}});
+</script>
+</body></html>"""
+
+
+# --------------------------------------------------------------------------- #
+# Nav-injection middleware (idempotent; appends a floating link to every HTML
+# surface so the tab is reachable from the console without editing the SPA).
+# --------------------------------------------------------------------------- #
+def _install_nav_injector(app: FastAPI) -> bool:
+    try:
+        from starlette.middleware.base import BaseHTTPMiddleware
+        from starlette.responses import Response as _Resp
+    except Exception:
+        return False
+
+    _MARKER = b"szl-nemo-corpus-nav"
+    _TAG = (
+        b'<a id="szl-nemo-corpus-nav" href="/signed-corpus" '
+        b'style="position:fixed;right:14px;bottom:14px;z-index:99998;'
+        b'background:#c8643c;color:#0a0f1e;font:600 12px ui-sans-serif,system-ui;'
+        b'padding:8px 12px;border-radius:999px;text-decoration:none;'
+        b'box-shadow:0 6px 18px -6px #000;" '
+        b'title="DSSE-signed agent-trajectory corpus (SZL-Nemo)">'
+        b'\xe2\x97\x88 Signed Corpus</a>'
+    )
+
+    class _NemoNavInjector(BaseHTTPMiddleware):
+        async def dispatch(self, request: Request, call_next):  # noqa: ANN001
+            resp = await call_next(request)
+            try:
+                ct = (resp.headers.get("content-type") or "").lower()
+                if "text/html" not in ct:
+                    return resp
+                p = request.url.path
+                if (p.startswith("/vendor/") or p.startswith("/api/")
+                        or p.startswith("/assets/") or p == "/signed-corpus"):
+                    return resp
+                body = b""
+                async for chunk in resp.body_iterator:
+                    body += chunk if isinstance(chunk, (bytes, bytearray)) \
+                        else str(chunk).encode()
+                if _MARKER in body:                       # idempotent
+                    new_body = body
+                elif b"</body>" in body:
+                    new_body = body.replace(b"</body>", _TAG + b"</body>", 1)
+                elif b"</html>" in body:
+                    new_body = body.replace(b"</html>", _TAG + b"</html>", 1)
+                else:
+                    new_body = body + _TAG
+                headers = dict(resp.headers)
+                headers.pop("content-length", None)
+                return _Resp(content=new_body, status_code=resp.status_code,
+                             headers=headers, media_type="text/html")
+            except Exception:
+                return resp
+
+    app.add_middleware(_NemoNavInjector)
+    return True
+
+
+# --------------------------------------------------------------------------- #
+# Registration
+# --------------------------------------------------------------------------- #
+def register(app: FastAPI, ns: str = "a11oy") -> str:
+    """Mount the Signed-Corpus tab + JSON/verify endpoints + nav injector.
+
+    ADDITIVE — explicit routes registered before the SPA catch-all; the nav
+    injector is idempotent and never rewrites page content. try/except in
+    serve.py guarantees a missing dep can never take down the Space.
+    """
+
+    @app.get("/signed-corpus", include_in_schema=False)
+    async def signed_corpus_page() -> HTMLResponse:  # noqa: ANN202
+        return HTMLResponse(_page_html(ns))
+
+    # Alias under the namespace, mirroring the other genius tabs.
+    @app.get(f"/{ns}/signed-corpus", include_in_schema=False)
+    async def signed_corpus_page_ns() -> HTMLResponse:  # noqa: ANN202
+        return HTMLResponse(_page_html(ns))
+
+    @app.get(f"/api/{ns}/v1/nemo/stats", include_in_schema=False)
+    async def nemo_stats() -> JSONResponse:  # noqa: ANN202
+        return JSONResponse(_stats())
+
+    @app.get(f"/api/{ns}/v1/nemo/sample", include_in_schema=False)
+    async def nemo_sample() -> PlainTextResponse:  # noqa: ANN202
+        return PlainTextResponse(_CORPUS["jsonl"], media_type="application/x-ndjson")
+
+    @app.post(f"/api/{ns}/v1/nemo/verify", include_in_schema=False)
+    async def nemo_verify(request: Request) -> JSONResponse:  # noqa: ANN202
+        try:
+            payload = await request.json()
+        except Exception:
+            payload = {}
+        jsonl = ""
+        if isinstance(payload, dict):
+            jsonl = payload.get("jsonl") or payload.get("text") or ""
+        if not isinstance(jsonl, str) or not jsonl.strip():
+            jsonl = _CORPUS["jsonl"]  # default: verify the shipped sample
+        result = sts.verify_jsonl(jsonl)
+        result["honesty"] = (
+            "Integrity check recomputes each step_hash and verifies each DSSE "
+            "envelope against the published cosign.pub. 'signed' counts receipts "
+            "carrying a real signature; with no private key in this environment "
+            "receipts are honestly UNSIGNED (signed=0) — never fabricated."
+        )
+        result["doctrine"] = DOCTRINE
+        return JSONResponse(result)
+
+    nav_ok = _install_nav_injector(app)
+    return (f"nemotron signed-corpus mounted: GET /signed-corpus + "
+            f"/api/{ns}/v1/nemo/{{stats,sample,verify}} ; nav-injector={nav_ok}")
+
+
+if __name__ == "__main__":
+    # Pure self-check: render page + verify endpoints without a live server.
+    st = _stats()
+    page = _page_html("a11oy")
+    assert "signed corpus" in page.lower()
+    assert "CC BY 4.0" in page or "cc-by-4.0" in page.lower()
+    assert "ROADMAP" in page
+    assert st["trajectory_count"] >= 1
+    print(json.dumps({
+        "page_bytes": len(page),
+        "trajectory_count": st["trajectory_count"],
+        "total_steps": st["total_steps"],
+        "verify": st["verify"],
+        "verdict_counts": st["verdict_counts"],
+        "pattern_counts": st["pattern_counts"],
+        "signing_available": st["signing_available"],
+        "attribution_license": st["attribution"]["license"],
+    }, indent=2))

szl_nemotron_ingest.py

@@ -0,0 +1,365 @@
+# SPDX-License-Identifier: Apache-2.0
+# © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11/v12
+# Authored by the NEMOTRON SIGNED-TRAJECTORY build team. Co-Authored-By: Perplexity Computer Agent.
+"""
+szl_nemotron_ingest — map nvidia/Nemotron-Agentic-v1 into the SZL trajectory schema.
+
+WHAT THIS IS (honest framing):
+    A pure-CPU mapper that takes rows from NVIDIA's open agentic dataset
+    (nvidia/Nemotron-Agentic-v1, 335,122 samples, CC BY 4.0) and re-expresses
+    each multi-turn conversation as an SZL trajectory: one signed-step receipt
+    per agent/tool turn (see szl_trajectory_sign). The output is QLoRA-ready and
+    every step is independently signature-verifiable.
+
+ATTRIBUTION (CC BY 4.0 — REQUIRED, never strip):
+    Source dataset : nvidia/Nemotron-Agentic-v1
+    Owner          : NVIDIA Corporation
+    License         : Creative Commons Attribution 4.0 International (CC BY 4.0)
+    Subsets         : interactive_agent (19,028) + tool_calling (316,094) = 335,122
+    URL             : https://huggingface.co/datasets/nvidia/Nemotron-Agentic-v1
+    Each emitted trajectory carries source="nvidia", verified=False, signed-status
+    per the signer, label="SAMPLE", and the full attribution block above. We do NOT
+    redistribute NVIDIA's raw rows here; we ship a representative SAMPLE mapping and
+    the mapper so the full 335k can be re-derived locally from the open source.
+
+WHAT THIS IS *NOT*:
+    - Not a model. Not a training run. Not an Ultra reproduction. The signed corpus
+      is a DATASET property. Actual QLoRA/GRPO training = ROADMAP (FORGE order,
+      needs >=2x80GB GPU).
+    - We do not claim NVIDIA endorses SZL. CC BY 4.0 attribution != endorsement.
+
+SOURCE ROW SCHEMA (from the HF dataset card / preview):
+    {
+      "uuid": str,
+      "messages": [ {role, content, [tool_calls], [tool_call_id], ...}, ... ],
+      "license": "cc-by-4.0",
+      "used_in": ["nano_v3", ...],
+      "tools":  [ {"type":"function","function":{name,description,parameters}}, ... ],
+      "reasoning": "on" | "off"
+    }
+
+MAPPING (Nemotron message -> SZL trajectory step):
+    role "assistant" with tool_calls -> step {role:assistant, pattern:ReAct,
+        action: the tool_call(s), restraint_verdict via _verdict_for()}
+    role "tool"                      -> step {role:tool, observation: content}
+    role "assistant" plain text      -> step {role:assistant, action: text,
+        pattern: Reflexion if it looks like a self-correction else AutoReview}
+    role "system"/"user"             -> recorded as trajectory context (not a
+        signed agent action), surfaced in provenance.
+
+ADDITIVE · stdlib + szl_trajectory_sign only · CPU-only · no network required.
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict, Iterable, List, Optional
+
+import szl_trajectory_sign as sts
+
+SOURCE_DATASET = "nvidia/Nemotron-Agentic-v1"
+SOURCE_OWNER = "NVIDIA Corporation"
+SOURCE_LICENSE = "CC BY 4.0"
+SOURCE_LICENSE_FULL = "Creative Commons Attribution 4.0 International (CC BY 4.0)"
+SOURCE_URL = "https://huggingface.co/datasets/nvidia/Nemotron-Agentic-v1"
+SOURCE_SUBSETS = {"interactive_agent": 19028, "tool_calling": 316094}
+SOURCE_TOTAL = 335122
+
+ATTRIBUTION = {
+    "source_dataset": SOURCE_DATASET,
+    "source_owner": SOURCE_OWNER,
+    "license": SOURCE_LICENSE,
+    "license_full": SOURCE_LICENSE_FULL,
+    "url": SOURCE_URL,
+    "subsets": SOURCE_SUBSETS,
+    "total_source_samples": SOURCE_TOTAL,
+    "note": (
+        "Re-expressed into the SZL trajectory schema under CC BY 4.0. Attribution to "
+        "NVIDIA is required and does not imply endorsement. Raw NVIDIA rows are not "
+        "redistributed here; this is a representative SAMPLE mapping plus the mapper."
+    ),
+}
+
+# Reflexion cue words: an assistant turn that reads like a self-correction.
+_REFLEXION_CUES = (
+    "let me reconsider", "i was wrong", "correction", "actually,", "on second thought",
+    "let me retry", "that was incorrect", "i made an error", "let me fix",
+)
+
+
+def _verdict_for(msg: Dict[str, Any], tools_present: bool) -> str:
+    """Conservative Restraint verdict for a mapped Nemotron turn.
+
+    Honest defaults ("never engage on doubt"): a tool call with arguments is
+    ALLOW; an assistant turn that declines/escalates -> HOLD/DECLINE; ambiguous
+    tool environments -> MONITOR.
+    """
+    content = (msg.get("content") or "")
+    low = content.lower() if isinstance(content, str) else ""
+    if any(w in low for w in ("cannot", "i'm sorry, but", "not able to", "decline",
+                              "against policy", "i can't")):
+        return "DECLINE"
+    if any(w in low for w in ("need to verify", "please confirm", "let me check",
+                              "i need more information", "could you clarify")):
+        return "HOLD"
+    if msg.get("tool_calls"):
+        return "ALLOW"
+    if tools_present and msg.get("role") == "assistant" and not low.strip():
+        return "MONITOR"
+    return "ALLOW"
+
+
+def _pattern_for(msg: Dict[str, Any], prev_assistant_text: str) -> str:
+    role = msg.get("role")
+    content = msg.get("content") or ""
+    low = content.lower() if isinstance(content, str) else ""
+    # A self-correcting turn is Reflexion even if it also calls a tool (the
+    # backtrack is the salient property for the trajectory corpus).
+    if role == "assistant" and any(c in low for c in _REFLEXION_CUES):
+        return "Reflexion"
+    if msg.get("tool_calls"):
+        return "ReAct"
+    if role == "assistant":
+        return "AutoReview"
+    return "ReAct"
+
+
+def _action_of(msg: Dict[str, Any]) -> Any:
+    """Extract the agent action: tool_calls if present, else the text content."""
+    tcs = msg.get("tool_calls")
+    if tcs:
+        # Normalise to {name, arguments} pairs (OpenAI-style function tool_calls).
+        out = []
+        for tc in tcs:
+            fn = (tc or {}).get("function", {}) if isinstance(tc, dict) else {}
+            out.append({"name": fn.get("name"), "arguments": fn.get("arguments")})
+        return {"tool_calls": out}
+    return msg.get("content", "")
+
+
+def map_row(row: Dict[str, Any], *, label: str = "SAMPLE",
+            environment: str = "nemotron-agentic") -> Dict[str, Any]:
+    """Map ONE Nemotron-Agentic-v1 row to a sealed, DSSE-signed SZL trajectory.
+
+    Returns the seal() dict: {"provenance", "steps", "jsonl"} with the attribution
+    and source UUID embedded in provenance.extra.
+    """
+    uuid_src = row.get("uuid") or ""
+    messages: List[Dict[str, Any]] = row.get("messages") or []
+    tools = row.get("tools") or []
+    tools_present = bool(tools)
+    reasoning = row.get("reasoning", "off")
+    used_in = row.get("used_in") or []
+
+    # Reconstruct a short task descriptor from the first user turn.
+    task = ""
+    for m in messages:
+        if m.get("role") == "user":
+            c = m.get("content") or ""
+            task = (c[:160] + "…") if isinstance(c, str) and len(c) > 160 else c
+            break
+
+    t = sts.SignedTrajectory(task=task or f"nemotron:{uuid_src[:8]}",
+                             environment=environment, label=label)
+    last_assistant_idx: Optional[int] = None
+    last_assistant_text = ""
+    context_turns: List[Dict[str, Any]] = []
+
+    for m in messages:
+        role = m.get("role")
+        if role in ("system", "user"):
+            # Context, not a signed agent action — preserved in provenance.
+            context_turns.append({"role": role,
+                                  "content": (m.get("content") or "")[:500]})
+            continue
+        if role == "tool":
+            # Observation turn: attach as a tool observation step.
+            t.add(action={"tool_result_for": m.get("tool_call_id")},
+                  observation=m.get("content", ""), role="tool",
+                  pattern="ReAct", restraint_verdict="MONITOR")
+            continue
+        if role == "assistant":
+            pattern = _pattern_for(m, last_assistant_text)
+            verdict = _verdict_for(m, tools_present)
+            is_corr = pattern == "Reflexion"
+            t.add(action=_action_of(m), observation="", role="assistant",
+                  pattern=pattern, restraint_verdict=verdict,
+                  is_correction=is_corr,
+                  correction_of=last_assistant_idx if is_corr else None,
+                  tool_calls=([{"function": (tc or {}).get("function", {})}
+                               for tc in (m.get("tool_calls") or [])] or None))
+            last_assistant_idx = len(t.steps) - 1
+            if isinstance(m.get("content"), str):
+                last_assistant_text = m["content"]
+
+    sealed = t.seal(outcome="mapped")
+    sealed["provenance"]["source"] = "nvidia"
+    sealed["provenance"]["verified"] = False
+    sealed["provenance"]["reasoning_mode"] = reasoning
+    sealed["provenance"]["used_in"] = used_in
+    sealed["provenance"]["source_uuid"] = uuid_src
+    sealed["provenance"]["context_turns"] = context_turns
+    sealed["provenance"]["tools_count"] = len(tools)
+    sealed["provenance"]["attribution"] = ATTRIBUTION
+    return sealed
+
+
+def map_rows(rows: Iterable[Dict[str, Any]], *, label: str = "SAMPLE",
+             environment: str = "nemotron-agentic") -> List[Dict[str, Any]]:
+    return [map_row(r, label=label, environment=environment) for r in rows]
+
+
+# --------------------------------------------------------------------------- #
+# Representative SAMPLE rows (faithful to the published schema; NOT NVIDIA's
+# verbatim rows — see ATTRIBUTION.note). Used to ship a demo corpus CPU-only.
+# --------------------------------------------------------------------------- #
+def sample_rows() -> List[Dict[str, Any]]:
+    """A handful of schema-faithful representative rows (tool_calling +
+    interactive_agent flavours), so the served demo has real content offline."""
+    return [
+        {
+            "uuid": "ff6ab2b0-7551-468c-8606-a7c3b0c75b68",
+            "license": "cc-by-4.0",
+            "used_in": ["nano_v3"],
+            "reasoning": "on",
+            "tools": [{"type": "function", "function": {
+                "name": "place_order",
+                "description": "Create a new food delivery order",
+                "parameters": {"type": "object", "properties": {
+                    "user_id": {"type": "string"},
+                    "restaurant_id": {"type": "string"}}}}}],
+            "messages": [
+                {"role": "system", "content": "You are a customer service agent. "
+                 "Follow the <policy>…</policy>. You may message the user or call a tool."},
+                {"role": "user", "content": "Order me a large pepperoni pizza from Tony's."},
+                {"role": "assistant", "content": "Let me check the menu first.",
+                 "tool_calls": [{"type": "function", "function": {
+                     "name": "get_menu", "arguments": "{\"restaurant_id\":\"tonys\"}"}}]},
+                {"role": "tool", "tool_call_id": "c1",
+                 "content": "{\"items\":[{\"id\":\"p_lg\",\"name\":\"Large Pepperoni\"}]}"},
+                {"role": "assistant", "content": "I need to verify your delivery address "
+                 "before placing the order. Could you confirm it?"},
+                {"role": "user", "content": "123 Main St, 10588."},
+                {"role": "assistant", "content": "Placing your order now.",
+                 "tool_calls": [{"type": "function", "function": {
+                     "name": "place_order",
+                     "arguments": "{\"user_id\":\"u1\",\"restaurant_id\":\"tonys\"}"}}]},
+                {"role": "tool", "tool_call_id": "c2",
+                 "content": "{\"order_id\":\"o_99\",\"status\":\"confirmed\"}"},
+                {"role": "assistant", "content": "Done — order o_99 is confirmed."},
+            ],
+        },
+        {
+            "uuid": "a1c9d2e3-0000-4aaa-bbbb-1234567890ab",
+            "license": "cc-by-4.0",
+            "used_in": ["super_v3"],
+            "reasoning": "on",
+            "tools": [{"type": "function", "function": {
+                "name": "search_flights",
+                "description": "Search available flights",
+                "parameters": {"type": "object", "properties": {
+                    "origin": {"type": "string"}, "dest": {"type": "string"}}}}}],
+            "messages": [
+                {"role": "system", "content": "You are a travel agent. Obey policy."},
+                {"role": "user", "content": "Find me a flight JFK to LAX tomorrow."},
+                {"role": "assistant", "content": "Searching flights.",
+                 "tool_calls": [{"type": "function", "function": {
+                     "name": "search_flights",
+                     "arguments": "{\"origin\":\"JFK\",\"dest\":\"LAZ\"}"}}]},
+                {"role": "tool", "tool_call_id": "c1",
+                 "content": "{\"error\":\"unknown airport LAZ\"}"},
+                {"role": "assistant", "content": "Correction: I mistyped the airport "
+                 "code. Let me retry with LAX.",
+                 "tool_calls": [{"type": "function", "function": {
+                     "name": "search_flights",
+                     "arguments": "{\"origin\":\"JFK\",\"dest\":\"LAX\"}"}}]},
+                {"role": "tool", "tool_call_id": "c2",
+                 "content": "{\"flights\":[{\"id\":\"f1\",\"dep\":\"08:00\"}]}"},
+                {"role": "assistant", "content": "Found flight f1 departing 08:00."},
+            ],
+        },
+        {
+            "uuid": "b2d0e4f5-1111-4ccc-dddd-0987654321fe",
+            "license": "cc-by-4.0",
+            "used_in": ["ultra_v3"],
+            "reasoning": "off",
+            "tools": [{"type": "function", "function": {
+                "name": "issue_refund",
+                "description": "Issue a refund subject to policy tier",
+                "parameters": {"type": "object", "properties": {
+                    "order_id": {"type": "string"},
+                    "refund_tier": {"type": "string", "enum": ["full", "partial"]}}}}}],
+            "messages": [
+                {"role": "system", "content": "Refund agent. Enforce refund policy strictly."},
+                {"role": "user", "content": "I want a full refund on order o_77, no receipt."},
+                {"role": "assistant", "content": "I'm sorry, but I cannot issue a full "
+                 "refund without proof of purchase under policy. I can escalate to a "
+                 "human reviewer if you'd like."},
+            ],
+        },
+    ]
+
+
+# --------------------------------------------------------------------------- #
+# Optional: load real NVIDIA rows from a local JSONL (if a user has downloaded
+# the dataset). Network-free; only reads what's on disk.
+# --------------------------------------------------------------------------- #
+def load_local_jsonl(path: str, limit: Optional[int] = None) -> List[Dict[str, Any]]:
+    rows: List[Dict[str, Any]] = []
+    if not os.path.exists(path):
+        return rows
+    with open(path, "r", encoding="utf-8") as fh:
+        for i, line in enumerate(fh):
+            if limit is not None and i >= limit:
+                break
+            line = line.strip()
+            if line:
+                try:
+                    rows.append(json.loads(line))
+                except Exception:
+                    continue
+    return rows
+
+
+def build_sample_corpus(label: str = "SAMPLE") -> Dict[str, Any]:
+    """Map the representative sample rows; return {trajectories, jsonl, stats}."""
+    sealed = map_rows(sample_rows(), label=label)
+    all_steps_jsonl: List[str] = []
+    for s in sealed:
+        if s["jsonl"]:
+            all_steps_jsonl.append(s["jsonl"])
+    jsonl = "\n".join(all_steps_jsonl)
+    total_steps = sum(s["provenance"]["total_steps"] for s in sealed)
+    verdict_counts: Dict[str, int] = {}
+    pattern_counts: Dict[str, int] = {}
+    for s in sealed:
+        for st in s["steps"]:
+            verdict_counts[st["restraint_verdict"]] = \
+                verdict_counts.get(st["restraint_verdict"], 0) + 1
+            pattern_counts[st["pattern"]] = pattern_counts.get(st["pattern"], 0) + 1
+    return {
+        "trajectories": sealed,
+        "jsonl": jsonl,
+        "stats": {
+            "label": label,
+            "trajectory_count": len(sealed),
+            "total_steps": total_steps,
+            "verdict_counts": verdict_counts,
+            "pattern_counts": pattern_counts,
+            "signing_available": sts.signing_available(),
+            "attribution": ATTRIBUTION,
+        },
+    }
+
+
+if __name__ == "__main__":
+    corpus = build_sample_corpus()
+    v = sts.verify_jsonl(corpus["jsonl"])
+    print(json.dumps({
+        "trajectories": corpus["stats"]["trajectory_count"],
+        "total_steps": corpus["stats"]["total_steps"],
+        "verdict_counts": corpus["stats"]["verdict_counts"],
+        "pattern_counts": corpus["stats"]["pattern_counts"],
+        "verify": {k: v[k] for k in ("total_steps", "all_hash_ok", "signed", "sig_ok")},
+        "attribution_license": corpus["stats"]["attribution"]["license"],
+    }, indent=2))