Make submissions editable; load by trial_id + username

- One submission file per (trial_id, username): submitting again updates the
same file (upsert) instead of creating a new timestamped one.
- save_submission() preserves createdAt, sets updatedAt on each save.
- Add get_submission_by_key() / submission_id_for(); form gets a 'Load existing
submission' button that pulls a prior submission back in for editing.
- Submit no longer clears the form, so editing can continue.
- Question widgets keyed by a form_nonce bumped on load, so loaded values
actually populate the fields (Streamlit widget-state gotcha).
- Admin list sorts by updatedAt and exposes it.

README.md

@@ -23,7 +23,8 @@ A Streamlit intake form for trial statisticians. Submissions are saved to a **Hu
     - `extraction_only` → 1 rubric: `output.json`
     - `derivation_required` → 4 rubrics: `output.json` × {Inputs used, Calculated value, Method} + `output.R` × {Reproducibility}
   - Each rubric collects `points`, `tolerance`, `criterion`.
-- **Admin page (`pages/1_Admin.py`)** — password-gated review console. A submission can be reviewed many times by different people: each review (status + reviewer name + comment) is written as its own file under `reviews/<submission>/`, and the page shows the full timeline. The current status is the most recent review's status. Submissions themselves are never modified.
+  - **Load existing submission** — re-enter the same `trial_id` + `username` and click Load to pull a previous submission back into the form, edit it, and Submit again to update.
+- **Admin page (`pages/1_Admin.py`)** — password-gated review console. A submission can be reviewed many times by different people: each review (status + reviewer name + comment) is written as its own file under `reviews/<submission>/`, and the page shows the full timeline. The current status is the most recent review's status.
 
 ## Run locally
 
@@ -84,25 +85,32 @@ The Space will restart automatically and pick up the new secrets.
 
 ### 6. Test
 
-- Open the Space URL → fill the form → **Submit**. A new file lands in `submissions/<trial_id>__<username>__<timestamp>.json` in the dataset repo.
+- Open the Space URL → fill the form → **Submit**. A file lands in `submissions/<trial_id>__<username>.json` in the dataset repo. Submitting again with the same trial_id + username updates that file.
 - Open the **Admin** page (left sidebar) → enter password → see the submission with status `pending` → add a review (your name + status + comment). It appears in the review timeline and a new file lands under `reviews/<submission>/`. Add more reviews to build up the history.
 
 ## Dataset layout
 
