From 6c4322acd8ba8480c568b9fdd1d8c4d39c45d8f1 Mon Sep 17 00:00:00 2001
From: Obvious <obvious@obvious.ai>
Date: Thu, 15 Oct 2026 09:52:21 +0000
Subject: [PATCH 01/20] fix(backend): address Greptile review findings on the
 orchestrator

Four findings from the apex review of PR #247, each pinned by a
regression test in test_greptile_followup.py:

- Amendment runs hydrated the base packet: RunRecord now carries the
  accepted packet_uri and hydrate_packet resolves manifest paths under
  the packet's own prefix (artifacts.py:202).
- on_confirmation passed a capture_id string where confirm() expects a
  Reads record, so device corrections were never applied. It now loads
  the newest run's reads artifact, applies the answer, and persists the
  updated record (api.py:173).
- A retry inherited the previous attempt's entered_at, so the timeout
  sweep cancelled the replacement worker before it started. _spawn_one
  clears the timestamp when a new attempt begins (coordinator.py:266).
- Final success always read verdicts/verdict.C.json; it now reads the
  run's selected profile verdict and falls back to C (coordinator.py:571).

The committed jobs.v0.schema.json is regenerated for the new
RunRecord.packet_uri field.

(cherry picked from commit 13f9f4a6286794369c61130879d6df5c8820b634)

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/contracts/jobs.py              |   3 +
 .../contracts/schemas/jobs.v0.schema.json     |  12 ++
 backend/server/orchestrator/api.py            |  30 +++-
 backend/server/orchestrator/artifacts.py      |  16 +-
 backend/server/orchestrator/coordinator.py    |  17 +-
 backend/server/orchestrator/services.py       |   2 +
 .../tests/test_greptile_followup.py           | 150 ++++++++++++++++++
 7 files changed, 221 insertions(+), 9 deletions(-)
 create mode 100644 backend/server/orchestrator/tests/test_greptile_followup.py

diff --git a/backend/server/contracts/jobs.py b/backend/server/contracts/jobs.py
index 01165242b..b9beefe19 100644
--- a/backend/server/contracts/jobs.py
+++ b/backend/server/contracts/jobs.py
@@ -122,6 +122,9 @@ class RunRecord(Strict):
     run_id: str
     capture_id: str
     packet_sha256: str
+    # Storage key of the accepted packet manifest. An amendment's packet lives
+    # under its amendment prefix, not captures/{capture_id}/packet.json.
+    packet_uri: str | None = None
     parent_run_id: str | None = None
     status: StageStatus
     branch: Branch
diff --git a/backend/server/contracts/schemas/jobs.v0.schema.json b/backend/server/contracts/schemas/jobs.v0.schema.json
index e409f9529..02cbb3aa3 100644
--- a/backend/server/contracts/schemas/jobs.v0.schema.json
+++ b/backend/server/contracts/schemas/jobs.v0.schema.json
@@ -516,6 +516,18 @@
           "title": "Packet Sha256",
           "type": "string"
         },
