Prepare Frame Control 0.4.31 and record round-two validation (#221 )

* Prepare Frame Control 0.4.31 with round-two validation * State the x86 Linux runtime limit in smoke evidence --------- Co-authored-by: SAPHID <saphid@users.noreply.github.com>
Add read-only large status screen to headset panel (#220 )
2026-10-25 13:01:47 +01:00 · 2026-10-25 06:54:03 +00:00 · 2026-10-25 06:46:01 +00:00 · 2026-10-25 06:42:11 +00:00 · 2026-10-25 06:37:51 +00:00 · 2026-10-25 06:35:47 +00:00
19 changed files with 976 additions and 52 deletions
@@ -24,6 +24,11 @@
  existing files in the old flat folder are left in place.
  [Copying guide](docs/recording.md).

+- Keep Steam clip exports separate for each headset, Steam account and nested
+  recording session. Manual export and automatic copying use the same folders;
+  existing flat exports stay untouched and do not mark unrelated clips saved.
+  [Recording guide](docs/recording.md#steam-clips).
+
 - Compare two explicit Windows Wireless Adapter doctor reads in local memory.
  Highlight exact PnP instances and known state changes after a dropout;
  incomplete inventories stay unknown. A Forget button clears the comparison.
@@ -225,3 +230,8 @@
  shared Wine services are left alone. Verified with local Linux process
  regressions and a 13/13 real Frame smoke run that stopped five test-owned
  Proton process PIDs before removing the Windows test title.
+
+- Keep failed automatic screenshot and clip copies visible after three attempts.
+  **Resume** and **Copy everything now** allow another try without restarting;
+  headset switches cannot use another headset's list or saved-file history.
+  [Copying guide](docs/recording.md).
@@ -1,12 +1,12 @@
 {
  "name": "frame-control",
-  "version": "0.4.30",
+  "version": "0.4.31",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "frame-control",
-      "version": "0.4.30",
+      "version": "0.4.31",
      "license": "MIT",
      "devDependencies": {
        "electron": "^44.4.5",
@@ -1,7 +1,7 @@
 {
  "name": "frame-control",
  "productName": "Frame Control",
-  "version": "0.4.30",
+  "version": "0.4.31",
  "description": "Desktop app for managing a Valve Steam Frame over SSH",
  "private": true,
  "main": "main.js",
@@ -1,9 +1,10 @@
 # What we have tested

-Current for Frame Control **v0.4.30**, 25 October 2026. “Real Frame + physical PC” means an actual headset and a non-virtual computer. “VM only” means a Windows virtual machine, sometimes connected to the real Frame. A CI test or a simulated device is **not** a physical hardware test. The date/version column is the last relevant check, not a promise that every new release was retested on that platform. See each link for the exact procedure and limits.
+Current for Frame Control **v0.4.31**, 25 October 2026. “Real Frame + physical PC” means an actual headset and a non-virtual computer. “VM only” means a Windows virtual machine, sometimes connected to the real Frame. A CI test or a simulated device is **not** a physical hardware test. The date/version column is the last relevant check, not a promise that every new release was retested on that platform. See each link for the exact procedure and limits.

 | Feature | Real Frame + physical PC tested | VM only | Untested or limited | Last check and proof |
 |---|---|---|---|---|
+| Core title smoke test | Linux lxso2 installed, launched and removed reserved native/Proton titles on the real Frame; all 13 steps passed | No | Unworn headset; visible rendering and controller input not checked. Other feature paths retain their separate limits below | 25 Oct, v0.4.31 candidate source `1255ef2`, Frame OS 0.5.6 build `20261022.6153909`: [sanitized results](evidence/round2-smoke-2026-10-25.json) |
 | Windows desktop in the headset | No physical Windows PC test | Windows 11 VM sent a whole desktop to a real Frame; this used an intermediate fix, not the final native DLL | Physical GPU, capture and controller input; individual windows unavailable in bundled DXGI build | 24 Oct, v0.4.10 installer + candidate fix: [VM log](evidence/windows-vm-2026-10-24.md), [PC guide](pc-in-headset.md) |
 | Linux desktop in the headset | No | No | Native Linux PC capture is disabled; lxso2 lacked a desktop portal and PipeWire session. The separate Steam `-pipewire` helper is not Frame Control's PC capture | 24 Oct, v0.4.17: [host audit](evidence/linux-pc-host-lxso2-2026-10-24.md), [Steam helper PR #163](https://github.com/saphid/frame-control/pull/163) |
 | Mac desktop in the headset | A physical Mac sent its screen/window to a real Frame | No | Current v0.4.26 Mac installer and worn-headset controller input have not been repeated | 28 Sep, pre-v0.4 / Frame OS 0.4.1: [Mac guide and measurement](streaming.md#b-show-the-macs-desktop-inside-the-frame) |
@@ -0,0 +1,79 @@
+# Auto-sync retry and headset-selection reliability
+
+Date: 25 October 2026. Base: `d79efb4`, Frame Control v0.4.30.
+Issue: [#214](https://github.com/saphid/frame-control/issues/214).
+Environment: Linux x86_64, Python 3.12.3, Node 24.15.0.
+
+## Reproduced problems
+
+The existing 19 auto-sync tests passed on the base revision. Added regressions
+failed before the implementation: an exhausted clip lost its error, explicit
+retry did not recover failed screenshots or clips, and switches around listing
+or copying continued the old pass. The original callback interface also had no
+way to carry the tick's captured device into the server list reservation.
+
+The final fake-source tests exercise these boundaries:
+
+- Fail screenshots or clips three times, keep checking without further copy
+  attempts, and retain the source error plus an explicit retry instruction.
+- Recover the source and use either Resume or Copy everything now without
+  restarting. Successful copies stay deduplicated; Resume retains the ledger
+  even after a local file is deleted. Copy everything now retains its documented
+  ability to restore deleted files and include older media.
+- Reset an exhausted budget while the source still fails: another three
+  attempts are allowed, rather than unlimited background attempts.
+- Save an exhausted item by hand and clear its stale failure on the next list.
+- Switch after tick captures A, during a list, after screenshot bookkeeping,
+  between media kinds, before a transfer, or before transfer bookkeeping.
+  Interrupted passes do not mark the other headset's IDs or continue copying.
+- Switch to B exactly at callback entry through the production `_sync_list`
+  adapter. `working(A)` refuses before calling the source list, leaving both
+  ledgers and copy callbacks untouched. The same production reservation blocks
+  a device switch during a list and rejects stale screenshot/clip transfers.
+- Execute the production Settings renderer in Node: Resume is available for
+  copy errors and disk-full pauses, and hidden for a healthy state.
+
+## Implementation boundary
+
+Each list callback now receives the captured device, like the copy callbacks.
+The existing server `working(meant)` mechanism checks that intended headset
+under `_work_lock` while reserving work; `devices_post` uses the same lock to
+refuse switches during that work. The worker also checks for interruption
+around lists and transfers. No new device lock or clip destination logic is
+introduced. The server diff is confined to `_sync_list`.
+
+The failed-attempt and error maps are in-memory and reset on explicit retry or
+restart. The successful-copy ledger and settings persistence retain their
+existing format. Disk-full pauses, offline backoff, clip settling and the
+three-attempt limit remain covered by the original tests.
+
+## Checks
+
+- `python3 -m unittest discover -s tests -p test_autosync.py -v`: 33 passed.
+- `python3 -m unittest discover -s tests -p test_shot_copy.py -v`: 2 passed.
+- `python3 -m unittest discover -s tests -p test_clips.py -v`: 34 passed,
+  including local ffmpeg coverage.
+- `python3 -m unittest discover -s tests -p test_service_regressions.py -v`:
+  36 passed.
+- `python3 -m unittest discover -s tests -p test_page_scripts.py -v`: 5 passed.
+- `node --test site/test/*.test.mjs`: 2 test files passed.
+- `python3 -m py_compile ui/frame_autosync.py ui/server.py tests/test_autosync.py`
+  and `git diff --check`: passed.
+
+- `python3 -m unittest discover -s tests -v`: 1,525 tests run in 184.876
+  seconds, passed with 16 skips. Ran with sandbox escalation for loopback
+  sockets; test isolation still used throwaway app/SSH data and mocked headset
+  transport. Final output:
+
+  ```text
+  Ran 1525 tests in 184.876s
+  OK (skipped=16)
+  ```
+
+## Limits and handoff
+
+All new regressions use fake sources and mocked transport; they do not prove
+real-headset transfer or UI rendering. No headset was accessed: its shared test
+lock was held by another task. The Docker fake-Frame end-to-end suite and
+Windows/macOS runs were not performed locally. The coordinator owns review and
+merge; this task does not release, change PR #113, or publish announcements.
@@ -0,0 +1,91 @@
+# Round 2 retry, 25 October 2026
+
+The provider retry completed four further fixes, each in an isolated child
+worktree with its own issue, branch, PR, tests, docs and Announcement draft.
+The coordinator reviewed each patch, independently ran focused tests, verified
+its exact head and complete CI, merged it, then read back GitHub's merged state.
+PR #113 was untouched. No social announcements were posted.
+
+## Merged fixes
+
+| Change | PR | Merge commit | Coordinator focused tests | Final CI |
+| --- | --- | --- | --- | --- |
+| Skip linked backup ancestors and recheck before packing | [#215](https://github.com/saphid/frame-control/pull/215) | `da34d94` | 34 passed | 11 checks passed at `8cc03c8` |
+| Clean orphan smoke metadata/shortcuts; POSIX runner without zsh | [#216](https://github.com/saphid/frame-control/pull/216) | `d5fa8fe` | 17 passed | 10 checks passed at `a5daa4a` |
+| Separate Steam clips by headset/account/full session ID | [#217](https://github.com/saphid/frame-control/pull/217) | `1255ef2` | 62 passed | 10 checks passed at `7dfe777` |
+| Retry failed automatic copies and bind listings to the captured headset | [#218](https://github.com/saphid/frame-control/pull/218) | `fdd60d3` | 33 passed | 10 checks passed at `af2bb17` |
+
+Two initial CI fixture failures were fixed before merging: macOS temporary-path
+aliases needed a resolved working directory in the wrapper test; Windows
+needed explicit UTF-8 when reading the Settings test's HTML fixture.
+Concurrent main changes #208/#209/#210 were preserved. Changelog conflicts
+retained both entries. No history was rewritten.
+
+## Integrated validation
+
+At main `1255ef2`, after all four merges:
+
+- `python3 -m unittest discover -s tests`: 1,559 tests, 16 skipped, passed in
+  157.335 seconds. Loopback networking was enabled for local HTTP fixtures.
+- `node --test app/test/*.test.js site/test/*.test.mjs`: 59 tests passed.
+- Worker backup validation also passed both Docker recovery-kit E2E tests in
+  an isolated Compose project, then removed its containers, volumes and network.
+- Local proof logs: `/tmp/frame-round2-integrated-tests.log` and
+  `/tmp/frame-round2-integrated-node.log`. Individual focused logs use
+  `/tmp/frame-round2-{backup,smoke,clips,autosync}-review.log`.
+
+## Real Frame smoke
+
+The current host is lxso2; its existing direct `ssh frame` alias works.
+Another OBS task initially held `/tmp/frame-test.lock`, so only read-only
+checks were done until it released the lock. This coordinator then acquired it
+atomically and labeled it `frame-round2-vdw4yh1xv8-20261025`.
+
+The merged `scripts/frame-smoke.sh` ran directly without zsh at 06:38:37 UTC.
+All 13 steps passed on SteamOS 0.5.6, BUILD_ID `20261022.6153909`. The ARM64
+and Proton titles ran. The x86-64 Linux title reported its runtime missing,
+an explicitly accepted smoke outcome rather than a successful execution.
+Installs/removals succeeded; the Windows title's remove
+step stopped five test-owned PIDs. Both final process sweeps were empty.
+Independent readback found no reserved title folders or metadata, SteamVR's
+PID was unchanged, and the three observed gamescope focus properties matched
+before/after. Battery went from 99% Charging to 100% Full. Only this task's
+lock was removed, and its absence was verified.
+
+[Sanitized structured proof](round2-smoke-2026-10-25.json). Raw local results:
+`/tmp/frame-round2-smoke-results/2026-10-25T063837Z-20261022.6153909.json`;
+console log `/tmp/frame-round2-headset-smoke.log`; state readbacks
+`/tmp/frame-round2-smoke-before.txt` and `/tmp/frame-round2-smoke-after.txt`.
+
+The headset was unworn. Visible rendering/controller input was not verified.
+No pairing, password/security change, reboot or factory reset was performed.
+The new backup/clip/auto-sync paths have local fixtures and cross-platform CI;
+this smoke does not establish a new real-data backup/clip/UI test. Synthetic
+orphan metadata was not seeded on the real device. Backup path checks retain
+a documented race with concurrent filesystem changes.
+
+## Prior round-two work reconciled
+
+The failed coordinator checkout was still at v0.4.7. It was first updated to
+main `d79efb4`, already v0.4.30. Earlier PRs had completed clipboard testing
+(#124), original smoke process cleanup (#126), Windows VM capture (#129),
+battery health (#125), setup doctor (#127), and read-only storage (#128).
+Later evidence already covered real clip export (#147/#149/#154/#156) and
+Return to Game Mode (#143/#157). These remain earlier evidence, not tests
+performed by this retry. Physical Windows GPU/input and current physical
+macOS checks remain incomplete; see the current support matrix.
+
+Decision: fix reproduced data/cleanup/retry defects rather than automate game
+moves without a verified transaction API or promise unverified phone-background
+sync. Prepare v0.4.31; publication still requires its Linux AppImage install test.
+
+## Delegation provenance
+
+All implementations completed. Task IDs use prefix
+`node:delegated-task:command%3Amcp%3Ad9bc35d8-0e9c-42c2-b798-25bd8af94d81%3Adelegate-task%3A`
+followed by one of:
+
+- `frame-r2-retry-smoke-orphans-20261025-r1`
+- `frame-r2-backup-symlink-20261025-r1`
+- `frame-r2-clip-collision-20261025-r1`
+- `frame-r2-autosync-retry-20261025-r1`
@@ -0,0 +1,123 @@
+{
+  "source_commit": "1255ef2bbf2e2e5fd86f8b984b592bed56f20780",
+  "started": "2026-10-25T06:38:37Z",
+  "os_release": {
+    "VERSION_ID": "0.5.6",
+    "VARIANT_ID": "vr",
+    "BUILD_ID": "20261022.6153909"
+  },
+  "passed": 13,
+  "failed": 0,
+  "paired": false,
+  "devkit_utils_there_before": true,
+  "battery_before": {
+    "capacity": 99,
+    "statuses": [
+      "Charging",
+      "Charging"
+    ]
+  },
+  "battery_after": {
+    "capacity": 100,
+    "statuses": [
+      "Full",
+      "Full"
+    ]
+  },
+  "steamvr_pid_before": 124586,
+  "steamvr_pid_after": 124586,
+  "observed_focus_properties_unchanged": true,
+  "reserved_files_and_processes_absent_after": true,
+  "own_shared_lock_released": true,
+  "headset_worn": false,
+  "steps": [
+    {
+      "step": "cleanup: leftovers from earlier runs",
+      "ok": true,
+      "seconds": 7.8,
+      "stopped_process_counts": [
+        0,
+        0
+      ]
+    },
+    {
+      "step": "devkit service: properties.json",
+      "ok": true,
+      "seconds": 0.0
+    },
+    {
+      "step": "status",
+      "ok": true,
+      "seconds": 0.6
+    },
+    {
+      "step": "arm64: install",
+      "ok": true,
+      "seconds": 7.7
+    },
+    {
+      "step": "arm64: launch",
+      "ok": true,
+      "seconds": 3.3,
+      "outcome": "running"
+    },
+    {
+      "step": "arm64: remove",
+      "ok": true,
+      "seconds": 6.4,
+      "stopped_process_counts": [
+        2,
+        0
+      ]
+    },
+    {
+      "step": "x86_64: install",
+      "ok": true,
+      "seconds": 7.6
+    },
+    {
+      "step": "x86_64: launch",
+      "ok": true,
+      "seconds": 3.2,
+      "outcome": "runtime missing"
+    },
+    {
+      "step": "x86_64: remove",
+      "ok": true,
+      "seconds": 6.2,
+      "stopped_process_counts": [
+        0,
+        0
+      ]
+    },
+    {
+      "step": "exe: install",
+      "ok": true,
+      "seconds": 7.5
+    },
+    {
+      "step": "exe: launch",
+      "ok": true,
+      "seconds": 3.3,
+      "outcome": "running"
+    },
+    {
+      "step": "exe: remove",
+      "ok": true,
+      "seconds": 6.5,
+      "stopped_process_counts": [
+        5,
+        0
+      ]
+    },
+    {
+      "step": "cleanup: everything this run installed",
+      "ok": true,
+      "seconds": 7.4,
+      "stopped_process_counts": [
+        0,
+        0
+      ]
+    }
+  ]
+}
@@ -0,0 +1,70 @@
+# Steam clip export collision fixtures, 25 October 2026
+
+Base: `d79efb4` (Frame Control v0.4.30). Issue:
+[#212](https://github.com/saphid/frame-control/issues/212).
+Host: Linux 6.8.0-139-generic, Python 3.12.3, ffmpeg 6.1.1.
+
+## Baseline reproduction
+
+Loaded the unmodified `ui/frame_clips.py` from `d79efb4` into a temporary
+Python module and exported three fake sources into a temporary directory:
+
+```
+1/clips/clip_620/video/bg
+2/clips/clip_620/video/bg
+1/clips/clip_620/video/other
+```
+
+Each source's payload was its own ID. All three exports returned the same
+destination, `clip_620.mp4`; listing marked all three saved. The final file
+contained only the last source ID. No SSH or headset was used.
+
+## Regression coverage
+
+`tests/test_clips.py` exports five IDs on each of two fake headsets, including
+equal clip names across accounts, nested sessions with equal leaf names,
+different leaf names under one clip and the background/clip distinction.
+All ten payloads survive at distinct destinations. Listing marks only the
+identities already exported. A pre-existing flat MP4 retains its original
+bytes and does not mark any identity saved. Normal export still returns
+`message` and `file`, removes its remote temporary export and clears local
+staging; a failed re-export preserves the completed file.
+
+`tests/test_clip_copy.py` exercises the server's list and manual export
+functions and its actual auto-sync callbacks with fake transport. A manual
+copy is recognised by auto-sync, all other account/session identities copy,
+and switching to a second headset copies its own sources without overwriting
+the first. A delayed manual job refuses a changed headset with status 409.
+Both local phone mode and local headset runtime reject Steam clip list,
+export and auto-sync requests with status 400. The separate `Recorder` path
+is unchanged.
+
+## Validation
+
+- `PYTHONPATH=tests python3 -m unittest test_clips test_clip_copy test_autosync test_shot_copy test_headset_actions -v`
+  — 66 tests passed in 17.288 seconds, no skips. Includes real ffmpeg/ffprobe
+  export of a generated 65-second DASH fixture and recording stop/cleanup.
+- `PYTHONPATH=tests python3 -m unittest test_server -v`
+  — 44 tests passed in 12.315 seconds, no skips.
+- `node --test site/test/*.test.mjs` — 2 tests passed.
+- `python3 -m unittest discover -s tests -v` — 1,518 tests run in
+  181.025 seconds; OK, 16 skipped for unavailable platform/tool prerequisites.
+- `python3 -m py_compile ui/frame_clips.py ui/server.py tests/test_clips.py tests/test_clip_copy.py`
+  and `git diff --check` — passed.
+
+The server and full Python suites require localhost sockets and were run
+outside the network sandbox. Tests import `tests/sandbox.py` to isolate app
+data, SSH settings, home directories and service URLs.
+
+## Limits and upgrade behaviour
+
+No real headset was accessed: the shared device lock is held by other work.
+This is Linux fixture and server coverage, not a fresh packaged-app or
+Windows/macOS verification. Existing real-headset export evidence in the
+recording guide predates this destination change.
+
+Old flat exports cannot prove headset/account/session identity and are left
+untouched. Previously remembered auto-sync IDs retain their existing
+watermark/history behaviour; **Copy everything now** or manual **Export**
+creates an identified copy. No release, version bump, merge or social post
+is included. PR #113 is outside this task.
@@ -14,8 +14,13 @@ panel. **Show in SteamVR** requests that dashboard tab; the wearer can select
 it again from SteamVR's dashboard. Closing the panel stops its browser and
 server. The service is not enabled at boot.

-The page shows battery, free home storage and SteamVR status. It can request
-SteamVR's main Game Mode dashboard, list and force quit a running game after an
+The page shows battery, free home storage and SteamVR status.
+The **Large status screen** uses large read-only values for battery, SteamVR,
+free home storage and Frame OS, with a refresh button and clear unknown values.
+It is an at-a-glance view, not a crash diagnosis or a Decky plugin page.
+The headset must still be worn to verify that a person can see and use it.
+
+The page can request SteamVR's main Game Mode dashboard, list and force quit a running game after an
 unsaved-progress confirmation, save an OpenVR screenshot to
 `~/Pictures/FrameControl`, and record the SteamVR mirror to
 `~/Videos/FrameControl`. Recordings have a 20-minute limit and use a separate
@@ -70,11 +70,31 @@ game recording path and were not checked for passthrough in this test.

 **Steam clips** lists what Steam's game recording has kept on the Frame: saved
 clips and background recordings, newest first, with the game, length and size.
-**Export** joins one into a single `.mp4` in `~/Videos/SteamFrame`, named after
-its folder (for example `clip_620_20261020_202134.mp4`), however long it is.
+**Export** joins one into a single `.mp4` under `~/Videos/SteamFrame`, named after
+its clip folder (for example `clip_620_20261020_202134.mp4`), however long it is.
 Steam's own export is reported to stop at about 60 seconds. Exports run in the
 background; ones already on your computer are marked.

+Each export keeps its headset, Steam account and complete recording session ID:
+
+```
+~/Videos/SteamFrame/headset-<id>/<account>/clips/<clip>/video/<session>/<clip>.mp4
+~/Videos/SteamFrame/headset-<id>/<account>/video/<session>/<session>.mp4
+```
+
+The headset folder uses the same short device-identity hash as screenshots.
+All folders in the Steam clip ID are kept, including nested sessions, so equal
+clip names across accounts, headsets or sessions keep separate files. Manual
+**Export** and automatic copying use the same path and saved marker. Exporting
+the same identified session again replaces only that session's export.
+
+Existing exports in the old flat `~/Videos/SteamFrame/<clip>.mp4` layout stay
+untouched. Their source identity cannot be proved, so they do not mark a clip
+as saved. Export again or use **Copy everything now** to make an identified
+copy. Automatic copying still remembers IDs copied before the upgrade; use
+**Copy everything now** to copy those again. This destination change has local
+fixture coverage; it has not been tested on a real headset.
+
 How it works: Steam keeps each recording as MPEG-DASH segments, one folder per
 recording session.

@@ -138,18 +158,29 @@ case was tested with separate fake sources, not two real same-name screenshots.
 - **When this computer is full** (under 512 MB free, or a copy runs out of
  space) it pauses and says so in Settings and above the lists. Free some space
  and press **Resume**.
- **With several headsets** it copies from the one you're connected to.
+- **When one file keeps failing** it tries at most three times, then leaves
+  the problem visible in Settings. Fix the source problem and press **Resume**
+  to allow another three attempts without restarting Frame Control. **Copy
+  everything now** also resets failed attempts and includes older files.
+  Resume keeps the history of successful copies, so it does not recopy them.
+- **With several headsets** each check and copy belongs to the headset selected
+  when the check began. Switching between lists or copies stops that pass;
+  another headset's saved files cannot become part of its copy history.

 Settings shows when it last checked, how many files it last copied and when,
 and the last problem it had. The screenshot and clip lists say when it's on.
+Retry and switch handling have offline regression coverage with fake sources;
+see the [test record](evidence/autosync-reliability-2026-10-25.md).

 ## For developers

 `ui/frame_clips.py` holds the logic, so other features can reuse it (automatic
 copying, in `ui/frame_autosync.py`, does):

- `list_clips(run_frame)` and `export_clip(id, run_frame, run, fetch)` are the
-  computer's side; the server passes how to reach the Frame.
+- `list_clips(run_frame, device_id=...)` and
+  `export_clip(id, run_frame, run, fetch, device_id=...)` are the computer's
+  side; the server passes how to reach the Frame and its pinned device identity.
+  Both use `clip_local_path(id, device_id, folder=None)` for the destination.
 - `list_recordings(userdata)` and `export(userdata, id)` are the Frame's side,
  run as `python3 - list` / `python3 - export ID` with the file on stdin.
 - `Recorder` runs one recording from Start to the copy.
@@ -172,7 +203,8 @@ The API, with the same guards as every other request:
 They aren't available when the server runs on the Frame itself (the iPhone
 app), since they save to a computer.

-Tests: `tests/test_clips.py`, and `tests/test_autosync.py` for automatic
+Tests: `tests/test_clips.py`, `tests/test_clip_copy.py` for server destinations
+and collision coverage, and `tests/test_autosync.py` for automatic
 copying (with a fake headset). They run the recording's shell under bash with a
 stand-in `ffmpeg`, so Stop, the time limit and the clean-up are tested as they
 run on the Frame. Where `ffmpeg` is installed, they also make a 65-second DASH
@@ -12,6 +12,21 @@ A fourth, a SteamOS VM, may come later ([issue #6](https://github.com/saphid/ste

 ## Unit tests

+Automatic screenshot and clip copying has offline coverage in
+`tests/test_autosync.py`:
+
+```sh
+python3 -m unittest discover -s tests -p test_autosync.py -v
+```
+
+Fake sources exercise the three-attempt limit, visible exhausted errors,
+Resume/Copy everything now recovery, successful-copy deduplication, disk-full
+pauses and headset changes around lists and transfers. Server tests use the
+production `working(meant)` reservation and listing/copy adapters; a Node test
+executes the Settings renderer to check that Resume is available after an error.
+These tests use no headset. See the
+[auto-sync reliability test record](evidence/autosync-reliability-2026-10-25.md).
+
 The gamescope keyboard/trackpad route has focused suites in `test_input.py`,
 `test_touch.py` and `test_service_regressions.py`. They cover pad translation,
 ASCII/modifier keys, Unicode queuing/retries, stale panel targets, release
@@ -246,7 +261,14 @@ title; the following process sweep found none. The final cleanup found no
 test titles or processes, the test desktop was closed, and the battery
 remained at 99%. That historical run used the Python entry point directly;
 the current POSIX wrapper has local offline coverage on a PATH without zsh.
-The orphan-metadata and shortcut follow-up has not been rerun on a headset.
+The current runner and all-six-ID cleanup sweeps passed another 13-step real
+Frame run on 25 October, build `20261022.6153909`, at source commit `1255ef2`.
+The Windows title's remove step stopped five test-owned Proton/wrapper PIDs;
+the final sweep and independent readback found no reserved files or processes.
+SteamVR stayed running, observed focus properties matched before/after, and
+this task's shared lock was released. The headset was unworn. This run did
+not seed synthetic orphan metadata or shortcuts; those cases use local
+fixtures. [Sanitized results](evidence/round2-smoke-2026-10-25.json).
 The local regression suite runs real Linux processes in temporary fake title
 directories (including deleted folders and a TERM-resistant wrapper); it checks
 exit, escalation and survival of unrelated processes. Local filesystem commands
@@ -7,11 +7,13 @@ import sandbox  # noqa: F401  (first: keeps tests off real data and services)
 import errno
 import json
 import shutil
+import subprocess
 import sys
 import tempfile
 import threading
 import unittest
 from pathlib import Path
+from unittest import mock

 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "ui"))
 import frame_autosync as fa  # noqa: E402
@@ -35,13 +37,15 @@ class FakeFrame:
        self.device, self.busy, self.down = "frame-a", False, False
        self.save_error = self.export_error = None

-    def list_shots(self):
+    def list_shots(self, device):
+        assert device == self.device
        self.calls.append("list_shots")
        if self.down:
            raise RuntimeError("ssh: connect to host frame port 22: Connection timed out")
        return {"shots": list(self.shots)}

-    def list_clips(self):
+    def list_clips(self, device):
+        assert device == self.device
        self.calls.append("list_clips")
        if self.down:
            raise RuntimeError("ssh: connect to host frame port 22: Connection timed out")
@@ -263,6 +267,134 @@ class AutoSyncTest(unittest.TestCase):
        for _ in range(fa.TRIES + 2):
            self.sync.tick()
        self.assertEqual(self.frame.calls.count("export_clip"), fa.TRIES)
+        self.assertIn("ffmpeg couldn't join", self.sync.state()["error"] or "")
+        self.assertIn("Resume", self.sync.state()["error"] or "")
+
+    def test_explicit_retry_recovers_without_recopying_successful_items(self):
+        for kind in ("shots", "clips"):
+            for action in ("resume", "copy_all"):
+                with self.subTest(kind=kind, action=action):
+                    self.frame = FakeFrame()
+                    f = self.frame
+                    sync = self.make()
+                    sync.update({"screenshots": True, "clips": True})
+                    f.shots, f.clips = [shot(1, NOW + 5)], [clip(1, NOW + 5)]
+                    error_attr = "save_error" if kind == "shots" else "export_error"
+                    copy_call = "save_shots" if kind == "shots" else "export_clip"
+                    setattr(f, error_attr, RuntimeError("source not ready"))
+                    for _ in range(fa.TRIES + 2):
+                        sync.tick()
+                    self.assertEqual(f.calls.count(copy_call), fa.TRIES)
+                    self.assertIn("source not ready", sync.state()["error"] or "")
+                    setattr(f, error_attr, None)
+                    sync.tick()  # recovery alone must not create unlimited automatic retries
+                    self.assertEqual(f.calls.count(copy_call), fa.TRIES)
+                    getattr(sync, action)()
+                    sync.tick()
+                    self.assertEqual(f.saved, [("frame-a", [shot(1, 0)["id"]])])
+                    self.assertEqual(f.exported, [("frame-a", clip(1, 0)["id"])])
+                    self.assertIsNone(sync.state()["error"])
+                    # Resume preserves the per-headset ledger even if a local file was deleted.
+                    for item in f.shots + f.clips:
+                        item["saved"] = False
+                    sync.resume()
+                    sync.tick()
+                    self.assertEqual((len(f.saved), len(f.exported)), (1, 1))
+                    self.sync.path.unlink(missing_ok=True)
+
+    def test_explicit_retry_is_still_bounded(self):
+        self.sync.update({"clips": True})
+        self.frame.clips = [clip(1, NOW + 5)]
+        self.frame.export_error = RuntimeError("bad source")
+        for action in ("resume", "copy_all"):
+            for _ in range(fa.TRIES + 2):
+                self.sync.tick()
+            before = self.frame.calls.count("export_clip")
+            getattr(self.sync, action)()
+            for _ in range(fa.TRIES + 2):
+                self.sync.tick()
+            self.assertEqual(self.frame.calls.count("export_clip") - before, fa.TRIES)
+            self.assertIn("bad source", self.sync.state()["error"] or "")
+
+    def test_failed_item_saved_by_hand_clears_error(self):
+        self.sync.update({"clips": True})
+        self.frame.clips = [clip(1, NOW + 5)]
+        self.frame.export_error = RuntimeError("bad source")
+        for _ in range(fa.TRIES + 1):
+            self.sync.tick()
+        self.frame.clips[0]["saved"] = True
+        self.sync.tick()
+        self.assertIsNone(self.sync.state()["error"])
+        self.assertIn(clip(1, 0)["id"], self.sync._synced("frame-a", "clips"))
+
+    def test_switch_after_capture_does_not_list_the_new_headset(self):
+        self.sync.update({"screenshots": True, "clips": True})
+        def switched():
+            self.frame.device = "frame-b"
+            return False
+        self.sync.busy = switched  # tick has already captured frame-a
+        self.assertEqual(self.sync.tick(), fa.BUSY_WAIT)
+        self.assertEqual(self.frame.calls, [])
+
+    def test_list_callbacks_receive_the_captured_device(self):
+        self.sync.update({"screenshots": True, "clips": True})
+        self.sync.list_shots = mock.Mock(return_value={"shots": []})
+        self.sync.list_clips = mock.Mock(return_value={"clips": []})
+        self.sync.tick()
+        self.sync.list_shots.assert_called_once_with("frame-a")
+        self.sync.list_clips.assert_called_once_with("frame-a")
+
+    def test_switch_during_listing_does_not_mark_or_copy_its_results(self):
+        for kind, item in (("shots", shot(1, NOW + 5)), ("clips", clip(1, NOW + 5))):
+            with self.subTest(kind=kind):
+                self.frame.device = "frame-a"
+                self.sync.update({"screenshots": kind == "shots", "clips": kind == "clips"})
+                def listing(*_args):
+                    self.frame.device = "frame-b"
+                    return {kind: [dict(item, saved=True), dict(item, id="uncopied", saved=False)]}
+                setattr(self.sync, "list_" + kind, listing)
+                self.assertEqual(self.sync.tick(), fa.BUSY_WAIT)
+                self.assertEqual(self.sync._synced("frame-a", kind), set())
+                self.assertEqual(self.sync._synced("frame-b", kind), set())
+                self.assertEqual((self.frame.saved, self.frame.exported), ([], []))
+
+    def test_switch_between_kinds_does_not_read_clips_or_mark_transfer(self):
+        self.sync.update({"screenshots": True, "clips": True})
+        self.frame.shots = [shot(1, NOW + 5)]
+        self.frame.clips = [clip(1, NOW + 5, saved=True)]
+        save = self.sync.save_shots
+        def then_switch(device, ids):
+            save(device, ids)
+            self.frame.device = "frame-b"
+        self.sync.save_shots = then_switch
+        self.assertEqual(self.sync.tick(), fa.BUSY_WAIT)
+        self.assertNotIn("list_clips", self.frame.calls)
+        self.assertEqual(self.sync._synced("frame-a", "clips"), set())
+        self.assertEqual(self.sync._synced("frame-a", "shots"), set())
+
+    def test_switch_after_bookkeeping_stops_before_next_kind(self):
+        self.sync.update({"screenshots": True, "clips": True})
+        self.frame.shots = [shot(1, NOW + 5, saved=True)]
+        mark = self.sync._mark
+        def then_switch(device, kind, ids):
+            mark(device, kind, ids)
+            self.frame.device = "frame-b"
+        self.sync._mark = then_switch
+        self.assertEqual(self.sync.tick(), fa.BUSY_WAIT)
+        self.assertNotIn("list_clips", self.frame.calls)
+
+    def test_switch_before_transfer_does_not_copy(self):
+        for kind, item in (("shots", shot(1, NOW + 5)), ("clips", clip(1, NOW + 5))):
+            with self.subTest(kind=kind):
+                self.frame.device = "frame-a"
+                self.sync.update({"screenshots": kind == "shots", "clips": kind == "clips"})
+                setattr(self.frame, kind, [item])
+                def switched_space(_folder):
+                    self.frame.device = "frame-b"
+                    return 100 * GB
+                self.sync.space = switched_space
+                self.assertEqual(self.sync.tick(), fa.BUSY_WAIT)
+                self.assertEqual((self.frame.saved, self.frame.exported), ([], []))

    def test_worker_stops(self):
        stop = threading.Event()
@@ -275,6 +407,75 @@ class AutoSyncTest(unittest.TestCase):


 class Server(unittest.TestCase):
+    def test_switch_at_list_callback_entry_does_not_read_or_mark_the_new_headset(self):
+        import server
+        with tempfile.TemporaryDirectory() as folder:
+            for kind in ("shots", "clips"):
+                with self.subTest(kind=kind):
+                    active = {"id": "frame-a"}
+                    link = mock.Mock()
+                    link.active_device.side_effect = lambda: dict(active)
+                    listing = mock.Mock(return_value={kind: [
+                        shot(1, NOW + 5, saved=True) if kind == "shots" else clip(1, NOW + 5, saved=True)]})
+                    def switch_then_list(device):
+                        active["id"] = "frame-b"
+                        return server._sync_list(listing)(device)
+                    with mock.patch.object(server, "LINK", link), mock.patch.object(server, "_work", [0]):
+                        sync = fa.AutoSync(switch_then_list, mock.Mock(), switch_then_list, mock.Mock(),
+                                           lambda: active["id"], lambda: False,
+                                           path=Path(folder) / (kind + ".json"), clock=lambda: NOW)
+                        sync.update({"screenshots": kind == "shots", "clips": kind == "clips"})
+                        sync.tick()
+                        listing.assert_not_called()
+                        sync.save_shots.assert_not_called()
+                        sync.export_clip.assert_not_called()
+                        self.assertEqual(sync._synced("frame-a", kind), set())
+                        self.assertEqual(sync._synced("frame-b", kind), set())
+                        self.assertIn("switched headsets", sync.state()["error"])
+                        self.assertEqual(server._work[0], 0)
+
+    def test_listing_rejects_switch_before_reserving_work(self):
+        import server
+        link = mock.Mock()
+        link.active_device.return_value = {"id": "frame-b"}
+        listing = mock.Mock(return_value={"shots": [shot(1, NOW, saved=True)]})
+        with mock.patch.object(server, "LINK", link), mock.patch.object(server, "_work", [0]):
+            with self.assertRaisesRegex(server.Failure, "switched headsets"):
+                server._sync_list(listing)("frame-a")
+            listing.assert_not_called()
+            self.assertEqual(server._work[0], 0)
+
+    def test_listing_reserves_work_on_the_captured_device(self):
+        import server
+        link = mock.Mock()
+        link.active_device.return_value = {"id": "frame-a", "name": "Frame A"}
+        def listing():
+            self.assertGreater(server._work[0], 0)
+            with self.assertRaises(server.Failure):
+                server.devices_post({"action": "use", "id": "frame-b"})
+            return {"shots": []}
+        with mock.patch.object(server, "LINK", link), \
+                mock.patch.object(server, "PRIVATE", False), mock.patch.object(server, "_work", [0]):
+            self.assertEqual(server._sync_list(listing)("frame-a"), {"shots": []})
+            self.assertEqual(server._work[0], 0)
+
+    def test_copy_rejects_switch_after_listing(self):
+        import server
+        link = mock.Mock()
+        link.active_device.return_value = {"id": "frame-a"}
+        with mock.patch.object(server, "LINK", link), mock.patch.object(server, "_work", [0]), \
+                mock.patch.object(server, "save_shots") as save, \
+                mock.patch.object(server.frame_clips, "export_clip") as export:
+            server._sync_list(lambda: {"shots": []})("frame-a")
+            link.active_device.return_value = {"id": "frame-b"}
+            for copy in (lambda: server._sync_shots("frame-a", [shot(1, NOW)["id"]]),
+                         lambda: server._sync_clip("frame-a", clip(1, NOW)["id"])):
+                with self.assertRaisesRegex(server.Failure, "switched headsets"):
+                    copy()
+            save.assert_not_called()
+            export.assert_not_called()
+            self.assertEqual(server._work[0], 0)
+
    def test_route_and_settings(self):
        import server
        self.assertIn("/api/autosync", server.POST)
@@ -287,5 +488,29 @@ class Server(unittest.TestCase):
                server.auto_sync({"action": "now"})  # nothing connected


+@unittest.skipUnless(shutil.which("node"), "Node exercises the Settings renderer")
+class Settings(unittest.TestCase):
+    def test_resume_is_available_after_a_copy_error(self):
+        page = (Path(__file__).resolve().parents[1] / "ui/index.html").read_text(encoding="utf-8")
+        script = page.split("const autoSync =", 1)[1].split("async function loadAutoSync", 1)[0]
+        harness = r'''
+const assert = require('node:assert/strict');
+const nodes = {};
+const $ = id => nodes[id] ||= {};
+const HOST = {mobile: false};
+const esc = value => value;
+'''
+        checks = r'''
+for (const state of [{error: 'Could not copy clip'}, {paused: 'Disk full'}, {}]) {
+  renderAutoSync(state);
+  assert.equal($('syncResume').hidden, !(state.error || state.paused));
+  if (state.error) assert.match($('syncStatus').textContent, /Could not copy clip/);
+}
+'''
+        result = subprocess.run(["node", "-e", harness + "const autoSync =" + script + checks],
+                                capture_output=True, text=True, timeout=10)
+        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+
+
 if __name__ == "__main__":
    unittest.main()
@@ -0,0 +1,115 @@
+"""Clip destinations through the server and automatic copying, without a headset."""
+import sandbox  # noqa: F401
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "ui"))
+import frame_autosync
+import frame_clips
+import server
+
+
+IDS = ["1/clips/clip_620/video/bg", "2/clips/clip_620/video/bg",
+       "1/clips/clip_620/video/other", "1/clips/other/video/bg"]
+NOW = 1800000000
+
+
+class ClipCopyTest(unittest.TestCase):
+    def setUp(self):
+        self.folder = Path(tempfile.mkdtemp(prefix="frame-clip-copy-"))
+        self.addCleanup(shutil.rmtree, self.folder, ignore_errors=True)
+        self.device = "frame-a"
+        self.link = mock.Mock()
+        self.link.active_device.side_effect = lambda: {"id": self.device, "name": self.device}
+        self.link.snapshot.return_value = {"phase": "connected"}
+        self.exports = []
+        self.payload = None
+        for name, value in (("LINK", self.link), ("LOCAL", False)):
+            patch = mock.patch.object(server, name, value)
+            patch.start()
+            self.addCleanup(patch.stop)
+        patch = mock.patch.object(frame_clips, "VIDEOS_DIR", self.folder)
+        patch.start()
+        self.addCleanup(patch.stop)
+        for name, fn in (("_clips_frame", self.frame), ("fetch_file", self.fetch),
+                         ("ssh", lambda *a, **k: "")):
+            patch = mock.patch.object(server, name, side_effect=fn)
+            patch.start()
+            self.addCleanup(patch.stop)
+        (self.folder / "clip_620.mp4").write_bytes(b"legacy export")
+
+    def frame(self, args, timeout):
+        if args == ["list"]:
+            return {"clips": [{"id": cid, "kind": "clip", "time": NOW + 5, "idle": 60} for cid in IDS]}
+        self.exports.append((self.device, args[1]))
+        self.payload = f"{self.device}: {args[1]}".encode()
+        return {"path": f"{frame_clips.WORK}/export-0123456789abcdef/clip_620.mp4",
+                "size": len(self.payload)}
+
+    def fetch(self, remote, target):
+        target.write_bytes(self.payload)
+
+    def test_manual_export_lists_only_matching_identity_and_keeps_job_shape(self):
+        with mock.patch.object(server, "start_job", side_effect=lambda label, work: work()) as job:
+            for device in ("frame-a", "frame-b"):
+                self.device = device
+                self.assertFalse(any(c["saved"] for c in server.list_clips()["clips"]))
+                result = server.export_clip({"id": IDS[0]})
+                self.assertEqual(set(result), {"message", "file"})
+                self.assertEqual(Path(result["file"]).read_bytes(), f"{device}: {IDS[0]}".encode())
+                self.assertEqual([c["saved"] for c in server.list_clips()["clips"]], [True, False, False, False])
+            self.assertEqual(job.call_args.args[0], "Export clip_620.mp4")
+        first = frame_clips.clip_local_path(IDS[0], "frame-a", self.folder)
+        self.assertEqual(first.read_bytes(), f"frame-a: {IDS[0]}".encode())
+        self.assertEqual((self.folder / "clip_620.mp4").read_bytes(), b"legacy export")
+
+    def test_auto_sync_uses_same_identity_as_manual_exports(self):
+        with mock.patch.object(server, "start_job", side_effect=lambda label, work: work()):
+            server.export_clip({"id": IDS[0]})
+        sync = frame_autosync.AutoSync(
+            server._sync_list(server.list_shots), server._sync_shots,
+            server._sync_list(server.list_clips), server._sync_clip,
+            server._sync_device, lambda: False, shots_folder=self.folder / "shots",
+            clips_folder=self.folder, path=self.folder / "auto-sync.json", clock=lambda: NOW,
+            space=lambda folder: 100 * 1024**3)
+        sync.update({"clips": True})
+        sync.tick()
+        self.assertEqual(self.exports, [("frame-a", cid) for cid in IDS])
+        self.device = "frame-b"
+        sync.tick()
+        self.assertEqual(self.exports, [(device, cid) for device in ("frame-a", "frame-b") for cid in IDS])
+        sync.tick()
+        self.assertEqual(len(self.exports), 8)
+        for device in ("frame-a", "frame-b"):
+            for cid in IDS:
+                target = frame_clips.clip_local_path(cid, device, self.folder)
+                self.assertEqual(target.read_bytes(), f"{device}: {cid}".encode())
+        self.assertEqual((self.folder / "clip_620.mp4").read_bytes(), b"legacy export")
+
+    def test_delayed_job_refuses_a_different_headset(self):
+        with mock.patch.object(server, "start_job", return_value={"job": "queued"}) as job:
+            self.assertEqual(server.export_clip({"id": IDS[0]}), {"job": "queued"})
+        self.device = "frame-b"
+        with self.assertRaises(server.Failure) as error:
+            job.call_args.args[1]()
+        self.assertEqual(error.exception.status, 409)
+        self.assertEqual(self.exports, [])
+
+    def test_local_and_headset_modes_reject_steam_clip_exports(self):
+        for headset in (False, True):
+            with self.subTest(headset=headset), mock.patch.object(server, "LOCAL", True), \
+                    mock.patch.object(server, "HEADSET_RUNTIME", headset):
+                for action in (server.list_clips, lambda: server.export_clip({"id": IDS[0]}),
+                               lambda: server.auto_sync({"action": "now"})):
+                    with self.assertRaises(server.Failure) as error:
+                        action()
+                    self.assertEqual(error.exception.status, 400)
+        self.assertEqual(self.exports, [])
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -71,6 +71,17 @@ class Ids(unittest.TestCase):
            with self.subTest(bad=bad), self.assertRaises(ValueError):
                clips.remove_command(bad)

+    def test_local_path_keeps_validated_identity_and_hashes_device_names(self):
+        folder = Path("exports")
+        target = clips.clip_local_path("123/clips/clip/video/session", "../../device:name", folder)
+        self.assertRegex(target.parts[1], r"^headset-[0-9a-f]{12}$")
+        self.assertEqual(target.parts[2:], ("123", "clips", "clip", "video", "session", "clip.mp4"))
+        for bad in (None, "", 42):
+            with self.subTest(device=bad), self.assertRaises(ValueError):
+                clips.clip_local_path("123/video/bg", bad, folder)
+        with self.assertRaises(ValueError):
+            clips.clip_local_path("../clips/clip", "frame-a", folder)
+
    def test_recording_names_checked(self):
        for fn in (clips.finish_command, clips.cleanup_command, lambda n: clips.record_command(n, True)):
            for bad in ("rec-1", "rec-20261020-201950; rm -rf ~", "../rec-20261020-201950", "*"):
@@ -156,10 +167,10 @@ class Sessions(unittest.TestCase):

    def test_listing_marks_what_is_already_here(self):
        here = self.dir / "here"
-        write(here / "clip_620_20261020_202134.mp4")
+        write(clips.clip_local_path("1/clips/clip_620_20261020_202134/video/bg", "frame-a", here))
        frame = lambda args, timeout: {"clips": [{"id": "1/clips/clip_620_20261020_202134/video/bg"},
                                                 {"id": "1/video/bg_620_20261020_201950"}]}
-        got = clips.list_clips(frame, folder=here)
+        got = clips.list_clips(frame, folder=here, device_id="frame-a")
        self.assertEqual([c["saved"] for c in got["clips"]], [True, False])
        self.assertEqual(got["folder"], str(here))

@@ -261,12 +272,16 @@ class ComputerSide(unittest.TestCase):
        frame = lambda args, timeout: calls.append(("frame", args)) or {"path": path, "size": 3}
        run = lambda cmd, timeout: calls.append(("run", cmd))
        fetch = lambda remote, local: calls.append(("fetch", remote)) or Path(local).write_bytes(b"mp4")
-        got = clips.export_clip("1/clips/clip_620/video/bg", frame, run, fetch, folder=self.dir)
+        got = clips.export_clip("1/clips/clip_620/video/bg", frame, run, fetch, folder=self.dir, device_id="frame-a")
        self.assertEqual(got["message"], "Saved clip_620.mp4 to ~/Videos/SteamFrame")
-        self.assertEqual((self.dir / "clip_620.mp4").read_bytes(), b"mp4")
+        target = clips.clip_local_path("1/clips/clip_620/video/bg", "frame-a", self.dir)
+        self.assertEqual(got["file"], str(target))
+        self.assertEqual(set(got), {"message", "file"})
+        self.assertEqual(target.read_bytes(), b"mp4")
        self.assertEqual([c[0] for c in calls], ["frame", "fetch", "run"])
        self.assertEqual(calls[2][1], clips.remove_command(path))
-        self.assertEqual([p.name for p in self.dir.iterdir()], ["clip_620.mp4"])
+        self.assertEqual(list(self.dir.rglob("*.mp4")), [target])
+        self.assertFalse(list(self.dir.glob(".incoming-*")))

    def test_failed_copy_leaves_no_partial_file_and_still_cleans_up(self):
        path = f"{clips.WORK}/export-0123456789abcdef/clip_620.mp4"
@@ -277,20 +292,62 @@ class ComputerSide(unittest.TestCase):
            raise RuntimeError("connection lost")
        with self.assertRaisesRegex(RuntimeError, "connection lost"):
            clips.export_clip("1/clips/clip_620/video/bg", lambda a, t: {"path": path, "size": 4},
-                              lambda cmd, timeout: ran.append(cmd), fetch, folder=self.dir)
+                              lambda cmd, timeout: ran.append(cmd), fetch, folder=self.dir, device_id="frame-a")
        self.assertEqual(list(self.dir.iterdir()), [])
        self.assertEqual(ran, [clips.remove_command(path)])

+    def test_same_names_keep_each_account_headset_kind_and_nested_session(self):
+        first = "1/clips/clip_620/video/bg"
+        ids = [first, "2/clips/clip_620/video/bg", "1/clips/clip_620/video/other",
+               "1/clips/clip_620/other/bg", "1/video/clip_620"]
+        legacy = write(self.dir / "clip_620.mp4", b"legacy export")
+        remote = f"{clips.WORK}/export-0123456789abcdef/clip_620.mp4"
+        frame = lambda args, timeout: {"clips": [{"id": cid} for cid in ids]}
+        stored = {}
+        for device in ("frame-a", "frame-b"):
+            self.assertFalse(any(c["saved"] for c in clips.list_clips(
+                frame, folder=self.dir, device_id=device)["clips"]))
+            for index, cid in enumerate(ids):
+                payload = f"{device} session {index}".encode()
+                result = clips.export_clip(cid, lambda a, t: {"path": remote, "size": len(payload)},
+                                           lambda c, t: None, lambda r, p: p.write_bytes(payload),
+                                           folder=self.dir, device_id=device)
+                stored[Path(result["file"])] = payload
+                listing = clips.list_clips(frame, folder=self.dir, device_id=device)
+                self.assertEqual([c["saved"] for c in listing["clips"]],
+                                 [n <= index for n in range(len(ids))])
+                self.assertEqual(listing["folder"], str(self.dir))
+        self.assertEqual(len(stored), len(ids) * 2)
+        for path, payload in stored.items():
+            self.assertEqual(path.read_bytes(), payload)
+        self.assertEqual(legacy.read_bytes(), b"legacy export")
+        self.assertFalse(list(self.dir.glob(".incoming-*")))
+
+    def test_failed_reexport_preserves_completed_export(self):
+        cid = "1/clips/clip_620/video/bg"
+        target = write(clips.clip_local_path(cid, "frame-a", self.dir), b"completed")
+        remote = f"{clips.WORK}/export-0123456789abcdef/clip_620.mp4"
+
+        def fetch(remote, local):
+            local.write_bytes(b"partial")
+            raise RuntimeError("connection lost")
+
+        with self.assertRaisesRegex(RuntimeError, "connection lost"):
+            clips.export_clip(cid, lambda a, t: {"path": remote}, lambda c, t: None, fetch,
+                              folder=self.dir, device_id="frame-a")
+        self.assertEqual(target.read_bytes(), b"completed")
+        self.assertFalse(list(self.dir.glob(".incoming-*")))
+
    def test_bad_id_never_reaches_the_frame(self):
        never = mock.Mock(side_effect=AssertionError("reached the Frame"))
        with self.assertRaises(ValueError):
-            clips.export_clip("1/video/../../.ssh", never, never, never, folder=self.dir)
+            clips.export_clip("1/video/../../.ssh", never, never, never, folder=self.dir, device_id="frame-a")

    def test_unexpected_path_from_the_frame_refused(self):
        never = mock.Mock(side_effect=AssertionError("deleted or copied"))
        with self.assertRaises(ValueError):
            clips.export_clip("1/video/bg", lambda a, t: {"path": ".ssh/id_ed25519", "size": 1}, never, never,
-                              folder=self.dir)
+                              folder=self.dir, device_id="frame-a")


 class Commands(unittest.TestCase):
@@ -16,9 +16,9 @@ saved Steam clips to ~/Videos/SteamFrame.
 - When the headset can't be reached it waits longer each time, up to MAX_BACKOFF.

 The server supplies how to reach the headset, so this can be tested without one:
-  list_shots() -> {"shots": [{"id", "time", "saved"}...]}
+  list_shots(device) -> {"shots": [{"id", "time", "saved"}...]}
  save_shots(device, ids) copies those screenshots here
-  list_clips() -> {"clips": [{"id", "kind", "time", "idle", "saved"}...]}
+  list_clips(device) -> {"clips": [{"id", "kind", "time", "idle", "saved"}...]}
  export_clip(device, id) exports one clip here
  device() -> the connected headset's id, or None
  busy() -> True while other work runs on the headset (installs, jobs, a recording)
@@ -41,7 +41,7 @@ SETTLE = 30  # a clip written to within this many seconds is still being recorde
 MIN_FREE = 512 * 1024**2  # pause below this much free space on this computer
 KEEP = 5000  # copied ids remembered per headset and kind
 BATCH = 100  # screenshots per copy
-TRIES = 3  # an item that fails this often is left until the app restarts
+TRIES = 3  # failed attempts per item until Resume, Copy everything now, or restart
 KINDS = ("shots", "clips")


@@ -86,6 +86,7 @@ class AutoSync:
        self._running = False
        self._backoff = 0
        self._tries = {}  # (device, id) -> failed attempts this run
+        self._failures = {}  # last error for each failed item, including exhausted retries
        self._errors = []  # this pass's, for the page
        self._s = self._load()

@@ -143,13 +144,19 @@ class AutoSync:
        """Copy everything on the headset that isn't on this computer, once (also resumes)."""
        with self._lock:
            self._all, self._s["paused"] = True, None
+            self._tries.clear()
+            self._failures.clear()
+            self._s["error"] = None
            self._save()
+        self._backoff = 0
        self._wake.set()
        return self.state()

    def resume(self):
        with self._lock:
            self._s["paused"], self._s["error"] = None, None
+            self._tries.clear()
+            self._failures.clear()
            self._save()
        self._backoff = 0
        self._wake.set()
@@ -215,6 +222,9 @@ class AutoSync:

    def _mark(self, device, kind, ids):
        with self._lock:
+            for item in ids:
+                self._tries.pop((device, item), None)
+                self._failures.pop((device, item), None)
            per = self._s["synced"].setdefault(device, {})
            have = per.get(kind, [])
            new = [i for i in ids if i not in set(have)]
@@ -233,24 +243,46 @@ class AutoSync:
                           "then press Resume.")
        if self.offline(error):
            raise error
-        key = (device, item)
-        self._tries[key] = self._tries.get(key, 0) + 1
-        self._errors.append(f"Couldn't copy {item.rsplit('/', 1)[-1]}: {error}")
+        with self._lock:
+            key = (device, item)
+            self._tries[key] = self._tries.get(key, 0) + 1
+            message = f"Couldn't copy {item.rsplit('/', 1)[-1]}: {error}"
+            if self._tries[key] >= TRIES:
+                message += ". Automatic retries stopped. Press Resume to try again."
+            self._failures[key] = message
+            self._errors.append(message)
+
+    def _retry_allowed(self, device, item):
+        with self._lock:
+            key = (device, item)
+            if self._tries.get(key, 0) < TRIES:
+                return True
+            self._errors.append(self._failures[key])
+            return False
+
+    def _interrupted(self, device):
+        return self.busy() or self.device() != device

    def _pass(self, device, shots, clips, since):
        """-> (copied, clips still being written, finished without stopping for other work)."""
        copied = waiting = 0
        if shots:
-            listing = self.list_shots()["shots"]
+            if self._interrupted(device):
+                return copied, waiting, False
+            listing = self.list_shots(device)["shots"]
+            if self._interrupted(device):
+                return copied, waiting, False
            done = self._synced(device, "shots")
            self._mark(device, "shots", [s["id"] for s in listing if s.get("saved")])
            todo = [s["id"] for s in sorted(listing, key=lambda s: s["time"])
                    if not s.get("saved") and (since is None or (s["time"] >= since and s["id"] not in done))
-                    and self._tries.get((device, s["id"]), 0) < TRIES]
+                    and self._retry_allowed(device, s["id"])]
            for i in range(0, len(todo), BATCH):
-                if self.busy():
+                if self._interrupted(device):
                    return copied, waiting, False
                self._room(self.shots_folder)
+                if self._interrupted(device):
+                    return copied, waiting, False
                batch = todo[i:i + BATCH]
                try:
                    self.save_shots(device, batch)
@@ -258,28 +290,40 @@ class AutoSync:
                    for item in batch:
                        self._failed(device, item, e)
                    continue
+                if self.device() != device:
+                    return copied, waiting, False
                self._mark(device, "shots", batch)
                copied += len(batch)
        if clips:
-            listing = [c for c in self.list_clips()["clips"] if c.get("kind") == "clip"]
+            if self._interrupted(device):
+                return copied, waiting, False
+            listing = [c for c in self.list_clips(device)["clips"] if c.get("kind") == "clip"]
+            if self._interrupted(device):
+                return copied, waiting, False
            done = self._synced(device, "clips")
            self._mark(device, "clips", [c["id"] for c in listing if c.get("saved")])
            for c in sorted(listing, key=lambda c: c["time"]):
-                if c.get("saved") or self._tries.get((device, c["id"]), 0) >= TRIES:
+                if c.get("saved"):
                    continue
                if since is not None and (c["time"] < since or c["id"] in done):
                    continue
+                if not self._retry_allowed(device, c["id"]):
+                    continue
                if c.get("idle") is None or c["idle"] < SETTLE:
                    waiting += 1  # still being written: copied on a later look
                    continue
-                if self.busy():
+                if self._interrupted(device):
                    return copied, waiting, False
                self._room(self.clips_folder)
+                if self._interrupted(device):
+                    return copied, waiting, False
                try:
                    self.export_clip(device, c["id"])
                except Exception as e:
                    self._failed(device, c["id"], e)
                    continue
+                if self.device() != device:
+                    return copied, waiting, False
                self._mark(device, "clips", [c["id"]])
                copied += 1
        return copied, waiting, True
@@ -26,6 +26,7 @@ that stream. The folder names are as users and Steam's own files describe them;
 listing doesn't depend on them: any folder under clips/ or video/ (up to four levels)
 holding init-stream*.m4s counts as a session.
 """
+import hashlib
 import json
 import os
 import re
@@ -363,10 +364,20 @@ def parse_id(clip_id):


 def export_name(clip_id):
-    """The .mp4's name on the computer: the clip's (or background session's) own folder name."""
+    """The .mp4's basename; it alone does not identify a saved export."""
    return parse_id(clip_id)[2] + ".mp4"


+def clip_local_path(clip_id, device_id, folder=None):
+    """Keep the headset, account and full Steam session identity in the destination."""
+    parts = parse_id(clip_id)
+    if not isinstance(device_id, str) or not device_id:
+        raise ValueError("missing clip headset identity")
+    headset = hashlib.sha256(device_id.encode("utf-8")).hexdigest()[:12]
+    folder = Path(folder) if folder else VIDEOS_DIR
+    return folder / f"headset-{headset}" / Path(*parts) / export_name(clip_id)
+
+
 def read_session(folder):
    """{stream number: [init, chunk, chunk...]} for one session folder, chunks in number
    order. A stream without its init segment or without chunks can't be played, so it's left out."""
@@ -552,19 +563,20 @@ def remove_command(path):
 # run_frame(args, timeout) runs this file on the Frame with `args` and returns its JSON;
 # run(command, timeout) and fetch(remote, local) as for Recorder.

-def list_clips(run_frame, folder=None):
+def list_clips(run_frame, folder=None, *, device_id):
    """Steam's recordings on the Frame, each marked saved if its .mp4 is already here."""
    folder = Path(folder) if folder else VIDEOS_DIR
    clips = run_frame(["list"], 60)["clips"]
    for c in clips:
-        c["saved"] = (folder / export_name(c["id"])).exists()
+        c["saved"] = clip_local_path(c["id"], device_id, folder).is_file()
    return {"clips": clips, "folder": str(folder)}


-def export_clip(clip_id, run_frame, run, fetch, folder=None):
+def export_clip(clip_id, run_frame, run, fetch, folder=None, *, device_id):
    """Stitch a Steam recording on the Frame and copy the .mp4 here. -> {"message", "file"}."""
    folder = Path(folder) if folder else VIDEOS_DIR
-    name = export_name(clip_id)  # checks the id before anything reaches the Frame
+    target = clip_local_path(clip_id, device_id, folder)  # validate before reaching the Frame
+    name = target.name
    made = run_frame(["export", clip_id], 1900)
    path = made.get("path")
    remove = remove_command(path)  # refuses a path that isn't one of our exports
@@ -573,7 +585,8 @@ def export_clip(clip_id, run_frame, run, fetch, folder=None):
        incoming = Path(tempfile.mkdtemp(prefix=".incoming-", dir=folder))
        try:
            fetch(path, incoming / name)
-            os.replace(incoming / name, folder / name)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            os.replace(incoming / name, target)
        finally:
            shutil.rmtree(incoming, ignore_errors=True)
    finally:
@@ -581,7 +594,7 @@ def export_clip(clip_id, run_frame, run, fetch, folder=None):
            run(remove, 30)
        except Exception:
            pass  # the next export sweeps it
-    return {"message": f"Saved {name} to ~/Videos/SteamFrame", "file": str(folder / name)}
+    return {"message": f"Saved {name} to ~/Videos/SteamFrame", "file": str(target)}


 # ---- on the Frame -----------------------------------------------------------------
@@ -13,7 +13,12 @@ button:focus-visible{outline:5px solid #f8d370;outline-offset:3px}button:disable
 button.secondary{background:#253c50;border-color:#617f97}button.danger{background:#78372d;border-color:#d78d79}
 small{color:#b9c9d6}#message,#actionStatus{min-height:1.5em;margin:12px 0}.game{display:flex;gap:14px;justify-content:space-between;align-items:center}
 iframe{display:block;width:100%;height:560px;background:#0d1925;border:1px solid #617f97;border-radius:12px;margin-top:14px}
-@media(max-width:720px){.cards{grid-template-columns:1fr}body{padding:18px}.game{display:block}.game button{margin-top:12px}}
+#statusScreen[hidden]{display:none}#statusScreen{position:fixed;inset:0;z-index:10;overflow:auto;background:#07131f;padding:30px}
+#statusScreen h2{font-size:clamp(40px,6vw,76px);margin:10px 0 20px}#statusScreen .cards{grid-template-columns:repeat(2,minmax(0,1fr))}
+#statusScreen .card{min-height:170px}#statusScreen .value{font-size:clamp(40px,6vw,76px)}
+#statusScreen .value.warn{color:#ffd27a}#statusScreen .value.bad{color:#ff9585}
+#statusScreen .meta{font-size:20px;margin-top:22px;color:#b9c9d6}
+@media(max-width:720px){.cards,#statusScreen .cards{grid-template-columns:1fr}body{padding:18px}.game{display:block}.game button{margin-top:12px}}
 </style></head><body>
 <h1>Frame Control</h1><p>Your Frame, from inside SteamVR. Select this panel again from the dashboard after switching away.</p>
 <div class="cards">
@@ -22,9 +27,20 @@ iframe{display:block;width:100%;height:560px;background:#0d1925;border:1px solid
  <div class="card"><span class="label">SteamVR</span><span class="value" id="steamvr">…</span></div>
 </div>
 <p id="message" role="status" aria-live="polite"></p>
-<div class="row"><button id="refresh">Refresh status</button><button id="gameMode" class="secondary">Return to Game Mode</button>
+<div class="row"><button id="refresh">Refresh status</button><button id="statusScreenOpen" class="secondary">Large status screen</button><button id="gameMode" class="secondary">Return to Game Mode</button>
  <button id="screenshot" class="secondary">Save screenshot</button><button id="record" class="secondary">Start recording</button></div>
 <p id="actionStatus" role="status" aria-live="polite"></p>
+<section id="statusScreen" role="dialog" aria-modal="true" aria-labelledby="statusScreenTitle" hidden>
+  <div class="row"><button id="statusScreenClose">Close status screen</button><button id="statusScreenRefresh" class="secondary">Refresh</button></div>
+  <h2 id="statusScreenTitle">Frame status</h2>
+  <div class="cards">
+    <div class="card"><span class="label">Battery</span><span class="value" id="bigBattery">…</span></div>
+    <div class="card"><span class="label">SteamVR</span><span class="value" id="bigSteamvr">…</span></div>
+    <div class="card"><span class="label">Home storage free</span><span class="value" id="bigStorage">…</span></div>
+    <div class="card"><span class="label">Frame OS</span><span class="value" id="bigOs">…</span></div>
+  </div>
+  <p id="bigStatusMessage" class="meta" role="status" aria-live="polite">Read-only status. This view does not diagnose a crash.</p>
+</section>
 <h2>Running games</h2><div class="row"><button id="gamesRefresh" class="secondary">Refresh games</button></div>
 <div id="games" class="stack" style="margin-top:12px">Loading…</div>
 <h2>Decky plugins</h2><p>Manage official store plugins here. Their backend can run on Frame, but Decky's Steam Deck Quick Access Menu is absent from this VR shell. Plugin pages, settings, routes, and toasts are not yet available in this panel.</p>
@@ -51,7 +67,20 @@ async function refresh(){try{const status=latestStatus=await api('/api/status');
  byId('storage').textContent=Number.isFinite(free)?`${(free/1e9).toFixed(1)} GB`:'Unavailable';
  byId('steamvr').textContent=status.services?.steamvr?'Running':'Unavailable';
  byId('message').textContent=`Frame OS ${status.os?.version||'unknown'} · Updated ${new Date().toLocaleTimeString()}`;
-  }catch(error){latestStatus=null;byId('message').textContent=error.message;}}
+  renderLargeStatus(status);
+  }catch(error){latestStatus=null;byId('message').textContent=error.message;renderLargeStatus(null,error.message);}}
+function renderLargeStatus(status,error=''){
+  const battery=status?.battery?.percent;
+  byId('bigBattery').textContent=Number.isFinite(battery)?`${battery}%`:'Unavailable';
+  byId('bigBattery').className='value'+(Number.isFinite(battery)&&battery<20?' bad':Number.isFinite(battery)&&battery<40?' warn':'');
+  byId('bigSteamvr').textContent=status?.services?.steamvr?'Running':'Unavailable';
+  byId('bigSteamvr').className='value'+(status?.services?.steamvr?'':' bad');
+  const free=status?.disk?.home?.free;
+  byId('bigStorage').textContent=Number.isFinite(free)?`${(free/1e9).toFixed(1)} GB`:'Unavailable';
+  byId('bigStorage').className='value'+(Number.isFinite(free)&&free<5e9?' warn':'');
+  byId('bigOs').textContent=status?.os?.version||'Unknown';
+  byId('bigStatusMessage').textContent=error||`Read-only status · Frame OS build ${status?.os?.build||'unknown'} · Updated ${new Date().toLocaleTimeString()}. This view does not diagnose a crash.`;
+}
 async function act(action){const button=byId(action==='game-mode'?'gameMode':'screenshot');button.disabled=true;
  try{const result=await api('/api/headset/quick',{action});byId('actionStatus').textContent=result.message;}
  catch(error){byId('actionStatus').textContent=error.message;}finally{button.disabled=false;}}
@@ -115,6 +144,10 @@ async function refreshExtensions(){const list=byId('extensions');try{const data=
  if(data.errors.length){const errors=document.createElement('p');errors.textContent=data.errors.map(x=>`${x.folder}: ${x.error}`).join('; ');list.append(errors);}
  }catch(error){list.textContent=error.message;}}
 byId('refresh').onclick=refresh;byId('gameMode').onclick=()=>act('game-mode');byId('screenshot').onclick=()=>act('screenshot');
+byId('statusScreenOpen').onclick=()=>{byId('statusScreen').hidden=false;renderLargeStatus(latestStatus);byId('statusScreenClose').focus();};
+byId('statusScreenClose').onclick=()=>{byId('statusScreen').hidden=true;byId('statusScreenOpen').focus();};
+byId('statusScreenRefresh').onclick=refresh;
+window.addEventListener('keydown',event=>{if(event.key==='Escape'&&!byId('statusScreen').hidden)byId('statusScreenClose').click();});
 byId('gamesRefresh').onclick=refreshGames;byId('record').onclick=toggleRecord;byId('extensionsRefresh').onclick=refreshExtensions;
 byId('deckyRefresh').onclick=refreshDecky;byId('deckyStoreLoad').onclick=loadDeckyStore;byId('deckySearch').oninput=showDeckyStore;
 byId('extensionClose').onclick=()=>{activeExtension=null;byId('extensionFrame').removeAttribute('src');byId('extensionPanel').hidden=true;};
@@ -5619,7 +5619,7 @@ const syncWhen = t => new Date(t * 1000).toLocaleString([], { dateStyle: "medium
 function renderAutoSync(s) {
  autoSync.s = s;
  $("syncShots").checked = s.screenshots; $("syncClips").checked = s.clips;
-  $("syncResume").hidden = !s.paused;
+  $("syncResume").hidden = !(s.paused || s.error);
  const on = s.screenshots || s.clips, lines = [];
  if (s.paused) lines.push(s.paused);
  else if (s.error) lines.push(`Last problem: ${s.error}`);
@@ -928,7 +928,9 @@ def _clips_frame(args, timeout):
 def list_clips():
    _clips_here()
    try:
-        return frame_clips.list_clips(_clips_frame)
+        device = agent_target()["id"]
+        with working(device):
+            return frame_clips.list_clips(_clips_frame, device_id=device)
    except frame_clips.ClipError as e:
        raise Failure(str(e), e.status)

@@ -938,11 +940,13 @@ def export_clip(body):
    _clips_here()
    clip_id = body.get("id")
    name = frame_clips.export_name(clip_id)  # ValueError, so 400, for a bad id
+    device = agent_target()["id"]

    def work():
        try:
-            return frame_clips.export_clip(clip_id, _clips_frame, lambda cmd, timeout: ssh(cmd, timeout=timeout),
-                                           fetch_file)
+            with working(device):
+                return frame_clips.export_clip(clip_id, _clips_frame, lambda cmd, timeout: ssh(cmd, timeout=timeout),
+                                               fetch_file, device_id=device)
        except frame_clips.ClipError as e:
            raise Failure(str(e), e.status)
    return start_job(f"Export {name}", work)
@@ -965,12 +969,12 @@ def _sync_shots(device, ids):
 def _sync_clip(device, clip_id):
    with working(device):
        return frame_clips.export_clip(clip_id, _clips_frame, lambda cmd, timeout: ssh(cmd, timeout=timeout),
-                                       fetch_file)
+                                       fetch_file, device_id=device)


 def _sync_list(listing):
-    def run():
-        with working(_sync_device()):
+    def run(device):
+        with working(device):
            return listing()
    return run
Author	SHA1	Message	Date
Alex SouthwellandSAPHID	f0f39ac823	Prepare Frame Control 0.4.31 and record round-two validation (#221 ) * Prepare Frame Control 0.4.31 with round-two validation * State the x86 Linux runtime limit in smoke evidence --------- Co-authored-by: SAPHID <saphid@users.noreply.github.com>	2026-10-25 06:54:03 +00:00
Alex SouthwellandSAPHID	1252ecc7af	Add read-only large status screen to headset panel (#220 ) Co-authored-by: SAPHID <saphid@users.noreply.github.com>	2026-10-25 06:46:01 +00:00
Alex SouthwellandSAPHID	7b53af1c18	Fix OBS lifecycle cleanup and validate real headset capture (#219 ) Co-authored-by: SAPHID <saphid@users.noreply.github.com>	2026-10-25 06:42:11 +00:00
Alex SouthwellandSAPHID	1255ef2bbf	Fix Steam clip export collisions across headsets, accounts and sessions (#217 ) * Fix Steam clip export collisions across headset and session identities * Group clip export changelog with screenshot copying --------- Co-authored-by: SAPHID <saphid@users.noreply.github.com>	2026-10-25 06:37:51 +00:00
Alex SouthwellandSAPHID	fdd60d3ccd	Fix auto-sync retry recovery and headset-bound listings (#218 ) * Fix auto-sync retry recovery and headset-bound listings * Read auto-sync Settings fixture as UTF-8 on Windows * Keep auto-sync changelog separate from parallel fixes --------- Co-authored-by: SAPHID <saphid@users.noreply.github.com>	2026-10-25 06:35:47 +00:00