-Submissions are **immutable**. Each review is a **separate file** — so a
-submission can be reviewed many times by different people, and concurrent
-reviews never conflict (each is a brand-new file, never an overwrite).
+One submission file per `(trial_id, username)` pair — submitting again
+**updates** the same file, so a submission can be loaded back and edited.
+(Edit history is preserved in the dataset's git commits.) Each review is a
+**separate file**, so a submission can be reviewed many times by different
+people and concurrent reviews never conflict.
 
 ```text
-submissions/<trial>__<user>__<stamp>.json            # the submission (never rewritten)
-reviews/<trial>__<user>__<stamp>/<stamp>__<rev>.json # one file per review
+submissions/<trial>__<user>.json            # the submission (upserted on each submit)
+reviews/<trial>__<user>/<stamp>__<rev>.json # one file per review
 ```
 
+To edit an existing submission: on the form, enter the same `trial_id` +
+`username` and click **Load existing submission**, edit, then **Submit**.
+
 ### Submission file (`submissions/*.json`)
 
 ```json
 {
-  "submissionId": "submissions/NCT0001__jdoe__2026-06-01T...Z.json",
+  "submissionId": "submissions/NCT0001__jdoe.json",
+  "createdAt": "2026-06-01T...",
+  "updatedAt": "2026-06-04T...",
   "submittedAt": "2026-06-01T...",
   "trial_id": "NCT0001",
   "username": "jdoe",

app.py

@@ -22,7 +22,7 @@ from lib.schema import (
     next_question_id,
     rubrics_for_type,
 )
-from lib.storage import create_submission, hf_configured
+from lib.storage import get_submission_by_key, hf_configured, save_submission
 
 st.set_page_config(
     page_title="TDB Intake",
@@ -40,6 +40,10 @@ if "username" not in st.session_state:
     st.session_state.username = ""
 if "last_result" not in st.session_state:
     st.session_state.last_result = None
+# Bumped whenever we replace the questions wholesale (load / reset) so the
+# per-question widgets get fresh keys and actually show the new values.
+if "form_nonce" not in st.session_state:
+    st.session_state.form_nonce = 0
 
 
 # ------------- callbacks -------------------------------------------------
@@ -66,6 +70,39 @@ def _save_draft() -> None:
     st.session_state.last_result = {"kind": "draft", "msg": "Draft saved in this browser session."}
 
 
+def _load() -> None:
+    """Load an existing submission by (trial_id, username) into the form."""
+    trial_id = st.session_state.trial_id.strip()
+    username = st.session_state.username.strip()
+    if not trial_id or not username:
+        st.session_state.last_result = {
+            "kind": "error",
+            "msg": "Enter trial_id and username, then click Load.",
+        }
+        return
+    try:
+        record = get_submission_by_key(trial_id, username)
+    except Exception as e:
+        st.session_state.last_result = {"kind": "error", "msg": f"Load failed: {e}"}
+        return
+    if not record:
+        st.session_state.last_result = {
+            "kind": "info",
+            "msg": f"No existing submission for `{trial_id}` / `{username}`. "
+            "Add questions and Submit to create one.",
+        }
+        return
+    prompts = (record.get("comparison") or {}).get("prompts") or []
+    st.session_state.questions = prompts
+    st.session_state.form_nonce += 1  # force question widgets to refresh
+    updated = record.get("updatedAt") or record.get("submittedAt") or ""
+    st.session_state.last_result = {
+        "kind": "success",
+        "msg": f"Loaded {len(prompts)} question(s) (last updated {updated}). "
+        "Edit and Submit to update.",
+    }
+
+
 def _submit() -> None:
     trial_id = st.session_state.trial_id.strip()
     username = st.session_state.username.strip()
@@ -79,16 +116,15 @@ def _submit() -> None:
         "prompts": st.session_state.questions,
     }
     try:
-        result = create_submission(trial_id, username, comparison)
+        result = save_submission(trial_id, username, comparison)
+        verb = "Updated" if result.get("updated") else "Submitted"
         st.session_state.last_result = {
             "kind": "success",
-            "msg": f"Submitted: `{result['submissionId']}`",
+            "msg": f"{verb}: `{result['submissionId']}`. "
+            "You can keep editing and Submit again to update.",
             "url": result.get("url"),
         }
-        # Reset form
-        st.session_state.questions = []
-        st.session_state.trial_id = ""
-        st.session_state.username = ""
+        # Keep the form populated so the user can continue editing.
     except Exception as e:
         st.session_state.last_result = {"kind": "error", "msg": f"Submit failed: {e}"}
 
@@ -112,6 +148,12 @@ with c1:
 with c2:
     st.text_input("username", key="username", placeholder="e.g., jdoe")
 
+st.button(
+    "Load existing submission",
+    on_click=_load,
+    help="If you already submitted for this trial_id + username, load it back to edit.",
+)
+
 st.divider()
 
 # ------------- questions list --------------------------------------------
@@ -121,6 +163,8 @@ st.subheader("Questions")
 if not st.session_state.questions:
     st.caption('No questions yet. Click "Add question" below to begin.')
 
+n = st.session_state.form_nonce  # widget-key namespace; changes on load/reset
+
 for i, q in enumerate(st.session_state.questions):
     with st.container(border=True):
         head_l, head_r = st.columns([6, 1])
@@ -128,12 +172,12 @@ for i, q in enumerate(st.session_state.questions):
             new_id = st.text_input(
                 "id",
                 value=q["id"],
-                key=f"q_{i}_id",
+                key=f"q_{n}_{i}_id",
                 label_visibility="collapsed",
             )
             q["id"] = new_id
         with head_r:
-            st.button("Remove", key=f"rm_{i}", on_click=_remove_question, args=(i,))
+            st.button("Remove", key=f"rm_{n}_{i}", on_click=_remove_question, args=(i,))
 
         col1, col2 = st.columns(2)
         with col1:
@@ -143,7 +187,7 @@ for i, q in enumerate(st.session_state.questions):
                 "design_element",
                 options=de_options,
                 index=de_idx,
-                key=f"q_{i}_de",
+                key=f"q_{n}_{i}_de",
                 format_func=lambda x: "— select —" if x == "" else x,
             )
             q["design_element"] = new_de
@@ -151,7 +195,7 @@ for i, q in enumerate(st.session_state.questions):
                 q["design_element_other"] = st.text_input(
                     "Specify other design element",
                     value=q.get("design_element_other", ""),
-                    key=f"q_{i}_de_other",
+                    key=f"q_{n}_{i}_de_other",
                 )
             else:
                 q["design_element_other"] = ""
@@ -163,7 +207,7 @@ for i, q in enumerate(st.session_state.questions):
                 "question_type",
                 options=qt_options,
                 index=qt_idx,
-                key=f"q_{i}_qt",
+                key=f"q_{n}_{i}_qt",
                 format_func=lambda x: "— select —" if x == "" else x,
             )
             # If question_type changed, regenerate rubrics via callback-like pattern.
@@ -173,7 +217,7 @@ for i, q in enumerate(st.session_state.questions):
         new_question = st.text_input(
             "question",
             value=q["question"],
-            key=f"q_{i}_question",
+            key=f"q_{n}_{i}_question",
             placeholder="e.g., Alpha allocated to PFS",
         )
         q["question"] = new_question
@@ -192,18 +236,18 @@ for i, q in enumerate(st.session_state.questions):
                         r["points"] = st.text_input(
                             "points",
                             value=r["points"],
-                            key=f"q_{i}_r_{j}_points",
+                            key=f"q_{n}_{i}_r_{j}_points",
                         )
                     with rc2:
                         r["tolerance"] = st.text_input(
                             "tolerance",
                             value=r["tolerance"],
-                            key=f"q_{i}_r_{j}_tolerance",
+                            key=f"q_{n}_{i}_r_{j}_tolerance",
                         )
                     r["criterion"] = st.text_area(
                         "criterion",
                         value=r["criterion"],
-                        key=f"q_{i}_r_{j}_criterion",
+                        key=f"q_{n}_{i}_r_{j}_criterion",
                         height=80,
                     )
 

lib/storage.py

@@ -134,25 +134,56 @@ def _all_files() -> List[str]:
 
 # ---- public API ----------------------------------------------------------
 
-def create_submission(trial_id: str, username: str, comparison: Dict[str, Any]) -> Dict[str, Any]:
-    """Write a new (immutable) submission file. Returns submissionId + url."""
-    file_name = f"{_safe(trial_id)}__{_safe(username)}__{_stamp()}.json"
-    submission_id = f"{SUBMISSIONS_PREFIX}/{file_name}"
+def submission_id_for(trial_id: str, username: str) -> str:
+    """Stable submission id (path) for a (trial_id, username) pair.
+
+    One submission per pair — submitting again updates the same file, so a
+    submission can be loaded back and edited.
+    """
+    return f"{SUBMISSIONS_PREFIX}/{_safe(trial_id)}__{_safe(username)}.json"
+
+
+def get_submission_by_key(trial_id: str, username: str) -> Optional[Dict[str, Any]]:
+    """Load an existing submission by (trial_id, username), or None."""
+    return get_submission(submission_id_for(trial_id, username))
+
+
+def save_submission(trial_id: str, username: str, comparison: Dict[str, Any]) -> Dict[str, Any]:
+    """Create or update the submission for (trial_id, username).
+
+    If a submission already exists for this pair, it is updated in place
+    (createdAt is preserved); otherwise a new one is created.
+    """
+    submission_id = submission_id_for(trial_id, username)
+    now = _now_iso()
+    existing = get_submission(submission_id)
+    created_at = (existing or {}).get("createdAt") or (existing or {}).get("submittedAt") or now
+    is_update = existing is not None
+
     record = {
         "submissionId": submission_id,
-        "submittedAt": _now_iso(),
+        "createdAt": created_at,
+        "updatedAt": now,
+        # kept for backward compatibility with older records / admin display
+        "submittedAt": created_at,
         "trial_id": trial_id,
         "username": username,
         "comparison": comparison,
     }
-    _write_json(submission_id, record, f"Add submission: {trial_id} — {username}")
+    verb = "Update" if is_update else "Add"
+    _write_json(submission_id, record, f"{verb} submission: {trial_id} — {username}")
     url = (
         f"https://huggingface.co/datasets/{HF_DATASET_REPO}"
         f"/blob/{HF_DATASET_BRANCH}/{submission_id}"
         if hf_configured
         else None
     )
-    return {"submissionId": submission_id, "url": url, "record": record}
+    return {
+        "submissionId": submission_id,
+        "url": url,
+        "record": record,
+        "updated": is_update,
+    }
 
 
 def add_review(submission_id: str, status: str, reviewer: str, note: str = "") -> Dict[str, Any]:
@@ -215,6 +246,7 @@ def list_submissions() -> List[Dict[str, Any]]:
                 "trial_id": sub.get("trial_id", ""),
                 "username": sub.get("username", ""),
                 "submittedAt": sub.get("submittedAt", ""),
+                "updatedAt": sub.get("updatedAt", sub.get("submittedAt", "")),
                 "status": latest["status"] if latest else "pending",
                 "reviewedAt": latest["at"] if latest else "",
                 "reviewer": latest["reviewer"] if latest else "",
@@ -223,7 +255,7 @@ def list_submissions() -> List[Dict[str, Any]]:
                 "submission": sub,
             }
         )
-    result.sort(key=lambda r: r.get("submittedAt", ""), reverse=True)
+    result.sort(key=lambda r: r.get("updatedAt", ""), reverse=True)
     return result