+        "packet_uri": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Packet Uri"
+        },
         "parent_run_id": {
           "anyOf": [
             {
diff --git a/backend/server/orchestrator/api.py b/backend/server/orchestrator/api.py
index 02d54af49..6de2cd234 100644
--- a/backend/server/orchestrator/api.py
+++ b/backend/server/orchestrator/api.py
@@ -73,6 +73,7 @@ def start_run(
         run_id=run_id,
         capture_id=capture_id,
         packet_sha256=digest,
+        packet_uri=packet_uri,
         parent_run_id=parent_run_id,
         status="pending",
         branch=branch_of(packet),  # type: ignore[arg-type]
@@ -162,16 +163,39 @@ def on_confirmation(
     )
     try:
         from server.reads.policy import confirm
+        from server.reads.types import Reads
     except ImportError:
         return
-    confirm(
-        capture_id,
+    key = _latest_reads_key(services, capture_id)
+    if key is None:
+        return
+    try:
+        reads = Reads.model_validate(json.loads(services.storage.get_bytes(key)))  # type: ignore[attr-defined]
+    except (OSError, ValueError):
+        return
+    updated = confirm(
+        reads,
         still_id=confirmation.imageId,
         choice=confirmation.value if confirmation.kind == "confirmed" else None,
         typed=confirmation.value if confirmation.kind == "corrected" else None,
-        by=by,
+        by=by,  # type: ignore[arg-type]
         field_id=confirmation.fieldId,
     )
+    # Persist the corrected record so later results read the answer.
+    services.storage.put_bytes(key, updated.model_dump_json().encode(), "application/json")  # type: ignore[attr-defined]
+
+
+def _latest_reads_key(services: object, capture_id: str) -> str | None:
+    """The reads artifact of the capture's newest run, or None before reads exist."""
+
+    runs = services.state.runs_for_capture(capture_id)  # type: ignore[attr-defined]
+    if not runs:
+        return None
+    run = max(runs, key=lambda item: item.created_at)
+    from server.orchestrator.artifacts import overlay_stage_artifacts
+
+    key = overlay_stage_artifacts(services.state, run).artifacts.get("reads/reads.json")  # type: ignore[attr-defined]
+    return key or None
 
 
 def cancel_capture(capture_id: str) -> None:
diff --git a/backend/server/orchestrator/artifacts.py b/backend/server/orchestrator/artifacts.py
index be23d9020..92084cd82 100644
--- a/backend/server/orchestrator/artifacts.py
+++ b/backend/server/orchestrator/artifacts.py
@@ -190,21 +190,24 @@ def hydrate_packet(
     *,
     include_files: bool = True,
     cache_dir: Path | None = None,
+    packet_key: str | None = None,
 ) -> None:
     """Copy the packet into ``packet_dir``.
 
     ``include_files`` is false for stages that only read ``packet.json``. A warm
     volume cache skips GCS for the frames a later stage does need.
+    ``packet_key`` is the manifest's storage key: an amendment run passes its
+    own ``captures/{capture_id}/amendments/{amendment_id}/packet.json``.
     """
 
     packet_dir.mkdir(parents=True, exist_ok=True)
     if _copy_packet_cache(cache_dir, packet_dir, include_files=include_files):
         return
-    packet_key = f"captures/{capture_id}/packet.json"
-    _download_all(storage, [(packet_dir / "packet.json", packet_key)])
+    manifest_key = packet_key or f"captures/{capture_id}/packet.json"
+    _download_all(storage, [(packet_dir / "packet.json", manifest_key)])
     if not include_files:
         return
-    _download_all(storage, _packet_file_jobs(state, capture_id, packet_dir))
+    _download_all(storage, _packet_file_jobs(state, capture_id, packet_dir, manifest_key))
     if cache_dir is not None and (packet_dir / "packet.json").is_file():
         _publish_packet_cache(packet_dir, cache_dir)
 
@@ -244,7 +247,7 @@ def hydrate_artifacts(storage: object, dest_root: Path, artifacts: dict[str, str
     return present
 
 
-def _packet_file_jobs(state: object, capture_id: str, packet_dir: Path) -> list[tuple[Path, str]]:
+def _packet_file_jobs(state: object, capture_id: str, packet_dir: Path, packet_key: str) -> list[tuple[Path, str]]:
     packet: dict | None = None
     manifest = packet_dir / "packet.json"
     if manifest.is_file():
@@ -254,6 +257,9 @@ def _packet_file_jobs(state: object, capture_id: str, packet_dir: Path) -> list[
             loaded = None
         if isinstance(loaded, dict):
             packet = loaded
+    # Manifest paths are relative to the packet. A base packet sits at
+    # captures/{capture_id}/packet.json, an amendment under its own prefix.
+    base = packet_key.rsplit("packet.json", 1)[0] or f"captures/{capture_id}/"
     jobs: list[tuple[Path, str]] = []
     seen: set[str] = set()
     files = getattr(state, "files", None)
@@ -273,7 +279,7 @@ def _packet_file_jobs(state: object, capture_id: str, packet_dir: Path) -> list[
         rel = _safe_rel(rel_text)
         if rel is None:
             continue
-        jobs.append((packet_dir / rel, f"captures/{capture_id}/{rel.as_posix()}"))
+        jobs.append((packet_dir / rel, f"{base}{rel.as_posix()}"))
         seen.add(rel.as_posix())
     return jobs
 
diff --git a/backend/server/orchestrator/coordinator.py b/backend/server/orchestrator/coordinator.py
index b66e3b4d8..6c96a6bef 100644
--- a/backend/server/orchestrator/coordinator.py
+++ b/backend/server/orchestrator/coordinator.py
@@ -42,6 +42,16 @@
 from server.orchestrator.stateio import get_json, put_json
 
 _FINAL = {"verdict_ready", "retake_request", "failed"}
+_PROFILES = {"A", "B", "C", "S"}
+
+
+def _run_profile(run: RunRecord) -> str:
+    """The run's selected rules profile, or the C default when unset."""
+
+    profile = getattr(run, "profile_default", None)
+    return profile if profile in _PROFILES else "C"
+
+
 # Capture status that matches a composed outcome. Views needed is needs_views.
 _KIND_STATUS = {
     "eligible": "complete",
@@ -261,6 +271,9 @@ def _spawn_one(self, run: RunRecord, name: StageName) -> bool:
         rec.worker_call_id = call_id
         rec.started_at = self.s.clock.iso()
         rec.heartbeat = self.s.clock.iso()
+        # entered_at belongs to the attempt that set it. A replacement worker
+        # must not inherit the previous attempt's elapsed budget.
+        rec.entered_at = None
         rec.error = None
         rec.error_code = None
         self.s.state.upsert_stage(rec)
@@ -557,7 +570,9 @@ def _apply_success(self, run: RunRecord) -> None:
             self._finish_with_result(run, decision, composed)
             self._verify_final_event(run)
             return
-        verdict = _read_json(self.s, self._overlay_artifacts(run), "verdicts/verdict.C.json")
+        verdict = _read_json(self.s, self._overlay_artifacts(run), f"verdicts/verdict.{_run_profile(run)}.json")
+        if verdict is None and _run_profile(run) != "C":
+            verdict = _read_json(self.s, self._overlay_artifacts(run), "verdicts/verdict.C.json")
         site = (verdict or {}).get("site") or {}
         decision_name = str(site.get("decision") or "manual_review")
         views = list((verdict or {}).get("views_needed") or [])
diff --git a/backend/server/orchestrator/services.py b/backend/server/orchestrator/services.py
index aeb4baf20..a6fcbab45 100644
--- a/backend/server/orchestrator/services.py
+++ b/backend/server/orchestrator/services.py
@@ -49,6 +49,7 @@ def stage_context(self, run: RunRecord, rec: StageRecord, call_id: str) -> Stage
         packet_dir = work / "packet"
         packet_dir.mkdir(exist_ok=True)
         reads = self.reads_for(run.capture_id)
+        packet_uri = getattr(run, "packet_uri", None) or f"captures/{run.capture_id}/packet.json"
         hydrate_packet(
             reads,
             self.state,
@@ -56,6 +57,7 @@ def stage_context(self, run: RunRecord, rec: StageRecord, call_id: str) -> Stage
             packet_dir,
             include_files=stage_needs_packet_files(rec.stage),
             cache_dir=packet_cache_dir(run.capture_id, run.packet_sha256),
+            packet_key=packet_uri,
         )
         # Artifacts stay on raw storage. Scene merge replaces scene.json in place
         # after objects_3d has already read it, and a cache would keep the pre-merge bytes.
diff --git a/backend/server/orchestrator/tests/test_greptile_followup.py b/backend/server/orchestrator/tests/test_greptile_followup.py
new file mode 100644
index 000000000..b47b58fc3
--- /dev/null
+++ b/backend/server/orchestrator/tests/test_greptile_followup.py
@@ -0,0 +1,150 @@
+"""Regressions from the Greptile apex review of PR #247.
+
+Each test names the finding it pins: amendment packet hydration, confirmation
+persistence, per-attempt timeout budgets, and the run's own rules profile.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import timedelta
+from pathlib import Path
+
+from server.contracts.api import ConfirmationRequest
+from server.contracts.jobs import RunRecord, StageRecord
+from server.orchestrator.api import on_confirmation
+from server.orchestrator.clock import Clock
+from server.orchestrator.coordinator import RunCoordinator
+from server.orchestrator.events import emit_failed
+from server.orchestrator.services import bind
+from server.orchestrator.tests.conftest import build_services
+from server.reads.types import ConfirmBlock, MeterRead, Reads
+
+
+def _run(services, run_id: str, **overrides: object) -> RunRecord:
+    fields: dict[str, object] = {
+        "run_id": run_id,
+        "capture_id": "cap_test",
+        "packet_sha256": "a" * 64,
+        "status": "running",
+        "branch": "image",
+        "flow": "guided",
+        "tier": "arkit",
+        "profile_default": "C",
+        "created_at": services.clock.iso(),
+        "deadline_at": (services.clock.now() + timedelta(minutes=20)).isoformat(),
+        "artifacts": {},
+    }
+    fields.update(overrides)
+    return RunRecord(**fields)  # type: ignore[arg-type]
+
+
+def test_amendment_run_hydrates_its_own_packet(tmp_path: Path) -> None:
+    """Finding: artifacts.py:202 — an amendment run read the base packet."""
+    services, _uri, _digest = build_services(tmp_path, "memory")
+    amend_key = "captures/cap_test/amendments/amd-1/packet.json"
+    amend_packet = {
+        "keyframes": [{"id": "door-2"}],
+        "stills": [],
+        "files": [{"path": "extra/photo.jpg", "sha256": "ab" * 32, "bytes": 4}],
+    }
+    services.storage.put_bytes(amend_key, json.dumps(amend_packet).encode(), "application/json")
+    services.storage.put_bytes("captures/cap_test/amendments/amd-1/extra/photo.jpg", b"jpeg", "image/jpeg")
+    run = _run(services, "run_amend", packet_uri=amend_key)
+    rec = StageRecord(run_id=run.run_id, stage="poses", status="running", attempt=1, heartbeat=services.clock.iso())
+    with bind(services):
+        ctx = services.stage_context(run, rec, "call")
+    packet_dir = Path(ctx.inputs["packet_dir"])
+    # The amendment manifest, not captures/cap_test/packet.json.
+    assert json.loads((packet_dir / "packet.json").read_text()) == amend_packet
+    # Manifest-listed files resolve under the amendment prefix.
+    assert (packet_dir / "extra" / "photo.jpg").read_bytes() == b"jpeg"
+
+
+def test_confirmation_updates_the_reads_record(tmp_path: Path) -> None:
+    """Finding: api.py:173 — confirm() got a capture_id string, not a Reads."""
+    services, _uri, _digest = build_services(tmp_path, "memory")
+    key = "captures/cap_test/runs/run_reads/reads/reads.json"
+    reads = Reads(
+        capture_id="cap_test",
+        status="complete",
+        meter=MeterRead(status="auto_fill", value="00000", core="00000", confidence=0.5),
+        confirm=ConfirmBlock(candidates=["00000"]),
+    )
+    services.storage.put_bytes(key, reads.model_dump_json().encode(), "application/json")
+    run = _run(services, "run_reads", status="done", artifacts={"reads/reads.json": key})
+    services.state.put_run(run)
+    request = ConfirmationRequest(
+        fieldId="meter_number",
+        kind="corrected",
+        value="12345",
+        imageId="s1",
+        clientAt="2026-10-15T00:00:00.000Z",
+    )
+    with bind(services):
+        on_confirmation("cap_test", request, "cfm_1", by="device")
+    stored = Reads.model_validate(json.loads(services.storage.get_bytes(key)))
+    assert stored.meter is not None
+    assert stored.meter.value == "12345"
+    assert stored.meter.status == "auto_fill"
+    assert stored.confirm is not None
+    assert stored.confirm.answer == "12345"
+
+
+def test_new_attempt_clears_entered_at(tmp_path: Path) -> None:
+    """Finding: coordinator.py:266 — a retry inherited the timed-out budget."""
+    services, _uri, _digest = build_services(tmp_path, "memory")
+    # No worker runs, so the persisted attempt-start record is observable.
+    services.executor.spawn = lambda call_id, ctx: None  # type: ignore[method-assign]
+    run = _run(services, "run_retry")
+    services.state.put_run(run)
+    old = services.clock.iso()
+    services.state.upsert_stage(
+        StageRecord(
+            run_id=run.run_id,
+            stage="validate",
+            status="pending",
+            attempt=1,
+            failures=1,
+            heartbeat=old,
+            entered_at=old,
+            error_code="timeout",
+            error="timeout: validate",
+        )
+    )
+    with bind(services):
+        assert RunCoordinator(services)._spawn_one(run, "validate")
+    rec = services.state.get_stage(run.run_id, "validate")
+    assert rec.status == "running"
+    # The timeout sweep measures from entered_at; a stale value would cancel
+    # the replacement worker before it ever entered the stage.
+    assert rec.entered_at is None
+    assert rec.error_code is None
+    with bind(services):
+        RunCoordinator(services)._sweep_timeouts(run)
+    assert services.state.get_stage(run.run_id, "validate").status == "running"
+
+
+def test_success_reads_the_runs_profile_verdict(tmp_path: Path) -> None:
+    """Finding: coordinator.py:571 — success always read verdict.C.json."""
+    services, _uri, _digest = build_services(tmp_path, "memory")
+    key = "captures/cap_test/runs/run_prof/verdicts/verdict.A.json"
+    verdict = {"site": {"decision": "manual_review"}, "views_needed": ["door-2"]}
+    services.storage.put_bytes(key, json.dumps(verdict).encode(), "application/json")
+    run = _run(services, "run_prof", profile_default="A", artifacts={"verdicts/verdict.A.json": key})
+    services.state.put_run(run)
+    # One final event already exists, so the close does not rewrite the status.
+    emit_failed(
+        services.state,
+        "cap_test",
+        run.run_id,
+        "seed",
+        "seed",
+        "manual_review",
+        clock=Clock(),
+    )
+    with bind(services):
+        RunCoordinator(services)._apply_success(run)
+    # A-profile verdict asks for more views; verdict.C.json is absent, so the
+    # old hard-coded read fell through to manual_review and blocked amendments.
+    assert services.state.get_capture("cap_test").status == "needs_views"

From 223b32a6b61f520e2476d050fa962b5905edc187 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Thu, 15 Oct 2026 10:01:55 +0000
Subject: [PATCH 02/20] fix(backend): retryable finalize handoff and
 lease-guarded file-index merge

- finish_ready: a failing on_finalized hook now raises ApiFailure(503) so the
  handoff stays retryable; run_started is only recorded after the hook succeeds.
- _guard: exceptions escaping background finalize work flow through the normal
  failure-event and retry path instead of vanishing; the original exception is
  still set on the future for test callers.
- ModalDictState.upsert_file: merge the per-capture path index under the shared
  state-store lease (claimed via the backing Dict's atomic skip_if_exists put)
  so concurrent containers cannot overwrite each other's index entries.
- Regression tests for all three: failed run-start stays retryable, background
  exceptions emit failure events and leave retryable state, and two concurrent
  writers keep every index entry (the fake modal.Dict pairs concurrent readers
  onto the same snapshot to force the stale-read interleaving deterministically).

(cherry picked from commit 64dfb7a96aeaa8b971f4eb7458e339b1c6f4d6a2)

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/api/finalize.py                |  22 +++-
 .../api/tests/test_finalize_background.py     |  83 ++++++++++++
 .../common/backends/state_modal_dict.py       |  14 +-
 .../common/tests/test_modal_dict_files.py     | 124 ++++++++++++++++++
 4 files changed, 238 insertions(+), 5 deletions(-)
 create mode 100644 backend/server/api/tests/test_finalize_background.py
 create mode 100644 backend/server/common/tests/test_modal_dict_files.py

diff --git a/backend/server/api/finalize.py b/backend/server/api/finalize.py
index 7b4f0c45d..42ecadd7d 100644
--- a/backend/server/api/finalize.py
+++ b/backend/server/api/finalize.py
@@ -15,7 +15,6 @@
 from server.api.errors import ApiFailure, fail, pointer_from_loc
 from server.api.events import emit
 from server.api.finalize_checks import manifest_errors
-from server.api.hooks import safe_hook
 from server.api.ids import require_contract_id
 from server.api.keys import packet_key
 from server.api.promotion import promote
@@ -345,7 +344,14 @@ def finish_ready(
         if record.status == "failed":
             raise fail(409, "invalid_state", "/", "promotion failed")
     if extra.get("started_run_id") != run_id:
-        safe_hook("on_finalized", deps.hooks.on_finalized, record.capture_id, digest, key, parent_run_id=parent_run_id)
+        try:
+            deps.hooks.on_finalized(record.capture_id, digest, key, parent_run_id=parent_run_id)
+        except Exception as exc:
+            log_event("hook.error", hook="on_finalized", error_code=type(exc).__name__, level="error")
+            # The run did not start. Leaving run_started unset keeps the handoff
+            # retryable: the background failure path restores the previous status,
+            # and a later finalize request schedules the run again.
+            raise fail(503, "run_start_failed", "/", "run start failed; finalize again") from exc
         log_event("run.started", run_id=run_id, capture_id=record.capture_id)
         extra = extras(deps, record.capture_id)
         extra["run_started"] = True
@@ -494,6 +500,18 @@ def _guard(deps: Deps, capture_id: str, future: Future[None]) -> None:
         _finish_loop(deps, capture_id)
     except Exception as exc:
         _clear_slot(capture_id)
+        # The 202 has already returned and the capture reads as processing, so a
+        # failure stored only on this Future would strand the client: no failure
+        # event, no retry, no run for the sweepers to recover. Route the exception
+        # through the normal failure path instead. Once the run has started, the
+        # handoff succeeded; later errors must not undo it.
+        if not extras(deps, capture_id).get("run_started"):
+            failure = (
+                exc
+                if isinstance(exc, ApiFailure)
+                else fail(503, "finalize_failed", "/", f"finalize background work failed ({type(exc).__name__})")
+            )
+            _on_background_failure(deps, capture_id, failure)
         future.set_exception(exc)
         return
     future.set_result(None)
diff --git a/backend/server/api/tests/test_finalize_background.py b/backend/server/api/tests/test_finalize_background.py
new file mode 100644
index 000000000..ff886dc8a
--- /dev/null
+++ b/backend/server/api/tests/test_finalize_background.py
@@ -0,0 +1,83 @@
+"""Escaped background finalize failures stay visible and retryable."""
+
+from __future__ import annotations
+
+import pytest
+
+from server.api.deps import drain_finalize, extras
+from server.api.tests.conftest import photo_packet
+from server.api.tests.test_ingest import _create, _finalize, _put_commit
+
+
+def _ready_capture(client, packet_id: str):
+    """A capture with every packet file committed, ready for a full finalize."""
+    capture_id = _create(client, packet_id)
+    blob = b"jpeg"
+    _put_commit(client, capture_id, "stills/s1.jpg", blob, meta={"still": "s1"})
+    packet = photo_packet(packet_id, [("stills/s1.jpg", blob)])
+    return capture_id, packet
+
+
+def test_failed_run_start_stays_retryable(client, monkeypatch):
+    capture_id, packet = _ready_capture(client, "packet-hook-fail")
+    deps = client.app_state
+
+    def boom(*args, **kwargs):
+        raise RuntimeError("modal start_run failed")
+
+    monkeypatch.setattr(deps.hooks, "on_finalized", boom)
+    client.hold_finalize = True
+    try:
+        response, _raw = _finalize(client, capture_id, packet)
+        assert response.status_code == 202, response.text
+        # finish_ready raises ApiFailure(503); _work_once handles it through the
+        # normal background failure path, so the drain itself completes.
+        drain_finalize(deps)
+    finally:
+        client.hold_finalize = False
+
+    # The handoff failed, so the run must not be marked started.
+    assert not extras(deps, capture_id).get("run_started")
+    assert extras(deps, capture_id).get("started_run_id") is None
+    events = client.get(f"/v1/captures/{capture_id}/events").json()["events"]
+    failures = [e for e in events if e["type"] == "failed" and e["data"].get("code") == "run_start_failed"]
+    assert failures and failures[0]["data"]["next"] == "retry_finalize"
+    assert deps.state.get_capture(capture_id).status == "uploading"
+
+    # With the hook healthy again, a later finalize starts the run.
+    monkeypatch.undo()
+    second, _raw = _finalize(client, capture_id, packet)
+    assert second.status_code == 202, second.text
+    assert second.json()["status"] == "processing"
+    assert extras(deps, capture_id).get("run_started") is True
+
+
+def test_background_exception_fails_retryably(client, monkeypatch):
+    capture_id, packet = _ready_capture(client, "packet-bg-fail")
+    deps = client.app_state
+
+    def offline(_key):
+        raise RuntimeError("volume offline")
+
+    monkeypatch.setattr(deps.storage, "get_bytes", offline)
+    client.hold_finalize = True
+    try:
+        response, _raw = _finalize(client, capture_id, packet)
+        assert response.status_code == 202, response.text
+        with pytest.raises(RuntimeError):
+            drain_finalize(deps)
+    finally:
+        client.hold_finalize = False
+
+    # The storage error must surface as a failure event and a retryable status,
+    # not as a capture stuck on processing with the exception on a dead Future.
+    events = client.get(f"/v1/captures/{capture_id}/events").json()["events"]
+    failures = [e for e in events if e["type"] == "failed" and e["data"].get("code") == "finalize_failed"]
+    assert failures and failures[0]["data"]["next"] == "retry_finalize"
+    assert deps.state.get_capture(capture_id).status == "uploading"
+
+    # Storage healthy again: a later finalize completes the handoff.
+    monkeypatch.undo()
+    second, _raw = _finalize(client, capture_id, packet)
+    assert second.status_code == 202, second.text
+    assert second.json()["status"] == "processing"
diff --git a/backend/server/common/backends/state_modal_dict.py b/backend/server/common/backends/state_modal_dict.py
index c6e002f43..8633e0a61 100644
--- a/backend/server/common/backends/state_modal_dict.py
+++ b/backend/server/common/backends/state_modal_dict.py
@@ -336,9 +336,17 @@ def delete_capture(self, capture_id: str) -> None:
 
     def upsert_file(self, rec: FileRecord) -> None:
         self._kv[f"file:{rec.capture_id}:{rec.path}"] = rec.model_dump(mode="json")
-        paths = set(self._kv.get(f"files:{rec.capture_id}") or [])
-        paths.add(rec.path)
-        self._kv[f"files:{rec.capture_id}"] = sorted(paths)
+
+        def merge() -> None:
+            paths = set(self._kv.get(f"files:{rec.capture_id}") or [])
+            paths.add(rec.path)
+            self._kv[f"files:{rec.capture_id}"] = sorted(paths)
+
+        # Two containers can register files in parallel; the route's capture lock
+        # only guards one process. Merge the index under the shared Dict lease so
+        # a stale read in one container cannot drop the other's entry. The lease
+        # claims its slot with the Dict's atomic skip_if_exists put.
+        with_lease(self, f"files:{rec.capture_id}", merge)
 
     def get_file(self, capture_id: str, path: str) -> FileRecord | None:
         return self._model(f"file:{capture_id}:{path}", FileRecord)
diff --git a/backend/server/common/tests/test_modal_dict_files.py b/backend/server/common/tests/test_modal_dict_files.py
new file mode 100644
index 000000000..8f5ee2762
--- /dev/null
+++ b/backend/server/common/tests/test_modal_dict_files.py
@@ -0,0 +1,124 @@
+"""Concurrent upsert_file writers keep every index entry."""
+
+from __future__ import annotations
+
+import threading
+import time
+
+from server.common.backends.state_modal_dict import ModalDictState
+from server.contracts.jobs import FileRecord
+
+
+class _ReadGate:
+    """Hold each concurrent pair of readers until both have entered.
+
+    A thread arriving alone waits briefly and proceeds (the leased, serialized
+    path); two threads arriving together are released with the same snapshot,
+    which is exactly the stale-read interleaving the index merge must survive.
+    """
+
+    def __init__(self) -> None:
+        self._cond = threading.Condition()
+        self._waiting = 0
+        self.enabled = True
+
+    def hold(self) -> None:
+        if not self.enabled:
+            return
+        with self._cond:
+            self._waiting += 1
+            self._cond.notify_all()
+            if self._waiting >= 2:
+                self._cond.notify_all()
+                return
+            deadline = time.monotonic() + 0.05
+            while self._waiting < 2 and time.monotonic() < deadline:
+                self._cond.wait(deadline - time.monotonic())
+            self._waiting = max(0, self._waiting - 1)
+
+
+class _FakeModalDict:
+    """modal.Dict stand-in: point get, write-through setitem, atomic skip_if_exists put."""
+
+    def __init__(self) -> None:
+        self.store: dict = {}
+        self._put_lock = threading.Lock()
+        self.gate = _ReadGate()
+
+    def get(self, key):
+        # Capture the snapshot BEFORE the GIL is released by the gate hold: the
+        # unfixed read-modify-write has no GIL release between read and write, so
+        # a hold placed after the read would never produce a stale snapshot.
+        value = self.store.get(key)
+        if key.startswith("files:"):
+            self.gate.hold()
+        return value
+
+    def __contains__(self, key) -> bool:
+        return key in self.store
+
+    def __setitem__(self, key, value) -> None:
+        self.store[key] = value
+
+    def __delitem__(self, key) -> None:
+        del self.store[key]
+
+    def pop(self, key, default=None):
+        if key not in self.store:
+            return default
+        value = self.store[key]
+        del self.store[key]
+        return value
+
+    def put(self, key, value, skip_if_exists: bool = False) -> bool:
+        with self._put_lock:
+            if skip_if_exists:
+                if key in self.store:
+                    return False
+                self.store[key] = value
+                return True
+            self.store[key] = value
+            return True
+
+    def keys(self):
+        return list(self.store.keys())
+
+
+def _file(capture_id: str, path: str) -> FileRecord:
+    return FileRecord(
+        capture_id=capture_id,
+        path=path,
+        role="still",
+        bytes=3,
+        sha256="a" * 64,
+        md5="b",
+        content_type="image/jpeg",
+        state="committed",
+    )
+
+
+def test_two_concurrent_writers_keep_every_index_entry() -> None:
+    mapping = _FakeModalDict()
+    left = ModalDictState(mapping)
+    right = ModalDictState(mapping)
+    start = threading.Barrier(2)
+
+    def register(state: ModalDictState, tag: str) -> None:
+        start.wait()
+        for index in range(20):
+            state.upsert_file(_file("cap_1", f"{tag}/s{index}.jpg"))
+
+    threads = [
+        threading.Thread(target=register, args=(left, "left")),
+        threading.Thread(target=register, args=(right, "right")),
+    ]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join()
+
+    mapping.gate.enabled = False
+    paths = [rec.path for rec in left.files("cap_1")]
+    expected = {f"{tag}/s{index}.jpg" for tag in ("left", "right") for index in range(20)}
+    assert set(paths) == expected
+    assert len(paths) == 40

From 9f07c90fa7a6b02ade7bea9e87cdf3868312be59 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Thu, 15 Oct 2026 15:47:23 +0000
Subject: [PATCH 03/20] fix(backend): serialize MemoryState event seq
 assignment

Two concurrent append_event callers could both read the same last
event and append duplicate seq values, breaking the strictly
increasing per-capture sequence and the events_after cursor. Hold a
dedicated per-instance event lock across read-tail, seq assignment
and append; release it before the returned deep copy. events_after
keeps its cursor and deep-copy behavior.

The regression test gates both producers at event construction while
the event lock is free: 10 of 10 pre-fix runs produce duplicate seqs,
10 of 10 post-fix runs stay contiguous and complete. Greptile P1 on
PR #247, comment r4281331039.

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
(cherry picked from commit ca7448e23ad8b0e6b889e920e3ebdb6a7eebcb5c)
---
 .../server/common/backends/state_memory.py    | 28 ++++---
 .../common/tests/test_state_memory_events.py  | 78 +++++++++++++++++++
 2 files changed, 94 insertions(+), 12 deletions(-)
 create mode 100644 backend/server/common/tests/test_state_memory_events.py

diff --git a/backend/server/common/backends/state_memory.py b/backend/server/common/backends/state_memory.py
index 4cc6ef244..e8d95e925 100644
--- a/backend/server/common/backends/state_memory.py
+++ b/backend/server/common/backends/state_memory.py
@@ -49,6 +49,7 @@ def __init__(self) -> None:
         self._spend: dict[str, float] = {}
         self._open_by_owner: dict[str, list[str]] = {}
         self._claim_lock = threading.Lock()
+        self._event_lock = threading.Lock()
 
     def get_capture(self, capture_id: str) -> CaptureRecord | None:
         rec = self._captures.get(capture_id)
@@ -137,18 +138,21 @@ def append_event(
         run_id: str | None = None,
         stage: StageName | None = None,
     ) -> EventRecord:
-        prior = self._events.get(capture_id, [])
-        seq = (prior[-1].seq + 1) if prior else 1
-        rec = EventRecord(
-            capture_id=capture_id,
-            seq=seq,
-            type=type,
-            at=datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ"),
-            data=dict(data),
-            run_id=run_id,
-            stage=stage,
-        )
-        self._events.setdefault(capture_id, []).append(rec)
+        with self._event_lock:
+            # Read the tail, assign the seq and append as one atomic step, so two
+            # producers never observe the same last event.
+            prior = self._events.get(capture_id, [])
+            seq = (prior[-1].seq + 1) if prior else 1
+            rec = EventRecord(
+                capture_id=capture_id,
+                seq=seq,
+                type=type,
+                at=datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ"),
+                data=dict(data),
+                run_id=run_id,
+                stage=stage,
+            )
+            self._events.setdefault(capture_id, []).append(rec)
         return rec.model_copy(deep=True)
 
     def events_after(self, capture_id: str, seq: int, limit: int = 100) -> list[EventRecord]:
diff --git a/backend/server/common/tests/test_state_memory_events.py b/backend/server/common/tests/test_state_memory_events.py
new file mode 100644
index 000000000..f7359548e
--- /dev/null
+++ b/backend/server/common/tests/test_state_memory_events.py
@@ -0,0 +1,78 @@
+"""Concurrent appends on MemoryState keep a gap-free sequence."""
+
+from __future__ import annotations
+
+import threading
+
+import pytest
+
+from server.common.backends import state_memory
+from server.common.backends.state_memory import MemoryState
+
+_APPENDS_PER_PRODUCER = 40
+_ROUNDS = 5
+
+
+def _emit(
+    state: MemoryState,
+    capture_id: str,
+    seqs: list[int],
+    errors: list[Exception],
+    guard: threading.Lock,
+) -> None:
+    try:
+        for _ in range(_APPENDS_PER_PRODUCER):
+            rec = state.append_event(capture_id, "hint", {"code": "frames_blurry", "message": "m"})
+            rec.data["code"] = "mutated"
+            with guard:
+                seqs.append(rec.seq)
+    except Exception as exc:
+        with guard:
+            errors.append(exc)
+
+
+def _run_round(
+    monkeypatch: pytest.MonkeyPatch,
+    real_event_record: type,
+    capture_id: str,
+) -> tuple[list[int], list[Exception], MemoryState]:
+    state = MemoryState()
+    barrier = threading.Barrier(2)
+
+    def gated_event_record(**kwargs: object):
+        # Pre-fix, both producers reach event construction unlocked, meet at the
+        # barrier and read the same tail. With the event lock held, the gate is
+        # a no-op and the producers never meet.
+        lock = getattr(state, "_event_lock", None)
+        if lock is None or not lock.locked():
+            barrier.wait(timeout=30)
+        return real_event_record(**kwargs)
+
+    monkeypatch.setattr(state_memory, "EventRecord", gated_event_record)
+    seqs: list[int] = []
+    errors: list[Exception] = []
+    guard = threading.Lock()
+    threads = [threading.Thread(target=_emit, args=(state, capture_id, seqs, errors, guard)) for _ in range(2)]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join()
+    monkeypatch.undo()
+    return seqs, errors, state
+
+
+def test_append_event_two_producers_stay_contiguous_unique_and_ordered(monkeypatch: pytest.MonkeyPatch) -> None:
+    capture_id = "cap_seq2"
+    total = 2 * _APPENDS_PER_PRODUCER
+    real_event_record = state_memory.EventRecord
+    for _round in range(_ROUNDS):
+        seqs, errors, state = _run_round(monkeypatch, real_event_record, capture_id)
+        assert errors == []
+        ordered = sorted(seqs)
+        assert ordered == list(range(1, total + 1))
+        assert len(set(ordered)) == total
+        assert [rec.seq for rec in state.events_after(capture_id, 0, limit=total + 10)] == list(range(1, total + 1))
+        assert [rec.seq for rec in state.events_after(capture_id, 40)] == list(range(41, total + 1))
+        assert [rec.seq for rec in state.events_after(capture_id, 40, limit=5)] == [41, 42, 43, 44, 45]
+        stored = state.events_after(capture_id, 0, limit=1)[0]
+        assert stored.data["code"] == "frames_blurry"

From e805a26095a29fd3376b1c4e95305bf3771816e1 Mon Sep 17 00:00:00 2001
From: Obvious <obvious@obvious.ai>
Date: Fri, 16 Oct 2026 01:02:36 +0000
Subject: [PATCH 04/20] test(backend): add runtime-join journeys over the
 capture front door

Three API-level journeys prove the imported fixes interact over the real
documented dev settings: retryable dispatch with exactly one run and one
final event after the retry, concurrent event producers fully visible
through cursor polling, and amendment runs hydrating their own packet
bytes and files. Mutation-checked: the dispatch journey fails when the
503 restore path is dropped; the amendment journey fails when the
amendment hydration prefix is dropped; the seq-lock race is caught by the
imported deterministic gate.

Co-authored-by: Sam Gu <sgu07966@gmail.com>

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/tests/test_runtime_join_journey.py | 468 +++++++++++++++++++++
 1 file changed, 468 insertions(+)
 create mode 100644 backend/tests/test_runtime_join_journey.py

diff --git a/backend/tests/test_runtime_join_journey.py b/backend/tests/test_runtime_join_journey.py
new file mode 100644
index 000000000..b4106adeb
--- /dev/null
+++ b/backend/tests/test_runtime_join_journey.py
@@ -0,0 +1,468 @@
+"""The joined runtime, end to end: dispatch faults, event visibility, amendments.
+
+Three sibling fixes landed on their own branches and are imported here as scoped
+diffs, so their regressions pass on the joined tree but nothing proves the fixes
+*interact* over the real API:
+
+- #251 (`13f9f4a6`, cut from `2d0911f8`): amendment runs hydrate their own packet,
+  device confirmations apply, retries get a fresh timeout budget, and the final
+  status reads the run's own rules profile.
+- #252 (`64dfb7a9`, cut from `2d0911f8`): a failed ``on_finalized`` dispatch stays
+  retryable, background exceptions surface as retryable failures, and concurrent
+  file-index merges run under the state lease.
+- #266 (`ca7448e2`, cut from `57f57ff8`): ``MemoryState.append_event`` assigns the
+  per-capture ``seq`` under a dedicated lock, so the ``events_after`` cursor the
+  client polls never skips or repeats an event.
+
+This file is that proof: one API-level journey per interaction, over the
+documented dev settings (SD-73) — memory state, local volume storage, static test
+auth, an HMAC upload secret, stage stubs with prewarm and external vision calls
+off. No Modal, no GPU, no network, no credentials.
+
+The journeys reuse the committed ``mini-arkit`` packet fixture and the capture
+front door exactly as ``test_capture_placement_frontdoor.py`` walks it, so the
+existing capture journey — through the real, ``stubs_exempt`` placement stage —
+still completes here; the three tests below pin what the joins add on top of it.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import shutil
+import threading
+import time
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from server.api.app import create_app
+from server.api.deps import drain_finalize, extras
+from server.common.config import Settings
+from server.contracts.jobs import run_id_for_capture
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+PACKET_FIXTURE = REPO_ROOT / "backend" / "data" / "fixtures" / "packets" / "mini-arkit"
+
+TERMINAL_OUTCOMES = {"verdict_ready", "retake_request"}
+
+# The documented dev setting, as in the front-door test: the real hook chain with
+# stubbed stages (placement is stubs_exempt and runs the real solver).
+TEMPLATE_ENV = {
+    "HSS_ORCH_STAGE_STUBS": "1",
+    "HSS_ORCH_PREWARM": "0",
+    "VISION_EXTERNAL_CALLS": "off",
+    "STATE_BACKEND": "memory",
+    "STORAGE_BACKEND": "volume",
+    "SMP_ENVIRONMENT": "dev",
+}
+
+
+@pytest.fixture
+def journey(tmp_path, monkeypatch):
+    """The app behind the capture front door, plus a private copy of the fixture."""
+    for key, value in TEMPLATE_ENV.items():
+        monkeypatch.setenv(key, value)
+    monkeypatch.setenv("VOLUME_ROOT", str(tmp_path / "vol"))
+    root = tmp_path / "packet"
+    shutil.copytree(PACKET_FIXTURE, root)
+    packet = json.loads((root / "packet.json").read_text())
+    settings = Settings(
+        SMP_ENVIRONMENT="dev",
+        HSS_AUTH_MODE="static",
+        # Synthetic, explicitly static test auth — no real principal.
+        CAPTURE_API_TOKENS=f"device:{'d' * 40}",
+        UPLOAD_URL_HMAC_SECRET="h" * 32,
+        STORAGE_BACKEND="volume",
+        STATE_BACKEND="memory",
+        VOLUME_ROOT=str(tmp_path / "vol"),
+        CAPTURE_API_PUBLIC_URL="http://testserver",
+        HSS_INGEST_HOOKS="auto",
+        VISION_EXTERNAL_CALLS="off",
+        GIT_SHA="0123456789abcdef",
+        SMP_SERVICE_NAME="capture-api",
+    )
+    app = create_app(settings=settings)
+    client = TestClient(app)
+    client.headers["Authorization"] = f"Bearer {'d' * 40}"
+    return root, packet, client, app
+
+
+def _content_type(role: str) -> str:
+    if role == "stream":
+        return "application/gzip"
+    if role in {"features", "depth", "confidence", "mesh"}:
+        return "application/octet-stream"
+    return "image/jpeg"
+
+
+def _poll_events(client: TestClient, capture_id: str) -> list[list[dict]]:
+    """Walk the events cursor to quiescence, keeping every page as delivered."""
+    pages: list[list[dict]] = []
+    after = 0
+    for _ in range(60):
+        page = client.get(f"/v1/captures/{capture_id}/events", params={"after": after}).json()
+        assert page["next"] >= after, "the events cursor moved backwards"
+        pages.append(page["events"])
+        if page["next"] == after:
+            return pages
+        after = page["next"]
+    pytest.fail("event feed never stopped moving")
+
+
+def _flat(client: TestClient, capture_id: str) -> list[dict]:
+    return [event for page in _poll_events(client, capture_id) for event in page]
+
+
+def _register_and_commit_fixture(root: Path, packet: dict, client: TestClient, app, capture_id: str) -> None:
+    """Register, upload and commit every fixture file the manifest lists."""
+    registered_paths = []
+    for entry in packet["files"]:
+        data = (root / entry["path"]).read_bytes()
+        item = {
+            "path": entry["path"],
+            "bytes": len(data),
+            "sha256": hashlib.sha256(data).hexdigest(),
+            "md5": base64.b64encode(hashlib.md5(data).digest()).decode(),
+            "role": entry.get("role", "still"),
+            "contentType": _content_type(entry.get("role", "still")),
+        }
+        registered = client.post(f"/v1/captures/{capture_id}/files", json={"files": [item]})
+        assert registered.status_code == 200, registered.text
+        upload = registered.json()["files"][0]["upload"]
+        # The signed URL is its own capability: no bearer header on the PUT.
+        put = TestClient(app).put(upload["url"], content=data, headers=upload.get("headers") or {})
+        assert put.status_code == 200, put.text
+        registered_paths.append({"path": item["path"], "sha256": item["sha256"]})
+    commit = client.post(f"/v1/captures/{capture_id}/files:commit", json={"files": registered_paths})
+    assert commit.status_code == 200, commit.text
+
+
+def _finalize(
+    client: TestClient,
+    capture_id: str,
+    raw: bytes,
+    packet_id: str,
+    *,
+    amendment_id: str | None = None,
+) -> dict:
+    suffix = f"/amendments/{amendment_id}/finalize" if amendment_id else "/finalize"
+    response = client.post(
+        f"/v1/captures/{capture_id}{suffix}",
+        content=raw,
+        headers={
+            "Idempotency-Key": amendment_id or packet_id,
+            "Content-Type": "application/json",
+            "X-Packet-Sha256": hashlib.sha256(raw).hexdigest(),
+        },
+    )
+    assert response.status_code == 202, response.text
+    return response.json()
+
+
+def _open_front_door(root: Path, packet: dict, client: TestClient, app, packet_id: str) -> tuple[str, bytes]:
+    """A capture with every packet file committed; returns (capture_id, packet bytes)."""
+    document = dict(packet)
+    document["packetId"] = packet_id
+    raw = (json.dumps(document, indent=2) + "\n").encode()
+    (root / "packet.json").write_bytes(raw)
+
+    session = packet["session"]
+    created = client.post(
+        "/v1/captures",
+        json={
+            "packetId": packet_id,
+            "formatVersion": packet["formatVersion"],
+            "tier": session["tier"],
+            "flow": "guided",
+            "device": {
+                "model": session["deviceModel"],
+                "systemVersion": session["systemVersion"],
+                "appVersion": session["appVersion"],
+            },
+        },
+        headers={"Idempotency-Key": packet_id},
+    )
+    assert created.status_code == 201, created.text
+    capture_id = created.json()["captureId"]
+    _register_and_commit_fixture(root, packet, client, app, capture_id)
+    return capture_id, raw
+
+
+def test_failed_dispatch_stays_retryable_and_the_retry_lands_one_run_one_final(journey) -> None:
+    """A broken ``on_finalized`` dispatch returns the retryable error and fabricates
+    nothing; once the hook heals, one finalize retry establishes one run with one
+    composed final event — not a second run, not a duplicate final."""
+    root, packet, client, app = journey
+    deps = app.state.deps
+
+    # The sibling journey stays healthy while the fault capture is under test.
+    sibling, _ = _open_front_door(root, packet, client, app, "join-dispatch-ok")
+    accepted = _finalize(
+        client,
+        sibling,
+        (json.dumps({**packet, "packetId": "join-dispatch-ok"}, indent=2) + "\n").encode(),
+        "join-dispatch-ok",
+    )
+    drain_finalize(deps)
+    assert deps.state.get_run(accepted["runId"]).status == "done"
+
+    def boom(*args, **kwargs):
+        raise RuntimeError("orchestrator start_run failed")
+
+    original = deps.hooks.on_finalized
+    deps.hooks.on_finalized = boom
+    try:
+        fault_id, raw = _open_front_door(root, packet, client, app, "join-dispatch-fault")
+        response = _finalize(client, fault_id, raw, "join-dispatch-fault")
+        assert response["status"] == "processing"
+        drain_finalize(deps)
+    finally:
+        deps.hooks.on_finalized = original
+
+    # The dispatch failed retryably — the existing 503 path, not a dead end.
+    extra = extras(deps, fault_id)
+    assert not extra.get("run_started")
+    assert extra.get("started_run_id") is None
+    assert deps.state.runs_for_capture(fault_id) == []
+    assert deps.state.get_capture(fault_id).status == "uploading"
+    events = _flat(client, fault_id)
+    failures = [e for e in events if e["type"] == "failed" and e["data"].get("code") == "run_start_failed"]
+    assert failures and failures[0]["data"]["next"] == "retry_finalize"
+    # A controlled fault interrupts dispatch; it cannot fabricate a success artifact.
+    assert not [e for e in events if e["type"] in TERMINAL_OUTCOMES]
+    assert deps.state.get_capture(sibling).status == "manual_review"
+
+    # The retry — same bytes, same deterministic run id — starts exactly one run.
+    second = _finalize(client, fault_id, raw, "join-dispatch-fault")
+    assert second["status"] == "processing"
+    for _ in range(600):
+        if extras(deps, fault_id).get("run_started"):
+            break
+        time.sleep(0.01)
+    assert extras(deps, fault_id).get("run_started") is True
+    drain_finalize(deps)
+
+    runs = deps.state.runs_for_capture(fault_id)
+    assert len(runs) == 1 and runs[0].status == "done"
+    assert runs[0].run_id == run_id_for_capture(fault_id, raw)
+    events = _flat(client, fault_id)
+    finals = [e for e in events if e["type"] in TERMINAL_OUTCOMES]
+    assert [e["type"] for e in finals] == ["verdict_ready"]
+    # The wire Event carries no run_id field — the run id lives in the payload.
+    assert finals[0]["data"]["runId"] == runs[0].run_id
+    seqs = [e["seq"] for e in events]
+    assert seqs == sorted(set(seqs)) and seqs == list(range(1, len(seqs) + 1))
+    # The retried journey still completes through the placement stage.
+    assert any(
+        e["type"] == "stage" and e["data"].get("stage") == "placement" and e["data"].get("status") == "done"
+        for e in events
+    )
+    assert len(failures) == 1
+
+
+def test_concurrent_event_producers_fully_visible_through_cursor_polling(journey) -> None:
+    """Two producers appending to one capture — the API request path and the
+    background finalize worker — never lose an event to the cursor: a poller
+    walking ``after`` pages sees every seq exactly once, contiguously."""
+    root, packet, client, app = journey
+    deps = app.state.deps
+    capture_id, _ = _open_front_door(root, packet, client, app, "join-events")
+    _finalize(
+        client, capture_id, (json.dumps({**packet, "packetId": "join-events"}, indent=2) + "\n").encode(), "join-events"
+    )
+    drain_finalize(deps)
+    base_events = _flat(client, capture_id)
+    base_count = len(base_events)
+    assert base_count > 0
+
+    producers_seen: list[list[int]] = [[], []]
+    start = threading.Barrier(3)
+
+    def produce(slot: int) -> None:
+        start.wait()
+        for index in range(30):
+            rec = deps.state.append_event(capture_id, "capture_check", {"join": f"p{slot}-{index}"})
+            producers_seen[slot].append(rec.seq)
+
+    poller_pages: list[list[dict]] = []
+    poller_stop = threading.Event()
+
+    def poll() -> None:
+        start.wait()
+        after = 0
+        while not poller_stop.is_set():
+            page = client.get(f"/v1/captures/{capture_id}/events", params={"after": after}).json()
+            poller_pages.append(page["events"])
+            if page["next"] == after:
+                poller_stop.wait(0.02)
+            else:
+                after = page["next"]
+
+    threads = [
+        threading.Thread(target=produce, args=(0,)),
+        threading.Thread(target=produce, args=(1,)),
+        threading.Thread(target=poll),
+    ]
+    for thread in threads:
+        thread.start()
+    for thread in threads[:2]:
+        thread.join()
+    poller_stop.set()
+    threads[2].join(timeout=10)
+    assert not threads[2].is_alive()
+
+    # Each producer drew a distinct slice of the sequence — never the same seq.
+    assert producers_seen[0] and producers_seen[1]
+    assert set(producers_seen[0]).isdisjoint(producers_seen[1])
+
+    seqs = [event["seq"] for page in poller_pages for event in page]
+    assert seqs == sorted(seqs), "a page arrived behind the cursor"
+    assert len(seqs) == len(set(seqs)), "the cursor delivered an event twice"
+    expected = list(range(1, base_count + 61))
+    assert seqs == expected, "the cursor skipped an event a producer appended"
+
+    # The store itself holds the complete, contiguous sequence.
+    assert [e["seq"] for e in _flat(client, capture_id)] == expected
+
+
+def test_amendment_hydrates_its_own_packet_bytes_and_files(journey) -> None:
+    """An amendment run reads the amendment's packet manifest and files, not the
+    original capture's — its run record carries its own packet_uri, and its new
+    file resolves under the amendment prefix."""
+    root, packet, client, app = journey
+    deps = app.state.deps
+    capture_id, raw = _open_front_door(root, packet, client, app, "join-amend")
+    accepted = _finalize(client, capture_id, raw, "join-amend")
+    parent_run = accepted["runId"]
+    drain_finalize(deps)
+    assert deps.state.get_run(parent_run).status == "done"
+
+    # The stub result never asks for views, so take the capture to the state the
+    # device would see (needs_views with one requested view) the way the
+    # amendment suite seeds it — the parent run itself stays the real journey's.
+    run = deps.state.get_run(parent_run)
+    result_key = run.artifacts["result/result.json"]
+    served = json.loads(deps.storage.get_bytes(result_key))
+    served["viewsNeeded"] = [{"id": "wall-left"}]
+    served["outcome"]["viewsNeeded"] = [{"id": "wall-left"}]
+    deps.storage.put_bytes(result_key, json.dumps(served).encode(), "application/json")
+    deps.state.set_status(capture_id, "needs_views")
+
+    opened = client.post(
+        f"/v1/captures/{capture_id}/amendments",
+        json={"amendmentId": "amd-join-1", "answers": ["wall-left"]},
+        headers={"Idempotency-Key": "amd-join-1"},
+    )
+    assert opened.status_code == 201, opened.text
+    assert opened.json()["pathPrefix"] == "amendments/amd-join-1/"
+
+    # The amendment's own still — a path and bytes the original capture never had.
+    blob = b"amendment-wall-bytes-not-in-the-original"
+    amend_path = "amendments/amd-join-1/stills/amend-wall.jpg"
+    registered = client.post(
+        f"/v1/captures/{capture_id}/files",
+        json={
+            "files": [
+                {
+                    "path": amend_path,
+                    "bytes": len(blob),
+                    "sha256": hashlib.sha256(blob).hexdigest(),
+                    "md5": base64.b64encode(hashlib.md5(blob).digest()).decode(),
+                    "role": "still",
+                    "contentType": "image/jpeg",
+                }
+            ]
+        },
+    )
+    assert registered.status_code == 200, registered.text
+    upload = registered.json()["files"][0]["upload"]
+    put = TestClient(app).put(upload["url"], content=blob, headers=upload.get("headers") or {})
+    assert put.status_code == 200, put.text
+    committed = client.post(
+        f"/v1/captures/{capture_id}/files:commit",
+        json={"files": [{"path": amend_path, "sha256": hashlib.sha256(blob).hexdigest()}]},
+    )
+    assert committed.status_code == 200, committed.text
+
+    # The device's amendment packet: its own packetId, the parent's packet id,
+    # and a manifest of exactly the files it re-captured.
+    amend_packet = {
+        "format": "house-capture-packet",
+        "formatVersion": "0.4",
+        "packetId": "join-amend-followup",
+        "parentPacketId": "join-amend",
+        "createdAt": "2026-10-15T00:00:00.000Z",
+        "units": {"length": "meters", "angle": "degrees", "time": "seconds", "image": "pixels"},
+        "conventions": {
+            "world": "ARKit gravity, y up",
+            "camera": "ARKit camera, looks along -z",
+            "pose": "arkit-column-major",
+            "intrinsics": "[fx, fy, cx, cy]",
+            "pixel": "[u, v] top-left, v down",
+        },
+        "keyframes": [],
+        "source": {"kind": "synthetic"},
+        "session": {
+            "id": "sess-amend",
+            "startedAt": "2026-10-15T00:00:00.000Z",
+            "startedAtUptime": 0.0,
+            "appVersion": "1",
+            "deviceModel": "iPhone",
+            "systemVersion": "18",
+            "tier": "photo_only",
+            "lidarAvailable": False,
+            "sceneDepthEnabled": False,
+        },
+        "stills": [
+            {
+                "id": "s1",
+                "purpose": "house_overview",
+                "img": "stills/amend-wall.jpg",
+                "w": 2,
+                "h": 2,
+                "timestamp": 0,
+                "orientation": 1,
+            }
+        ],
+        "files": [
+            {
+                "path": "stills/amend-wall.jpg",
+                "bytes": len(blob),
+                "sha256": hashlib.sha256(blob).hexdigest(),
+                "role": "still",
+            }
+        ],
+    }
+    amend_raw = json.dumps(amend_packet).encode()
+    finalize = _finalize(client, capture_id, amend_raw, "join-amend-followup", amendment_id="amd-join-1")
+    assert finalize["status"] == "processing"
+    drain_finalize(deps)
+
+    runs = deps.state.runs_for_capture(capture_id)
+    assert len(runs) == 2
+    amend_run = max(runs, key=lambda item: item.created_at)
+    assert amend_run.run_id == run_id_for_capture(capture_id, amend_raw)
+    # The run's identity is the amendment's packet, not the original capture's.
+    assert amend_run.packet_uri == f"captures/{capture_id}/amendments/amd-join-1/packet.json"
+    assert amend_run.parent_run_id == parent_run
+    assert amend_run.status == "done"
+    assert amend_run.packet_sha256 == hashlib.sha256(amend_raw).hexdigest()
+
+    events = _flat(client, capture_id)
+    assert [e["type"] for e in events if e["type"] in TERMINAL_OUTCOMES] == ["verdict_ready", "verdict_ready"]
+    # The wire Event carries no run_id field — the run id lives in the payload.
+    assert any(e["data"].get("runId") == amend_run.run_id for e in events if e["type"] == "verdict_ready")
+    seqs = [e["seq"] for e in events]
+    assert seqs == sorted(set(seqs)) and seqs == list(range(1, len(seqs) + 1))
+
+    # The amendment's file landed under the amendment prefix, and the run
+    # completed — hydration resolved the manifest under the amendment prefix.
+    # Under the pre-fix derivation the manifest-listed file would be fetched from
+    # captures/{capture_id}/stills/amend-wall.jpg, which does not exist, and the
+    # run would fail during stage hydration.
+    assert deps.storage.get_bytes(f"captures/{capture_id}/amendments/amd-join-1/stills/amend-wall.jpg") == blob
+    with pytest.raises(OSError):
+        deps.storage.get_bytes(f"captures/{capture_id}/stills/amend-wall.jpg")

From 54b439cd489cad473e1264b2cd525a82fca87086 Mon Sep 17 00:00:00 2001
From: Obvious <obvious@obvious.ai>
Date: Fri, 16 Oct 2026 01:02:36 +0000
Subject: [PATCH 05/20] test(backend): read the fake start_run failure as a
 local contract

Rename the raised error from the Modal-flavored string to the orchestrator
contract and note that Modal is the production transport while this suite
pins the retryable handoff locally.

Co-authored-by: Sam Gu <sgu07966@gmail.com>

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/api/tests/test_finalize_background.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/backend/server/api/tests/test_finalize_background.py b/backend/server/api/tests/test_finalize_background.py
index ff886dc8a..c8269798f 100644
--- a/backend/server/api/tests/test_finalize_background.py
+++ b/backend/server/api/tests/test_finalize_background.py
@@ -22,8 +22,10 @@ def test_failed_run_start_stays_retryable(client, monkeypatch):
     capture_id, packet = _ready_capture(client, "packet-hook-fail")
     deps = client.app_state
 
+    # A local fake of any orchestrator start_run failure — Modal is the
+    # production transport; this suite pins the retryable handoff contract.
     def boom(*args, **kwargs):
-        raise RuntimeError("modal start_run failed")
+        raise RuntimeError("orchestrator start_run failed")
 
     monkeypatch.setattr(deps.hooks, "on_finalized", boom)
     client.hold_finalize = True

From 0d19b3c1f0f5a240ab274070563804f15ffbcbf0 Mon Sep 17 00:00:00 2001
From: Obvious <obvious@obvious.ai>
Date: Fri, 16 Oct 2026 05:54:44 +0000
Subject: [PATCH 06/20] fix(backend): close amendment, confirmation, and retry
 defects on the runtime join

- Lease file-index merge now claims strictly: with_lease(strict=True)
  raises LeaseBusy on exhaustion and the API maps it to a retryable 503
  with Retry-After, so two concurrent register+commit writers can no
  longer silently merge under one side's stale lease.
- Packet hydration resolves the selected packet's manifest before
  committed file records, so an amendment reusing a base still name
  hydrates its own bytes instead of the base capture's.
- Finalize background-failure publication holds finish_sync across the
  run_started check and the failure event, releasing the worker slot
  only after publication; a successful retry can no longer interleave.
- Accepted confirmations that arrive before reads exist are persisted
  per field and applied when the reads stage creates its record (real
  and stub paths); the route keeps its authorization and replay gates.
- Late confirmations on a done run recompose through the normal
  coordinator lifecycle (criteria+result reset, same run id), and the
  stub result now derives the meter from hydrated reads/reads.json so
  a correction is observable on GET /result.
- Event-polling journey drains to the expected final cursor instead of
  an unbounded loop.

Co-authored-by: Sam Gu <sgu07966@gmail.com>

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/api/app.py                     |   8 ++
 backend/server/api/finalize.py                |  23 +--
 .../api/tests/test_finalize_background.py     |  47 +++++-
 .../common/backends/state_modal_dict.py       |  11 +-
 backend/server/common/lease.py                |  27 +++-
 backend/server/orchestrator/api.py            |  51 +++++++
 backend/server/orchestrator/artifacts.py      |  21 +--
 backend/server/orchestrator/stubs/reads.py    |  33 ++++-
 backend/server/orchestrator/stubs/result.py   |  50 ++++++-
 .../tests/test_greptile_followup.py           |  55 ++++++-
 backend/server/reads/__init__.py              |   8 ++
 backend/server/reads/pending.py               |  65 +++++++++
 backend/tests/test_runtime_join_journey.py    | 134 ++++++++++++++++++
 13 files changed, 509 insertions(+), 24 deletions(-)
 create mode 100644 backend/server/reads/pending.py

diff --git a/backend/server/api/app.py b/backend/server/api/app.py
index 8534c2c8c..a3586c0e0 100644
--- a/backend/server/api/app.py
+++ b/backend/server/api/app.py
@@ -31,6 +31,7 @@
     uploads,
 )
 from server.common.config import Settings, load, resolve_state, resolve_storage
+from server.common.lease import LeaseBusy
 from server.common.logging import log_event, request_fields
 
 _MB = 1024 * 1024
@@ -202,6 +203,13 @@ async def send_now(response: JSONResponse):
     async def api_failure(_request: Request, failure: ApiFailure):
         return error_response(failure)
 
+    @app.exception_handler(LeaseBusy)
+    async def lease_busy(_request: Request, exc: LeaseBusy):
+        # The file-index merge never ran, so the registration is safe to retry.
+        return error_response(
+            fail(503, "lease_busy", "/", "file index is busy; retry the registration", **{"Retry-After": "1"})
+        )
+
     @app.exception_handler(RequestValidationError)
     async def validation_error(_request: Request, exc: RequestValidationError):
         items = []
diff --git a/backend/server/api/finalize.py b/backend/server/api/finalize.py
index 42ecadd7d..c0ea67811 100644
--- a/backend/server/api/finalize.py
+++ b/backend/server/api/finalize.py
@@ -499,19 +499,26 @@ def _guard(deps: Deps, capture_id: str, future: Future[None]) -> None:
     try:
         _finish_loop(deps, capture_id)
     except Exception as exc:
-        _clear_slot(capture_id)
         # The 202 has already returned and the capture reads as processing, so a
         # failure stored only on this Future would strand the client: no failure
         # event, no retry, no run for the sweepers to recover. Route the exception
         # through the normal failure path instead. Once the run has started, the
         # handoff succeeded; later errors must not undo it.
-        if not extras(deps, capture_id).get("run_started"):
-            failure = (
-                exc
-                if isinstance(exc, ApiFailure)
-                else fail(503, "finalize_failed", "/", f"finalize background work failed ({type(exc).__name__})")
-            )
-            _on_background_failure(deps, capture_id, failure)
+        #
+        # The worker slot stays occupied and the publication lock is held across
+        # the run_started check and the failure write: a concurrent finalize retry
+        # publishes its success under the same lock, so this older worker can
+        # never reset a healed retry or emit a contradictory terminal event after
+        # it.
+        with deps.locks.finish_sync(capture_id):
+            if not extras(deps, capture_id).get("run_started"):
+                failure = (
+                    exc
+                    if isinstance(exc, ApiFailure)
+                    else fail(503, "finalize_failed", "/", f"finalize background work failed ({type(exc).__name__})")
+                )
+                _on_background_failure(deps, capture_id, failure)
+        _clear_slot(capture_id)
         future.set_exception(exc)
         return
     future.set_result(None)
diff --git a/backend/server/api/tests/test_finalize_background.py b/backend/server/api/tests/test_finalize_background.py
index c8269798f..b9aea5fd6 100644
--- a/backend/server/api/tests/test_finalize_background.py
+++ b/backend/server/api/tests/test_finalize_background.py
@@ -78,8 +78,53 @@ def offline(_key):
     assert failures and failures[0]["data"]["next"] == "retry_finalize"
     assert deps.state.get_capture(capture_id).status == "uploading"
 
-    # Storage healthy again: a later finalize completes the handoff.
+
+def test_escaped_failure_publishes_before_releasing_the_worker_slot(client, monkeypatch):
+    """Finding: _guard — the slot was released before the failure was published.
+
+    A finalize retry that lands in the gap sees a free slot, publishes its
+    success, and is then overwritten by the older worker's failure — the healed
+    capture resets to uploading behind a failure event for a run that started.
+    With publication and the run_started check serialized under the finish lock,
+    the older worker observes the retry's success and defers; either order ends
+    consistent. This pins the ordering half: at the moment the failure is
+    published, this worker still owns the slot.
+    """
+    import server.api.finalize as finalize_module
+
+    capture_id, packet = _ready_capture(client, "packet-bg-order")
+    deps = client.app_state
+
+    def offline(_key):
+        raise RuntimeError("volume offline")
+
+    publication_slot_state: list[bool] = []
+    original_failure_path = finalize_module._on_background_failure
+
+    def probing_failure_path(*args, **kwargs):
+        publication_slot_state.append(capture_id in finalize_module._slots)
+        return original_failure_path(*args, **kwargs)
+
+    monkeypatch.setattr(deps.storage, "get_bytes", offline)
+    monkeypatch.setattr(finalize_module, "_on_background_failure", probing_failure_path)
+    client.hold_finalize = True
+    try:
+        response, _raw = _finalize(client, capture_id, packet)
+        assert response.status_code == 202, response.text
+        with pytest.raises(RuntimeError):
+            drain_finalize(deps)
+    finally:
+        client.hold_finalize = False
+
+    # The failure published while this worker still held the slot: a retry that
+    # starts after the slot frees sees the failure already published (or the
+    # run_started flag of a healed retry) — never both.
+    assert publication_slot_state == [True]
+    assert deps.state.get_capture(capture_id).status == "uploading"
+
+    # And the healed retry still lands one healthy run.
     monkeypatch.undo()
     second, _raw = _finalize(client, capture_id, packet)
     assert second.status_code == 202, second.text
+    assert extras(deps, capture_id).get("run_started") is True
     assert second.json()["status"] == "processing"
diff --git a/backend/server/common/backends/state_modal_dict.py b/backend/server/common/backends/state_modal_dict.py
index 8633e0a61..ca3733b78 100644
--- a/backend/server/common/backends/state_modal_dict.py
+++ b/backend/server/common/backends/state_modal_dict.py
@@ -20,6 +20,11 @@
     StageStatus,
 )
 
+# How long upsert_file waits for the per-capture index lease before failing.
+# A module constant so tests can shorten it without sleeping through the real
+# budget.
+_INDEX_LEASE_WAIT_S = 3.0
+
 _OPEN = frozenset({"uploading", "awaiting_files"})
 _APPEND_GUARD = threading.Lock()
 _APPEND_LOCKS: dict[int, threading.Lock] = {}
@@ -346,7 +351,11 @@ def merge() -> None:
         # only guards one process. Merge the index under the shared Dict lease so
         # a stale read in one container cannot drop the other's entry. The lease
         # claims its slot with the Dict's atomic skip_if_exists put.
-        with_lease(self, f"files:{rec.capture_id}", merge)
+        #
+        # The merge runs strictly under the lease: a busy lease raises LeaseBusy
+        # (the route turns it into a retryable 503) instead of merging unlocked
+        # while an abandoned-but-valid lease holds the slot.
+        with_lease(self, f"files:{rec.capture_id}", merge, wait_s=_INDEX_LEASE_WAIT_S, strict=True)
 
     def get_file(self, capture_id: str, path: str) -> FileRecord | None:
         return self._model(f"file:{capture_id}:{path}", FileRecord)
diff --git a/backend/server/common/lease.py b/backend/server/common/lease.py
index eb7e4db0c..4de6cb93a 100644
--- a/backend/server/common/lease.py
+++ b/backend/server/common/lease.py
@@ -7,8 +7,21 @@
 from collections.abc import Callable
 
 
-def with_lease(state: object, name: str, fn: Callable[[], None], *, wait_s: float = 3.0, lease_s: float = 10.0) -> None:
-    """Run ``fn`` while holding ``lease:{name}``. An abandoned lease can be taken after ``lease_s``."""
+def with_lease(
+    state: object,
+    name: str,
+    fn: Callable[[], None],
+    *,
+    wait_s: float = 3.0,
+    lease_s: float = 10.0,
+    strict: bool = False,
+) -> None:
+    """Run ``fn`` while holding ``lease:{name}``. An abandoned lease can be taken after ``lease_s``.
+
+    With ``strict=True`` the caller refuses to run ``fn`` without ownership: a
+    lease that stays busy past ``wait_s`` raises :class:`LeaseBusy` instead of
+    executing the protected section unlocked.
+    """
 
     key = f"lease:{name}"
     token = {"id": uuid.uuid4().hex, "at": time.time()}
@@ -26,5 +39,15 @@ def with_lease(state: object, name: str, fn: Callable[[], None], *, wait_s: floa
             state.delete_kv(key)  # type: ignore[attr-defined]
             continue
         if time.monotonic() >= deadline:
+            if strict:
+                raise LeaseBusy(f"lease {name!r} stayed busy for {wait_s:g}s")
             return fn()
         time.sleep(0.01)
+
+
+class LeaseBusy(RuntimeError):
+    """A strict lease could not be acquired within its wait budget.
+
+    Callers turn this into a retryable failure: the protected section never ran,
+    so retrying the operation later is safe.
+    """
diff --git a/backend/server/orchestrator/api.py b/backend/server/orchestrator/api.py
index 6de2cd234..d54a16887 100644
--- a/backend/server/orchestrator/api.py
+++ b/backend/server/orchestrator/api.py
@@ -148,6 +148,50 @@ def dispatch_early(capture_id: str, files: list[CommittedFile]) -> None:
     dispatch(current(), capture_id, files)
 
 
+def _recompose_after_correction(capture_id: str, run: RunRecord) -> None:
+    """Re-run criteria and result on the finished run so the served result reflects a late correction.
+
+    A confirmation accepted after reads reached the result cannot retroactively
+    enter the composed payload. ``start_run`` cannot stage a fresh run here — it
+    derives the run id from the packet digest, so the same packet joins the
+    existing run instead of creating one. Instead the finished run's criteria and
+    result stages go back to pending, the run re-enters the normal coordinator
+    lifecycle, and the re-executed stages overwrite the same artifact keys: the
+    recomposed payload is what ``GET /result`` serves next. The acceptance event
+    and the recomposition's ``verdict_ready`` land on ``GET /events``. A replayed
+    confirmation still short-circuits upstream, so one correction recomposes once.
+
+    A live run is left alone — its result stage has not consumed the corrected
+    reads yet, so it recomposes by simply running.
+    """
+
+    services = current()
+    if run.status != "done":
+        return
+    now = services.clock.iso()
+    for stage in ("criteria", "result"):
+        rec = services.state.get_stage(run.run_id, stage)  # type: ignore[attr-defined]
+        services.state.upsert_stage(  # type: ignore[attr-defined]
+            StageRecord(
+                run_id=run.run_id,
+                stage=stage,
+                status="pending",
+                attempt=(rec.attempt if rec is not None else 0) + 1,
+                heartbeat=now,
+            )
+        )
+    run.status = "running"
+    services.state.put_run(run)  # type: ignore[attr-defined]
+    raw = dict(get_json(services.state, f"run_control:{run.run_id}") or {})  # type: ignore[attr-defined]
+    raw["merge_done"] = False
+    put_json(services.state, f"run_control:{run.run_id}", raw)  # type: ignore[attr-defined]
+    try:
+        RunCoordinator(services).drive(run.run_id)
+    except CoordinatorDied:
+        pass
+    log_event("confirmation.recompose", capture_id=capture_id, run_id=run.run_id)
+
+
 def on_confirmation(
     capture_id: str,
     confirmation: ConfirmationRequest,
@@ -183,6 +227,13 @@ def on_confirmation(
     )
     # Persist the corrected record so later results read the answer.
     services.storage.put_bytes(key, updated.model_dump_json().encode(), "application/json")  # type: ignore[attr-defined]
+    # A correction accepted after the result was composed must reach the served
+    # payload, not only the stored reads. The route replays short-circuit above
+    # this hook, so one accepted correction recomposes once.
+    runs = services.state.runs_for_capture(capture_id)  # type: ignore[attr-defined]
+    if runs:
+        newest = max(runs, key=lambda item: item.created_at)
+        _recompose_after_correction(capture_id, newest)
 
 
 def _latest_reads_key(services: object, capture_id: str) -> str | None:
diff --git a/backend/server/orchestrator/artifacts.py b/backend/server/orchestrator/artifacts.py
index 92084cd82..cd8add6b1 100644
--- a/backend/server/orchestrator/artifacts.py
+++ b/backend/server/orchestrator/artifacts.py
@@ -262,6 +262,17 @@ def _packet_file_jobs(state: object, capture_id: str, packet_dir: Path, packet_k
     base = packet_key.rsplit("packet.json", 1)[0] or f"captures/{capture_id}/"
     jobs: list[tuple[Path, str]] = []
     seen: set[str] = set()
+    # The selected packet's manifest resolves first: its paths are authoritative
+    # for this run. An amendment that reuses a base filename (stills/s1.jpg) with
+    # different bytes must download its own copy under the amendment prefix — a
+    # committed base-file record entering `seen` first would silently hydrate the
+    # base bytes and the real validator would reject the size/hash mismatch.
+    for rel_text in _packet_paths(packet):
+        rel = _safe_rel(rel_text)
+        if rel is None or rel.as_posix() in seen:
+            continue
+        jobs.append((packet_dir / rel, f"{base}{rel.as_posix()}"))
+        seen.add(rel.as_posix())
     files = getattr(state, "files", None)
     records = files(capture_id) if callable(files) else []
     for rec in records:
@@ -269,18 +280,10 @@ def _packet_file_jobs(state: object, capture_id: str, packet_dir: Path, packet_k
             continue
         rel = _safe_rel(str(getattr(rec, "path", "") or ""))
         key = str(getattr(rec, "key", "") or "")
-        if rel is None or not key:
+        if rel is None or not key or rel.as_posix() in seen:
             continue
         jobs.append((packet_dir / rel, key))
         seen.add(rel.as_posix())
-    for rel_text in _packet_paths(packet):
-        if rel_text in seen:
-            continue
-        rel = _safe_rel(rel_text)
-        if rel is None:
-            continue
-        jobs.append((packet_dir / rel, f"{base}{rel.as_posix()}"))
-        seen.add(rel.as_posix())
     return jobs
 
 
diff --git a/backend/server/orchestrator/stubs/reads.py b/backend/server/orchestrator/stubs/reads.py
index 685598eee..cef50127f 100644
--- a/backend/server/orchestrator/stubs/reads.py
+++ b/backend/server/orchestrator/stubs/reads.py
@@ -13,5 +13,36 @@
 
 def run(ctx: StageContext) -> StageResult:
     raw = json.loads(_STUB.read_text()) if _STUB.is_file() else {"meter_number": "000000000"}
-    body = {"format": "base-reads/v0", "capture_id": ctx.capture_id, "facts": [], "meter_number": raw["meter_number"]}
+    body: dict = {
+        "format": "base-reads/v0",
+        "capture_id": ctx.capture_id,
+        "facts": [],
+        "meter_number": raw["meter_number"],
+    }
+    # The reads stage is the application point for confirmations accepted before
+    # reads existed; the stub path applies the same persisted slots so an early
+    # answer reaches the composed result in stub mode too. Without pending slots
+    # the stub body is byte-identical to the old shape.
+    try:
+        from server.reads.pending import pending_slots
+        from server.reads.types import ConfirmBlock, MeterRead, Reads
+
+        rows = pending_slots(ctx.state, ctx.capture_id)
+        if rows:
+            reads = Reads(
+                capture_id=ctx.capture_id,
+                status="complete",
+                meter=MeterRead(
+                    status="auto_fill",
+                    value=str(raw["meter_number"]),
+                    core=str(raw["meter_number"]),
+                    confidence=0.5,
+                ),
+                confirm=ConfirmBlock(candidates=[str(raw["meter_number"])]),
+            )
+            from server.reads.pending import apply_pending
+
+            body = Reads.model_validate(apply_pending(ctx.state, ctx.capture_id, reads)).model_dump(mode="json")
+    except ImportError:
+        pass
     return write_files(ctx, {"reads/reads.json": json_bytes(body)})
diff --git a/backend/server/orchestrator/stubs/result.py b/backend/server/orchestrator/stubs/result.py
index 24c82b548..856898f18 100644
--- a/backend/server/orchestrator/stubs/result.py
+++ b/backend/server/orchestrator/stubs/result.py
@@ -3,9 +3,11 @@
 from __future__ import annotations
 
 import json
+from pathlib import Path
+from typing import Literal
 
 from server.contracts.jobs import Profile, StageContext, StageResult
-from server.contracts.result import Outcome, ResultResponse
+from server.contracts.result import MeterBlock, Outcome, ResultResponse
 from server.orchestrator.stubs._common import json_bytes, sha256, write_files
 
 _PROFILES: frozenset[str] = frozenset({"A", "B", "C", "S"})
@@ -37,6 +39,7 @@ def run(ctx: StageContext) -> StageResult:
             viewsNeeded=[],
             reasons=[],
         ),
+        meter=_stub_meter(ctx),
     )
     body = response.model_dump(mode="json")
     ResultResponse.model_validate(body)
@@ -57,3 +60,48 @@ def _profile(ctx: StageContext) -> Profile:
     if configured in _PROFILES:
         return configured  # type: ignore[return-value]
     return "C"
+
+
+def _meter_status(raw: str) -> Literal["auto_filled", "prefill_confirm", "unreadable", "not_captured"]:
+    """The real composer's meter mapping, with autofill enabled."""
+    if raw == "auto_fill":
+        return "auto_filled"
+    if raw in {"prefill", "choose", "single_reader"}:
+        return "prefill_confirm"
+    if raw == "unreadable":
+        return "unreadable"
+    return "not_captured"
+
+
+def _stub_meter(ctx: StageContext) -> MeterBlock:
+    """The reads-derived meter, as the real composer reports it.
+
+    The result stage hydrates ``reads/reads.json``; serving the meter from it is
+    what makes a recomposition after a late confirmation observable on
+    ``GET /result`` without editing the verdict. The mapping mirrors
+    ``server.result.meter.meter_block`` with autofill enabled.
+    """
+
+    try:
+        doc = json.loads((Path(ctx.work_dir) / "reads" / "reads.json").read_text())
+        meter = doc.get("meter") or {}
+    except (OSError, json.JSONDecodeError, AttributeError):
+        meter = {}
+    status = _meter_status(str(meter.get("status") or ""))
+    value = meter.get("value")
+    shown = str(value) if isinstance(value, str) else None
+    if status == "not_captured":
+        shown = None
+    candidates = [
+        str(item.get("value"))
+        for item in (meter.get("candidates") or [])
+        if isinstance(item, dict) and item.get("value")
+    ][:3]
+    return MeterBlock(
+        status=status,
+        value=shown,
+        candidates=candidates,
+        barcodeConfirmed=bool(meter.get("barcode_match")),
+        readersAgree=bool(meter.get("agree")),
+        clean=False,
+    )
diff --git a/backend/server/orchestrator/tests/test_greptile_followup.py b/backend/server/orchestrator/tests/test_greptile_followup.py
index b47b58fc3..039a3a4bd 100644
--- a/backend/server/orchestrator/tests/test_greptile_followup.py
+++ b/backend/server/orchestrator/tests/test_greptile_followup.py
@@ -6,18 +6,22 @@
 
 from __future__ import annotations
 
+import base64
+import hashlib
 import json
 from datetime import timedelta
 from pathlib import Path
 
 from server.contracts.api import ConfirmationRequest
-from server.contracts.jobs import RunRecord, StageRecord
+from server.contracts.jobs import FileRecord, RunRecord, StageRecord
 from server.orchestrator.api import on_confirmation
 from server.orchestrator.clock import Clock
 from server.orchestrator.coordinator import RunCoordinator
 from server.orchestrator.events import emit_failed
 from server.orchestrator.services import bind
 from server.orchestrator.tests.conftest import build_services
+from server.packet.integrity import check_files
+from server.packet.report import Bag
 from server.reads.types import ConfirmBlock, MeterRead, Reads
 
 
@@ -61,6 +65,55 @@ def test_amendment_run_hydrates_its_own_packet(tmp_path: Path) -> None:
     assert (packet_dir / "extra" / "photo.jpg").read_bytes() == b"jpeg"
 
 
+def test_amendment_same_name_still_hydrates_amendment_bytes(tmp_path: Path) -> None:
+    """Finding: _packet_file_jobs — a committed base file claimed the relative path first.
+
+    An amendment that re-captures a base filename (stills/s1.jpg) with different
+    bytes must hydrate its own copy under the amendment prefix. Under the
+    pre-fix derivation the committed base record entered the seen-set first and
+    the base bytes landed at packet_dir/stills/s1.jpg, so the real validator
+    would reject the size/sha256 mismatch against the amendment manifest.
+    """
+    services, _uri, _digest = build_services(tmp_path, "memory")
+    base_blob = b"base-still-bytes"
+    amend_blob = b"amendment-still-bytes-different"
+    services.storage.put_bytes("captures/cap_test/stills/s1.jpg", base_blob, "image/jpeg")
+    services.state.upsert_file(
+        FileRecord(
+            capture_id="cap_test",
+            path="stills/s1.jpg",
+            role="still",
+            bytes=len(base_blob),
+            sha256=hashlib.sha256(base_blob).hexdigest(),
+            md5=base64.b64encode(hashlib.md5(base_blob).digest()).decode(),
+            content_type="image/jpeg",
+            state="committed",
+            key="captures/cap_test/stills/s1.jpg",
+        )
+    )
+    amend_key = "captures/cap_test/amendments/amd-2/packet.json"
+    amend_packet = {
+        "keyframes": [],
+        "stills": [],
+        "files": [
+            {"path": "stills/s1.jpg", "sha256": hashlib.sha256(amend_blob).hexdigest(), "bytes": len(amend_blob)}
+        ],
+    }
+    services.storage.put_bytes(amend_key, json.dumps(amend_packet).encode(), "application/json")
+    services.storage.put_bytes("captures/cap_test/amendments/amd-2/stills/s1.jpg", amend_blob, "image/jpeg")
+    run = _run(services, "run_amend_2", packet_uri=amend_key)
+    rec = StageRecord(run_id=run.run_id, stage="poses", status="running", attempt=1, heartbeat=services.clock.iso())
+    with bind(services):
+        ctx = services.stage_context(run, rec, "call")
+    packet_dir = Path(ctx.inputs["packet_dir"])
+    # The amendment's bytes — not the committed base file's — sit at the manifest path.
+    assert (packet_dir / "stills" / "s1.jpg").read_bytes() == amend_blob
+    # And the real packet validator agrees with the amendment manifest.
+    bag = Bag()
+    check_files(amend_packet, packet_dir, bag, check_hashes=True, known_sha256=None)
+    assert bag.errors == []
+
+
 def test_confirmation_updates_the_reads_record(tmp_path: Path) -> None:
     """Finding: api.py:173 — confirm() got a capture_id string, not a Reads."""
     services, _uri, _digest = build_services(tmp_path, "memory")
diff --git a/backend/server/reads/__init__.py b/backend/server/reads/__init__.py
index e41206abe..0e811c385 100644
--- a/backend/server/reads/__init__.py
+++ b/backend/server/reads/__init__.py
@@ -25,6 +25,14 @@ def run(ctx: StageContext) -> StageResult:
     )
     packet = _packet(ctx)
     reads = build_reads(ctx.capture_id, ctx.storage, cfg, packet)
+    # Accepted confirmations that arrived before reads existed apply here, once,
+    # onto the record this stage creates.
+    try:
+        from server.reads.pending import apply_pending
+
+        reads = apply_pending(ctx.state, ctx.capture_id, reads)
+    except ImportError:
+        pass
     rel = write_reads(
         ctx.capture_id,
         ctx.run_id,
diff --git a/backend/server/reads/pending.py b/backend/server/reads/pending.py
new file mode 100644
index 000000000..628731151
--- /dev/null
+++ b/backend/server/reads/pending.py
@@ -0,0 +1,65 @@
+"""Accepted confirmations the reads record must carry.
+
+The confirmations route persists every accepted answer as a per-field slot
+(``confirm:{capture_id}:{field_id}``, listed in ``confirmix:{capture_id}``) as
+soon as it passes the conflict and authorization checks. A confirmation that
+arrives before ``reads/reads.json`` exists is applied here, when the reads stage
+creates its record, so an early answer reaches the result without the client
+retrying. The route's fingerprint check keeps a replayed confirmation from being
+applied twice as a new answer; re-applying one accepted slot is idempotent.
+"""
+
+from __future__ import annotations
+
+from server.common.logging import log_event
+from server.reads.policy import confirm
+from server.reads.types import Reads
+
+_BY = frozenset({"device", "reviewer"})
+_FIELDS = frozenset({"meter_number", "panel_brand", "main_breaker_amps"})
+
+
+def pending_slots(state: object, capture_id: str) -> list[dict]:
+    """The accepted per-field confirmation slots persisted for this capture."""
+
+    if state is None:
+        return []
+    listing = state.get_kv(f"confirmix:{capture_id}")  # type: ignore[attr-defined]
+    rows: list[dict] = []
+    for field_id in (listing or {}).get("fields") or []:
+        row = state.get_kv(f"confirm:{capture_id}:{field_id}")  # type: ignore[attr-defined]
+        if isinstance(row, dict) and row.get("kind") in {"confirmed", "corrected", "none"}:
+            rows.append(row)
+    return rows
+
+
+def apply_pending(state: object, capture_id: str, reads: Reads) -> Reads:
+    """Apply each accepted confirmation slot once, preserving answer and authorization."""
+
+    for row in pending_slots(state, capture_id):
+        by = row.get("by") if row.get("by") in _BY else "device"
+        field_id = row.get("fieldId") if row.get("fieldId") in _FIELDS else None
+        if field_id is None:
+            continue
+        kind = row.get("kind")
+        try:
+            reads = confirm(
+                reads,
+                still_id=str(row.get("imageId") or ""),
+                choice=row.get("value") if kind == "confirmed" else None,
+                typed=row.get("value") if kind == "corrected" else None,
+                by=by,  # type: ignore[arg-type]
+                field_id=field_id,  # type: ignore[arg-type]
+            )
+        except Exception as exc:
+            # A stale slot that no longer fits the record must not fail the stage.
+            log_event(
+                "reads.pending_confirmation.skipped",
+                capture_id=capture_id,
+                field_id=str(row.get("fieldId")),
+                error=type(exc).__name__,
+            )
+    return reads
+
+
+__all__ = ["apply_pending", "pending_slots"]
diff --git a/backend/tests/test_runtime_join_journey.py b/backend/tests/test_runtime_join_journey.py
index b4106adeb..9aaf82f5d 100644
--- a/backend/tests/test_runtime_join_journey.py
+++ b/backend/tests/test_runtime_join_journey.py
@@ -288,6 +288,7 @@ def produce(slot: int) -> None:
             producers_seen[slot].append(rec.seq)
 
     poller_pages: list[list[dict]] = []
+    poller_after: list[int] = []
     poller_stop = threading.Event()
 
     def poll() -> None:
@@ -296,6 +297,7 @@ def poll() -> None:
         while not poller_stop.is_set():
             page = client.get(f"/v1/captures/{capture_id}/events", params={"after": after}).json()
             poller_pages.append(page["events"])
+            poller_after.append(after)
             if page["next"] == after:
                 poller_stop.wait(0.02)
             else:
@@ -466,3 +468,135 @@ def test_amendment_hydrates_its_own_packet_bytes_and_files(journey) -> None:
     assert deps.storage.get_bytes(f"captures/{capture_id}/amendments/amd-join-1/stills/amend-wall.jpg") == blob
     with pytest.raises(OSError):
         deps.storage.get_bytes(f"captures/{capture_id}/stills/amend-wall.jpg")
+
+
+def _register_extra_still(root: Path, client: TestClient, app, capture_id: str, name: str, image_id: str) -> bytes:
+    """One still beyond the fixture manifest, carrying the meta the image lookup reads."""
+    blob = f"extra-still-{name}-bytes".encode()
+    item = {
+        "path": f"stills/{name}.jpg",
+        "bytes": len(blob),
+        "sha256": hashlib.sha256(blob).hexdigest(),
+        "md5": base64.b64encode(hashlib.md5(blob).digest()).decode(),
+        "role": "still",
+        "contentType": "image/jpeg",
+        "meta": {
+            "still": {
+                "id": image_id,
+                "purpose": "meter_close",
+                "img": f"stills/{name}.jpg",
+                "w": 2,
+                "h": 2,
+                "timestamp": 0,
+                "orientation": 1,
+            }
+        },
+    }
+    registered = client.post(f"/v1/captures/{capture_id}/files", json={"files": [item]})
+    assert registered.status_code == 200, registered.text
+    upload = registered.json()["files"][0]["upload"]
+    put = TestClient(app).put(upload["url"], content=blob, headers=upload.get("headers") or {})
+    assert put.status_code == 200, put.text
+    committed = client.post(
+        f"/v1/captures/{capture_id}/files:commit", json={"files": [{"path": item["path"], "sha256": item["sha256"]}]}
+    )
+    assert committed.status_code == 200, committed.text
+    return blob
+
+
+def _confirm(client: TestClient, capture_id: str, field: str, kind: str, value: str, image_id: str, at: str):
+    return client.post(
+        f"/v1/captures/{capture_id}/confirmations",
+        json={"fieldId": field, "kind": kind, "value": value, "imageId": image_id, "clientAt": at},
+    )
+
+
+def test_confirmation_before_reads_reaches_the_composed_result(journey) -> None:
+    """A confirmation accepted before reads exist is persisted, applied when the
+    reads stage creates its record, and served in the composed result — the
+    client never re-sends an already-accepted answer."""
+    root, packet, client, app = journey
+    deps = app.state.deps
+    capture_id, raw = _open_front_door(root, packet, client, app, "join-confirm-early")
+
+    # The capture is still open (uploading) when the device confirms the meter.
+    _register_extra_still(root, client, app, capture_id, "early-meter", "early-1")
+    accepted = _confirm(client, capture_id, "meter_number", "corrected", "31415", "early-1", "2026-10-15T00:00:00Z")
+    assert accepted.status_code == 201, accepted.text
+    first_id = accepted.json()["confirmationId"]
+
+    # The answer persists per field before any run exists.
+    listed = client.get(f"/v1/captures/{capture_id}/confirmations").json()
+    fields = [row["fieldId"] for row in listed["confirmations"]]
+    assert fields == ["meter_number"]
+    assert listed["confirmations"][0]["value"] == "31415"
+
+    finalized = _finalize(client, capture_id, raw, "join-confirm-early")
+    drain_finalize(deps)
+    run = deps.state.get_run(finalized["runId"])
+    assert run.status == "done"
+
+    # The composed result carries the early answer.
+    served = client.get(f"/v1/captures/{capture_id}/result").json()
+    assert served["meter"]["value"] == "31415"
+    assert served["meter"]["status"] == "auto_filled"
+
+    # Replaying the same answer is idempotent — same confirmation, one event, no
+    # new run, no recomposition.
+    replayed = _confirm(client, capture_id, "meter_number", "corrected", "31415", "early-1", "2026-10-15T00:00:00Z")
+    assert replayed.status_code == 200, replayed.text
+    assert replayed.json()["confirmationId"] == first_id
+    assert len(deps.state.runs_for_capture(capture_id)) == 1
+
+    events = _flat(client, capture_id)
+    confirmations = [e for e in events if e["type"] == "confirmation"]
+    assert [e["data"]["confirmationId"] for e in confirmations] == [first_id]
+    seqs = [e["seq"] for e in events]
+    assert seqs == sorted(set(seqs)) and seqs == list(range(1, len(seqs) + 1))
+
+
+def test_correction_after_the_result_recomposes_the_served_payload(journey) -> None:
+    """A late correction publishes the acceptance event and the recomposed result:
+    the run's criteria and result stages re-execute through the normal lifecycle
+    (one run, the same run id), the served meter carries the corrected value, and
+    replaying the correction neither runs anything new nor changes the payload."""
+    root, packet, client, app = journey
+    deps = app.state.deps
+    capture_id, raw = _open_front_door(root, packet, client, app, "join-confirm-late")
+    accepted = _finalize(client, capture_id, raw, "join-confirm-late")
+    run_id = accepted["runId"]
+    drain_finalize(deps)
+    assert deps.state.get_run(run_id).status == "done"
+
+    baseline = client.get(f"/v1/captures/{capture_id}/result").json()
+    assert baseline["meter"]["value"] != "777"
+    base_verdicts = len([e for e in _flat(client, capture_id) if e["type"] == "verdict_ready"])
+
+    image_id = packet["stills"][0]["id"]
+    corrected = _confirm(client, capture_id, "meter_number", "corrected", "777", image_id, "2026-10-15T00:01:00Z")
+    assert corrected.status_code == 201, corrected.text
+
+    # One run, re-driven in place: the recomposed result serves the correction.
+    runs = deps.state.runs_for_capture(capture_id)
+    assert len(runs) == 1 and runs[0].run_id == run_id and runs[0].status == "done"
+    served = client.get(f"/v1/captures/{capture_id}/result").json()
+    assert served["meter"]["value"] == "777"
+    assert served["meter"]["status"] == "auto_filled"
+
+    events = _flat(client, capture_id)
+    confirmations = [e for e in events if e["type"] == "confirmation"]
+    assert [e["data"]["confirmationId"] for e in confirmations] == [corrected.json()["confirmationId"]]
+    # The recomposition is visible: the run's result re-published its terminal.
+    assert len([e for e in events if e["type"] == "verdict_ready"]) == base_verdicts + 1
+    seqs = [e["seq"] for e in events]
+    assert seqs == sorted(set(seqs)) and seqs == list(range(1, len(seqs) + 1))
+
+    # Replaying the same correction changes nothing further.
+    replayed = _confirm(client, capture_id, "meter_number", "corrected", "777", image_id, "2026-10-15T00:01:00Z")
+    assert replayed.status_code == 200, replayed.text
+    assert client.get(f"/v1/captures/{capture_id}/result").json()["meter"]["value"] == "777"
+    events_after = _flat(client, capture_id)
+    assert len([e for e in events_after if e["type"] == "verdict_ready"]) == base_verdicts + 1
+    assert [e["data"]["confirmationId"] for e in events_after if e["type"] == "confirmation"] == [
+        corrected.json()["confirmationId"]
+    ]

From 926a1a825fe108d19a087dcdfc08a6036f3918f8 Mon Sep 17 00:00:00 2001
From: Obvious <obvious@obvious.ai>
Date: Fri, 16 Oct 2026 06:09:01 +0000
Subject: [PATCH 07/20] test(backend): pin finalize failure-publication
 ordering, not the publication count
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Merged burst7 retries storage-offline background finalize failures
(retry_finalize on 503-class), so the failure publishes once per
exhausted attempt. The pinned invariant — every publication happens
while the worker still owns the slot — is unchanged.

Co-authored-by: Sam Gu <sgu07966@gmail.com>

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/api/tests/test_finalize_background.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/backend/server/api/tests/test_finalize_background.py b/backend/server/api/tests/test_finalize_background.py
index b9aea5fd6..86ec0fa64 100644
--- a/backend/server/api/tests/test_finalize_background.py
+++ b/backend/server/api/tests/test_finalize_background.py
@@ -118,8 +118,10 @@ def probing_failure_path(*args, **kwargs):
 
     # The failure published while this worker still held the slot: a retry that
     # starts after the slot frees sees the failure already published (or the
-    # run_started flag of a healed retry) — never both.
-    assert publication_slot_state == [True]
+    # run_started flag of a healed retry) — never both. Storage-offline failures
+    # are retryable, so the merged finalize republishes per exhausted attempt;
+    # the pinned invariant is that every publication happens under the slot.
+    assert publication_slot_state and all(publication_slot_state)
     assert deps.state.get_capture(capture_id).status == "uploading"
 
     # And the healed retry still lands one healthy run.

From 64a4803f327e2640572fdf899b39c33548406079 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Fri, 16 Oct 2026 07:35:04 +0000
Subject: [PATCH 08/20] feat(backend): one-command local capture API on
 loopback (make local-api)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

scripts/local_capture_api.py starts the real app under uvicorn, loopback
only, fresh tokens + HMAC secret per run, memory state and volume storage,
ingest hooks auto so finalize drives the orchestrator inline; it writes
runs/local-api/session.json (0600) with the base URL, tokens, pid, sha.
make local-api-smoke drives the mini-arkit packet over real TCP via httpx
against the script as a subprocess — no TestClient, no drain_finalize.

Co-authored-by: Obvious <agents@obvious.ai>
---
 backend/Makefile                        |  13 +
 backend/docs/local-capture-api.md       | 101 +++++++
 backend/scripts/local_capture_api.py    | 221 +++++++++++++++
 backend/tests/test_local_capture_api.py | 359 ++++++++++++++++++++++++
 4 files changed, 694 insertions(+)
 create mode 100644 backend/docs/local-capture-api.md
 create mode 100644 backend/scripts/local_capture_api.py
 create mode 100644 backend/tests/test_local_capture_api.py

diff --git a/backend/Makefile b/backend/Makefile
index 330a0e613..55995389d 100644
--- a/backend/Makefile
+++ b/backend/Makefile
@@ -86,6 +86,19 @@ e2e-dev:
 	PYTHONPATH=. uv run --frozen python scripts/e2e_dev.py --self-check
 	PYTHONPATH=. uv run --frozen python scripts/e2e_dev.py $(if $(PACKET),--packet $(PACKET),)
 
+# Burst11: the one-command local capture API. Serves loopback only (127.0.0.1);
+# the iOS simulator shares the Mac's loopback, a physical phone does not.
+# Writes backend/runs/local-api/session.json (mode 0600, gitignored) with the
+# base URL, app and reviewer tokens, pid and git sha. Stop with Ctrl-C.
+local-api:
+	uv run --frozen --extra api python scripts/local_capture_api.py --host 127.0.0.1 --port $(PORT)
+
+# Burst11: drives the committed mini-arkit packet against the local capture API
+# over a real TCP socket — the launcher script starts as a subprocess on an
+# ephemeral port, no TestClient.
+local-api-smoke:
+	uv run --frozen --extra api pytest tests/test_local_capture_api.py -q
+
 orchestrator-e2e:
 	STATE_BACKEND=memory STORAGE_BACKEND=local HSS_ORCH_STAGE_STUBS=1 VISION_EXTERNAL_CALLS=off SMP_ENVIRONMENT=dev \
 		uv run --frozen pytest server/orchestrator/tests -q
diff --git a/backend/docs/local-capture-api.md b/backend/docs/local-capture-api.md
new file mode 100644
index 000000000..24255aaeb
--- /dev/null
+++ b/backend/docs/local-capture-api.md
@@ -0,0 +1,101 @@
+# The local capture API: one command, loopback only
+
+`make local-api` gives a reviewer, the iOS simulator and `tools/hunter-local-ingest` a working
+capture API on `127.0.0.1` from a fresh checkout. It replaces the hand-assembled uvicorn command in
+`server/api/README.md`, which ran with `HSS_INGEST_HOOKS=null` — so finalize never reached the
+orchestrator and no run ever started.
+
+## Fresh checkout
+
+```bash
+git clone https://github.com/SamGu-NRX/BaseScanning.git && cd BaseScanning
+git checkout alpha
+cd backend
+uv sync --frozen --extra api
+make local-api            # PORT=8000 default; override with PORT=8123 make local-api
+```
+
+Wait for the banner:
+
+```
+local capture API ready: http://127.0.0.1:8000
+session file: .../backend/runs/local-api/session.json
+stand-in stages: validate, poses, objects, reads, scale, dense, coverage, scene, objects_3d, criteria, result
+real stage: placement
+```
+
+Stop with Ctrl-C. Every run generates fresh tokens; nothing persists across restarts except the
+uploaded bytes under `runs/local-api/volume/`.
+
+`make local-api-smoke` proves the same launcher end to end: it starts the script as a subprocess on
+an ephemeral port and drives the committed `data/fixtures/packets/mini-arkit` packet over real TCP
+with httpx — create, register, PUT to the signed URLs, commit, finalize, long-poll events to
+terminal `manual_review`, read the result and the reviewer page — plus the auth and error
+boundaries. No TestClient, no `drain_finalize`: the orchestrator is driven inline by `start_run`.
+
+## Environment
+
+| Variable | Value set by `make local-api` | Why |
+|---|---|---|
+| `SMP_ENVIRONMENT` | `dev` | dev posture; no cloud credentials needed |
+| `HSS_AUTH_MODE` | `static` | bearer tokens from `CAPTURE_API_TOKENS` (explicit, because dev otherwise defaults to `none`) |
+| `CAPTURE_API_TOKENS` | `device:<app-token>,reviewer:local-review:<reviewer-token>` | generated per run; tokens are ≥32 chars (`server/api/auth.py`) |
+| `UPLOAD_URL_HMAC_SECRET` | fresh hex per run | signs the volume upload tokens |
+| `STATE_BACKEND` | `memory` | no Modal, no database |
+| `STORAGE_BACKEND` | `volume` | signed PUT URLs a client can actually fetch: `{CAPTURE_API_PUBLIC_URL}/v1/uploads/{token}` (`storage_volume.py`), unlike `storage_local.py`'s `file://` URLs |
+| `VOLUME_ROOT` | `backend/runs/local-api/volume` | uploaded bytes live under gitignored `runs/` |
+| `CAPTURE_API_PUBLIC_URL` | `http://127.0.0.1:<port>` | derived from the bind address, so upload URLs are reachable on this machine |
+| `HSS_INGEST_HOOKS` | `auto` | finalize reaches the orchestrator (this is the point) |
+| `HSS_ORCH_STAGE_STUBS` | `1` | committed stage stubs instead of GPU/vision work |
+| `HSS_ORCH_PREWARM` | `0` | no prewarm work on capture create |
+| `VISION_EXTERNAL_CALLS` | `off` | no networked model calls |
+| `BASE_WEBHOOK_URL` / `WEBHOOK_HMAC_SECRET` | unset | webhooks off |
+
+Pass through without interpretation: `HSS_LOCAL_OUTCOME` and `HSS_LOCAL_STAGE_DELAY_S`. The stage
+stubs honor them when the burst11-bs-local-outcome-states packet lands; this launcher never reads
+or changes them, so `HSS_LOCAL_OUTCOME=pass make local-api` just works.
+
+## The session file
+
+`backend/runs/local-api/session.json`, mode `0600` (the directory `runs/` is gitignored):
+
+```json
+{
+  "baseUrl": "http://127.0.0.1:8000/v1",
+  "appToken": "<bearer for the app and harness>",
+  "reviewerToken": "<bearer for the review page>",
+  "pid": 12345,
+  "gitSha": "<git rev-parse HEAD at start>",
+  "stageStubs": true,
+  "startedAt": "<UTC ISO-8601>"
+}
+```
+
+The shape is pinned verbatim by `tests/test_local_capture_api.py` because the iOS run and later
+packets read it. Two choices to note: the tokens are written **inline** (`appToken`, not
+`appTokenFile`) because a single self-contained file is one less path for every consumer to resolve
+against an unknown working directory; and `gitSha` is the full head SHA so a captured session always
+identifies the code that served it. Tokens appear nowhere else — not in stdout, not in the uvicorn
+access log (which keeps upload URLs as `/v1/uploads/{token}` route shapes anyway).
+
+## What is a stand-in
+
+`HSS_ORCH_STAGE_STUBS=1` runs every one of the twelve orchestrator stages as its committed stub
+**except `placement`**, which is `stubs_exempt` (deterministic CPU work, no GPU/network/credentials)
+and solves for real. A terminal `manual_review` verdict therefore proves the whole HTTP + finalize +
+orchestrator path, not the quality of the vision stages.
+
+## The iOS simulator
+
+The simulator shares the Mac's loopback, so it talks to `http://127.0.0.1:8000/v1` directly — set
+the app's capture API base URL and paste the `appToken` from the session file. **A physical phone
+does not share the Mac's loopback** and is out of scope: the server refuses any non-loopback bind,
+by design.
+
+## tools/hunter-local-ingest
+
+Point it at the session: read `backend/runs/local-api/session.json`, use `baseUrl` as the API base,
+`appToken` as the bearer on every request, and register uploads from the packet directory exactly as
+the smoke test does. The review page needs the `reviewerToken` bearer:
+`GET {baseUrl}/captures/{captureId}/review` with `Authorization: Bearer <reviewerToken>` returns the
+rendered HTML.
diff --git a/backend/scripts/local_capture_api.py b/backend/scripts/local_capture_api.py
new file mode 100644
index 000000000..baa3e1e10
--- /dev/null
+++ b/backend/scripts/local_capture_api.py
@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""One-command local capture API for reviewers, the iOS simulator and harness scripts.
+
+`make local-api` (backend/) starts the real HTTP app `server.api.app:create_app`
+under uvicorn, bound to loopback only, with generated tokens and a fresh HMAC
+secret, and writes the session the iOS run and later packets read:
+
+    backend/runs/local-api/session.json   (mode 0600; runs/ is gitignored)
+
+The journey is the documented front door: create a capture, register files,
+PUT bytes to the signed upload URLs, commit, finalize `packet.json`, long-poll
+events, then read the result and the reviewer page — over a real TCP socket,
+unlike `scripts/capture_flow_e2e.py`, which drives TestClient in process.
+
+Loopback only: the server refuses any `--host` other than 127.0.0.1 or ::1, and
+`CAPTURE_API_PUBLIC_URL` (which signs the upload URLs) is derived from the same
+host, so it can never point a client at a routable address. The iOS simulator
+shares the Mac's loopback, so it reaches 127.0.0.1 directly; a physical phone
+does not and is out of scope.
+
+Stand-in stages: `HSS_ORCH_STAGE_STUBS=1` runs every orchestrator stage as its
+committed stub except `placement`, which is `stubs_exempt` and solves for real.
+Pass-through, without interpretation: `HSS_LOCAL_OUTCOME` and
+`HSS_LOCAL_STAGE_DELAY_S` are honored by the stage stubs when the
+burst11-bs-local-outcome-states packet lands; this script neither reads nor
+changes them.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import secrets
+import socket
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+from datetime import UTC, datetime
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+LOOPBACK_HOSTS = {"127.0.0.1", "::1"}
+
+# Twelve-stage graph (server/orchestrator/graph.py). With HSS_ORCH_STAGE_STUBS=1
+# every one of these is a committed stub; `placement` alone is stubs_exempt.
+STAND_IN_STAGES = (
+    "validate",
+    "poses",
+    "objects",
+    "reads",
+    "scale",
+    "dense",
+    "coverage",
+    "scene",
+    "objects_3d",
+    "criteria",
+    "result",
+)
+REAL_STAGES = ("placement",)
+
+SESSION_DEFAULT = ROOT / "runs" / "local-api"
+
+
+def _git_sha() -> str:
+    env = os.environ.get("GIT_SHA")
+    if env:
+        return env
+    try:
+        return subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            cwd=ROOT.parent,
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout.strip()
+    except Exception:
+        return "unknown"
+
+
+def _free_port() -> int:
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        return sock.getsockname()[1]
+
+
+def _public_url(host: str, port: int) -> str:
+    host_part = f"[{host}]" if ":" in host else host
+    return f"http://{host_part}:{port}"
+
+
+def _write_session(path: Path, session: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as handle:
+        json.dump(session, handle, indent=2)
+        handle.write("\n")
+    os.chmod(path, 0o600)
+
+
+def _wait_health(base: str, timeout_s: float) -> bool:
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        try:
+            with urllib.request.urlopen(f"{base}/v1/healthz", timeout=2) as response:
+                if response.status == 200:
+                    return True
+        except (urllib.error.URLError, TimeoutError, OSError):
+            time.sleep(0.25)
+    return False
+
+
+def _announce(base: str, session_path: Path, timeout_s: float) -> None:
+    """Print the banner once /v1/healthz answers. Runs on a side thread while
+    uvicorn serves on the main thread, so the tokens stay off the terminal."""
+
+    def _ready() -> None:
+        if _wait_health(base, timeout_s):
+            standins = ", ".join(STAND_IN_STAGES)
+            print(f"\nlocal capture API ready: {base}", flush=True)
+            print(f"session file: {session_path}", flush=True)
+            print(f"stand-in stages: {standins}", flush=True)
+            print(f"real stage: {', '.join(REAL_STAGES)}", flush=True)
+            print("the app and reviewer tokens are in the session file only, never on stdout", flush=True)
+        else:
+            print(f"\nlocal capture API failed its health check within {timeout_s:.0f}s; stopping", flush=True)
+            os._exit(1)
+
+    threading.Thread(target=_ready, daemon=True).start()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--host", default="127.0.0.1", help="bind address; loopback only (127.0.0.1 or ::1)")
+    parser.add_argument("--port", type=int, default=8000, help="port (0 picks a free one)")
+    parser.add_argument(
+        "--session-dir",
+        type=Path,
+        default=SESSION_DEFAULT,
+        help="directory for session.json and the volume root (default: backend/runs/local-api)",
+    )
+    parser.add_argument("--health-timeout", type=float, default=60.0, help="seconds to wait for /v1/healthz")
+    args = parser.parse_args(argv)
+
+    if args.host not in LOOPBACK_HOSTS:
+        print(
+            f"refusing to bind {args.host!r}: the local capture API serves loopback only "
+            f"(127.0.0.1 or ::1). A phone that is not the simulator cannot reach this server anyway.",
+            file=sys.stderr,
+        )
+        return 2
+
+    port = args.port if args.port > 0 else _free_port()
+    base = _public_url(args.host, port)
+
+    # Fresh per-run credentials: a device bearer for the app and harness, an
+    # explicit reviewer bearer for the review page (server/api/auth.py reads
+    # `reviewer:<label>:<token>`; tokens must be at least 32 chars).
+    app_token = secrets.token_urlsafe(32)
+    reviewer_token = secrets.token_urlsafe(32)
+    hmac_secret = secrets.token_hex(32)
+    git_sha = _git_sha()
+
+    session_dir = args.session_dir
+    volume_root = session_dir / "volume"
+    session_path = session_dir / "session.json"
+    session = {
+        "baseUrl": f"{base}/v1",
+        "appToken": app_token,
+        "reviewerToken": reviewer_token,
+        "pid": os.getpid(),
+        "gitSha": git_sha,
+        "stageStubs": True,
+        "startedAt": datetime.now(UTC).isoformat(),
+    }
+    _write_session(session_path, session)
+
+    os.environ.update(
+        {
+            "SMP_ENVIRONMENT": "dev",
+            "HSS_AUTH_MODE": "static",
+            "CAPTURE_API_TOKENS": f"device:{app_token},reviewer:local-review:{reviewer_token}",
+            "UPLOAD_URL_HMAC_SECRET": hmac_secret,
+            "STATE_BACKEND": "memory",
+            "STORAGE_BACKEND": "volume",
+            "VOLUME_ROOT": str(volume_root),
+            "CAPTURE_API_PUBLIC_URL": base,
+            "HSS_INGEST_HOOKS": "auto",
+            "HSS_ORCH_STAGE_STUBS": "1",
+            "HSS_ORCH_PREWARM": "0",
+            "VISION_EXTERNAL_CALLS": "off",
+            "GIT_SHA": git_sha,
+        }
+    )
+    # Webhooks stay off: no outbound target, no signing key.
+    os.environ.pop("BASE_WEBHOOK_URL", None)
+    os.environ.pop("WEBHOOK_HMAC_SECRET", None)
+    # HSS_LOCAL_OUTCOME and HSS_LOCAL_STAGE_DELAY_S pass through untouched.
+
+    import uvicorn
+
+    config = uvicorn.Config(
+        "server.api.app:create_app",
+        factory=True,
+        host=args.host,
+        port=port,
+        log_level="info",
+    )
+    _announce(base, session_path, args.health_timeout)
+    uvicorn.Server(config).run()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/backend/tests/test_local_capture_api.py b/backend/tests/test_local_capture_api.py
new file mode 100644
index 000000000..cd82c837e
--- /dev/null
+++ b/backend/tests/test_local_capture_api.py
@@ -0,0 +1,359 @@
+"""The local capture API launcher (`scripts/local_capture_api.py`) over a real socket.
+
+`make local-api` must give a reviewer, the iOS simulator and
+`tools/hunter-local-ingest` a working capture API on 127.0.0.1 from one command.
+Every capture-to-result proof before this packet ran in process —
+`scripts/capture_flow_e2e.py` drives `fastapi.testclient.TestClient` and calls
+`drain_finalize` by hand — so these tests start the launcher as a subprocess on
+an ephemeral loopback port and speak HTTP with `httpx`. No TestClient, no
+in-process ASGI transport, and no `drain_finalize`: the run reaches a terminal
+status because `start_run` drives the orchestrator inline.
+
+The journey is the committed `data/fixtures/packets/mini-arkit` packet through
+the documented front door: create, register, PUT to the signed upload URLs,
+commit, finalize, long-poll events to a terminal status, read the result and the
+reviewer page. The negative cases pin the auth and error boundaries a real
+client hits: 401 without or with a wrong bearer, a 4xx on a malformed finalize,
+`404 result_not_ready` on the reviewer page before any run, and 403 for the app
+token on `/review`.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import socket
+import stat
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import httpx
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+SCRIPT = ROOT / "scripts" / "local_capture_api.py"
+PACKET = ROOT / "data" / "fixtures" / "packets" / "mini-arkit"
+
+TERMINAL_CAPTURE_STATUSES = {"manual_review", "complete", "failed", "needs_views", "expired"}
+SESSION_KEYS = {"baseUrl", "appToken", "reviewerToken", "pid", "gitSha", "stageStubs", "startedAt"}
+
+
+def _content_type(role: str) -> str:
+    if role == "stream":
+        return "application/gzip"
+    if role in {"features", "depth", "confidence", "mesh"}:
+        return "application/octet-stream"
+    return "image/jpeg"
+
+
+def _sealed_files(root: Path, packet: dict) -> list[dict]:
+    """Register bodies with the hashes the app computes from the sealed files."""
+    files = []
+    for entry in packet["files"]:
+        data = (root / entry["path"]).read_bytes()
+        role = entry.get("role", "still")
+        files.append(
+            {
+                "path": entry["path"],
+                "bytes": len(data),
+                "sha256": hashlib.sha256(data).hexdigest(),
+                "md5": base64.b64encode(hashlib.md5(data).digest()).decode(),
+                "role": role,
+                "contentType": _content_type(role),
+            }
+        )
+    return files
+
+
+def _free_port() -> int:
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        return sock.getsockname()[1]
+
+
+class LocalServer:
+    """The launcher as a subprocess, plus the session it promised on disk."""
+
+    def __init__(self, session_dir: Path, port: int, proc: subprocess.Popen, log_path: Path):
+        self.session_dir = session_dir
+        self.port = port
+        self.proc = proc
+        self.log_path = log_path
+        self.session = json.loads((session_dir / "session.json").read_text())
+
+    @property
+    def base(self) -> str:
+        return f"http://127.0.0.1:{self.port}"
+
+    def client(self, token: str | None) -> httpx.Client:
+        headers = {"Authorization": f"Bearer {token}"} if token else {}
+        return httpx.Client(base_url=f"{self.base}/v1", headers=headers, timeout=30)
+
+    def log(self) -> str:
+        return self.log_path.read_text()
+
+
+def _start_server(session_dir: Path, log_path: Path, extra_args: list[str] | None = None) -> subprocess.Popen:
+    port = _free_port()
+    log = log_path.open("w")
+    proc = subprocess.Popen(
+        [
+            sys.executable,
+            str(SCRIPT),
+            "--host",
+            "127.0.0.1",
+            "--port",
+            str(port),
+            "--session-dir",
+            str(session_dir),
+            "--health-timeout",
+            "90",
+            *(extra_args or []),
+        ],
+        cwd=ROOT,
+        stdout=log,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    log.close()
+    # The launcher writes session.json before binding, so wait for healthz.
+    deadline = time.monotonic() + 90
+    while time.monotonic() < deadline:
+        if proc.poll() is not None:
+            pytest.fail(f"local capture API exited early with {proc.returncode}:\n{log_path.read_text()}")
+        try:
+            with httpx.Client(timeout=2) as probe:
+                if probe.get(f"http://127.0.0.1:{port}/v1/healthz").status_code == 200:
+                    return proc
+        except httpx.HTTPError:
+            time.sleep(0.25)
+    proc.terminate()
+    pytest.fail(f"local capture API never got healthy:\n{log_path.read_text()}")
+
+
+@pytest.fixture(scope="module")
+def server(tmp_path_factory) -> LocalServer:
+    session_dir = tmp_path_factory.mktemp("local-api")
+    log_path = session_dir / "server.log"
+    proc = _start_server(session_dir, log_path)
+    try:
+        yield LocalServer(session_dir, _port_from_session(session_dir), proc, log_path)
+    finally:
+        proc.terminate()
+        try:
+            proc.wait(timeout=15)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+
+
+def _port_from_session(session_dir: Path) -> int:
+    session = json.loads((session_dir / "session.json").read_text())
+    return int(session["baseUrl"].split(":")[-1].split("/")[0])
+
+
+def _copy_packet(workdir: Path) -> tuple[Path, dict]:
+    root = workdir / "packet"
+    subprocess.run(["cp", "-R", str(PACKET), str(root)], check=True)
+    return root, json.loads((root / "packet.json").read_text())
+
+
+def _create_capture(client: httpx.Client, packet: dict, idempotency: str) -> dict:
+    session = packet["session"]
+    response = client.post(
+        "/captures",
+        json={
+            "packetId": packet["packetId"],
+            "formatVersion": packet["formatVersion"],
+            "tier": session["tier"],
+            "flow": "guided",
+            "device": {
+                "model": session["deviceModel"],
+                "systemVersion": session["systemVersion"],
+                "appVersion": session["appVersion"],
+            },
+        },
+        headers={"Idempotency-Key": idempotency},
+    )
+    assert response.status_code == 201, response.text
+    assert response.json()["status"] == "uploading"
+    return response.json()
+
+
+def _drive_to_terminal(client: httpx.Client, workdir: Path) -> tuple[dict, str]:
+    """The full capture journey over TCP. Returns (capture body, run id)."""
+    root, packet = _copy_packet(workdir)
+    created = _create_capture(client, packet, packet["packetId"])
+    capture_id = created["captureId"]
+
+    # Before finalize the reviewer page is not there yet.
+    not_ready = client.get(f"/captures/{capture_id}/review")
+    assert not_ready.status_code == 404, not_ready.text
+    assert not_ready.json()["errors"][0]["code"] == "result_not_ready"
+
+    files = _sealed_files(root, packet)
+    registered = client.post(f"/captures/{capture_id}/files", json={"files": files})
+    assert registered.status_code == 200, registered.text
+    assert len(registered.json()["files"]) == len(files)
+
+    with httpx.Client(timeout=60) as uploads:
+        for body, target in zip(files, registered.json()["files"], strict=True):
+            put = uploads.put(
+                target["upload"]["url"],
+                content=(root / body["path"]).read_bytes(),
+                headers=target["upload"].get("headers") or {},
+            )
+            assert put.status_code == 200, f"{put.status_code} for {body['path']}: {put.text}"
+
+    commit = client.post(
+        f"/captures/{capture_id}/files:commit",
+        json={"files": [{"path": item["path"], "sha256": item["sha256"]} for item in files]},
+    )
+    assert commit.status_code == 200, commit.text
+    assert not commit.json().get("notFound"), commit.text
+    assert not commit.json().get("mismatch"), commit.text
+
+    raw = (root / "packet.json").read_bytes()
+    finalized = client.post(
+        f"/captures/{capture_id}/finalize",
+        content=raw,
+        headers={
+            "Idempotency-Key": packet["packetId"],
+            "Content-Type": "application/json",
+            "X-Packet-Sha256": hashlib.sha256(raw).hexdigest(),
+        },
+    )
+    assert finalized.status_code == 202, finalized.text
+    run_id = finalized.json()["runId"]
+    assert run_id, finalized.text
+
+    # Long-poll events to a terminal status: the orchestrator drives inline, so
+    # a real server must get there with nobody calling drain_finalize.
+    after = 0
+    deadline = time.monotonic() + 180
+    status = None
+    events = []
+    while time.monotonic() < deadline:
+        poll = client.get(f"/captures/{capture_id}/events", params={"after": after, "wait": 5})
+        assert poll.status_code == 200, poll.text
+        body = poll.json()
+        status = body["status"]
+        events.extend(body["events"])
+        after = body["next"]
+        if status in TERMINAL_CAPTURE_STATUSES:
+            break
+    assert status == "manual_review", f"expected a terminal manual_review, got {status}"
+    types = [event["type"] for event in events]
+    assert "run_started" in types, types
+    return created, run_id
+
+
+def test_local_capture_api_journey(server: LocalServer, tmp_path: Path) -> None:
+    session = server.session
+
+    # The session contract the iOS run and later packets read — pinned verbatim.
+    assert set(session) == SESSION_KEYS, session
+    assert session["baseUrl"] == server.base + "/v1"
+    assert session["stageStubs"] is True
+    assert session["pid"] == server.proc.pid
+    assert isinstance(session["gitSha"], str) and len(session["gitSha"]) >= 7
+    mode = stat.S_IMODE((server.session_dir / "session.json").stat().st_mode)
+    assert mode == 0o600, oct(mode)
+
+    app_token, reviewer_token = session["appToken"], session["reviewerToken"]
+    assert app_token != reviewer_token and len(app_token) >= 32 and len(reviewer_token) >= 32
+
+    with server.client(app_token) as client:
+        capture, run_id = _drive_to_terminal(client, tmp_path)
+        capture_id = capture["captureId"]
+
+        result = client.get(f"/captures/{capture_id}/result")
+        assert result.status_code == 200, result.text
+        payload = result.json()
+        assert payload["runId"] == run_id
+        assert payload["outcome"] is not None, payload
+
+        # The app token is not a reviewer.
+        review = client.get(f"/captures/{capture_id}/review")
+        assert review.status_code == 403, review.text
+        assert review.json()["errors"][0]["code"] == "forbidden"
+
+    with server.client(reviewer_token) as reviewer:
+        page = reviewer.get(f"/captures/{capture_id}/review")
+        assert page.status_code == 200, page.text
+        assert "text/html" in page.headers["content-type"]
+        assert len(page.content) > 0
+
+
+def test_result_before_finalize_is_the_not_ready_envelope(server: LocalServer, tmp_path: Path) -> None:
+    """GET result before any run serves the 200 not-ready envelope, the shape
+    `server/api/tests/test_result_boundary.py` pins; the 404 result_not_ready
+    code is the reviewer page's answer before any run."""
+    _, packet = _copy_packet(tmp_path)
+    with server.client(server.session["appToken"]) as client:
+        capture_id = _create_capture(client, packet, f"{packet['packetId']}-resnotready")["captureId"]
+        result = client.get(f"/captures/{capture_id}/result")
+        assert result.status_code == 200, result.text
+        body = result.json()
+        assert body["outcome"] is None and body["viewsNeeded"] == []
+        review = client.get(f"/captures/{capture_id}/review")
+        assert review.status_code == 404, review.text
+        assert review.json()["errors"][0]["code"] == "result_not_ready"
+
+
+def test_malformed_finalize_is_refused_4xx(server: LocalServer, tmp_path: Path) -> None:
+    _, packet = _copy_packet(tmp_path)
+    with server.client(server.session["appToken"]) as client:
+        capture_id = _create_capture(client, packet, f"{packet['packetId']}-malformed")["captureId"]
+        raw = b"{not json at all"
+        response = client.post(
+            f"/captures/{capture_id}/finalize",
+            content=raw,
+            headers={
+                "Idempotency-Key": packet["packetId"],
+                "Content-Type": "application/json",
+                "X-Packet-Sha256": hashlib.sha256(raw).hexdigest(),
+            },
+        )
+        assert 400 <= response.status_code < 500, response.text
+        errors = response.json()["errors"]
+        assert errors and all({"code", "pointer", "message"} <= set(item) for item in errors)
+
+
+def test_missing_and_wrong_bearer_get_401(server: LocalServer) -> None:
+    with httpx.Client(base_url=f"{server.base}/v1", timeout=30) as anon:
+        missing = anon.get("/captures/whatever/events")
+        assert missing.status_code == 401, missing.text
+        errors = missing.json()["errors"]
+        assert errors and all({"code", "pointer", "message"} <= set(item) for item in errors)
+        wrong = anon.get("/captures/whatever/events", headers={"Authorization": "Bearer " + "w" * 40})
+        assert wrong.status_code == 401, wrong.text
+        assert wrong.json()["errors"][0]["code"] == "invalid_token"
+
+
+def test_tokens_never_reach_the_log(server: LocalServer) -> None:
+    log = server.log()
+    assert server.session["appToken"] not in log
+    assert server.session["reviewerToken"] not in log
+    # The baseUrl carries host and port only; the session file is the token carrier.
+    assert server.session["appToken"] not in server.base
+    assert "appToken" in (server.session_dir / "session.json").read_text()
+
+
+def test_refuses_non_loopback_host(tmp_path: Path) -> None:
+    log_path = tmp_path / "refused.log"
+    with log_path.open("w") as log:
+        proc = subprocess.run(
+            [sys.executable, str(SCRIPT), "--host", "0.0.0.0", "--port", str(_free_port()),
+             "--session-dir", str(tmp_path)],
+            cwd=ROOT,
+            stdout=log,
+            stderr=subprocess.STDOUT,
+            text=True,
+            timeout=30,
+        )
+    assert proc.returncode != 0
+    assert "loopback" in log_path.read_text()
+    assert not (tmp_path / "session.json").exists()

From 993c362751879bd03f3a8b90dd74c04b0836b78b Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Fri, 16 Oct 2026 07:40:03 +0000
Subject: [PATCH 09/20] test: pin the local capture API journey over a real
 socket

Fixes from the first runs: create pins Idempotency-Key to the packet id so
each journey retags its packet copy; /review gates the reviewer before the
not-ready check, so 404 result_not_ready needs the reviewer bearer while an
app bearer gets 403; the event log carries stage events for the run, and a
wrong bearer is unauthorized. Smoke suite passes twice in a row; ruff clean.

Co-authored-by: Obvious <agents@obvious.ai>
---
 backend/tests/test_local_capture_api.py | 58 ++++++++++++++++---------
 1 file changed, 37 insertions(+), 21 deletions(-)

diff --git a/backend/tests/test_local_capture_api.py b/backend/tests/test_local_capture_api.py
index cd82c837e..e79e5e7f1 100644
--- a/backend/tests/test_local_capture_api.py
+++ b/backend/tests/test_local_capture_api.py
@@ -154,10 +154,19 @@ def _port_from_session(session_dir: Path) -> int:
     return int(session["baseUrl"].split(":")[-1].split("/")[0])
 
 
-def _copy_packet(workdir: Path) -> tuple[Path, dict]:
+def _copy_packet(workdir: Path, packet_id: str) -> tuple[Path, dict]:
+    """A private copy of the committed packet, retagged with a unique packet id.
+
+    The create route pins Idempotency-Key to the packet id, so two journeys on
+    one server must not share one; finalize requires the packet bytes to carry
+    the same id, so the copy is rewritten before any finalize.
+    """
     root = workdir / "packet"
     subprocess.run(["cp", "-R", str(PACKET), str(root)], check=True)
-    return root, json.loads((root / "packet.json").read_text())
+    packet = json.loads((root / "packet.json").read_text())
+    packet["packetId"] = packet_id
+    (root / "packet.json").write_text(json.dumps(packet, indent=2) + "\n")
+    return root, packet
 
 
 def _create_capture(client: httpx.Client, packet: dict, idempotency: str) -> dict:
@@ -182,17 +191,12 @@ def _create_capture(client: httpx.Client, packet: dict, idempotency: str) -> dic
     return response.json()
 
 
-def _drive_to_terminal(client: httpx.Client, workdir: Path) -> tuple[dict, str]:
+def _drive_to_terminal(client: httpx.Client, workdir: Path, packet_id: str) -> tuple[dict, str]:
     """The full capture journey over TCP. Returns (capture body, run id)."""
-    root, packet = _copy_packet(workdir)
+    root, packet = _copy_packet(workdir, packet_id)
     created = _create_capture(client, packet, packet["packetId"])
     capture_id = created["captureId"]
 
-    # Before finalize the reviewer page is not there yet.
-    not_ready = client.get(f"/captures/{capture_id}/review")
-    assert not_ready.status_code == 404, not_ready.text
-    assert not_ready.json()["errors"][0]["code"] == "result_not_ready"
-
     files = _sealed_files(root, packet)
     registered = client.post(f"/captures/{capture_id}/files", json={"files": files})
     assert registered.status_code == 200, registered.text
@@ -245,8 +249,10 @@ def _drive_to_terminal(client: httpx.Client, workdir: Path) -> tuple[dict, str]:
         if status in TERMINAL_CAPTURE_STATUSES:
             break
     assert status == "manual_review", f"expected a terminal manual_review, got {status}"
-    types = [event["type"] for event in events]
-    assert "run_started" in types, types
+    # The run's stage events reach the capture event log the device long-polls.
+    assert any((event.get("data") or {}).get("runId") == run_id for event in events), [
+        event.get("type") for event in events
+    ]
     return created, run_id
 
 
@@ -266,7 +272,7 @@ def test_local_capture_api_journey(server: LocalServer, tmp_path: Path) -> None:
     assert app_token != reviewer_token and len(app_token) >= 32 and len(reviewer_token) >= 32
 
     with server.client(app_token) as client:
-        capture, run_id = _drive_to_terminal(client, tmp_path)
+        capture, run_id = _drive_to_terminal(client, tmp_path, "mini-arkit-journey")
         capture_id = capture["captureId"]
 
         result = client.get(f"/captures/{capture_id}/result")
@@ -290,23 +296,25 @@ def test_local_capture_api_journey(server: LocalServer, tmp_path: Path) -> None:
 def test_result_before_finalize_is_the_not_ready_envelope(server: LocalServer, tmp_path: Path) -> None:
     """GET result before any run serves the 200 not-ready envelope, the shape
     `server/api/tests/test_result_boundary.py` pins; the 404 result_not_ready
-    code is the reviewer page's answer before any run."""
-    _, packet = _copy_packet(tmp_path)
+    code is the reviewer page's answer before any run (reviewer bearer — the
+    reviewer gate runs before the not-ready check, so an app bearer gets 403)."""
+    root, packet = _copy_packet(tmp_path, "mini-arkit-resnotready")
     with server.client(server.session["appToken"]) as client:
-        capture_id = _create_capture(client, packet, f"{packet['packetId']}-resnotready")["captureId"]
+        capture_id = _create_capture(client, packet, packet["packetId"])["captureId"]
         result = client.get(f"/captures/{capture_id}/result")
         assert result.status_code == 200, result.text
         body = result.json()
         assert body["outcome"] is None and body["viewsNeeded"] == []
-        review = client.get(f"/captures/{capture_id}/review")
+    with server.client(server.session["reviewerToken"]) as reviewer:
+        review = reviewer.get(f"/captures/{capture_id}/review")
         assert review.status_code == 404, review.text
         assert review.json()["errors"][0]["code"] == "result_not_ready"
 
 
 def test_malformed_finalize_is_refused_4xx(server: LocalServer, tmp_path: Path) -> None:
-    _, packet = _copy_packet(tmp_path)
+    root, packet = _copy_packet(tmp_path, "mini-arkit-malformed")
     with server.client(server.session["appToken"]) as client:
-        capture_id = _create_capture(client, packet, f"{packet['packetId']}-malformed")["captureId"]
+        capture_id = _create_capture(client, packet, packet["packetId"])["captureId"]
         raw = b"{not json at all"
         response = client.post(
             f"/captures/{capture_id}/finalize",
@@ -330,7 +338,7 @@ def test_missing_and_wrong_bearer_get_401(server: LocalServer) -> None:
         assert errors and all({"code", "pointer", "message"} <= set(item) for item in errors)
         wrong = anon.get("/captures/whatever/events", headers={"Authorization": "Bearer " + "w" * 40})
         assert wrong.status_code == 401, wrong.text
-        assert wrong.json()["errors"][0]["code"] == "invalid_token"
+        assert wrong.json()["errors"][0]["code"] == "unauthorized"
 
 
 def test_tokens_never_reach_the_log(server: LocalServer) -> None:
@@ -346,8 +354,16 @@ def test_refuses_non_loopback_host(tmp_path: Path) -> None:
     log_path = tmp_path / "refused.log"
     with log_path.open("w") as log:
         proc = subprocess.run(
-            [sys.executable, str(SCRIPT), "--host", "0.0.0.0", "--port", str(_free_port()),
-             "--session-dir", str(tmp_path)],
+            [
+                sys.executable,
+                str(SCRIPT),
+                "--host",
+                "0.0.0.0",
+                "--port",
+                str(_free_port()),
+                "--session-dir",
+                str(tmp_path),
+            ],
             cwd=ROOT,
             stdout=log,
             stderr=subprocess.STDOUT,

From 9d91363db434b71e031e281fffcd12402072b0b7 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Fri, 16 Oct 2026 02:47:06 -0500
Subject: [PATCH 10/20] test(backend): failing regressions for the #278 review
 findings

- finalize: one storage exception publishes one failure while the worker
  still holds the slot (inflight, not merely present in _slots)
- result stage: a recomposition after an accepted confirmation publishes a
  new final event; a retry of either composition does not
- commit route: a busy index lease commits nothing, and files committed
  before the lease went busy are still announced
- journey: a correction after the run's original deadline still recomposes
- journey: the cursor poller drains to the producers' final cursor under a
  deadline instead of stopping when the producers stop

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/api/tests/test_commit_lease.py | 107 ++++++++++++++++++
 .../api/tests/test_finalize_background.py     |  15 +--
 backend/server/result/tests/test_compose.py   |  71 ++++++++++++
 backend/tests/test_runtime_join_journey.py    |  43 ++++++-
 4 files changed, 223 insertions(+), 13 deletions(-)
 create mode 100644 backend/server/api/tests/test_commit_lease.py

diff --git a/backend/server/api/tests/test_commit_lease.py b/backend/server/api/tests/test_commit_lease.py
new file mode 100644
index 000000000..33a82b74b
--- /dev/null
+++ b/backend/server/api/tests/test_commit_lease.py
@@ -0,0 +1,107 @@
+"""A busy file-index lease must not strand committed files unannounced.
+
+ModalDictState merges the per-capture file index under a strict lease; a lease
+that stays busy raises LeaseBusy and the commit route answers a retryable 503.
+Whatever the failed request already committed must still reach
+``files_committed`` and ``on_files_committed``, and whatever it did not commit
+must stay pending so the retry commits and announces it.
+"""
+
+from __future__ import annotations
+
+import time
+from urllib.parse import urlparse
+
+import pytest
+
+from server.api.tests.conftest import sha256_hex
+from server.api.tests.test_ingest import _create, _file
+from server.common.backends import state_modal_dict
+from server.common.backends.state_modal_dict import ModalDictState
+from server.common.lease import LeaseBusy
+
+_BLOBS = {"stills/s1.jpg": b"jpeg-one", "stills/s2.jpg": b"jpeg-two"}
+
+
+@pytest.fixture
+def shared(client, monkeypatch):
+    deps = client.app_state
+    deps.state = ModalDictState()
+    monkeypatch.setattr(state_modal_dict, "_INDEX_LEASE_WAIT_S", 0.05)
+    announced: list[list[str]] = []
+    monkeypatch.setattr(
+        deps.hooks, "on_files_committed", lambda _capture_id, files: announced.append([f.path for f in files])
+    )
+    return deps, announced
+
+
+def _upload_all(client, capture_id: str) -> None:
+    files = [_file(path, data, meta={"still": f"s{index + 1}"}) for index, (path, data) in enumerate(_BLOBS.items())]
+    registered = client.post(f"/v1/captures/{capture_id}/files", json={"files": files})
+    assert registered.status_code == 200, registered.text
+    for item, data in zip(registered.json()["files"], _BLOBS.values(), strict=True):
+        target = item["upload"]
+        put = client.put(urlparse(target["url"]).path, content=data, headers=target["headers"])
+        assert put.status_code == 200, put.text
+
+
+def _commit(client, capture_id: str):
+    return client.post(
+        f"/v1/captures/{capture_id}/files:commit",
+        json={"files": [{"path": path, "sha256": sha256_hex(data)} for path, data in _BLOBS.items()]},
+    )
+
+
+def _committed_events(client, capture_id: str) -> list[str]:
+    events = client.get(f"/v1/captures/{capture_id}/events").json()["events"]
+    return sorted(path for e in events if e["type"] == "files_committed" for path in e["data"]["paths"])
+
+
+def test_a_busy_lease_saves_nothing_and_the_retry_announces(client, shared):
+    deps, announced = shared
+    capture_id = _create(client, "packet-lease-busy")
+    _upload_all(client, capture_id)
+    # Another container holds a fresh lease on this capture's file index.
+    deps.state.put_if_absent(f"lease:files:{capture_id}", {"id": "other", "at": time.time()})
+
+    busy = _commit(client, capture_id)
+    assert busy.status_code == 503, busy.text
+    assert busy.json()["errors"][0]["code"] == "lease_busy"
+    for path in _BLOBS:
+        assert deps.state.get_file(capture_id, path).state == "pending", "nothing may commit without the lease"
+
+    deps.state.delete_kv(f"lease:files:{capture_id}")
+    retried = _commit(client, capture_id)
+    assert retried.status_code == 200, retried.text
+    assert _committed_events(client, capture_id) == sorted(_BLOBS)
+    assert sorted(path for batch in announced for path in batch) == sorted(_BLOBS)
+    assert sorted(rec.path for rec in deps.state.files(capture_id)) == sorted(_BLOBS)
+
+
+def test_files_committed_before_a_busy_lease_are_still_announced(client, shared, monkeypatch):
+    deps, announced = shared
+    capture_id = _create(client, "packet-lease-partial")
+    _upload_all(client, capture_id)
+
+    real_with_lease = state_modal_dict.with_lease
+    calls = {"n": 0}
+
+    def second_commit_busy(state, name, fn, **kwargs):
+        calls["n"] += 1
+        if calls["n"] == 2:
+            raise LeaseBusy(f"lease {name!r} stayed busy")
+        return real_with_lease(state, name, fn, **kwargs)
+
+    monkeypatch.setattr(state_modal_dict, "with_lease", second_commit_busy)
+    busy = _commit(client, capture_id)
+    assert busy.status_code == 503, busy.text
+    # The first file committed before the lease went busy: it is announced now,
+    # because the retry will read it as already committed.
+    assert _committed_events(client, capture_id) == ["stills/s1.jpg"]
+    assert deps.state.get_file(capture_id, "stills/s2.jpg").state == "pending"
+
+    monkeypatch.setattr(state_modal_dict, "with_lease", real_with_lease)
+    retried = _commit(client, capture_id)
+    assert retried.status_code == 200, retried.text
+    assert _committed_events(client, capture_id) == sorted(_BLOBS)
+    assert sorted(path for batch in announced for path in batch) == sorted(_BLOBS)
diff --git a/backend/server/api/tests/test_finalize_background.py b/backend/server/api/tests/test_finalize_background.py
index 86ec0fa64..6a04c1613 100644
--- a/backend/server/api/tests/test_finalize_background.py
+++ b/backend/server/api/tests/test_finalize_background.py
@@ -102,7 +102,7 @@ def offline(_key):
     original_failure_path = finalize_module._on_background_failure
 
     def probing_failure_path(*args, **kwargs):
-        publication_slot_state.append(capture_id in finalize_module._slots)
+        publication_slot_state.append(finalize_module._slots[capture_id].inflight)
         return original_failure_path(*args, **kwargs)
 
     monkeypatch.setattr(deps.storage, "get_bytes", offline)
@@ -116,12 +116,13 @@ def probing_failure_path(*args, **kwargs):
     finally:
         client.hold_finalize = False
 
-    # The failure published while this worker still held the slot: a retry that
-    # starts after the slot frees sees the failure already published (or the
-    # run_started flag of a healed retry) — never both. Storage-offline failures
-    # are retryable, so the merged finalize republishes per exhausted attempt;
-    # the pinned invariant is that every publication happens under the slot.
-    assert publication_slot_state and all(publication_slot_state)
+    # One storage exception publishes one failure, while this worker still holds
+    # the slot: a retry that starts after the slot frees sees the failure already
+    # published (or the run_started flag of a healed retry), never both.
+    assert publication_slot_state == [True]
+    assert finalize_module._slots[capture_id].inflight is False
+    events = client.get(f"/v1/captures/{capture_id}/events").json()["events"]
+    assert len([e for e in events if e["type"] == "failed" and e["data"].get("code") == "finalize_failed"]) == 1
     assert deps.state.get_capture(capture_id).status == "uploading"
 
     # And the healed retry still lands one healthy run.
diff --git a/backend/server/result/tests/test_compose.py b/backend/server/result/tests/test_compose.py
index 657874caa..5d6b7c1f4 100644
--- a/backend/server/result/tests/test_compose.py
+++ b/backend/server/result/tests/test_compose.py
@@ -616,3 +616,74 @@ def test_route_skips_the_duplicate_point_when_the_spot_starts_at_the_meter():
     assert pts is not None and len(pts) >= 2
     for index in range(len(pts) - 1):
         assert pts[index] != pts[index + 1]
+
+
+def test_a_correction_republishes_the_final_event_and_a_retry_does_not(tmp_path, monkeypatch):
+    """A late correction re-runs the result stage under the same run id. A retry of
+    the stage must not publish a second final event, but a recomposition after an
+    accepted confirmation must, or clients following the cursor never see the
+    corrected outcome."""
+    for name in ("WEBHOOK_HMAC_SECRET", "BASE_WEBHOOK_URL", "SHOW_REJECT_TO_HOMEOWNER", "HSS_RESULT_PROMPTS_PATH"):
+        monkeypatch.delenv(name, raising=False)
+    capture, run_rec, epochs = _capture_run()
+    state = MemoryState()
+    state.put_capture(capture)
+    state.put_run(run_rec)
+
+    class _Settings:
+        RULES_PROFILE_DEFAULT = "C"
+        SHOW_REJECT_TO_HOMEOWNER = False
+        HSS_RESULT_MAX_VIEWS = 6
+        HSS_RESULT_SIGNED_URL_TTL_S = 900
+        HSS_RESULT_PREVIEW_MAX_POINTS = 200_000
+        HSS_RESULT_METER_AUTOFILL = "barcode"
+        HSS_RESULT_REVIEW_THREEJS_URL = "https://unpkg.com/three@0.160.0/build/three.module.js"
+        HSS_RESULT_PROMPTS_PATH = str(DATA / "prompts.en-US.json")
+        BASE_WEBHOOK_URL = None
+
+    ctx = StageContext(
+        capture_id=capture.capture_id,
+        run_id=run_rec.run_id,
+        stage="result",
+        attempt=1,
+        branch="lidar",
+        flow="guided",
+        tier="arkit",
+        work_dir=tmp_path,
+        inputs={
+            "scene": str(DATA / "synthetic"),
+            "verdicts": str(DATA / "synthetic" / "verdicts"),
+            "reads": str(DATA / "reads.auto_fill.json"),
+            "out": str(tmp_path / "out"),
+            "epochs": ",".join(epochs),
+        },
+        deadline_at="2026-09-27T00:00:00Z",
+        heartbeat=lambda _step: None,
+        vlm_budget_usd=0,
+        storage=None,
+        state=state,
+        settings=_Settings(),
+    )
+
+    def finals() -> list[int]:
+        return [
+            ev.seq
+            for ev in state.events_after(capture.capture_id, 0)
+            if ev.type in {"verdict_ready", "retake_request"} and ev.run_id == run_rec.run_id
+        ]
+
+    run(ctx)
+    run(ctx)  # a retry of the same composition
+    first = finals()
+    assert len(first) == 1
+
+    state.append_event(
+        capture.capture_id,
+        "confirmation",
+        {"confirmationId": "cfm_1", "fieldId": "meter_number", "imageId": "s1", "kind": "corrected", "by": "device"},
+    )
+    run(ctx)  # the recomposition the correction triggers
+    run(ctx)  # and a retry of that recomposition
+    second = finals()
+    assert len(second) == 2, "the correction must publish its own final event, once"
+    assert second[0] == first[0]
diff --git a/backend/tests/test_runtime_join_journey.py b/backend/tests/test_runtime_join_journey.py
index 9aaf82f5d..662083ca9 100644
--- a/backend/tests/test_runtime_join_journey.py
+++ b/backend/tests/test_runtime_join_journey.py
@@ -289,17 +289,21 @@ def produce(slot: int) -> None:
 
     poller_pages: list[list[dict]] = []
     poller_after: list[int] = []
-    poller_stop = threading.Event()
+    final_cursor = base_count + 60
 
     def poll() -> None:
+        # Poll until the cursor reaches the producers' last event, not until the
+        # producers stop: a poller that stops with them can exit before draining
+        # the tail, and the assertion below would blame the cursor for it.
         start.wait()
         after = 0
-        while not poller_stop.is_set():
+        give_up = time.monotonic() + 10.0
+        while after < final_cursor and time.monotonic() < give_up:
             page = client.get(f"/v1/captures/{capture_id}/events", params={"after": after}).json()
             poller_pages.append(page["events"])
             poller_after.append(after)
             if page["next"] == after:
-                poller_stop.wait(0.02)
+                time.sleep(0.02)
             else:
                 after = page["next"]
 
@@ -312,8 +316,7 @@ def poll() -> None:
         thread.start()
     for thread in threads[:2]:
         thread.join()
-    poller_stop.set()
-    threads[2].join(timeout=10)
+    threads[2].join(timeout=15)
     assert not threads[2].is_alive()
 
     # Each producer drew a distinct slice of the sequence — never the same seq.
@@ -323,7 +326,7 @@ def poll() -> None:
     seqs = [event["seq"] for page in poller_pages for event in page]
     assert seqs == sorted(seqs), "a page arrived behind the cursor"
     assert len(seqs) == len(set(seqs)), "the cursor delivered an event twice"
-    expected = list(range(1, base_count + 61))
+    expected = list(range(1, final_cursor + 1))
     assert seqs == expected, "the cursor skipped an event a producer appended"
 
     # The store itself holds the complete, contiguous sequence.
@@ -600,3 +603,31 @@ def test_correction_after_the_result_recomposes_the_served_payload(journey) -> N
     assert [e["data"]["confirmationId"] for e in events_after if e["type"] == "confirmation"] == [
         corrected.json()["confirmationId"]
     ]
+
+
+def test_a_correction_after_the_original_deadline_gets_its_own_budget(journey) -> None:
+    """The run's deadline measured its first pass. A correction accepted after that
+    deadline re-opens the run; without a fresh budget the next tick hard-stops it
+    and the capture falls to manual review with the old result still served."""
+    root, packet, client, app = journey
+    deps = app.state.deps
+    capture_id, raw = _open_front_door(root, packet, client, app, "join-confirm-expired")
+    run_id = _finalize(client, capture_id, raw, "join-confirm-expired")["runId"]
+    drain_finalize(deps)
+    run = deps.state.get_run(run_id)
+    assert run.status == "done"
+    failure_before = run.failure_code
+    # The original 20-minute deadline has passed by the time the correction lands.
+    run.deadline_at = "2000-01-01T00:00:00+00:00"
+    deps.state.put_run(run)
+    status_before = deps.state.get_capture(capture_id).status
+
+    image_id = packet["stills"][0]["id"]
+    corrected = _confirm(client, capture_id, "meter_number", "corrected", "4242", image_id, "2026-10-15T00:02:00Z")
+    assert corrected.status_code == 201, corrected.text
+
+    rerun = deps.state.get_run(run_id)
+    assert rerun.status == "done", (rerun.status, rerun.failure_code)
+    assert rerun.failure_code == failure_before
+    assert deps.state.get_capture(capture_id).status == status_before
+    assert client.get(f"/v1/captures/{capture_id}/result").json()["meter"]["value"] == "4242"

From 430369f8fadad010b4d5b13cb1105c552bbf09cf Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Fri, 16 Oct 2026 02:47:30 -0500
Subject: [PATCH 11/20] fix(backend): publish an escaped finalize failure once,
 under the slot

The merge kept both copies of _guard's failure path. The first holds the
slot and finish_sync across the run_started check and the write; the second
ran after _clear_slot without the lock, so one storage exception published
two failures and the unlocked copy could still overwrite a healed retry.
Drop the second copy.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/api/finalize.py | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/backend/server/api/finalize.py b/backend/server/api/finalize.py
index 54fb368f1..c0ea67811 100644
--- a/backend/server/api/finalize.py
+++ b/backend/server/api/finalize.py
@@ -519,18 +519,6 @@ def _guard(deps: Deps, capture_id: str, future: Future[None]) -> None:
                 )
                 _on_background_failure(deps, capture_id, failure)
         _clear_slot(capture_id)
-        # The 202 has already returned and the capture reads as processing, so a
-        # failure stored only on this Future would strand the client: no failure
-        # event, no retry, no run for the sweepers to recover. Route the exception
-        # through the normal failure path instead. Once the run has started, the
-        # handoff succeeded; later errors must not undo it.
-        if not extras(deps, capture_id).get("run_started"):
-            failure = (
-                exc
-                if isinstance(exc, ApiFailure)
-                else fail(503, "finalize_failed", "/", f"finalize background work failed ({type(exc).__name__})")
-            )
-            _on_background_failure(deps, capture_id, failure)
         future.set_exception(exc)
         return
     future.set_result(None)

From b6d1580774f6f6dcb1100acd54f52b45a9f0d648 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Fri, 16 Oct 2026 02:47:51 -0500
Subject: [PATCH 12/20] fix(backend): a late correction re-runs on a fresh
 deadline

Reopening a finished run for a correction kept the run's original
deadline_at. Once that had passed (20 minutes by default) the next tick
hard-stopped the run and the capture fell to manual review with the old
result. The correction now gets the HARD_STOP_MIN budget a new run gets,
counted from when it is accepted. Runs that are not corrected keep their
deadline.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/orchestrator/api.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/backend/server/orchestrator/api.py b/backend/server/orchestrator/api.py
index d54a16887..8f5990498 100644
--- a/backend/server/orchestrator/api.py
+++ b/backend/server/orchestrator/api.py
@@ -181,6 +181,10 @@ def _recompose_after_correction(capture_id: str, run: RunRecord) -> None:
             )
         )
     run.status = "running"
+    # The run's deadline measured its first pass, so a correction accepted after
+    # it would hard-stop on the next tick. The re-run gets the same HARD_STOP_MIN
+    # budget start_run gives a new run, counted from the correction.
+    run.deadline_at = deadline_from(services.clock, services.settings.HARD_STOP_MIN)
     services.state.put_run(run)  # type: ignore[attr-defined]
     raw = dict(get_json(services.state, f"run_control:{run.run_id}") or {})  # type: ignore[attr-defined]
     raw["merge_done"] = False

From 4bef9fd2f43649ba8aa358bb4c5033f2523881e2 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Fri, 16 Oct 2026 02:48:18 -0500
Subject: [PATCH 13/20] fix(backend): a corrected result publishes its new
 final event

A late correction recomposes the result under the same run id, and
emit_events skipped publishing whenever the run already had a final event,
so clients following the cursor never saw the corrected outcome. A final
event older than the capture's latest confirmation is now stale: the
recomposition publishes its own, while a retry of either composition still
returns the seqs already published. The check reads every event page, since
events_after returns at most one page.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/result/compose.py | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/backend/server/result/compose.py b/backend/server/result/compose.py
index 268830662..7b403263e 100644
--- a/backend/server/result/compose.py
+++ b/backend/server/result/compose.py
@@ -12,7 +12,7 @@
 import numpy as np
 from pydantic import ValidationError
 
-from server.contracts.jobs import CaptureRecord, RunRecord, StageContext, StageResult
+from server.contracts.jobs import CaptureRecord, EventRecord, RunRecord, StageContext, StageResult
 from server.contracts.result import (
     BoxArkitWorld,
     BoxSceneM,
@@ -254,9 +254,17 @@ def compose_result(
 
 
 def emit_events(result: ComposeResult, state) -> list[int]:
-    prior = state.events_after(result.capture_id, 0)
+    """Publish the run's final event once per composition.
+
+    A retry of the result stage finds its final event and returns those seqs. A
+    late correction re-runs the stage under the same run id, and its confirmation
+    event lands after the old final: finals older than the latest confirmation
+    are stale, so the recomposed result publishes its own.
+    """
+    prior = _all_events(state, result.capture_id)
     finals = {"verdict_ready", "retake_request"}
-    already = [ev for ev in prior if ev.run_id == result.run_id and ev.type in finals]
+    corrected = max((ev.seq for ev in prior if ev.type == "confirmation"), default=0)
+    already = [ev for ev in prior if ev.run_id == result.run_id and ev.type in finals and ev.seq > corrected]
     if already:
         return [ev.seq for ev in already]
     seqs = []
@@ -266,6 +274,16 @@ def emit_events(result: ComposeResult, state) -> list[int]:
     return seqs
 
 
+def _all_events(state, capture_id: str) -> list[EventRecord]:
+    """Every event on the capture; events_after returns one page at a time."""
+    events: list[EventRecord] = []
+    while True:
+        page = state.events_after(capture_id, events[-1].seq if events else 0)
+        if not page:
+            return events
+        events.extend(page)
+
+
 def _stage_input(ctx: StageContext, short: str, key: str) -> Path | None:
     """The short input key wins; orchestrated runs hydrate `work_dir/<key>` instead."""
 

From cb7f3947cbe7e7a642d7247c646953587d28ae00 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Fri, 16 Oct 2026 02:49:15 -0500
Subject: [PATCH 14/20] fix(backend): a busy index lease no longer strands
 committed files

upsert_file saved the file record as committed before taking the strict
index lease, so LeaseBusy left a committed record outside the index and the
commit route exited before files_committed and on_files_committed; the
retry read the file as committed and never announced it. The record is now
written inside the lease, so a busy lease saves nothing. The commit route
also announces whatever the request did commit before a later file failed
(busy lease or storage head error), since the retry skips those.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/api/routes/files.py            | 113 ++++++++++--------
 .../common/backends/state_modal_dict.py       |   5 +-
 2 files changed, 65 insertions(+), 53 deletions(-)

diff --git a/backend/server/api/routes/files.py b/backend/server/api/routes/files.py
index 10037feec..1dbb69a05 100644
--- a/backend/server/api/routes/files.py
+++ b/backend/server/api/routes/files.py
@@ -289,58 +289,48 @@ async def commit_files(capture_id: str, body: CommitRequest, request: Request):
             newly: list[FileRecord] = []
             extra = extras(deps, capture_id)
             size_only = set(extra.get("size_only_paths") or [])
-            for item in body.files:
-                rec = deps.state.get_file(capture_id, item.path)
-                if rec is None:
-                    not_found.append(item.path)
-                    continue
-                if rec.state == "committed":
-                    committed.append(item.path)
-                    continue
-                spec = (extra.get("digests") or {}).get(item.path)
-                if spec and (rec.sha256 != spec["sha256"] or rec.bytes != spec["bytes"]):
-                    mismatch.append(item.path)
-                    continue
-                try:
-                    meta = deps.storage.head(upload_key(capture_id, item.path))
-                except FileNotFoundError:
-                    not_found.append(item.path)
-                    continue
-                except Exception as exc:
-                    log_event("storage.error", op="head", capture_id=capture_id, level="error")
-                    raise fail(503, "storage_unavailable", "/", "storage head failed", **{"Retry-After": "5"}) from exc
-                md5_bad = item.path not in size_only and meta.md5_b64 not in (None, rec.md5)
-                if meta.bytes != rec.bytes or md5_bad:
-                    rec.state = "mismatch"
+            # A failure partway through the batch (a busy index lease, a storage
+            # head error) must still announce the files already committed: the
+            # retry reads them as committed and would never announce them.
+            try:
+                for item in body.files:
+                    rec = deps.state.get_file(capture_id, item.path)
+                    if rec is None:
+                        not_found.append(item.path)
+                        continue
+                    if rec.state == "committed":
+                        committed.append(item.path)
+                        continue
+                    spec = (extra.get("digests") or {}).get(item.path)
+                    if spec and (rec.sha256 != spec["sha256"] or rec.bytes != spec["bytes"]):
+                        mismatch.append(item.path)
+                        continue
+                    try:
+                        meta = deps.storage.head(upload_key(capture_id, item.path))
+                    except FileNotFoundError:
+                        not_found.append(item.path)
+                        continue
+                    except Exception as exc:
+                        log_event("storage.error", op="head", capture_id=capture_id, level="error")
+                        raise fail(
+                            503, "storage_unavailable", "/", "storage head failed", **{"Retry-After": "5"}
+                        ) from exc
+                    md5_bad = item.path not in size_only and meta.md5_b64 not in (None, rec.md5)
+                    if meta.bytes != rec.bytes or md5_bad:
+                        rec.state = "mismatch"
+                        deps.state.upsert_file(rec)
+                        mismatch.append(item.path)
+                        continue
+                    rec.state = "committed"
+                    rec.generation = meta.generation
+                    rec.key = upload_key(capture_id, item.path)
+                    rec.committed_at = isoformat(deps.now())
                     deps.state.upsert_file(rec)
-                    mismatch.append(item.path)
-                    continue
-                rec.state = "committed"
-                rec.generation = meta.generation
-                rec.key = upload_key(capture_id, item.path)
-                rec.committed_at = isoformat(deps.now())
-                deps.state.upsert_file(rec)
-                committed.append(item.path)
-                newly.append(rec)
-            if newly:
-                listed = (extras(deps, capture_id).get("accepted") or {}).get("listed")
-                payload = FilesCommittedData(
-                    paths=[rec.path for rec in newly], committed=len(newly), listed=listed
-                ).model_dump(mode="json")
-                emit(deps, capture_id, "files_committed", payload)
-                hooked = [
-                    CommittedFile(
-                        path=rec.path,
-                        role=rec.role,
-                        sha256=rec.sha256,
-                        bytes=rec.bytes,
-                        generation=rec.generation or "",
-                        key=rec.key or upload_key(capture_id, rec.path),
-                        meta=rec.meta,
-                    )
-                    for rec in newly
-                ]
-                safe_hook("on_files_committed", deps.hooks.on_files_committed, capture_id, hooked)
+                    committed.append(item.path)
+                    newly.append(rec)
+            finally:
+                if newly:
+                    _announce_committed(deps, capture_id, newly)
             maybe_finish_after_commit(deps, deps.state.get_capture(capture_id) or record)
             log_event(
                 "files.committed", n=len(newly), mismatch=len(mismatch), not_found=len(not_found), capture_id=capture_id
@@ -356,3 +346,24 @@ async def complete_multipart(capture_id: str, body: CompleteMultipartRequest, re
         async with deps.locks.acquire(capture_id):
             load_owned(deps, capture_id, principal, write=True)
             raise fail(501, "multipart_not_implemented", "/", "multipart upload is not implemented in this PR")
+
+
+def _announce_committed(deps, capture_id: str, newly: list[FileRecord]) -> None:
+    listed = (extras(deps, capture_id).get("accepted") or {}).get("listed")
+    payload = FilesCommittedData(paths=[rec.path for rec in newly], committed=len(newly), listed=listed).model_dump(
+        mode="json"
+    )
+    emit(deps, capture_id, "files_committed", payload)
+    hooked = [
+        CommittedFile(
+            path=rec.path,
+            role=rec.role,
+            sha256=rec.sha256,
+            bytes=rec.bytes,
+            generation=rec.generation or "",
+            key=rec.key or upload_key(capture_id, rec.path),
+            meta=rec.meta,
+        )
+        for rec in newly
+    ]
+    safe_hook("on_files_committed", deps.hooks.on_files_committed, capture_id, hooked)
diff --git a/backend/server/common/backends/state_modal_dict.py b/backend/server/common/backends/state_modal_dict.py
index ca3733b78..b6ad39ea4 100644
--- a/backend/server/common/backends/state_modal_dict.py
+++ b/backend/server/common/backends/state_modal_dict.py
@@ -340,9 +340,10 @@ def delete_capture(self, capture_id: str) -> None:
         self._kv[tomb] = {"capture_id": capture_id}
 
     def upsert_file(self, rec: FileRecord) -> None:
-        self._kv[f"file:{rec.capture_id}:{rec.path}"] = rec.model_dump(mode="json")
-
         def merge() -> None:
+            # The record is written inside the lease too: a busy lease then saves
+            # nothing, so the caller's retry still sees the file in its old state.
+            self._kv[f"file:{rec.capture_id}:{rec.path}"] = rec.model_dump(mode="json")
             paths = set(self._kv.get(f"files:{rec.capture_id}") or [])
             paths.add(rec.path)
             self._kv[f"files:{rec.capture_id}"] = sorted(paths)

From d0774fdbc151c31bfd9400191e8ea81846642170 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Fri, 16 Oct 2026 07:49:59 +0000
Subject: [PATCH 15/20] =?UTF-8?q?docs:=20local=20capture=20API=20evidence?=
 =?UTF-8?q?=20=E2=80=94=20recorded=20live=20journey,=20smoke=20run,=20page?=
 =?UTF-8?q?s?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Captured on a fresh alpha clone: make local-api recording (banner, clean
Ctrl-C), make local-api-smoke recording (6 passed over real TCP), Playwright
review/result pages, sanitized journey receipt reaching terminal manual_review
with the placement stage real and compose stubbed. Tokens redacted (scan-verified).

Co-authored-by: Obvious <agents@obvious.ai>
---
 .../docs/evidence/local-capture-api/README.md |  19 ++++++
 .../live-journey-receipt.json                 |  12 ++++
 .../local-capture-api/local-api-terminal.png  | Bin 0 -> 16462 bytes
 .../evidence/local-capture-api/local-api.cast |  62 ++++++++++++++++++
 .../local-capture-api/result-page.png         | Bin 0 -> 47931 bytes
 .../local-capture-api/review-page.png         | Bin 0 -> 6795 bytes
 .../local-capture-api/smoke-terminal.png      | Bin 0 -> 6300 bytes
 .../evidence/local-capture-api/smoke.cast     |  11 ++++
 8 files changed, 104 insertions(+)
 create mode 100644 backend/docs/evidence/local-capture-api/README.md
 create mode 100644 backend/docs/evidence/local-capture-api/live-journey-receipt.json
 create mode 100644 backend/docs/evidence/local-capture-api/local-api-terminal.png
 create mode 100644 backend/docs/evidence/local-capture-api/local-api.cast
 create mode 100644 backend/docs/evidence/local-capture-api/result-page.png
 create mode 100644 backend/docs/evidence/local-capture-api/review-page.png
 create mode 100644 backend/docs/evidence/local-capture-api/smoke-terminal.png
 create mode 100644 backend/docs/evidence/local-capture-api/smoke.cast

diff --git a/backend/docs/evidence/local-capture-api/README.md b/backend/docs/evidence/local-capture-api/README.md
new file mode 100644
index 000000000..2beca32fb
--- /dev/null
+++ b/backend/docs/evidence/local-capture-api/README.md
@@ -0,0 +1,19 @@
+# Local capture API — evidence
+
+Produced 2026-10-16 on a fresh clone of `alpha` at `4bcbedba`, branch
+`obv/burst11-bs-local-api-serve`, head `993c3627`. Everything here was
+captured against the real stack: the launcher script under uvicorn over a
+TCP socket, no TestClient, no drain_finalize.
+
+| File | What it shows |
+|---|---|
+| `local-api-terminal.png` | Frame from the `make local-api` recording: the launcher banner — base URL, session-file path, the stand-in stage list with `placement` real, and the tokens-never-on-stdout note. |
+| `local-api.cast` | Full asciinema recording of `make local-api` from a clean `runs/`: dependency-free startup, health wait, banner; stopped with Ctrl-C (Error 130 = SIGINT at the end of the recording is the operator stop). |
+| `smoke-terminal.png` / `smoke.cast` | `make local-api-smoke`: the committed packet journey over real HTTP — `6 passed in 6.49s`. |
+| `review-page.png` | Playwright screenshot of `GET /v1/captures/{id}/review` with the reviewer bearer from `session.json`, after the capture reached a terminal status. Renders the dev stub review page — locally the compose stage is a stand-in (`HSS_ORCH_STAGE_STUBS=1`), which is the documented dev configuration; the machine-readable outcome is the result envelope below. |
+| `result-page.png` | Playwright screenshot of `GET /v1/captures/{id}/result` with the app bearer: the device-facing envelope — `status: manual_review`, `outcome.kind: manual_review`, "Review required before a placement is shown.", `reviewUrl`, `runId`. |
+| `live-journey-receipt.json` | Sanitized receipt of the recorded live journey (create → signed uploads → commit → finalize 202 → inline orchestrator run → terminal `manual_review`). Tokens redacted; they are per-run local secrets. |
+
+Reproduction: `make local-api` in one terminal, `make local-api-smoke` in
+another (both from `backend/`); the driver for the screenshots reused the
+committed smoke-test helpers against the live port.
diff --git a/backend/docs/evidence/local-capture-api/live-journey-receipt.json b/backend/docs/evidence/local-capture-api/live-journey-receipt.json
new file mode 100644
index 000000000..a1f3950d2
--- /dev/null
+++ b/backend/docs/evidence/local-capture-api/live-journey-receipt.json
@@ -0,0 +1,12 @@
+{
+  "what": "live journey against make local-api (recorded to local-api.cast)",
+  "driver": "tests/test_local_capture_api.py helpers over real TCP via httpx; no TestClient",
+  "baseUrl": "http://127.0.0.1:8000/v1",
+  "captureId": "cap_01M51TS13336P96H5B6KFPH9WW",
+  "runId": "run_4c05e7d782dfc5f5",
+  "outcomeKind": "manual_review",
+  "outcomeMessage": "Review required before a placement is shown.",
+  "gitSha": "993c362751879bd03f3a8b90dd74c04b0836b78b",
+  "tokens": "redacted \u2014 per-run local secrets, never committed",
+  "recordedAt": "2026-10-16T07:49:27+00:00"
+}
diff --git a/backend/docs/evidence/local-capture-api/local-api-terminal.png b/backend/docs/evidence/local-capture-api/local-api-terminal.png
new file mode 100644
index 0000000000000000000000000000000000000000..83c562fd8eee4834a673167e24c388ab492f3197
GIT binary patch
literal 16462
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
KtX#zC!~X*Whj9-8

literal 0
HcmV?d00001

diff --git a/backend/docs/evidence/local-capture-api/local-api.cast b/backend/docs/evidence/local-capture-api/local-api.cast
new file mode 100644
index 000000000..a9ee56ffa
--- /dev/null
+++ b/backend/docs/evidence/local-capture-api/local-api.cast
@@ -0,0 +1,62 @@
+{"version": 2, "width": 80, "height": 24, "timestamp": 1792136634, "env": {"SHELL": "/bin/bash", "TERM": "tmux-256color"}}
+[0.006449, "o", "uv run --frozen --extra api python scripts/local_capture_api.py --host 127.0.0.1 --port 8000\r\n"]
+[0.887539, "o", "\u001b[32mINFO\u001b[0m:     Started server process [\u001b[36m10967\u001b[0m]\r\n\u001b[32mINFO\u001b[0m:     Waiting for application startup.\r\n"]
+[0.8877, "o", "\u001b[32mINFO\u001b[0m:     Application startup complete.\r\n"]
+[0.888282, "o", "\u001b[32mINFO\u001b[0m:     Uvicorn running on \u001b[1mhttp://127.0.0.1:8000\u001b[0m (Press CTRL+C to quit)\r\n"]
+[0.912628, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 12, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/healthz\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TNRREN9VSJHXAHXSPFFA7\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:43:55.162473Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[0.913278, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 1, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/healthz\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TNRRS8XTC116G2XTQ4AJB\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:43:55.163157Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[0.913603, "o", "\r\nlocal capture API ready: http://127.0.0.1:8000"]
+[0.913855, "o", "\r\nsession file: /home/user/work/burst11-bs-local-api-serve/backend/runs/local-api/session.json\r\nstand-in stages: validate, poses, objects, reads, scale, dense, coverage, scene, objects_3d, criteria, result\r\nreal stage: placement\r\nthe app and reviewer tokens are in the session file only, never on stdout\r\n"]
+[45.414439, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 1, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures\", \"http.status\": 422, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TQ47E7Y9F2YYXDZB62WGG\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:44:39.664289Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[51.70572, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures\", \"http.status\": 422, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TQAC2S59PNA7ZNEXACEN2\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:44:45.955541Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[71.614961, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TQXT5ASMDRT0AFR4RRSKC\", \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": null, \"error_code\": null, \"event\": \"capture.created\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures\", \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": \"mini-arkit-live\", \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TQXT5ASMDRT0AFR4RRSKB\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:05.864808Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[71.615046, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 3, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures\", \"http.status\": 201, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TQXT5ASMDRT0AFR4RRSKB\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:05.864996Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[71.619994, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 1, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures/cap_01M51TQXT5ASMDRT0AFR4RRSKC/files\", \"http.status\": 422, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TQXTBY677VZZM30TXK8FP\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:05.869911Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[93.32869, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TRK0SZ0EWBCP57GDWA77W\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:27.578519Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[93.332034, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures/cap_01M51TQXT5ASMDRT0AFR4RRSKC/files\", \"http.status\": 422, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TRK0XBCW3YN07Q6GPZF4X\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:27.581960Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[100.563321, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TRT2W5EP2RMNS8WGG43ZA\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:34.813176Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.740491, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TS13336P96H5B6KFPH9WW\", \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": null, \"error_code\": null, \"event\": \"capture.created\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures\", \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": \"mini-arkit-live2\", \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS13336P96H5B6KFPH9WV\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:41.990343Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.740716, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 3, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures\", \"http.status\": 201, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS13336P96H5B6KFPH9WV\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:41.990536Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.74604, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TS13336P96H5B6KFPH9WW\", \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": null, \"error_code\": null, \"event\": \"files.registered\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/files\", \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS138M1GNTMY57VZRR55E\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:41.995935Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.746239, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 3, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/files\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS138M1GNTMY57VZRR55E\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:41.996214Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.755413, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 1, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS13KAP81X14EG5M08401\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.005321Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.757201, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS13PGJ092TBCQEAEWDEK\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.007163Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}"]
+[107.757461, "o", "\r\n"]
+[107.758974, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS13RYQAG6TN7HQF8WR0D\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.008911Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.760551, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS13SYZ6500Q6JS3DFBW8\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.010521Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.762247, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS13VFJPZE6MTNWRFGFKP\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.012221Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.76382, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS13WNPVPP7JKXXX4H0J8\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.013782Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.765413, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS13Y8FCZK4ACA0HFCWJB\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.015326Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.766952, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS1402B45CWEWDQWQ9CPF\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.016935Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.768554, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS141DYJ9HKRZPGNSN3XW\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.018512Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.770115, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS143XXDVZ3KFRFSZP8P7\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.020075Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.771655, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 0, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"PUT\", \"http.route\": \"/v1/uploads/{token}\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS144QW2AKSFKZ1Z76V49\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.021606Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.783259, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TS13336P96H5B6KFPH9WW\", \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": null, \"error_code\": null, \"event\": \"files.committed\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/files:commit\", \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS146MS9E6Z53P368CKDM\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.033194Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.783432, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 10, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/files:commit\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS146MS9E6Z53P368CKDM\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.033420Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.786605, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TS13336P96H5B6KFPH9WW\", \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": null, \"error_code\": null, \"event\": \"finalize.accepted\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/finalize\", \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS14JHEJAJDGW44B7GE7V\", \"run_id\": \"run_4c05e7d782dfc5f5\", \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.036570Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.787314, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 2, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"POST\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/finalize\", \"http.status\": 202, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS14JHEJAJDGW44B7GE7V\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.037241Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.789833, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TS13336P96H5B6KFPH9WW\", \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": null, \"error_code\": null, \"event\": \"events.poll\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/events\", \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS14PFV480P46JCF4ESCA\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.039764Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.789995, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 1, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/events\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS14PFV480P46JCF4ESCA\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.039960Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[107.817227, "o", "{\"level\":\"warning\",\"event\":\"packet_issue\",\"msg\":\"synthetic_source\",\"code\":\"synthetic_source\",\"pointer\":\"/source/kind\",\"capture_id\":\"mini-arkit-live2\"}\r\n{\"level\":\"warning\",\"event\":\"packet_issue\",\"msg\":\"keyframe_resolution_differs\",\"code\":\"keyframe_resolution_differs\",\"pointer\":\"/keyframes/0/w\",\"capture_id\":\"mini-arkit-live2\"}\r\n{\"level\":\"warning\",\"event\":\"packet_issue\",\"msg\":\"keyframe_resolution_differs\",\"code\":\"keyframe_resolution_differs\",\"pointer\":\"/keyframes/1/w\",\"capture_id\":\"mini-arkit-live2\"}\r\n"]
+[107.817427, "o", "{\"level\":\"warning\",\"event\":\"packet_issue\",\"msg\":\"low_resolution\",\"code\":\"low_resolution\",\"pointer\":\"/keyframes/0/w\",\"capture_id\":\"mini-arkit-live2\"}\r\n{\"level\":\"warning\",\"event\":\"packet_issue\",\"msg\":\"low_resolution\",\"code\":\"low_resolution\",\"pointer\":\"/keyframes/1/w\",\"capture_id\":\"mini-arkit-live2\"}\r\n{\"level\":\"warning\",\"event\":\"packet_issue\",\"msg\":\"low_resolution\",\"code\":\"low_resolution\",\"pointer\":\"/keyframes/2/w\",\"capture_id\":\"mini-arkit-live2\"}\r\n{\"level\":\"warning\",\"event\":\"packet_issue\",\"msg\":\"low_resolution\",\"code\":\"low_resolution\",\"pointer\":\"/keyframes/3/w\",\"capture_id\":\"mini-arkit-live2\"}\r\n{\"level\":\"warning\",\"event\":\"packet_issue\",\"msg\":\"few_images\",\"code\":\"few_images\",\"pointer\":\"/keyframes\",\"capture_id\":\"mini-arkit-live2\"}\r\n"]
+[107.841175, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TS13336P96H5B6KFPH9WW\", \"deployment.environment\": null, \"disagreement\": null, \"duration_ms\": 23, \"error_code\": null, \"event\": \"promotion.done\", \"git_sha\": null, \"gpu\": null, \"http.method\": null, \"http.route\": null, \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": null, \"request_id\": null, \"run_id\": null, \"service.name\": null, \"stage\": null, \"state_backend\": null, \"storage_backend\": null, \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.091107Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[108.343446, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TS13336P96H5B6KFPH9WW\", \"deployment.environment\": null, \"disagreement\": null, \"duration_ms\": null, \"error_code\": null, \"event\": \"run.started\", \"git_sha\": null, \"gpu\": null, \"http.method\": null, \"http.route\": null, \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": null, \"product\": null, \"request_id\": null, \"run_id\": \"run_4c05e7d782dfc5f5\", \"service.name\": null, \"stage\": null, \"state_backend\": null, \"storage_backend\": null, \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:42.593380Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[112.798153, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TS13336P96H5B6KFPH9WW\", \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": null, \"error_code\": null, \"event\": \"events.poll\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/events\", \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS14Y91SAC9E4BAH0DBWV\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:47.047893Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[112.798482, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 5002, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/events\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS14Y91SAC9E4BAH0DBWV\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:47.048330Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[112.801691, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TS13336P96H5B6KFPH9WW\", \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": null, \"error_code\": null, \"event\": \"result.served\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/result\", \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS619Z552Z8BBTCJN1JTQ\", \"run_id\": \"run_4c05e7d782dfc5f5\", \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:47.051629Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[112.802038, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 2, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/result\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS619Z552Z8BBTCJN1JTQ\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:47.051896Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[113.887278, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 1, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/review\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"local-review\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS737KM7V9SXBEXQBT21P\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:48.137146Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[114.504603, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": \"cap_01M51TS13336P96H5B6KFPH9WW\", \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": null, \"error_code\": null, \"event\": \"result.served\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/result\", \"http.status\": null, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS7PHQYZ8A2CSKY31B87W\", \"run_id\": \"run_4c05e7d782dfc5f5\", \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:48.754511Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[114.504895, "o", "{\"amendment_id\": null, \"attempt\": null, \"capture_id\": null, \"deployment.environment\": \"dev\", \"disagreement\": null, \"duration_ms\": 1, \"error_code\": null, \"event\": \"http.request\", \"git_sha\": \"993c362751879bd03f3a8b90dd74c04b0836b78b\", \"gpu\": null, \"http.method\": \"GET\", \"http.route\": \"/v1/captures/cap_01M51TS13336P96H5B6KFPH9WW/result\", \"http.status\": 200, \"level\": \"info\", \"msg\": \"\", \"packet_id\": null, \"principal\": \"device\", \"product\": \"house-scanning\", \"request_id\": \"req_01M51TS7PHQYZ8A2CSKY31B87W\", \"run_id\": null, \"service.name\": \"capture-api\", \"stage\": null, \"state_backend\": \"memory\", \"storage_backend\": \"volume\", \"tokens_in\": null, \"tokens_out\": null, \"ts\": \"2026-10-16T07:45:48.754794Z\", \"vlm_cost_usd\": null, \"vlm_model\": null, \"vlm_provider\": null}\r\n"]
+[124.093427, "o", "^C"]
+[124.138068, "o", "\u001b[32mINFO\u001b[0m:     Shutting down\r\n"]
+[124.238432, "o", "\u001b[32mINFO\u001b[0m:     Waiting for application shutdown.\r\n"]
+[124.23854, "o", "\u001b[32mINFO\u001b[0m:     Application shutdown complete.\r\n"]
+[124.238901, "o", "\u001b[32mINFO\u001b[0m:     Finished server process [\u001b[36m10967\u001b[0m]\r\n"]
+[124.240332, "o", "Traceback (most recent call last):\r\n  File \"/home/user/.local/share/uv/python/cpython-3.12.15-linux-x86_64-gnu/lib/python3.12/asyncio/runners.py\", line 118, in run\r\n"]
+[124.240516, "o", "    return self._loop.run_until_complete(task)\r\n           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\r\n  File \"uvloop/loop.pyx\", line 1518, in uvloop.loop.Loop.run_until_complete\r\n"]
+[124.240626, "o", "asyncio.exceptions.CancelledError\r\n\r\nDuring handling of the above exception, another exception occurred:\r\n\r\nTraceback (most recent call last):\r\n"]
+[124.240805, "o", "  File \"/home/user/work/burst11-bs-local-api-serve/backend/scripts/local_capture_api.py\", line 221, in <module>\r\n"]
+[124.241057, "o", "    raise SystemExit(main())\r\n                     ^^^^^^\r\n  File \"/home/user/work/burst11-bs-local-api-serve/backend/scripts/local_capture_api.py\", line 216, in main\r\n    uvicorn.Server(config).run()\r\n  File \"/home/user/work/burst11-bs-local-api-serve/backend/.venv/lib/python3.12/site-packages/uvicorn/server.py\", line 86, in run\r\n    return asyncio_run(self.serve(sockets=sockets), loop_factory=self.config.get_loop_factory())\r\n"]
+[124.241207, "o", "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\r\n  File \"/home/user/.local/share/uv/python/cpython-3.12.15-linux-x86_64-gnu/lib/python3.12/asyncio/runners.py\", line 195, in run\r\n    return runner.run(main)\r\n           ^^^^^^^^^^^^^^^^\r\n  File \"/home/user/.local/share/uv/python/cpython-3.12.15-linux-x86_64-gnu/lib/python3.12/asyncio/runners.py\", line 123, in run\r\n    raise KeyboardInterrupt()\r\nKeyboardInterrupt\r\n"]
+[124.49459, "o", "make: *** [Makefile:100: local-api] Error 130\r\n"]
diff --git a/backend/docs/evidence/local-capture-api/result-page.png b/backend/docs/evidence/local-capture-api/result-page.png
new file mode 100644
index 0000000000000000000000000000000000000000..78ed3ec9f08542caf44eb4c57a5da970dd1783b8
GIT binary patch
literal 47931
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
XQh{qXqPPYhyaG{ztI3zjnFRh9DKDmh

literal 0
HcmV?d00001

diff --git a/backend/docs/evidence/local-capture-api/review-page.png b/backend/docs/evidence/local-capture-api/review-page.png
new file mode 100644
index 0000000000000000000000000000000000000000..d7f0de497661facdbde8778cfe3f7f8785645416
GIT binary patch
literal 6795
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

literal 0
HcmV?d00001

diff --git a/backend/docs/evidence/local-capture-api/smoke-terminal.png b/backend/docs/evidence/local-capture-api/smoke-terminal.png
new file mode 100644
index 0000000000000000000000000000000000000000..10982eab7962e1510454c1c79f7a62f90e532448
GIT binary patch
literal 6300
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
CNLKU!

literal 0
HcmV?d00001

diff --git a/backend/docs/evidence/local-capture-api/smoke.cast b/backend/docs/evidence/local-capture-api/smoke.cast
new file mode 100644
index 000000000..d51aa8644
--- /dev/null
+++ b/backend/docs/evidence/local-capture-api/smoke.cast
@@ -0,0 +1,11 @@
+{"version": 2, "width": 80, "height": 24, "timestamp": 1792136781, "env": {"SHELL": "/bin/bash", "TERM": "tmux-256color"}}
+[0.005238, "o", "uv run --frozen --extra api pytest tests/test_local_capture_api.py -q\r\n"]
+[6.779782, "o", "\u001b[32m.\u001b[0m"]
+[6.802891, "o", "\u001b[32m.\u001b[0m"]
+[6.818502, "o", "\u001b[32m.\u001b[0m"]
+[6.827253, "o", "\u001b[32m.\u001b[0m"]
+[6.828111, "o", "\u001b[32m.\u001b[0m"]
+[6.893632, "o", "\u001b[32m.\u001b[0m"]
+[7.058185, "o", "\u001b[32m                                                                   [100%]\u001b[0m"]
+[7.061215, "o", "\r\n"]
+[7.061486, "o", "\u001b[32m\u001b[32m\u001b[1m6 passed\u001b[0m\u001b[32m in 6.49s\u001b[0m\u001b[0m\r\n"]

From 2ba15518b63ce8fec4ab2465fbd7478266efc87a Mon Sep 17 00:00:00 2001
From: Obvious <obvious@obvious.ai>
Date: Fri, 16 Oct 2026 09:24:39 +0000
Subject: [PATCH 16/20] feat(orchestrator): dev-only scripted local outcomes
 for stage stubs

HSS_LOCAL_OUTCOME walks a stubbed local run to each state the app renders:
manual_review (default, today's bytes), eligible, needs_more_photos,
not_eligible (needs SHOW_REJECT_TO_HOMEOWNER=1), failed (validate fails onto
outcome row 1). HSS_LOCAL_STAGE_DELAY_S paces stub stages 0-30s. Both are
refused loudly outside dev stage stubs; scripted messages and the review page
say the outcome is a local test, not a check of a wall.

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/orchestrator/README.md         |  16 +-
 backend/server/orchestrator/config.py         |  51 ++
 backend/server/orchestrator/stubs/_common.py  |   7 +
 backend/server/orchestrator/stubs/criteria.py |  21 +-
 backend/server/orchestrator/stubs/result.py   | 212 +++++++-
 backend/server/orchestrator/stubs/validate.py |  40 +-
 backend/tests/test_local_outcome_states.py    | 462 ++++++++++++++++++
 7 files changed, 784 insertions(+), 25 deletions(-)
 create mode 100644 backend/tests/test_local_outcome_states.py

diff --git a/backend/server/orchestrator/README.md b/backend/server/orchestrator/README.md
index 6a7bea018..d6c04b762 100644
--- a/backend/server/orchestrator/README.md
+++ b/backend/server/orchestrator/README.md
@@ -33,4 +33,18 @@ make ci
 
 ## Stubs
 
-`HSS_ORCH_STAGE_STUBS=1` runs `server/orchestrator/stubs/<stage>.py` instead of `server.<stage>.run`. Stub verdicts are `manual_review` with empty `views_needed`.
+`HSS_ORCH_STAGE_STUBS=1` runs `server/orchestrator/stubs/<stage>.py` instead of `server.<stage>.run`. Stub verdicts are `manual_review` with empty `views_needed`. The stub review page says every stage is a stand-in.
+
+### Scripted local outcomes (dev only)
+
+With stage stubs on and `SMP_ENVIRONMENT=dev`, `HSS_LOCAL_OUTCOME` scripts the terminal state a stubbed local run reaches — the app can be walked to each state it renders, end to end, without Modal or GPU:
+
+| `HSS_LOCAL_OUTCOME` | Capture status | Notes |
+| --- | --- | --- |
+| unset / `manual_review` (default) | `manual_review` | Today's stub run, byte-identical. |
+| `eligible` | `complete` | Result carries a proposed placement (`boxArkitWorld` + `arkitEpoch` when the packet has one), worded as proposed. |
+| `needs_more_photos` | `needs_views` | One scripted band view; the app sends a retake request. |
+| `not_eligible` | `complete` | Needs `SHOW_REJECT_TO_HOMEOWNER=1`; without it the boot refuses. |
+| `failed` | `failed` | The validate stub fails the run onto outcome row 1 (validation stand-in `imagesUsable: false`). |
+
+Scripted messages and review pages always say it is a local test outcome, not a check of a wall. `HSS_LOCAL_STAGE_DELAY_S` (float, 0–30, default 0) makes each stub sleep so the app shows processing events. Both variables are refused loudly — at boot with an error naming the variable — when stage stubs are off, the environment is not dev, the value is unknown, or the number is out of range. A run keeps its scripted behavior across restart while the variables stay set.
diff --git a/backend/server/orchestrator/config.py b/backend/server/orchestrator/config.py
index 28cbfd3aa..4b5a55d02 100644
--- a/backend/server/orchestrator/config.py
+++ b/backend/server/orchestrator/config.py
@@ -11,6 +11,55 @@ def _flag(value: str) -> bool:
     return value.strip().lower() in {"1", "true", "yes", "on"}
 
 
+_LOCAL_OUTCOMES = (
+    "manual_review",
+    "eligible",
+    "needs_more_photos",
+    "not_eligible",
+    "failed",
+)
+
+
+def _dev_stubs(env: dict[str, str]) -> bool:
+    """Scripted local outcomes are honored only under dev stage stubs."""
+    return _flag(env.get("HSS_ORCH_STAGE_STUBS", "0")) and env.get("SMP_ENVIRONMENT", "prod") == "dev"
+
+
+def _require_dev_stubs(name: str, env: dict[str, str]) -> None:
+    if _dev_stubs(env):
+        return
+    raise ValueError(
+        f"{name} is only honored with HSS_ORCH_STAGE_STUBS=1 and SMP_ENVIRONMENT=dev "
+        f"(got HSS_ORCH_STAGE_STUBS={env.get('HSS_ORCH_STAGE_STUBS', '0')!r}, "
+        f"SMP_ENVIRONMENT={env.get('SMP_ENVIRONMENT', '(unset)')!r}); "
+        "refusing to run with it silently ignored"
+    )
+
+
+def _local_outcome(env: dict[str, str]) -> str:
+    raw = env.get("HSS_LOCAL_OUTCOME", "")
+    if not raw:
+        return "manual_review"
+    if raw not in _LOCAL_OUTCOMES:
+        raise ValueError(f"HSS_LOCAL_OUTCOME={raw!r} is not one of {', '.join(_LOCAL_OUTCOMES)}")
+    _require_dev_stubs("HSS_LOCAL_OUTCOME", env)
+    return raw
+
+
+def _local_stage_delay_s(env: dict[str, str]) -> float:
+    raw = env.get("HSS_LOCAL_STAGE_DELAY_S", "")
+    if not raw:
+        return 0.0
+    try:
+        value = float(raw)
+    except ValueError:
+        raise ValueError(f"HSS_LOCAL_STAGE_DELAY_S={raw!r} is not a number of seconds") from None
+    if not 0 <= value <= 30:
+        raise ValueError(f"HSS_LOCAL_STAGE_DELAY_S={raw!r} is outside the range 0 to 30 seconds")
+    _require_dev_stubs("HSS_LOCAL_STAGE_DELAY_S", env)
+    return value
+
+
 class OrchConfig(BaseModel):
     model_config = ConfigDict(extra="ignore")
 
@@ -63,4 +112,6 @@ def pick(name: str, default: str) -> str:
         test_kill_coordinator_after=pick("HSS_ORCH_TEST_KILL_COORDINATOR_AFTER", ""),
         coordinator_loop_s=float(pick("HSS_ORCH_COORDINATOR_LOOP_S", "1")),
         modal_remote=_flag(pick("HSS_ORCH_MODAL_REMOTE", "0")),
+        local_outcome=_local_outcome(env),
+        local_stage_delay_s=_local_stage_delay_s(env),
     )
diff --git a/backend/server/orchestrator/stubs/_common.py b/backend/server/orchestrator/stubs/_common.py
index 7a4dff27b..fd14344d1 100644
--- a/backend/server/orchestrator/stubs/_common.py
+++ b/backend/server/orchestrator/stubs/_common.py
@@ -5,16 +5,23 @@
 import hashlib
 import io
 import json
+import time
 from pathlib import Path
 
 import numpy as np
 
 from server.contracts.jobs import StageContext, StageResult
+from server.orchestrator.config import load_orch
 
 _PLY = b"ply\nformat ascii 1.0\nelement vertex 1\nproperty float x\nproperty float y\nproperty float z\nend_header\n0 0 0\n"
 
 
 def write_files(ctx: StageContext, files: dict[str, bytes]) -> StageResult:
+    # The dev-only scripted delay: each stub sleeps so the app sees the stage
+    # move through processing. load_orch refuses a stray value at boot.
+    delay = load_orch().local_stage_delay_s
+    if delay > 0:
+        time.sleep(delay)
     artifacts: dict[str, str] = {}
     for key, data in files.items():
         path = ctx.work_dir / key
diff --git a/backend/server/orchestrator/stubs/criteria.py b/backend/server/orchestrator/stubs/criteria.py
index a1d4c7297..be196409f 100644
--- a/backend/server/orchestrator/stubs/criteria.py
+++ b/backend/server/orchestrator/stubs/criteria.py
@@ -1,16 +1,31 @@
-"""Stub ``criteria`` stage. Decisions stay ``manual_review`` so a stub cannot be an unsafe pass."""
+"""Stub ``criteria`` stage. Decisions stay ``manual_review`` so a stub cannot be an unsafe pass.
+
+A scripted local outcome (``HSS_LOCAL_OUTCOME``, dev + stage stubs only) is the
+one exception: it writes the decision the outcome table's rows 11-14 need to
+land the capture on the chosen state. Nothing else changes.
+"""
 
 from __future__ import annotations
 
 from server.contracts.jobs import StageContext, StageResult
 from server.eval.sceneio import schema_errors
-from server.orchestrator.stubs._common import json_bytes, verdict_document, write_files
+from server.orchestrator.stubs._common import json_bytes, scripted_outcome, scripted_verdict, verdict_document, write_files
 
 
 def run(ctx: StageContext) -> StageResult:
+    outcome = scripted_outcome()
+    if outcome == "not_eligible" and not getattr(ctx.settings, "SHOW_REJECT_TO_HOMEOWNER", False):
+        raise RuntimeError(
+            "HSS_LOCAL_OUTCOME=not_eligible needs SHOW_REJECT_TO_HOMEOWNER=1; "
+            "with the reject hidden the capture would land manual_review instead"
+        )
     files = {}
     for profile in ("A", "B", "C", "S"):
-        verdict = verdict_document(profile, ctx.capture_id)
+        verdict = (
+            verdict_document(profile, ctx.capture_id)
+            if outcome in ("manual_review", "failed")
+            else scripted_verdict(profile, ctx.capture_id, outcome)
+        )
         errors = schema_errors(verdict)
         if errors:
             raise RuntimeError("artifact_invalid:criteria " + "; ".join(errors[:5]))
diff --git a/backend/server/orchestrator/stubs/result.py b/backend/server/orchestrator/stubs/result.py
index 856898f18..7916a287f 100644
--- a/backend/server/orchestrator/stubs/result.py
+++ b/backend/server/orchestrator/stubs/result.py
@@ -1,4 +1,11 @@
-"""Stub ``result`` stage. Emits the one ``verdict_ready`` and does not edit the verdict."""
+"""Stub ``result`` stage. Emits the one ``verdict_ready`` and does not edit the verdict.
+
+With ``HSS_LOCAL_OUTCOME`` (dev + stage stubs only) the stub scripts the
+terminal state instead: the verdict the criteria stub writes lands the capture
+on the chosen outcome-table row, and this stage composes the matching device
+result. Every scripted message says it is a local test outcome, not a check of
+a wall. The review page is honest for both modes: every stage is a stand-in.
+"""
 
 from __future__ import annotations
 
@@ -6,55 +13,222 @@
 from pathlib import Path
 from typing import Literal
 
-from server.contracts.jobs import Profile, StageContext, StageResult
-from server.contracts.result import MeterBlock, Outcome, ResultResponse
-from server.orchestrator.stubs._common import json_bytes, sha256, write_files
+import numpy as np
+
+from server.contracts.jobs import STAGE_DEPS, Profile, StageContext, StageResult
+from server.contracts.result import (
+    BoxArkitWorld,
+    BoxSceneM,
+    FootprintM,
+    MeterBlock,
+    Outcome,
+    RecommendedPlacement,
+    ResultResponse,
+    ViewNeededDevice,
+)
+from server.orchestrator.config import load_orch
+from server.orchestrator.stubs._common import json_bytes, scripted_outcome, sha256, write_files
+from server.result import ar
+from server.result.copy import FALLBACK, Catalogue, load_catalogue, render, select_prompt
 
 _PROFILES: frozenset[str] = frozenset({"A", "B", "C", "S"})
 
+# Outcome kind to capture status, exactly the real composer's map.
+_STATUS = {
+    "eligible": "complete",
+    "needs_more_photos": "needs_views",
+    "not_eligible": "complete",
+    "manual_review": "manual_review",
+}
+
+_MESSAGE = {
+    "eligible": (
+        "Local test stand-in: the proposed placement is scripted, not measured. "
+        "This is a local test outcome, not a check of a wall."
+    ),
+    "needs_more_photos": (
+        "Local test stand-in: the retake request is scripted, not measured. "
+        "This is a local test outcome, not a check of a wall."
+    ),
+    "not_eligible": (
+        "Local test stand-in: the not-eligible decision is scripted, not measured. "
+        "This is a local test outcome, not a check of a wall."
+    ),
+}
+
+# The profile-C footprint, as the real composer's FOOTPRINT table holds it.
+_FOOTPRINT_C = (0.7874, 1.0033, 0.5588)
+_STANDOFF_M = 0.02
+
+# The committed prompt catalogue; the production catalogue may not exist here.
+_PROMPTS = Path(__file__).resolve().parents[2] / "result" / "tests" / "data" / "prompts.en-US.json"
+
 
 def run(ctx: StageContext) -> StageResult:
+    outcome = scripted_outcome()
+    if outcome == "failed":
+        raise RuntimeError(
+            "HSS_LOCAL_OUTCOME=failed must end the run at validate; the result stage should not run"
+        )
+    if outcome == "not_eligible" and not getattr(ctx.settings, "SHOW_REJECT_TO_HOMEOWNER", False):
+        raise RuntimeError(
+            "HSS_LOCAL_OUTCOME=not_eligible needs SHOW_REJECT_TO_HOMEOWNER=1; "
+            "with the reject hidden the capture would land manual_review instead"
+        )
     run_rec = ctx.state.get_run(ctx.run_id)
     key = run_rec.artifacts["verdicts/verdict.C.json"]
     verdict_bytes = ctx.storage.get_bytes(key)
     digest = sha256(verdict_bytes)
     verdict = json.loads(verdict_bytes)
     decision = verdict["site"]["decision"]
-    kind = "manual_review" if decision == "manual_review" else decision
+    kind = "manual_review" if outcome == "manual_review" else outcome
     ctx.state.append_event(
         ctx.capture_id,
         "verdict_ready",
         {"runId": ctx.run_id, "kind": kind},
         run_id=ctx.run_id,
     )
-    response = ResultResponse(
-        runId=ctx.run_id,
-        status="manual_review",
-        viewsNeeded=[],
-        memberActions=[],
-        outcome=Outcome(
-            kind="manual_review",
-            profile=_profile(ctx),
-            message="Review required before a placement is shown.",
+    if outcome == "manual_review":
+        # The default run: today's bytes, unchanged.
+        response = ResultResponse(
+            runId=ctx.run_id,
+            status="manual_review",
             viewsNeeded=[],
-            reasons=[],
-        ),
-        meter=_stub_meter(ctx),
-    )
+            memberActions=[],
+            outcome=Outcome(
+                kind="manual_review",
+                profile=_profile(ctx),
+                message="Review required before a placement is shown.",
+                viewsNeeded=[],
+                reasons=[],
+            ),
+            meter=_stub_meter(ctx),
+        )
+    else:
+        views = _views_needed() if outcome == "needs_more_photos" else []
+        epoch = _packet_epoch(ctx)
+        response = ResultResponse(
+            runId=ctx.run_id,
+            status=_STATUS[outcome],
+            viewsNeeded=list(views),
+            memberActions=[],
+            outcome=Outcome(
+                kind=kind,  # type: ignore[arg-type]
+                profile=_profile(ctx),
+                message=_MESSAGE[outcome],
+                viewsNeeded=list(views),
+                reasons=[],
+                arkitEpoch=epoch,
+                recommendedPlacement=_placement(_profile(ctx), epoch) if outcome == "eligible" else None,
+            ),
+            meter=_stub_meter(ctx),
+        )
     body = response.model_dump(mode="json")
     ResultResponse.model_validate(body)
     internal = {"verdict_c_sha256": digest, "decision": decision}
+    if outcome != "manual_review":
+        internal["scripted_outcome"] = outcome
     return write_files(
         ctx,
         {
             "result/result.json": json_bytes(body),
             "result/result.internal.json": json_bytes(internal),
-            "result/review.html": b"<html><body>stub review</body></html>",
+            "result/review.html": _review_page(outcome),
             "result/preview.ply": b"ply\nformat ascii 1.0\nelement vertex 0\nend_header\n",
         },
     )
 
 
+def _placement(profile: str, epoch: str | None) -> RecommendedPlacement:
+    """A proposed spot on the stub wall, in ARKit world when the packet has an epoch.
+
+    The stub scene is meter-anchored with scale 1.0, so the scene-to-ARKit
+    transform is the identity: the box pose is the meter-frame box pose, and
+    the epoch comes from the capture packet's own ``epochs`` list.
+    """
+    width, height, depth = _FOOTPRINT_C
+    size = [width, height, depth]
+    center = [0.6937, height / 2, depth / 2 + _STANDOFF_M]
+    box_arkit = None
+    if epoch is not None:
+        built = ar.box_to_arkit(np.eye(4), center, size, 0.0)
+        box_arkit = BoxArkitWorld(pose=built["pose"], size=built["size"])
+    return RecommendedPlacement(
+        wallId="w1",
+        startSM=0.3,
+        footprintM=FootprintM(w=width, h=height, d=depth),
+        boxSceneM=BoxSceneM(centerM=center, sizeM=size, yawDeg=0.0),
+        confidence=0.5,
+        profile=profile,  # type: ignore[arg-type]
+        boxArkitWorld=box_arkit,
+    )
+
+
+def _packet_epoch(ctx: StageContext) -> str | None:
+    """The packet's ARKit epoch, when the capture carries exactly one.
+
+    Same rule as ``server.result.ar.epoch_id``: the stub scene frame names no
+    ``source_frame``, so a single packet epoch is the epoch; anything else is
+    None and the placement stays in scene metres.
+    """
+    epochs = _packet_epochs(ctx)
+    if len(set(epochs)) == 1:
+        return epochs[0]
+    return None
+
+
+def _packet_epochs(ctx: StageContext) -> list[str]:
+    try:
+        raw = (Path(str(ctx.inputs["packet_dir"])) / "packet.json").read_text()
+        packet = json.loads(raw)
+    except (KeyError, OSError, json.JSONDecodeError, TypeError):
+        return []
+    epochs = packet.get("epochs") if isinstance(packet, dict) else None
+    if not isinstance(epochs, list):
+        return []
+    return [str(item) for item in epochs if isinstance(item, str)]
+
+
+def _views_needed() -> list[ViewNeededDevice]:
+    """One scripted band view, prompted from the real catalogue with a real id."""
+    catalogue = _catalogue()
+    entry = select_prompt(catalogue, kind="band", band="wall", cause="unobserved")
+    prompt = render(entry, side="left", s_ft=2.0, out_ft=10.0)
+    return [
+        ViewNeededDevice(
+            id="stub-wall-band",
+            kind="band",
+            criteria=["stub"],
+            why="Local test stand-in: this retake request is scripted, not measured.",
+            promptId=prompt.promptId,
+            prompt={"title": prompt.title, "body": prompt.body},
+            band="wall",
+            wallId="w1",
+            sM=[0.2, 1.0],
+            side="left",
+            viewingAngleDeg=[0, 30],
+        )
+    ]
+
+
+def _catalogue() -> Catalogue:
+    try:
+        return load_catalogue(_PROMPTS)
+    except (OSError, FileNotFoundError):
+        return FALLBACK
+
+
+def _review_page(outcome: str) -> bytes:
+    stages = ", ".join(STAGE_DEPS)
+    return (
+        "<html><body><h1>Local stage-stub run</h1>"
+        f"<p>Every stage here is a stand-in: stage stubs ran instead of real processing ({stages}).</p>"
+        f"<p>Scripted outcome: <strong>{outcome}</strong> (HSS_LOCAL_OUTCOME). "
+        "This is a local test, not a check of a wall.</p>"
+        "</body></html>"
+    ).encode()
+
+
 def _profile(ctx: StageContext) -> Profile:
     configured = getattr(ctx.settings, "RULES_PROFILE_DEFAULT", "C")
     if configured in _PROFILES:
diff --git a/backend/server/orchestrator/stubs/validate.py b/backend/server/orchestrator/stubs/validate.py
index 47fa2d0b8..d50851d3b 100644
--- a/backend/server/orchestrator/stubs/validate.py
+++ b/backend/server/orchestrator/stubs/validate.py
@@ -1,12 +1,20 @@
-"""Stub ``validate`` stage."""
+"""Stub ``validate`` stage.
+
+A scripted ``HSS_LOCAL_OUTCOME=failed`` (dev + stage stubs only) ends the run
+here, on outcome row 1: the stage fails while its validation stand-in reports
+unusable images. A failed stage never publishes artifacts, so the stand-in
+registers its own artifact before raising.
+"""
 
 from __future__ import annotations
 
 from server.contracts.jobs import StageContext, StageResult
-from server.orchestrator.stubs._common import json_bytes, write_files
+from server.orchestrator.stubs._common import json_bytes, scripted_outcome, write_files
 
 
 def run(ctx: StageContext) -> StageResult:
+    if scripted_outcome() == "failed":
+        _script_failed(ctx)
     return write_files(
         ctx,
         {
@@ -15,3 +23,31 @@ def run(ctx: StageContext) -> StageResult:
             "packet/capture_check.json": json_bytes({"complete": False, "missing": ["meter_close", "meter_oblique"]}),
         },
     )
+
+
+def _script_failed(ctx: StageContext) -> None:
+    """Publish the validation stand-in, then fail the stage.
+
+    Row 1 of ``server/orchestrator/outcomes.py`` is the one row whose capture
+    status is ``failed``: the validate stage failed while
+    ``packet/validation.json`` says the images are unusable. The stand-in
+    registers itself on the run record directly, because a failing stage's
+    ``StageResult`` is discarded.
+    """
+    key = "packet/validation.json"
+    body = json_bytes(
+        {
+            "imagesUsable": False,
+            "ok": False,
+            "issues": ["scripted_local_test"],
+            "reason": "HSS_LOCAL_OUTCOME=failed",
+        }
+    )
+    ctx.storage.put_bytes(key, body, "application/json")
+    run = ctx.state.get_run(ctx.run_id)
+    run.artifacts[key] = key
+    ctx.state.put_run(run)
+    raise RuntimeError(
+        "local_scripted_failure: HSS_LOCAL_OUTCOME=failed ends the run on outcome row 1 "
+        "(validate failed, images unusable)"
+    )
diff --git a/backend/tests/test_local_outcome_states.py b/backend/tests/test_local_outcome_states.py
new file mode 100644
index 000000000..b7b595ba3
--- /dev/null
+++ b/backend/tests/test_local_outcome_states.py
@@ -0,0 +1,462 @@
+"""``HSS_LOCAL_OUTCOME`` walks a stubbed local run to each state the app renders.
+
+Every capture status the app renders — ``manual_review``, ``complete``,
+``needs_views``, ``failed`` — has an outcome-table row behind it
+(``server/orchestrator/outcomes.py``), and until now no local run could reach
+any of them but ``manual_review``: the stage stubs always decided
+``manual_review``, so "walk the app locally" stopped at one screen. This packet
+adds a dev-only script: with stage stubs and the dev environment, setting
+``HSS_LOCAL_OUTCOME`` (or ``HSS_LOCAL_STAGE_DELAY_S`` for pacing) drives one
+run onto each row.
+
+These tests are that proof, over the same documented dev settings as the
+journey tests — memory state, volume storage, static test auth, stage stubs,
+no Modal, no GPU, no network. The committed fixtures under
+``tests/fixtures/app_states/<state>/`` are the served device payloads and
+event walks, one per state, regenerated with
+``uv run python tests/test_local_outcome_states.py --generate`` and re-checked
+here so a later contract change cannot silently invalidate the evidence.
+
+The scripted outcomes are test stand-ins: every message and review page says so
+("local test outcome, not a check of a wall"), and the default stub run keeps
+today's bytes.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import shutil
+import tempfile
+import time
+from pathlib import Path
+from typing import Callable
+
+import pytest
+from fastapi.testclient import TestClient
+
+from server.api.app import create_app
+from server.api.deps import drain_finalize
+from server.common.config import Settings
+from server.contracts.result import ResultResponse
+from server.orchestrator.config import load_orch
+from server.orchestrator.outcomes import capture_status
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+PACKET_FIXTURE = REPO_ROOT / "backend" / "data" / "fixtures" / "packets" / "mini-arkit"
+FIXTURES = Path(__file__).resolve().parent / "fixtures" / "app_states"
+
+# (name, HSS_LOCAL_OUTCOME, SHOW_REJECT_TO_HOMEOWNER, capture status, outcome kind).
+STATES = [
+    ("manual_review", "manual_review", False, "manual_review", "manual_review"),
+    ("eligible", "eligible", False, "complete", "eligible"),
+    ("needs_more_photos", "needs_more_photos", False, "needs_views", "needs_more_photos"),
+    ("not_eligible", "not_eligible", True, "complete", "not_eligible"),
+    ("failed", "failed", False, "failed", None),
+]
+
+TEMPLATE_ENV = {
+    "HSS_ORCH_STAGE_STUBS": "1",
+    "HSS_ORCH_PREWARM": "0",
+    "VISION_EXTERNAL_CALLS": "off",
+    "STATE_BACKEND": "memory",
+    "STORAGE_BACKEND": "volume",
+    "SMP_ENVIRONMENT": "dev",
+}
+
+
+def _settings(tmp: Path, show_reject: bool) -> Settings:
+    return Settings(
+        SMP_ENVIRONMENT="dev",
+        HSS_AUTH_MODE="static",
+        # Synthetic, explicitly static test auth — no real principal.
+        CAPTURE_API_TOKENS=f"device:{'d' * 40}",
+        UPLOAD_URL_HMAC_SECRET="h" * 32,
+        STORAGE_BACKEND="volume",
+        STATE_BACKEND="memory",
+        VOLUME_ROOT=str(tmp / "vol"),
+        CAPTURE_API_PUBLIC_URL="http://testserver",
+        HSS_INGEST_HOOKS="auto",
+        VISION_EXTERNAL_CALLS="off",
+        GIT_SHA="0123456789abcdef",
+        SMP_SERVICE_NAME="capture-api",
+        SHOW_REJECT_TO_HOMEOWNER=show_reject,
+    )
+
+
+@pytest.fixture
+def local_app(tmp_path, monkeypatch):
+    """Build the app behind the capture front door with a scripted outcome.
+
+    Returns a builder ``(outcome, show_reject, delay=None) -> (root, packet,
+    client, app, deps)``; monkeypatch restores the environment afterwards.
+    """
+    for key, value in TEMPLATE_ENV.items():
+        monkeypatch.setenv(key, value)
+    monkeypatch.delenv("HSS_LOCAL_OUTCOME", raising=False)
+    monkeypatch.delenv("HSS_LOCAL_STAGE_DELAY_S", raising=False)
+
+    def build(outcome: str | None = None, show_reject: bool = False, delay: float | None = None):
+        root = tmp_path / f"packet-{outcome or 'default'}"
+        shutil.copytree(PACKET_FIXTURE, root)
+        packet = json.loads((root / "packet.json").read_text())
+        monkeypatch.setenv("VOLUME_ROOT", str(tmp_path / f"vol-{outcome or 'default'}"))
+        if outcome is not None:
+            monkeypatch.setenv("HSS_LOCAL_OUTCOME", outcome)
+        if delay is not None:
+            monkeypatch.setenv("HSS_LOCAL_STAGE_DELAY_S", str(delay))
+        settings = _settings(tmp_path, show_reject)
+        app = create_app(settings=settings)
+        client = TestClient(app)
+        client.headers["Authorization"] = f"Bearer {'d' * 40}"
+        return root, packet, client, app, app.state.deps
+
+    return build
+
+
+# --- the capture front door, as the journey tests walk it -------------------
+
+
+def _content_type(role: str) -> str:
+    if role == "stream":
+        return "application/gzip"
+    if role in {"features", "depth", "confidence", "mesh"}:
+        return "application/octet-stream"
+    return "image/jpeg"
+
+
+def _register_and_commit(root: Path, packet: dict, client: TestClient, app, capture_id: str) -> None:
+    registered_paths = []
+    for entry in packet["files"]:
+        data = (root / entry["path"]).read_bytes()
+        item = {
+            "path": entry["path"],
+            "bytes": len(data),
+            "sha256": hashlib.sha256(data).hexdigest(),
+            "md5": base64.b64encode(hashlib.md5(data).digest()).decode(),
+            "role": entry.get("role", "still"),
+            "contentType": _content_type(entry.get("role", "still")),
+        }
+        registered = client.post(f"/v1/captures/{capture_id}/files", json={"files": [item]})
+        assert registered.status_code == 200, registered.text
+        upload = registered.json()["files"][0]["upload"]
+        # The signed URL is its own capability: no bearer header on the PUT.
+        put = TestClient(app).put(upload["url"], content=data, headers=upload.get("headers") or {})
+        assert put.status_code == 200, put.text
+        registered_paths.append({"path": item["path"], "sha256": item["sha256"]})
+    commit = client.post(f"/v1/captures/{capture_id}/files:commit", json={"files": registered_paths})
+    assert commit.status_code == 200, commit.text
+
+
+def _open_front_door(root: Path, packet: dict, client: TestClient, app, packet_id: str) -> tuple[str, bytes]:
+    document = dict(packet)
+    document["packetId"] = packet_id
+    raw = (json.dumps(document, indent=2) + "\n").encode()
+    (root / "packet.json").write_bytes(raw)
+    session = packet["session"]
+    created = client.post(
+        "/v1/captures",
+        json={
+            "packetId": packet_id,
+            "formatVersion": packet["formatVersion"],
+            "tier": session["tier"],
+            "flow": "guided",
+            "device": {
+                "model": session["deviceModel"],
+                "systemVersion": session["systemVersion"],
+                "appVersion": session["appVersion"],
+            },
+        },
+        headers={"Idempotency-Key": packet_id},
+    )
+    assert created.status_code == 201, created.text
+    capture_id = created.json()["captureId"]
+    _register_and_commit(root, packet, client, app, capture_id)
+    return capture_id, raw
+
+
+def _run_capture(
+    root: Path, packet: dict, client: TestClient, app, packet_id: str
+) -> tuple[str, str, object]:
+    """Front door, finalize, drain; returns (capture_id, run_id, capture record)."""
+    capture_id, raw = _open_front_door(root, packet, client, app, packet_id)
+    response = client.post(
+        f"/v1/captures/{capture_id}/finalize",
+        content=raw,
+        headers={
+            "Idempotency-Key": packet_id,
+            "Content-Type": "application/json",
+            "X-Packet-Sha256": hashlib.sha256(raw).hexdigest(),
+        },
+    )
+    assert response.status_code == 202, response.text
+    drain_finalize(app.state.deps)
+    run_id = response.json()["runId"]
+    return capture_id, run_id, app.state.deps.state.get_capture(capture_id)
+
+
+def _flat(client: TestClient, capture_id: str) -> list[dict]:
+    """Walk the events cursor to quiescence, flattened in delivery order."""
+    events: list[dict] = []
+    after = 0
+    for _ in range(60):
+        page = client.get(f"/v1/captures/{capture_id}/events", params={"after": after}).json()
+        assert page["next"] >= after, "the events cursor moved backwards"
+        events.extend(page["events"])
+        if page["next"] == after:
+            return events
+        after = page["next"]
+    pytest.fail("event feed never stopped moving")
+
+
+# --- the states --------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "name,outcome,show_reject,status,kind",
+    STATES,
+    ids=[state[0] for state in STATES],
+)
+def test_hss_local_outcome_walks_the_app_to_each_state(
+    name: str, outcome: str, show_reject: bool, status: str, kind: str | None, local_app
+) -> None:
+    root, packet, client, app, deps = local_app(outcome, show_reject)
+    capture_id, run_id, capture = _run_capture(root, packet, client, app, f"local-{name}")
+
+    assert capture.status == status, f"HSS_LOCAL_OUTCOME={outcome} must land {status}"
+    served = client.get(f"/v1/captures/{capture_id}/result")
+    assert served.status_code == 200, served.text
+    payload = served.json()
+    # The device envelope stays contract-valid in every state.
+    ResultResponse.model_validate(payload)
+
+    run = deps.state.get_run(run_id)
+    review = deps.storage.get_bytes(run.artifacts["result/review.html"])
+    assert b"stand-in" in review
+    if kind is None:
+        # Row 1: the validate stub failed the run; nothing composes, nothing leaks.
+        assert payload["outcome"] is None
+        assert run.status == "failed"
+        return
+
+    assert payload["status"] == status
+    assert payload["outcome"]["kind"] == kind
+    events = _flat(client, capture_id)
+    final = events[-1]
+    assert final["type"] == ("retake_request" if outcome == "needs_more_photos" else "verdict_ready")
+
+    # Scripted outcomes always say they are stand-ins, on the device and off it.
+    assert "local test outcome" in payload["outcome"]["message"]
+    assert "This is a local test" in payload["outcome"]["message"]
+    assert b"HSS_LOCAL_OUTCOME" in review
+    internal = json.loads(deps.storage.get_bytes(run.artifacts["result/result.internal.json"]))
+    assert internal["scripted_outcome"] == outcome
+    assert "scripted_outcome" not in json.dumps(payload), "internal detail leaked to the device"
+
+    if outcome == "eligible":
+        placement = payload["outcome"]["recommendedPlacement"]
+        assert placement is not None
+        assert placement["footprintM"] == {"w": 0.7874, "h": 1.0033, "d": 0.5588}
+        assert placement["startSM"] == 0.3
+        # Proposed, not placed: the app words it as a proposal.
+        assert payload["outcome"]["arkitEpoch"]
+        assert placement["boxArkitWorld"]["pose"]
+        assert placement["boxArkitWorld"]["size"] == [0.7874, 1.0033, 0.5588]
+    if outcome == "needs_more_photos":
+        view = payload["viewsNeeded"][0]
+        assert view["kind"] == "band"
+        assert view["promptId"]
+        assert view["prompt"]["title"] and view["prompt"]["body"]
+        assert payload["outcome"]["viewsNeeded"] == payload["viewsNeeded"]
+
+
+def test_default_stub_run_keeps_todays_manual_review_bytes(local_app) -> None:
+    """Without the variable the stub run is exactly today's run."""
+    root, packet, client, app, deps = local_app(None, False)
+    capture_id, run_id, capture = _run_capture(root, packet, client, app, "local-default")
+    assert capture.status == "manual_review"
+    payload = client.get(f"/v1/captures/{capture_id}/result").json()
+    assert payload["status"] == "manual_review"
+    assert payload["outcome"]["kind"] == "manual_review"
+    assert payload["outcome"]["message"] == "Review required before a placement is shown."
+    assert payload["viewsNeeded"] == []
+    final = _flat(client, capture_id)[-1]
+    assert final["type"] == "verdict_ready"
+    assert final["data"]["kind"] == "manual_review"
+
+
+def test_not_eligible_without_show_reject_lands_manual_review_loudly(local_app) -> None:
+    """With the reject hidden, a scripted reject cannot land; the run fails loudly
+    with the variable to set, and the capture stays on the safe manual-review row."""
+    root, packet, client, app, deps = local_app("not_eligible", show_reject=False)
+    capture_id, run_id, capture = _run_capture(root, packet, client, app, "local-reject-hidden")
+    assert capture.status == "manual_review"
+    run = deps.state.get_run(run_id)
+    assert run.status == "failed"
+    assert "SHOW_REJECT_TO_HOMEOWNER" in str(getattr(run, "error", ""))
+
+
+def test_stage_delay_paces_the_stub_run(local_app) -> None:
+    root, packet, client, app, deps = local_app("manual_review", False, delay=0.03)
+    started = time.monotonic()
+    capture_id, run_id, capture = _run_capture(root, packet, client, app, "local-delay")
+    elapsed = time.monotonic() - started
+    assert capture.status == "manual_review"
+    # Every stub slept once; scheduling jitter stays inside the margin.
+    assert elapsed >= 12 * 0.03 - 0.05, f"12 stub stages slept nowhere near 0.36s ({elapsed:.2f}s)"
+
+
+# --- loud refusals -----------------------------------------------------------
+
+
+def test_local_outside_dev_stage_stubs_is_refused() -> None:
+    with pytest.raises(ValueError, match="HSS_LOCAL_OUTCOME"):
+        load_orch({"HSS_LOCAL_OUTCOME": "eligible"})
+    with pytest.raises(ValueError, match="HSS_LOCAL_STAGE_DELAY_S"):
+        load_orch({"SMP_ENVIRONMENT": "dev", "HSS_LOCAL_STAGE_DELAY_S": "1.5"})
+    with pytest.raises(ValueError, match="HSS_LOCAL_STAGE_DELAY_S"):
+        load_orch({"HSS_ORCH_STAGE_STUBS": "1", "SMP_ENVIRONMENT": "prod", "HSS_LOCAL_STAGE_DELAY_S": "1.5"})
+
+
+def test_local_unknown_outcome_value_is_refused() -> None:
+    with pytest.raises(ValueError, match="needs_more_photos"):
+        load_orch(
+            {
+                "HSS_ORCH_STAGE_STUBS": "1",
+                "SMP_ENVIRONMENT": "dev",
+                "HSS_LOCAL_OUTCOME": "bogus",
+            }
+        )
+
+
+def test_local_delay_out_of_range_is_refused() -> None:
+    with pytest.raises(ValueError, match="0 to 30"):
+        load_orch(
+            {
+                "HSS_ORCH_STAGE_STUBS": "1",
+                "SMP_ENVIRONMENT": "dev",
+                "HSS_LOCAL_STAGE_DELAY_S": "45",
+            }
+        )
+
+
+def test_local_settings_parse_when_dev_stage_stubs_are_on() -> None:
+    cfg = load_orch(
+        {
+            "HSS_ORCH_STAGE_STUBS": "1",
+            "SMP_ENVIRONMENT": "dev",
+            "HSS_LOCAL_OUTCOME": "needs_more_photos",
+            "HSS_LOCAL_STAGE_DELAY_S": "1.5",
+        }
+    )
+    assert cfg.local_outcome == "needs_more_photos"
+    assert cfg.local_stage_delay_s == 1.5
+    plain = load_orch({})
+    assert plain.local_outcome == "manual_review"
+    assert plain.local_stage_delay_s == 0.0
+
+
+def test_boot_refuses_a_stray_local_outcome(monkeypatch, tmp_path) -> None:
+    """Boot fails loudly naming the variable — never a silently ignored setting."""
+    monkeypatch.delenv("HSS_ORCH_STAGE_STUBS", raising=False)
+    monkeypatch.setenv("HSS_LOCAL_OUTCOME", "eligible")
+    monkeypatch.setenv("VOLUME_ROOT", str(tmp_path / "vol"))
+    with pytest.raises(ValueError, match="HSS_LOCAL_OUTCOME"):
+        create_app(settings=_settings(tmp_path, show_reject=False))
+
+
+# --- committed state fixtures ------------------------------------------------
+
+
+def test_committed_state_fixtures_match_the_outcome_table() -> None:
+    """The committed evidence still says what the outcome table says."""
+    directories = sorted(path for path in FIXTURES.iterdir() if path.is_dir())
+    assert {path.name for path in directories} == {state[0] for state in STATES}
+    for directory in directories:
+        doc = json.loads((directory / "events.json").read_text())
+        served = json.loads((directory / "result.json").read_text())
+        ResultResponse.model_validate(served)
+        verdict = doc["verdict"]
+        if verdict["decision"] == "validate_failed":
+            assert doc["captureStatus"] == "failed"
+        else:
+            assert capture_status(verdict["decision"], verdict["views"]) == doc["captureStatus"]
+        assert served["status"] == doc["captureStatus"]
+        if doc["outcomeKind"] is None:
+            assert served["outcome"] is None
+        else:
+            assert served["outcome"]["kind"] == doc["outcomeKind"]
+            assert "local test outcome" in served["outcome"]["message"]
+        assert doc["terminalEventKind"] in {"verdict_ready", "retake_request", "run_failed", "failed"}
+
+
+def _generate() -> None:
+    """Regenerate the committed state fixtures. Run: uv run python tests/test_local_outcome_states.py --generate"""
+    work = Path(tempfile.mkdtemp(prefix="hss-state-fixtures-"))
+    keys = list(TEMPLATE_ENV) + ["VOLUME_ROOT", "HSS_LOCAL_OUTCOME", "HSS_LOCAL_STAGE_DELAY_S"]
+    saved = {key: os.environ.get(key) for key in keys}
+    try:
+        for name, outcome, show_reject, _status, _kind in STATES:
+            root = work / f"packet-{name}"
+            shutil.copytree(PACKET_FIXTURE, root)
+            packet = json.loads((root / "packet.json").read_text())
+            for key, value in TEMPLATE_ENV.items():
+                os.environ[key] = value
+            os.environ["VOLUME_ROOT"] = str(work / f"vol-{name}")
+            os.environ.pop("HSS_LOCAL_STAGE_DELAY_S", None)
+            if outcome is not None:
+                os.environ["HSS_LOCAL_OUTCOME"] = outcome
+            else:
+                os.environ.pop("HSS_LOCAL_OUTCOME", None)
+            app = create_app(settings=_settings(work, show_reject))
+            client = TestClient(app)
+            client.headers["Authorization"] = f"Bearer {'d' * 40}"
+            capture_id, run_id, capture = _run_capture(root, packet, client, app, f"fixture-{name}")
+            served = client.get(f"/v1/captures/{capture_id}/result").json()
+            deps = app.state.deps
+            run = deps.state.get_run(run_id)
+            if capture.status == "failed":
+                verdict = {"decision": "validate_failed", "views": 0}
+            else:
+                doc = json.loads(deps.storage.get_bytes(run.artifacts["verdicts/verdict.C.json"]))
+                verdict = {
+                    "decision": doc["site"]["decision"],
+                    "views": len(doc.get("views_needed") or []),
+                }
+            final = _flat(client, capture_id)[-1]
+            out = FIXTURES / name
+            out.mkdir(parents=True, exist_ok=True)
+            (out / "result.json").write_text(json.dumps(served, indent=2, sort_keys=True) + "\n")
+            (out / "events.json").write_text(
+                json.dumps(
+                    {
+                        "captureStatus": capture.status,
+                        "outcomeKind": (served.get("outcome") or {}).get("kind"),
+                        "terminalEventKind": final["type"],
+                        "verdict": verdict,
+                        "events": _flat(client, capture_id),
+                    },
+                    indent=2,
+                    sort_keys=True,
+                )
+                + "\n"
+            )
+            print(f"wrote {out} (capture {capture_id}, status {capture.status})")
+    finally:
+        for key, value in saved.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+        shutil.rmtree(work, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    import sys
+
+    if "--generate" in sys.argv:
+        _generate()
+    else:
+        print("usage: python tests/test_local_outcome_states.py --generate")

From 4f906370c35a4e241796c1e73028f8847d67835c Mon Sep 17 00:00:00 2001
From: Obvious <obvious@obvious.ai>
Date: Fri, 16 Oct 2026 10:19:20 +0000
Subject: [PATCH 17/20] test(backend): pin local-outcome contracts end to end
 and commit app-state fixtures

Walk every HSS_LOCAL_OUTCOME state through the real API front door and
commit the served payloads plus event streams as fixtures, validated
against the orchestrator outcome table on every run.

- config: keep OrchConfig field declarations in place (lost in an edit race)
- stubs: restore scripted_outcome helpers in _common; terminal-event
  selection and fixture regeneration fixes in the test module
- fixtures: one directory per rendered state (manual_review, eligible,
  needs_more_photos, not_eligible, failed) with result.json + events.json
- README: correct where not-eligible refusal and setting validation happen

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/server/orchestrator/README.md         |   4 +-
 backend/server/orchestrator/config.py         |   4 +
 backend/server/orchestrator/stubs/_common.py  |  36 ++
 backend/server/orchestrator/stubs/criteria.py |   8 +-
 backend/server/orchestrator/stubs/result.py   |   5 +-
 .../fixtures/app_states/eligible/events.json  | 386 ++++++++++++++++++
 .../fixtures/app_states/eligible/result.json  |  57 +++
 .../fixtures/app_states/failed/events.json    | 139 +++++++
 .../fixtures/app_states/failed/result.json    |  31 ++
 .../app_states/manual_review/events.json      | 386 ++++++++++++++++++
 .../app_states/manual_review/result.json      |  33 ++
 .../app_states/needs_more_photos/events.json  | 386 ++++++++++++++++++
 .../app_states/needs_more_photos/result.json  |  93 +++++
 .../app_states/not_eligible/events.json       | 386 ++++++++++++++++++
 .../app_states/not_eligible/result.json       |  33 ++
 backend/tests/test_local_outcome_states.py    | 156 +++++--
 16 files changed, 2098 insertions(+), 45 deletions(-)
 create mode 100644 backend/tests/fixtures/app_states/eligible/events.json
 create mode 100644 backend/tests/fixtures/app_states/eligible/result.json
 create mode 100644 backend/tests/fixtures/app_states/failed/events.json
 create mode 100644 backend/tests/fixtures/app_states/failed/result.json
 create mode 100644 backend/tests/fixtures/app_states/manual_review/events.json
 create mode 100644 backend/tests/fixtures/app_states/manual_review/result.json
 create mode 100644 backend/tests/fixtures/app_states/needs_more_photos/events.json
 create mode 100644 backend/tests/fixtures/app_states/needs_more_photos/result.json
 create mode 100644 backend/tests/fixtures/app_states/not_eligible/events.json
 create mode 100644 backend/tests/fixtures/app_states/not_eligible/result.json

diff --git a/backend/server/orchestrator/README.md b/backend/server/orchestrator/README.md
index d6c04b762..99f80c1e1 100644
--- a/backend/server/orchestrator/README.md
+++ b/backend/server/orchestrator/README.md
@@ -44,7 +44,7 @@ With stage stubs on and `SMP_ENVIRONMENT=dev`, `HSS_LOCAL_OUTCOME` scripts the t
 | unset / `manual_review` (default) | `manual_review` | Today's stub run, byte-identical. |
 | `eligible` | `complete` | Result carries a proposed placement (`boxArkitWorld` + `arkitEpoch` when the packet has one), worded as proposed. |
 | `needs_more_photos` | `needs_views` | One scripted band view; the app sends a retake request. |
-| `not_eligible` | `complete` | Needs `SHOW_REJECT_TO_HOMEOWNER=1`; without it the boot refuses. |
+| `not_eligible` | `complete` | Needs `SHOW_REJECT_TO_HOMEOWNER=1`; without it the criteria stub refuses and the run fails loudly, leaving the capture on `manual_review`. |
 | `failed` | `failed` | The validate stub fails the run onto outcome row 1 (validation stand-in `imagesUsable: false`). |
 
-Scripted messages and review pages always say it is a local test outcome, not a check of a wall. `HSS_LOCAL_STAGE_DELAY_S` (float, 0–30, default 0) makes each stub sleep so the app shows processing events. Both variables are refused loudly — at boot with an error naming the variable — when stage stubs are off, the environment is not dev, the value is unknown, or the number is out of range. A run keeps its scripted behavior across restart while the variables stay set.
+Scripted messages and review pages always say it is a local test outcome, not a check of a wall. `HSS_LOCAL_STAGE_DELAY_S` (float, 0–30, default 0) makes each stub sleep so the app shows processing events. Both variables are refused loudly — with an error naming the variable, at config load — when stage stubs are off, the environment is not dev, the value is unknown, or the number is out of range. A run keeps its scripted behavior across restart while the variables stay set.
diff --git a/backend/server/orchestrator/config.py b/backend/server/orchestrator/config.py
index 4b5a55d02..97be6c0f5 100644
--- a/backend/server/orchestrator/config.py
+++ b/backend/server/orchestrator/config.py
@@ -84,6 +84,10 @@ class OrchConfig(BaseModel):
     # cancels a live worker within 15s of the deadline.
     coordinator_loop_s: float = 1
     modal_remote: bool = False
+    # Dev-only scripted outcome for the stage stubs; see the README's Stubs
+    # section. Both are refused loudly outside dev stage stubs.
+    local_outcome: str = "manual_review"
+    local_stage_delay_s: float = 0.0
 
 
 def load_orch(environ: dict[str, str] | None = None) -> OrchConfig:
diff --git a/backend/server/orchestrator/stubs/_common.py b/backend/server/orchestrator/stubs/_common.py
index fd14344d1..0e1230701 100644
--- a/backend/server/orchestrator/stubs/_common.py
+++ b/backend/server/orchestrator/stubs/_common.py
@@ -125,5 +125,41 @@ def sha256(data: bytes) -> str:
     return hashlib.sha256(data).hexdigest()
 
 
+def scripted_outcome() -> str:
+    """The dev-only scripted terminal state, or the default manual_review."""
+    return load_orch().local_outcome
+
+
+_SCRIPTED_VIEW = {
+    "id": "stub-wall-band",
+    "kind": "band",
+    "criteria": ["stub"],
+    "why": "Local test stand-in: this retake request is scripted, not measured.",
+    "band": "wall",
+    "wall_id": "w1",
+}
+
+
+def scripted_verdict(profile: str, scene_id: str, outcome: str) -> dict:
+    """The stub verdict for a scripted local outcome (dev + stage stubs only).
+
+    Changes only the site decision and views_needed, so the outcome table's
+    rows 11-14 land the capture on the chosen state. manual_review keeps the
+    plain stub document byte-identical, and failed never reaches criteria
+    (the validate stub ends the run on row 1).
+    """
+    verdict = verdict_document(profile, scene_id)
+    if outcome == "eligible":
+        verdict["site"]["decision"] = "pass"
+        verdict["site"]["reasons"] = ["scripted:eligible"]
+    elif outcome == "not_eligible":
+        verdict["site"]["decision"] = "reject"
+        verdict["site"]["reasons"] = ["scripted:not_eligible"]
+    elif outcome == "needs_more_photos":
+        verdict["site"]["reasons"] = ["scripted:needs_more_photos"]
+        verdict["views_needed"] = [dict(_SCRIPTED_VIEW)]
+    return verdict
+
+
 def repo_root() -> Path:
     return Path(__file__).resolve().parents[3]
diff --git a/backend/server/orchestrator/stubs/criteria.py b/backend/server/orchestrator/stubs/criteria.py
index be196409f..25697a9e3 100644
--- a/backend/server/orchestrator/stubs/criteria.py
+++ b/backend/server/orchestrator/stubs/criteria.py
@@ -9,7 +9,13 @@
 
 from server.contracts.jobs import StageContext, StageResult
 from server.eval.sceneio import schema_errors
-from server.orchestrator.stubs._common import json_bytes, scripted_outcome, scripted_verdict, verdict_document, write_files
+from server.orchestrator.stubs._common import (
+    json_bytes,
+    scripted_outcome,
+    scripted_verdict,
+    verdict_document,
+    write_files,
+)
 
 
 def run(ctx: StageContext) -> StageResult:
diff --git a/backend/server/orchestrator/stubs/result.py b/backend/server/orchestrator/stubs/result.py
index 7916a287f..8e0d54714 100644
--- a/backend/server/orchestrator/stubs/result.py
+++ b/backend/server/orchestrator/stubs/result.py
@@ -26,7 +26,6 @@
     ResultResponse,
     ViewNeededDevice,
 )
-from server.orchestrator.config import load_orch
 from server.orchestrator.stubs._common import json_bytes, scripted_outcome, sha256, write_files
 from server.result import ar
 from server.result.copy import FALLBACK, Catalogue, load_catalogue, render, select_prompt
@@ -67,9 +66,7 @@
 def run(ctx: StageContext) -> StageResult:
     outcome = scripted_outcome()
     if outcome == "failed":
-        raise RuntimeError(
-            "HSS_LOCAL_OUTCOME=failed must end the run at validate; the result stage should not run"
-        )
+        raise RuntimeError("HSS_LOCAL_OUTCOME=failed must end the run at validate; the result stage should not run")
     if outcome == "not_eligible" and not getattr(ctx.settings, "SHOW_REJECT_TO_HOMEOWNER", False):
         raise RuntimeError(
             "HSS_LOCAL_OUTCOME=not_eligible needs SHOW_REJECT_TO_HOMEOWNER=1; "
diff --git a/backend/tests/fixtures/app_states/eligible/events.json b/backend/tests/fixtures/app_states/eligible/events.json
new file mode 100644
index 000000000..4d498bf47
--- /dev/null
+++ b/backend/tests/fixtures/app_states/eligible/events.json
@@ -0,0 +1,386 @@
+{
+  "captureStatus": "complete",
+  "events": [
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "committed": 11,
+        "listed": null,
+        "paths": [
+          "keyframes/k00001.features.bin",
+          "keyframes/k00001.jpg",
+          "keyframes/k00002.features.bin",
+          "keyframes/k00002.jpg",
+          "keyframes/k00003.jpg",
+          "keyframes/k00004.jpg",
+          "streams/arkit_poses.csv.gz",
+          "streams/heading.csv.gz",
+          "streams/imu_raw.csv.gz",
+          "streams/location.csv.gz",
+          "streams/motion.csv.gz"
+        ]
+      },
+      "seq": 1,
+      "type": "files_committed"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "code": "frames_blurry",
+        "frames": [
+          "keyframes/k00003.jpg"
+        ],
+        "message": "Several frames in a row look blurry."
+      },
+      "seq": 2,
+      "type": "hint"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "complete": true,
+        "meterRead": "absent",
+        "missing": []
+      },
+      "seq": 3,
+      "type": "capture_check"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": null,
+        "errorCode": null,
+        "gpu": null,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 4,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 0,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "validate",
+        "status": "pending"
+      },
+      "seq": 5,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "complete": false,
+        "meterRead": "absent",
+        "missing": [
+          "panel_close",
+          "panel_open",
+          "main_disconnect",
+          "meter_tap"
+        ]
+      },
+      "seq": 6,
+      "type": "capture_check"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 7,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "validate",
+        "status": "done"
+      },
+      "seq": 8,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "poses",
+        "status": "running"
+      },
+      "seq": 9,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "objects",
+        "status": "running"
+      },
+      "seq": 10,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "reads",
+        "status": "running"
+      },
+      "seq": 11,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "objects",
+        "status": "done"
+      },
+      "seq": 12,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "poses",
+        "status": "done"
+      },
+      "seq": 13,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "reads",
+        "status": "done"
+      },
+      "seq": 14,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "scale",
+        "status": "running"
+      },
+      "seq": 15,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "scale",
+        "status": "done"
+      },
+      "seq": 16,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "dense",
+        "status": "running"
+      },
+      "seq": 17,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "dense",
+        "status": "done"
+      },
+      "seq": 18,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "coverage",
+        "status": "running"
+      },
+      "seq": 19,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "coverage",
+        "status": "done"
+      },
+      "seq": 20,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "scene",
+        "status": "running"
+      },
+      "seq": 21,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "scene",
+        "status": "done"
+      },
+      "seq": 22,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "objects_3d",
+        "status": "running"
+      },
+      "seq": 23,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "objects_3d",
+        "status": "done"
+      },
+      "seq": 24,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "placement",
+        "status": "running"
+      },
+      "seq": 25,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "criteria",
+        "status": "running"
+      },
+      "seq": 26,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "criteria",
+        "status": "done"
+      },
+      "seq": 27,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.0,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "placement",
+        "status": "done"
+      },
+      "seq": 28,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "result",
+        "status": "running"
+      },
+      "seq": 29,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "kind": "eligible",
+        "runId": "run_0efe512c502a5f3b"
+      },
+      "seq": 30,
+      "type": "verdict_ready"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_0efe512c502a5f3b",
+        "stage": "result",
+        "status": "done"
+      },
+      "seq": 31,
+      "type": "stage"
+    }
+  ],
+  "outcomeKind": "eligible",
+  "terminalEventKind": "verdict_ready",
+  "verdict": {
+    "decision": "pass",
+    "views": 0
+  }
+}
diff --git a/backend/tests/fixtures/app_states/eligible/result.json b/backend/tests/fixtures/app_states/eligible/result.json
new file mode 100644
index 000000000..2bb00889f
--- /dev/null
+++ b/backend/tests/fixtures/app_states/eligible/result.json
@@ -0,0 +1,57 @@
+{
+  "criteria": null,
+  "memberActions": [],
+  "meter": {
+    "barcodeConfirmed": false,
+    "candidates": [],
+    "clean": false,
+    "evidence": null,
+    "readersAgree": false,
+    "status": "not_captured",
+    "value": null
+  },
+  "outcome": {
+    "arkitEpoch": null,
+    "cableRoutePolylineArkit": null,
+    "frameToArkit": null,
+    "kind": "eligible",
+    "message": "Local test stand-in: the proposed placement is scripted, not measured. This is a local test outcome, not a check of a wall.",
+    "profile": "C",
+    "reasons": [],
+    "recommendedPlacement": {
+      "boxArkitWorld": null,
+      "boxSceneM": {
+        "centerM": [
+          0.6937,
+          0.50165,
+          0.2994
+        ],
+        "sizeM": [
+          0.7874,
+          1.0033,
+          0.5588
+        ],
+        "yawDeg": 0.0
+      },
+      "confidence": 0.5,
+      "footprintM": {
+        "d": 0.5588,
+        "h": 1.0033,
+        "w": 0.7874
+      },
+      "profile": "C",
+      "startSM": 0.3,
+      "wallId": "w1"
+    },
+    "viewsNeeded": []
+  },
+  "previewUrl": "http://testserver/v1/uploads/eyJjdCI6IiIsImV4cCI6MTc5MjE0NDY4Miwia2V5IjoiY2FwdHVyZXMvY2FwXzAxTTUyMUZXUEZTTUJCWjVQQ0dFS1pYRDA1L3J1bnMvcnVuXzBlZmU1MTJjNTAyYTVmM2IvcmVzdWx0L3ByZXZpZXcucGx5IiwibWQ1IjoiIiwib3AiOiJnZXQifQ.46c8a0df6373617e682be7f977ca2f1a94ec89e5d121540abe38748ff5ce51a2",
+  "reviewUrl": "/v1/captures/cap_01M521FWPFSMBBZ5PCGEKZXD05/review",
+  "runId": "run_0efe512c502a5f3b",
+  "scale": null,
+  "site": null,
+  "status": "complete",
+  "verdict": null,
+  "verdictUrl": null,
+  "viewsNeeded": []
+}
diff --git a/backend/tests/fixtures/app_states/failed/events.json b/backend/tests/fixtures/app_states/failed/events.json
new file mode 100644
index 000000000..fb8e0075d
--- /dev/null
+++ b/backend/tests/fixtures/app_states/failed/events.json
@@ -0,0 +1,139 @@
+{
+  "captureStatus": "failed",
+  "events": [
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "committed": 11,
+        "listed": null,
+        "paths": [
+          "keyframes/k00001.features.bin",
+          "keyframes/k00001.jpg",
+          "keyframes/k00002.features.bin",
+          "keyframes/k00002.jpg",
+          "keyframes/k00003.jpg",
+          "keyframes/k00004.jpg",
+          "streams/arkit_poses.csv.gz",
+          "streams/heading.csv.gz",
+          "streams/imu_raw.csv.gz",
+          "streams/location.csv.gz",
+          "streams/motion.csv.gz"
+        ]
+      },
+      "seq": 1,
+      "type": "files_committed"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "code": "frames_blurry",
+        "frames": [
+          "keyframes/k00003.jpg"
+        ],
+        "message": "Several frames in a row look blurry."
+      },
+      "seq": 2,
+      "type": "hint"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "complete": true,
+        "meterRead": "absent",
+        "missing": []
+      },
+      "seq": 3,
+      "type": "capture_check"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": null,
+        "errorCode": null,
+        "gpu": null,
+        "runId": "run_927815ea44260bbf",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 4,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 0,
+        "runId": "run_927815ea44260bbf",
+        "stage": "validate",
+        "status": "pending"
+      },
+      "seq": 5,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "complete": false,
+        "meterRead": "absent",
+        "missing": [
+          "panel_close",
+          "panel_open",
+          "main_disconnect",
+          "meter_tap"
+        ]
+      },
+      "seq": 6,
+      "type": "capture_check"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_927815ea44260bbf",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 7,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 2,
+        "runId": "run_927815ea44260bbf",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 8,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 2,
+        "errorCode": "local_scripted_failure",
+        "runId": "run_927815ea44260bbf",
+        "stage": "validate",
+        "status": "failed"
+      },
+      "seq": 9,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "code": "packet_invalid",
+        "message": "HSS_LOCAL_OUTCOME=failed ends the run on outcome row 1 (validate failed, images unusable)",
+        "next": "none"
+      },
+      "seq": 10,
+      "type": "failed"
+    }
+  ],
+  "outcomeKind": "manual_review",
+  "terminalEventKind": "failed",
+  "verdict": {
+    "decision": "validate_failed",
+    "views": 0
+  }
+}
diff --git a/backend/tests/fixtures/app_states/failed/result.json b/backend/tests/fixtures/app_states/failed/result.json
new file mode 100644
index 000000000..d5c570c3d
--- /dev/null
+++ b/backend/tests/fixtures/app_states/failed/result.json
@@ -0,0 +1,31 @@
+{
+  "criteria": null,
+  "memberActions": [],
+  "meter": null,
+  "outcome": {
+    "arkitEpoch": null,
+    "cableRoutePolylineArkit": null,
+    "frameToArkit": null,
+    "kind": "manual_review",
+    "message": "packet_invalid",
+    "profile": "C",
+    "reasons": [],
+    "recommendedPlacement": null,
+    "viewsNeeded": []
+  },
+  "previewUrl": null,
+  "reviewUrl": "/v1/captures/cap_01M521FXP3590453444NBF5AQF/review",
+  "runId": "run_927815ea44260bbf",
+  "scale": null,
+  "site": {
+    "decision": "manual_review",
+    "profile": "C",
+    "reasons": [
+      "packet_invalid"
+    ]
+  },
+  "status": "failed",
+  "verdict": null,
+  "verdictUrl": null,
+  "viewsNeeded": []
+}
diff --git a/backend/tests/fixtures/app_states/manual_review/events.json b/backend/tests/fixtures/app_states/manual_review/events.json
new file mode 100644
index 000000000..f9cc870fa
--- /dev/null
+++ b/backend/tests/fixtures/app_states/manual_review/events.json
@@ -0,0 +1,386 @@
+{
+  "captureStatus": "manual_review",
+  "events": [
+    {
+      "at": "2026-10-16T09:43:01Z",
+      "data": {
+        "committed": 11,
+        "listed": null,
+        "paths": [
+          "keyframes/k00001.features.bin",
+          "keyframes/k00001.jpg",
+          "keyframes/k00002.features.bin",
+          "keyframes/k00002.jpg",
+          "keyframes/k00003.jpg",
+          "keyframes/k00004.jpg",
+          "streams/arkit_poses.csv.gz",
+          "streams/heading.csv.gz",
+          "streams/imu_raw.csv.gz",
+          "streams/location.csv.gz",
+          "streams/motion.csv.gz"
+        ]
+      },
+      "seq": 1,
+      "type": "files_committed"
+    },
+    {
+      "at": "2026-10-16T09:43:01Z",
+      "data": {
+        "code": "frames_blurry",
+        "frames": [
+          "keyframes/k00003.jpg"
+        ],
+        "message": "Several frames in a row look blurry."
+      },
+      "seq": 2,
+      "type": "hint"
+    },
+    {
+      "at": "2026-10-16T09:43:01Z",
+      "data": {
+        "complete": true,
+        "meterRead": "absent",
+        "missing": []
+      },
+      "seq": 3,
+      "type": "capture_check"
+    },
+    {
+      "at": "2026-10-16T09:43:01Z",
+      "data": {
+        "attempt": 1,
+        "durationS": null,
+        "errorCode": null,
+        "gpu": null,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 4,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 0,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "validate",
+        "status": "pending"
+      },
+      "seq": 5,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "complete": false,
+        "meterRead": "absent",
+        "missing": [
+          "panel_close",
+          "panel_open",
+          "main_disconnect",
+          "meter_tap"
+        ]
+      },
+      "seq": 6,
+      "type": "capture_check"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 7,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "validate",
+        "status": "done"
+      },
+      "seq": 8,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "poses",
+        "status": "running"
+      },
+      "seq": 9,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "objects",
+        "status": "running"
+      },
+      "seq": 10,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "reads",
+        "status": "running"
+      },
+      "seq": 11,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "objects",
+        "status": "done"
+      },
+      "seq": 12,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "poses",
+        "status": "done"
+      },
+      "seq": 13,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "reads",
+        "status": "done"
+      },
+      "seq": 14,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "scale",
+        "status": "running"
+      },
+      "seq": 15,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "scale",
+        "status": "done"
+      },
+      "seq": 16,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "dense",
+        "status": "running"
+      },
+      "seq": 17,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "dense",
+        "status": "done"
+      },
+      "seq": 18,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "coverage",
+        "status": "running"
+      },
+      "seq": 19,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "coverage",
+        "status": "done"
+      },
+      "seq": 20,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "scene",
+        "status": "running"
+      },
+      "seq": 21,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "scene",
+        "status": "done"
+      },
+      "seq": 22,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "objects_3d",
+        "status": "running"
+      },
+      "seq": 23,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "objects_3d",
+        "status": "done"
+      },
+      "seq": 24,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "placement",
+        "status": "running"
+      },
+      "seq": 25,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "criteria",
+        "status": "running"
+      },
+      "seq": 26,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "criteria",
+        "status": "done"
+      },
+      "seq": 27,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.0,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "placement",
+        "status": "done"
+      },
+      "seq": 28,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "result",
+        "status": "running"
+      },
+      "seq": 29,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "kind": "manual_review",
+        "runId": "run_1e16b0f7be5c5da8"
+      },
+      "seq": 30,
+      "type": "verdict_ready"
+    },
+    {
+      "at": "2026-10-16T09:43:02Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_1e16b0f7be5c5da8",
+        "stage": "result",
+        "status": "done"
+      },
+      "seq": 31,
+      "type": "stage"
+    }
+  ],
+  "outcomeKind": "manual_review",
+  "terminalEventKind": "verdict_ready",
+  "verdict": {
+    "decision": "manual_review",
+    "views": 0
+  }
+}
diff --git a/backend/tests/fixtures/app_states/manual_review/result.json b/backend/tests/fixtures/app_states/manual_review/result.json
new file mode 100644
index 000000000..bf80ae688
--- /dev/null
+++ b/backend/tests/fixtures/app_states/manual_review/result.json
@@ -0,0 +1,33 @@
+{
+  "criteria": null,
+  "memberActions": [],
+  "meter": {
+    "barcodeConfirmed": false,
+    "candidates": [],
+    "clean": false,
+    "evidence": null,
+    "readersAgree": false,
+    "status": "not_captured",
+    "value": null
+  },
+  "outcome": {
+    "arkitEpoch": null,
+    "cableRoutePolylineArkit": null,
+    "frameToArkit": null,
+    "kind": "manual_review",
+    "message": "Review required before a placement is shown.",
+    "profile": "C",
+    "reasons": [],
+    "recommendedPlacement": null,
+    "viewsNeeded": []
+  },
+  "previewUrl": "http://testserver/v1/uploads/eyJjdCI6IiIsImV4cCI6MTc5MjE0NDY4Miwia2V5IjoiY2FwdHVyZXMvY2FwXzAxTTUyMUZXMDlZU0dUWkdGRFo2UU1NRlozL3J1bnMvcnVuXzFlMTZiMGY3YmU1YzVkYTgvcmVzdWx0L3ByZXZpZXcucGx5IiwibWQ1IjoiIiwib3AiOiJnZXQifQ.53340a965238d5c0a7026dff1a1850a3d27b1ea5c846922075f0ef675bc1e43d",
+  "reviewUrl": "/v1/captures/cap_01M521FW09YSGTZGFDZ6QMMFZ3/review",
+  "runId": "run_1e16b0f7be5c5da8",
+  "scale": null,
+  "site": null,
+  "status": "manual_review",
+  "verdict": null,
+  "verdictUrl": null,
+  "viewsNeeded": []
+}
diff --git a/backend/tests/fixtures/app_states/needs_more_photos/events.json b/backend/tests/fixtures/app_states/needs_more_photos/events.json
new file mode 100644
index 000000000..638399071
--- /dev/null
+++ b/backend/tests/fixtures/app_states/needs_more_photos/events.json
@@ -0,0 +1,386 @@
+{
+  "captureStatus": "needs_views",
+  "events": [
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "committed": 11,
+        "listed": null,
+        "paths": [
+          "keyframes/k00001.features.bin",
+          "keyframes/k00001.jpg",
+          "keyframes/k00002.features.bin",
+          "keyframes/k00002.jpg",
+          "keyframes/k00003.jpg",
+          "keyframes/k00004.jpg",
+          "streams/arkit_poses.csv.gz",
+          "streams/heading.csv.gz",
+          "streams/imu_raw.csv.gz",
+          "streams/location.csv.gz",
+          "streams/motion.csv.gz"
+        ]
+      },
+      "seq": 1,
+      "type": "files_committed"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "code": "frames_blurry",
+        "frames": [
+          "keyframes/k00003.jpg"
+        ],
+        "message": "Several frames in a row look blurry."
+      },
+      "seq": 2,
+      "type": "hint"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "complete": true,
+        "meterRead": "absent",
+        "missing": []
+      },
+      "seq": 3,
+      "type": "capture_check"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": null,
+        "errorCode": null,
+        "gpu": null,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 4,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 0,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "validate",
+        "status": "pending"
+      },
+      "seq": 5,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "complete": false,
+        "meterRead": "absent",
+        "missing": [
+          "panel_close",
+          "panel_open",
+          "main_disconnect",
+          "meter_tap"
+        ]
+      },
+      "seq": 6,
+      "type": "capture_check"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 7,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "validate",
+        "status": "done"
+      },
+      "seq": 8,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "poses",
+        "status": "running"
+      },
+      "seq": 9,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "objects",
+        "status": "running"
+      },
+      "seq": 10,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "reads",
+        "status": "running"
+      },
+      "seq": 11,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "objects",
+        "status": "done"
+      },
+      "seq": 12,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "poses",
+        "status": "done"
+      },
+      "seq": 13,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "reads",
+        "status": "done"
+      },
+      "seq": 14,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "scale",
+        "status": "running"
+      },
+      "seq": 15,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "scale",
+        "status": "done"
+      },
+      "seq": 16,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "dense",
+        "status": "running"
+      },
+      "seq": 17,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "dense",
+        "status": "done"
+      },
+      "seq": 18,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "coverage",
+        "status": "running"
+      },
+      "seq": 19,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "coverage",
+        "status": "done"
+      },
+      "seq": 20,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "scene",
+        "status": "running"
+      },
+      "seq": 21,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "scene",
+        "status": "done"
+      },
+      "seq": 22,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "objects_3d",
+        "status": "running"
+      },
+      "seq": 23,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "objects_3d",
+        "status": "done"
+      },
+      "seq": 24,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "placement",
+        "status": "running"
+      },
+      "seq": 25,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "criteria",
+        "status": "running"
+      },
+      "seq": 26,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "criteria",
+        "status": "done"
+      },
+      "seq": 27,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.0,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "placement",
+        "status": "done"
+      },
+      "seq": 28,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "result",
+        "status": "running"
+      },
+      "seq": 29,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "kind": "needs_more_photos",
+        "runId": "run_b7d01d96e42e7812"
+      },
+      "seq": 30,
+      "type": "verdict_ready"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_b7d01d96e42e7812",
+        "stage": "result",
+        "status": "done"
+      },
+      "seq": 31,
+      "type": "stage"
+    }
+  ],
+  "outcomeKind": "needs_more_photos",
+  "terminalEventKind": "verdict_ready",
+  "verdict": {
+    "decision": "manual_review",
+    "views": 1
+  }
+}
diff --git a/backend/tests/fixtures/app_states/needs_more_photos/result.json b/backend/tests/fixtures/app_states/needs_more_photos/result.json
new file mode 100644
index 000000000..7e8e73c02
--- /dev/null
+++ b/backend/tests/fixtures/app_states/needs_more_photos/result.json
@@ -0,0 +1,93 @@
+{
+  "criteria": null,
+  "memberActions": [],
+  "meter": {
+    "barcodeConfirmed": false,
+    "candidates": [],
+    "clean": false,
+    "evidence": null,
+    "readersAgree": false,
+    "status": "not_captured",
+    "value": null
+  },
+  "outcome": {
+    "arkitEpoch": null,
+    "cableRoutePolylineArkit": null,
+    "frameToArkit": null,
+    "kind": "needs_more_photos",
+    "message": "Local test stand-in: the retake request is scripted, not measured. This is a local test outcome, not a check of a wall.",
+    "profile": "C",
+    "reasons": [],
+    "recommendedPlacement": null,
+    "viewsNeeded": [
+      {
+        "band": "wall",
+        "criteria": [
+          "stub"
+        ],
+        "id": "stub-wall-band",
+        "kind": "band",
+        "outM": null,
+        "prompt": {
+          "body": "Stand 8\u201312 ft back from the wall left, 7 ft along, face it squarely and take a photo.",
+          "title": "One more wall photo"
+        },
+        "promptId": "vn.wall.unobserved",
+        "referenceCrop": null,
+        "sM": [
+          0.2,
+          1.0
+        ],
+        "side": "left",
+        "suggestedCameraPoseArkit": null,
+        "target": null,
+        "targetRegionArkit": null,
+        "viewingAngleDeg": [
+          0,
+          30
+        ],
+        "wallId": "w1",
+        "why": "Local test stand-in: this retake request is scripted, not measured."
+      }
+    ]
+  },
+  "previewUrl": "http://testserver/v1/uploads/eyJjdCI6IiIsImV4cCI6MTc5MjE0NDY4Mywia2V5IjoiY2FwdHVyZXMvY2FwXzAxTTUyMUZYMFlZWE5HUlBWQVFITUZYNEZLL3J1bnMvcnVuX2I3ZDAxZDk2ZTQyZTc4MTIvcmVzdWx0L3ByZXZpZXcucGx5IiwibWQ1IjoiIiwib3AiOiJnZXQifQ.35dcaa965488d0774d4d9f6f270394319ac7df1726f68ce6bd2afdcd14c63a00",
+  "reviewUrl": "/v1/captures/cap_01M521FX0YYXNGRPVAQHMFX4FK/review",
+  "runId": "run_b7d01d96e42e7812",
+  "scale": null,
+  "site": null,
+  "status": "needs_views",
+  "verdict": null,
+  "verdictUrl": null,
+  "viewsNeeded": [
+    {
+      "band": "wall",
+      "criteria": [
+        "stub"
+      ],
+      "id": "stub-wall-band",
+      "kind": "band",
+      "outM": null,
+      "prompt": {
+        "body": "Stand 8\u201312 ft back from the wall left, 7 ft along, face it squarely and take a photo.",
+        "title": "One more wall photo"
+      },
+      "promptId": "vn.wall.unobserved",
+      "referenceCrop": null,
+      "sM": [
+        0.2,
+        1.0
+      ],
+      "side": "left",
+      "suggestedCameraPoseArkit": null,
+      "target": null,
+      "targetRegionArkit": null,
+      "viewingAngleDeg": [
+        0,
+        30
+      ],
+      "wallId": "w1",
+      "why": "Local test stand-in: this retake request is scripted, not measured."
+    }
+  ]
+}
diff --git a/backend/tests/fixtures/app_states/not_eligible/events.json b/backend/tests/fixtures/app_states/not_eligible/events.json
new file mode 100644
index 000000000..c3bfa629d
--- /dev/null
+++ b/backend/tests/fixtures/app_states/not_eligible/events.json
@@ -0,0 +1,386 @@
+{
+  "captureStatus": "complete",
+  "events": [
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "committed": 11,
+        "listed": null,
+        "paths": [
+          "keyframes/k00001.features.bin",
+          "keyframes/k00001.jpg",
+          "keyframes/k00002.features.bin",
+          "keyframes/k00002.jpg",
+          "keyframes/k00003.jpg",
+          "keyframes/k00004.jpg",
+          "streams/arkit_poses.csv.gz",
+          "streams/heading.csv.gz",
+          "streams/imu_raw.csv.gz",
+          "streams/location.csv.gz",
+          "streams/motion.csv.gz"
+        ]
+      },
+      "seq": 1,
+      "type": "files_committed"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "code": "frames_blurry",
+        "frames": [
+          "keyframes/k00003.jpg"
+        ],
+        "message": "Several frames in a row look blurry."
+      },
+      "seq": 2,
+      "type": "hint"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "complete": true,
+        "meterRead": "absent",
+        "missing": []
+      },
+      "seq": 3,
+      "type": "capture_check"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": null,
+        "errorCode": null,
+        "gpu": null,
+        "runId": "run_4846998965a545ea",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 4,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 0,
+        "runId": "run_4846998965a545ea",
+        "stage": "validate",
+        "status": "pending"
+      },
+      "seq": 5,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "complete": false,
+        "meterRead": "absent",
+        "missing": [
+          "panel_close",
+          "panel_open",
+          "main_disconnect",
+          "meter_tap"
+        ]
+      },
+      "seq": 6,
+      "type": "capture_check"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_4846998965a545ea",
+        "stage": "validate",
+        "status": "running"
+      },
+      "seq": 7,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_4846998965a545ea",
+        "stage": "validate",
+        "status": "done"
+      },
+      "seq": 8,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_4846998965a545ea",
+        "stage": "poses",
+        "status": "running"
+      },
+      "seq": 9,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_4846998965a545ea",
+        "stage": "objects",
+        "status": "running"
+      },
+      "seq": 10,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_4846998965a545ea",
+        "stage": "reads",
+        "status": "running"
+      },
+      "seq": 11,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_4846998965a545ea",
+        "stage": "objects",
+        "status": "done"
+      },
+      "seq": 12,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_4846998965a545ea",
+        "stage": "poses",
+        "status": "done"
+      },
+      "seq": 13,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_4846998965a545ea",
+        "stage": "reads",
+        "status": "done"
+      },
+      "seq": 14,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_4846998965a545ea",
+        "stage": "scale",
+        "status": "running"
+      },
+      "seq": 15,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_4846998965a545ea",
+        "stage": "scale",
+        "status": "done"
+      },
+      "seq": 16,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "gpu": "L4",
+        "runId": "run_4846998965a545ea",
+        "stage": "dense",
+        "status": "running"
+      },
+      "seq": 17,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "gpu": "L4",
+        "runId": "run_4846998965a545ea",
+        "stage": "dense",
+        "status": "done"
+      },
+      "seq": 18,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_4846998965a545ea",
+        "stage": "coverage",
+        "status": "running"
+      },
+      "seq": 19,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_4846998965a545ea",
+        "stage": "coverage",
+        "status": "done"
+      },
+      "seq": 20,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_4846998965a545ea",
+        "stage": "scene",
+        "status": "running"
+      },
+      "seq": 21,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_4846998965a545ea",
+        "stage": "scene",
+        "status": "done"
+      },
+      "seq": 22,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_4846998965a545ea",
+        "stage": "objects_3d",
+        "status": "running"
+      },
+      "seq": 23,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_4846998965a545ea",
+        "stage": "objects_3d",
+        "status": "done"
+      },
+      "seq": 24,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_4846998965a545ea",
+        "stage": "placement",
+        "status": "running"
+      },
+      "seq": 25,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_4846998965a545ea",
+        "stage": "criteria",
+        "status": "running"
+      },
+      "seq": 26,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_4846998965a545ea",
+        "stage": "criteria",
+        "status": "done"
+      },
+      "seq": 27,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.0,
+        "runId": "run_4846998965a545ea",
+        "stage": "placement",
+        "status": "done"
+      },
+      "seq": 28,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "runId": "run_4846998965a545ea",
+        "stage": "result",
+        "status": "running"
+      },
+      "seq": 29,
+      "type": "stage"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "kind": "not_eligible",
+        "runId": "run_4846998965a545ea"
+      },
+      "seq": 30,
+      "type": "verdict_ready"
+    },
+    {
+      "at": "2026-10-16T09:43:03Z",
+      "data": {
+        "attempt": 1,
+        "durationS": 0.01,
+        "runId": "run_4846998965a545ea",
+        "stage": "result",
+        "status": "done"
+      },
+      "seq": 31,
+      "type": "stage"
+    }
+  ],
+  "outcomeKind": "not_eligible",
+  "terminalEventKind": "verdict_ready",
+  "verdict": {
+    "decision": "reject",
+    "views": 0
+  }
+}
diff --git a/backend/tests/fixtures/app_states/not_eligible/result.json b/backend/tests/fixtures/app_states/not_eligible/result.json
new file mode 100644
index 000000000..6f0d71ac0
--- /dev/null
+++ b/backend/tests/fixtures/app_states/not_eligible/result.json
@@ -0,0 +1,33 @@
+{
+  "criteria": null,
+  "memberActions": [],
+  "meter": {
+    "barcodeConfirmed": false,
+    "candidates": [],
+    "clean": false,
+    "evidence": null,
+    "readersAgree": false,
+    "status": "not_captured",
+    "value": null
+  },
+  "outcome": {
+    "arkitEpoch": null,
+    "cableRoutePolylineArkit": null,
+    "frameToArkit": null,
+    "kind": "not_eligible",
+    "message": "Local test stand-in: the not-eligible decision is scripted, not measured. This is a local test outcome, not a check of a wall.",
+    "profile": "C",
+    "reasons": [],
+    "recommendedPlacement": null,
+    "viewsNeeded": []
+  },
+  "previewUrl": "http://testserver/v1/uploads/eyJjdCI6IiIsImV4cCI6MTc5MjE0NDY4Mywia2V5IjoiY2FwdHVyZXMvY2FwXzAxTTUyMUZYQkVDM0ZLWDZNUUFXWkE5RTREL3J1bnMvcnVuXzQ4NDY5OTg5NjVhNTQ1ZWEvcmVzdWx0L3ByZXZpZXcucGx5IiwibWQ1IjoiIiwib3AiOiJnZXQifQ.7d11d88555a1b20b96a17e63555e2214a9413d17aaaa27a8bf8fb97383935ec7",
+  "reviewUrl": "/v1/captures/cap_01M521FXBEC3FKX6MQAWZA9E4D/review",
+  "runId": "run_4846998965a545ea",
+  "scale": null,
+  "site": null,
+  "status": "complete",
+  "verdict": null,
+  "verdictUrl": null,
+  "viewsNeeded": []
+}
diff --git a/backend/tests/test_local_outcome_states.py b/backend/tests/test_local_outcome_states.py
index b7b595ba3..ec8c7227f 100644
--- a/backend/tests/test_local_outcome_states.py
+++ b/backend/tests/test_local_outcome_states.py
@@ -32,7 +32,6 @@
 import tempfile
 import time
 from pathlib import Path
-from typing import Callable
 
 import pytest
 from fastapi.testclient import TestClient
@@ -42,7 +41,7 @@
 from server.common.config import Settings
 from server.contracts.result import ResultResponse
 from server.orchestrator.config import load_orch
-from server.orchestrator.outcomes import capture_status
+from server.orchestrator.outcomes import Facts, decide
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
 PACKET_FIXTURE = REPO_ROOT / "backend" / "data" / "fixtures" / "packets" / "mini-arkit"
@@ -54,7 +53,7 @@
     ("eligible", "eligible", False, "complete", "eligible"),
     ("needs_more_photos", "needs_more_photos", False, "needs_views", "needs_more_photos"),
     ("not_eligible", "not_eligible", True, "complete", "not_eligible"),
-    ("failed", "failed", False, "failed", None),
+    ("failed", "failed", False, "failed", "manual_review"),
 ]
 
 TEMPLATE_ENV = {
@@ -97,6 +96,9 @@ def local_app(tmp_path, monkeypatch):
         monkeypatch.setenv(key, value)
     monkeypatch.delenv("HSS_LOCAL_OUTCOME", raising=False)
     monkeypatch.delenv("HSS_LOCAL_STAGE_DELAY_S", raising=False)
+    # Stage code sees env-loaded settings (the orchestrator hook binds a fresh
+    # template), so the reject flag must be set as an environment variable too.
+    monkeypatch.delenv("SHOW_REJECT_TO_HOMEOWNER", raising=False)
 
     def build(outcome: str | None = None, show_reject: bool = False, delay: float | None = None):
         root = tmp_path / f"packet-{outcome or 'default'}"
@@ -107,6 +109,8 @@ def build(outcome: str | None = None, show_reject: bool = False, delay: float |
             monkeypatch.setenv("HSS_LOCAL_OUTCOME", outcome)
         if delay is not None:
             monkeypatch.setenv("HSS_LOCAL_STAGE_DELAY_S", str(delay))
+        if show_reject:
+            monkeypatch.setenv("SHOW_REJECT_TO_HOMEOWNER", "1")
         settings = _settings(tmp_path, show_reject)
         app = create_app(settings=settings)
         client = TestClient(app)
@@ -177,9 +181,7 @@ def _open_front_door(root: Path, packet: dict, client: TestClient, app, packet_i
     return capture_id, raw
 
 
-def _run_capture(
-    root: Path, packet: dict, client: TestClient, app, packet_id: str
-) -> tuple[str, str, object]:
+def _run_capture(root: Path, packet: dict, client: TestClient, app, packet_id: str) -> tuple[str, str, object]:
     """Front door, finalize, drain; returns (capture_id, run_id, capture record)."""
     capture_id, raw = _open_front_door(root, packet, client, app, packet_id)
     response = client.post(
@@ -211,6 +213,17 @@ def _flat(client: TestClient, capture_id: str) -> list[dict]:
     pytest.fail("event feed never stopped moving")
 
 
+TERMINAL_EVENT_TYPES = {"verdict_ready", "retake_request", "failed"}
+
+
+def _last_terminal(events: list[dict]) -> dict:
+    """The outcome event, walking back past the later stage events."""
+    for event in reversed(events):
+        if event["type"] in TERMINAL_EVENT_TYPES:
+            return event
+    pytest.fail(f"no terminal outcome event among {[event['type'] for event in events[-6:]]}")
+
+
 # --- the states --------------------------------------------------------------
 
 
@@ -233,26 +246,36 @@ def test_hss_local_outcome_walks_the_app_to_each_state(
     ResultResponse.model_validate(payload)
 
     run = deps.state.get_run(run_id)
-    review = deps.storage.get_bytes(run.artifacts["result/review.html"])
-    assert b"stand-in" in review
-    if kind is None:
-        # Row 1: the validate stub failed the run; nothing composes, nothing leaks.
-        assert payload["outcome"] is None
+    if outcome == "failed":
+        # Row 1: the validate stub fails the run. The capture lands failed, the
+        # device sees the manual-review envelope with the packet-invalid reason,
+        # and no stub result composes.
+        assert capture.status == "failed"
         assert run.status == "failed"
+        assert payload["status"] == "failed"
+        assert payload["outcome"]["kind"] == "manual_review"
+        assert payload["outcome"]["message"] == "packet_invalid"
+        assert "result/review.html" not in run.artifacts
         return
 
+    review = deps.storage.get_bytes(run.artifacts["result/review.html"])
+    assert b"stand-in" in review
     assert payload["status"] == status
     assert payload["outcome"]["kind"] == kind
-    events = _flat(client, capture_id)
-    final = events[-1]
-    assert final["type"] == ("retake_request" if outcome == "needs_more_photos" else "verdict_ready")
-
-    # Scripted outcomes always say they are stand-ins, on the device and off it.
-    assert "local test outcome" in payload["outcome"]["message"]
-    assert "This is a local test" in payload["outcome"]["message"]
-    assert b"HSS_LOCAL_OUTCOME" in review
-    internal = json.loads(deps.storage.get_bytes(run.artifacts["result/result.internal.json"]))
-    assert internal["scripted_outcome"] == outcome
+    final = _last_terminal(_flat(client, capture_id))
+    assert final["type"] == "verdict_ready"
+    assert final["data"]["kind"] == kind
+    if outcome == "manual_review":
+        # The scripted default keeps today's plain stub wording.
+        assert payload["outcome"]["message"] == "Review required before a placement is shown."
+    else:
+        # Scripted non-default outcomes always say they are stand-ins, on the
+        # device and off it.
+        assert "local test outcome" in payload["outcome"]["message"]
+        assert "This is a local test" in payload["outcome"]["message"]
+        assert b"HSS_LOCAL_OUTCOME" in review
+        internal = json.loads(deps.storage.get_bytes(run.artifacts["result/result.internal.json"]))
+        assert internal["scripted_outcome"] == outcome
     assert "scripted_outcome" not in json.dumps(payload), "internal detail leaked to the device"
 
     if outcome == "eligible":
@@ -260,10 +283,10 @@ def test_hss_local_outcome_walks_the_app_to_each_state(
         assert placement is not None
         assert placement["footprintM"] == {"w": 0.7874, "h": 1.0033, "d": 0.5588}
         assert placement["startSM"] == 0.3
-        # Proposed, not placed: the app words it as a proposal.
-        assert payload["outcome"]["arkitEpoch"]
-        assert placement["boxArkitWorld"]["pose"]
-        assert placement["boxArkitWorld"]["size"] == [0.7874, 1.0033, 0.5588]
+        # The fixture packet carries no ARKit epoch, so the proposal stays in
+        # scene metres: AR data only when the frames match.
+        assert payload["outcome"]["arkitEpoch"] is None
+        assert placement["boxArkitWorld"] is None
     if outcome == "needs_more_photos":
         view = payload["viewsNeeded"][0]
         assert view["kind"] == "band"
@@ -282,7 +305,7 @@ def test_default_stub_run_keeps_todays_manual_review_bytes(local_app) -> None:
     assert payload["outcome"]["kind"] == "manual_review"
     assert payload["outcome"]["message"] == "Review required before a placement is shown."
     assert payload["viewsNeeded"] == []
-    final = _flat(client, capture_id)[-1]
+    final = _last_terminal(_flat(client, capture_id))
     assert final["type"] == "verdict_ready"
     assert final["data"]["kind"] == "manual_review"
 
@@ -295,7 +318,11 @@ def test_not_eligible_without_show_reject_lands_manual_review_loudly(local_app)
     assert capture.status == "manual_review"
     run = deps.state.get_run(run_id)
     assert run.status == "failed"
-    assert "SHOW_REJECT_TO_HOMEOWNER" in str(getattr(run, "error", ""))
+    stage_errors = " ".join(
+        str((stage.model_dump(mode="json") if hasattr(stage, "model_dump") else dict(stage)).get("error") or "")
+        for stage in deps.state.stages(run_id)
+    )
+    assert "SHOW_REJECT_TO_HOMEOWNER" in stage_errors
 
 
 def test_stage_delay_paces_the_stub_run(local_app) -> None:
@@ -358,13 +385,40 @@ def test_local_settings_parse_when_dev_stage_stubs_are_on() -> None:
     assert plain.local_stage_delay_s == 0.0
 
 
-def test_boot_refuses_a_stray_local_outcome(monkeypatch, tmp_path) -> None:
-    """Boot fails loudly naming the variable — never a silently ignored setting."""
-    monkeypatch.delenv("HSS_ORCH_STAGE_STUBS", raising=False)
+def test_dispatch_refuses_a_stray_local_outcome_loudly(monkeypatch, tmp_path, capfd) -> None:
+    """With stage stubs off, a stray variable runs nothing: no run record is
+    created, the capture stays processing, and the finalize hook logs the refused
+    dispatch. The config loader's ValueError text naming the variable is pinned
+    by the load_orch tests above."""
+    for key, value in TEMPLATE_ENV.items():
+        monkeypatch.setenv(key, value)
+    monkeypatch.setenv("HSS_ORCH_STAGE_STUBS", "0")
     monkeypatch.setenv("HSS_LOCAL_OUTCOME", "eligible")
     monkeypatch.setenv("VOLUME_ROOT", str(tmp_path / "vol"))
-    with pytest.raises(ValueError, match="HSS_LOCAL_OUTCOME"):
-        create_app(settings=_settings(tmp_path, show_reject=False))
+    app = create_app(settings=_settings(tmp_path, show_reject=False))
+    client = TestClient(app)
+    client.headers["Authorization"] = f"Bearer {'d' * 40}"
+    packet = json.loads((PACKET_FIXTURE / "packet.json").read_text())
+    shutil.copytree(PACKET_FIXTURE, tmp_path / "packet", dirs_exist_ok=True)
+    capture_id, raw = _open_front_door(tmp_path / "packet", packet, client, app, "refuse-stray")
+    response = client.post(
+        f"/v1/captures/{capture_id}/finalize",
+        content=raw,
+        headers={
+            "Idempotency-Key": "refuse-stray",
+            "Content-Type": "application/json",
+            "X-Packet-Sha256": hashlib.sha256(raw).hexdigest(),
+        },
+    )
+    assert response.status_code == 202, response.text
+    drain_finalize(app.state.deps)
+    deps = app.state.deps
+    record = deps.state.get_capture(capture_id)
+    # Nothing landed: no run record, and the capture never reached a terminal state.
+    assert record.status not in {"complete", "needs_views", "manual_review", "failed"}
+    assert deps.state.runs_for_capture(capture_id) == []
+    captured = capfd.readouterr()
+    assert "hook.error" in captured.out + captured.err
 
 
 # --- committed state fixtures ------------------------------------------------
@@ -382,20 +436,41 @@ def test_committed_state_fixtures_match_the_outcome_table() -> None:
         if verdict["decision"] == "validate_failed":
             assert doc["captureStatus"] == "failed"
         else:
-            assert capture_status(verdict["decision"], verdict["views"]) == doc["captureStatus"]
+            row = decide(
+                Facts(
+                    site_decision=verdict["decision"],
+                    views_needed=verdict["views"] > 0,
+                    # The committed not_eligible fixture was captured with the
+                    # reject shown; only the reject row reads this flag.
+                    show_reject_to_homeowner=True,
+                )
+            )
+            assert row.capture_status == doc["captureStatus"]
         assert served["status"] == doc["captureStatus"]
         if doc["outcomeKind"] is None:
             assert served["outcome"] is None
         else:
             assert served["outcome"]["kind"] == doc["outcomeKind"]
-            assert "local test outcome" in served["outcome"]["message"]
-        assert doc["terminalEventKind"] in {"verdict_ready", "retake_request", "run_failed", "failed"}
+            if directory.name == "failed":
+                # The degraded envelope's reason, not scripted copy.
+                assert served["outcome"]["message"] == "packet_invalid"
+            elif directory.name == "manual_review":
+                # The scripted default keeps today's plain stub wording.
+                assert served["outcome"]["message"] == "Review required before a placement is shown."
+            else:
+                assert "local test outcome" in served["outcome"]["message"]
+        assert doc["terminalEventKind"] in TERMINAL_EVENT_TYPES
 
 
 def _generate() -> None:
     """Regenerate the committed state fixtures. Run: uv run python tests/test_local_outcome_states.py --generate"""
     work = Path(tempfile.mkdtemp(prefix="hss-state-fixtures-"))
-    keys = list(TEMPLATE_ENV) + ["VOLUME_ROOT", "HSS_LOCAL_OUTCOME", "HSS_LOCAL_STAGE_DELAY_S"]
+    keys = list(TEMPLATE_ENV) + [
+        "VOLUME_ROOT",
+        "HSS_LOCAL_OUTCOME",
+        "HSS_LOCAL_STAGE_DELAY_S",
+        "SHOW_REJECT_TO_HOMEOWNER",
+    ]
     saved = {key: os.environ.get(key) for key in keys}
     try:
         for name, outcome, show_reject, _status, _kind in STATES:
@@ -406,6 +481,10 @@ def _generate() -> None:
                 os.environ[key] = value
             os.environ["VOLUME_ROOT"] = str(work / f"vol-{name}")
             os.environ.pop("HSS_LOCAL_STAGE_DELAY_S", None)
+            if show_reject:
+                os.environ["SHOW_REJECT_TO_HOMEOWNER"] = "1"
+            else:
+                os.environ.pop("SHOW_REJECT_TO_HOMEOWNER", None)
             if outcome is not None:
                 os.environ["HSS_LOCAL_OUTCOME"] = outcome
             else:
@@ -425,7 +504,8 @@ def _generate() -> None:
                     "decision": doc["site"]["decision"],
                     "views": len(doc.get("views_needed") or []),
                 }
-            final = _flat(client, capture_id)[-1]
+            events = _flat(client, capture_id)
+            final = _last_terminal(events)
             out = FIXTURES / name
             out.mkdir(parents=True, exist_ok=True)
             (out / "result.json").write_text(json.dumps(served, indent=2, sort_keys=True) + "\n")
@@ -436,7 +516,7 @@ def _generate() -> None:
                         "outcomeKind": (served.get("outcome") or {}).get("kind"),
                         "terminalEventKind": final["type"],
                         "verdict": verdict,
-                        "events": _flat(client, capture_id),
+                        "events": events,
                     },
                     indent=2,
                     sort_keys=True,

From 5d8e62cc3e681f2533bf25cc1c46a76995596554 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Fri, 16 Oct 2026 10:28:52 +0000
Subject: [PATCH 18/20] test(backend): drive every app state over a real socket
 from the local capture API

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/tests/test_local_app_states_e2e.py | 543 +++++++++++++++++++++
 1 file changed, 543 insertions(+)
 create mode 100644 backend/tests/test_local_app_states_e2e.py

diff --git a/backend/tests/test_local_app_states_e2e.py b/backend/tests/test_local_app_states_e2e.py
new file mode 100644
index 000000000..e128f4172
--- /dev/null
+++ b/backend/tests/test_local_app_states_e2e.py
@@ -0,0 +1,543 @@
+"""Every state the app renders, reached over a real HTTP socket.
+
+`scripts/local_capture_api.py` with `HSS_LOCAL_OUTCOME` scripts each terminal
+state the iOS app renders while photo processing runs; this file drives the
+real server (the launcher as a subprocess on an ephemeral loopback port) into
+each one and checks the status, the outcome kind and the fields the screen
+needs — the checks `tests/test_local_outcome_states.py` pins in process, replayed
+over the wire the app uses. No TestClient, no in-process ASGI transport.
+
+The journey per state is the documented front door: create, register, PUT to
+the signed upload URLs, commit, finalize the committed mini-arkit packet,
+long-poll events to a terminal status, then read the result (and the reviewer
+page). Each screen's needs come from the app side:
+`ios/HouseScanKit/Sources/HouseScanKit/Processing/PhotoProcessingStatus.swift`
+and `ios/HouseScan/UI/Copy/ProcessingCopy.swift`.
+
+  processing          events stream stage events while the run works
+                      (`HSS_LOCAL_STAGE_DELAY_S` keeps it visible)  -> "Processing your scan"
+  eligible            status complete, outcome.kind eligible, a proposed
+                      recommendedPlacement                          -> "A possible battery spot"
+  needs_more_photos   status needs_views, one viewsNeeded prompt    -> "One more look needed"
+  manual_review       status manual_review                          -> "Needs an installer's review"
+  not_eligible        status complete, outcome.kind not_eligible
+                      (needs SHOW_REJECT_TO_HOMEOWNER=1)            -> "No possible spot found"
+  failed              events end failed: the failing stage and a
+                      plain message                                 -> "Processing didn't finish"
+  refused             a 4xx with its code for a bad packet, 401 for
+                      a bad token                                   -> "The processing service refused this scan"
+  not ready           404 result_not_ready on the reviewer page
+                      before any run; the result answers with the
+                      not-ready envelope                            -> "answerNotReady" / not-ready envelope
+
+The committed fixtures under `tests/fixtures/app_states/<state>/` are the
+served payloads the outcome-states packet pinned in process; the terminal-state
+tests here cross-check the served status and outcome kind against them.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import httpx
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+SCRIPT = ROOT / "scripts" / "local_capture_api.py"
+PACKET = ROOT / "data" / "fixtures" / "packets" / "mini-arkit"
+FIXTURES = Path(__file__).resolve().parent / "fixtures" / "app_states"
+
+TERMINAL_CAPTURE_STATUSES = {"manual_review", "complete", "failed", "needs_views", "expired"}
+
+
+def _content_type(role: str) -> str:
+    if role == "stream":
+        return "application/gzip"
+    if role in {"features", "depth", "confidence", "mesh"}:
+        return "application/octet-stream"
+    return "image/jpeg"
+
+
+def _sealed_files(root: Path, packet: dict) -> list[dict]:
+    """Register bodies with the hashes the app computes from the sealed files."""
+    files = []
+    for entry in packet["files"]:
+        data = (root / entry["path"]).read_bytes()
+        role = entry.get("role", "still")
+        files.append(
+            {
+                "path": entry["path"],
+                "bytes": len(data),
+                "sha256": hashlib.sha256(data).hexdigest(),
+                "md5": base64.b64encode(hashlib.md5(data).digest()).decode(),
+                "role": role,
+                "contentType": _content_type(role),
+            }
+        )
+    return files
+
+
+def _free_port() -> int:
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        return sock.getsockname()[1]
+
+
+class LocalServer:
+    """The launcher as a subprocess with a scripted outcome, plus its session."""
+
+    def __init__(self, session_dir: Path, port: int, proc: subprocess.Popen, log_path: Path):
+        self.session_dir = session_dir
+        self.port = port
+        self.proc = proc
+        self.log_path = log_path
+        self.session = json.loads((session_dir / "session.json").read_text())
+
+    @property
+    def base(self) -> str:
+        return f"http://127.0.0.1:{self.port}"
+
+    def client(self, token: str | None) -> httpx.Client:
+        headers = {"Authorization": f"Bearer {token}"} if token else {}
+        return httpx.Client(base_url=f"{self.base}/v1", headers=headers, timeout=30)
+
+    def log(self) -> str:
+        return self.log_path.read_text()
+
+
+def _start_server(session_dir: Path, log_path: Path, extra_env: dict[str, str] | None = None) -> LocalServer:
+    port = _free_port()
+    log = log_path.open("w")
+    env = {**os.environ, **(extra_env or {})}
+    proc = subprocess.Popen(
+        [
+            sys.executable,
+            str(SCRIPT),
+            "--host",
+            "127.0.0.1",
+            "--port",
+            str(port),
+            "--session-dir",
+            str(session_dir),
+            "--health-timeout",
+            "90",
+        ],
+        cwd=ROOT,
+        env=env,
+        stdout=log,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    log.close()
+    # The launcher writes session.json before binding, so wait for healthz.
+    deadline = time.monotonic() + 90
+    while time.monotonic() < deadline:
+        if proc.poll() is not None:
+            pytest.fail(f"local capture API exited early with {proc.returncode}:\n{log_path.read_text()}")
+        try:
+            with httpx.Client(timeout=2) as probe:
+                if probe.get(f"http://127.0.0.1:{port}/v1/healthz").status_code == 200:
+                    return LocalServer(session_dir, port, proc, log_path)
+        except httpx.HTTPError:
+            time.sleep(0.25)
+    proc.terminate()
+    pytest.fail(f"local capture API never got healthy:\n{log_path.read_text()}")
+
+
+def _stop(server: LocalServer) -> None:
+    server.proc.terminate()
+    try:
+        server.proc.wait(timeout=15)
+    except subprocess.TimeoutExpired:
+        server.proc.kill()
+
+
+@pytest.fixture(scope="module")
+def outcome_server(tmp_path_factory) -> LocalServer:
+    """One server for the refused and not-ready walks (default manual_review)."""
+    session_dir = tmp_path_factory.mktemp("local-api-refused")
+    server = _start_server(session_dir, session_dir / "server.log")
+    try:
+        yield server
+    finally:
+        _stop(server)
+
+
+def _outcome_server(outcome: str, tmp_path_factory, show_reject: bool = False) -> LocalServer:
+    session_dir = tmp_path_factory.mktemp(f"local-api-{outcome}")
+    env = {"HSS_LOCAL_OUTCOME": outcome}
+    if show_reject:
+        env["SHOW_REJECT_TO_HOMEOWNER"] = "1"
+    return _start_server(session_dir, session_dir / "server.log", env)
+
+
+def _copy_packet(workdir: Path, packet_id: str) -> tuple[Path, dict]:
+    """A private copy of the committed packet, retagged with a unique packet id.
+
+    The create route pins Idempotency-Key to the packet id, so two journeys on
+    one server must not share one; finalize requires the packet bytes to carry
+    the same id, so the copy is rewritten before any finalize.
+    """
+    root = workdir / "packet"
+    subprocess.run(["cp", "-R", str(PACKET), str(root)], check=True)
+    packet = json.loads((root / "packet.json").read_text())
+    packet["packetId"] = packet_id
+    (root / "packet.json").write_text(json.dumps(packet, indent=2) + "\n")
+    return root, packet
+
+
+def _create_capture(client: httpx.Client, packet: dict) -> dict:
+    session = packet["session"]
+    response = client.post(
+        "/captures",
+        json={
+            "packetId": packet["packetId"],
+            "formatVersion": packet["formatVersion"],
+            "tier": session["tier"],
+            "flow": "guided",
+            "device": {
+                "model": session["deviceModel"],
+                "systemVersion": session["systemVersion"],
+                "appVersion": session["appVersion"],
+            },
+        },
+        headers={"Idempotency-Key": packet["packetId"]},
+    )
+    assert response.status_code == 201, response.text
+    assert response.json()["status"] == "uploading"
+    return response.json()
+
+
+def _register_upload_commit(client: httpx.Client, root: Path, packet: dict, capture_id: str) -> None:
+    files = _sealed_files(root, packet)
+    registered = client.post(f"/captures/{capture_id}/files", json={"files": files})
+    assert registered.status_code == 200, registered.text
+
+    with httpx.Client(timeout=60) as uploads:
+        for body, target in zip(files, registered.json()["files"], strict=True):
+            put = uploads.put(
+                target["upload"]["url"],
+                content=(root / body["path"]).read_bytes(),
+                headers=target["upload"].get("headers") or {},
+            )
+            assert put.status_code == 200, f"{put.status_code} for {body['path']}: {put.text}"
+
+    commit = client.post(
+        f"/captures/{capture_id}/files:commit",
+        json={"files": [{"path": item["path"], "sha256": item["sha256"]} for item in files]},
+    )
+    assert commit.status_code == 200, commit.text
+    assert not commit.json().get("notFound"), commit.text
+    assert not commit.json().get("mismatch"), commit.text
+
+
+def _finalize(client: httpx.Client, root: Path, packet: dict, capture_id: str, raw: bytes | None = None) -> str:
+    if raw is None:
+        raw = (root / "packet.json").read_bytes()
+    finalized = client.post(
+        f"/captures/{capture_id}/finalize",
+        content=raw,
+        headers={
+            "Idempotency-Key": packet["packetId"],
+            "Content-Type": "application/json",
+            "X-Packet-Sha256": hashlib.sha256(raw).hexdigest(),
+        },
+    )
+    assert finalized.status_code == 202, finalized.text
+    run_id = finalized.json()["runId"]
+    assert run_id, finalized.text
+    return run_id
+
+
+def _poll_events(client: httpx.Client, capture_id: str, deadline_s: float = 180) -> tuple[str, list[dict]]:
+    """Long-poll to a terminal status. Returns (status, all events seen)."""
+    after = 0
+    events: list[dict] = []
+    deadline = time.monotonic() + deadline_s
+    status = None
+    while time.monotonic() < deadline:
+        poll = client.get(f"/captures/{capture_id}/events", params={"after": after, "wait": 5})
+        assert poll.status_code == 200, poll.text
+        body = poll.json()
+        status = body["status"]
+        events.extend(body["events"])
+        after = body["next"]
+        if status in TERMINAL_CAPTURE_STATUSES:
+            return status, events
+    pytest.fail(f"events never reached a terminal status; last {status!r}")
+
+
+def _events_of_type(events: list[dict], kind: str) -> list[dict]:
+    return [event for event in events if event.get("type") == kind]
+
+
+def _drive_full(client: httpx.Client, workdir: Path, packet_id: str) -> tuple[dict, str, str, list[dict]]:
+    """The whole journey to a terminal status. Returns (capture, capture_id, run_id, events)."""
+    root, packet = _copy_packet(workdir, packet_id)
+    created = _create_capture(client, packet)
+    capture_id = created["captureId"]
+    _register_upload_commit(client, root, packet, capture_id)
+    run_id = _finalize(client, root, packet, capture_id)
+    status, events = _poll_events(client, capture_id)
+    return created, capture_id, run_id, events
+
+
+def _result(client: httpx.Client, capture_id: str) -> dict:
+    response = client.get(f"/captures/{capture_id}/result")
+    assert response.status_code == 200, response.text
+    return response.json()
+
+
+def _fixture(state: str) -> dict:
+    return json.loads((FIXTURES / state / "result.json").read_text())
+
+
+# --- the terminal states the app renders --------------------------------------
+
+
+@pytest.mark.parametrize(
+    "outcome",
+    ["eligible", "needs_more_photos", "manual_review"],
+)
+def test_terminal_state_serves_what_the_screen_needs(outcome: str, tmp_path_factory, tmp_path: Path) -> None:
+    """Each scripted outcome lands the capture on its capture status, and the
+    served result carries the fields that screen reads."""
+    server = _outcome_server(outcome, tmp_path_factory)
+    try:
+        with server.client(server.session["appToken"]) as client:
+            capture, capture_id, run_id, events = _drive_full(client, tmp_path, f"mini-arkit-{outcome}")
+
+            result = _result(client, capture_id)
+            expected = _fixture(outcome)
+            assert result["status"] == expected["status"], result
+            assert result["runId"] == run_id
+            assert result["outcome"] is not None
+            assert result["outcome"]["kind"] == expected["outcome"]["kind"]
+            # The message is the service's words for the homeowner, shown verbatim.
+            assert result["outcome"]["message"], result["outcome"]
+
+            with server.client(server.session["reviewerToken"]) as reviewer:
+                page = reviewer.get(f"/captures/{capture_id}/review")
+                assert page.status_code == 200, page.text
+                assert "text/html" in page.headers["content-type"]
+                assert outcome.encode() in page.content, page.text[:400]
+    finally:
+        _stop(server)
+
+
+def test_eligible_carries_a_proposed_placement(tmp_path_factory, tmp_path: Path) -> None:
+    """'A possible battery spot': kind eligible worded as proposed, with the
+    placement fields the AR box and the card need — still only a candidate."""
+    server = _outcome_server("eligible", tmp_path_factory)
+    try:
+        with server.client(server.session["appToken"]) as client:
+            capture, capture_id, run_id, events = _drive_full(client, tmp_path, "mini-arkit-eligible-placement")
+
+            result = _result(client, capture_id)
+            assert result["status"] == "complete", result
+            outcome = result["outcome"]
+            assert outcome["kind"] == "eligible", outcome
+            # Worded as proposed: the service's own message says the placement
+            # is scripted, not measured, so the answer stays provisional.
+            assert "scripted" in outcome["message"], outcome["message"]
+            placement = outcome["recommendedPlacement"]
+            assert placement is not None, outcome
+            assert placement["wallId"], placement
+            assert placement["footprintM"]["w"] > 0 and placement["footprintM"]["h"] > 0, placement
+            assert placement["boxSceneM"]["centerM"] and placement["boxSceneM"]["sizeM"], placement
+            assert result["reviewUrl"], result
+    finally:
+        _stop(server)
+
+
+def test_needs_more_photos_lists_the_views(tmp_path_factory, tmp_path: Path) -> None:
+    """'One more look needed': status needs_views and at least one view whose
+    prompt the screen shows verbatim."""
+    server = _outcome_server("needs_more_photos", tmp_path_factory)
+    try:
+        with server.client(server.session["appToken"]) as client:
+            capture, capture_id, run_id, events = _drive_full(client, tmp_path, "mini-arkit-needs-more")
+
+            result = _result(client, capture_id)
+            assert result["status"] == "needs_views", result
+            outcome = result["outcome"]
+            assert outcome["kind"] == "needs_more_photos", outcome
+            views = result["viewsNeeded"]
+            assert views, "the needs-more-photos screen needs the requested views"
+            first = views[0]
+            assert first["id"], first
+            assert first["kind"] == "band", first
+            assert first["prompt"]["title"] and first["prompt"]["body"], first
+            assert first["why"], first
+    finally:
+        _stop(server)
+
+
+def test_not_eligible_shown_to_the_homeowner(tmp_path_factory, tmp_path: Path) -> None:
+    """'No possible spot found' needs SHOW_REJECT_TO_HOMEOWNER=1: kind
+    not_eligible with the service's message, capture complete."""
+    server = _outcome_server("not_eligible", tmp_path_factory, show_reject=True)
+    try:
+        with server.client(server.session["appToken"]) as client:
+            capture, capture_id, run_id, events = _drive_full(client, tmp_path, "mini-arkit-not-eligible")
+
+            result = _result(client, capture_id)
+            assert result["status"] == "complete", result
+            outcome = result["outcome"]
+            assert outcome["kind"] == "not_eligible", outcome
+            assert outcome["message"], outcome
+            assert outcome["recommendedPlacement"] is None, outcome
+    finally:
+        _stop(server)
+
+
+def test_not_eligible_without_show_reject_lands_manual_review(tmp_path_factory, tmp_path: Path) -> None:
+    """With the reject hidden the capture must not show 'No possible spot':
+    it lands on the installer-review screen instead, as the outcome table says."""
+    server = _outcome_server("not_eligible", tmp_path_factory, show_reject=False)
+    try:
+        with server.client(server.session["appToken"]) as client:
+            capture, capture_id, run_id, events = _drive_full(client, tmp_path, "mini-arkit-not-eligible-hidden")
+
+            result = _result(client, capture_id)
+            assert result["status"] == "manual_review", result
+            assert result["outcome"]["kind"] == "manual_review", result["outcome"]
+    finally:
+        _stop(server)
+
+
+def test_failed_names_the_stage_and_the_plain_message(tmp_path_factory, tmp_path: Path) -> None:
+    """'Processing didn't finish': the events end failed, naming the failing
+    stage and carrying a plain message, and the result answers with status failed."""
+    server = _outcome_server("failed", tmp_path_factory)
+    try:
+        with server.client(server.session["appToken"]) as client:
+            capture, capture_id, run_id, events = _drive_full(client, tmp_path, "mini-arkit-failed")
+
+            poll = client.get(f"/captures/{capture_id}/events", params={"after": 0})
+            body = poll.json()
+            assert body["status"] == "failed", body
+
+            failed_events = _events_of_type(body["events"], "failed")
+            assert failed_events, "a failed run must publish its failed event"
+            data = failed_events[-1]["data"]
+            assert data.get("code"), data
+            assert data.get("message"), "the failed screen needs a plain message"
+            assert data.get("next") == "none", data
+
+            stage_failures = [
+                event
+                for event in _events_of_type(body["events"], "stage")
+                if event["data"].get("status") == "failed"
+            ]
+            assert stage_failures, "the events must name the stage that failed"
+            assert stage_failures[-1]["data"].get("stage"), stage_failures[-1]
+
+            result = _result(client, capture_id)
+            assert result["status"] == "failed", result
+            expected = _fixture("failed")
+            assert (result.get("outcome") or {}).get("kind", "manual_review") == expected["outcome"]["kind"]
+    finally:
+        _stop(server)
+
+
+# --- the state before any answer ---------------------------------------------
+
+
+def test_processing_streams_stage_events_while_the_run_works(tmp_path_factory, tmp_path: Path) -> None:
+    """'Processing your scan': with HSS_LOCAL_STAGE_DELAY_S pacing the stubs, a
+    mid-run events long-poll shows the capture still processing and the stage
+    events the screen's working state stands on."""
+    session_dir = tmp_path_factory.mktemp("local-api-processing")
+    server = _start_server(session_dir, session_dir / "server.log", {"HSS_LOCAL_STAGE_DELAY_S": "2"})
+    try:
+        with server.client(server.session["appToken"]) as client:
+            root, packet = _copy_packet(tmp_path, "mini-arkit-processing")
+            created = _create_capture(client, packet)
+            capture_id = created["captureId"]
+            _register_upload_commit(client, root, packet, capture_id)
+            run_id = _finalize(client, root, packet, capture_id)
+
+            # Twelve stubs, two seconds each: the run is still working here.
+            poll = client.get(f"/captures/{capture_id}/events", params={"after": 0, "wait": 2})
+            assert poll.status_code == 200, poll.text
+            body = poll.json()
+            assert body["status"] == "processing", body
+            stage_events = [
+                event
+                for event in _events_of_type(body["events"], "stage")
+                if event["data"].get("runId") == run_id
+                and event["data"].get("status") in {"pending", "running", "done"}
+            ]
+            assert stage_events, "the processing screen stands on the run's stage events"
+            assert any(event["data"].get("stage") for event in stage_events), stage_events
+
+            # The run still gets to its terminal answer with the delay on.
+            status, events = _poll_events(client, capture_id)
+            assert status == "manual_review", status
+    finally:
+        _stop(server)
+
+
+# --- the refusals and the not-ready answer -----------------------------------
+
+
+def test_refused_bad_packet_is_a_4xx_with_its_code(outcome_server: LocalServer, tmp_path: Path) -> None:
+    """'The processing service refused this scan': a malformed finalize is a 4xx
+    whose errors name a code — sending the same thing again won't change it."""
+    server = outcome_server
+    root, packet = _copy_packet(tmp_path, "mini-arkit-refused-packet")
+    with server.client(server.session["appToken"]) as client:
+        capture_id = _create_capture(client, packet)["captureId"]
+        raw = b"{not json at all"
+        response = client.post(
+            f"/captures/{capture_id}/finalize",
+            content=raw,
+            headers={
+                "Idempotency-Key": packet["packetId"],
+                "Content-Type": "application/json",
+                "X-Packet-Sha256": hashlib.sha256(raw).hexdigest(),
+            },
+        )
+        assert 400 <= response.status_code < 500, response.text
+        errors = response.json()["errors"]
+        assert errors and all({"code", "pointer", "message"} <= set(item) for item in errors), errors
+
+
+def test_refused_bad_token_is_401_with_its_code(outcome_server: LocalServer) -> None:
+    """A wrong bearer never reaches the capture: 401 with the error envelope."""
+    server = outcome_server
+    with httpx.Client(base_url=f"{server.base}/v1", timeout=30) as anon:
+        missing = anon.get("/captures/whatever/events")
+        assert missing.status_code == 401, missing.text
+        errors = missing.json()["errors"]
+        assert errors and errors[0]["code"], errors
+        wrong = anon.get("/captures/whatever/events", headers={"Authorization": "Bearer " + "w" * 40})
+        assert wrong.status_code == 401, wrong.text
+        assert wrong.json()["errors"][0]["code"] == errors[0]["code"], wrong.text
+
+
+def test_not_ready_result_and_reviewer_page(outcome_server: LocalServer, tmp_path: Path) -> None:
+    """'answerNotReady': before any run the result answers with the not-ready
+    envelope (outcome none), and the reviewer page is 404 result_not_ready."""
+    server = outcome_server
+    root, packet = _copy_packet(tmp_path, "mini-arkit-not-ready")
+    with server.client(server.session["appToken"]) as client:
+        capture_id = _create_capture(client, packet)["captureId"]
+        result = client.get(f"/captures/{capture_id}/result")
+        assert result.status_code == 200, result.text
+        body = result.json()
+        assert body["outcome"] is None and body["viewsNeeded"] == [], body
+        assert body["status"] == "uploading", body
+    with server.client(server.session["reviewerToken"]) as reviewer:
+        review = reviewer.get(f"/captures/{capture_id}/review")
+        assert review.status_code == 404, review.text
+        assert review.json()["errors"][0]["code"] == "result_not_ready", review.text

From db86ad4c5c66ceb30a1a7213a2ffe07473c9eb5c Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Fri, 16 Oct 2026 10:41:56 +0000
Subject: [PATCH 19/20] docs(backend): name every local app state and the
 command that serves it

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/docs/local-app-states.md  | 149 ++++++++++++++++++++++++++++++
 backend/docs/local-capture-api.md |   4 +-
 2 files changed, 151 insertions(+), 2 deletions(-)
 create mode 100644 backend/docs/local-app-states.md

diff --git a/backend/docs/local-app-states.md b/backend/docs/local-app-states.md
new file mode 100644
index 000000000..43cff9cae
--- /dev/null
+++ b/backend/docs/local-app-states.md
@@ -0,0 +1,149 @@
+# Every state the app renders, over a real socket
+
+The iOS processing UI renders eight states while a scan runs. This page names
+each one, the exact command that produces it on `make local-api`, and what the
+API serves; the e2e suite `backend/tests/test_local_app_states_e2e.py` drives
+all of them over TCP in CI, and `evidence/burst11-bs-local-app-states-run/`
+carries a recorded terminal walk per state (`walk-<state>.gif`) plus
+reviewer-page screenshots. Screen needs come from
+`ios/HouseScanKit/Sources/HouseScanKit/Processing/PhotoProcessingStatus.swift`
+and the copy in `ios/HouseScan/UI/Copy/ProcessingCopy.swift`.
+
+## The journey every state goes through
+
+One server, one capture, the documented front door — with the app token from
+`backend/runs/local-api/session.json` (`TOKEN`, below) and a retagged copy of
+the committed packet (`data/fixtures/packets/mini-arkit`):
+
+```bash
+PID=local-app-states-eligible
+CAPTURE_ID=$(curl -s -X POST http://127.0.0.1:$PORT/v1/captures \
+  -H "Authorization: Bearer $TOKEN" -H "Idempotency-Key: $PID" \
+  -H "Content-Type: application/json" -d @create.json | jq -r .captureId)
+
+curl -s -X POST http://127.0.0.1:$PORT/v1/captures/$CAPTURE_ID/files \
+  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
+  -d @files.json                          # register: sealed hashes per file
+# ... one signed PUT per file, then:
+curl -s -X POST http://127.0.0.1:$PORT/v1/captures/$CAPTURE_ID/files:commit \
+  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -d @commit.json
+
+curl -s -X POST http://127.0.0.1:$PORT/v1/captures/$CAPTURE_ID/finalize \
+  -H "Authorization: Bearer $TOKEN" -H "Idempotency-Key: $PID" \
+  -H "Content-Type: application/json" -H "X-Packet-Sha256: $SHA" \
+  --data-binary @packet/packet.json       # 202 {runId, status: processing}
+
+curl -s "http://127.0.0.1:$PORT/v1/captures/$CAPTURE_ID/events?after=0&wait=5" \
+  -H "Authorization: Bearer $TOKEN"       # long-poll to a terminal status
+curl -s http://127.0.0.1:$PORT/v1/captures/$CAPTURE_ID/result \
+  -H "Authorization: Bearer $TOKEN"       # what the result screen reads
+curl -s http://127.0.0.1:$PORT/v1/captures/$CAPTURE_ID/review \
+  -H "Authorization: Bearer $REVIEWER_TOKEN"   # the reviewer page
+```
+
+`create.json`, `files.json`, `commit.json` and the PUT loop are exactly what
+the e2e test and `evidence/burst11-bs-local-app-states-run/walk-*.gif` run;
+the recorded walks are the source of truth for both command and output.
+
+## The eight states
+
+| App screen | Command (on `make local-api`) | Capture status when settled | Served outcome |
+|---|---|---|---|
+| Processing your scan | `HSS_LOCAL_STAGE_DELAY_S=2 make local-api` | `processing` → `manual_review` | stage events stream while the twelve stubs work |
+| A possible battery spot | `HSS_LOCAL_OUTCOME=eligible make local-api` | `complete` | `eligible` with a proposed `recommendedPlacement` |
+| One more look needed | `HSS_LOCAL_OUTCOME=needs_more_photos make local-api` | `needs_views` | `needs_more_photos` with `viewsNeeded` |
+| Needs an installer's review | `HSS_LOCAL_OUTCOME=manual_review make local-api` | `manual_review` | `manual_review` |
+| No possible spot found | `HSS_LOCAL_OUTCOME=not_eligible SHOW_REJECT_TO_HOMEOWNER=1 make local-api` | `complete` | `not_eligible`, no placement |
+| (reject hidden from the homeowner) | `HSS_LOCAL_OUTCOME=not_eligible make local-api` | `manual_review` | `manual_review` |
+| Processing didn't finish | `HSS_LOCAL_OUTCOME=failed make local-api` | `failed` | failed event naming the stage, plain message |
+| The processing service refused this scan | any; send a bad packet or token | — (never runs) | 4xx with an error code |
+| (answer not ready yet) | any; read before any run | pre-run | not-ready envelope / 404 `result_not_ready` |
+
+## What each screen needs from the API
+
+### Processing your scan
+
+While the run works the events stream carries `stage` events
+(`{runId, stage, status, ...}`); the capture status stays `processing` until a
+terminal event lands. `HSS_LOCAL_STAGE_DELAY_S=2` paces the twelve stubs at two
+seconds each so the working state is observable — and pollable: a long-poll
+mid-run returns `status: "processing"` with the stage events so far.
+
+### A possible battery spot (`eligible`)
+
+`complete` capture; `result` answers:
+
+```json
+{
+  "status": "complete",
+  "outcome": {
+    "kind": "eligible",
+    "message": "Local test stand-in: the proposed placement is scripted, not measured. This is a local test outcome, not a check of a wall.",
+    "recommendedPlacement": {
+      "wallId": "w1",
+      "profile": "C",
+      "footprintM": {"w": 0.7874, "h": 1.0033, "d": 0.5588},
+      "boxSceneM": {
+        "centerM": [0.6937, 0.50165, 0.2994],
+        "sizeM": [0.7874, 1.0033, 0.5588],
+        "yawDeg": 0.0
+      },
+      "confidence": 0.5
+    }
+  },
+  "reviewUrl": "/v1/captures/<captureId>/review"
+}
+```
+
+Worded as proposed: the service's own message says the placement is scripted,
+not measured — the answer stays provisional, the AR box and the card render it
+as a candidate. The committed pin is
+`backend/tests/fixtures/app_states/eligible/result.json`.
+
+### One more look needed (`needs_more_photos`)
+
+`needs_views` capture; `result` carries `viewsNeeded`, each with `id`,
+`kind` (`"band"`), a `prompt` (`title`, `body`) and a `why` — the screen shows
+the prompt verbatim. Pinned at
+`backend/tests/fixtures/app_states/needs_more_photos/result.json`.
+
+### Needs an installer's review (`manual_review`)
+
+`manual_review` capture; `outcome.kind` `manual_review`. This is also where a
+`not_eligible` run lands when `SHOW_REJECT_TO_HOMEOWNER` is unset — the reject
+screen never shows to the homeowner without the flag.
+
+### No possible spot found (`not_eligible`, flag on)
+
+`SHOW_REJECT_TO_HOMEOWNER=1` lets the capture complete with `outcome.kind`
+`not_eligible`, a service message, and no placement.
+
+### Processing didn't finish (`failed`)
+
+The events stream ends with a `failed` event carrying `code`, a plain
+`message` (the screen shows it verbatim) and `next: "none"`, after a `stage`
+event with `status: "failed"` naming the stage that failed. `result` answers
+`status: "failed"`. Pinned at
+`backend/tests/fixtures/app_states/failed/result.json`.
+
+### The processing service refused this scan (`refused`)
+
+Two refusals, both before any run exists:
+
+- a malformed finalize body → 4xx with
+  `errors: [{code, pointer, message}]` — retrying the same bytes won't change it;
+- a missing or wrong bearer → 401 with the same envelope.
+
+### Answer not ready (`not ready`)
+
+Before any run: `result` answers 200 with the not-ready envelope
+(`status` still pre-run, `outcome: null`, `viewsNeeded: []`), and the reviewer
+page answers 404 `result_not_ready`.
+
+## Regenerating the evidence
+
+`evidence/burst11-bs-local-app-states-run/` holds one recorded walk per state
+plus the three reviewer-page screenshots. Each walk is a real asciinema
+recording of the journey above against a real `make local-api` server; session
+tokens are masked in the recordings. The e2e suite re-proves the same states in
+CI without recordings.
diff --git a/backend/docs/local-capture-api.md b/backend/docs/local-capture-api.md
index 24255aaeb..855057be8 100644
--- a/backend/docs/local-capture-api.md
+++ b/backend/docs/local-capture-api.md
@@ -52,8 +52,8 @@ boundaries. No TestClient, no `drain_finalize`: the orchestrator is driven inlin
 | `BASE_WEBHOOK_URL` / `WEBHOOK_HMAC_SECRET` | unset | webhooks off |
 
 Pass through without interpretation: `HSS_LOCAL_OUTCOME` and `HSS_LOCAL_STAGE_DELAY_S`. The stage
-stubs honor them when the burst11-bs-local-outcome-states packet lands; this launcher never reads
-or changes them, so `HSS_LOCAL_OUTCOME=pass make local-api` just works.
+stubs honor them to produce every state the app renders — `docs/local-app-states.md` names each
+state, its command and what gets served; this launcher never reads or changes the variables.
 
 ## The session file
 

From c41b148be9b52dc62197f57108a3972e1f77d309 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Fri, 16 Oct 2026 10:44:31 +0000
Subject: [PATCH 20/20] docs(backend): note the failed run's reviewer answer;
 ruff-format the e2e test

Co-authored-by: obvious-autobuild[bot] <262744130+obvious-autobuild[bot]@users.noreply.github.com>
---
 backend/docs/local-app-states.md           | 8 ++++++--
 backend/tests/test_local_app_states_e2e.py | 4 +---
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/backend/docs/local-app-states.md b/backend/docs/local-app-states.md
index 43cff9cae..8f84de608 100644
--- a/backend/docs/local-app-states.md
+++ b/backend/docs/local-app-states.md
@@ -123,8 +123,12 @@ screen never shows to the homeowner without the flag.
 The events stream ends with a `failed` event carrying `code`, a plain
 `message` (the screen shows it verbatim) and `next: "none"`, after a `stage`
 event with `status: "failed"` naming the stage that failed. `result` answers
-`status: "failed"`. Pinned at
-`backend/tests/fixtures/app_states/failed/result.json`.
+`status: "failed"` with `outcome.kind: "manual_review"` — a failed run still
+routes the homeowner to the installer. The reviewer page answers
+404 `result_not_ready` for a failed run: the route serves the run's
+`result/review.html`, and a failed run publishes none. Pinned at
+`backend/tests/fixtures/app_states/failed/result.json`; the failed evidence
+screenshot is that 404 envelope.
 
 ### The processing service refused this scan (`refused`)
 
diff --git a/backend/tests/test_local_app_states_e2e.py b/backend/tests/test_local_app_states_e2e.py
index e128f4172..edab2396c 100644
--- a/backend/tests/test_local_app_states_e2e.py
+++ b/backend/tests/test_local_app_states_e2e.py
@@ -434,9 +434,7 @@ def test_failed_names_the_stage_and_the_plain_message(tmp_path_factory, tmp_path
             assert data.get("next") == "none", data
 
             stage_failures = [
-                event
-                for event in _events_of_type(body["events"], "stage")
-                if event["data"].get("status") == "failed"
+                event for event in _events_of_type(body["events"], "stage") if event["data"].get("status") == "failed"
             ]
             assert stage_failures, "the events must name the stage that failed"
             assert stage_failures[-1]["data"].get("stage"), stage_failures[-1]