Releasing 1.0.0-beta.3

.github/workflows/finalise-release.yml

@@ -62,7 +62,6 @@ jobs:
                   VERSION: ${{ inputs.version }}
                   EXPECTED_HEAD_SHA: ${{ inputs.expected_head_sha }}
                   PRERELEASE: ${{ inputs.prerelease }}
-                  PUBLISH_CLI: ${{ inputs.publish_cli }}
               run: |
                   set -euo pipefail
                   ACTUAL_HEAD_SHA="$(git rev-parse HEAD)"
@@ -74,10 +73,6 @@ jobs:
                     echo "Version ${VERSION} is a pre-release version, but prerelease was not enabled." >&2
                     exit 1
                   fi
-                  if [[ "${VERSION}" != *-* && "${PRERELEASE}" == "true" && "${PUBLISH_CLI}" == "true" ]]; then
-                    echo "A stable version staged as a pre-release must use publish_cli=false so that the CLI latest and major-minor image tags do not advance before BRAT validation." >&2
-                    exit 1
-                  fi
                   node utils/release-notes.mjs validate "${VERSION}"
 
             - name: Ensure and push release tags
@@ -125,13 +120,8 @@ jobs:
                     echo ""
                     echo "Dispatched the plug-in release workflow for \`${VERSION}\`. After approval for the release environment, it creates a draft GitHub Release."
                     echo ""
-                    if [[ "${VERSION}" == *-* ]]; then
-                      echo "Publish the draft as a pre-release without replacing the latest stable release."
-                      echo "Keep the release pull request in draft and unmerged after BRAT validation; close it only through a separate maintainer action."
-                    elif [[ "${PRERELEASE}" == "true" ]]; then
-                      echo "Publish the draft initially as a pre-release without replacing the latest stable release."
-                      echo "After BRAT validation, remove the pre-release designation and make this exact release the latest stable release before merging the release pull request."
-                      echo "Create the stable CLI tag and publish its latest and major-minor image tags through a separate maintainer gate."
+                    if [[ "${PRERELEASE}" == "true" ]]; then
+                      echo "Publish the draft as a pre-release, keep the release pull request in draft, and merge only after BRAT validation succeeds."
                     else
                       echo "Publish the draft as the latest stable release, keep the release pull request in draft, and merge only after BRAT validation succeeds."
                     fi

devs.md

@@ -244,9 +244,7 @@ export class ModuleExample extends AbstractObsidianModule {
 - Use SemVer beta identifiers such as `1.0.0-beta.0` for immutable integration previews. Increment the beta number when a published preview needs a correction. Reserve `1.0.0-rc.0` for the first feature- and contract-frozen release candidate. Historical `-patchedN` releases remain unchanged in the release history.
 - Publish a pre-release from an immutable reviewed tag, mark its GitHub Release as a pre-release, and do not replace the latest stable release.
 - A plug-in review release may omit the CLI image when the CLI artefact is not part of the required validation. When a pre-release CLI image is published, it receives immutable version and SHA-qualified tags only; it must not advance `latest` or a stable major-minor tag.
-- Keep a hyphenated pre-release's release pull request in draft and unmerged after BRAT validation. Reconcile the published version's metadata into its base branch through a reviewed metadata-only commit, then close the release pull request only through a separate maintainer action.
-- Stage a stable version for BRAT by publishing its exact `x.y.z` tag initially as a GitHub pre-release with `prerelease=true` and `publish_cli=false`. The stable manifest version would otherwise make the CLI workflow advance `latest` and the major-minor image tag before validation.
-- If validation fails, leave every published tag unchanged and prepare the next pre-release or patch version.
+- Keep the release pull request in draft until the exact published plug-in has passed BRAT validation. If validation fails, prepare the next pre-release version rather than moving the existing tag.
 
 ## Release Notes
 
@@ -266,15 +264,13 @@ The `Finalise Release Tags` and `Release Obsidian Plugin` workflows use the `rel
 - Do not tag the release branch when the PR is first created. Polish the release PR first, especially `updates.md`.
 - Once the release PR head is fixed, run the `Finalise Release Tags` workflow with its full head commit SHA. It validates the release branch, ensures that the plug-in tag points to that commit, optionally creates the corresponding CLI tag, and dispatches the plug-in release workflow. A CLI tag starts its own container workflow. The finalisation workflow can be retried when existing tags already point to the reviewed commit, but stops if a selected tag points elsewhere.
 - The plug-in publishing workflow is intentionally dispatch-only. Pushing a plug-in tag directly does not publish a GitHub Release; use `Finalise Release Tags`, or dispatch `Release Obsidian Plugin` explicitly for recovery or a pre-release. The CLI Docker workflow retains its documented branch, tag, and manual triggers.
-- For a hyphenated pre-release, run finalisation with `prerelease=true`; CLI publication remains optional. For a stable version awaiting BRAT validation, use `prerelease=true` and `publish_cli=false`.
-- Approve the `Release Obsidian Plugin` workflow for the `release` environment, then inspect the generated draft GitHub Release. When a hyphenated pre-release includes the CLI, confirm that it received only its immutable version and SHA-qualified image tags.
-- Publish the draft as a GitHub pre-release without replacing the latest stable release. Keep its release pull request in draft and leave its base branch unchanged throughout BRAT validation. Record that state in the pull request.
+- Approve the `Release Obsidian Plugin` workflow for the `release` environment, then inspect the generated draft GitHub Release. For a selected CLI publication, confirm the image tags appropriate to a stable or pre-release version.
+- Publish a stable draft as the latest release, or publish a pre-release draft without replacing the latest stable release. In either case, keep the release PR in draft and leave its base branch unchanged until BRAT validation succeeds. Record that state in the PR.
 - Validate the published release through BRAT. Confirm start-up, ordinary bidirectional synchronisation, and any regression scenario relevant to the release.
-- After a hyphenated pre-release passes, keep its release pull request unmerged. Add a reviewed metadata-only commit to the selected base branch which records the published version in `versions.json` and moves its exact tagged release notes out of `## Unreleased`, then close the release pull request only through a separate maintainer action.
-- After a stable version passes, remove its GitHub pre-release designation and make that exact release the latest stable release. Create the stable CLI tag and publish its `latest` and major-minor image tags, if selected, through a separate maintainer gate. Only then mark the stable release pull request ready and merge it into the selected base branch with a merge commit.
+- After BRAT validation succeeds, mark the release PR ready and merge it into the selected base branch with a merge commit. This keeps the tagged release commit in that branch's history.
 - If BRAT validation fails, keep the release PR in draft and do not move published tags. Before preparing the next version, add a reviewed metadata-only commit to the selected base branch which records the published version in `versions.json` and moves its exact tagged release notes out of `## Unreleased`. Keep only changes made after that tag under `## Unreleased`. Compare the historical section with `git show <tag>:updates.md`; do not merge the failed release PR or describe it as validated. The next release PR can then rotate only the correction notes while preserving the immutable release history.
 - Prepare and publish the next patch or pre-release version from that reconciled base. Leave the failed release PR draft until it is deliberately closed as superseded under a separate maintainer action.
-- A hyphenated version is rejected unless `prerelease=true`. A stable version staged with `prerelease=true` is rejected unless `publish_cli=false`.
+- For a pre-release, set `prerelease=true` in `Finalise Release Tags`. A hyphenated version is rejected unless that input is enabled.
 
 ### Release Cheat Sheet
 
@@ -294,16 +290,15 @@ The `Finalise Release Tags` and `Release Obsidian Plugin` workflows use the `rel
     - `version`: the same target version.
     - `release_branch`: leave blank unless the release branch used a custom name.
     - `expected_head_sha`: the full head commit SHA reviewed in the release PR.
-    - `prerelease`: enable for a version such as `1.0.0-rc.0`, and also when staging a stable version for BRAT.
-    - `publish_cli`: optional for a hyphenated pre-release, but disable it when staging a stable version.
+    - `prerelease`: enable for a version such as `1.0.0-rc.0`.
+    - `publish_cli`: disable when the reviewed release is plug-in-only.
 5. Approve the `Release Obsidian Plugin` workflow for the `release` environment, then check the generated draft GitHub Release.
-6. If a hyphenated pre-release includes the CLI, confirm that the CLI tag event published only immutable version and SHA-qualified image tags.
-7. Publish the draft as a GitHub pre-release without replacing the latest stable release, but keep the release PR in draft and leave its base branch unchanged.
-8. Update the PR state message to describe the published pre-release and state that merging remains on hold.
+6. If CLI publication was selected, confirm that the CLI tag event published the expected image tags.
+7. Publish the draft as a stable release or pre-release as selected, but keep the release PR in draft and leave its base branch unchanged.
+8. Update the PR state message to describe the published release and state that merging remains on hold until BRAT validation is complete.
 9. Validate the published release through BRAT, including start-up, ordinary bidirectional synchronisation, and any release-specific regression scenario.
-10. After a hyphenated pre-release passes, keep its release PR unmerged, reconcile its `versions.json` entry and exact release-note section into the selected base branch as metadata only, then close the PR through a separate maintainer action.
-11. After a stable version passes, remove its pre-release designation, make the exact release the latest stable release, publish the stable CLI tags through a separate maintainer gate if selected, then mark the release PR ready and merge it into the selected base branch.
-12. If validation fails, leave the PR in draft and do not move the published tags. Reconcile the published version's `updates.md` section and `versions.json` entry into the base branch as metadata only, then prepare the next patch or pre-release version from the remaining `## Unreleased` entries.
+10. After BRAT validation succeeds, mark the release PR ready and merge it into the selected base branch with a merge commit.
+11. If validation fails, leave the PR in draft and do not move the published tags. Reconcile the published version's `updates.md` section and `versions.json` entry into the base branch as metadata only, then prepare the next patch or pre-release version from the remaining `## Unreleased` entries.
 
 ## Contribution Guidelines
 

docs/adr/2026_07_multiple_remote_onboarding.md

@@ -65,7 +65,7 @@ The special meaning would duplicate `activeConfigurationId`, make a user-visible
 
 ### Add profile naming and full list editing to onboarding
 
-That would make the first-run path longer and duplicate the established Saved connections interface. Automatic descriptive names and later renaming keep this change limited to data integrity and consistent selection.
+That would make the first-run path longer and duplicate the established Remote Databases interface. Automatic descriptive names and later renaming keep this change limited to data integrity and consistent selection.
 
 ### Replace the compatibility fields immediately
 
@@ -77,11 +77,11 @@ Commonlib unit tests cover preserving existing profiles, opaque-ID insertion, ge
 
 Self-hosted LiveSync unit tests cover preserving modern Setup URI profiles and their active selection, retaining legacy Setup URI and QR migration, adding CouchDB and Object Storage profiles beside an existing profile, independent P2P selection, fresh P2P selection as both main and P2P remote, and cancellation without mutation.
 
-The real-Obsidian onboarding E2E owns the invitation, dialogue presentation, safe-area and touch-target checks, cancellation, and reopening from the Setup pane. It does not contact a remote or submit credentials. Remote connection correctness remains owned by the CouchDB, Object Storage, P2P, and two-Vault suites. The end-to-end Setup URI and provisioning acceptance workflow remains a separate release gate.
+The real-Obsidian onboarding E2E owns the invitation, dialogue presentation, safe-area and touch-target checks, cancellation, and command reopening. It does not contact a remote or submit credentials. Remote connection correctness remains owned by the CouchDB, Object Storage, P2P, and two-Vault suites. The end-to-end Setup URI and provisioning acceptance workflow remains a separate release gate.
 
 ## Consequences
 
-- Manual onboarding and the Saved connections list share one Commonlib profile contract.
+- Manual onboarding and the Remote Databases pane share one Commonlib profile contract.
 - Existing profiles survive reconfiguration, and a newly configured connection becomes explicitly selectable.
 - Modern imports retain user-assigned profile identity and names.
 - Legacy Setup URIs continue to work through an isolated compatibility boundary.

docs/adr/2026_07_release_notes_and_database_compatibility.md

@@ -60,7 +60,7 @@ Keep configured-state inference separate from new-Vault initialisation. If an ex
 
 ### Onboarding activation and initialisation
 
-- Keep an unconfigured Vault outside database initialisation, offline scanning, and configured-only checks. Offer setup through the long-lived onboarding Notice, and allow the wizard to be reopened from the Setup pane instead of opening a competing dialogue automatically.
+- Keep an unconfigured Vault outside database initialisation, offline scanning, and configured-only checks. Offer setup through the long-lived onboarding Notice and the permanent command instead of opening a competing dialogue automatically.
 - For new-device onboarding, reserve Rebuild before enabling and saving the accepted settings.
 - For an unconfigured existing device, reserve Fetch before enabling and saving imported or manually confirmed settings.
 - Suspend the current runtime after the flag has been written, apply the accepted settings through the scheduler's preparation callback, and request restart only after that callback succeeds.

docs/p2p.md

@@ -48,7 +48,7 @@ A TURN provider cannot read LiveSync's encrypted Vault contents, but it can obse
 
 The **P2P Status** pane is the current Obsidian interface for P2P connections.
 
-- After a P2P configuration exists, the command **Self-hosted LiveSync: P2P Sync : Open P2P Status** is available from the command palette.
+- The command **Self-hosted LiveSync: P2P Sync : Open P2P Status** remains available from the command palette.
 - The P2P ribbon icon appears only after a P2P configuration exists.
 - LiveSync does not open the pane merely because Obsidian has started. If the pane was already part of the saved Obsidian workspace, Obsidian may restore it.
 - Workspaces containing the retired P2P pane are migrated to the current status pane. The retired command is no longer exposed.

docs/recovery.md

@@ -32,28 +32,6 @@ While suspended:
 
 The flag deliberately enables file logging, which may affect performance. Remove it after the emergency has been understood.
 
-## Recover a conflicted or mismatched file
-
-Use this workflow when one file, or a small number of known files, has conflicts, missing chunks, or a difference between the current Vault file and the local LiveSync database. The inspection is device-local: it does not query a remote database or prove that another device has the same chunks.
-
-The `Hatch` recovery controls are ordered by escalation. Running **Recreate chunks for current Vault files** again with unchanged chunk settings and file contents produces the same chunks, and does not alter the revision tree. **Inspect conflicts and file/database differences** then provides actions for exact revisions. **Resolve All conflicted files by the newer one** is last because it applies a modification-time policy in bulk and logically deletes every other live version.
-
-1. Stop editing the affected file, pause replication on the participating devices, and keep a separate copy of every readable version.
-2. If another device or backup has the intended content, preserve that copy before changing any revision.
-3. If the current Vault file is readable, select **Recreate current chunks**. This can restore only chunks derived from the current Vault contents; it cannot reconstruct unique bytes from an unavailable historical or conflict revision.
-4. Select **Inspect conflicts and file/database differences** → **Begin inspection**.
-5. Review the database winner, every conflict revision, and any unavailable shared ancestor separately. Revision identifiers, `Δsize`, `Δtime`, and chunk availability are diagnostic evidence; they do not decide which content is correct.
-6. Use the wrench menu on the exact revision:
-   - **Compare with Vault** opens a read-only comparison for readable text.
-   - **Apply this revision to Vault** replaces the Vault file with that readable database revision.
-   - **Mark this revision as the Vault version** records an exact byte-for-byte match without creating a child revision.
-   - **Store Vault file as a child of this revision** preserves the current Vault bytes on that selected branch.
-   - **Retry reading revision** retries configured chunk retrieval without changing the revision tree.
-   - **Apply logical deletion to Vault**, **Discard this branch**, and **Discard unreadable revision** are destructive decisions. Use them only after preserving every version which may still be needed.
-7. Synchronise the healthy source if chunks were restored, scan again, and confirm that the expected conflict or difference has disappeared before resuming ordinary editing.
-
-An absent Vault file and a logical-deletion winner already agree and do not require a repair card unless another live branch remains. If the scan reports many unrelated files, or the local database itself is incomplete or corrupt, stop the per-file workflow and use [Reset synchronisation on this device](#reset-synchronisation-on-this-device) from a trusted remote. If the central remote must instead be reconstructed from an authoritative Vault, use [Overwrite server data with this device's files](#overwrite-server-data-with-this-devices-files).
-
 ## Reset synchronisation on this device
 
 Use this when the remote copy is trusted but this device's local LiveSync database is incomplete, corrupt, or no longer aligned with it.
@@ -91,7 +69,7 @@ Garbage Collection removes unreferenced chunks while preserving the current data
 - all relevant devices have synchronised; and
 - the remaining historical and deletion state is understood.
 
-Deleted documents, tombstones, live conflicts, and retained metadata are not free. Live conflict branches keep the chunks needed for review, while an ordinary superseded linear revision does not protect its former chunks. Garbage Collection can therefore make old content unreadable and cannot promise the smallest possible remote. Review the [Garbage Collection V3 specification](specs_garbage_collection.md) before using it.
+Deleted documents and tombstones are not free, and historical revisions may keep chunks reachable. Garbage Collection therefore cannot promise the smallest possible remote.
 
 Rebuild is a different operation. It reconstructs the database from a chosen authoritative state and is the more certain way to remove unwanted history or repair a damaged remote, but it is also more disruptive and can discard changes which exist only elsewhere.
 

docs/settings.md

@@ -12,7 +12,7 @@ The following status applies to optional and compatibility features in the 1.0 l
 | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Supported, opt-in    | Peer-to-Peer Synchronisation, Hidden File Sync, and Customisation Sync                                                                                | Maintained and covered by focused real-runtime tests. Enable them only where their separate setup and operational constraints are acceptable.                                   |
 | Maintained, advanced | Data Compression                                                                                                                                      | Available as an explicit storage and bandwidth trade-off. It remains disabled by default because the measured processing and memory costs outweigh the mixed-dataset saving.    |
-| Beta or experimental | JWT authentication, ignore files, automatic newer-file conflict resolution, and Garbage Collection V3 for CouchDB                                     | Retained for explicit testing and specialised use. They remain disabled by default and are not part of the minimum supported setup.                                             |
+| Beta or experimental | JWT authentication, ignore files, automatic newer-file conflict resolution, and Garbage Collection V3                                                 | Retained for explicit testing and specialised use. They remain disabled by default and are not part of the minimum supported setup.                                             |
 | Compatibility only   | V1 dynamic iteration counts, the old IndexedDB adapter, non-current hash algorithms, Eden chunks, and the stored `doNotUseFixedRevisionForChunks` key | Existing settings and data remain readable. New Vaults use the current defaults, and compatibility controls are shown only where a migration or recovery path still needs them. |
 
 | Icon | Description                                                        |
@@ -40,7 +40,7 @@ Internal database or settings compatibility reviews use a separate safety dialog
 
 This pane is used for setting up Self-hosted LiveSync. There are several options to set up Self-hosted LiveSync.
 
-An unconfigured installation does not open the onboarding dialogue automatically or scan the Vault into the local database. A long-lived Notice offers the onboarding action. If the Notice is dismissed, open **Self-hosted LiveSync settings** → **Setup** → **Rerun Onboarding Wizard**.
+An unconfigured installation does not open the onboarding dialogue automatically or scan the Vault into the local database. A long-lived Notice offers the onboarding action, and **Open onboarding wizard** remains available from the command palette after that Notice closes.
 
 Choose the new-device path when this device owns the files which should initialise synchronisation. Choose the existing-device path when it should receive an established remote state. The wizard reserves Rebuild or Fetch respectively before enabling the settings and requesting a restart, so the selected initialisation runs before the ordinary start-up scan.
 
@@ -169,9 +169,9 @@ Show verbose log. Please enable when you report the logs
 
 ## 3. Remote Configuration
 
-### 1. Connection settings
+### 1. Remote Server
 
-Self-hosted LiveSync stores multiple remote connection profiles under **Connection settings** → **Saved connections**. Each profile represents a CouchDB database, an Object Storage connection, or a P2P configuration, and several profiles can be kept in one Vault.
+Self-hosted LiveSync supports multiple remote connection profiles under **Remote Server** -> **Remote Databases**. This allows you to save and switch between multiple databases or bucket configurations in a single vault.
 
 Each profile has an opaque identifier and a presentation name. The name does not need to be unique and is not used to select the profile. The main remote and the P2P remote are selected independently, so code and settings imports must preserve both selections rather than relying on a special identifier such as `default`.
 
@@ -185,7 +185,7 @@ Each profile has an opaque identifier and a presentation name. The name does not
 
 Setting key: remoteType
 
-The active connection type. This is automatically projected to the legacy configuration when you activate a connection profile.
+The active remote server type. This is automatically projected to the legacy configuration when you activate a connection profile.
 
 ### 2. Notification
 
@@ -698,12 +698,6 @@ Open the dialogue
 
 #### Make report to inform the issue
 
-#### Copy database information for a file
-
-Select a file to copy its local database information. The command **Copy database information for the active file** performs the same inspection for the file open in the editor.
-
-The report includes the Vault-relative path, document and chunk identifiers, local database revisions, conflicts, and local chunk availability. It does not query the remote or include file contents. Paths and identifiers can still be private metadata, so review the report before sharing it.
-
 #### Write logs into the file
 
 Setting key: writeLogToTheFile
@@ -727,19 +721,17 @@ Stop reflecting database changes to storage files.
 
 ### 3. Recovery and Repair
 
-#### Recreate chunks for current Vault files
+#### Recreate missing chunks for all files
 
-Recreate chunks from files currently present in the Vault. This can repair missing chunks for those exact current contents after they have been confirmed as authoritative. It cannot reconstruct unavailable historical or conflict content.
-
-#### Inspect conflicts and file/database differences
-
-Compare each Vault file with every current live revision in the local database. Each winner and conflict revision is shown separately with its exact revision identifier, local chunk availability, and relationship to the current Vault file. Unavailable shared ancestors are reported separately because they prevent conservative three-way merging but are not live revisions which can be discarded.
-
-Select **Begin inspection** to run the inspection. Each reported file and live revision has a wrench menu for read-only comparison, applying an exact database revision to the Vault, recording an exact byte match, preserving the Vault file as a child of a selected branch, retrying chunk retrieval, or explicitly discarding a branch. Destructive actions require confirmation. Follow [Recover a conflicted or mismatched file](recovery.md#recover-a-conflicted-or-mismatched-file) before changing revision history.
+This will recreate chunks for all files. If there were missing chunks, this may fix the errors.
 
 #### Resolve All conflicted files by the newer one
 
-After confirmation, resolve every conflict by modification time. This logically deletes every version except the newest one. It is a destructive policy choice and cannot recover content which is already unavailable.
+Resolve all conflicted files by the newer one. Caution: This will overwrite the older one, and cannot resurrect the overwritten one.
+
+#### Verify and repair all files
+
+Compare the content of files between on local database and storage. If not matched, you will be asked which one you want to keep.
 
 #### Check and convert non-path-obfuscated files
 
@@ -1047,12 +1039,6 @@ Purge all download/upload cache.
 
 Delete all data on the remote server.
 
-### 6. Garbage Collection V3 (CouchDB only)
-
-Garbage Collection V3 identifies chunk documents which are not reachable from any current file or live conflict branch, creates logical deletions for those chunks locally, propagates the deletions to CouchDB, and requests remote compaction.
-
-Use it only when the Vault, local database, and remote are healthy, and every relevant device has synchronised. It can make an ordinary superseded file revision unreadable when no live state still needs its chunks. It does not repair corruption or replace a deliberate rebuild. See the [Garbage Collection V3 specification](specs_garbage_collection.md).
-
 ### 7. Reset
 
 #### Delete local database to reset or uninstall Self-hosted LiveSync

docs/setup_p2p.md

@@ -34,7 +34,7 @@ Before starting:
     ![P2P local database confirmation on the first device](../images/p2p-setup/guide-p2p-setup-first-rebuild-confirmation.png)
 
 7. Keep optional features disabled until ordinary note synchronisation works.
-8. After saving the P2P profile, open `Self-hosted LiveSync: P2P Sync : Open P2P Status` from the command palette. The P2P ribbon icon provides the same destination. Select `Open connection` if signalling is disconnected.
+8. Open `Self-hosted LiveSync: P2P Sync : Open P2P Status` from the command palette. After a P2P profile exists, the P2P ribbon icon provides the same destination. Select `Open connection` if signalling is disconnected.
 
     ![First P2P device connected to the signalling relay](../images/p2p-setup/guide-p2p-setup-first-device-connected.png)
 

docs/specs_conflict_resolution.md

@@ -46,37 +46,6 @@ The all-branch history check prevents a resolved conflict from being recreated m
 
 The compatibility implementation currently selects the newer modification time for differing binary conflicts even when the general **Always overwrite with a newer file** option is disabled. This is existing behaviour, not a new 1.0 guarantee. Changing it to explicit selection only is a separate compatibility decision.
 
-## Unreadable revisions and repair
-
-A document revision can remain in the PouchDB tree while one or more chunks needed to reconstruct its content are unavailable. Missing content is not evidence that the revision is obsolete. LiveSync therefore leaves an unreadable winner or conflict revision in the tree instead of deleting it during automatic conflict processing.
-
-**Hatch** → **Inspect conflicts and file/database differences** inspects the current winner, every current conflict revision, and the nearest shared ancestor for each conflict. A logical-deletion winner and an absent Vault file already agree, so that state is not reported unless another live branch still requires attention. When the Vault already matches the winner but conflict branches remain, the card shows the compact status `✅ Vault matches winner · ⚠️ Conflicts: N`; matching the winner does not mean that the conflict has been resolved.
-
-Each reported live revision has a compact wrench menu. The available actions depend on the exact revision and current Vault state:
-
-- **Compare with Vault** opens the existing difference dialogue in read-only mode for differing text files.
-- **Apply this revision to Vault** writes the selected readable revision, even when it is not the database winner. Replacing an existing file requires confirmation.
-- **Mark this revision as the Vault version** is offered when the bytes already match. It records exact device-local provenance without creating a child revision, and refuses the operation if the file changed after inspection.
-- **Store Vault file as a child of this revision** preserves the current Vault bytes on the explicitly selected live branch.
-- **Apply logical deletion to Vault** removes an existing Vault file after confirmation. An absent file needs no retained deletion provenance.
-- **Retry reading revision** attempts the configured chunk-retrieval path again. It does not change the revision tree.
-- **Discard this branch** is available for each exact live revision while at least one other live branch remains. It requires confirmation and creates a logical deletion on only the selected branch without changing the current Vault file.
-- **Discard unreadable revision** remains available as a recovery action when an unreadable revision is the only live leaf. It requires confirmation because no other database branch remains.
-
-Every mutating action rechecks that the selected revision is still a current live leaf. If another operation resolved or replaced it, the action fails and the card is refreshed instead of extending an obsolete branch.
-
-The card uses compact, mobile-friendly diagnostic rows with an emoji and a text label. `🧩 Missing chunks: N` identifies an unreadable revision. In the database row, `Δsize` is decoded size minus recorded size; in the Vault row, `Δsize vs DB` is Vault size minus decoded database size. `Δtime` is Vault modification time minus database modification time. The ordinary two-second comparison window still labels which side is newer. These values help diagnose a mismatch; path, size, and modification time do not prove revision identity or decide which content should win.
-
-A shared ancestor is informational. An ancestor which is no longer a live revision cannot be discarded independently through this workflow. If its body is unavailable, conservative three-way merge remains disabled, although readable live revisions can still be selected manually.
-
-Logical deletion does not recreate missing bytes, purge the document history, or prove that the deleted version was unimportant. Another replica or backup may still contain the missing chunks. Recover from that source before discarding a revision whenever possible.
-
-**Recreate chunks for current Vault files** can recreate chunks only from files which are readable in the current Vault. It cannot reconstruct unique bytes from an unavailable historical or conflict revision.
-
-Garbage Collection V3 treats every live conflict revision and its nearest available shared ancestor as reachable. Their locally available chunks are retained until the conflict is resolved. After resolution, chunks used only by the discarded branch or no-longer-needed merge ancestry can become eligible for collection. See the [Garbage Collection V3 specification](specs_garbage_collection.md).
-
-A generation-one revision has no parent. When its body is unavailable, LiveSync cannot preserve a changed Vault file as a sibling branch without inventing ancestry. It leaves the operation unresolved. Recover the missing chunks from another replica or backup, or explicitly discard that live revision. If the current Vault file is the intended replacement, it can be stored after the unreadable revision has been logically deleted.
-
 ### Two devices independently create the same path
 
 If two devices create the same full synchronised path before either device has
@@ -251,8 +220,8 @@ Do not:
 
 ## Verification
 
-Commonlib's real-PouchDB and injected-boundary unit tests cover unequal branch lengths, exact shared ancestry, deterministic ordering of multiple live leaves, a sensible stage followed by reconstruction of a manual pair, content below a deleted losing leaf, recorded and reconstructed branch identity, ambiguous matches, conflict-time editing, missing-body preservation when parent metadata is available, refusal to invent a parent for a generation-one revision, logical deletion, case-only rename, cross-path rename, and safe unproven fallbacks.
+Commonlib's real-PouchDB and injected-boundary unit tests cover unequal branch lengths, exact shared ancestry, deterministic ordering of multiple live leaves, a sensible stage followed by reconstruction of a manual pair, content below a deleted losing leaf, recorded and reconstructed branch identity, ambiguous matches, conflict-time editing, logical deletion, case-only rename, cross-path rename, and safe unproven fallbacks.
 
 LiveSync's optional real-Obsidian two-Vault checks have two scopes. `E2E_OBSIDIAN_INCLUDE_MARKDOWN_CONFLICT=true` resolves and edits a Markdown conflict, propagates it to a Vault which still displays the deleted losing content, and requires one live result to remain. `E2E_OBSIDIAN_INCLUDE_CONFLICT_OPERATIONS=true` edits, deletes, case-renames, and cross-path-renames files while conflicts remain active; it verifies the parent revision of each resulting branch, replicates those exact trees, and confirms that the other live branches remain intact.
 
-The focused `test:e2e:obsidian:conflict-dialog-policy` scenario creates three live versions in one real Obsidian Vault. It verifies the count warning, commits a concatenated child of the displayed winner, confirms that the untouched leaf remains as one conflict, postpones that remaining pair, restarts the isolated Obsidian profile, and confirms that only the live pair is reconstructed. It also verifies that an incoming resolution closes a stale dialogue, completes the waiting conflict operation, and clears the warning. The repair scenario removes a referenced local chunk, confirms that the exact unreadable live revision remains in the tree, and exercises explicit retry and discard controls without deleting another live revision.
+The focused `test:e2e:obsidian:conflict-dialog-policy` scenario creates three live versions in one real Obsidian Vault. It verifies the count warning, commits a concatenated child of the displayed winner, confirms that the untouched leaf remains as one conflict, postpones that remaining pair, restarts the isolated Obsidian profile, and confirms that only the live pair is reconstructed. It also verifies that an incoming resolution closes a stale dialogue, completes the waiting conflict operation, and clears the warning.

docs/specs_garbage_collection.md

@@ -1,65 +0,0 @@
-# Garbage Collection V3
-
-Garbage Collection V3 is a beta maintenance operation for CouchDB remotes. It removes chunk documents which are no longer required by the current local revision tree, propagates those logical deletions to CouchDB, and then requests remote compaction.
-
-It is not a repair operation. Use it only when the Vault, the local LiveSync database, and the CouchDB remote are healthy, every relevant device has synchronised, and recoverable backups exist.
-
-## Supported scope
-
-Garbage Collection V3 is available in Edge Case mode for CouchDB. It is not offered for Object Storage or P2P:
-
-- Object Storage has a different journal and object lifecycle.
-- P2P has no central database to compact and cannot provide the accepted-device progress information required by this workflow.
-
-The operation requires **Fetch chunks on demand** to be off so that its local reachability result is not confused with chunks which exist only on the remote.
-
-## Workflow
-
-After the user starts Garbage Collection V3, LiveSync:
-
-1. completes a one-shot bidirectional CouchDB synchronisation;
-2. reads the accepted-device list and current progress recorded on the remote;
-3. requires parseable progress information, warns when an accepted device has no current information or device progress differs, then requires explicit confirmation;
-4. computes the chunks reachable from the local PouchDB revision tree;
-5. creates a logical deletion for each locally present chunk which is not reachable;
-6. completes a push-only replication so that those deletions reach CouchDB;
-7. requests CouchDB compaction and waits for it for up to two minutes; and
-8. clears the local chunk caches.
-
-If the initial synchronisation, device inspection, or confirmation fails, the workflow stops before collection. Missing or invalid device progress is treated as a failed inspection rather than offered as a confirmation override. If push-only replication fails, the local logical deletions have already been created, but remote compaction is not started; synchronise again before retrying or using another device. A compaction failure or completion timeout is reported separately and is not also reported as a successful completion.
-
-## Reachability rules
-
-A chunk remains reachable when it is referenced by any of the following:
-
-- the current database winner for a file;
-- any other live conflict revision for that file;
-- an available revision on either side of a live conflict which is required to describe the divergence; or
-- the nearest available revision shared by both live conflict branches.
-
-Chunk identifiers are content-derived and shared between files. Reachability is therefore collected into one set across the database. A chunk used by two or more current files remains protected even when one file is updated or deleted.
-
-An ordinary superseded linear revision does not protect its former chunks. Once no current file or live conflict branch references a chunk, it can be collected. After a conflict is resolved, chunks unique to the discarded branch and to no-longer-needed merge ancestry can also become eligible.
-
-## Consequences
-
-Garbage Collection deliberately trades historical recoverability for storage. A metadata revision may remain in the revision tree after a chunk which only that superseded revision used has been collected, so that historical body can become unreadable. Remote compaction can then discard old CouchDB revision bodies. Tombstones and retained metadata also consume storage, so the operation does not promise the smallest possible database.
-
-Writing the same bytes again produces the same content-derived chunk identifier. If that chunk was collected previously, the normal chunk-writing path creates a new live revision for it, and ordinary replication can transfer it again. This does not recover an older file revision automatically; it only makes the newly written content available.
-
-Garbage Collection does not reconstruct a chunk which is already missing, determine whether an unreadable revision is important, or repair a damaged local database. Use **Inspect conflicts and file/database differences**, another healthy replica, or a backup for those cases. Use **Overwrite Server Data with This Device's Files** only when a chosen Vault is authoritative and a deliberate remote rebuild is required.
-
-## Verification
-
-Commonlib tests use real in-memory PouchDB revision trees to verify:
-
-- collection eligibility after a normal file update;
-- protection of chunks shared by multiple current files;
-- protection of all live conflict branches and their nearest available shared ancestor;
-- eligibility of losing-branch and ancestor-only chunks after conflict resolution;
-- propagation of chunk deletion to another PouchDB database; and
-- recreation and propagation when the same content is written again.
-
-Self-hosted LiveSync unit tests verify that Garbage Collection V3 uses Commonlib's revision-aware result, deletes only unreachable chunks, performs the initial bidirectional and final push-only replications in order, and requests remote compaction.
-
-A disposable real-CouchDB integration test verifies logical deletion on the server, retention of shared and conflict chunks, compaction completion, replication after collection, and recreation of a content-addressed chunk. CouchDB's choice and timing of physical byte reclamation remain an external database boundary, so the test does not assert a particular reduction in database size.

docs/terms.md

@@ -27,7 +27,7 @@ All guidelines and conventions listed below are disclosed and maintained solely
 - Boot-up sequence (boot-sequence)
     - The initialisation process of the plug-in when Obsidian starts. It starts with the loading of the plug-in, setting up core services, loading saved settings, and opening the local database. Once the layout is ready, the plug-in checks for the presence of flag files, runs configuration diagnostics, connects to the remote database, and begins file watching. The sequence finishes once the plug-in is fully ready and operational.
 - Broken files (Size mismatch)
-    - A state where a file's metadata and the actual content stored in its chunks do not match, causing file retrieval or synchronisation failures. These mismatches can be inspected with `Inspect conflicts and file/database differences` on the Hatch pane, then handled one exact revision at a time.
+    - A state where a file's metadata and the actual content stored in its chunks do not match, causing file retrieval or synchronisation failures. These mismatches can be detected and resolved by running validation tools such as `Verify and repair all files` on the Hatch pane.
 - Chunk / Chunks
     - Divided units of data stored in the database or object storage to facilitate efficient synchronisation.
 - Compaction

docs/troubleshooting.md

@@ -53,18 +53,9 @@ Check Obsidian's `Detect all file extensions`, LiveSync selectors, ignore files,
 
 If the log reports missing chunks or a size mismatch:
 
-1. stop editing the affected file and keep a separate copy of any readable content;
-2. restart Obsidian once to rule out an interrupted fetch;
-3. synchronise a device or restore a backup which still has the correct content;
-4. on that healthy device, run `Recreate chunks for current Vault files`, then synchronise;
-5. follow [Recover a conflicted or mismatched file](recovery.md#recover-a-conflicted-or-mismatched-file); run `Inspect conflicts and file/database differences` from `Hatch`, then use each revision's wrench menu to review and act on that exact branch; and
-6. use `Discard this branch` only after confirming that the exact live branch is no longer wanted. Use the separate `Discard unreadable revision` recovery action only when an unreadable revision is the sole live leaf.
-
-The repair card uses compact diagnostic rows which remain readable in a narrow mobile settings pane. `🧩 Missing chunks: N` marks an unreadable revision. In the database row, `Δsize` means decoded size minus recorded size; `Δsize vs DB` means Vault size minus decoded database size; and `Δtime` means Vault modification time minus database modification time. These are diagnostic values, not a rule for deciding which revision is correct. `✅ Vault matches winner · ⚠️ Conflicts: N` means that the current Vault bytes agree with the database winner while other live branches still need a decision. Every mutating action rechecks that its selected revision is still live. Applying a logical deletion to an existing Vault file requires confirmation; a logical-deletion winner with no Vault file already agrees and is omitted.
-
-`Retry reading revision` does not change the revision tree. `Discard this branch` creates a logical deletion on one exact live revision while another live branch remains and leaves the current Vault file unchanged. If the discarded revision was recorded as the Vault's exact source, that stale device-local provenance is removed. `Discard unreadable revision` provides the corresponding explicit escape hatch for a sole unreadable live leaf. Neither action purges history or reconstructs missing content. An unavailable non-live ancestor cannot be deleted through this workflow; it disables conservative three-way merge but does not prevent explicit selection between readable live revisions.
-
-`Recreate chunks for current Vault files` uses current Vault content. It cannot recreate unique bytes which exist only in an unreadable historical or conflict revision.
+1. restart Obsidian once to rule out an interrupted fetch;
+2. on a device which has the correct file, run `Recreate missing chunks for all files`, then synchronise; and
+3. if the mismatch remains, run `Verify and repair all files` from `Hatch` and review which copy is authoritative.
 
 ## A configuration mismatch dialogue blocks synchronisation
 
@@ -119,8 +110,6 @@ Enable Obsidian's `Detect all file extensions`, then check LiveSync selectors, i
 
 Run `Generate full report for opening the issue with debug info` to copy the current settings summary and recent verbose log lines. Remove credentials, remote URLs, Vault names, file contents, and other private information before sharing it.
 
-When a problem concerns one file, run **Copy database information for the active file**, or use **Hatch** → **Copy database information for a file** to select another file. The report describes this device's local database view, including the Vault-relative path, document and chunk identifiers, local database revisions, conflicts, and local chunk availability. It does not query the remote server or include file contents. Treat paths and identifiers as private metadata before sharing.
-
 Use `Show log` for live inspection. Logs are intentionally kept in memory for a limited time to reduce accidental disclosure. Enable `Write logs into the file` only while reproducing a problem, then disable it and remove the file after review because persistent logging affects performance and may contain private data.
 
 ![Write logs into the file](../images/write_logs_into_the_file.png)
@@ -131,7 +120,7 @@ Browser security errors, particularly CORS failures, may reach the plug-in only
 
 LiveSync stores file metadata, chunks, revision history, conflicts, deletions, and tombstones. Deleting or shortening a file therefore does not immediately remove every object which once represented it.
 
-Garbage Collection V3 can remove unreferenced chunks from a healthy CouchDB setup, but it is appropriate only when the Vault and local database are healthy and all relevant devices have synchronised. Current files and live conflict branches protect their required chunks; an ordinary superseded revision does not. Tombstones and retained metadata are not free, so Garbage Collection does not guarantee a minimal database. Review the [Garbage Collection V3 specification](specs_garbage_collection.md) before using it.
+Garbage Collection can remove unreferenced chunks, but it is appropriate only when the Vault and local database are healthy and all relevant devices have synchronised. Tombstones and retained revisions are not free, so Garbage Collection does not guarantee a minimal database.
 
 `Overwrite Server Data with This Device's Files` is a separate rebuild operation and is the more certain way to reconstruct a central remote from a chosen authoritative Vault. It is also destructive and may discard changes which exist only on another device. Review [Recovery and flag files](recovery.md#garbage-collection-is-not-rebuild) before choosing between them.
 

manifest.json

@@ -1,7 +1,7 @@
 {
     "id": "obsidian-livesync",
     "name": "Self-hosted LiveSync",
-    "version": "1.0.0-rc.0",
+    "version": "1.0.0-beta.3",
     "minAppVersion": "1.7.2",
     "description": "Community implementation of self-hosted livesync. Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "author": "vorotamoroz",

package-lock.json

@@ -1,12 +1,12 @@
 {
     "name": "obsidian-livesync",
-    "version": "1.0.0-rc.0",
+    "version": "1.0.0-beta.3",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "obsidian-livesync",
-            "version": "1.0.0-rc.0",
+            "version": "1.0.0-beta.3",
             "license": "MIT",
             "workspaces": [
                 "src/apps/cli",
@@ -22,7 +22,7 @@
                 "@smithy/querystring-builder": "^4.2.9",
                 "@smithy/types": "^4.14.3",
                 "@smithy/util-retry": "^4.4.5",
-                "@vrtmrz/livesync-commonlib": "0.1.0",
+                "@vrtmrz/livesync-commonlib": "0.1.0-rc.11",
                 "@vrtmrz/obsidian-plugin-kit": "0.1.2",
                 "diff-match-patch": "^1.0.5",
                 "fflate": "^0.8.2",
@@ -56,7 +56,7 @@
                 "@types/transform-pouch": "^1.0.6",
                 "@typescript-eslint/parser": "8.56.1",
                 "@vitest/coverage-v8": "^4.1.8",
-                "@vrtmrz/obsidian-test-session": "0.2.6",
+                "@vrtmrz/obsidian-test-session": "0.2.5",
                 "dotenv-cli": "^11.0.0",
                 "esbuild": "0.28.1",
                 "esbuild-plugin-inline-worker": "^0.1.1",
@@ -4764,9 +4764,9 @@
             }
         },
         "node_modules/@vrtmrz/livesync-commonlib": {
-            "version": "0.1.0",
-            "resolved": "https://registry.npmjs.org/@vrtmrz/livesync-commonlib/-/livesync-commonlib-0.1.0.tgz",
-            "integrity": "sha512-rdzEubzLStioanE67pps2XSGZ2UGyMIyeEoKsdPztQLLW8wM05PWApOPbJujIydHcDr2hFanbDFe89Lk7Mn4XQ==",
+            "version": "0.1.0-rc.11",
+            "resolved": "https://registry.npmjs.org/@vrtmrz/livesync-commonlib/-/livesync-commonlib-0.1.0-rc.11.tgz",
+            "integrity": "sha512-o811duZFajxDFI6cy7zwtXPg6lihx5e1MH6Xse1sx4HseYurbaDf9DtZJdAtfkjTxl5wOZRSnVMoMLn+I/xD+g==",
             "license": "MIT",
             "dependencies": {
                 "@aws-sdk/client-s3": "^3.808.0",
@@ -4839,9 +4839,9 @@
             }
         },
         "node_modules/@vrtmrz/obsidian-test-session": {
-            "version": "0.2.6",
-            "resolved": "https://registry.npmjs.org/@vrtmrz/obsidian-test-session/-/obsidian-test-session-0.2.6.tgz",
-            "integrity": "sha512-7xDTmTW3igBxwQGgbbpoRZU0JvOBpGgdRT4qF2WVrKz03OtKMJdkfJILY04/HZ+n4tvn9Ze8phJBr0dx3wewcQ==",
+            "version": "0.2.5",
+            "resolved": "https://registry.npmjs.org/@vrtmrz/obsidian-test-session/-/obsidian-test-session-0.2.5.tgz",
+            "integrity": "sha512-ZsI+Yx3z6IEFfh5Ey5mEUBNI0SUD6oDhP7D9LSZVEqPmdJz2JMiag7d8u/p1i6KpsoI2HbDvtw4RHpB+BQReAw==",
             "dev": true,
             "license": "MIT",
             "engines": {
@@ -5975,15 +5975,15 @@
             "license": "MIT"
         },
         "node_modules/brace-expansion": {
-            "version": "5.0.8",
-            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.8.tgz",
-            "integrity": "sha512-JZyDyq3D4AUifKTPOB7DELf6XsB3WdPuNxCtob1vFXPsSXhdAiHBWJ/tJ8HAc9aH84BK+5JFZLNkJKx3G9kzQg==",
+            "version": "5.0.7",
+            "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.7.tgz",
+            "integrity": "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA==",
             "license": "MIT",
             "dependencies": {
                 "balanced-match": "^4.0.2"
             },
             "engines": {
-                "node": "20 || >=22"
+                "node": "18 || 20 || >=22"
             }
         },
         "node_modules/braces": {
@@ -15913,7 +15913,7 @@
         },
         "src/apps/cli": {
             "name": "self-hosted-livesync-cli",
-            "version": "1.0.0-rc.0-cli",
+            "version": "1.0.0-beta.3-cli",
             "dependencies": {
                 "chokidar": "^4.0.0",
                 "minimatch": "^10.2.5",
@@ -15938,7 +15938,7 @@
         },
         "src/apps/webapp": {
             "name": "livesync-webapp",
-            "version": "1.0.0-rc.0-webapp",
+            "version": "1.0.0-beta.3-webapp",
             "dependencies": {
                 "octagonal-wheels": "^0.1.51"
             },
@@ -15950,7 +15950,7 @@
             }
         },
         "src/apps/webpeer": {
-            "version": "1.0.0-rc.0-webpeer",
+            "version": "1.0.0-beta.3-webpeer",
             "dependencies": {
                 "octagonal-wheels": "^0.1.51"
             },

package.json

@@ -1,6 +1,6 @@
 {
     "name": "obsidian-livesync",
-    "version": "1.0.0-rc.0",
+    "version": "1.0.0-beta.3",
     "description": "Reflect your vault changes to some other devices immediately. Please make sure to disable other synchronize solutions to avoid content corruption or duplication.",
     "main": "main.js",
     "type": "module",
@@ -50,7 +50,6 @@
         "test:e2e:obsidian:onboarding-invitation": "tsx test/e2e-obsidian/scripts/onboarding-invitation.ts",
         "test:e2e:obsidian:dialog-mounts": "tsx test/e2e-obsidian/scripts/dialog-mounts.ts",
         "test:e2e:obsidian:conflict-dialog-policy": "tsx test/e2e-obsidian/scripts/conflict-dialog-policy.ts",
-        "test:e2e:obsidian:revision-repair": "tsx test/e2e-obsidian/scripts/revision-repair.ts",
         "test:e2e:obsidian:settings-ui": "tsx test/e2e-obsidian/scripts/settings-ui.ts",
         "test:e2e:obsidian:review-harness": "tsx test/e2e-obsidian/scripts/review-harness.ts",
         "test:e2e:obsidian:p2p-pane": "tsx test/e2e-obsidian/scripts/p2p-pane.ts",
@@ -64,7 +63,6 @@
         "test:e2e:obsidian:startup-scan": "tsx test/e2e-obsidian/scripts/startup-scan.ts",
         "test:e2e:obsidian:setup-uri-workflow": "tsx test/e2e-obsidian/scripts/setup-uri-workflow.ts",
         "test:e2e:obsidian:two-vault-sync": "tsx test/e2e-obsidian/scripts/two-vault-sync.ts",
-        "test:e2e:obsidian:security-seed-reconnect": "tsx test/e2e-obsidian/scripts/security-seed-reconnect.ts",
         "test:e2e:obsidian:hidden-file-snippet-sync": "tsx test/e2e-obsidian/scripts/hidden-file-snippet-sync.ts",
         "test:e2e:obsidian:customisation-sync": "tsx test/e2e-obsidian/scripts/customisation-sync.ts",
         "test:e2e:obsidian:setting-markdown-export": "tsx test/e2e-obsidian/scripts/setting-markdown-export.ts",
@@ -116,7 +114,7 @@
         "@types/transform-pouch": "^1.0.6",
         "@typescript-eslint/parser": "8.56.1",
         "@vitest/coverage-v8": "^4.1.8",
-        "@vrtmrz/obsidian-test-session": "0.2.6",
+        "@vrtmrz/obsidian-test-session": "0.2.5",
         "dotenv-cli": "^11.0.0",
         "esbuild": "0.28.1",
         "esbuild-plugin-inline-worker": "^0.1.1",
@@ -165,7 +163,7 @@
         "@smithy/querystring-builder": "^4.2.9",
         "@smithy/types": "^4.14.3",
         "@smithy/util-retry": "^4.4.5",
-        "@vrtmrz/livesync-commonlib": "0.1.0",
+        "@vrtmrz/livesync-commonlib": "0.1.0-rc.11",
         "@vrtmrz/obsidian-plugin-kit": "0.1.2",
         "diff-match-patch": "^1.0.5",
         "fflate": "^0.8.2",

src/apps/cli/package.json

@@ -1,7 +1,7 @@
 {
     "name": "self-hosted-livesync-cli",
     "private": true,
-    "version": "1.0.0-rc.0-cli",
+    "version": "1.0.0-beta.3-cli",
     "main": "dist/index.cjs",
     "type": "module",
     "scripts": {

src/apps/webapp/package.json

@@ -1,7 +1,7 @@
 {
     "name": "livesync-webapp",
     "private": true,
-    "version": "1.0.0-rc.0-webapp",
+    "version": "1.0.0-beta.3-webapp",
     "type": "module",
     "description": "Browser-based Self-hosted LiveSync using FileSystem API",
     "scripts": {

src/apps/webpeer/package.json

@@ -1,7 +1,7 @@
 {
     "name": "webpeer",
     "private": true,
-    "version": "1.0.0-rc.0-webpeer",
+    "version": "1.0.0-beta.3-webpeer",
     "type": "module",
     "scripts": {
         "dev": "vite",

src/common/messages/LiveSyncProvisionalMessages.ts

@@ -9,7 +9,8 @@
 export const liveSyncProvisionalEnglishMessages = {
     "This first setup has several short steps because it confirms encryption, the connection method, and which device provides the initial data. Once it is complete, additional devices can reuse a Setup URI.":
         "This first setup has several short steps because it confirms encryption, the connection method, and which device provides the initial data. Once it is complete, additional devices can reuse a Setup URI.",
-    "Setup Complete: Preparing to Fetch from Another Device": "Setup Complete: Preparing to Fetch from Another Device",
+    "Setup Complete: Preparing to Fetch from Another Device":
+        "Setup Complete: Preparing to Fetch from Another Device",
     "The P2P connection has been configured successfully. The initial synchronisation data must now be fetched from an online source device.":
         "The P2P connection has been configured successfully. The initial synchronisation data must now be fetched from an online source device.",
     "After restarting, select an online source device for the initial Fetch. The local LiveSync database on this device will be rebuilt from that source. Unsynchronised files in this Vault may conflict with the fetched data.":
@@ -63,90 +64,6 @@ export const liveSyncProvisionalEnglishMessages = {
     "This file has unresolved conflicts.": "This file has unresolved conflicts.",
     "This file has ${COUNT} unresolved versions. They will be reviewed one pair at a time.":
         "This file has ${COUNT} unresolved versions. They will be reviewed one pair at a time.",
-    "Sync now": "Sync now",
-    "Apply pending changes now": "Apply pending changes now",
-    "Copy database information for the active file": "Copy database information for the active file",
-    "Copy database information for a file": "Copy database information for a file",
-    "Copy revision, conflict, and local chunk availability information, including document and chunk identifiers but not file contents.":
-        "Copy revision, conflict, and local chunk availability information, including document and chunk identifiers but not file contents.",
-    "Choose file": "Choose file",
-    "Choose a file to inspect": "Choose a file to inspect",
-    "Database information for ${FILE}": "Database information for ${FILE}",
-    "All revisions and chunk availability below are a snapshot of this device's local database; the remote is not queried. Review the Vault-relative path, document identifier, content-derived chunk identifiers, and metadata before sharing this report. File contents are omitted.":
-        "All revisions and chunk availability below are a snapshot of this device's local database; the remote is not queried. Review the Vault-relative path, document identifier, content-derived chunk identifiers, and metadata before sharing this report. File contents are omitted.",
-    "📁 Vault: ${SIZE} B · ${TIME}": "📁 Vault: ${SIZE} B · ${TIME}",
-    "📁 Vault: missing": "📁 Vault: missing",
-    "🗄️ Local DB: missing": "🗄️ Local DB: missing",
-    "Vault and database revision": "Vault and database revision",
-    "Vault file": "Vault file",
-    "Database revision": "Database revision",
-    "Vault file is newer": "Vault file is newer",
-    "Database revision is newer": "Database revision is newer",
-    "Within the two-second comparison window": "Within the two-second comparison window",
-    "Timestamp comparison unavailable": "Timestamp comparison unavailable",
-    "${ROLE}: ${REVISION}": "${ROLE}: ${REVISION}",
-    "Winner revision": "Winner revision",
-    "Conflict revision": "Conflict revision",
-    "Unknown revision": "Unknown revision",
-    "🗑️ Logical deletion": "🗑️ Logical deletion",
-    "Readable on this device; recorded size ${RECORDED}, decoded size ${ACTUAL}":
-        "Readable on this device; recorded size ${RECORDED}, decoded size ${ACTUAL}",
-    "🧩 Missing chunks: ${COUNT}": "🧩 Missing chunks: ${COUNT}",
-    "📦 DB: recorded ${RECORDED} B · decoded ${DECODED} B · Δsize ${DIFFERENCE} B":
-        "📦 DB: recorded ${RECORDED} B · decoded ${DECODED} B · Δsize ${DIFFERENCE} B",
-    "📦 DB: recorded ${RECORDED} B · decoded unavailable":
-        "📦 DB: recorded ${RECORDED} B · decoded unavailable",
-    "📁 Vault: ${VAULT} B · Δsize vs DB ${DIFFERENCE} B":
-        "📁 Vault: ${VAULT} B · Δsize vs DB ${DIFFERENCE} B",
-    "🕒 DB ${DATABASE_TIME} · Vault ${VAULT_TIME} · Δtime ${DIFFERENCE} ms (${RELATION})":
-        "🕒 DB ${DATABASE_TIME} · Vault ${VAULT_TIME} · Δtime ${DIFFERENCE} ms (${RELATION})",
-    "✅ Matches Vault": "✅ Matches Vault",
-    "⚠️ Differs from Vault": "⚠️ Differs from Vault",
-    "✅ Vault matches winner": "✅ Vault matches winner",
-    "⚠️ Conflicts: ${COUNT}": "⚠️ Conflicts: ${COUNT}",
-    "Compare with Vault": "Compare with Vault",
-    "Apply this revision to Vault": "Apply this revision to Vault",
-    "Apply database revision ${REVISION} to ${FILE}? The current Vault file will be overwritten.":
-        "Apply database revision ${REVISION} to ${FILE}? The current Vault file will be overwritten.",
-    "Apply database revision to Vault": "Apply database revision to Vault",
-    "Mark this revision as the Vault version": "Mark this revision as the Vault version",
-    "Store Vault file as a child of this revision": "Store Vault file as a child of this revision",
-    "Apply logical deletion to Vault": "Apply logical deletion to Vault",
-    "Apply logical deletion ${REVISION} to ${FILE}? The current Vault file will be removed.":
-        "Apply logical deletion ${REVISION} to ${FILE}? The current Vault file will be removed.",
-    "Retry reading revision": "Retry reading revision",
-    "Discard this branch": "Discard this branch",
-    "Discard branch": "Discard branch",
-    "Discard database branch ${REVISION} of ${FILE}? This creates a logical deletion for that exact live branch. The current Vault file will not be changed.":
-        "Discard database branch ${REVISION} of ${FILE}? This creates a logical deletion for that exact live branch. The current Vault file will not be changed.",
-    "Discard unreadable revision": "Discard unreadable revision",
-    "Discard database revision ${REVISION} of ${FILE}? This creates a logical deletion for that exact live revision. Missing content cannot be recovered by this action.":
-        "Discard database revision ${REVISION} of ${FILE}? This creates a logical deletion for that exact live revision. Missing content cannot be recovered by this action.",
-    "Revision metadata is unavailable on this device": "Revision metadata is unavailable on this device",
-    "Shared ancestor ${REVISION} is not readable on this device. Automatic three-way merging may be unavailable, but the live revisions remain available for explicit review.":
-        "Shared ancestor ${REVISION} is not readable on this device. Automatic three-way merging may be unavailable, but the live revisions remain available for explicit review.",
-    "No shared ancestor is available for this conflict. The live revisions remain available for explicit review.":
-        "No shared ancestor is available for this conflict. The live revisions remain available for explicit review.",
-    "More actions for revision ${REVISION}": "More actions for revision ${REVISION}",
-    "More actions for ${FILE}": "More actions for ${FILE}",
-    "Show revision history": "Show revision history",
-    "Store Vault file as a new local database document":
-        "Store Vault file as a new local database document",
-    "Copy database information": "Copy database information",
-    "Recreate chunks for current Vault files": "Recreate chunks for current Vault files",
-    "Recreate chunks from the files currently present in this Vault. This cannot reconstruct unavailable historical or conflict content.":
-        "Recreate chunks from the files currently present in this Vault. This cannot reconstruct unavailable historical or conflict content.",
-    "Recreate current chunks": "Recreate current chunks",
-    "Resolve every conflict by modification time? This logically deletes every version except the newest one and cannot recover content which is already unavailable.":
-        "Resolve every conflict by modification time? This logically deletes every version except the newest one and cannot recover content which is already unavailable.",
-    "Resolve all conflicts by the newest version": "Resolve all conflicts by the newest version",
-    "Inspect conflicts and file/database differences":
-        "Inspect conflicts and file/database differences",
-    "Scan every Vault file and live local-database revision for conflicts, missing chunks, and differences. Each result provides actions for the exact revision.":
-        "Scan every Vault file and live local-database revision for conflicts, missing chunks, and differences. Each result provides actions for the exact revision.",
-    "Begin inspection": "Begin inspection",
-    "Connection settings": "Connection settings",
-    "Saved connections": "Saved connections",
 } as const;
 
 export type LiveSyncProvisionalMessageKey = keyof typeof liveSyncProvisionalEnglishMessages;

src/common/translation.unit.spec.ts

@@ -30,8 +30,6 @@ describe("LiveSync-owned translation catalogue", () => {
     it("uses LiveSync-owned provisional English without extending Commonlib's message contract", () => {
         expect($msg("This file has unresolved conflicts.")).toBe("This file has unresolved conflicts.");
         expect($msg("More actions for ${DEVICE}", { DEVICE: "phone" })).toBe("More actions for phone");
-        expect($msg("Connection settings")).toBe("Connection settings");
-        expect($msg("Saved connections")).toBe("Saved connections");
         expect(
             $msg("This file has ${COUNT} unresolved versions. They will be reviewed one pair at a time.", {
                 COUNT: "3",

src/deps.ts

@@ -26,7 +26,6 @@ export {
     WorkspaceLeaf,
     Menu,
     request,
-    setIcon,
     getLanguage,
     requireApiVersion,
     ButtonComponent,

src/features/ConfigSync/CmdConfigSync.command.unit.spec.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-vi.mock("@/deps.ts", () => ({
-    addIcon: vi.fn(),
-    diff_match_patch: class DiffMatchPatch {},
-    normalizePath: vi.fn((path: string) => path),
-    Notice: class Notice {},
-    parseYaml: vi.fn(),
-    Platform: {},
-}));
-vi.mock("./PluginDialogModal.ts", () => ({
-    PluginDialogModal: class PluginDialogModal {},
-}));
-vi.mock("@/features/HiddenFileCommon/JsonResolveModal.ts", () => ({
-    JsonResolveModal: class JsonResolveModal {},
-}));
-vi.mock("@/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts", () => ({
-    ConflictResolveModal: class ConflictResolveModal {},
-}));
-vi.mock("@/features/LiveSyncCommands.ts", () => ({
-    LiveSyncCommands: class LiveSyncCommands {
-        core!: { services: unknown };
-        get services() {
-            return this.core.services;
-        }
-    },
-}));
-vi.mock("@/common/types.ts", () => ({
-    ICXHeader: "ix:",
-    PERIODIC_PLUGIN_SWEEP: 60,
-}));
-vi.mock("@/common/utils.ts", () => ({
-    EVEN: Symbol("even"),
-    disposeMemoObject: vi.fn(),
-    isCustomisationSyncMetadata: vi.fn(),
-    isPluginMetadata: vi.fn(),
-    memoIfNotExist: vi.fn(),
-    memoObject: vi.fn(),
-    retrieveMemoObject: vi.fn(),
-    scheduleTask: vi.fn(),
-}));
-vi.mock("@/common/PeriodicProcessor.ts", () => ({
-    PeriodicProcessor: class PeriodicProcessor {},
-}));
-vi.mock("@/common/events.ts", () => ({
-    EVENT_REQUEST_OPEN_PLUGIN_SYNC_DIALOG: "open-plugin-sync",
-    eventHub: {
-        onEvent: vi.fn(),
-    },
-}));
-vi.mock("@/common/translation", () => ({
-    $msg: vi.fn((message: string) => message),
-}));
-vi.mock("@/common/obsidianCommunityPlugins.ts", () => ({
-    getObsidianCommunityPluginManager: vi.fn(),
-}));
-
-import { ConfigSync } from "./CmdConfigSync";
-
-describe("ConfigSync commands", () => {
-    it("shows the Customisation Sync command only whilst the feature is enabled", () => {
-        const commands: Array<{
-            id: string;
-            checkCallback?: (checking: boolean) => boolean | void;
-        }> = [];
-        const settings = {
-            usePluginSync: false,
-        };
-        const showPluginSyncModal = vi.fn();
-        const configSync = Object.create(ConfigSync.prototype) as ConfigSync;
-        Object.assign(configSync, {
-            core: {
-                settings,
-                services: {
-                    API: {
-                        addCommand: vi.fn((command) => commands.push(command)),
-                    },
-                },
-            },
-            addRibbonIcon: vi.fn(() => ({
-                addClass: vi.fn(),
-            })),
-            showPluginSyncModal,
-        });
-
-        configSync.onload();
-
-        const command = commands.find(({ id }) => id === "livesync-plugin-dialog-ex");
-        expect(command?.checkCallback?.(true)).toBe(false);
-
-        settings.usePluginSync = true;
-        expect(command?.checkCallback?.(true)).toBe(true);
-        expect(command?.checkCallback?.(false)).toBe(true);
-        expect(showPluginSyncModal).toHaveBeenCalledOnce();
-    });
-});

src/features/ConfigSync/CmdConfigSync.ts

@@ -454,14 +454,8 @@ export class ConfigSync extends LiveSyncCommands {
         this.services.API.addCommand({
             id: "livesync-plugin-dialog-ex",
             name: "Show customization sync dialog",
-            checkCallback: (checking) => {
-                if (!this.isThisModuleEnabled()) {
-                    return false;
-                }
-                if (!checking) {
-                    this.showPluginSyncModal();
-                }
-                return true;
+            callback: () => {
+                this.showPluginSyncModal();
             },
         });
         this.addRibbonIcon("custom-sync", $msg("cmdConfigSync.showCustomizationSync"), () => {

src/features/HiddenFileSync/CmdHiddenFileSync.ts

@@ -54,7 +54,10 @@ import { EVENT_SETTING_SAVED, eventHub } from "@/common/events.ts";
 import { Semaphore } from "octagonal-wheels/concurrency/semaphore";
 import type { LiveSyncCore } from "@/main.ts";
 import { tryGetFilePath } from "@vrtmrz/livesync-commonlib/compat/common/utils.doc";
-import { configureHiddenFileSyncMode, type ConfigureHiddenFileSyncResult } from "./configureHiddenFileSyncMode.ts";
+import {
+    configureHiddenFileSyncMode,
+    type ConfigureHiddenFileSyncResult,
+} from "./configureHiddenFileSyncMode.ts";
 import type { OptionalSyncFeatureMode } from "@/features/optionalSyncFeatures.ts";
 import { getObsidianCommunityPluginManager } from "@/common/obsidianCommunityPlugins.ts";
 type SyncDirection = "push" | "pull" | "safe" | "pullForce" | "pushForce";
@@ -106,45 +109,37 @@ export class HiddenFileSync extends LiveSyncCommands {
         this.services.API.addCommand({
             id: "livesync-sync-internal",
             name: "(re)initialise hidden files between storage and database",
-            checkCallback: (checking) => {
-                if (!this.isManualCommandAvailable()) return false;
-                if (!checking) {
+            callback: () => {
+                if (this.isReady()) {
                     void this.initialiseInternalFileSync("safe", true);
                 }
-                return true;
             },
         });
         this.services.API.addCommand({
             id: "livesync-scaninternal-storage",
             name: "Scan hidden file changes on the storage",
-            checkCallback: (checking) => {
-                if (!this.isManualCommandAvailable()) return false;
-                if (!checking) {
+            callback: () => {
+                if (this.isReady()) {
                     void this.scanAllStorageChanges(true);
                 }
-                return true;
             },
         });
         this.services.API.addCommand({
             id: "livesync-scaninternal-database",
             name: "Scan hidden file changes on the local database",
-            checkCallback: (checking) => {
-                if (!this.isManualCommandAvailable()) return false;
-                if (!checking) {
+            callback: () => {
+                if (this.isReady()) {
                     void this.scanAllDatabaseChanges(true);
                 }
-                return true;
             },
         });
         this.services.API.addCommand({
             id: "livesync-internal-scan-offline-changes",
             name: "Scan and apply all offline hidden-file changes",
-            checkCallback: (checking) => {
-                if (!this.isManualCommandAvailable()) return false;
-                if (!checking) {
+            callback: () => {
+                if (this.isReady()) {
                     void this.applyOfflineChanges(true);
                 }
-                return true;
             },
         });
         eventHub.onEvent(EVENT_SETTING_SAVED, () => {
@@ -196,16 +191,12 @@ export class HiddenFileSync extends LiveSyncCommands {
     }
 
     isReady() {
-        if (!this._isMainReady()) return false;
+        if (!this._isMainReady) return false;
         if (this._isMainSuspended()) return false;
         if (!this.isThisModuleEnabled()) return false;
         return true;
     }
 
-    private isManualCommandAvailable() {
-        return this.settings.useAdvancedMode && this.isReady() && this._isDatabaseReady();
-    }
-
     async performStartupScan(showNotice: boolean) {
         await this.applyOfflineChanges(showNotice);
     }
@@ -1530,29 +1521,6 @@ Offline Changed files: ${files.length}`;
         }
     }
 
-    private async getLiveInternalRevision(
-        prefixedFileName: FilePathWithPrefix,
-        revision: string
-    ): Promise<MetaEntry | false> {
-        const [selected, current, conflicts] = await Promise.all([
-            this.core.databaseFileAccess.fetchEntryMeta(prefixedFileName, revision, true),
-            this.core.databaseFileAccess.fetchEntryMeta(prefixedFileName, undefined, true),
-            this.core.databaseFileAccess.getConflictedRevs(prefixedFileName),
-        ]);
-        const liveRevisions = new Set([
-            ...(current && current._rev ? [current._rev] : []),
-            ...conflicts,
-        ]);
-        if (!selected || selected._rev !== revision || !liveRevisions.has(revision)) {
-            this._log(
-                `Could not use hidden-file revision ${revision} of ${stripAllPrefixes(prefixedFileName)}; the selected revision is no longer live`,
-                LOG_LEVEL_NOTICE
-            );
-            return false;
-        }
-        return selected;
-    }
-
     async storeInternalFileToDatabase(file: InternalFileInfo | UXFileInfo, forceWrite = false) {
         const storeFilePath = stripAllPrefixes(file.path);
         const storageFilePath = file.path;
@@ -1604,79 +1572,6 @@ Offline Changed files: ${files.length}`;
         });
     }
 
-    async storeInternalFileToDatabaseWithBaseRevision(
-        file: InternalFileInfo | UXFileInfo,
-        baseRevision: string,
-        createIfDifferent = true
-    ): Promise<boolean> {
-        const storeFilePath = stripAllPrefixes(file.path);
-        const storageFilePath = file.path;
-        if (await this.services.vault.isIgnoredByIgnoreFile(storageFilePath)) {
-            return false;
-        }
-        const prefixedFileName = addPrefix(storeFilePath, ICHeader);
-
-        return await serialized("file-" + prefixedFileName, async () => {
-            try {
-                const baseData = await this.getLiveInternalRevision(prefixedFileName, baseRevision);
-                if (baseData === false) {
-                    return false;
-                }
-                const fileInfo = "stat" in file && "body" in file ? file : await this.loadFileWithInfo(storeFilePath);
-                if (fileInfo.deleted) {
-                    throw new Error(`Hidden file:${storeFilePath} is deleted. This should not be occurred.`);
-                }
-                if (!baseData.deleted && !baseData._deleted) {
-                    const loadedBase = await this.core.databaseFileAccess.fetchEntryFromMeta(baseData, true, true);
-                    if (loadedBase && (await isDocContentSame(readAsBlob(loadedBase), fileInfo.body))) {
-                        this.updateLastProcessed(storeFilePath, baseData, fileInfo.stat);
-                        return true;
-                    }
-                }
-                if (!createIfDifferent) {
-                    this._log(
-                        `Could not mark hidden file ${storeFilePath} as revision ${baseRevision}; the storage content differs`,
-                        LOG_LEVEL_NOTICE
-                    );
-                    return false;
-                }
-
-                const storedRevision = await this.core.databaseFileAccess.storeWithBaseRevision(
-                    {
-                        ...fileInfo,
-                        path: storeFilePath,
-                        name: fileInfo.name || storeFilePath.split("/").pop() || "",
-                        isInternal: true,
-                    },
-                    baseRevision,
-                    true
-                );
-                if (storedRevision === false) {
-                    return false;
-                }
-                this.updateLastProcessed(
-                    storeFilePath,
-                    {
-                        ...baseData,
-                        _rev: storedRevision,
-                        path: prefixedFileName,
-                        ctime: fileInfo.stat.ctime,
-                        mtime: fileInfo.stat.mtime,
-                        size: fileInfo.stat.size,
-                        deleted: false,
-                    },
-                    fileInfo.stat
-                );
-                this._log(`STORAGE --> DB:${storageFilePath}: (hidden, selected branch) Done`);
-                return true;
-            } catch (ex) {
-                this._log(`STORAGE --> DB:${storageFilePath}: (hidden, selected branch) Failed`);
-                this._log(ex, LOG_LEVEL_VERBOSE);
-                return false;
-            }
-        });
-    }
-
     async deleteInternalFileOnDatabase(filenameSrc: FilePath, forceWrite = false) {
         const storeFilePath = filenameSrc;
         const storageFilePath = filenameSrc;
@@ -1740,8 +1635,7 @@ Offline Changed files: ${files.length}`;
         metaEntry?: MetaEntry | LoadedEntry,
         preventDoubleProcess = true,
         onlyNew = false,
-        includeDeletion = true,
-        requiredLiveRevision?: string
+        includeDeletion = true
     ) {
         const prefixedFileName = addPrefix(storageFilePath, ICHeader);
         if (await this.services.vault.isIgnoredByIgnoreFile(storageFilePath)) {
@@ -1750,11 +1644,9 @@ Offline Changed files: ${files.length}`;
         return await serialized("file-" + prefixedFileName, async () => {
             try {
                 // Check conflicted status
-                const metaOnDB = requiredLiveRevision
-                    ? await this.getLiveInternalRevision(prefixedFileName, requiredLiveRevision)
-                    : metaEntry
-                      ? metaEntry
-                      : await this.localDatabase.getDBEntryMeta(prefixedFileName, { conflicts: true }, true);
+                const metaOnDB = metaEntry
+                    ? metaEntry
+                    : await this.localDatabase.getDBEntryMeta(prefixedFileName, { conflicts: true }, true);
                 if (metaOnDB === false) throw new Error(`File not found on database.:${storageFilePath}`);
                 // Prevent overwrite for Prevent overwriting while some conflicted revision exists.
                 if (metaOnDB?._conflicts?.length) {
@@ -1828,24 +1720,6 @@ Offline Changed files: ${files.length}`;
         });
     }
 
-    async extractInternalFileRevisionFromDatabase(
-        storageFilePath: FilePath,
-        revision: string,
-        force = false
-    ): Promise<boolean> {
-        return Boolean(
-            await this.extractInternalFileFromDatabase(
-                storageFilePath,
-                force,
-                undefined,
-                true,
-                false,
-                true,
-                revision
-            )
-        );
-    }
-
     async __checkIsNeedToWriteFile(storageFilePath: FilePath, content: string | ArrayBuffer): Promise<boolean> {
         try {
             const storageContent = await this.core.storageAccess.readHiddenFileAuto(storageFilePath);

src/features/HiddenFileSync/CmdHiddenFileSync.unit.spec.ts

@@ -1,12 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import {
-    type DocumentID,
-    LOG_LEVEL_NOTICE,
-    type FilePath,
-    type FilePathWithPrefix,
-    type MetaEntry,
-    type UXFileInfo,
-} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { LOG_LEVEL_NOTICE } from "@vrtmrz/livesync-commonlib/compat/common/types";
 
 vi.mock("@/deps.ts", () => ({}));
 vi.mock("@/features/HiddenFileCommon/JsonResolveModal.ts", () => ({
@@ -15,16 +8,13 @@ vi.mock("@/features/HiddenFileCommon/JsonResolveModal.ts", () => ({
 vi.mock("@/features/LiveSyncCommands.ts", () => ({
     LiveSyncCommands: class LiveSyncCommands {
         plugin!: { app: unknown };
-        core!: { services: unknown; settings: unknown };
+        core!: { services: unknown };
         get app() {
             return this.plugin.app;
         }
         get services() {
             return this.core.services;
         }
-        get settings() {
-            return this.core.settings;
-        }
     },
 }));
 vi.mock("./configureHiddenFileSyncMode.ts", () => ({
@@ -34,131 +24,7 @@ vi.mock("./configureHiddenFileSyncMode.ts", () => ({
 import { HiddenFileSync } from "./CmdHiddenFileSync.ts";
 import { configureHiddenFileSyncMode } from "./configureHiddenFileSyncMode.ts";
 
-function createHiddenRevisionOperation() {
-    const path = ".obsidian/plugins/example/data.json" as FilePath;
-    const file = {
-        path,
-        name: "data.json",
-        isInternal: true,
-        body: new Blob(["{\"value\":\"vault\"}"]),
-        stat: {
-            ctime: 1,
-            mtime: 2,
-            size: 17,
-            type: "file",
-        },
-    } as UXFileInfo;
-    const selected = {
-        _id: "i:example" as DocumentID,
-        _rev: "2-selected",
-        path: `i:${path}` as FilePathWithPrefix,
-        ctime: 1,
-        mtime: 2,
-        size: 17,
-        type: "plain",
-        datatype: "plain",
-        children: [],
-        eden: {},
-        deleted: false,
-    } as MetaEntry;
-    const winner = {
-        ...selected,
-        _rev: "3-winner",
-    } as MetaEntry;
-    const databaseFileAccess = {
-        fetchEntryMeta: vi.fn(
-            async (_path: unknown, revision?: string) =>
-                revision === selected._rev ? selected : winner
-        ),
-        getConflictedRevs: vi.fn(async () => [selected._rev]),
-        fetchEntryFromMeta: vi.fn(async () => ({ ...selected, data: "{\"value\":\"database\"}" })),
-        storeWithBaseRevision: vi.fn(async () => "3-vault-child"),
-    };
-    const hiddenFileSync = Object.create(HiddenFileSync.prototype) as HiddenFileSync;
-    Object.assign(hiddenFileSync, {
-        core: {
-            services: {
-                vault: {
-                    isIgnoredByIgnoreFile: vi.fn(async () => false),
-                },
-            },
-            databaseFileAccess,
-        },
-        loadFileWithInfo: vi.fn(async () => file),
-        updateLastProcessed: vi.fn(),
-        _log: vi.fn(),
-    });
-    return {
-        hiddenFileSync,
-        path,
-        file,
-        selected,
-        winner,
-        databaseFileAccess,
-    };
-}
-
 describe("HiddenFileSync configuration-change notices", () => {
-    it("shows manual Hidden File Sync commands only when the feature, Advanced mode, and runtime are ready", () => {
-        const commands: Array<{
-            id: string;
-            checkCallback?: (checking: boolean) => boolean | void;
-        }> = [];
-        const settings = {
-            syncInternalFiles: false,
-            useAdvancedMode: false,
-        };
-        const hiddenFileSync = Object.create(HiddenFileSync.prototype) as HiddenFileSync;
-        Object.assign(hiddenFileSync, {
-            core: {
-                settings,
-                services: {
-                    API: {
-                        addCommand: vi.fn((command) => commands.push(command)),
-                    },
-                },
-            },
-            _isMainReady: vi.fn(() => true),
-            _isMainSuspended: vi.fn(() => false),
-            _isDatabaseReady: vi.fn(() => true),
-        });
-
-        hiddenFileSync.onload();
-
-        const commandIds = [
-            "livesync-sync-internal",
-            "livesync-scaninternal-storage",
-            "livesync-scaninternal-database",
-            "livesync-internal-scan-offline-changes",
-        ];
-        for (const commandId of commandIds) {
-            const command = commands.find(({ id }) => id === commandId);
-            expect(command?.checkCallback?.(true)).toBe(false);
-        }
-
-        settings.syncInternalFiles = true;
-        settings.useAdvancedMode = true;
-        for (const commandId of commandIds) {
-            const command = commands.find(({ id }) => id === commandId);
-            expect(command?.checkCallback?.(true)).toBe(true);
-        }
-    });
-
-    it("does not report Hidden File Sync as ready before the main runtime is ready", () => {
-        const hiddenFileSync = Object.create(HiddenFileSync.prototype) as HiddenFileSync;
-        Object.assign(hiddenFileSync, {
-            core: {
-                settings: {
-                    syncInternalFiles: true,
-                },
-            },
-            _isMainReady: vi.fn(() => false),
-            _isMainSuspended: vi.fn(() => false),
-        });
-
-        expect(hiddenFileSync.isReady()).toBe(false);
-    });
-
     it("groups plug-in reloads and an Obsidian restart into one finished Notice", async () => {
         const noticeGroups = {
             setItem: vi.fn(),
@@ -341,130 +207,3 @@ describe("HiddenFileSync configuration-change notices", () => {
         expect(progress.done).toHaveBeenCalledWith("Failed");
     });
 });
-
-describe("HiddenFileSync exact revision repair operations", () => {
-    it("stores the current hidden Vault file as a child of the selected live revision", async () => {
-        const {
-            hiddenFileSync,
-            file,
-            selected,
-            databaseFileAccess,
-        } = createHiddenRevisionOperation();
-
-        await expect(
-            hiddenFileSync.storeInternalFileToDatabaseWithBaseRevision(file, selected._rev!)
-        ).resolves.toBe(true);
-
-        expect(databaseFileAccess.storeWithBaseRevision).toHaveBeenCalledWith(
-            expect.objectContaining({
-                path: file.path,
-                body: file.body,
-                isInternal: true,
-            }),
-            selected._rev,
-            true
-        );
-        expect(hiddenFileSync.updateLastProcessed).toHaveBeenCalledWith(
-            file.path,
-            expect.objectContaining({ _rev: "3-vault-child" }),
-            file.stat
-        );
-    });
-
-    it("refuses to extend a hidden-file revision which is no longer live", async () => {
-        const {
-            hiddenFileSync,
-            file,
-            selected,
-            databaseFileAccess,
-        } = createHiddenRevisionOperation();
-        databaseFileAccess.getConflictedRevs.mockResolvedValue([]);
-
-        await expect(
-            hiddenFileSync.storeInternalFileToDatabaseWithBaseRevision(file, selected._rev!)
-        ).resolves.toBe(false);
-
-        expect(databaseFileAccess.storeWithBaseRevision).not.toHaveBeenCalled();
-        expect(hiddenFileSync.updateLastProcessed).not.toHaveBeenCalled();
-    });
-
-    it("does not create a hidden-file child when asked only to mark a revision which differs from the Vault", async () => {
-        const {
-            hiddenFileSync,
-            file,
-            selected,
-            databaseFileAccess,
-        } = createHiddenRevisionOperation();
-
-        await expect(
-            hiddenFileSync.storeInternalFileToDatabaseWithBaseRevision(
-                file,
-                selected._rev!,
-                false
-            )
-        ).resolves.toBe(false);
-
-        expect(databaseFileAccess.storeWithBaseRevision).not.toHaveBeenCalled();
-        expect(hiddenFileSync.updateLastProcessed).not.toHaveBeenCalled();
-    });
-
-    it("marks a matching hidden-file revision without creating a child", async () => {
-        const {
-            hiddenFileSync,
-            file,
-            selected,
-            databaseFileAccess,
-        } = createHiddenRevisionOperation();
-        databaseFileAccess.fetchEntryFromMeta.mockResolvedValue({
-            ...selected,
-            data: "{\"value\":\"vault\"}",
-        });
-
-        await expect(
-            hiddenFileSync.storeInternalFileToDatabaseWithBaseRevision(
-                file,
-                selected._rev!,
-                false
-            )
-        ).resolves.toBe(true);
-
-        expect(databaseFileAccess.storeWithBaseRevision).not.toHaveBeenCalled();
-        expect(hiddenFileSync.updateLastProcessed).toHaveBeenCalledWith(
-            file.path,
-            selected,
-            file.stat
-        );
-    });
-
-    it("applies the selected live hidden-file revision through the existing extraction path", async () => {
-        const {
-            hiddenFileSync,
-            path,
-            selected,
-        } = createHiddenRevisionOperation();
-        const extract = vi.fn(async () => true);
-        hiddenFileSync.extractInternalFileFromDatabase = extract;
-
-        await expect(
-            hiddenFileSync.extractInternalFileRevisionFromDatabase(path, selected._rev!, true)
-        ).resolves.toBe(true);
-
-        expect(extract).toHaveBeenCalledWith(path, true, undefined, true, false, true, selected._rev);
-    });
-
-    it("does not apply a hidden-file revision which ceased to be live", async () => {
-        const {
-            hiddenFileSync,
-            path,
-            selected,
-            databaseFileAccess,
-        } = createHiddenRevisionOperation();
-        databaseFileAccess.getConflictedRevs.mockResolvedValue([]);
-
-        await expect(
-            hiddenFileSync.extractInternalFileRevisionFromDatabase(path, selected._rev!, true)
-        ).resolves.toBe(false);
-
-        expect(databaseFileAccess.fetchEntryFromMeta).not.toHaveBeenCalled();
-    });
-});

src/features/LocalDatabaseMainte/CmdLocalDatabaseMainte.integration.spec.ts

@@ -1,257 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import PouchDB from "pouchdb-core";
-import HttpPouch from "pouchdb-adapter-http";
-import MemoryAdapter from "pouchdb-adapter-memory";
-import replication from "pouchdb-replication";
-
-vi.mock("@/features/LiveSyncCommands", () => ({
-    LiveSyncCommands: class LiveSyncCommands {
-        core!: { settings: unknown };
-        get settings() {
-            return this.core.settings;
-        }
-    },
-}));
-vi.mock("@/common/events", () => ({
-    EVENT_ANALYSE_DB_USAGE: "analyse",
-    EVENT_REQUEST_PERFORM_GC_V3: "gc",
-    eventHub: {
-        onEvent: vi.fn(),
-    },
-}));
-
-import {
-    DEFAULT_SETTINGS,
-    REMOTE_COUCHDB,
-    type DocumentID,
-    type EntryDoc,
-} from "@vrtmrz/livesync-commonlib/compat/common/types";
-import { LiveSyncLocalDB } from "@vrtmrz/livesync-commonlib/compat/pouchdb/LiveSyncLocalDB";
-import { LocalDatabaseMaintenance } from "./CmdLocalDatabaseMainte";
-
-PouchDB.plugin(HttpPouch).plugin(MemoryAdapter).plugin(replication);
-
-type FixtureContent = {
-    type: "leaf" | "plain";
-    data?: string;
-    path?: string;
-    children?: string[];
-    ctime?: number;
-    mtime?: number;
-    size?: number;
-    eden?: Record<string, never>;
-};
-
-type FixtureDocument = PouchDB.Core.PutDocument<FixtureContent> & {
-    _id: DocumentID;
-    _revisions?: {
-        start: number;
-        ids: string[];
-    };
-};
-
-function chunk(id: string, data = id): FixtureDocument {
-    return {
-        _id: id as DocumentID,
-        type: "leaf",
-        data,
-    };
-}
-
-function revision(id: string, rev: string, history: string[], children: string[]): FixtureDocument {
-    return {
-        _id: id as DocumentID,
-        _rev: rev,
-        _revisions: {
-            start: Number(rev.split("-")[0]),
-            ids: history,
-        },
-        type: "plain",
-        path: id,
-        children,
-        ctime: 1,
-        mtime: 1,
-        size: children.length,
-        eden: {},
-    } as unknown as FixtureDocument;
-}
-
-function liveSyncDatabaseFor(database: PouchDB.Database<FixtureContent>): LiveSyncLocalDB {
-    const subject = Object.create(LiveSyncLocalDB.prototype) as LiveSyncLocalDB;
-    Object.assign(subject, {
-        localDatabase: database as unknown as PouchDB.Database<EntryDoc>,
-    });
-    return subject;
-}
-
-function requiredEnvironment(name: "hostname" | "username" | "password"): string {
-    const value = process.env[name];
-    if (!value) {
-        throw new Error(`Missing required integration-test environment variable: ${name}`);
-    }
-    return value;
-}
-
-describe("LocalDatabaseMaintenance Garbage Collection V3 with CouchDB", () => {
-    it("propagates collection safely, completes compaction, and permits content-addressed chunk recreation", async () => {
-        const databaseName = `livesync-gcv3-${crypto.randomUUID()}`;
-        const local = new PouchDB<FixtureContent>(`${databaseName}-source`, { adapter: "memory" });
-        const replica = new PouchDB<FixtureContent>(`${databaseName}-replica`, { adapter: "memory" });
-        const remote = new PouchDB<FixtureContent>(
-            `${requiredEnvironment("hostname").replace(/\/+$/u, "")}/${databaseName}`,
-            {
-                adapter: "http",
-                auth: {
-                    username: requiredEnvironment("username"),
-                    password: requiredEnvironment("password"),
-                },
-            }
-        );
-
-        try {
-            await remote.info();
-            await local.bulkDocs([
-                chunk("h:obsolete"),
-                chunk("h:current"),
-                chunk("h:shared"),
-                chunk("h:base"),
-                chunk("h:left"),
-                chunk("h:right"),
-            ]);
-
-            const firstRevision = revision("first.md", "1-first", ["first"], ["h:obsolete"]);
-            delete firstRevision._rev;
-            delete firstRevision._revisions;
-            await local.put(firstRevision);
-            await local.put({
-                ...(await local.get("first.md")),
-                children: ["h:current"],
-            });
-
-            for (const id of ["second.md", "third.md"]) {
-                const sharedRevision = revision(id, `1-${id}`, [id], ["h:shared"]);
-                delete sharedRevision._rev;
-                delete sharedRevision._revisions;
-                await local.put(sharedRevision);
-            }
-
-            await local.bulkDocs(
-                [
-                    revision("conflicted.md", "1-base", ["base"], ["h:base"]),
-                    revision("conflicted.md", "2-left", ["left", "base"], ["h:left"]),
-                    revision("conflicted.md", "2-right", ["right", "base"], ["h:right"]),
-                ],
-                { new_edits: false }
-            );
-
-            const liveSyncDatabase = liveSyncDatabaseFor(local);
-            const replicationModes: string[] = [];
-            const replicator = {
-                openOneShotReplication: vi.fn(
-                    async (
-                        _settings: typeof DEFAULT_SETTINGS,
-                        _showResult: boolean,
-                        _ignoreCleanLock: boolean,
-                        mode: string
-                    ) => {
-                        replicationModes.push(mode);
-                        if (mode === "sync") {
-                            await local.sync(remote);
-                        } else if (mode === "pushOnly") {
-                            await local.replicate.to(remote);
-                        } else {
-                            throw new Error(`Unexpected replication mode: ${mode}`);
-                        }
-                        return true;
-                    }
-                ),
-                getConnectedDeviceList: vi.fn(() =>
-                    Promise.resolve({
-                        accepted_nodes: ["integration-device"],
-                        node_info: {
-                            "integration-device": {
-                                progress: "10-local",
-                                device_name: "Integration device",
-                                app_version: "1.12.7",
-                                plugin_version: "1.0.0-beta.0",
-                            },
-                        },
-                    })
-                ),
-                connectRemoteCouchDBWithSetting: vi.fn(() => Promise.resolve({ db: remote })),
-            };
-            const notice = vi.fn();
-            const maintenance = Object.create(LocalDatabaseMaintenance.prototype) as LocalDatabaseMaintenance;
-            Object.assign(maintenance, {
-                core: {
-                    settings: {
-                        ...DEFAULT_SETTINGS,
-                        remoteType: REMOTE_COUCHDB,
-                    },
-                    replicator,
-                    confirm: {
-                        askSelectStringDialogue: vi.fn(() => Promise.resolve("Proceed Garbage Collection")),
-                    },
-                },
-                localDatabase: liveSyncDatabase,
-                _notice: notice,
-            });
-            vi.spyOn(maintenance, "ensureAvailable").mockResolvedValue(true);
-            const clearHash = vi.spyOn(maintenance, "clearHash").mockImplementation(() => undefined);
-
-            await maintenance.gcv3();
-
-            expect(replicationModes).toEqual(["sync", "pushOnly"]);
-            expect(clearHash).toHaveBeenCalledOnce();
-            expect(notice).toHaveBeenCalledWith("Compaction on remote database completed successfully.", "gc-compact");
-            expect(notice).not.toHaveBeenCalledWith("Compaction on remote database timed out.", "gc-compact");
-            expect(notice).not.toHaveBeenCalledWith("Compaction on remote database failed.", "gc-compact");
-
-            const obsoleteRow = (await remote.allDocs({ keys: ["h:obsolete"] })).rows[0];
-            expect(obsoleteRow).toMatchObject({
-                id: "h:obsolete",
-                value: {
-                    deleted: true,
-                },
-            });
-
-            for (const retainedChunk of ["h:current", "h:shared", "h:base", "h:left", "h:right"]) {
-                await expect(remote.get(retainedChunk)).resolves.toMatchObject({
-                    _id: retainedChunk,
-                    type: "leaf",
-                });
-            }
-            await expect(remote.get("second.md")).resolves.toMatchObject({ children: ["h:shared"] });
-            await expect(remote.get("third.md")).resolves.toMatchObject({ children: ["h:shared"] });
-            await expect(remote.get("conflicted.md", { conflicts: true })).resolves.toMatchObject({
-                _conflicts: [expect.any(String)],
-            });
-
-            await remote.replicate.to(replica);
-            await expect(replica.get("h:obsolete")).rejects.toMatchObject({ status: 404 });
-            for (const retainedChunk of ["h:current", "h:shared", "h:base", "h:left", "h:right"]) {
-                await expect(replica.get(retainedChunk)).resolves.toMatchObject({
-                    _id: retainedChunk,
-                    type: "leaf",
-                });
-            }
-
-            await local.put(chunk("h:obsolete", "recreated"));
-            await local.replicate.to(remote);
-            await remote.replicate.to(replica);
-
-            await expect(remote.get("h:obsolete")).resolves.toMatchObject({
-                _id: "h:obsolete",
-                type: "leaf",
-                data: "recreated",
-            });
-            await expect(replica.get("h:obsolete")).resolves.toMatchObject({
-                _id: "h:obsolete",
-                type: "leaf",
-                data: "recreated",
-            });
-        } finally {
-            await Promise.all([local.destroy(), replica.destroy(), remote.destroy()]);
-        }
-    }, 30_000);
-});

src/features/LocalDatabaseMainte/CmdLocalDatabaseMainte.ts

@@ -4,7 +4,6 @@ import {
     LOG_LEVEL_INFO,
     LOG_LEVEL_NOTICE,
     LOG_LEVEL_VERBOSE,
-    REMOTE_COUCHDB,
     type DocumentID,
     type EntryDoc,
     type EntryLeaf,
@@ -39,27 +38,16 @@ export class LocalDatabaseMaintenance extends LiveSyncCommands {
             id: "analyse-database",
             name: "Analyse Database Usage (advanced)",
             icon: "database-search",
-            checkCallback: (checking) => {
-                if (!this.settings.useAdvancedMode || !this._isDatabaseReady()) return false;
-                if (!checking) {
-                    void this.analyseDatabase();
-                }
-                return true;
+            callback: async () => {
+                await this.analyseDatabase();
             },
         });
         this.plugin.addCommand({
             id: "gc-v3",
             name: "Garbage Collection V3 (advanced, beta)",
             icon: "trash-2",
-            checkCallback: (checking) => {
-                const isApplicableRemote = this.settings.remoteType === REMOTE_COUCHDB;
-                if (!this.settings.useEdgeCaseMode || !this._isDatabaseReady() || !isApplicableRemote) {
-                    return false;
-                }
-                if (!checking) {
-                    void this.gcv3();
-                }
-                return true;
+            callback: async () => {
+                await this.gcv3();
             },
         });
         eventHub.onEvent(EVENT_ANALYSE_DB_USAGE, () => this.analyseDatabase());
@@ -462,7 +450,7 @@ Note: **Make sure to synchronise all devices before deletion.**
         const confirmMessage = `This function deletes unused chunks from the device. If there are differences between devices, some chunks may be missing when resolving conflicts.
 Be sure to synchronise before executing.
 
-If chunks used by current Vault files are deleted, Hatch -> Recreate chunks for current Vault files can recreate them only from files currently present in the Vault. It cannot recover unreadable historical or conflict content.
+However, if you have deleted them, you may be able to recover them by performing Hatch -> Recreate missing chunks for all files.
 
 Are you ready to delete unused chunks?`;
 
@@ -760,7 +748,7 @@ Success: ${successCount}, Errored: ${errored}`;
                 timeout -= 2000;
                 if (timeout <= 0) {
                     this._notice("Compaction on remote database timed out.", "gc-compact");
-                    return;
+                    break;
                 }
             } else {
                 break;
@@ -883,14 +871,9 @@ It is preferable to update all devices if possible. If you have any devices that
         }
 
         //2. Check whether the progress values in NodeData are roughly the same (only the numerical part is needed).
-        const progressValues = Object.values(node_info).map((entry) => {
-            const progress = typeof entry.progress === "string" ? entry.progress.split("-")[0] : "";
-            return /^\d+$/u.test(progress) ? Number(progress) : Number.NaN;
-        });
-        if (progressValues.length === 0 || progressValues.some((progress) => !Number.isSafeInteger(progress))) {
-            this._notice("No connected device information found. Cancelling Garbage Collection.");
-            return;
-        }
+        const progressValues = Object.values(node_info)
+            .map((e) => e.progress.split("-")[0])
+            .map((e) => parseInt(e));
         const maxProgress = Math.max(...progressValues);
         const minProgress = Math.min(...progressValues);
         const progressDifference = maxProgress - minProgress;
@@ -929,22 +912,41 @@ This may indicate that some devices have not completed synchronisation, which co
         const gcStartTime = Date.now();
         // Perform Garbage Collection (new implementation).
         const localDatabase = this.localDatabase.localDatabase;
-        // Use the revision-aware reachability scan. Reading only winning revisions
-        // would make chunks used exclusively by live conflict branches look unused.
-        const { used: usedChunks, existing: allChunks } = await this.localDatabase.allChunks();
+        const usedChunks = new Set<DocumentID>();
+        const allChunks = new Map<DocumentID, string>();
+
+        const IDs = this.localDatabase.findEntryNames("", "", {});
+        let i = 0;
+        const doc_count = (await localDatabase.info()).doc_count;
+        for await (const id of IDs) {
+            const doc = await this.localDatabase.getRaw(id as DocumentID);
+            i++;
+            if (i % 100 == 0) {
+                this._notice(`Garbage Collection: Scanned ${i} / ~${doc_count} `, "gc-scanning");
+            }
+            if (!doc) continue;
+            if ("children" in doc) {
+                const children = (doc.children || []) as DocumentID[];
+                for (const chunkId of children) {
+                    usedChunks.add(chunkId);
+                }
+            } else if (doc.type === EntryTypes.CHUNK) {
+                allChunks.set(doc._id, doc._rev);
+            }
+        }
         this._notice(
             `Garbage Collection: Scanning completed. Total chunks: ${allChunks.size}, Used chunks: ${usedChunks.size}`,
             "gc-scanning"
         );
 
-        const unusedChunks = [...allChunks.entries()].filter(([chunkId]) => !usedChunks.has(chunkId));
+        const unusedChunks = [...allChunks.keys()].filter((e) => !usedChunks.has(e));
         this._notice(`Garbage Collection: Found ${unusedChunks.length} unused chunks to delete.`, "gc-scanning");
         const deleteChunkDocs = unusedChunks.map(
-            ([chunkId, chunk]) =>
+            (chunkId) =>
                 ({
-                    _id: chunkId as DocumentID,
+                    _id: chunkId,
                     _deleted: true,
-                    _rev: chunk._rev,
+                    _rev: allChunks.get(chunkId),
                 }) as EntryLeaf
         );
         const response = await localDatabase.bulkDocs(deleteChunkDocs);

src/features/LocalDatabaseMainte/CmdLocalDatabaseMainte.unit.spec.ts

@@ -1,43 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-
-vi.mock("octagonal-wheels/number", () => ({
-    sizeToHumanReadable: vi.fn((value: number) => `${value} B`),
-}));
-vi.mock("octagonal-wheels/concurrency/lock_v2", () => ({
-    serialized: vi.fn((_key: string, task: () => unknown) => task()),
-}));
-vi.mock("octagonal-wheels/collection", () => ({
-    arrayToChunkedArray: vi.fn((values: unknown[]) => [values]),
-}));
-vi.mock("@vrtmrz/livesync-commonlib/compat/common/utils", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("@vrtmrz/livesync-commonlib/compat/common/utils")>();
-    return {
-        ...actual,
-        delay: vi.fn(async () => undefined),
-    };
-});
-vi.mock("@/features/LiveSyncCommands", () => ({
-    LiveSyncCommands: class LiveSyncCommands {
-        core!: { settings: unknown };
-        get settings() {
-            return this.core.settings;
-        }
-    },
-}));
-vi.mock("@/common/events", () => ({
-    EVENT_ANALYSE_DB_USAGE: "analyse",
-    EVENT_REQUEST_PERFORM_GC_V3: "gc",
-    eventHub: {
-        onEvent: vi.fn(),
-    },
-}));
-import {
-    DEFAULT_SETTINGS,
-    REMOTE_COUCHDB,
-    REMOTE_MINIO,
-    REMOTE_P2P,
-} from "@vrtmrz/livesync-commonlib/compat/common/types";
-import { LocalDatabaseMaintenance } from "./CmdLocalDatabaseMainte";
+import { DEFAULT_SETTINGS } from "@vrtmrz/livesync-commonlib/compat/common/types";
 import { ensureLocalDatabaseMaintenancePrerequisites } from "./maintenancePrerequisites";
 
 function createPrerequisites(settingsOverride: Partial<typeof DEFAULT_SETTINGS> = {}) {
@@ -60,52 +22,6 @@ function createPrerequisites(settingsOverride: Partial<typeof DEFAULT_SETTINGS>
 }
 
 describe("LocalDatabaseMaintenance prerequisites", () => {
-    it("shows database analysis in Advanced mode and Garbage Collection only in applicable Edge Case mode", () => {
-        const commands: Array<{
-            id: string;
-            checkCallback?: (checking: boolean) => boolean | void;
-        }> = [];
-        const settings: {
-            useAdvancedMode: boolean;
-            useEdgeCaseMode: boolean;
-            remoteType: string;
-        } = {
-            useAdvancedMode: false,
-            useEdgeCaseMode: false,
-            remoteType: REMOTE_COUCHDB,
-        };
-        const maintenance = Object.create(LocalDatabaseMaintenance.prototype) as LocalDatabaseMaintenance;
-        Object.assign(maintenance, {
-            plugin: {
-                addCommand: vi.fn((command) => commands.push(command)),
-            },
-            core: {
-                settings,
-            },
-            _isDatabaseReady: vi.fn(() => true),
-        });
-
-        maintenance.onload();
-
-        const analyse = commands.find(({ id }) => id === "analyse-database");
-        const garbageCollect = commands.find(({ id }) => id === "gc-v3");
-        expect(analyse?.checkCallback?.(true)).toBe(false);
-        expect(garbageCollect?.checkCallback?.(true)).toBe(false);
-
-        settings.useAdvancedMode = true;
-        expect(analyse?.checkCallback?.(true)).toBe(true);
-        expect(garbageCollect?.checkCallback?.(true)).toBe(false);
-
-        settings.useEdgeCaseMode = true;
-        expect(garbageCollect?.checkCallback?.(true)).toBe(true);
-
-        settings.remoteType = REMOTE_P2P;
-        expect(garbageCollect?.checkCallback?.(true)).toBe(false);
-
-        settings.remoteType = REMOTE_MINIO;
-        expect(garbageCollect?.checkCallback?.(true)).toBe(false);
-    });
-
     it("asks to disable on-demand chunk fetching before maintenance actions", async () => {
         const { settings, askSelectStringDialogue, applyPartial } = createPrerequisites();
 
@@ -191,231 +107,4 @@ describe("LocalDatabaseMaintenance prerequisites", () => {
         expect(askSelectStringDialogue).not.toHaveBeenCalled();
         expect(applyPartial).not.toHaveBeenCalled();
     });
-
-    it("describes the current chunk-recreation action without promising historical recovery", async () => {
-        const maintenance = Object.create(LocalDatabaseMaintenance.prototype) as LocalDatabaseMaintenance;
-        const askSelectStringDialogue = vi.fn().mockResolvedValue("Cancel");
-        Object.assign(maintenance, {
-            core: {
-                confirm: {
-                    askSelectStringDialogue,
-                },
-            },
-            _log: vi.fn(),
-        });
-        vi.spyOn(maintenance, "ensureAvailable").mockResolvedValue(true);
-        vi.spyOn(maintenance, "trackChanges").mockResolvedValue(undefined);
-
-        await maintenance.performGC();
-
-        const message = vi.mocked(askSelectStringDialogue).mock.calls[0]?.[0] as string;
-        expect(message).toContain("Hatch -> Recreate chunks for current Vault files");
-        expect(message).toContain("only from files currently present in the Vault");
-        expect(message).not.toContain("Recreate missing chunks for all files");
-    });
-});
-
-describe("LocalDatabaseMaintenance Garbage Collection V3", () => {
-    it("does not report remote compaction as successful after its completion wait times out", async () => {
-        const maintenance = Object.create(LocalDatabaseMaintenance.prototype) as LocalDatabaseMaintenance;
-        const notice = vi.fn();
-        const remoteDatabase = {
-            compact: vi.fn(async () => ({ ok: true })),
-            info: vi.fn(async () => ({ compact_running: true })),
-        };
-        Object.assign(maintenance, {
-            core: {
-                replicator: {
-                    connectRemoteCouchDBWithSetting: vi.fn(async () => ({ db: remoteDatabase })),
-                },
-                settings: {
-                    ...DEFAULT_SETTINGS,
-                    remoteType: REMOTE_COUCHDB,
-                },
-            },
-            _notice: notice,
-        });
-
-        await maintenance.compactDatabase();
-
-        expect(notice).toHaveBeenCalledWith("Compaction on remote database timed out.", "gc-compact");
-        expect(notice).not.toHaveBeenCalledWith(
-            "Compaction on remote database completed successfully.",
-            "gc-compact"
-        );
-    });
-
-    it.each([
-        ["no device progress entries", {}],
-        [
-            "an unparseable device progress entry",
-            {
-                "device-a": {
-                    progress: "",
-                    device_name: "Device A",
-                    app_version: "1.12.7",
-                    plugin_version: "1.0.0-beta.0",
-                },
-            },
-        ],
-        [
-            "a missing device progress entry",
-            {
-                "device-a": {
-                    device_name: "Device A",
-                    app_version: "1.12.7",
-                    plugin_version: "1.0.0-beta.0",
-                },
-            },
-        ],
-    ] as const)("cancels before collection when the milestone has %s", async (_case, nodeInfo) => {
-        const maintenance = Object.create(LocalDatabaseMaintenance.prototype) as LocalDatabaseMaintenance;
-        const pushModes: string[] = [];
-        const allChunks = vi.fn(async () => ({
-            used: new Set<string>(),
-            existing: new Map(),
-        }));
-        const replicator = {
-            openOneShotReplication: vi.fn(async (...args: unknown[]) => {
-                pushModes.push(String(args[3]));
-                return true;
-            }),
-            getConnectedDeviceList: vi.fn(async () => ({
-                accepted_nodes: Object.keys(nodeInfo),
-                node_info: nodeInfo,
-            })),
-        };
-        const notice = vi.fn();
-        Object.assign(maintenance, {
-            core: {
-                settings: {
-                    ...DEFAULT_SETTINGS,
-                    remoteType: REMOTE_COUCHDB,
-                },
-                replicator,
-                confirm: {
-                    askSelectStringDialogue: vi.fn(async () => "Proceed Garbage Collection"),
-                },
-            },
-            localDatabase: {
-                allChunks,
-                localDatabase: {
-                    bulkDocs: vi.fn(async () => []),
-                },
-            },
-            _notice: notice,
-        });
-        vi.spyOn(maintenance, "ensureAvailable").mockResolvedValue(true);
-        vi.spyOn(maintenance, "compactDatabase").mockResolvedValue(undefined);
-        vi.spyOn(maintenance, "clearHash").mockImplementation(() => undefined);
-
-        await maintenance.gcv3();
-
-        expect(allChunks).not.toHaveBeenCalled();
-        expect(pushModes).toEqual(["sync"]);
-        expect(notice).toHaveBeenCalledWith(
-            "No connected device information found. Cancelling Garbage Collection."
-        );
-    });
-
-    it("keeps chunks referenced by a live conflict revision and deletes only unreachable chunks", async () => {
-        const maintenance = Object.create(LocalDatabaseMaintenance.prototype) as LocalDatabaseMaintenance;
-        const pushModes: string[] = [];
-        const deletedChunks: Array<{ _id: string; _rev?: string; _deleted?: boolean }> = [];
-        const allChunks = vi.fn(async () => ({
-            used: new Set(["h:winner", "h:conflict"]),
-            existing: new Map([
-                ["h:winner", { _id: "h:winner", _rev: "1-winner", type: "leaf", data: "winner" }],
-                ["h:conflict", { _id: "h:conflict", _rev: "1-conflict", type: "leaf", data: "conflict" }],
-                ["h:obsolete", { _id: "h:obsolete", _rev: "1-obsolete", type: "leaf", data: "obsolete" }],
-            ]),
-        }));
-        const rawDocuments = new Map<string, object>([
-            [
-                "note.md",
-                {
-                    _id: "note.md",
-                    _rev: "2-winner",
-                    _conflicts: ["2-conflict"],
-                    type: "plain",
-                    children: ["h:winner"],
-                },
-            ],
-            ["h:winner", { _id: "h:winner", _rev: "1-winner", type: "leaf", data: "winner" }],
-            ["h:conflict", { _id: "h:conflict", _rev: "1-conflict", type: "leaf", data: "conflict" }],
-            ["h:obsolete", { _id: "h:obsolete", _rev: "1-obsolete", type: "leaf", data: "obsolete" }],
-        ]);
-        const findEntryNames = vi.fn(async function* () {
-            yield* rawDocuments.keys();
-        });
-        const getRaw = vi.fn(async (id: string) => rawDocuments.get(id));
-        const localDatabase = {
-            allChunks,
-            localDatabase: {
-                info: vi.fn(async () => ({ doc_count: rawDocuments.size })),
-                bulkDocs: vi.fn(async (docs: Array<{ _id: string; _rev?: string; _deleted?: boolean }>) => {
-                    deletedChunks.push(...docs);
-                    return docs.map(({ _id }) => ({ ok: true, id: _id, rev: "2-deleted" }));
-                }),
-            },
-            findEntryNames,
-            getRaw,
-        };
-        const replicator = {
-            openOneShotReplication: vi.fn(
-                async (
-                    _settings: typeof DEFAULT_SETTINGS,
-                    _showResult: boolean,
-                    _ignoreCleanLock: boolean,
-                    mode: string
-                ) => {
-                    pushModes.push(mode);
-                    return true;
-                }
-            ),
-            getConnectedDeviceList: vi.fn(async () => ({
-                accepted_nodes: ["device-a"],
-                node_info: {
-                    "device-a": {
-                        progress: "10-local",
-                        device_name: "Device A",
-                        app_version: "1.12.7",
-                        plugin_version: "1.0.0-beta.0",
-                    },
-                },
-            })),
-        };
-        Object.assign(maintenance, {
-            core: {
-                settings: {
-                    ...DEFAULT_SETTINGS,
-                    remoteType: REMOTE_COUCHDB,
-                },
-                replicator,
-                confirm: {
-                    askSelectStringDialogue: vi.fn(async () => "Proceed Garbage Collection"),
-                },
-            },
-            localDatabase,
-            _notice: vi.fn(),
-        });
-        vi.spyOn(maintenance, "ensureAvailable").mockResolvedValue(true);
-        vi.spyOn(maintenance, "compactDatabase").mockResolvedValue(undefined);
-        vi.spyOn(maintenance, "clearHash").mockImplementation(() => undefined);
-
-        await maintenance.gcv3();
-
-        expect(allChunks).toHaveBeenCalledOnce();
-        expect(findEntryNames).not.toHaveBeenCalled();
-        expect(getRaw).not.toHaveBeenCalled();
-        expect(deletedChunks).toEqual([
-            {
-                _id: "h:obsolete",
-                _rev: "1-obsolete",
-                _deleted: true,
-            },
-        ]);
-        expect(pushModes).toEqual(["sync", "pushOnly"]);
-        expect(maintenance.compactDatabase).toHaveBeenCalledOnce();
-    });
 });

src/modules/coreFeatures/ModuleConflictResolver.ts

@@ -86,11 +86,8 @@ export class ModuleConflictResolver extends AbstractModule {
             return MISSING_OR_ERROR;
         }
         if (rightLeaf == false) {
-            // A locally unreadable conflict leaf may still be recoverable from another
-            // replica or backup. Keep it visible for explicit repair instead of treating
-            // missing chunks as evidence that the branch is obsolete.
-            this._log(`could not read conflicted revision ${rightRev}:${path}`, LOG_LEVEL_NOTICE);
-            return MISSING_OR_ERROR;
+            // Conflicted item could not load, delete this.
+            return await this.services.conflict.resolveByDeletingRevision(path, rightRev, "MISSING OLD REV");
         }
 
         const isSame = leftLeaf.data == rightLeaf.data && leftLeaf.deleted == rightLeaf.deleted;

src/modules/coreFeatures/ModuleConflictResolver.unit.spec.ts

@@ -4,7 +4,6 @@ import {
     DEFAULT_SETTINGS,
     LOG_LEVEL_INFO,
     LOG_LEVEL_NOTICE,
-    MISSING_OR_ERROR,
     type FilePathWithPrefix,
     type MetaEntry,
 } from "@vrtmrz/livesync-commonlib/compat/common/types";
@@ -190,28 +189,6 @@ describe("ModuleConflictResolver independent same-path creation", () => {
 });
 
 describe("ModuleConflictResolver sensible merge hand-off", () => {
-    it("keeps an unreadable non-winner revision unresolved", async () => {
-        const path = "missing-conflict-body.md" as FilePathWithPrefix;
-        const { module, resolveByDeletingRevision, tryAutoMerge } = createModule();
-        tryAutoMerge.mockResolvedValue({
-            leftRev: "3-current",
-            rightRev: "2-unreadable",
-            leftLeaf: {
-                rev: "3-current",
-                data: "Readable current body\n",
-                ctime: 1,
-                mtime: 3,
-                deleted: false,
-            },
-            rightLeaf: false,
-        });
-
-        const result = await module.checkConflictAndPerformAutoMerge(path);
-
-        expect(result).toBe(MISSING_OR_ERROR);
-        expect(resolveByDeletingRevision).not.toHaveBeenCalled();
-    });
-
     it("stores the merged body and removes the resolved conflict leaf", async () => {
         const path = "sensible.md" as FilePathWithPrefix;
         const { module, resolveByDeletingRevision, tryAutoMerge } = createModule();

src/modules/essential/ModuleBasicMenu.ts

@@ -2,29 +2,24 @@ import type { LiveSyncCore } from "@/main";
 import { LOG_LEVEL_NOTICE } from "octagonal-wheels/common/logger";
 import { fireAndForget } from "octagonal-wheels/promises";
 import { AbstractModule } from "@/modules/AbstractModule";
-import { $msg } from "@/common/translation";
-import { copyFileDatabaseInfo } from "@/serviceFeatures/fileDatabaseInfo";
 // Separated Module for basic menu commands, which are not related to obsidian specific features. It is expected to be used in other platforms with minimal changes.
 // However, it is odd that it has here at all; it really ought to be in each respective feature. It will likely be moved eventually. Until now, addCommand pointed to Obsidian's version.
 export class ModuleBasicMenu extends AbstractModule {
     _everyOnloadStart(): Promise<boolean> {
         this.addCommand({
             id: "livesync-replicate",
-            name: $msg("Sync now"),
+            name: "Replicate now",
             callback: async () => {
                 await this.services.replication.replicate();
             },
         });
         this.addCommand({
             id: "livesync-dump",
-            name: $msg("Copy database information for the active file"),
-            checkCallback: (checking) => {
+            name: "Dump information of this doc ",
+            callback: () => {
                 const file = this.services.vault.getActiveFilePath();
-                if (!file) return false;
-                if (!checking) {
-                    fireAndForget(() => copyFileDatabaseInfo(this.core, file));
-                }
-                return true;
+                if (!file) return;
+                fireAndForget(() => this.localDatabase.getDBEntry(file, {}, true, false));
             },
         });
         this.addCommand({
@@ -61,18 +56,14 @@ export class ModuleBasicMenu extends AbstractModule {
         this.addCommand({
             id: "livesync-scan-files",
             name: "Scan storage and database again",
-            checkCallback: (checking) => {
-                if (!this.settings.useAdvancedMode) return false;
-                if (!checking) {
-                    fireAndForget(() => this.services.vault.scanVault(true));
-                }
-                return true;
+            callback: async () => {
+                await this.services.vault.scanVault(true);
             },
         });
 
         this.addCommand({
             id: "livesync-runbatch",
-            name: $msg("Apply pending changes now"),
+            name: "Run pended batch processes",
             callback: async () => {
                 await this.services.fileProcessing.commitPendingFileEvents();
             },
@@ -82,12 +73,8 @@ export class ModuleBasicMenu extends AbstractModule {
         this.addCommand({
             id: "livesync-abortsync",
             name: "Abort synchronization immediately",
-            checkCallback: (checking) => {
-                if (!this.settings.useAdvancedMode) return false;
-                if (!checking) {
-                    this.core.replicator.terminateSync();
-                }
-                return true;
+            callback: () => {
+                this.core.replicator.terminateSync();
             },
         });
         return Promise.resolve(true);

src/modules/essential/ModuleBasicMenu.unit.spec.ts

@@ -1,170 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { Command } from "@/deps";
-import { ModuleBasicMenu } from "./ModuleBasicMenu";
-
-type RegisteredCommand = Command & {
-    checkCallback?: (checking: boolean) => boolean | void;
-};
-
-function createFixture() {
-    const commands: RegisteredCommand[] = [];
-    const settings = {
-        liveSync: false,
-        useAdvancedMode: false,
-        enableDebugTools: false,
-    };
-    const services = {
-        API: {
-            addLog: vi.fn(),
-            addCommand: vi.fn((command: RegisteredCommand) => {
-                commands.push(command);
-                return command;
-            }),
-            registerWindow: vi.fn(),
-            addRibbonIcon: vi.fn(),
-            registerProtocolHandler: vi.fn(),
-        },
-        replication: {
-            replicate: vi.fn(async () => undefined),
-        },
-        vault: {
-            getActiveFilePath: vi.fn((): string | null => "note.md"),
-            scanVault: vi.fn(async () => undefined),
-        },
-        control: {
-            applySettings: vi.fn(async () => undefined),
-        },
-        setting: {
-            saveSettingData: vi.fn(async () => undefined),
-        },
-        appLifecycle: {
-            isSuspended: vi.fn(() => false),
-            setSuspended: vi.fn(),
-        },
-        fileProcessing: {
-            commitPendingFileEvents: vi.fn(async () => true),
-        },
-        UI: {
-            promptCopyToClipboard: vi.fn(async (_title: string, _value: string) => true),
-        },
-        path: {
-            path2id: vi.fn(async () => "f:note"),
-        },
-    };
-    const core = {
-        settings,
-        _services: services,
-        services,
-        localDatabase: {
-            getDBEntry: vi.fn(async () => false),
-            localDatabase: {
-                get: vi.fn(async () => ({
-                    _id: "f:note",
-                    _rev: "2-current",
-                    _conflicts: [],
-                    path: "note.md",
-                    ctime: 100,
-                    mtime: 200,
-                    size: 12,
-                    type: "plain",
-                    children: ["h:private-chunk-id"],
-                    eden: {},
-                })),
-            },
-            getDBEntryMeta: vi.fn(async () => ({
-                _id: "f:note",
-                _rev: "2-current",
-                _conflicts: [],
-                path: "note.md",
-                ctime: 100,
-                mtime: 200,
-                size: 12,
-                type: "plain",
-                datatype: "plain",
-                data: "",
-                children: ["h:private-chunk-id"],
-                eden: {},
-            })),
-            allDocsRaw: vi.fn(async () => ({
-                rows: [{ id: "h:private-chunk-id", key: "h:private-chunk-id", value: { rev: "1-chunk" } }],
-            })),
-        },
-        storageAccess: {
-            isExistsIncludeHidden: vi.fn(async () => true),
-            statHidden: vi.fn(async () => ({ ctime: 100, mtime: 200, size: 12, type: "file" })),
-        },
-        replicator: {
-            terminateSync: vi.fn(),
-        },
-    };
-    const module = new ModuleBasicMenu(core as never);
-
-    return {
-        commands,
-        core,
-        module,
-        services,
-        settings,
-        getCommand(id: string) {
-            const command = commands.find((candidate) => candidate.id === id);
-            expect(command, `command ${id}`).toBeDefined();
-            return command!;
-        },
-    };
-}
-
-describe("ModuleBasicMenu command palette", () => {
-    it("uses clear user-facing names without changing the established command IDs", async () => {
-        const fixture = createFixture();
-
-        await fixture.module._everyOnloadStart();
-
-        expect(fixture.getCommand("livesync-replicate").name).toBe("Sync now");
-        expect(fixture.getCommand("livesync-runbatch").name).toBe("Apply pending changes now");
-    });
-
-    it("keeps maintenance commands out of the normal palette", async () => {
-        const fixture = createFixture();
-
-        await fixture.module._everyOnloadStart();
-
-        expect(fixture.getCommand("livesync-scan-files").checkCallback?.(true)).toBe(false);
-        expect(fixture.getCommand("livesync-abortsync").checkCallback?.(true)).toBe(false);
-
-        fixture.settings.useAdvancedMode = true;
-        expect(fixture.getCommand("livesync-scan-files").checkCallback?.(true)).toBe(true);
-        expect(fixture.getCommand("livesync-abortsync").checkCallback?.(true)).toBe(true);
-    });
-
-    it("keeps active-file database information available and opens it in a copy dialogue", async () => {
-        const fixture = createFixture();
-
-        await fixture.module._everyOnloadStart();
-
-        const command = fixture.getCommand("livesync-dump");
-        expect(command.name).toBe("Copy database information for the active file");
-        expect(command.checkCallback?.(true)).toBe(true);
-
-        command.checkCallback?.(false);
-
-        await vi.waitFor(() => {
-            expect(fixture.services.UI.promptCopyToClipboard).toHaveBeenCalledOnce();
-        });
-        const [title, report] = fixture.services.UI.promptCopyToClipboard.mock.calls[0];
-        expect(title).toBe("Database information for note.md");
-        expect(report).toContain("note.md");
-        expect(report).toContain("2-current");
-        expect(report).toContain("h:private-chunk-id");
-        expect(report).toContain("1-chunk");
-        expect(fixture.core.localDatabase.getDBEntry).not.toHaveBeenCalled();
-    });
-
-    it("hides the active-file database report when no file is active", async () => {
-        const fixture = createFixture();
-        fixture.services.vault.getActiveFilePath.mockReturnValue(null);
-
-        await fixture.module._everyOnloadStart();
-
-        expect(fixture.getCommand("livesync-dump").checkCallback?.(true)).toBe(false);
-    });
-});

src/modules/features/InteractiveConflictResolving/ConflictResolveModal.ts

@@ -13,13 +13,6 @@ export const POSTPONED = Symbol("postponed");
 
 export type MergeDialogResult = typeof CANCELLED | typeof POSTPONED | typeof LEAVE_TO_SUBSEQUENT | string;
 
-export type ConflictResolveModalOptions = {
-    readOnly?: boolean;
-    title?: string;
-    localName?: string;
-    remoteName?: string;
-};
-
 export class ConflictResolveModal extends Modal {
     result: diff_result;
     filename: FilePathWithPrefix;
@@ -32,7 +25,6 @@ export class ConflictResolveModal extends Modal {
     title: string = "Conflicting changes";
 
     pluginPickMode: boolean = false;
-    readOnly: boolean = false;
     localName: string = "Base";
     remoteName: string = "Conflicted";
     offEvent?: ReturnType<typeof eventHub.onEvent>;
@@ -45,22 +37,16 @@ export class ConflictResolveModal extends Modal {
         filename: FilePathWithPrefix,
         diff: diff_result,
         pluginPickMode?: boolean,
-        remoteName?: string,
-        options?: ConflictResolveModalOptions
+        remoteName?: string
     ) {
         super(app);
         this.result = diff;
         this.filename = filename;
         this.pluginPickMode = pluginPickMode || false;
-        this.readOnly = options?.readOnly ?? false;
         if (this.pluginPickMode) {
             this.title = "Pick a version";
             this.remoteName = `${remoteName || "Remote"}`;
             this.localName = "Local";
-        } else if (this.readOnly) {
-            this.title = options?.title ?? "Vault and database revision";
-            this.localName = options?.localName ?? "Vault file";
-            this.remoteName = options?.remoteName ?? "Database revision";
         }
     }
 
@@ -115,18 +101,16 @@ export class ConflictResolveModal extends Modal {
         if (this.offEvent) {
             this.offEvent();
         }
-        if (!this.readOnly) {
-            // Cancel an older dialogue for this path before subscribing this
-            // instance. Emitting after subscription would close the replacement
-            // itself; the instance-owned result promise then completes the older
-            // caller even when it only begins waiting after this event.
-            eventHub.emitEvent(EVENT_CONFLICT_CANCELLED, this.filename);
-            this.offEvent = eventHub.onEvent(EVENT_CONFLICT_CANCELLED, (path) => {
-                if (path === this.filename) {
-                    this.sendResponse(CANCELLED);
-                }
-            });
-        }
+        // Cancel an older dialogue for this path before subscribing this
+        // instance. Emitting after subscription would close the replacement
+        // itself; the instance-owned result promise then completes the older
+        // caller even when it only begins waiting after this event.
+        eventHub.emitEvent(EVENT_CONFLICT_CANCELLED, this.filename);
+        this.offEvent = eventHub.onEvent(EVENT_CONFLICT_CANCELLED, (path) => {
+            if (path === this.filename) {
+                this.sendResponse(CANCELLED);
+            }
+        });
         this.titleEl.setText(this.title);
         contentEl.empty();
         const diffOptionsRow = contentEl.createDiv("");
@@ -175,31 +159,24 @@ export class ConflictResolveModal extends Modal {
         this.appendVersionInfo(div2, "deleted", this.localName, date1);
         this.appendVersionInfo(div2, "added", this.remoteName, date2);
         const actionContainer = contentEl.createDiv("conflict-action-container");
-        if (this.readOnly) {
-            actionContainer.createEl("button", { text: "Close" }, (e) => {
+        actionContainer.createEl("button", { text: `Use ${this.localName}` }, (e) => {
+            e.addClass("conflict-action-button");
+            e.addEventListener("click", () => this.sendResponse(this.result.right.rev));
+        });
+        actionContainer.createEl("button", { text: `Use ${this.remoteName}` }, (e) => {
+            e.addClass("conflict-action-button");
+            e.addEventListener("click", () => this.sendResponse(this.result.left.rev));
+        });
+        if (!this.pluginPickMode) {
+            actionContainer.createEl("button", { text: "Concat both" }, (e) => {
                 e.addClass("conflict-action-button");
-                e.addEventListener("click", () => this.sendResponse(CANCELLED));
-            });
-        } else {
-            actionContainer.createEl("button", { text: `Use ${this.localName}` }, (e) => {
-                e.addClass("conflict-action-button");
-                e.addEventListener("click", () => this.sendResponse(this.result.right.rev));
-            });
-            actionContainer.createEl("button", { text: `Use ${this.remoteName}` }, (e) => {
-                e.addClass("conflict-action-button");
-                e.addEventListener("click", () => this.sendResponse(this.result.left.rev));
-            });
-            if (!this.pluginPickMode) {
-                actionContainer.createEl("button", { text: "Concat both" }, (e) => {
-                    e.addClass("conflict-action-button");
-                    e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT));
-                });
-            }
-            actionContainer.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) => {
-                e.addClass("conflict-action-button");
-                e.addEventListener("click", () => this.sendResponse(this.pluginPickMode ? CANCELLED : POSTPONED));
+                e.addEventListener("click", () => this.sendResponse(LEAVE_TO_SUBSEQUENT));
             });
         }
+        actionContainer.createEl("button", { text: !this.pluginPickMode ? "Not now" : "Cancel" }, (e) => {
+            e.addClass("conflict-action-button");
+            e.addEventListener("click", () => this.sendResponse(this.pluginPickMode ? CANCELLED : POSTPONED));
+        });
         if (diffLength > 100 * 1024) {
             this.diffView.empty();
             this.diffView.setText("(Too large diff to display)");

src/modules/features/InteractiveConflictResolving/ConflictResolveModal.unit.spec.ts

@@ -5,8 +5,6 @@ import { CANCELLED, type diff_result, type FilePathWithPrefix } from "@vrtmrz/li
 vi.mock("@/deps.ts", () => ({
     App: class App {},
     Modal: class Modal {
-        createdButtons: string[] = [];
-
         private createElement(): Record<string, unknown> {
             const element: Record<string, unknown> = {
                 addClass: vi.fn(),
@@ -24,14 +22,6 @@ vi.mock("@/deps.ts", () => ({
             };
             element.createDiv = vi.fn(() => this.createElement());
             element.createEl = vi.fn((_tag: string, _options?: unknown, callback?: (child: unknown) => void) => {
-                if (
-                    _tag === "button" &&
-                    typeof _options === "object" &&
-                    _options !== null &&
-                    "text" in _options
-                ) {
-                    this.createdButtons.push(String((_options as { text: unknown }).text));
-                }
                 const child = this.createElement();
                 callback?.(child);
                 return child;
@@ -92,55 +82,4 @@ describe("ConflictResolveModal result lifecycle", () => {
         expect(previousResult).toBe(CANCELLED);
         expect(replacementState).toBe("still-open");
     });
-
-    it("renders a read-only comparison with no resolution actions", () => {
-        const ReadOnlyModal = ConflictResolveModal as unknown as new (
-            ...args: unknown[]
-        ) => ConflictResolveModal & { createdButtons: string[] };
-        const modal = new ReadOnlyModal(
-            {},
-            "repair-preview.md",
-            conflict,
-            false,
-            undefined,
-            {
-                readOnly: true,
-                title: "Vault and database revision",
-                localName: "Vault file",
-                remoteName: "Database revision",
-            }
-        );
-
-        modal.onOpen();
-
-        expect(modal.createdButtons).toContain("Close");
-        expect(modal.createdButtons).not.toContain("Use Vault file");
-        expect(modal.createdButtons).not.toContain("Use Database revision");
-        expect(modal.createdButtons).not.toContain("Concat both");
-        expect(modal.createdButtons).not.toContain("Not now");
-        modal.close();
-    });
-
-    it("does not cancel an active conflict dialogue when a read-only comparison opens for the same file", async () => {
-        const filename = "repair-alongside-conflict.md" as FilePathWithPrefix;
-        const previous = new ConflictResolveModal({} as never, filename, conflict);
-        const ReadOnlyModal = ConflictResolveModal as unknown as new (
-            ...args: unknown[]
-        ) => ConflictResolveModal;
-        const comparison = new ReadOnlyModal({}, filename, conflict, false, undefined, {
-            readOnly: true,
-        });
-        previous.onOpen();
-
-        comparison.onOpen();
-        const previousState = await Promise.race([
-            previous.waitForResult(),
-            new Promise<"still-open">((resolve) => setTimeout(() => resolve("still-open"), 25)),
-        ]);
-
-        previous.sendResponse(CANCELLED);
-        comparison.close();
-
-        expect(previousState).toBe("still-open");
-    });
 });

src/modules/features/SettingDialogue/PaneMaintenance.ts

@@ -187,7 +187,7 @@ export function paneMaintenance(
             )
             .addOnUpdate(this.onlyOnMinIO);
     });
-    void addPanel(paneEl, "Garbage Collection V3 (Beta)", (e) => e, this.onlyOnCouchDB).then((paneEl) => {
+    void addPanel(paneEl, "Garbage Collection V3 (Beta)", (e) => e, this.onlyOnP2POrCouchDB).then((paneEl) => {
         new Setting(paneEl)
             .setName("Perform Garbage Collection")
             .setDesc("Perform Garbage Collection to remove unused chunks and reduce database size.")

src/modules/features/SettingDialogue/PaneRemoteConfig.ts

@@ -133,8 +133,8 @@ export function paneRemoteConfig(
     }
     {
         // TODO: very WIP. need to refactor the UI.
-        void addPanel(paneEl, $msg("Connection settings"), () => {}).then((paneEl) => {
-            const actions = new Setting(paneEl).setName($msg("Saved connections"));
+        void addPanel(paneEl, $msg("obsidianLiveSyncSettingTab.titleRemoteServer"), () => {}).then((paneEl) => {
+            const actions = new Setting(paneEl).setName("Remote Databases");
             // actions.addButton((button) =>
             //     button
             //         .setButtonText("Change Remote and Setup")

src/modules/features/SettingDialogue/PaneSetup.ts

@@ -12,7 +12,7 @@ import type { ObsidianLiveSyncSettingTab } from "./ObsidianLiveSyncSettingTab.ts
 import type { PageFunctions } from "./SettingPane.ts";
 import { visibleOnly } from "./SettingPane.ts";
 import { request } from "@/deps.ts";
-import { SetupManager } from "@/modules/features/SetupManager.ts";
+import { SetupManager, UserMode } from "@/modules/features/SetupManager.ts";
 import { LiveSyncError } from "@vrtmrz/livesync-commonlib/compat/common/LSError";
 import {
     createCoreSettingsAfterFullReset,
@@ -40,7 +40,8 @@ export function paneSetup(
             .addButton((text) => {
                 text.setButtonText($msg("Rerun Wizard")).onClick(async () => {
                     const setupManager = this.core.getModule(SetupManager);
-                    await setupManager.startOnBoarding();
+                    await setupManager.onOnboard(UserMode.ExistingUser);
+                    // await this.plugin.moduleSetupObsidian.onBoardingWizard(true);
                 });
             });
 

src/modules/services/LiveSyncUI/DialogHost.svelte

@@ -68,8 +68,6 @@
         display: flex;
         flex-direction: column;
         padding-bottom: var(--keyboard-height, 0px);
-        user-select: text;
-        -webkit-user-select: text;
     }
 
     .dialog-host :global(button) {

src/modules/services/ObsidianAPIService.unit.spec.ts

@@ -1,67 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mocks = vi.hoisted(() => ({
-    platform: {
-        isMobile: false,
-    },
-}));
-
-vi.mock("@/deps.ts", () => ({
-    Platform: mocks.platform,
-    requestUrl: vi.fn(),
-}));
-
-vi.mock("@/deps", () => ({
-    Platform: mocks.platform,
-    requestUrl: vi.fn(),
-}));
-
-vi.mock("@/modules/essentialObsidian/APILib/ObsHttpHandler", () => ({
-    ObsHttpHandler: class {},
-}));
-
-vi.mock("./ObsidianConfirm", () => ({
-    ObsidianConfirm: class {},
-}));
-
-import { ObsidianAPIService } from "./ObsidianAPIService";
-import type { ObsidianServiceContext } from "./ObsidianServiceContext";
-
-function createService(workspace: Record<string, unknown>, isMobile = false): ObsidianAPIService {
-    return new ObsidianAPIService({
-        app: { workspace, isMobile },
-    } as unknown as ObsidianServiceContext);
-}
-
-beforeEach(() => {
-    mocks.platform.isMobile = false;
-    vi.clearAllMocks();
-});
-
-describe("ObsidianAPIService.showWindowOnRight", () => {
-    it("keeps the status view in the right leaf on mobile", async () => {
-        mocks.platform.isMobile = true;
-        const rightLeaf = {
-            setViewState: vi.fn().mockResolvedValue(undefined),
-        };
-        const workspace = {
-            getLeavesOfType: vi.fn(() => []),
-            getLeaf: vi.fn(),
-            getRightLeaf: vi.fn(() => rightLeaf),
-            revealLeaf: vi.fn().mockResolvedValue(undefined),
-        };
-        const service = createService(workspace, true);
-
-        expect(service.isMobile()).toBe(true);
-        await service.showWindowOnRight("p2p-status");
-
-        expect(workspace.getLeavesOfType).toHaveBeenCalledWith("p2p-status");
-        expect(workspace.getRightLeaf).toHaveBeenCalledWith(false);
-        expect(workspace.getLeaf).not.toHaveBeenCalled();
-        expect(rightLeaf.setViewState).toHaveBeenCalledWith({
-            type: "p2p-status",
-            active: false,
-        });
-        expect(workspace.revealLeaf).toHaveBeenCalledWith(rightLeaf);
-    });
-});

src/serviceFeatures/fileDatabaseInfo.ts

@@ -1,454 +0,0 @@
-import { $msg } from "@/common/translation";
-import type {
-    FilePath,
-    FilePathWithPrefix,
-    LoadedEntry,
-    ObsidianLiveSyncSettings,
-} from "@vrtmrz/livesync-commonlib/compat/common/types";
-import { getFileRegExp } from "@vrtmrz/livesync-commonlib/compat/common/utils";
-import { isNotFoundError } from "@vrtmrz/livesync-commonlib/compat/common/utils.doc";
-import { ICHeader, ICXHeader, PSCHeader } from "@vrtmrz/livesync-commonlib/compat/common/models/fileaccess.const";
-import type { StorageAccess } from "@vrtmrz/livesync-commonlib/compat/interfaces/StorageAccess";
-import type { LiveSyncLocalDB } from "@vrtmrz/livesync-commonlib/compat/pouchdb/LiveSyncLocalDB";
-import type { IPathService, IUIService } from "@vrtmrz/livesync-commonlib/compat/services/base/IService";
-import { addPrefix, stripAllPrefixes } from "@vrtmrz/livesync-commonlib/compat/string_and_binary/path";
-
-type DatabaseMeta = LoadedEntry & {
-    _rawStorageType: string | null;
-    _legacyBodyPresent: boolean;
-    _revs_info?: Array<{
-        rev: string;
-        status: string;
-    }>;
-};
-
-export type FileDatabaseInfoCore = {
-    localDatabase: Pick<
-        LiveSyncLocalDB,
-        "allDocsRaw" | "findAllDocs" | "getDBEntryFromMeta" | "getDBEntry" | "localDatabase"
-    >;
-    services: {
-        path: Pick<IPathService, "path2id">;
-        UI: IUIService;
-    };
-    settings: ObsidianLiveSyncSettings;
-    storageAccess: Pick<
-        StorageAccess,
-        "getFileNames" | "getFilesIncludeHidden" | "isExistsIncludeHidden" | "statHidden"
-    >;
-};
-
-export type RevisionDatabaseInfo = {
-    documentId: string;
-    revision: string | null;
-    current: boolean;
-    deleted: boolean;
-    storageType: string;
-    storageLayout: "chunked" | "legacy-inline";
-    ctime: number;
-    mtime: number;
-    recordedSize: number;
-    revisionHistory: Array<{
-        revision: string;
-        status: string;
-    }>;
-    chunkReferences: number;
-    uniqueChunkReferences: number;
-    embeddedChunkReferences: number;
-    locallyStoredChunkReferences: number;
-    contentAvailableLocally: boolean;
-    chunks: Array<{
-        id: string;
-        referenceCount: number;
-        embedded: boolean;
-        storedInLocalDatabase: boolean;
-        localDatabaseState: "available" | "deleted" | "missing";
-        localDatabaseRevision: string | null;
-    }>;
-};
-
-export type FileDatabaseMergeBaseInfo = {
-    winnerRevision: string;
-    conflictRevision: string;
-    revision: string | null;
-    metadataAvailableLocally: boolean;
-    contentAvailableLocally: boolean;
-    missingChunkIds: string[];
-    unavailableSharedRevisions: string[];
-};
-
-export type FileDatabaseInfo = {
-    path: string;
-    databasePath: FilePathWithPrefix | FilePath;
-    storage: {
-        exists: boolean;
-        ctime?: number;
-        mtime?: number;
-        size?: number;
-    };
-    database: {
-        source: "local database on this device";
-        remoteQueried: false;
-        exists: boolean;
-        currentRevision: string | null;
-        conflictCount: number;
-        conflictRevisions: string[];
-        unavailableConflictRevisions: string[];
-        revisions: RevisionDatabaseInfo[];
-        mergeBases: FileDatabaseMergeBaseInfo[];
-    };
-};
-
-const REPORT_WARNING =
-    "All revisions and chunk availability below are a snapshot of this device's local database; the remote is not queried. Review the Vault-relative path, document identifier, content-derived chunk identifiers, and metadata before sharing this report. File contents are omitted.";
-
-function toDatabasePath(path: string): FilePathWithPrefix | FilePath {
-    if (path.startsWith(".")) {
-        return addPrefix(path as FilePath, ICHeader);
-    }
-    return path as FilePath;
-}
-
-type RawDatabaseDocument = {
-    _id: string;
-    _rev?: string;
-    _conflicts?: string[];
-    _deleted?: boolean;
-    _revs_info?: Array<{
-        rev: string;
-        status: string;
-    }>;
-    children?: string[];
-    ctime?: number;
-    deleted?: boolean;
-    data?: string | string[];
-    eden?: Record<string, unknown>;
-    mtime?: number;
-    size?: number;
-    type?: string;
-};
-
-async function getLocalDatabaseMeta(
-    core: FileDatabaseInfoCore,
-    path: FilePathWithPrefix | FilePath,
-    options: PouchDB.Core.GetOptions
-): Promise<DatabaseMeta | false> {
-    const documentId = await core.services.path.path2id(path);
-    let raw: RawDatabaseDocument;
-    try {
-        raw = await core.localDatabase.localDatabase.get(documentId, options);
-    } catch (error) {
-        if (isNotFoundError(error)) {
-            return false;
-        }
-        throw error;
-    }
-
-    if (raw.type === "leaf") {
-        return false;
-    }
-    if (raw.type && raw.type !== "notes" && raw.type !== "newnote" && raw.type !== "plain") {
-        return false;
-    }
-
-    const rawStorageType = raw.type ?? null;
-    const legacy = rawStorageType === null || rawStorageType === "notes";
-    const type = legacy ? "notes" : rawStorageType;
-    const legacyBodyPresent =
-        legacy && (typeof raw.data === "string" || (Array.isArray(raw.data) && raw.data.every((item) => typeof item === "string")));
-    return {
-        _id: raw._id,
-        _rev: raw._rev,
-        _conflicts: raw._conflicts,
-        _revs_info: raw._revs_info,
-        path,
-        data: legacyBodyPresent ? raw.data : "",
-        ctime: raw.ctime ?? 0,
-        mtime: raw.mtime ?? 0,
-        size: raw.size ?? 0,
-        children: type === "newnote" || type === "plain" ? (raw.children ?? []) : [],
-        datatype: type === "newnote" ? "newnote" : "plain",
-        deleted: raw.deleted ?? raw._deleted,
-        type,
-        eden: raw.eden ?? {},
-        _rawStorageType: rawStorageType,
-        _legacyBodyPresent: legacyBodyPresent,
-    } as DatabaseMeta;
-}
-
-async function collectRevisionDatabaseInfo(
-    core: FileDatabaseInfoCore,
-    meta: DatabaseMeta,
-    current: boolean
-): Promise<RevisionDatabaseInfo> {
-    const legacy = meta._rawStorageType === null || meta._rawStorageType === "notes";
-    const children = legacy ? [] : "children" in meta ? meta.children : [];
-    const uniqueChildren = [...new Set(children)];
-    const referenceCounts = new Map<string, number>();
-    for (const child of children) {
-        referenceCounts.set(child, (referenceCounts.get(child) ?? 0) + 1);
-    }
-    const embeddedChildren = new Set(
-        Object.keys("eden" in meta && meta.eden ? meta.eden : {}).filter((id) => uniqueChildren.includes(id))
-    );
-    const localRows =
-        uniqueChildren.length === 0
-            ? []
-            : (
-                  await core.localDatabase.allDocsRaw({
-                      keys: uniqueChildren,
-                      include_docs: false,
-                  })
-              ).rows;
-    const localChunkStates = new Map(
-        localRows
-            .filter((row) => "value" in row)
-            .map(
-                (row) =>
-                    [
-                        row.key,
-                        {
-                            state: row.value.deleted ? ("deleted" as const) : ("available" as const),
-                            revision: row.value.rev,
-                        },
-                    ] as const
-            )
-    );
-
-    return {
-        documentId: meta._id,
-        revision: meta._rev ?? null,
-        current,
-        deleted: Boolean(meta.deleted ?? meta._deleted),
-        storageType: meta._rawStorageType ?? "absent",
-        storageLayout: legacy ? "legacy-inline" : "chunked",
-        ctime: meta.ctime,
-        mtime: meta.mtime,
-        recordedSize: meta.size,
-        revisionHistory: (meta._revs_info ?? []).map(({ rev, status }) => ({
-            revision: rev,
-            status,
-        })),
-        chunkReferences: children.length,
-        uniqueChunkReferences: uniqueChildren.length,
-        embeddedChunkReferences: children.filter((id) => embeddedChildren.has(id)).length,
-        locallyStoredChunkReferences: children.filter((id) => localChunkStates.get(id)?.state === "available").length,
-        contentAvailableLocally: legacy
-            ? meta._legacyBodyPresent
-            : uniqueChildren.every(
-                  (id) => embeddedChildren.has(id) || localChunkStates.get(id)?.state === "available"
-              ),
-        chunks: uniqueChildren.map((id) => {
-            const localState = localChunkStates.get(id);
-            return {
-                id,
-                referenceCount: referenceCounts.get(id) ?? 0,
-                embedded: embeddedChildren.has(id),
-                storedInLocalDatabase: localState?.state === "available",
-                localDatabaseState: localState?.state ?? "missing",
-                localDatabaseRevision: localState?.revision ?? null,
-            };
-        }),
-    };
-}
-
-function revisionHistory(meta: DatabaseMeta): Array<{ revision: string; status: string }> {
-    const history = (meta._revs_info ?? []).map(({ rev, status }) => ({
-        revision: rev,
-        status,
-    }));
-    if (meta._rev && !history.some(({ revision }) => revision === meta._rev)) {
-        history.unshift({
-            revision: meta._rev,
-            status: "available",
-        });
-    }
-    return history;
-}
-
-function missingChunkIds(info: RevisionDatabaseInfo): string[] {
-    return info.chunks
-        .filter(({ embedded, localDatabaseState }) => !embedded && localDatabaseState !== "available")
-        .map(({ id }) => id);
-}
-
-export async function inspectFileDatabaseInfo(core: FileDatabaseInfoCore, path: string): Promise<FileDatabaseInfo> {
-    const storageExists = await core.storageAccess.isExistsIncludeHidden(path);
-    const storageStat = storageExists ? await core.storageAccess.statHidden(path) : null;
-    const databasePath = toDatabasePath(path);
-    const currentMeta = await getLocalDatabaseMeta(core, databasePath, {
-        conflicts: true,
-        revs: true,
-        revs_info: true,
-    });
-
-    const revisions: RevisionDatabaseInfo[] = [];
-    const conflictRevisions = currentMeta === false ? [] : (currentMeta._conflicts ?? []);
-    const unavailableConflictRevisions: string[] = [];
-    const mergeBases: FileDatabaseMergeBaseInfo[] = [];
-    const metadataByRevision = new Map<string, DatabaseMeta | false>();
-    if (currentMeta !== false && currentMeta._rev) {
-        metadataByRevision.set(currentMeta._rev, currentMeta);
-    }
-    const getRevisionMeta = async (revision: string): Promise<DatabaseMeta | false> => {
-        const cached = metadataByRevision.get(revision);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const meta = await getLocalDatabaseMeta(core, databasePath, {
-            rev: revision,
-            revs: true,
-            revs_info: true,
-        });
-        metadataByRevision.set(revision, meta);
-        return meta;
-    };
-
-    if (currentMeta) {
-        revisions.push(await collectRevisionDatabaseInfo(core, currentMeta, true));
-        for (const revision of conflictRevisions) {
-            const conflictMeta = await getRevisionMeta(revision);
-            if (conflictMeta) {
-                revisions.push(await collectRevisionDatabaseInfo(core, conflictMeta, false));
-                const winnerHistory = revisionHistory(currentMeta);
-                const conflictHistory = revisionHistory(conflictMeta);
-                const conflictHistoryByRevision = new Map(
-                    conflictHistory.map(({ revision: historyRevision, status }) => [historyRevision, status])
-                );
-                const sharedHistory = winnerHistory.filter(({ revision: historyRevision }) =>
-                    conflictHistoryByRevision.has(historyRevision)
-                );
-                const sharedRevision = sharedHistory[0]?.revision ?? null;
-                const unavailableSharedRevisions = sharedHistory
-                    .filter(
-                        ({ revision: historyRevision, status }) =>
-                            status !== "available" ||
-                            conflictHistoryByRevision.get(historyRevision) !== "available"
-                    )
-                    .map(({ revision: historyRevision }) => historyRevision);
-                const sharedMeta = sharedRevision ? await getRevisionMeta(sharedRevision) : false;
-                const sharedInfo = sharedMeta
-                    ? await collectRevisionDatabaseInfo(core, sharedMeta, false)
-                    : undefined;
-                mergeBases.push({
-                    winnerRevision: currentMeta._rev ?? "",
-                    conflictRevision: revision,
-                    revision: sharedRevision,
-                    metadataAvailableLocally: Boolean(sharedMeta),
-                    contentAvailableLocally: sharedInfo?.contentAvailableLocally ?? false,
-                    missingChunkIds: sharedInfo ? missingChunkIds(sharedInfo) : [],
-                    unavailableSharedRevisions,
-                });
-            } else {
-                unavailableConflictRevisions.push(revision);
-            }
-        }
-    }
-
-    const report: FileDatabaseInfo = {
-        path,
-        databasePath,
-        storage: storageStat
-            ? {
-                  exists: true,
-                  ctime: storageStat.ctime,
-                  mtime: storageStat.mtime,
-                  size: storageStat.size,
-              }
-            : {
-                  exists: false,
-              },
-        database: {
-            source: "local database on this device",
-            remoteQueried: false,
-            exists: currentMeta !== false,
-            currentRevision: currentMeta ? (currentMeta._rev ?? null) : null,
-            conflictCount: conflictRevisions.length,
-            conflictRevisions,
-            unavailableConflictRevisions,
-            revisions,
-            mergeBases,
-        },
-    };
-
-    return report;
-}
-
-export async function readFileDatabaseRevisionLocally(
-    core: FileDatabaseInfoCore,
-    path: string,
-    revision: string
-): Promise<LoadedEntry | false> {
-    const databasePath = toDatabasePath(path);
-    const meta = await getLocalDatabaseMeta(core, databasePath, {
-        rev: revision,
-        revs: true,
-        revs_info: true,
-    });
-    if (!meta) {
-        return false;
-    }
-    const info = await collectRevisionDatabaseInfo(core, meta, false);
-    if (info.deleted || !info.contentAvailableLocally) {
-        return false;
-    }
-    return await core.localDatabase.getDBEntryFromMeta(meta, false, false);
-}
-
-export async function retryReadFileDatabaseRevision(
-    core: FileDatabaseInfoCore,
-    path: string,
-    revision: string
-): Promise<LoadedEntry | false> {
-    return await core.localDatabase.getDBEntry(toDatabasePath(path), { rev: revision }, false, true, true);
-}
-
-export async function buildFileDatabaseInfoReport(core: FileDatabaseInfoCore, path: string): Promise<string> {
-    const report = await inspectFileDatabaseInfo(core, path);
-    return `${$msg(REPORT_WARNING)}
-
-\`\`\`json
-${JSON.stringify(report, null, 2)}
-\`\`\``;
-}
-
-export async function copyFileDatabaseInfo(core: FileDatabaseInfoCore, path: string): Promise<boolean> {
-    const report = await buildFileDatabaseInfoReport(core, path);
-    return await core.services.UI.promptCopyToClipboard(
-        $msg("Database information for ${FILE}", { FILE: path }),
-        report
-    );
-}
-
-export async function collectFileDatabaseInfoPaths(core: FileDatabaseInfoCore): Promise<string[]> {
-    const ignorePatterns = getFileRegExp(core.settings, "syncInternalFilesIgnorePatterns");
-    const targetPatterns = getFileRegExp(core.settings, "syncInternalFilesTargetPatterns");
-    const storagePaths = core.settings.syncInternalFiles
-        ? await core.storageAccess.getFilesIncludeHidden("/", targetPatterns, ignorePatterns)
-        : await core.storageAccess.getFileNames();
-    const databasePaths: string[] = [];
-
-    for await (const entry of core.localDatabase.findAllDocs()) {
-        const prefixedPath = entry.path;
-        if (prefixedPath.startsWith(ICXHeader) || prefixedPath.startsWith(PSCHeader)) {
-            continue;
-        }
-        if (!core.settings.syncInternalFiles && prefixedPath.startsWith(ICHeader)) {
-            continue;
-        }
-        databasePaths.push(stripAllPrefixes(prefixedPath));
-    }
-
-    return [...new Set([...storagePaths, ...databasePaths])].sort((left, right) =>
-        left < right ? -1 : left > right ? 1 : 0
-    );
-}
-
-export async function chooseAndCopyFileDatabaseInfo(core: FileDatabaseInfoCore): Promise<boolean> {
-    const paths = await collectFileDatabaseInfoPaths(core);
-    const selected = await core.services.UI.confirm.askSelectString($msg("Choose a file to inspect"), paths);
-    if (!selected) {
-        return false;
-    }
-    return await copyFileDatabaseInfo(core, selected);
-}

src/serviceFeatures/fileDatabaseInfo.unit.spec.ts

@@ -1,413 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import {
-    buildFileDatabaseInfoReport,
-    chooseAndCopyFileDatabaseInfo,
-    collectFileDatabaseInfoPaths,
-    inspectFileDatabaseInfo,
-    readFileDatabaseRevisionLocally,
-    retryReadFileDatabaseRevision,
-} from "./fileDatabaseInfo";
-
-async function* documents(paths: string[]) {
-    for (const path of paths) {
-        yield {
-            _id: `f:${path}`,
-            path,
-        };
-    }
-}
-
-function createCore() {
-    const current = {
-        _id: "f:note",
-        _rev: "3-current",
-        _conflicts: ["2-conflict"],
-        _revs_info: [
-            { rev: "3-current", status: "available" },
-            { rev: "2-parent", status: "missing" },
-        ],
-        path: "note.md",
-        ctime: 100,
-        mtime: 300,
-        size: 42,
-        type: "plain",
-        datatype: "plain",
-        data: "secret current body",
-        children: ["h:private-current", "h:private-current", "h:private-embedded", "h:private-deleted"],
-        eden: {
-            "h:private-embedded": {
-                data: "secret embedded body",
-                epoch: 1,
-            },
-        },
-    };
-    const conflict = {
-        ...current,
-        _rev: "2-conflict",
-        _conflicts: undefined,
-        _revs_info: [{ rev: "2-conflict", status: "available" }],
-        mtime: 200,
-        data: "secret conflict body",
-        children: ["h:private-missing"],
-        eden: {},
-    };
-    const promptCopyToClipboard = vi.fn(async (_title: string, _value: string) => true);
-    const askSelectString = vi.fn(async () => "db-only.md");
-    const core = {
-        settings: {
-            syncInternalFiles: false,
-            syncInternalFilesIgnorePatterns: "",
-            syncInternalFilesTargetPatterns: "",
-        },
-        storageAccess: {
-            isExistsIncludeHidden: vi.fn(async () => true),
-            statHidden: vi.fn(async () => ({
-                ctime: 90,
-                mtime: 310,
-                size: 45,
-                type: "file",
-            })),
-            getFileNames: vi.fn(async () => ["z.md", "a.md"]),
-            getFilesIncludeHidden: vi.fn(async () => [".obsidian/app.json", "a.md"]),
-        },
-        localDatabase: {
-            getDBEntryFromMeta: vi.fn(async (meta: typeof current) => ({
-                ...meta,
-                data: ["loaded body"],
-            })),
-            getDBEntry: vi.fn(async () => current),
-            localDatabase: {
-                get: vi.fn(async (_id: string, options?: { rev?: string }) =>
-                    options?.rev === "2-conflict" ? conflict : current
-                ),
-            },
-            allDocsRaw: vi.fn(async ({ keys }: { keys: string[] }) => ({
-                rows: [
-                    ...(keys.includes("h:private-current")
-                        ? [
-                              {
-                                  id: "h:private-current",
-                                  key: "h:private-current",
-                                  value: { rev: "1-chunk" },
-                              },
-                          ]
-                        : []),
-                    ...(keys.includes("h:private-deleted")
-                        ? [
-                              {
-                                  id: "h:private-deleted",
-                                  key: "h:private-deleted",
-                                  value: { rev: "4-deleted-chunk", deleted: true },
-                              },
-                          ]
-                        : []),
-                ],
-            })),
-            findAllDocs: vi.fn(() => documents(["db-only.md", "i:.obsidian/app.json", "ix:ignore", "ps:setting"])),
-        },
-        services: {
-            path: {
-                path2id: vi.fn(async () => "f:note"),
-            },
-            UI: {
-                promptCopyToClipboard,
-                confirm: {
-                    askSelectString,
-                },
-            },
-        },
-    };
-    return {
-        askSelectString,
-        conflict,
-        core,
-        current,
-        promptCopyToClipboard,
-    };
-}
-
-describe("file database information", () => {
-    it("reports document and chunk revisions without exposing file contents", async () => {
-        const { core } = createCore();
-
-        const report = await buildFileDatabaseInfoReport(core as never, "note.md");
-
-        expect(report).toContain('"path": "note.md"');
-        expect(report).toContain('"documentId": "f:note"');
-        expect(report).toContain('"revision": "3-current"');
-        expect(report).toContain('"revision": "2-conflict"');
-        expect(report).toContain('"storageType": "plain"');
-        expect(report).toContain('"storageLayout": "chunked"');
-        expect(report).toContain('"contentAvailableLocally": false');
-        expect(report).toContain('"id": "h:private-current"');
-        expect(report).toContain('"localDatabaseRevision": "1-chunk"');
-        expect(report).toContain('"referenceCount": 2');
-        expect(report).toContain('"id": "h:private-embedded"');
-        expect(report).toContain('"embedded": true');
-        expect(report).toContain('"id": "h:private-deleted"');
-        expect(report).toContain('"localDatabaseState": "deleted"');
-        expect(report).toContain('"localDatabaseRevision": "4-deleted-chunk"');
-        expect(report).toContain('"id": "h:private-missing"');
-        expect(report).toContain('"localDatabaseState": "missing"');
-        expect(report).toContain('"localDatabaseRevision": null');
-        expect(report).not.toContain("secret current body");
-        expect(report).not.toContain("secret conflict body");
-        expect(report).not.toContain("secret embedded body");
-    });
-
-    it.each([
-        {
-            name: "notes",
-            document: {
-                type: "notes",
-                data: "secret legacy body",
-            },
-            storageType: "notes",
-        },
-        {
-            name: "an absent type",
-            document: {
-                type: undefined,
-                data: ["secret", " legacy body"],
-            },
-            storageType: "absent",
-        },
-    ])("reports $name as legacy inline storage without exposing its body", async ({ document, storageType }) => {
-        const { core, current } = createCore();
-        core.localDatabase.localDatabase.get.mockResolvedValue({
-            ...current,
-            ...document,
-            _conflicts: [],
-            children: ["h:must-not-be-treated-as-a-chunk"],
-        } as never);
-
-        const info = await inspectFileDatabaseInfo(core as never, "note.md");
-        const report = await buildFileDatabaseInfoReport(core as never, "note.md");
-
-        expect(info.database.revisions).toEqual([
-            expect.objectContaining({
-                storageType,
-                storageLayout: "legacy-inline",
-                chunkReferences: 0,
-                contentAvailableLocally: true,
-            }),
-        ]);
-        expect(report).not.toContain("secret legacy body");
-        expect(report).not.toContain("h:must-not-be-treated-as-a-chunk");
-    });
-
-    it("reports the exact shared ancestor and its missing chunks for each conflict", async () => {
-        const { conflict, core, current } = createCore();
-        const parent = {
-            ...current,
-            _rev: "2-parent",
-            _conflicts: undefined,
-            _revs_info: [
-                { rev: "2-parent", status: "available" },
-                { rev: "1-root", status: "missing" },
-            ],
-            children: ["h:missing-parent"],
-            eden: {},
-        };
-        core.localDatabase.localDatabase.get.mockImplementation(async (_id: string, options?: { rev?: string }) => {
-            if (options?.rev === "2-conflict") {
-                return {
-                    ...conflict,
-                    _revs_info: [
-                        { rev: "2-conflict", status: "available" },
-                        { rev: "2-parent", status: "available" },
-                        { rev: "1-root", status: "missing" },
-                    ],
-                };
-            }
-            if (options?.rev === "2-parent") {
-                return parent;
-            }
-            return {
-                ...current,
-                _revs_info: [
-                    { rev: "3-current", status: "available" },
-                    { rev: "2-parent", status: "available" },
-                    { rev: "1-root", status: "missing" },
-                ],
-            };
-        });
-
-        const info = await inspectFileDatabaseInfo(core as never, "note.md");
-
-        expect(info.database.mergeBases).toEqual([
-            {
-                winnerRevision: "3-current",
-                conflictRevision: "2-conflict",
-                revision: "2-parent",
-                metadataAvailableLocally: true,
-                contentAvailableLocally: false,
-                missingChunkIds: ["h:missing-parent"],
-                unavailableSharedRevisions: ["1-root"],
-            },
-        ]);
-    });
-
-    it("does not decode a revision whose chunks are not all available locally", async () => {
-        const { core } = createCore();
-
-        await expect(readFileDatabaseRevisionLocally(core as never, "note.md", "3-current")).resolves.toBe(false);
-
-        expect(core.localDatabase.getDBEntryFromMeta).not.toHaveBeenCalled();
-    });
-
-    it("decodes an exact revision after confirming that every chunk is available locally", async () => {
-        const { core, current } = createCore();
-        core.localDatabase.localDatabase.get.mockResolvedValue({
-            ...current,
-            children: ["h:available"],
-            eden: {},
-        } as never);
-        core.localDatabase.allDocsRaw.mockResolvedValue({
-            rows: [
-                {
-                    id: "h:available",
-                    key: "h:available",
-                    value: { rev: "1-available" },
-                },
-            ],
-        });
-
-        await expect(readFileDatabaseRevisionLocally(core as never, "note.md", "3-current")).resolves.toEqual(
-            expect.objectContaining({
-                data: ["loaded body"],
-            })
-        );
-
-        expect(core.localDatabase.getDBEntryFromMeta).toHaveBeenCalledWith(
-            expect.objectContaining({
-                _rev: "3-current",
-            }),
-            false,
-            false
-        );
-    });
-
-    it("retries an exact revision through the configured chunk retrieval path", async () => {
-        const { core } = createCore();
-
-        await retryReadFileDatabaseRevision(core as never, "note.md", "2-conflict");
-
-        expect(core.localDatabase.getDBEntry).toHaveBeenCalledWith(
-            "note.md",
-            { rev: "2-conflict" },
-            false,
-            true,
-            true
-        );
-    });
-
-    it("reports the exact revision as locally available after retry recovers its missing chunk", async () => {
-        const { conflict, core } = createCore();
-        let recovered = false;
-        core.localDatabase.getDBEntry.mockImplementation(async () => {
-            recovered = true;
-            return conflict as never;
-        });
-        core.localDatabase.allDocsRaw.mockImplementation(async ({ keys }: { keys: string[] }) => ({
-            rows:
-                recovered && keys.includes("h:private-missing")
-                    ? [
-                          {
-                              id: "h:private-missing",
-                              key: "h:private-missing",
-                              value: { rev: "1-recovered" },
-                          },
-                      ]
-                    : [],
-        }));
-
-        await expect(
-            retryReadFileDatabaseRevision(core as never, "note.md", "2-conflict")
-        ).resolves.not.toBe(false);
-        const information = await inspectFileDatabaseInfo(core as never, "note.md");
-
-        expect(
-            information.database.revisions.find(({ revision }) => revision === "2-conflict")
-        ).toEqual(
-            expect.objectContaining({
-                contentAvailableLocally: true,
-                chunks: [
-                    expect.objectContaining({
-                        id: "h:private-missing",
-                        localDatabaseState: "available",
-                        localDatabaseRevision: "1-recovered",
-                    }),
-                ],
-            })
-        );
-    });
-
-    it("keeps the exact revision identifiers when conflict metadata is unavailable", async () => {
-        const { conflict, core, current } = createCore();
-        core.localDatabase.localDatabase.get.mockImplementation(async (_id: string, options?: { rev?: string }) => {
-            if (options?.rev === "2-unavailable") {
-                throw Object.assign(new Error("missing"), { status: 404 });
-            }
-            if (options?.rev === "2-conflict") {
-                return conflict;
-            }
-            return { ...current, _conflicts: ["2-conflict", "2-unavailable"] };
-        });
-
-        const report = await buildFileDatabaseInfoReport(core as never, "note.md");
-
-        expect(report).toContain('"conflictRevisions"');
-        expect(report).toContain('"2-conflict"');
-        expect(report).toContain('"2-unavailable"');
-        expect(report).toContain('"unavailableConflictRevisions"');
-    });
-
-    it("reads an existing local document even when current synchronisation filters exclude its path", async () => {
-        const { core, current } = createCore();
-        core.services.path.path2id.mockResolvedValue("f:ignored");
-        core.localDatabase.localDatabase.get.mockResolvedValue({
-            ...current,
-            _id: "f:ignored",
-            _rev: "5-ignored",
-            _conflicts: [],
-            _revs_info: [],
-            path: "ignored.md",
-            ctime: 10,
-            mtime: 20,
-            size: 30,
-            children: [],
-        });
-
-        const report = await buildFileDatabaseInfoReport(core as never, "ignored.md");
-
-        expect(report).toContain('"exists": true');
-        expect(report).toContain('"documentId": "f:ignored"');
-        expect(report).toContain('"revision": "5-ignored"');
-    });
-
-    it("offers the union of storage and database paths and excludes inactive internal namespaces", async () => {
-        const { core } = createCore();
-
-        await expect(collectFileDatabaseInfoPaths(core as never)).resolves.toEqual(["a.md", "db-only.md", "z.md"]);
-
-        core.settings.syncInternalFiles = true;
-        await expect(collectFileDatabaseInfoPaths(core as never)).resolves.toEqual([
-            ".obsidian/app.json",
-            "a.md",
-            "db-only.md",
-        ]);
-    });
-
-    it("copies the selected file report through the existing copy dialogue", async () => {
-        const { askSelectString, core, promptCopyToClipboard } = createCore();
-
-        await expect(chooseAndCopyFileDatabaseInfo(core as never)).resolves.toBe(true);
-
-        expect(askSelectString).toHaveBeenCalledWith("Choose a file to inspect", ["a.md", "db-only.md", "z.md"]);
-        expect(promptCopyToClipboard).toHaveBeenCalledWith(
-            "Database information for db-only.md",
-            expect.stringContaining('"path": "db-only.md"')
-        );
-    });
-});

src/serviceFeatures/fileRepair.ts

@@ -1,132 +0,0 @@
-import type { LoadedEntry } from "@vrtmrz/livesync-commonlib/compat/common/types";
-import { createBlob, isDocContentSame, readAsBlob } from "@vrtmrz/livesync-commonlib/compat/common/utils";
-import type { StorageAccess } from "@vrtmrz/livesync-commonlib/compat/interfaces/StorageAccess";
-import type { IFileHandler } from "@vrtmrz/livesync-commonlib/compat/interfaces/FileHandler";
-import {
-    inspectFileDatabaseInfo,
-    readFileDatabaseRevisionLocally,
-    type FileDatabaseInfo,
-    type FileDatabaseInfoCore,
-    type RevisionDatabaseInfo,
-} from "./fileDatabaseInfo";
-
-export type FileRepairCore = FileDatabaseInfoCore & {
-    fileHandler: Pick<IFileHandler, "deleteRevisionFromDB">;
-    storageAccess: FileDatabaseInfoCore["storageAccess"] & Pick<StorageAccess, "readHiddenFileBinary">;
-};
-
-export type FileRepairRevision = {
-    role: "winner" | "conflict";
-    metadata: RevisionDatabaseInfo;
-    contentReadable: boolean;
-    contentMatchesStorage: boolean | null;
-    loadedEntry: LoadedEntry | false;
-};
-
-export type FileRepairInspection = {
-    information: FileDatabaseInfo;
-    revisions: FileRepairRevision[];
-    requiresAttention: boolean;
-};
-
-export type DiscardUnreadableRevisionResult =
-    | "discarded"
-    | "failed"
-    | "no-longer-live"
-    | "revision-is-readable";
-
-export type DiscardLiveBranchResult = "discarded" | "failed" | "no-longer-live" | "only-live-revision";
-
-export async function inspectFileRepair(core: FileRepairCore, path: string): Promise<FileRepairInspection> {
-    const information = await inspectFileDatabaseInfo(core, path);
-    const storageContent = information.storage.exists
-        ? createBlob(await core.storageAccess.readHiddenFileBinary(path))
-        : undefined;
-    const revisions: FileRepairRevision[] = [];
-
-    for (const metadata of information.database.revisions) {
-        const loadedEntry =
-            metadata.deleted || !metadata.contentAvailableLocally
-                ? false
-                : await readFileDatabaseRevisionLocally(core, path, metadata.revision ?? "");
-        const contentReadable = metadata.deleted || loadedEntry !== false;
-        const contentMatchesStorage =
-            storageContent && loadedEntry !== false
-                ? await isDocContentSame(storageContent, readAsBlob(loadedEntry))
-                : null;
-        revisions.push({
-            role: metadata.current ? "winner" : "conflict",
-            metadata,
-            contentReadable,
-            contentMatchesStorage,
-            loadedEntry,
-        });
-    }
-
-    const winner = revisions.find(({ role }) => role === "winner");
-    const winnerRepresentsStoredFile = winner !== undefined && !winner.metadata.deleted;
-    const databaseAndStorageDiffer =
-        information.storage.exists !== winnerRepresentsStoredFile ||
-        (information.storage.exists &&
-            winnerRepresentsStoredFile &&
-            winner.contentMatchesStorage === false);
-    const unreadableLiveRevision =
-        information.database.unavailableConflictRevisions.length > 0 ||
-        revisions.some(({ contentReadable }) => !contentReadable);
-    const requiresAttention =
-        databaseAndStorageDiffer ||
-        information.database.conflictCount > 0 ||
-        unreadableLiveRevision ||
-        (information.database.exists && winner === undefined);
-
-    return {
-        information,
-        revisions,
-        requiresAttention,
-    };
-}
-
-export async function discardUnreadableLiveRevision(
-    core: FileRepairCore,
-    path: string,
-    revision: string
-): Promise<DiscardUnreadableRevisionResult> {
-    const latest = await inspectFileDatabaseInfo(core, path);
-    const liveRevisions = [
-        latest.database.currentRevision,
-        ...latest.database.conflictRevisions,
-    ].filter((candidate): candidate is string => candidate !== null);
-    if (!liveRevisions.includes(revision)) {
-        return "no-longer-live";
-    }
-
-    const metadata = latest.database.revisions.find((candidate) => candidate.revision === revision);
-    const metadataUnavailable = latest.database.unavailableConflictRevisions.includes(revision);
-    if (!metadataUnavailable && (metadata?.deleted || metadata?.contentAvailableLocally)) {
-        return "revision-is-readable";
-    }
-
-    const deleted = await core.fileHandler.deleteRevisionFromDB(latest.databasePath, revision);
-    return deleted ? "discarded" : "failed";
-}
-
-export async function discardLiveBranch(
-    core: FileRepairCore,
-    path: string,
-    revision: string
-): Promise<DiscardLiveBranchResult> {
-    const latest = await inspectFileDatabaseInfo(core, path);
-    const liveRevisions = [
-        latest.database.currentRevision,
-        ...latest.database.conflictRevisions,
-    ].filter((candidate): candidate is string => candidate !== null);
-    if (!liveRevisions.includes(revision)) {
-        return "no-longer-live";
-    }
-    if (liveRevisions.length < 2) {
-        return "only-live-revision";
-    }
-
-    const deleted = await core.fileHandler.deleteRevisionFromDB(latest.databasePath, revision);
-    return deleted ? "discarded" : "failed";
-}

src/serviceFeatures/fileRepair.unit.spec.ts

@@ -1,228 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import {
-    discardLiveBranch,
-    discardUnreadableLiveRevision,
-    inspectFileRepair,
-} from "./fileRepair";
-
-function createCore() {
-    const current = {
-        _id: "f:note",
-        _rev: "3-current",
-        _conflicts: ["2-conflict"],
-        _revs_info: [{ rev: "3-current", status: "available" }],
-        path: "note.md",
-        ctime: 1,
-        mtime: 3,
-        size: 7,
-        type: "plain",
-        children: ["h:current"],
-        deleted: false,
-        eden: {},
-    };
-    const conflict = {
-        ...current,
-        _rev: "2-conflict",
-        _conflicts: undefined,
-        _revs_info: [{ rev: "2-conflict", status: "available" }],
-        mtime: 2,
-        children: ["h:missing-conflict"],
-    };
-    const deleteRevisionFromDB = vi.fn(async () => true);
-    const core = {
-        settings: {
-            syncInternalFiles: false,
-            syncInternalFilesIgnorePatterns: "",
-            syncInternalFilesTargetPatterns: "",
-        },
-        storageAccess: {
-            isExistsIncludeHidden: vi.fn(async () => true),
-            statHidden: vi.fn(async () => ({
-                ctime: 1,
-                mtime: 3,
-                size: 7,
-                type: "file",
-            })),
-            readHiddenFileBinary: vi.fn(async () => new TextEncoder().encode("current").buffer),
-            getFileNames: vi.fn(async () => ["note.md"]),
-            getFilesIncludeHidden: vi.fn(async () => ["note.md"]),
-        },
-        localDatabase: {
-            localDatabase: {
-                get: vi.fn(async (_id: string, options?: { rev?: string }) =>
-                    options?.rev === "2-conflict" ? conflict : current
-                ),
-            },
-            allDocsRaw: vi.fn(async ({ keys }: { keys: string[] }) => ({
-                rows: keys.includes("h:current")
-                    ? [
-                          {
-                              id: "h:current",
-                              key: "h:current",
-                              value: { rev: "1-current" },
-                          },
-                      ]
-                    : [],
-            })),
-            getDBEntryFromMeta: vi.fn(async (meta: typeof current) => ({
-                ...meta,
-                data: [meta._rev === "3-current" ? "current" : "conflict"],
-            })),
-            getDBEntry: vi.fn(async () => false),
-            findAllDocs: vi.fn(async function* () {
-                yield current;
-            }),
-        },
-        fileHandler: {
-            deleteRevisionFromDB,
-        },
-        services: {
-            path: {
-                path2id: vi.fn(async () => "f:note"),
-            },
-            UI: {
-                confirm: {},
-            },
-        },
-    };
-    return {
-        conflict,
-        core,
-        current,
-        deleteRevisionFromDB,
-    };
-}
-
-describe("file repair inspection", () => {
-    it("shows the winner and every conflict revision independently", async () => {
-        const { core } = createCore();
-
-        const inspection = await inspectFileRepair(core as never, "note.md");
-
-        expect(inspection.revisions).toEqual([
-            expect.objectContaining({
-                role: "winner",
-                contentReadable: true,
-                contentMatchesStorage: true,
-                metadata: expect.objectContaining({
-                    revision: "3-current",
-                }),
-            }),
-            expect.objectContaining({
-                role: "conflict",
-                contentReadable: false,
-                contentMatchesStorage: null,
-                metadata: expect.objectContaining({
-                    revision: "2-conflict",
-                }),
-            }),
-        ]);
-        expect(inspection.requiresAttention).toBe(true);
-    });
-
-    it("omits a logical deletion which already matches an absent Vault file", async () => {
-        const { core, current } = createCore();
-        current.deleted = true;
-        current._conflicts = [];
-        current.children = [];
-        core.storageAccess.isExistsIncludeHidden.mockResolvedValue(false);
-        core.storageAccess.statHidden.mockResolvedValue(null as never);
-
-        const inspection = await inspectFileRepair(core as never, "note.md");
-
-        expect(inspection.revisions).toEqual([
-            expect.objectContaining({
-                role: "winner",
-                contentReadable: true,
-                metadata: expect.objectContaining({
-                    deleted: true,
-                    revision: "3-current",
-                }),
-            }),
-        ]);
-        expect(inspection.requiresAttention).toBe(false);
-    });
-
-    it("rechecks liveness and readability before discarding an exact revision", async () => {
-        const { core, deleteRevisionFromDB } = createCore();
-
-        await expect(
-            discardUnreadableLiveRevision(core as never, "note.md", "2-conflict")
-        ).resolves.toBe("discarded");
-        await expect(
-            discardUnreadableLiveRevision(core as never, "note.md", "3-current")
-        ).resolves.toBe("revision-is-readable");
-
-        expect(deleteRevisionFromDB).toHaveBeenCalledOnce();
-        expect(deleteRevisionFromDB).toHaveBeenCalledWith("note.md", "2-conflict");
-    });
-
-    it("allows an exact unreadable generation-one winner to be discarded explicitly", async () => {
-        const { core, current, deleteRevisionFromDB } = createCore();
-        current._rev = "1-root";
-        current._conflicts = [];
-        current.children = ["h:missing-root"];
-        core.localDatabase.allDocsRaw.mockResolvedValue({ rows: [] });
-
-        const inspection = await inspectFileRepair(core as never, "note.md");
-
-        expect(inspection.revisions).toEqual([
-            expect.objectContaining({
-                role: "winner",
-                contentReadable: false,
-                metadata: expect.objectContaining({
-                    revision: "1-root",
-                }),
-            }),
-        ]);
-        await expect(
-            discardUnreadableLiveRevision(core as never, "note.md", "1-root")
-        ).resolves.toBe("discarded");
-        expect(deleteRevisionFromDB).toHaveBeenCalledWith("note.md", "1-root");
-    });
-
-    it("refuses to discard a revision which stopped being a live leaf", async () => {
-        const { core, current, deleteRevisionFromDB } = createCore();
-        core.localDatabase.localDatabase.get.mockResolvedValue({
-            ...current,
-            _conflicts: [],
-        });
-
-        await expect(
-            discardUnreadableLiveRevision(core as never, "note.md", "2-conflict")
-        ).resolves.toBe("no-longer-live");
-
-        expect(deleteRevisionFromDB).not.toHaveBeenCalled();
-    });
-
-    it("discards an exact readable winner while another live branch remains", async () => {
-        const { core, deleteRevisionFromDB } = createCore();
-
-        await expect(
-            discardLiveBranch(core as never, "note.md", "3-current")
-        ).resolves.toBe("discarded");
-
-        expect(deleteRevisionFromDB).toHaveBeenCalledWith("note.md", "3-current");
-    });
-
-    it("refuses to discard the only live branch", async () => {
-        const { core, current, deleteRevisionFromDB } = createCore();
-        current._conflicts = [];
-
-        await expect(
-            discardLiveBranch(core as never, "note.md", "3-current")
-        ).resolves.toBe("only-live-revision");
-
-        expect(deleteRevisionFromDB).not.toHaveBeenCalled();
-    });
-
-    it("refuses to discard a branch which is no longer live", async () => {
-        const { core, deleteRevisionFromDB } = createCore();
-
-        await expect(
-            discardLiveBranch(core as never, "note.md", "1-stale")
-        ).resolves.toBe("no-longer-live");
-
-        expect(deleteRevisionFromDB).not.toHaveBeenCalled();
-    });
-});

src/serviceFeatures/fileRepairPresentation.ts

@@ -1,144 +0,0 @@
-import {
-    BASE_IS_NEW,
-    EVEN,
-    TARGET_IS_NEW,
-} from "@vrtmrz/livesync-commonlib/compat/common/models/shared.const.symbols";
-import {
-    compareMTime,
-    readAsBlob,
-} from "@vrtmrz/livesync-commonlib/compat/common/utils";
-import { isPlainText } from "@vrtmrz/livesync-commonlib/compat/string_and_binary/path";
-import type {
-    FileRepairInspection,
-    FileRepairRevision,
-} from "./fileRepair";
-
-export type FileRepairRevisionActions = {
-    compareWithVault: boolean;
-    applyRevisionToVault: boolean;
-    markAsVaultRevision: boolean;
-    storeVaultOnBranch: boolean;
-    applyLogicalDeletionToVault: boolean;
-    retryRevision: boolean;
-    discardBranch: boolean;
-    discardRevision: boolean;
-};
-
-export type FileRepairTimestampRelation =
-    | "vault-newer"
-    | "database-newer"
-    | "same-window"
-    | "unavailable";
-
-export type FileRepairRevisionComparison = {
-    recordedSize: number;
-    decodedSize: number | null;
-    recordedToDecodedSizeDifference: number | null;
-    vaultSize: number | null;
-    databaseToVaultSizeDifference: number | null;
-    databaseMtime: number;
-    vaultMtime: number | null;
-    timestampDifferenceMs: number | null;
-    timestampRelation: FileRepairTimestampRelation;
-};
-
-export function getFileRepairRevisionActions(
-    inspection: FileRepairInspection,
-    revision: FileRepairRevision
-): FileRepairRevisionActions {
-    const storageExists = inspection.information.storage.exists;
-    const hasRevision = revision.metadata.revision !== null;
-    const readableFileRevision =
-        !revision.metadata.deleted &&
-        revision.contentReadable &&
-        revision.loadedEntry !== false;
-    const matchesVault = storageExists && revision.contentMatchesStorage === true;
-    const hasConflictBranches = inspection.information.database.conflictCount > 0;
-
-    return {
-        compareWithVault:
-            readableFileRevision &&
-            storageExists &&
-            revision.contentMatchesStorage === false &&
-            isPlainText(inspection.information.path),
-        applyRevisionToVault:
-            hasRevision &&
-            readableFileRevision &&
-            (!storageExists || revision.contentMatchesStorage !== true),
-        markAsVaultRevision:
-            hasRevision &&
-            readableFileRevision &&
-            matchesVault,
-        storeVaultOnBranch:
-            hasRevision &&
-            storageExists &&
-            revision.contentMatchesStorage !== true,
-        applyLogicalDeletionToVault:
-            hasRevision &&
-            revision.metadata.deleted &&
-            storageExists,
-        retryRevision:
-            hasRevision &&
-            !revision.metadata.deleted &&
-            !revision.contentReadable,
-        discardBranch: hasRevision && hasConflictBranches,
-        discardRevision:
-            hasRevision &&
-            !hasConflictBranches &&
-            !revision.metadata.deleted &&
-            !revision.contentReadable,
-    };
-}
-
-export function getFileRepairRevisionComparison(
-    inspection: FileRepairInspection,
-    revision: FileRepairRevision
-): FileRepairRevisionComparison {
-    const decodedSize =
-        revision.loadedEntry === false
-            ? null
-            : readAsBlob(revision.loadedEntry).size;
-    const vaultSize =
-        inspection.information.storage.exists
-            ? (inspection.information.storage.size ?? null)
-            : null;
-    const databaseMtime = revision.metadata.mtime;
-    const vaultMtime =
-        inspection.information.storage.exists
-            ? (inspection.information.storage.mtime ?? null)
-            : null;
-    const timestampDifferenceMs =
-        databaseMtime > 0 && vaultMtime !== null && vaultMtime > 0
-            ? vaultMtime - databaseMtime
-            : null;
-    let timestampRelation: FileRepairTimestampRelation = "unavailable";
-    if (timestampDifferenceMs !== null) {
-        const comparison = compareMTime(vaultMtime!, databaseMtime);
-        timestampRelation =
-            comparison === EVEN
-                ? "same-window"
-                : comparison === BASE_IS_NEW
-                  ? "vault-newer"
-                  : comparison === TARGET_IS_NEW
-                    ? "database-newer"
-                    : "unavailable";
-    }
-
-    return {
-        recordedSize: revision.metadata.recordedSize,
-        decodedSize,
-        recordedToDecodedSizeDifference:
-            decodedSize === null
-                ? null
-                : decodedSize - revision.metadata.recordedSize,
-        vaultSize,
-        databaseToVaultSizeDifference:
-            decodedSize === null || vaultSize === null
-                ? null
-                : vaultSize - decodedSize,
-        databaseMtime,
-        vaultMtime,
-        timestampDifferenceMs,
-        timestampRelation,
-    };
-}

src/serviceFeatures/fileRepairPresentation.unit.spec.ts

@@ -1,230 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { FilePathWithPrefix } from "@vrtmrz/livesync-commonlib/compat/common/types";
-import type { FileRepairInspection, FileRepairRevision } from "./fileRepair";
-import {
-    getFileRepairRevisionActions,
-    getFileRepairRevisionComparison,
-} from "./fileRepairPresentation";
-
-function createInspection(
-    revision: Partial<FileRepairRevision> = {},
-    storage: { exists: boolean; size?: number; mtime?: number } = {
-        exists: true,
-        size: 12,
-        mtime: 5_500,
-    }
-): { inspection: FileRepairInspection; revision: FileRepairRevision } {
-    const completeRevision = {
-        role: "conflict",
-        metadata: {
-            documentId: "f:note",
-            revision: "2-conflict",
-            current: false,
-            deleted: false,
-            storageType: "plain",
-            storageLayout: "chunked",
-            ctime: 1,
-            mtime: 2_000,
-            recordedSize: 9,
-            revisionHistory: [],
-            chunkReferences: 0,
-            uniqueChunkReferences: 0,
-            embeddedChunkReferences: 0,
-            locallyStoredChunkReferences: 0,
-            contentAvailableLocally: true,
-            chunks: [],
-        },
-        contentReadable: true,
-        contentMatchesStorage: false,
-        loadedEntry: {
-            _id: "f:note",
-            _rev: "2-conflict",
-            path: "note.md",
-            ctime: 1,
-            mtime: 2_000,
-            size: 9,
-            type: "plain",
-            datatype: "plain",
-            children: [],
-            eden: {},
-            data: "content",
-        },
-        ...revision,
-    } as FileRepairRevision;
-    const inspection = {
-        information: {
-            path: "note.md",
-            databasePath: "note.md" as FilePathWithPrefix,
-            storage,
-            database: {
-                source: "local database on this device",
-                remoteQueried: false,
-                exists: true,
-                currentRevision: "3-winner",
-                conflictCount: 1,
-                conflictRevisions: ["2-conflict"],
-                unavailableConflictRevisions: [],
-                revisions: [],
-                mergeBases: [],
-            },
-        },
-        revisions: [completeRevision],
-        requiresAttention: true,
-    } satisfies FileRepairInspection;
-    return { inspection, revision: completeRevision };
-}
-
-describe("file repair presentation", () => {
-    it("offers both reconciliation directions for a readable differing revision", () => {
-        const { inspection, revision } = createInspection();
-
-        expect(getFileRepairRevisionActions(inspection, revision)).toEqual({
-            compareWithVault: true,
-            applyRevisionToVault: true,
-            markAsVaultRevision: false,
-            storeVaultOnBranch: true,
-            applyLogicalDeletionToVault: false,
-            retryRevision: false,
-            discardRevision: false,
-            discardBranch: true,
-        });
-    });
-
-    it("marks an exact matching revision without creating another child", () => {
-        const { inspection, revision } = createInspection({
-            contentMatchesStorage: true,
-        });
-
-        expect(getFileRepairRevisionActions(inspection, revision)).toMatchObject({
-            compareWithVault: false,
-            applyRevisionToVault: false,
-            markAsVaultRevision: true,
-            storeVaultOnBranch: false,
-            discardBranch: true,
-        });
-    });
-
-    it("does not offer a text comparison for a binary file", () => {
-        const { inspection, revision } = createInspection();
-        inspection.information.path = "image.png";
-
-        expect(getFileRepairRevisionActions(inspection, revision)).toMatchObject({
-            compareWithVault: false,
-            applyRevisionToVault: true,
-            storeVaultOnBranch: true,
-        });
-    });
-
-    it("offers explicit deletion or branch extension for a logical deletion", () => {
-        const { inspection, revision } = createInspection({
-            metadata: {
-                ...createInspection().revision.metadata,
-                deleted: true,
-            },
-            contentReadable: true,
-            contentMatchesStorage: null,
-            loadedEntry: false,
-        });
-
-        expect(getFileRepairRevisionActions(inspection, revision)).toMatchObject({
-            applyRevisionToVault: false,
-            storeVaultOnBranch: true,
-            applyLogicalDeletionToVault: true,
-            retryRevision: false,
-            discardRevision: false,
-            discardBranch: true,
-        });
-    });
-
-    it("offers retry, discard, and branch extension for an unreadable live revision", () => {
-        const { inspection, revision } = createInspection({
-            contentReadable: false,
-            contentMatchesStorage: null,
-            loadedEntry: false,
-        });
-
-        expect(getFileRepairRevisionActions(inspection, revision)).toMatchObject({
-            compareWithVault: false,
-            applyRevisionToVault: false,
-            markAsVaultRevision: false,
-            storeVaultOnBranch: true,
-            retryRevision: true,
-            discardRevision: false,
-            discardBranch: true,
-        });
-    });
-
-    it("keeps the existing unreadable-leaf escape hatch when there is no conflict branch", () => {
-        const { inspection, revision } = createInspection({
-            role: "winner",
-            contentReadable: false,
-            contentMatchesStorage: null,
-            loadedEntry: false,
-        });
-        inspection.information.database.conflictCount = 0;
-        inspection.information.database.conflictRevisions = [];
-        inspection.information.database.currentRevision = revision.metadata.revision;
-
-        expect(getFileRepairRevisionActions(inspection, revision)).toMatchObject({
-            discardRevision: true,
-            discardBranch: false,
-        });
-    });
-
-    it("does not offer a storage action for a matching absent logical deletion", () => {
-        const { inspection, revision } = createInspection(
-            {
-                metadata: {
-                    ...createInspection().revision.metadata,
-                    deleted: true,
-                },
-                contentReadable: true,
-                contentMatchesStorage: null,
-                loadedEntry: false,
-            },
-            { exists: false }
-        );
-
-        expect(getFileRepairRevisionActions(inspection, revision)).toMatchObject({
-            applyLogicalDeletionToVault: false,
-            storeVaultOnBranch: false,
-        });
-    });
-
-    it("reports recorded, decoded, Vault-size, and timestamp differences", () => {
-        const { inspection, revision } = createInspection();
-
-        expect(getFileRepairRevisionComparison(inspection, revision)).toEqual({
-            recordedSize: 9,
-            decodedSize: 7,
-            recordedToDecodedSizeDifference: -2,
-            vaultSize: 12,
-            databaseToVaultSizeDifference: 5,
-            databaseMtime: 2_000,
-            vaultMtime: 5_500,
-            timestampDifferenceMs: 3_500,
-            timestampRelation: "vault-newer",
-        });
-    });
-
-    it("uses the same two-second timestamp comparison window as synchronisation", () => {
-        const { inspection, revision } = createInspection(
-            {
-                metadata: {
-                    ...createInspection().revision.metadata,
-                    mtime: 3_001,
-                },
-            },
-            {
-                exists: true,
-                size: 12,
-                mtime: 3_999,
-            }
-        );
-
-        expect(getFileRepairRevisionComparison(inspection, revision)).toMatchObject({
-            timestampDifferenceMs: 998,
-            timestampRelation: "same-window",
-        });
-    });
-});

src/serviceFeatures/onLayoutReady/enablei18n.ts

@@ -1,4 +1,4 @@
-import { getLanguage, Notice, requireApiVersion } from "@/deps";
+import { getLanguage, requireApiVersion } from "@/deps";
 import { createServiceFeature } from "@vrtmrz/livesync-commonlib/compat/interfaces/ServiceModule";
 import { SUPPORTED_I18N_LANGS, type I18N_LANGS } from "@/common/rosetta";
 import { $msg, __onMissingTranslation, setLang } from "@/common/translation";
@@ -15,40 +15,7 @@ function tryGetLanguage(onError: (error: unknown) => void) {
     return "en";
 }
 
-class ObsidianLanguageAppliedNotice {
-    private reminder: Notice | undefined;
-
-    show(openDetails: () => void): void {
-        this.clear();
-        let reminderAnchor: HTMLAnchorElement | undefined;
-        const appliedMessage =
-            $msg("dialog.yourLanguageAvailable")
-                .split(/\r?\n\s*\r?\n/u, 1)[0]
-                ?.trim() ?? $msg("Display Language");
-        const fragment = createFragment((documentFragment) => {
-            documentFragment.createSpan({
-                text: `${appliedMessage} `,
-            });
-            documentFragment.createEl("a", { text: $msg("Open the dialog") }, (anchor) => {
-                reminderAnchor = anchor;
-                anchor.addEventListener("click", (event) => {
-                    event.preventDefault();
-                    this.clear();
-                    openDetails();
-                });
-            });
-        });
-        this.reminder = new Notice(fragment, 0);
-        reminderAnchor?.closest<HTMLElement>(".notice")?.classList.add("livesync-language-applied-notice");
-    }
-
-    clear(): void {
-        this.reminder?.hide();
-        this.reminder = undefined;
-    }
-}
-
-export const enableI18nFeature = createServiceFeature(async ({ services: { setting, API, appLifecycle } }) => {
+export const enableI18nFeature = createServiceFeature(async ({ services: { setting, API } }) => {
     // Clear missing translation handler to avoid unnecessary warnings.
     __onMissingTranslation(() => {});
     let isChanged = false;
@@ -69,48 +36,26 @@ export const enableI18nFeature = createServiceFeature(async ({ services: { setti
             // settings.displayLanguage = obsidianLanguage as I18N_LANGS;
             await setting.applyPartial({ displayLanguage: obsidianLanguage as I18N_LANGS });
             isChanged = true;
-            setLang(obsidianLanguage as I18N_LANGS);
+            setLang(settings.displayLanguage);
         } else if (settings.displayLanguage == "") {
             // settings.displayLanguage = "def";
             await setting.applyPartial({ displayLanguage: "def" });
-            setLang("def");
+            setLang(settings.displayLanguage);
             await setting.saveSettingData();
         }
     }
     if (isChanged) {
+        const revert = $msg("dialog.yourLanguageAvailable.btnRevertToDefault");
+        if (
+            (await API.confirm.askSelectStringDialogue($msg(`dialog.yourLanguageAvailable`), ["OK", revert], {
+                defaultAction: "OK",
+                title: $msg(`dialog.yourLanguageAvailable.Title`),
+            })) == revert
+        ) {
+            await setting.applyPartial({ displayLanguage: "def" });
+            setLang(settings.displayLanguage);
+        }
         await setting.saveSettingData();
-        const reminder = new ObsidianLanguageAppliedNotice();
-        appLifecycle.onUnload.addHandler(() => {
-            reminder.clear();
-            return Promise.resolve(true);
-        });
-        reminder.show(() => {
-            void (async () => {
-                try {
-                    const revert = $msg("dialog.yourLanguageAvailable.btnRevertToDefault");
-                    if (
-                        (await API.confirm.askSelectStringDialogue(
-                            $msg(`dialog.yourLanguageAvailable`),
-                            ["OK", revert],
-                            {
-                                defaultAction: "OK",
-                                title: $msg("Display Language"),
-                            }
-                        )) == revert
-                    ) {
-                        await setting.applyPartial({ displayLanguage: "def" });
-                        setLang("def");
-                        await setting.saveSettingData();
-                    }
-                } catch (error) {
-                    API.addLog(
-                        `Failed to open translation details: ${String(error)}`,
-                        LOG_LEVEL_VERBOSE,
-                        "i18n-language"
-                    );
-                }
-            })();
-        });
     }
     return true;
 });

src/serviceFeatures/onLayoutReady/enablei18n.unit.spec.ts

@@ -1,110 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const noticeState = vi.hoisted(() => ({
-    instances: [] as Array<{ hide: ReturnType<typeof vi.fn>; duration: number }>,
-    spanTexts: [] as string[],
-}));
-
-vi.mock("@/deps", () => ({
-    getLanguage: () => "ja",
-    requireApiVersion: () => true,
-    Notice: class {
-        hide = vi.fn();
-
-        constructor(_fragment: unknown, duration: number) {
-            noticeState.instances.push({ hide: this.hide, duration });
-        }
-    },
-}));
-
-vi.mock("@/common/translation", () => ({
-    $msg: (key: string) =>
-        ({
-            "dialog.yourLanguageAvailable": "Translation has been applied.\n\nMore details.",
-            "dialog.yourLanguageAvailable.btnRevertToDefault": "Keep Default",
-            "dialog.yourLanguageAvailable.Title": "Translation is available!",
-            "Display Language": "Display language",
-            "Open the dialog": "Open the dialogue",
-        })[key] ?? key,
-    __onMissingTranslation: vi.fn(),
-    setLang: vi.fn(),
-}));
-
-import { enableI18nFeature } from "./enablei18n.ts";
-
-describe("automatic display language", () => {
-    let clickDetails: ((event: { preventDefault(): void }) => void) | undefined;
-
-    beforeEach(() => {
-        noticeState.instances.length = 0;
-        noticeState.spanTexts.length = 0;
-        clickDetails = undefined;
-        vi.stubGlobal("createFragment", (build: (fragment: unknown) => void) => {
-            const anchor = {
-                addEventListener: (_event: string, listener: (event: { preventDefault(): void }) => void) => {
-                    clickDetails = listener;
-                },
-                closest: () => ({ classList: { add: vi.fn() } }),
-            };
-            const fragment = {
-                createSpan: ({ text }: { text: string }) => noticeState.spanTexts.push(text),
-                createEl: (_tag: string, _options: unknown, configure: (element: typeof anchor) => void) => {
-                    configure(anchor);
-                    return anchor;
-                },
-            };
-            build(fragment);
-            return fragment;
-        });
-    });
-
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
-    });
-
-    it("lets start-up continue and opens translation details only from a persistent Notice", async () => {
-        const settings = { displayLanguage: "" };
-        const applyPartial = vi.fn(async (partial: Partial<typeof settings>) => Object.assign(settings, partial));
-        const saveSettingData = vi.fn().mockResolvedValue(undefined);
-        const askSelectStringDialogue = vi.fn().mockResolvedValue("Keep Default");
-        const unloadHandlers: Array<() => Promise<boolean>> = [];
-        const host = {
-            services: {
-                setting: {
-                    currentSettings: () => settings,
-                    applyPartial,
-                    saveSettingData,
-                },
-                API: {
-                    addLog: vi.fn(),
-                    confirm: { askSelectStringDialogue },
-                },
-                appLifecycle: {
-                    onUnload: {
-                        addHandler: (handler: () => Promise<boolean>) => unloadHandlers.push(handler),
-                    },
-                },
-            },
-        };
-
-        await expect(enableI18nFeature(host as never)).resolves.toBe(true);
-
-        expect(settings.displayLanguage).toBe("ja");
-        expect(saveSettingData).toHaveBeenCalledOnce();
-        expect(askSelectStringDialogue).not.toHaveBeenCalled();
-        expect(noticeState.instances).toHaveLength(1);
-        expect(noticeState.instances[0]?.duration).toBe(0);
-        expect(noticeState.spanTexts).toEqual(["Translation has been applied. "]);
-        expect(clickDetails).toBeTypeOf("function");
-
-        clickDetails?.({ preventDefault: vi.fn() });
-        await vi.waitFor(() => expect(askSelectStringDialogue).toHaveBeenCalledOnce());
-        expect(askSelectStringDialogue.mock.calls[0]?.[2]).toMatchObject({ title: "Display language" });
-        await vi.waitFor(() => expect(settings.displayLanguage).toBe("def"));
-        expect(saveSettingData).toHaveBeenCalledTimes(2);
-
-        await expect(unloadHandlers[0]?.()).resolves.toBe(true);
-        expect(noticeState.instances[0]?.hide).toHaveBeenCalled();
-    });
-});

src/serviceFeatures/setupObsidian/qrCode.ts

@@ -65,11 +65,7 @@ export function useSetupQRCodeFeature(host: NecessaryServices<"API" | "UI" | "se
         host.services.API.addCommand({
             id: "livesync-setting-qr",
             name: "Show settings as a QR code",
-            checkCallback: (checking) => {
-                if (!host.services.setting.currentSettings().isConfigured) return false;
-                if (!checking) fireAndForget(encodeSetupSettingsAsQR(host));
-                return true;
-            },
+            callback: () => fireAndForget(encodeSetupSettingsAsQR(host)),
         });
         host.services.context.events.onEvent(EVENT_REQUEST_SHOW_SETUP_QR, () =>
             fireAndForget(() => encodeSetupSettingsAsQR(host))

src/serviceFeatures/setupObsidian/qrCode.unit.spec.ts

@@ -114,44 +114,4 @@ describe("setupObsidian/qrCode", () => {
         );
         expect(onEventSpy).toHaveBeenCalledWith(EVENT_REQUEST_SHOW_SETUP_QR, expect.any(Function));
     });
-
-    it("keeps the QR command out of the palette until setup is complete", async () => {
-        const addHandler = vi.fn();
-        const commands: Array<{
-            id: string;
-            checkCallback?: (checking: boolean) => boolean | void;
-        }> = [];
-        const settings = { isConfigured: false };
-        const host = {
-            services: {
-                context: createServiceContext(),
-                API: {
-                    addCommand: vi.fn((command) => commands.push(command)),
-                },
-                appLifecycle: {
-                    onLoaded: {
-                        addHandler,
-                    },
-                },
-                setting: {
-                    currentSettings: vi.fn(() => settings),
-                },
-                UI: {
-                    confirm: {
-                        confirmWithMessage: vi.fn(),
-                    },
-                },
-            },
-        } as any;
-
-        useSetupQRCodeFeature(host);
-        const loadedHandler = addHandler.mock.calls[0][0] as () => Promise<boolean>;
-        await loadedHandler();
-
-        const command = commands.find((candidate) => candidate.id === "livesync-setting-qr")!;
-        expect(command.checkCallback?.(true)).toBe(false);
-
-        settings.isConfigured = true;
-        expect(command.checkCallback?.(true)).toBe(true);
-    });
 });

src/serviceFeatures/setupObsidian/setupManagerHandlers.ts

@@ -47,6 +47,11 @@ export function useSetupManagerHandlersFeature(
     setupManager: SetupManager
 ) {
     host.services.appLifecycle.onLoaded.addHandler(() => {
+        host.services.API.addCommand({
+            id: "livesync-open-onboarding",
+            name: "Open onboarding wizard",
+            callback: () => fireAndForget(() => openOnboarding(setupManager)),
+        });
         host.services.API.addCommand({
             id: "livesync-opensetupuri",
             name: "Use the copied setup URI (Formerly Open setup URI)",

src/serviceFeatures/setupObsidian/setupManagerHandlers.unit.spec.ts

@@ -109,7 +109,7 @@ describe("setupObsidian/setupManagerHandlers", () => {
         expect(preventDefault).toHaveBeenCalledOnce();
     });
 
-    it("keeps onboarding out of the command palette while wiring the setup URI command and events", async () => {
+    it("useSetupManagerHandlersFeature should register onLoaded handler that wires command and events", async () => {
         const addHandler = vi.fn();
         const addCommand = vi.fn();
         const events = { onEvent: vi.fn() };
@@ -147,9 +147,10 @@ describe("setupObsidian/setupManagerHandlers", () => {
         const loadedHandler = addHandler.mock.calls[0][0] as () => Promise<boolean>;
         await loadedHandler();
 
-        expect(addCommand).not.toHaveBeenCalledWith(
+        expect(addCommand).toHaveBeenCalledWith(
             expect.objectContaining({
                 id: "livesync-open-onboarding",
+                name: "Open onboarding wizard",
             })
         );
         expect(addCommand).toHaveBeenCalledWith(

src/serviceFeatures/setupObsidian/setupUri.ts

@@ -50,33 +50,19 @@ export function useSetupURIFeature(host: NecessaryServices<"API" | "UI" | "setti
         host.services.API.addCommand({
             id: "livesync-copysetupuri",
             name: "Copy settings as a new setup URI",
-            checkCallback: (checking) => {
-                if (!host.services.setting.currentSettings().isConfigured) return false;
-                if (!checking) fireAndForget(copySetupURI(host, log));
-                return true;
-            },
+            callback: () => fireAndForget(copySetupURI(host, log)),
         });
 
         host.services.API.addCommand({
             id: "livesync-copysetupuri-short",
             name: "Copy settings as a new setup URI (With customization sync)",
-            checkCallback: (checking) => {
-                const settings = host.services.setting.currentSettings();
-                if (!settings.isConfigured || !settings.usePluginSync) return false;
-                if (!checking) fireAndForget(copySetupURI(host, log, false));
-                return true;
-            },
+            callback: () => fireAndForget(copySetupURI(host, log, false)),
         });
 
         host.services.API.addCommand({
             id: "livesync-copysetupurifull",
             name: "Copy settings as a new setup URI (Full)",
-            checkCallback: (checking) => {
-                const settings = host.services.setting.currentSettings();
-                if (!settings.isConfigured || !settings.useAdvancedMode) return false;
-                if (!checking) fireAndForget(copySetupURIFull(host, log));
-                return true;
-            },
+            callback: () => fireAndForget(copySetupURIFull(host, log)),
         });
 
         host.services.context.events.onEvent(EVENT_REQUEST_COPY_SETUP_URI, () =>

src/serviceFeatures/setupObsidian/setupUri.unit.spec.ts

@@ -156,57 +156,4 @@ describe("setupObsidian/setupUri", () => {
         expect(addCommand).toHaveBeenCalledWith(expect.objectContaining({ id: "livesync-copysetupurifull" }));
         expect(onEventSpy).toHaveBeenCalledWith(EVENT_REQUEST_COPY_SETUP_URI, expect.any(Function));
     });
-
-    it("shows Setup URI variants only when their configuration level is relevant", async () => {
-        const addHandler = vi.fn();
-        const commands: Array<{
-            id: string;
-            checkCallback?: (checking: boolean) => boolean | void;
-        }> = [];
-        const settings = {
-            isConfigured: false,
-            usePluginSync: false,
-            useAdvancedMode: false,
-        };
-        const host = {
-            services: {
-                context: createServiceContext(),
-                API: {
-                    addCommand: vi.fn((command) => commands.push(command)),
-                    addLog: vi.fn(),
-                },
-                appLifecycle: {
-                    onLoaded: {
-                        addHandler,
-                    },
-                },
-                setting: {
-                    currentSettings: vi.fn(() => settings),
-                },
-                UI: {
-                    confirm: {
-                        askString: vi.fn(() => "pass"),
-                    },
-                    promptCopyToClipboard: vi.fn(() => true),
-                },
-            },
-        } as any;
-
-        useSetupURIFeature(host);
-        const loadedHandler = addHandler.mock.calls[0][0] as () => Promise<boolean>;
-        await loadedHandler();
-
-        const command = (id: string) => commands.find((candidate) => candidate.id === id)!;
-        expect(command("livesync-copysetupuri").checkCallback?.(true)).toBe(false);
-
-        settings.isConfigured = true;
-        expect(command("livesync-copysetupuri").checkCallback?.(true)).toBe(true);
-        expect(command("livesync-copysetupuri-short").checkCallback?.(true)).toBe(false);
-        expect(command("livesync-copysetupurifull").checkCallback?.(true)).toBe(false);
-
-        settings.usePluginSync = true;
-        settings.useAdvancedMode = true;
-        expect(command("livesync-copysetupuri-short").checkCallback?.(true)).toBe(true);
-        expect(command("livesync-copysetupurifull").checkCallback?.(true)).toBe(true);
-    });
 });

src/serviceFeatures/useP2PReplicatorUI.ts

@@ -67,12 +67,7 @@ export function useP2PReplicatorUI(
         showWindow: (type: string) => Promise<void>;
         showWindowOnRight?: (type: string) => Promise<void>;
         registerWindow: (type: string, factory: (leaf: WorkspaceLeaf) => unknown) => void;
-        addCommand: (command: {
-            id: string;
-            name: string;
-            callback?: () => void;
-            checkCallback?: (checking: boolean) => boolean | void;
-        }) => unknown;
+        addCommand: (command: { id: string; name: string; callback: () => void }) => unknown;
         addRibbonIcon: (
             icon: string,
             title: string,
@@ -151,12 +146,8 @@ export function useP2PReplicatorUI(
         api.addCommand({
             id: "open-p2p-server-status",
             name: "P2P Sync : Open P2P Status",
-            checkCallback: (checking) => {
-                if (!hasP2PConfiguration(host.services.setting.currentSettings())) return false;
-                if (!checking) {
-                    void openStatusPane();
-                }
-                return true;
+            callback: () => {
+                void openStatusPane();
             },
         });
         host.services.API.addCommand({
@@ -164,15 +155,11 @@ export function useP2PReplicatorUI(
             name: "Replicate P2P to default peer",
             checkCallback: (isChecking: boolean) => {
                 const settings = host.services.setting.currentSettings();
-                const isAvailable =
-                    hasP2PConfiguration(settings) &&
-                    settings.remoteType !== REMOTE_P2P &&
-                    (replicator.replicator?.server?.isServing ?? false);
-                if (!isAvailable) return false;
-                if (!isChecking) {
-                    runOpenReplication();
+                if (isChecking) {
+                    if (settings.remoteType == REMOTE_P2P) return false;
+                    return replicator.replicator?.server?.isServing ?? false;
                 }
-                return true;
+                runOpenReplication();
             },
         });
         host.services.API.addCommand({
@@ -180,15 +167,11 @@ export function useP2PReplicatorUI(
             name: "Replicate now by P2P",
             checkCallback: (isChecking: boolean) => {
                 const settings = host.services.setting.currentSettings();
-                const isAvailable =
-                    hasP2PConfiguration(settings) &&
-                    settings.remoteType !== REMOTE_P2P &&
-                    (replicator.replicator?.server?.isServing ?? false);
-                if (!isAvailable) return false;
-                if (!isChecking) {
-                    runOpenReplication();
+                if (isChecking) {
+                    if (settings.remoteType == REMOTE_P2P) return false;
+                    return replicator.replicator?.server?.isServing ?? false;
                 }
-                return true;
+                runOpenReplication();
             },
         });
 
@@ -196,14 +179,10 @@ export function useP2PReplicatorUI(
             id: "p2p-sync-targets",
             name: "P2P: Sync with targets",
             checkCallback: (isChecking: boolean) => {
-                const isAvailable =
-                    hasP2PConfiguration(host.services.setting.currentSettings()) &&
-                    (replicator.replicator?.server?.isServing ?? false);
-                if (!isAvailable) return false;
-                if (!isChecking) {
-                    void replicator.replicator?.replicateFromCommand(true);
+                if (isChecking) {
+                    return replicator.replicator?.server?.isServing ?? false;
                 }
-                return true;
+                void replicator.replicator?.replicateFromCommand(true);
             },
         });
 

src/serviceFeatures/useP2PReplicatorUI.unit.spec.ts

@@ -85,12 +85,7 @@ describe("useP2PReplicatorUI commands", () => {
                     onSettingLoaded: { addHandler: vi.fn() },
                     onLayoutReady: { addHandler: vi.fn() },
                 },
-                setting: {
-                    currentSettings: vi.fn(() => ({
-                        remoteType: "COUCHDB",
-                        P2P_Enabled: true,
-                    })),
-                },
+                setting: { currentSettings: vi.fn(() => ({ remoteType: "COUCHDB" })) },
                 replicator: { runFiniteReplicationActivity },
             },
         } as any;
@@ -148,11 +143,7 @@ describe("useP2PReplicatorUI commands", () => {
     });
 
     it("retains only the current P2P status command and routes existing open requests to it", async () => {
-        const commands: Array<{
-            id: string;
-            callback?: () => void;
-            checkCallback?: (checking: boolean) => boolean | void;
-        }> = [];
+        const commands: Array<{ id: string; callback?: () => void }> = [];
         let initialise: (() => Promise<unknown>) | undefined;
         const showWindow = vi.fn(async () => undefined);
         const showWindowOnRight = vi.fn(async () => undefined);
@@ -192,90 +183,12 @@ describe("useP2PReplicatorUI commands", () => {
 
         expect(commands.map((command) => command.id)).not.toContain("open-p2p-replicator");
         expect(commands.map((command) => command.id)).toContain("open-p2p-server-status");
-        expect(commands.find((command) => command.id === "open-p2p-server-status")?.checkCallback?.(true)).toBe(false);
 
         eventHub.emitEvent(EVENT_REQUEST_OPEN_P2P);
         await vi.waitFor(() => expect(showWindowOnRight).toHaveBeenCalledWith("p2p-status"));
         expect(showWindow).not.toHaveBeenCalledWith("p2p");
     });
 
-    it("shows P2P commands only when a P2P configuration exists and their runtime prerequisites are met", async () => {
-        const commands: Array<{
-            id: string;
-            checkCallback?: (checking: boolean) => boolean | void;
-        }> = [];
-        let initialise: (() => Promise<unknown>) | undefined;
-        let settings: Record<string, unknown> = {
-            remoteType: "COUCHDB",
-            remoteConfigurations: {},
-        };
-        const host = {
-            services: {
-                context: createServiceContext(),
-                API: {
-                    showWindow: vi.fn(async () => undefined),
-                    showWindowOnRight: vi.fn(async () => undefined),
-                    registerWindow: vi.fn(),
-                    addCommand: vi.fn((command) => commands.push(command)),
-                    addRibbonIcon: vi.fn(),
-                },
-                appLifecycle: {
-                    onInitialise: {
-                        addHandler: vi.fn((handler) => {
-                            initialise = handler;
-                        }),
-                    },
-                    onSettingLoaded: { addHandler: vi.fn() },
-                    onLayoutReady: { addHandler: vi.fn() },
-                },
-                setting: {
-                    currentSettings: vi.fn(() => settings),
-                    onSettingSaved: { addHandler: vi.fn() },
-                },
-                replicator: { runFiniteReplicationActivity: vi.fn() },
-            },
-        } as any;
-        const p2p = {
-            replicator: {
-                server: { isServing: true },
-                openReplication: vi.fn(),
-                replicateFromCommand: vi.fn(),
-            },
-        } as any;
-
-        useP2PReplicatorUI(host, {} as any, p2p);
-        await initialise?.();
-
-        for (const commandId of [
-            "open-p2p-server-status",
-            "replicate-now-by-p2p-default-peer",
-            "replicate-now-by-p2p",
-            "p2p-sync-targets",
-        ]) {
-            expect(commands.find(({ id }) => id === commandId)?.checkCallback?.(true)).toBe(false);
-        }
-
-        settings = {
-            ...settings,
-            remoteConfigurations: {
-                peer: {
-                    id: "peer",
-                    name: "Peer",
-                    uri: "sls+p2p://room?passphrase=secret",
-                    isEncrypted: false,
-                },
-            },
-        };
-        for (const commandId of [
-            "open-p2p-server-status",
-            "replicate-now-by-p2p-default-peer",
-            "replicate-now-by-p2p",
-            "p2p-sync-targets",
-        ]) {
-            expect(commands.find(({ id }) => id === commandId)?.checkCallback?.(true)).toBe(true);
-        }
-    });
-
     it("does not open the P2P status pane automatically when the workspace becomes ready", async () => {
         let layoutReady: (() => Promise<unknown>) | undefined;
         const showWindow = vi.fn(async () => undefined);

styles.css

@@ -12,11 +12,6 @@
     background-color: var(--text-muted);
 }
 
-.vpk-action-dialog__message {
-    user-select: text;
-    -webkit-user-select: text;
-}
-
 .conflict-dev-name {
     display: inline-block;
     min-width: 5em;
@@ -360,10 +355,6 @@ body {
     justify-content: center;
 }
 
-body:not(.is-mobile):has(.sls-setting) .notice:has(.sls-onboarding-invitation-action) {
-    margin-right: 96px;
-}
-
 .sls-review-harness {
     box-sizing: border-box;
     max-width: 100%;
@@ -600,98 +591,6 @@ body.is-mobile .livesync-compatibility-review-notice {
     word-break: break-all;
 }
 
-.sls-repair-results {
-    display: grid;
-    gap: var(--size-4-3);
-}
-
-.sls-repair-result {
-    padding: var(--size-4-3);
-    border: 1px solid var(--background-modifier-border);
-    border-radius: var(--radius-m);
-    background: var(--background-secondary);
-}
-
-.sls-repair-header {
-    display: flex;
-    align-items: flex-start;
-    justify-content: space-between;
-    gap: var(--size-4-2);
-    min-width: 0;
-}
-
-.sls-repair-header > :first-child {
-    flex: 1 1 auto;
-    min-width: 0;
-}
-
-.sls-repair-header h6 {
-    margin: 0;
-    overflow-wrap: anywhere;
-}
-
-.sls-repair-status {
-    display: flex;
-    flex-wrap: wrap;
-    gap: var(--size-4-2);
-    margin-top: var(--size-4-1);
-    font-size: var(--font-ui-smaller);
-}
-
-.sls-repair-status-ok {
-    color: var(--text-success);
-}
-
-.sls-repair-status-warning {
-    color: var(--text-warning);
-}
-
-.sls-repair-metric {
-    margin-top: var(--size-4-1);
-    font-size: var(--font-ui-smaller);
-    line-height: var(--line-height-tight);
-    overflow-wrap: anywhere;
-}
-
-.sls-repair-action-menu {
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    min-width: var(--clickable-icon-size);
-    width: var(--clickable-icon-size);
-    height: var(--clickable-icon-size);
-    padding: 0;
-}
-
-.sls-repair-action-menu .svg-icon {
-    width: 18px;
-    height: 18px;
-}
-
-.sls-repair-revision {
-    margin-top: var(--size-4-2);
-    padding: var(--size-4-2);
-    border-left: 3px solid var(--background-modifier-border);
-    background: var(--background-primary-alt);
-}
-
-.sls-repair-revision-title {
-    font-weight: var(--font-semibold);
-    overflow-wrap: anywhere;
-}
-
-.sls-repair-revision code {
-    display: block;
-    margin-top: var(--size-4-1);
-    overflow-wrap: anywhere;
-    white-space: normal;
-}
-
-.sls-repair-ancestor-warning {
-    margin-top: var(--size-4-2);
-    color: var(--text-warning);
-}
-
 /* Diff navigation */
 .diff-options-row {
     display: flex;

test/e2e-obsidian/README.md

@@ -7,12 +7,12 @@ The generic application discovery, isolated-vault, plug-in installation, process
 The current smoke runner verifies the launch path and the loaded plug-in's Service Context composition:
 
 1. create a temporary vault,
-2. install the built Self-hosted LiveSync plug-in artefacts,
+2. install the built Self-hosted LiveSync plug-in artifacts,
 3. launch real Obsidian,
 4. open the temporary vault through `obsidian-cli`,
-5. prepare the isolated Vault trust state and handle any Obsidian trust prompt,
-6. preserve natural plug-in loading, or complete requested pre-load work before loading the plug-in once in controlled start-up,
-7. verify through the active renderer that the plug-in is loaded,
+5. enable Obsidian community plug-ins for the temporary app profile,
+6. reload Self-hosted LiveSync through `obsidian-cli`,
+7. verify through `obsidian-cli eval` that the plug-in is loaded,
 8. observe event and translation results from the actual `ObsidianServiceContext`,
 9. verify that the Service Hub and every exposed service retain that exact Context,
 10. optionally drive a real vault or CouchDB workflow through Obsidian's own API, and
@@ -24,32 +24,12 @@ Obsidian 1.12 stores the global community plug-in switch outside `.obsidian/comm
 
 Future workflows should use `startObsidianLiveSyncSession()` from `runner/session.ts` rather than repeating the launch and plug-in readiness sequence. Add generic Obsidian bootstrap improvements to Fancy Kit; keep LiveSync behaviour and scenario helpers here.
 
-When a LiveSync-owned scenario must establish application state before the plug-in's first load, pass an instance-scoped `lifecycle.beforePluginStart` callback through that wrapper. For example, the P2P pane scenario calls `setObsidianMobileTestModeBeforePluginStart()` there so LiveSync observes the mobile application state while registering its command and view. Mobile emulation reopens Obsidian's workspace layout; this helper waits for both the `is-mobile` body state and `workspace.layoutReady` before controlled loading continues. The shared package owns the controlled start-up order and guarantees that the plug-in loads once; the LiveSync scenario owns the resulting command, workspace placement, and visible UI assertions. Changing the state only after loading the plug-in is not evidence of its mobile start-up behaviour.
-
 Each test vault uses an isolated Obsidian profile. The runner creates temporary directories for `HOME`, `XDG_CONFIG_HOME`, `XDG_CACHE_HOME`, `XDG_DATA_HOME`, and Electron `--user-data-dir`, writes the vault registry into those directories, pre-seeds the temporary Chromium local storage so community plug-ins are trusted for that generated vault ID, and passes the same environment to `obsidian-cli`. This is intended to keep real Obsidian E2E runs separate from a developer's daily Obsidian profile and vault registry.
 
 On macOS, `@vrtmrz/obsidian-test-session` keeps the generated Vault and profile below `/tmp` so Obsidian's Unix-domain CLI socket remains below the platform path limit. It also gives only the isolated Obsidian process Chromium's mock-keychain flag, preventing the empty test HOME from opening a blocking login-keychain dialogue. LiveSync's deterministic fixture selects the built-in default language so a host-language translation prompt cannot pause plug-in readiness. The case-only rename check enumerates the parent directory and compares exact spellings because an old-path lookup still resolves the renamed file on the default case-insensitive macOS filesystem.
 
 Multi-session workflows must keep each started Obsidian session tracked until its stop operation completes. If a scenario throws, teardown stops every active session before disposing its temporary Vault and profile, so a failed CLI or synchronisation operation cannot leave Obsidian using directories which have already been removed.
 
-## Observing and diagnosing a scenario
-
-Use externally visible behaviour as the pass condition: Vault files, remote-service state, revision data, or visible Obsidian UI. A log line can explain a failure, but should not replace an assertion about the resulting behaviour.
-
-The maintained runner provides several complementary observation paths:
-
-- `evalObsidianJson()` and `obsidian-cli eval` can read a small, explicitly selected piece of LiveSync or Obsidian state.
-- `withObsidianPage()` can inspect the active renderer, invoke a registered command, or interact with visible UI through CDP. `captureObsidianPage()`, `captureObsidianDialogue()`, and `captureObsidianElement()` retain screenshots; the capture helpers also write a full-page `.failure.png` before rethrowing a UI assertion failure.
-- `session.app.output()` returns the standard output and standard error captured from the isolated Obsidian process. This is especially useful when the renderer or CLI becomes unreachable.
-- **Show log** (`obsidian-livesync:view-log`) exposes the recent LiveSync log, while **Copy full report to clipboard** (`obsidian-livesync:dump-debug-info`) opens the generated diagnostic report. `dialog-mounts.ts` verifies both surfaces, and focused scenarios may inspect the log pane and `appLifecycle.getUnresolvedMessages()` for a bounded set of expected errors.
-- Renderer `console` messages and uncaught page errors are not retained automatically. A focused investigation can attach `page.on("console", ...)` and `page.on("pageerror", ...)` while it owns a `withObsidianPage()` callback. That observer ends when the callback closes its CDP connection, so use it around the action under investigation rather than treating it as a session-wide audit trail.
-
-If a scenario times out or appears to do nothing, capture the visible page before teardown, then record a bounded state snapshot and the relevant tail of the LiveSync log, unresolved messages, and process output. If an unexplained Notice appears, retain a screenshot while it is still visible before opening or dismissing it, then use the log or full report to identify its source. A Notice alone is not enough evidence for its cause.
-
-Set `showVerboseLog: true` only in isolated plug-in data when a focused investigation needs it. Keep captured output short and redact it before retaining or sharing it: logs and reports can contain Vault paths, document names, endpoints, credentials, Setup URIs, passphrases, or Security Seed material. Do not collect verbose logs from an ordinary user Vault.
-
-Collect evidence before cleanup, and keep process, Vault, profile, and remote-fixture cleanup in `finally`. After `app.emulateMobile(true)`, use the active CDP renderer for fixture operations because Obsidian may remove desktop-only CLI commands. Visually inspect screenshots before copying selected images into user documentation; a passing locator assertion does not establish that a dialogue is readable or unobstructed.
-
 ## Local Setup
 
 Set `OBSIDIAN_BINARY` when Obsidian is not installed in a standard location. Set `OBSIDIAN_CLI` as well when its companion executable is outside the built-in discovery paths.
@@ -75,7 +55,6 @@ After changing plug-in source, use the focused wrapper rather than invoking a sc
 ```bash
 npm run test:e2e:obsidian:focused -- settings-ui
 npm run test:e2e:obsidian:focused -- two-vault-sync
-npm run test:e2e:obsidian:focused -- security-seed-reconnect
 ```
 
 The wrapper accepts only maintained real-Obsidian scenario names; run it with `--help` for the current list. It deliberately does not manage CouchDB, Object Storage, or the P2P signalling relay. Start the required fixture first, or use the complete service-managed suite.
@@ -102,7 +81,7 @@ The underlying `test:e2e:obsidian:<scenario>` scripts remain available for an im
 
 `test:contract:context:cli` builds the Node CLI and runs its existing Deno setup, put, read, list, information, remove, conflict-resolution, and revision workflow. `test:contract:context:obsidian` builds the plug-in and runs the real-Obsidian smoke test, including the Context inspection. These runtime scripts are local validation entry points and are not added to the default CI gate by this change.
 
-`test:e2e:obsidian:onboarding-invitation` starts an unconfigured temporary Vault with no plug-in data and verifies that startup selects Commonlib's new-Vault recommendations, offers the setup wizard without opening it, and does not scan Vault files automatically. It checks the invitation action and introduction in mobile test mode, then reopens the wizard from **Self-hosted LiveSync settings** → **Setup** on the desktop. This scenario owns the unconfigured-startup boundary only; configured compatibility review remains covered by `settings-ui`, and the setup workflows remain covered by their dedicated scenarios.
+`test:e2e:obsidian:onboarding-invitation` starts an unconfigured temporary Vault with no plug-in data and verifies that startup selects Commonlib's new-Vault recommendations, offers the setup wizard without opening it, and does not scan Vault files automatically. It checks the invitation action and introduction in mobile test mode, then uses the permanent command to reopen the wizard on the desktop. This scenario owns the unconfigured-startup boundary only; configured compatibility review remains covered by `settings-ui`, and the setup workflows remain covered by their dedicated scenarios.
 
 `test:e2e:obsidian:dialog-mounts` starts a temporary real Obsidian session and exercises remote selection and CouchDB settings through `SetupManager`, plus Setup URI entry through the registered command. It verifies the compatibility pause and remote-size review, the distinction between a central data-storage server and P2P signalling, the explicit tested and untested CouchDB save actions, the internal-API warning, the Setup URI controls, automatic adjustment when differences are limited to compatible chunk settings, and both manual configuration-mismatch routes. The same session opens the live log and generated full report, reaches the `Hatch` recovery controls, writes and removes its own persistent log, and runs the missing-chunk recreation and file-verification actions against the empty disposable Vault. It captures representative desktop and mobile dialogues, checks the mobile layout and vertically stacked actions, closes each route through its normal controls, and verifies that each mounted operation settles without an error. It does not apply a remote configuration, contact a remote service, or claim to repair a deliberately damaged database.
 
@@ -112,9 +91,9 @@ The mobile pass uses Obsidian's `app.emulateMobile(true)`, a 390 by 844 CSS-pixe
 
 `test:e2e:obsidian:review-harness` exercises only the boundaries owned by the opt-in maintainer Harness. It retains a real compatibility pause, uses the fixed Harness restart action to persist a device-local continuation and reload Obsidian, and requires the Harness to delete that state before reopening. It also runs the bounded local observations, confirms the dedicated Vault fixture root is removed, captures the copied privacy-bounded Markdown report, and checks the Harness layout and touch targets in mobile test mode. Compatibility explanation and persistence details remain owned by `settings-ui`, real P2P transfer remains owned by the dedicated P2P suites, and general Vault reflection remains owned by `vault-reflection`; the Harness test does not duplicate those workflows.
 
-`test:e2e:obsidian:p2p-pane` starts one configured CouchDB-only session with no P2P profile and separate configured P2P sessions for desktop and mobile. It proves that the command remains registered while the retired command, automatic pane, and ribbon entry without a P2P configuration are absent. For the configured P2P profiles, it verifies that the desktop ribbon is available, the current status command reaches the pane without it opening at start-up, checks its connection control and horizontal layout, and captures unobstructed desktop and mobile screenshots. The mobile session uses a fresh Vault, profile, and Obsidian process, enters `app.emulateMobile(true)` through `lifecycle.beforePluginStart`, and requires the P2P view to belong to the right drawer rather than inheriting desktop workspace state. It deliberately uses no relay or peer: replacement of the active replicator is covered by focused unit tests, the Deno and Compose CLI P2P lifecycle suite covers the headless transport, and `p2p-setup-uri-workflow` owns the visible transfer path between two real Obsidian sessions.
+`test:e2e:obsidian:p2p-pane` starts one unconfigured CouchDB-only session and one configured P2P session. It proves that the command remains registered while the retired command, automatic pane, and unconfigured ribbon entry are absent. For the configured profile, it verifies that the ribbon and current status command reach the pane without opening it at start-up, checks its connection control and horizontal layout, and captures unobstructed desktop and mobile screenshots. It deliberately uses no relay or peer: replacement of the active replicator is covered by focused unit tests, the Deno and Compose CLI P2P lifecycle suite covers the headless transport, and `p2p-setup-uri-workflow` owns the visible transfer path between two real Obsidian sessions.
 
-`test:e2e:obsidian:local-suite` builds the plug-in and, unless `LIVESYNC_CLI_COMMAND` selects an external CLI, the local LiveSync CLI. It then runs discovery, smoke, the onboarding invitation, Svelte dialogue mounting, revision repair, settings UI, the Review Harness, the P2P status pane, Vault reflection, CouchDB upload and manual setup, CLI-to-Obsidian synchronisation, Object Storage upload and Setup URI round-trip, P2P Setup URI round-trip, startup scan, provisioned CouchDB Setup URI, two-vault synchronisation, Hidden File Sync, Customisation Sync, and setting Markdown export in sequence. Start the local CouchDB, MinIO, and P2P relay fixtures before running it, or use `test:e2e:obsidian:local-suite:services` to let the wrapper stop leftover fixtures, start fresh fixtures, and stop them again after the run.
+`test:e2e:obsidian:local-suite` builds the plug-in and, unless `LIVESYNC_CLI_COMMAND` selects an external CLI, the local LiveSync CLI. It then runs discovery, smoke, the onboarding invitation, Svelte dialogue mounting, settings UI, the Review Harness, the P2P status pane, Vault reflection, CouchDB upload and manual setup, CLI-to-Obsidian synchronisation, Object Storage upload and Setup URI round-trip, P2P Setup URI round-trip, startup scan, provisioned CouchDB Setup URI, two-vault synchronisation, Hidden File Sync, Customisation Sync, and setting Markdown export in sequence. Start the local CouchDB, MinIO, and P2P relay fixtures before running it, or use `test:e2e:obsidian:local-suite:services` to let the wrapper stop leftover fixtures, start fresh fixtures, and stop them again after the run.
 
 `test:e2e:obsidian:couchdb-upload` reuses the CouchDB variables from `.test.env` or the process environment. It expects a reachable CouchDB service, creates a unique database, starts from configured plug-in data without the device-local compatibility marker, and verifies the copied-or-restored Vault explanation in the actual compatibility dialogue. It captures the summary and details, resumes explicitly, confirms that the marker was recorded, creates a note in real Obsidian, commits the note into the local database, runs one-shot synchronisation, and verifies that the remote database contains both the metadata document and its chunk documents.
 
@@ -122,14 +101,12 @@ The same workflow checks the two remote-activity status boundaries. It first hol
 
 `test:e2e:obsidian:couchdb-manual-setup-workflow` follows the visible onboarding path for the first device when no Setup URI is available. It enters end-to-end encryption and CouchDB details, runs the read-only `Check server requirements` step, requires the prepared fixture to pass without applying a server fix, and lets the onboarding connection test create the named database. After Rebuild completes on the first device, it creates an ordinary note, asks that working device to generate a Setup URI for a second device, completes Fetch there, and verifies a bidirectional note round-trip. The workflow captures each decision point and the expanded server-check result; password controls remain visually masked.
 
-If this status workflow fails while Obsidian is running, it writes a full-page screenshot and a JSON snapshot of the status text and counters under `/tmp/obsidian-livesync-e2e`. The dialogue-mount workflow leaves desktop and mobile screenshots for both representative Svelte routes, the Hidden File Sync workflow captures the successfully displayed JSON Resolve dialogue before selecting an option, and the Security Seed reconnect workflow captures each significant application state. The suite therefore records representative evidence without capturing every interaction. Set `E2E_OBSIDIAN_DIAGNOSTICS_DIR` to use another directory.
+If this status workflow fails while Obsidian is running, it writes a full-page screenshot and a JSON snapshot of the status text and counters under `/tmp/obsidian-livesync-e2e`. The dialogue-mount workflow leaves desktop and mobile screenshots for both representative Svelte routes, and the Hidden File Sync workflow captures the successfully displayed JSON Resolve dialogue before selecting an option. The suite therefore records representative evidence without capturing every interaction. Set `E2E_OBSIDIAN_DIAGNOSTICS_DIR` to use another directory.
 
 The two-Vault workflow performs the missing-marker review once for each isolated Vault. Later process launches reuse the same profile-backed acknowledgement, rather than seeding a replacement or repeatedly applying a decision for the first device. The Hidden File Sync scenario is narrower: it starts from an explicitly acknowledged marker because it tests consumer-owned hidden-file behaviour, JSON resolution, target filtering, and grouped mobile Notices rather than duplicating the compatibility workflow. After `app.emulateMobile(true)`, its fixture operations use the active DevTools renderer because Obsidian can remove desktop-only CLI commands in mobile mode.
 
 `test:e2e:obsidian:cli-to-obsidian-sync` is the cross-runtime compatibility check for the official LiveSync CLI and the real Obsidian plug-in. Build the plug-in first, and build the local CLI too when no external CLI command is selected. The script uses E2EE, Path Obfuscation, and the current preferred chunk settings to create and synchronise a note through the CLI, starts real Obsidian with an isolated Vault and profile, synchronises the same CouchDB database, and verifies that the plug-in materialises identical note content. This covers the boundary that CLI-only and plug-in-only round trips do not exercise.
 
-The isolated Obsidian session starts with its CouchDB settings and device-local compatibility acknowledgement already in place. This keeps the scenario focused on cross-runtime data compatibility; unconfigured start-up and visible CouchDB onboarding are covered by their dedicated workflows.
-
 By default, the compatibility check runs `node src/apps/cli/dist/index.cjs`. Set `LIVESYNC_CLI_COMMAND` to test another CLI build or distribution. The value may be a quoted command line or a JSON array of executable and prefix arguments; the scenario arguments are appended without going through a shell.
 
 For example, to test an executable on `PATH`:
@@ -145,28 +122,20 @@ LIVESYNC_CLI_COMMAND="docker run --rm --network host --user $(id -u):$(id -g) --
   npm run test:e2e:obsidian:cli-to-obsidian-sync
 ```
 
-`test:e2e:obsidian:minio-upload` reuses the Object Storage variables from `.test.env` or the process environment. It expects a reachable S3-compatible service and starts with isolated Object Storage settings and the device-local compatibility acknowledgement already in place, keeping the scenario focused on upload rather than unconfigured start-up or setup. It confirms those settings through `obsidian-cli eval`, creates a note in real Obsidian, runs one-shot Journal Sync, and verifies through the AWS SDK that objects were written under a unique bucket prefix. Adapter tests separately observe an in-progress SDK command, while this real-runtime workflow verifies the resulting request counters advance and rebalance.
+`test:e2e:obsidian:minio-upload` reuses the Object Storage variables from `.test.env` or the process environment. It expects a reachable S3-compatible service, configures Self-hosted LiveSync for Object Storage through `obsidian-cli eval`, creates a note in real Obsidian, runs one-shot Journal Sync, and verifies through the AWS SDK that objects were written under a unique bucket prefix. Adapter tests separately observe an in-progress SDK command, while this real-runtime workflow verifies the resulting request counters advance and rebalance.
 
 `test:e2e:obsidian:object-storage-setup-uri-workflow` uses the public Commonlib-backed tool to generate the initial Setup URI for a unique MinIO prefix, completes visible initialisation on the first device, and then asks that working real Obsidian device to create a new Setup URI through the registered command. A second real Obsidian device imports only the device-generated URI. The workflow verifies A-to-B and B-to-A notes, captures the documented onboarding choices, and removes the Object Storage prefix only after both sessions have stopped.
 
 `test:e2e:obsidian:p2p-setup-uri-workflow` runs two concurrent isolated real Obsidian sessions against the local Compose Nostr relay fixture. The first device imports a generated initial Setup URI and completes its signalling test with zero peers, creates a Setup URI for the second device through the registered command, and remains online while the second device imports it. The second device must select the expected online source before Fetch can rebuild its local database. The workflow accepts each connection request visibly on the receiving device, verifies the initial A-to-B fetch, checks that the menu for the three persistent per-peer actions remains within the viewport, reconnects both P2P sessions in join order, and verifies the B-to-A return journey. Every started session remains tracked until teardown completes.
 
-`test:e2e:obsidian:startup-scan` starts from a CouchDB fixture using current settings with its device-local compatibility marker already acknowledged, stops Obsidian, writes a note directly into the Vault, restarts the same isolated Vault and profile without rewriting its plug-in data, and verifies from CouchDB that the start-up scan picked up the offline file. Onboarding remains covered by `onboarding-invitation`; this scenario owns the ordinary configured restart and start-up scan.
+`test:e2e:obsidian:startup-scan` configures a temporary CouchDB database, stops Obsidian, writes a note directly into the vault, restarts Obsidian, and verifies from CouchDB that the boot-time scan picked up the offline file.
 
 `test:e2e:obsidian:setup-uri-workflow` runs the repository's public Commonlib-backed CouchDB provisioning and Setup URI tools against the local CouchDB fixture. It configures a new, empty Vault in the first real Obsidian session through the visible onboarding wizard and uses Rebuild. After that device is working, it generates a new Setup URI through the registered command; the second real Obsidian Vault uses that URI for Fetch instead of reusing the initial Setup URI produced by the provisioning tool. The workflow verifies ordinary notes from the first device to the second and back again, independently enables Hidden File Sync on each device, and verifies a snippet. The retained Setup URI screenshots show only encrypted URIs and visually masked Setup URI passphrases; plaintext credentials are not captured. Files prefixed with `guide-` capture the relevant dialogue, settings panel, or workspace leaf without transient Notices. Public documentation copies selected images only after visual inspection; the E2E run does not overwrite repository documentation assets.
 
 `test:e2e:obsidian:two-vault-sync` runs a two-vault note synchronisation workflow. It verifies note creation, update, ordinary rename, a case-only file name change within the same directory, deletion, and a separate encrypted round-trip with Path Obfuscation enabled. Its target-filter scenario confirms that one Vault receives and checkpoints a remote document without reflecting it, restarts with the same profile and filter, and then reflects the stored document after the filter is broadened through the settings service. Directory case changes deliberately remain outside this scenario because they require directory-aware rename handling. The optional Markdown conflict check can be enabled with `E2E_OBSIDIAN_INCLUDE_MARKDOWN_CONFLICT=true`. It creates divergent revisions in two separate Vaults, performs a conservative merge on one Vault, edits that result again, and requires the other Vault to replace its known deleted losing revision without recreating the conflict. The separate `E2E_OBSIDIAN_INCLUDE_CONFLICT_OPERATIONS=true` check keeps four conflicts active while one Vault edits, deletes, performs a case-only rename, and performs a cross-path rename. It asserts that each operation extends the revision displayed on that device, replicates the exact resulting revision tree, and preserves the other live branch. During focused development, `E2E_OBSIDIAN_ONLY_CONFLICT_OPERATIONS=true` runs that self-contained scope without the ordinary, target-filter, or encrypted scenarios. Both conflict checks remain outside the default local suite.
 
-`test:e2e:obsidian:security-seed-reconnect` is a focused CouchDB release-acceptance workflow. Device A first recognises an initial remote Security Seed, stops automatic replication while remaining open, and creates an unsent note. The runner replaces only the Security Seed in the managed remote synchronisation-parameter fixture. Device A must retain its deliberately stale cached value until the next one-shot synchronisation, refresh it before sending, and upload an HKDF-encrypted payload which uses the replacement value. A fresh device B must decrypt that note and send an encrypted note back; the original device A then receives the return journey with its Vault and isolated profile preserved. Desktop Obsidian may enforce a single application instance, so the two device sessions run sequentially after the same-process stale-cache assertion has completed.
-
-The workflow creates a random dedicated database, records only SHA-256 Seed fingerprints, and never writes a Seed, passphrase, or CouchDB credentials to its result. It also requires the remote Seed and all other synchronisation parameters to remain unchanged after the replacement revision, rejects HKDF and Seed errors from either session, writes `security-seed-reconnect-result.json`, and verifies that every Obsidian process, temporary Vault, isolated profile, and database has been removed. The result file and stage screenshots are retained in `E2E_OBSIDIAN_DIAGNOSTICS_DIR`; the screenshots show ordinary Vault content, not settings or secrets. The strict cleanup workflow rejects `E2E_OBSIDIAN_KEEP_VAULT` and `E2E_OBSIDIAN_KEEP_COUCHDB`.
-
-This proves in real Obsidian the plug-in behaviour shared by supported platforms, including the encrypted bidirectional round-trip and protection against a stale client restoring the old remote Seed. It does not verify iPadOS-specific background or reconnect lifecycle behaviour, and it does not count as Android device evidence. The workflow remains outside `test:e2e:obsidian:local-suite` because it is a focused release-acceptance check.
-
 `test:e2e:obsidian:conflict-dialog-policy` creates three real local revision leaves without a remote service and opens the pairwise merge dialogue in Obsidian. It verifies the three-version count, requires the four decision buttons to be stacked vertically, concatenates the displayed pair as a child of the displayed winner, confirms that the untouched leaf remains as one conflict, postpones that remaining pair, restarts the same isolated Vault and profile, and confirms that only the two live versions are reconstructed. It also verifies that an ordinary repeated conflict check does not reopen a postponed dialogue, that **Resolve if conflicted.** explicitly reopens it, and that the active editor retains the appropriate unresolved-conflict warning. The scenario then invokes the same Commonlib consumer boundary used for an incoming replicated document and checks that a postponed warning disappears, an open stale dialogue closes, and the conflict-processing queue completes even when the dialogue closes immediately. This isolates the Obsidian UI contract from transport and second-device setup. The fixture owns one temporary Vault and profile, and the session runner stops Obsidian before removing them.
 
-`test:e2e:obsidian:revision-repair` creates an ordinary healthy logical deletion and two conflicting live revisions in a temporary real Obsidian Vault, then removes a chunk used only by the non-winning revision. It proves that automatic conflict checking does not discard the unreadable branch, and that a healthy logical deletion with no Vault file is neither reported nor retained as Vault provenance. **Inspect conflicts and file/database differences** must show the winner and conflict separately, identify the exact unreadable revision and missing chunk, show the compact `Δsize` and `Δtime` diagnostics, and expose a wrench menu with the appropriate actions for each branch. The scenario opens the existing comparison dialogue in read-only mode, applies the readable winner to the Vault, shows the compact matching-winner and remaining-conflict status, records the exact winner as Vault provenance without creating a child, and confirms that retrying the unreadable branch leaves the revision tree unchanged. It then verifies both the cancellation path and the explicit confirmation path for discarding only that selected live branch, requires the winner and its Vault provenance to remain unchanged, and captures the repair card, a 360-pixel-wide reflow check, the matching-winner status, both revision menus, and the read-only comparison. The narrow capture checks responsive layout, not a mobile operating-system lifecycle. The scenario uses no remote service; a retry is therefore expected to remain unreadable unless the chunk is already available locally.
-
 `test:e2e:obsidian:hidden-file-snippet-sync` runs a two-vault hidden file round-trip. It verifies creation and deletion of a real `.obsidian/snippets/*.css` file, automatic JSON conflict merging for a hidden file with the merged result propagated by a second synchronisation, manual JSON Resolve dialogue application through Obsidian's UI, and per-device target patterns where one vault ignores a hidden file that the other vault synchronises. Initial enablement must open one user-visible progress Notice before the enabled setting is saved, then retain that Notice while its nested rebuild and scan phases continue in the ordinary log. The configured fixture starts with a current CouchDB remote profile, so migration from legacy remote settings remains the responsibility of the upgrade scenarios and cannot add unrelated Notices to this check. It also covers [issue #555](https://github.com/vrtmrz/obsidian-livesync/issues/555) by requiring several plug-in and settings changes to share one separate action Notice whose controls remain usable in mobile layouts; a manually dismissed group must not repeat its acknowledged rows when a later change arrives.
 
 `test:e2e:obsidian:customisation-sync` runs a two-vault Customisation Sync workflow. It scans a real snippet CSS file, config JSON file, and sample plug-in fixture into per-file Customisation Sync data, synchronises the entries through CouchDB, applies them on the second vault, verifies the resulting `.obsidian` files, propagates a snippet update, and verifies deletion of the source-vault snippet sync data without confusing it with the target vault's own applied copy.
@@ -218,7 +187,6 @@ Useful environment variables:
 - `E2E_OBSIDIAN_SKIP_EXTRACT=true`: download the AppImage without extracting it.
 - `E2E_OBSIDIAN_SMOKE_TIMEOUT_MS`: smoke timeout in milliseconds.
 - `E2E_OBSIDIAN_DIALOG_TIMEOUT_MS`: timeout for a representative Svelte dialogue to mount, expose its principal controls, and close; default is 10 seconds.
-- `E2E_OBSIDIAN_REVISION_REPAIR_TIMEOUT_MS`: timeout for each visible revision-repair control and result; default is 15 seconds.
 - `E2E_OBSIDIAN_SETTINGS_TIMEOUT_MS`: timeout for the settings pane and its deletion controls to become visible; default is 10 seconds.
 - `E2E_OBSIDIAN_REVIEW_HARNESS_TIMEOUT_MS`: timeout for Review Harness view and action boundaries; default is 15 seconds.
 - `E2E_OBSIDIAN_P2P_PANE_TIMEOUT_MS`: timeout for the P2P status pane and its principal connection control; default is 10 seconds.
@@ -233,14 +201,12 @@ Useful environment variables:
 - `LIVESYNC_CLI_COMMAND`: optional LiveSync CLI executable and prefix arguments used by the CLI-to-Obsidian compatibility check. The default is the locally built CLI.
 - `E2E_LIVESYNC_SOURCE_ARTIFACT_ROOT`: optional cache directory containing the exact pinned 0.25.83 plug-in artefacts. Cached files are always checksum-verified.
 - `E2E_LIVESYNC_TARGET_ARTIFACT_ROOT`: directory containing the built 1.0 target `main.js`, `manifest.json`, and `styles.css`; default is the repository root.
-- `E2E_OBSIDIAN_ARTIFACT_ROOT`: directory containing the plug-in artefact installed by a direct scenario invocation; default is the repository root.
-- `E2E_OBSIDIAN_ARTIFACT_REVISION`: exact source commit recorded by the Security Seed reconnect result when `E2E_OBSIDIAN_ARTIFACT_ROOT` is a downloaded artefact rather than a Git worktree.
 - `E2E_OBSIDIAN_FILE_TIMEOUT_MS`: timeout for waiting until a note created through Obsidian's vault API is reflected to disk.
 - `E2E_OBSIDIAN_CORE_READY_TIMEOUT_MS`: timeout for waiting until Self-hosted LiveSync reports that its core lifecycle and local database are ready.
 - `E2E_OBSIDIAN_LOCAL_DB_TIMEOUT_MS`: timeout for waiting until a file appears in Self-hosted LiveSync's local database.
 - `E2E_OBSIDIAN_COUCHDB_TIMEOUT_MS`: timeout for waiting until CouchDB contains uploaded E2E documents.
 - `E2E_OBSIDIAN_REMOTE_ACTIVITY_TIMEOUT_MS`: timeout for an observed remote activity to enter or leave its status boundary; default is 30 seconds.
-- `E2E_OBSIDIAN_DIAGNOSTICS_DIR`: directory for screenshots and status snapshots, including the Security Seed reconnect stages; default is `/tmp/obsidian-livesync-e2e`.
+- `E2E_OBSIDIAN_DIAGNOSTICS_DIR`: directory for screenshots and status snapshots captured after a remote-activity failure; default is `/tmp/obsidian-livesync-e2e`.
 - `E2E_OBSIDIAN_OBJECT_STORAGE_TIMEOUT_MS`: timeout for waiting until Object Storage contains uploaded E2E objects.
 - `E2E_OBSIDIAN_KEEP_COUCHDB=true`: keep the temporary CouchDB database for inspection.
 - `E2E_OBSIDIAN_KEEP_OBJECT_STORAGE=true`: keep the temporary Object Storage prefix for inspection.

test/e2e-obsidian/runner/couchdb.ts

@@ -42,12 +42,6 @@ export type CouchDbDatabaseInfo = {
     update_seq: number | string;
 };
 
-export type CouchDbPutResponse = {
-    ok: boolean;
-    id: string;
-    rev: string;
-};
-
 function parseEnvFile(content: string): Record<string, string> {
     const entries = content
         .split(/\r?\n/u)
@@ -85,14 +79,6 @@ function databaseUrl(config: Pick<CouchDbConfig, "uri">, dbName: string, suffix
     return `${config.uri.replace(/\/+$/u, "")}/${encodeURIComponent(dbName)}${suffix}`;
 }
 
-function documentSuffix(documentId: string): string {
-    const localPrefix = "_local/";
-    if (documentId.startsWith(localPrefix)) {
-        return `/_local/${encodeURIComponent(documentId.slice(localPrefix.length))}`;
-    }
-    return `/${encodeURIComponent(documentId)}`;
-}
-
 async function couchDbRequest(
     config: Pick<CouchDbConfig, "uri" | "username" | "password">,
     path: string,
@@ -160,8 +146,8 @@ export async function putCouchDbDocument(
     config: CouchDbConfig,
     dbName: string,
     document: CouchDbDocument
-): Promise<CouchDbPutResponse> {
-    const response = await fetch(databaseUrl(config, dbName, documentSuffix(document._id)), {
+): Promise<void> {
+    const response = await fetch(databaseUrl(config, dbName, `/${encodeURIComponent(document._id)}`), {
         method: "PUT",
         headers: {
             authorization: authHeader(config),
@@ -174,23 +160,6 @@ export async function putCouchDbDocument(
             `Failed to write CouchDB document ${document._id}. HTTP ${response.status}: ${await response.text()}`
         );
     }
-    return (await response.json()) as CouchDbPutResponse;
-}
-
-export async function fetchCouchDbDocument(
-    config: CouchDbConfig,
-    dbName: string,
-    documentId: string
-): Promise<CouchDbDocument> {
-    const response = await fetch(databaseUrl(config, dbName, documentSuffix(documentId)), {
-        headers: { authorization: authHeader(config) },
-    });
-    if (!response.ok) {
-        throw new Error(
-            `Failed to read CouchDB document ${documentId}. HTTP ${response.status}: ${await response.text()}`
-        );
-    }
-    return (await response.json()) as CouchDbDocument;
 }
 
 export async function deleteCouchDbDatabase(config: CouchDbConfig, dbName: string): Promise<void> {
@@ -205,19 +174,6 @@ export async function deleteCouchDbDatabase(config: CouchDbConfig, dbName: strin
     }
 }
 
-export async function couchDbDatabaseExists(config: CouchDbConfig, dbName: string): Promise<boolean> {
-    const response = await fetch(databaseUrl(config, dbName), {
-        headers: { authorization: authHeader(config) },
-    });
-    if (response.status === 404) {
-        return false;
-    }
-    if (!response.ok) {
-        throw new Error(`Failed to inspect CouchDB ${dbName}. HTTP ${response.status}: ${await response.text()}`);
-    }
-    return true;
-}
-
 export async function fetchAllCouchDbDocs(config: CouchDbConfig, dbName: string): Promise<CouchDbAllDocsResponse> {
     const response = await fetch(databaseUrl(config, dbName, "/_all_docs?include_docs=true"), {
         headers: { authorization: authHeader(config) },

test/e2e-obsidian/runner/liveSyncWorkflow.test.ts

@@ -10,8 +10,6 @@ vi.mock("./cli.ts", () => ({ evalObsidianJson }));
 import {
     assertE2eCompatibilityMarker,
     createE2eCouchDbPluginData,
-    prepareRemote,
-    waitForLiveSyncCoreReady,
     type CompatibilityMarkerState,
 } from "./liveSyncWorkflow.ts";
 
@@ -56,40 +54,3 @@ describe("configured CouchDB fixture", () => {
         expect(pluginData.activeConfigurationId).toBe(Object.keys(remoteConfigurations ?? {})[0]);
     });
 });
-
-describe("Real Obsidian core readiness", () => {
-    it("retries while the plug-in core is temporarily unavailable during reload", async () => {
-        evalObsidianJson.mockReset();
-        evalObsidianJson
-            .mockRejectedValueOnce(new Error("Cannot read properties of undefined (reading 'core')"))
-            .mockResolvedValueOnce({
-                databaseReady: true,
-                appReady: true,
-                configured: true,
-                remoteType: "",
-                settingVersion: 10,
-                suspended: false,
-            });
-
-        await expect(waitForLiveSyncCoreReady("obsidian-cli", {}, 1000)).resolves.toMatchObject({
-            databaseReady: true,
-            appReady: true,
-        });
-        expect(evalObsidianJson).toHaveBeenCalledTimes(2);
-    });
-});
-
-describe("remote fixture preparation", () => {
-    it("waits for the remote Security Seed after resolving a new remote", async () => {
-        evalObsidianJson.mockReset();
-        evalObsidianJson.mockResolvedValueOnce({ status: "resolved", securitySeedReady: true });
-
-        await prepareRemote("obsidian-cli", {});
-
-        const evaluatedCode = String(evalObsidianJson.mock.calls[0]?.[1] ?? "");
-        expect(evaluatedCode.indexOf("markRemoteResolved")).toBeLessThan(
-            evaluatedCode.indexOf("ensurePBKDF2Salt")
-        );
-        expect(evaluatedCode).toContain("Timed out preparing the remote Security Seed");
-    });
-});

test/e2e-obsidian/runner/liveSyncWorkflow.ts

@@ -353,50 +353,31 @@ export async function waitForLiveSyncCoreReady(
 ): Promise<CoreReadiness> {
     const deadline = Date.now() + timeoutMs;
     let lastReadiness: CoreReadiness | undefined;
-    let lastError: unknown;
     while (Date.now() < deadline) {
-        try {
-            lastReadiness = await evalObsidianJson<CoreReadiness>(
-                cliBinary,
-                [
-                    "(async()=>{",
-                    "const core=app.plugins.plugins['obsidian-livesync']?.core;",
-                    "if(!core) return JSON.stringify({databaseReady:false,appReady:false});",
-                    "const settings=core.services.setting.currentSettings();",
-                    "return JSON.stringify({",
-                    "databaseReady:core.services.database.isDatabaseReady(),",
-                    "appReady:core.services.appLifecycle.isReady(),",
-                    "configured:settings?.isConfigured===true,",
-                    "remoteType:settings?.remoteType??'',",
-                    "settingVersion:settings?.settingVersion,",
-                    "suspended:core.services.appLifecycle.isSuspended(),",
-                    "});",
-                    "})()",
-                ].join(""),
-                env
-            );
-            lastError = undefined;
-        } catch (error) {
-            // Obsidian reloads the renderer while enabling the plug-in. During
-            // that short window the CLI can reach the Vault before the plug-in
-            // catalogue has exposed its core. This is a readiness state, not a
-            // failed scenario, so retain the error for the eventual timeout.
-            lastError = error;
-            await new Promise((resolve) => setTimeout(resolve, 500));
-            continue;
-        }
+        lastReadiness = await evalObsidianJson<CoreReadiness>(
+            cliBinary,
+            [
+                "(async()=>{",
+                "const core=app.plugins.plugins['obsidian-livesync'].core;",
+                "const settings=core.services.setting.currentSettings();",
+                "return JSON.stringify({",
+                "databaseReady:core.services.database.isDatabaseReady(),",
+                "appReady:core.services.appLifecycle.isReady(),",
+                "configured:settings?.isConfigured===true,",
+                "remoteType:settings?.remoteType??'',",
+                "settingVersion:settings?.settingVersion,",
+                "suspended:core.services.appLifecycle.isSuspended(),",
+                "});",
+                "})()",
+            ].join(""),
+            env
+        );
         if (lastReadiness.databaseReady && lastReadiness.appReady) {
             return lastReadiness;
         }
         await new Promise((resolve) => setTimeout(resolve, 500));
     }
-    const errorSuffix =
-        lastError === undefined
-            ? ""
-            : ` Last error: ${lastError instanceof Error ? lastError.message : String(lastError)}`;
-    throw new Error(
-        `Timed out waiting for Self-hosted LiveSync core readiness: ${JSON.stringify(lastReadiness)}${errorSuffix}`
-    );
+    throw new Error(`Timed out waiting for Self-hosted LiveSync core readiness: ${JSON.stringify(lastReadiness)}`);
 }
 
 /**
@@ -462,7 +443,6 @@ export function assertObsidianServiceContextContract(result: ObsidianServiceCont
 }
 
 export async function prepareRemote(cliBinary: string, env: NodeJS.ProcessEnv): Promise<void> {
-    const timeoutMs = Number(process.env.E2E_OBSIDIAN_REMOTE_PREPARE_TIMEOUT_MS ?? 20000);
     await evalObsidianJson<unknown>(
         cliBinary,
         [
@@ -472,16 +452,8 @@ export async function prepareRemote(cliBinary: string, env: NodeJS.ProcessEnv):
             "const replicator=core.services.replicator.getActiveReplicator();",
             "await replicator.tryCreateRemoteDatabase(settings);",
             "await replicator.markRemoteResolved(settings);",
-            `const deadline=Date.now()+${JSON.stringify(timeoutMs)};`,
-            "let securitySeedReady=false;",
-            "do{",
-            "securitySeedReady=await replicator.ensurePBKDF2Salt(settings,false,false);",
-            "if(securitySeedReady) break;",
-            "await new Promise((resolve)=>setTimeout(resolve,250));",
-            "}while(Date.now()<deadline);",
-            "if(!securitySeedReady) throw new Error('Timed out preparing the remote Security Seed');",
             "const status=await replicator.getRemoteStatus(settings);",
-            "return JSON.stringify({status,securitySeedReady});",
+            "return JSON.stringify({status});",
             "})()",
         ].join(""),
         env

test/e2e-obsidian/runner/mobileUi.ts

@@ -1,5 +1,3 @@
-import { mkdir } from "node:fs/promises";
-import { join } from "node:path";
 import {
     assertLocatorHasMinimumTouchTarget,
     assertLocatorWithinSafeArea,
@@ -14,20 +12,13 @@ export const desktopViewport = { width: 1024, height: 768 } as const;
 export const iPhoneSafeArea = { top: 47, right: 0, bottom: 34, left: 0 } as const;
 
 type ObsidianTestApp = {
-    isMobile?: boolean;
     emulateMobile?: (mobile: boolean) => void;
     plugins?: { plugins: Record<string, unknown> };
-    workspace?: { layoutReady?: boolean };
 };
 
 type ObsidianTestGlobal = typeof globalThis & { app?: ObsidianTestApp };
 
-async function applyObsidianMobileTestMode(
-    port: number,
-    enabled: boolean,
-    timeoutMs: number,
-    waitForLiveSync: boolean
-): Promise<void> {
+export async function setObsidianMobileTestMode(port: number, enabled: boolean, timeoutMs: number): Promise<void> {
     await withObsidianPage(port, async (page) => {
         await page.setViewportSize(enabled ? mobileViewport : desktopViewport);
         await page.evaluate((nextEnabled) => {
@@ -37,49 +28,17 @@ async function applyObsidianMobileTestMode(
             }
             obsidianApp.emulateMobile(nextEnabled);
         }, enabled);
-        // Obsidian reopens its workspace layout when platform emulation
-        // changes. Loading a controlled plug-in before that transition has
-        // completed can leave the plug-in enabled but absent from the active
-        // renderer.
-        try {
-            await page.waitForFunction(
-                ({ nextEnabled, waitForLiveSync }) => {
-                    const obsidianApp = (globalThis as ObsidianTestGlobal).app;
-                    return (
-                        document.body.classList.contains("is-mobile") === nextEnabled &&
-                        obsidianApp?.workspace?.layoutReady === true &&
-                        (!waitForLiveSync || obsidianApp?.plugins?.plugins["obsidian-livesync"] !== undefined)
-                    );
-                },
-                { nextEnabled: enabled, waitForLiveSync },
-                { timeout: timeoutMs }
-            );
-        } catch (error) {
-            const state = await page.evaluate(() => {
+        await page.waitForFunction(
+            (nextEnabled) => {
                 const obsidianApp = (globalThis as ObsidianTestGlobal).app;
-                return {
-                    appIsMobile: obsidianApp?.isMobile ?? null,
-                    bodyClasses: document.body.className,
-                    documentReadyState: document.readyState,
-                    liveSyncLoaded: obsidianApp?.plugins?.plugins["obsidian-livesync"] !== undefined,
-                    viewport: { width: window.innerWidth, height: window.innerHeight },
-                    workspaceLayoutReady: obsidianApp?.workspace?.layoutReady ?? null,
-                };
-            });
-            const outputDirectory = process.env.E2E_OBSIDIAN_DIAGNOSTICS_DIR ?? "/tmp/obsidian-livesync-e2e";
-            await mkdir(outputDirectory, { recursive: true });
-            const screenshotPath = join(
-                outputDirectory,
-                waitForLiveSync
-                    ? "mobile-mode-transition.failure.png"
-                    : "mobile-mode-before-plugin-start.failure.png"
-            );
-            await page.screenshot({ path: screenshotPath, fullPage: true });
-            const detail = error instanceof Error ? error.message : String(error);
-            throw new Error(
-                `Obsidian mobile-mode transition did not settle: ${JSON.stringify(state)}; screenshot=${screenshotPath}; cause=${detail}`
-            );
-        }
+                return (
+                    document.body.classList.contains("is-mobile") === nextEnabled &&
+                    obsidianApp?.plugins?.plugins["obsidian-livesync"] !== undefined
+                );
+            },
+            enabled,
+            { timeout: timeoutMs }
+        );
         await page.evaluate(
             (safeArea) => {
                 for (const edge of ["top", "right", "bottom", "left"] as const) {
@@ -93,19 +52,6 @@ async function applyObsidianMobileTestMode(
     });
 }
 
-/** Enters mobile emulation before LiveSync's first load in a controlled session. */
-export async function setObsidianMobileTestModeBeforePluginStart(
-    port: number,
-    enabled: boolean,
-    timeoutMs: number
-): Promise<void> {
-    await applyObsidianMobileTestMode(port, enabled, timeoutMs, false);
-}
-
-export async function setObsidianMobileTestMode(port: number, enabled: boolean, timeoutMs: number): Promise<void> {
-    await applyObsidianMobileTestMode(port, enabled, timeoutMs, true);
-}
-
 export async function assertMobileDialogueLayout(page: Page, container: Locator, label: string): Promise<void> {
     const dialogue = container.locator(".modal").last();
     const closeButton = dialogue.locator(".modal-close-button");

test/e2e-obsidian/runner/securitySeed.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-    SECURITY_SEED_DOCUMENT_ID,
-    changedSynchronisationParameterFields,
-    fingerprintSecuritySeed,
-    replaceSecuritySeed,
-    requireSecuritySeedDocument,
-    snapshotSecuritySeedDocument,
-} from "./securitySeed.ts";
-
-const seedA = Buffer.alloc(32, 1).toString("base64");
-const seedB = Buffer.alloc(32, 2).toString("base64");
-
-describe("Security Seed E2E evidence", () => {
-    it("reports stable, non-secret fingerprints", () => {
-        expect(fingerprintSecuritySeed(seedA)).toMatch(/^sha256:[0-9a-f]{16}$/u);
-        expect(fingerprintSecuritySeed(seedA)).toBe(fingerprintSecuritySeed(seedA));
-        expect(fingerprintSecuritySeed(seedA)).not.toBe(fingerprintSecuritySeed(seedB));
-    });
-
-    it("redacts the Seed from the machine-readable document snapshot", () => {
-        const document = requireSecuritySeedDocument({
-            _id: SECURITY_SEED_DOCUMENT_ID,
-            _rev: "0-1",
-            type: "syncinfo",
-            protocolVersion: 2,
-            pbkdf2salt: seedA,
-        });
-
-        const snapshot = snapshotSecuritySeedDocument(document);
-
-        expect(snapshot).toEqual({
-            id: SECURITY_SEED_DOCUMENT_ID,
-            revision: "0-1",
-            fingerprint: fingerprintSecuritySeed(seedA),
-            fields: {
-                type: "syncinfo",
-                protocolVersion: 2,
-            },
-        });
-        expect(JSON.stringify(snapshot)).not.toContain(seedA);
-    });
-
-    it("replaces only the Seed and identifies later synchronisation-parameter changes", () => {
-        const before = requireSecuritySeedDocument({
-            _id: SECURITY_SEED_DOCUMENT_ID,
-            _rev: "0-1",
-            type: "syncinfo",
-            protocolVersion: 2,
-            pbkdf2salt: seedA,
-        });
-        const replaced = replaceSecuritySeed(before, seedB);
-        const laterRevision = {
-            ...replaced,
-            _rev: "0-3",
-        };
-
-        expect(before.pbkdf2salt).toBe(seedA);
-        expect(replaced.pbkdf2salt).toBe(seedB);
-        expect(changedSynchronisationParameterFields(before, replaced)).toEqual(["pbkdf2salt"]);
-        expect(changedSynchronisationParameterFields(replaced, laterRevision)).toEqual([]);
-    });
-});

test/e2e-obsidian/runner/securitySeed.ts

@@ -1,88 +0,0 @@
-/**
- * Supplies the runner-owned CouchDB fixture operations for the Security Seed
- * reconnect scenario. Production code remains responsible for fetching,
- * caching, and applying the Seed; this helper only validates the managed
- * synchronisation-parameter document, replaces the one intended field, and
- * compares document snapshots.
- *
- * Callers expose only short SHA-256 fingerprints. The original and replacement
- * Seed values must stay inside the isolated test process and must not be
- * written to diagnostics, screenshots, or machine-readable results.
- */
-import { createHash, randomBytes } from "node:crypto";
-import type { CouchDbDocument } from "./couchdb.ts";
-
-export const SECURITY_SEED_DOCUMENT_ID = "_local/obsidian_livesync_sync_parameters";
-
-export type SecuritySeedDocument = CouchDbDocument & {
-    _id: typeof SECURITY_SEED_DOCUMENT_ID;
-    _rev: string;
-    pbkdf2salt: string;
-};
-
-export type SecuritySeedDocumentSnapshot = {
-    id: string;
-    revision: string;
-    fingerprint: string;
-    fields: Record<string, unknown>;
-};
-
-function decodeSecuritySeed(seed: string): Buffer {
-    const bytes = Buffer.from(seed, "base64");
-    if (seed.length === 0 || bytes.length === 0) {
-        throw new Error("The Security Seed is empty or is not valid base64.");
-    }
-    return bytes;
-}
-
-export function createSecuritySeed(): string {
-    return randomBytes(32).toString("base64");
-}
-
-export function fingerprintSecuritySeed(seed: string): string {
-    const bytes = Uint8Array.from(decodeSecuritySeed(seed));
-    return `sha256:${createHash("sha256").update(bytes).digest("hex").slice(0, 16)}`;
-}
-
-export function requireSecuritySeedDocument(document: CouchDbDocument): SecuritySeedDocument {
-    if (document._id !== SECURITY_SEED_DOCUMENT_ID) {
-        throw new Error(`Unexpected synchronisation-parameter document: ${document._id}`);
-    }
-    if (typeof document._rev !== "string" || document._rev.length === 0) {
-        throw new Error("The synchronisation-parameter document does not have a revision.");
-    }
-    if (typeof document.pbkdf2salt !== "string") {
-        throw new Error("The synchronisation-parameter document does not have a Security Seed.");
-    }
-    decodeSecuritySeed(document.pbkdf2salt);
-    return document as SecuritySeedDocument;
-}
-
-export function replaceSecuritySeed(document: SecuritySeedDocument, replacementSeed: string): SecuritySeedDocument {
-    decodeSecuritySeed(replacementSeed);
-    return {
-        ...document,
-        pbkdf2salt: replacementSeed,
-    };
-}
-
-export function snapshotSecuritySeedDocument(document: SecuritySeedDocument): SecuritySeedDocumentSnapshot {
-    const { _id, _rev, pbkdf2salt, ...fields } = document;
-    return {
-        id: _id,
-        revision: _rev,
-        fingerprint: fingerprintSecuritySeed(pbkdf2salt),
-        fields,
-    };
-}
-
-export function changedSynchronisationParameterFields(
-    before: SecuritySeedDocument,
-    after: SecuritySeedDocument
-): string[] {
-    const ignoredFields = new Set(["_rev"]);
-    return [...new Set([...Object.keys(before), ...Object.keys(after)])]
-        .filter((key) => !ignoredFields.has(key))
-        .filter((key) => JSON.stringify(before[key]) !== JSON.stringify(after[key]))
-        .sort();
-}

test/e2e-obsidian/runner/session.test.ts

@@ -52,36 +52,4 @@ describe("LiveSync real-Obsidian session", () => {
             })
         );
     });
-
-    it("forwards instance-scoped lifecycle hooks and the selected plug-in start mode", async () => {
-        const beforePluginStart = vi.fn(async () => undefined);
-        const vault = {
-            path: "/tmp/mobile-vault",
-            statePath: "/tmp/mobile-state",
-            name: "mobile-vault",
-            id: "mobile-vault-id",
-            homePath: "/tmp/mobile-state/home",
-            xdgConfigPath: "/tmp/mobile-state/xdg-config",
-            xdgCachePath: "/tmp/mobile-state/xdg-cache",
-            xdgDataPath: "/tmp/mobile-state/xdg-data",
-            userDataPath: "/tmp/mobile-state/user-data",
-            processMarker: "/tmp/mobile-state",
-            dispose: vi.fn(async () => undefined),
-        };
-
-        await startObsidianLiveSyncSession({
-            binary: "/Applications/Obsidian",
-            cliBinary: "obsidian-cli",
-            vault,
-            pluginStartup: "controlled",
-            lifecycle: { beforePluginStart },
-        });
-
-        expect(startObsidianPluginSession).toHaveBeenCalledWith(
-            expect.objectContaining({
-                lifecycle: { beforePluginStart },
-                pluginStartup: "controlled",
-            })
-        );
-    });
 });

test/e2e-obsidian/runner/session.ts

@@ -1,9 +1,4 @@
-import {
-    startObsidianPluginSession,
-    type ObsidianPluginSession,
-    type ObsidianPluginSessionLifecycle,
-    type ObsidianPluginStartupMode,
-} from "@vrtmrz/obsidian-test-session";
+import { startObsidianPluginSession, type ObsidianPluginSession } from "@vrtmrz/obsidian-test-session";
 import type { TemporaryVault } from "./vault.ts";
 
 export type ObsidianLiveSyncSession = ObsidianPluginSession;
@@ -16,8 +11,6 @@ export type StartObsidianLiveSyncSessionOptions = {
     startupGraceMs?: number;
     pluginData?: Record<string, unknown>;
     localStorageEntries?: Readonly<Record<string, string>>;
-    pluginStartup?: ObsidianPluginStartupMode;
-    lifecycle?: ObsidianPluginSessionLifecycle;
     env?: NodeJS.ProcessEnv;
 };
 
@@ -33,8 +26,6 @@ export async function startObsidianLiveSyncSession(
         startupGraceMs: options.startupGraceMs,
         pluginData: options.pluginData,
         localStorageEntries: options.localStorageEntries,
-        pluginStartup: options.pluginStartup,
-        lifecycle: options.lifecycle,
         env: options.env,
     });
 }

test/e2e-obsidian/scripts/cli-to-obsidian-sync.ts

@@ -13,8 +13,7 @@ import {
 import { discoverObsidianCli, requireObsidianBinary } from "../runner/environment.ts";
 import {
     assertEqual,
-    createE2eCouchDbPluginData,
-    createE2eObsidianDeviceLocalState,
+    configureCouchDb,
     prepareRemote,
     pushLocalChanges,
     waitForLiveSyncCoreReady,
@@ -312,23 +311,25 @@ async function main(): Promise<void> {
             cliBinary: obsidianCli.binary,
             vault,
             startupGraceMs: Number(process.env.E2E_OBSIDIAN_STARTUP_GRACE_MS ?? 1000),
-            pluginData: createE2eCouchDbPluginData(
-                {
-                    uri: couchDb.uri,
-                    username: couchDb.username,
-                    password: couchDb.password,
-                    dbName,
-                },
-                {
-                    encrypt: true,
-                    passphrase: e2eePassphrase,
-                    usePathObfuscation: true,
-                    E2EEAlgorithm: "v2",
-                }
-            ),
-            localStorageEntries: createE2eObsidianDeviceLocalState(vault.name),
         });
         await waitForLiveSyncCoreReady(obsidianCli.binary, session.cliEnv);
+        await configureCouchDb(
+            obsidianCli.binary,
+            session.cliEnv,
+            {
+                uri: couchDb.uri,
+                username: couchDb.username,
+                password: couchDb.password,
+                dbName,
+            },
+            {
+                encrypt: true,
+                passphrase: e2eePassphrase,
+                usePathObfuscation: true,
+                E2EEAlgorithm: "v2",
+            }
+        );
+        await waitForLiveSyncCoreReady(obsidianCli.binary, session.cliEnv);
         await prepareRemote(obsidianCli.binary, session.cliEnv);
         await pushLocalChanges(obsidianCli.binary, session.cliEnv);
 

test/e2e-obsidian/scripts/dialog-mounts.ts

@@ -194,28 +194,6 @@ async function verifyRemoteSizeNoticeAndDialogue(): Promise<{
                     .filter({ hasText: "Synchronisation paused for compatibility review" }),
             });
             await compatibilityReview.waitFor({ state: "visible", timeout: uiTimeoutMs });
-            const message = compatibilityReview.locator(".vpk-action-dialog__message");
-            const textSelection = await message.evaluate((element) => {
-                const selection = window.getSelection();
-                const range = document.createRange();
-                range.selectNodeContents(element);
-                selection?.removeAllRanges();
-                selection?.addRange(range);
-                const selectedText = selection?.toString() ?? "";
-                selection?.removeAllRanges();
-                return {
-                    selectedText,
-                    userSelect: getComputedStyle(element).userSelect,
-                };
-            });
-            if (
-                textSelection.userSelect !== "text" ||
-                !textSelection.selectedText.includes("Remote synchronisation is paused on this device")
-            ) {
-                throw new Error(
-                    `Expected the action dialogue message to be selectable, received user-select=${textSelection.userSelect} and selected text '${textSelection.selectedText}'.`
-                );
-            }
             const actions = compatibilityReview.locator(".vpk-action-dialog__actions--vertical");
             await actions.waitFor({ state: "visible", timeout: uiTimeoutMs });
             const flexDirection = await actions.evaluate((element) => getComputedStyle(element).flexDirection);
@@ -308,32 +286,12 @@ async function verifyRemoteSelectionDialogue(mode: DialogueMode): Promise<string
             for (const label of ["CouchDB", "S3-compatible Object Storage", "Peer-to-Peer (P2P)"]) {
                 await dialogue.getByText(label, { exact: true }).waitFor({ state: "visible", timeout: uiTimeoutMs });
             }
-            const p2pDescription = dialogue.getByText(
-                "No central data-storage server is required, but a signalling relay is required for peer discovery.",
-                { exact: false }
-            );
-            await p2pDescription.waitFor({ state: "visible", timeout: uiTimeoutMs });
-            const textSelection = await p2pDescription.evaluate((element) => {
-                const selection = window.getSelection();
-                const range = document.createRange();
-                range.selectNodeContents(element);
-                selection?.removeAllRanges();
-                selection?.addRange(range);
-                const selectedText = selection?.toString() ?? "";
-                selection?.removeAllRanges();
-                return {
-                    selectedText,
-                    userSelect: getComputedStyle(element).userSelect,
-                };
-            });
-            if (
-                textSelection.userSelect !== "text" ||
-                !textSelection.selectedText.includes("signalling relay is required for peer discovery")
-            ) {
-                throw new Error(
-                    `Expected Svelte dialogue prose to be selectable, received user-select=${textSelection.userSelect} and selected text '${textSelection.selectedText}'.`
-                );
-            }
+            await dialogue
+                .getByText(
+                    "No central data-storage server is required, but a signalling relay is required for peer discovery.",
+                    { exact: false }
+                )
+                .waitFor({ state: "visible", timeout: uiTimeoutMs });
             await modal
                 .getByRole("button", { name: "No, please take me back" })
                 .waitFor({ state: "visible", timeout: uiTimeoutMs });
@@ -764,45 +722,24 @@ async function verifyHatchSurfacesAndSafeActions(): Promise<string> {
             await liveSyncSettings.locator('.sls-setting-menu-btn[title="Hatch"]').click({ timeout: uiTimeoutMs });
             for (const label of [
                 "Write logs into the file",
-                "Recreate chunks for current Vault files",
-                "Inspect conflicts and file/database differences",
-                "Resolve All conflicted files by the newer one",
+                "Recreate missing chunks for all files",
+                "Verify and repair all files",
             ]) {
                 await liveSyncSettings.locator(".setting-item-name", { hasText: label }).waitFor({
                     state: "visible",
                     timeout: uiTimeoutMs,
                 });
             }
-            const settingNames = await liveSyncSettings.locator(".setting-item-name").allTextContents();
-            const recreateIndex = settingNames.findIndex((name) =>
-                name.includes("Recreate chunks for current Vault files")
-            );
-            const inspectIndex = settingNames.findIndex((name) =>
-                name.includes("Inspect conflicts and file/database differences")
-            );
-            const resolveIndex = settingNames.findIndex((name) =>
-                name.includes("Resolve All conflicted files by the newer one")
-            );
-            if (
-                recreateIndex === -1 ||
-                inspectIndex === -1 ||
-                resolveIndex === -1 ||
-                !(recreateIndex < inspectIndex && inspectIndex < resolveIndex)
-            ) {
-                throw new Error(
-                    "Recovery actions are not ordered from chunk recreation through inspection to bulk conflict resolution"
-                );
-            }
-            await liveSyncSettings.getByRole("button", { name: "Recreate current chunks", exact: true }).waitFor({
+            await liveSyncSettings.getByRole("button", { name: "Recreate all", exact: true }).waitFor({
                 state: "visible",
                 timeout: uiTimeoutMs,
             });
-            await liveSyncSettings.getByRole("button", { name: "Begin inspection", exact: true }).waitFor({
+            await liveSyncSettings.getByRole("button", { name: "Verify all", exact: true }).waitFor({
                 state: "visible",
                 timeout: uiTimeoutMs,
             });
             await liveSyncSettings
-                .locator(".setting-item-name", { hasText: "Recreate chunks for current Vault files" })
+                .locator(".setting-item-name", { hasText: "Recreate missing chunks for all files" })
                 .scrollIntoViewIfNeeded();
             return liveSyncSettings;
         }
@@ -894,13 +831,9 @@ async function verifyHatchSurfacesAndSafeActions(): Promise<string> {
                 }
             };
         }, repairRunStateKey);
-        await page
-            .locator(".sls-setting:visible")
-            .last()
-            .getByRole("button", { name: "Recreate current chunks", exact: true })
-            .click({
-                timeout: uiTimeoutMs,
-            });
+        await liveSyncSettings.getByRole("button", { name: "Recreate all", exact: true }).click({
+            timeout: uiTimeoutMs,
+        });
         await page.waitForFunction(
             (stateKey) =>
                 (globalThis as unknown as Record<string, DialogueRunState | undefined>)[stateKey]?.done === true,
@@ -915,13 +848,9 @@ async function verifyHatchSurfacesAndSafeActions(): Promise<string> {
             throw new Error(`Recreate missing chunks failed: ${repairState.error}`);
         }
 
-        await page
-            .locator(".sls-setting:visible")
-            .last()
-            .getByRole("button", { name: "Begin inspection", exact: true })
-            .click({
-                timeout: uiTimeoutMs,
-            });
+        await liveSyncSettings.getByRole("button", { name: "Verify all", exact: true }).click({
+            timeout: uiTimeoutMs,
+        });
         await page
             .locator(".notice")
             .filter({ hasText: /^done$/u })

test/e2e-obsidian/scripts/local-suite.ts

@@ -15,7 +15,6 @@ const testSteps: Step[] = [
     { name: "smoke", args: ["run", "test:e2e:obsidian:smoke"] },
     { name: "onboarding invitation", args: ["run", "test:e2e:obsidian:onboarding-invitation"] },
     { name: "Svelte dialogue mounts", args: ["run", "test:e2e:obsidian:dialog-mounts"] },
-    { name: "revision repair", args: ["run", "test:e2e:obsidian:revision-repair"] },
     { name: "settings UI", args: ["run", "test:e2e:obsidian:settings-ui"] },
     { name: "Review Harness", args: ["run", "test:e2e:obsidian:review-harness"] },
     { name: "P2P status pane", args: ["run", "test:e2e:obsidian:p2p-pane"] },

test/e2e-obsidian/scripts/minio-upload.ts

@@ -1,27 +1,8 @@
-/**
- * Verifies one complete Object Storage upload from a real Obsidian Vault,
- * through LiveSync's local database and Journal Sync, to an S3-compatible
- * service observed independently through the AWS SDK.
- *
- * The isolated Vault starts with Object Storage settings and the device-local
- * compatibility acknowledgement already in place. Unconfigured start-up is
- * intentionally inert and belongs to the onboarding scenario; compatibility
- * review and visible setup have their own dedicated workflows. Supplying those
- * prerequisites here keeps this scenario focused on the upload boundary.
- *
- * Note creation, local-database observation, one-shot synchronisation, request
- * accounting, remote-object inspection, and prefix cleanup remain in one
- * scenario so that a pass proves the same payload crossed every boundary.
- * Separate successes would not prove that those observations belonged to the
- * same upload.
- */
 import { evalObsidianJson } from "../runner/cli.ts";
 import { discoverObsidianCli, requireObsidianBinary } from "../runner/environment.ts";
 import {
     assertEqual,
     configureObjectStorage,
-    createE2eObjectStoragePluginData,
-    createE2eObsidianDeviceLocalState,
     prepareRemote,
     pushLocalChanges,
     waitForLiveSyncCoreReady,
@@ -119,11 +100,6 @@ async function main(): Promise<void> {
             cliBinary: cli.binary,
             vault,
             startupGraceMs: Number(process.env.E2E_OBSIDIAN_STARTUP_GRACE_MS ?? 1000),
-            pluginData: createE2eObjectStoragePluginData({
-                ...objectStorage,
-                bucketPrefix,
-            }),
-            localStorageEntries: createE2eObsidianDeviceLocalState(vault.name),
         });
         await waitForLiveSyncCoreReady(cli.binary, session.cliEnv);
 

test/e2e-obsidian/scripts/onboarding-invitation.ts

@@ -26,10 +26,7 @@ type UnconfiguredStartupEvidence = {
 };
 
 type ObsidianTestApp = {
-    setting?: {
-        open(): void;
-        openTabById(tabId: string): void;
-    };
+    commands?: { executeCommandById(commandId: string): boolean };
 };
 
 type ObsidianTestGlobal = typeof globalThis & { app?: ObsidianTestApp };
@@ -154,38 +151,14 @@ async function captureAndCloseIntro(filename: string, mobile: boolean): Promise<
     return screenshot;
 }
 
-async function openOnboardingFromSettings(): Promise<void> {
-    await withObsidianPage(obsidianRemoteDebuggingPort(), async (page) => {
-        await page.evaluate(() => {
-            const setting = (globalThis as ObsidianTestGlobal).app?.setting;
-            if (setting === undefined) throw new Error("Obsidian settings are unavailable");
-            setting.open();
-            setting.openTabById("obsidian-livesync");
-        });
-
-        const liveSyncSettings = page.locator(".sls-setting");
-        await liveSyncSettings.waitFor({ state: "visible", timeout: uiTimeoutMs });
-        await liveSyncSettings.locator('.sls-setting-menu-btn[title="Setup"]').click({ timeout: uiTimeoutMs });
-
-        const onboardingSetting = liveSyncSettings.locator(".setting-item").filter({
-            has: page.locator(".setting-item-name").filter({ hasText: "Rerun Onboarding Wizard" }),
-        });
-        await onboardingSetting.waitFor({ state: "visible", timeout: uiTimeoutMs });
-        await onboardingSetting
-            .getByRole("button", { name: "Rerun Wizard", exact: true })
-            .click({ timeout: uiTimeoutMs });
-        await onboardingDialogue(page).waitFor({ state: "visible", timeout: uiTimeoutMs });
-    });
-}
-
-async function closeSettings(): Promise<void> {
-    await withObsidianPage(obsidianRemoteDebuggingPort(), async (page) => {
-        const settingsContainer = page.locator(".modal-container").filter({
-            has: page.locator(".sls-setting"),
-        });
-        await settingsContainer.locator(".modal-close-button").click({ timeout: uiTimeoutMs });
-        await settingsContainer.waitFor({ state: "hidden", timeout: uiTimeoutMs });
+async function openPermanentCommand(): Promise<void> {
+    const opened = await withObsidianPage(obsidianRemoteDebuggingPort(), async (page) => {
+        return await page.evaluate(
+            (commandId) => (globalThis as ObsidianTestGlobal).app?.commands?.executeCommandById(commandId) === true,
+            "obsidian-livesync:livesync-open-onboarding"
+        );
     });
+    if (!opened) throw new Error("The permanent onboarding command was not registered.");
 }
 
 async function main(): Promise<void> {
@@ -217,9 +190,8 @@ async function main(): Promise<void> {
         console.log(`Fresh Vault startup evidence: ${JSON.stringify(evidence)}`);
 
         const desktopInvitation = await captureDesktopInvitation();
-        await openOnboardingFromSettings();
-        const settingsIntro = await captureAndCloseIntro("onboarding-intro-settings-desktop.png", false);
-        await closeSettings();
+        await openPermanentCommand();
+        const commandIntro = await captureAndCloseIntro("onboarding-intro-command-desktop.png", false);
         const mobileInvitation = await captureAndSelectMobileInvitation();
         const mobileIntro = await captureAndCloseIntro("onboarding-intro-mobile.png", true);
 
@@ -228,7 +200,7 @@ async function main(): Promise<void> {
                 desktopInvitation,
                 mobileInvitation,
                 mobileIntro,
-                settingsIntro,
+                commandIntro,
             ].join(", ")}`
         );
     } finally {

test/e2e-obsidian/scripts/p2p-pane.ts

@@ -1,181 +1,46 @@
-/**
- * Verifies the complete user-visible contract of the P2P status pane in real
- * Obsidian: a configured CouchDB-only Vault with no P2P profile is not
- * presented with P2P controls, while configured P2P devices can deliberately
- * open the current pane in the appropriate workspace area.
- *
- * Desktop and mobile use separate Vaults, profiles, and Obsidian processes.
- * Mobile mode is enabled before LiveSync's first load so that command and view
- * registration observe the mobile application state, and no desktop workspace
- * state can make a misplaced or restored pane appear correct.
- *
- * Command registration, automatic-opening policy, ribbon availability,
- * workspace ownership, layout, and screenshots are kept in one scenario
- * because together they describe one navigation path. Checking them in
- * isolation could miss a pane which is registered correctly but opens in the
- * wrong area, or one which is visible only because another session restored it.
- */
 import { assertLocatorWithinViewport, assertNoHorizontalOverflow } from "@vrtmrz/obsidian-test-session";
 import type { ObsidianLiveSyncSettings } from "@vrtmrz/livesync-commonlib/compat/common/models/setting.type";
 import { upsertRemoteConfigurationInPlace } from "@vrtmrz/livesync-commonlib/remote-configurations";
-import type { ConsoleMessage, Page } from "playwright";
+import type { Page } from "playwright";
 import { discoverObsidianCli, requireObsidianBinary } from "../runner/environment.ts";
 import {
     createE2eCouchDbPluginData,
     createE2eObsidianDeviceLocalState,
     waitForLiveSyncCoreReady,
 } from "../runner/liveSyncWorkflow.ts";
-import { setObsidianMobileTestModeBeforePluginStart } from "../runner/mobileUi.ts";
+import { setObsidianMobileTestMode } from "../runner/mobileUi.ts";
 import { startObsidianLiveSyncSession, type ObsidianLiveSyncSession } from "../runner/session.ts";
 import { captureObsidianPage, obsidianRemoteDebuggingPort, withObsidianPage } from "../runner/ui.ts";
 import { createTemporaryVault } from "../runner/vault.ts";
 
 const uiTimeoutMs = Number(process.env.E2E_OBSIDIAN_P2P_PANE_TIMEOUT_MS ?? 10000);
 
-type ObsidianTestLeaf = {
-    containerEl?: HTMLElement;
-    view?: { getViewType?: () => string };
-};
-
-type ObsidianTestWorkspace = {
-    activeLeaf?: ObsidianTestLeaf;
-    getLeavesOfType?: (type: string) => ObsidianTestLeaf[];
-    getRightLeaf?: (split: boolean) => ObsidianTestLeaf | null;
-    rightSplit?: { containerEl?: HTMLElement };
-};
-
 type ObsidianTestApp = {
     commands?: {
         commands?: Record<string, unknown>;
         executeCommandById(commandId: string): boolean;
     };
-    isMobile?: boolean;
-    plugins?: {
-        plugins?: Record<
-            string,
-            {
-                core?: {
-                    services?: {
-                        API?: {
-                            isMobile?: () => boolean;
-                        };
-                    };
-                };
-            }
-        >;
-    };
-    workspace?: ObsidianTestWorkspace;
 };
 
 type ObsidianTestGlobal = typeof globalThis & { app?: ObsidianTestApp };
 
-async function openP2PStatusPane(page: Page) {
-    return await page.evaluate((commandId) => {
-        const app = (globalThis as ObsidianTestGlobal).app;
-        const plugin = app?.plugins?.plugins?.["obsidian-livesync"];
-        return {
-            opened: app?.commands?.executeCommandById(commandId) === true,
-            appIsMobile: app?.isMobile ?? null,
-            apiIsMobile: plugin?.core?.services?.API?.isMobile?.() ?? null,
-            bodyIsMobile: document.body.classList.contains("is-mobile"),
-        };
-    }, "obsidian-livesync:open-p2p-server-status");
-}
-
-async function collectP2PWorkspaceState(page: Page) {
-    return await page.evaluate(() => {
-        const workspace = (globalThis as ObsidianTestGlobal).app?.workspace;
-        const activeLeaf = workspace?.activeLeaf;
-        const p2pLeaves = workspace?.getLeavesOfType?.("p2p-server-status") ?? [];
-        const rightLeaf = workspace?.getRightLeaf?.(false);
-        return {
-            bodyClasses: document.body.className,
-            activeLeaf: {
-                type: activeLeaf?.view?.getViewType?.() ?? null,
-                visible: activeLeaf?.containerEl?.checkVisibility?.() ?? null,
-                classes: activeLeaf?.containerEl?.className ?? null,
-            },
-            p2pLeaves: p2pLeaves.map((leaf) => ({
-                type: leaf.view?.getViewType?.() ?? null,
-                visible: leaf.containerEl?.checkVisibility?.() ?? null,
-                classes: leaf.containerEl?.className ?? null,
-            })),
-            rightLeaf: {
-                type: rightLeaf?.view?.getViewType?.() ?? null,
-                visible: rightLeaf?.containerEl?.checkVisibility?.() ?? null,
-                classes: rightLeaf?.containerEl?.className ?? null,
-            },
-            visibleP2PContents: document.querySelectorAll(
-                ".workspace-leaf-content[data-type='p2p-server-status']:not(.is-hidden)"
-            ).length,
-        };
+async function openP2PStatusPane(): Promise<void> {
+    const opened = await withObsidianPage(obsidianRemoteDebuggingPort(), async (page) => {
+        return await page.evaluate(
+            (commandId) => (globalThis as ObsidianTestGlobal).app?.commands?.executeCommandById(commandId) === true,
+            "obsidian-livesync:open-p2p-server-status"
+        );
     });
-}
-
-async function assertMobileP2PPlacement(page: Page): Promise<void> {
-    const placement = await page.evaluate(() => {
-        const workspace = (globalThis as ObsidianTestGlobal).app?.workspace;
-        const p2pLeaves = workspace?.getLeavesOfType?.("p2p-server-status") ?? [];
-        const rightSplit = workspace?.rightSplit?.containerEl;
-        const rightLeaf = workspace?.getRightLeaf?.(false);
-        return {
-            p2pLeafCount: p2pLeaves.length,
-            inRightSplit: p2pLeaves.some(
-                (leaf) =>
-                    (rightSplit?.contains(leaf.containerEl ?? null) ?? false) ||
-                    (leaf.containerEl?.closest(".mod-right-split, .workspace-drawer.mod-right") ?? null) !== null
-            ),
-            rightLeafType: rightLeaf?.view?.getViewType?.() ?? null,
-            p2pLeafClasses: p2pLeaves.map((leaf) => leaf.containerEl?.className ?? null),
-            rightSplitClasses: rightSplit?.className ?? null,
-        };
-    });
-    if (!placement.inRightSplit) {
-        throw new Error(`The mobile P2P status view was not opened in the right leaf: ${JSON.stringify(placement)}`);
+    if (!opened) {
+        throw new Error("The P2P status command was not registered or could not be executed.");
     }
 }
 
 async function verifyP2PStatusPane(filename: string, mobile: boolean): Promise<string> {
+    await openP2PStatusPane();
     return await captureObsidianPage(obsidianRemoteDebuggingPort(), filename, async (page) => {
-        const runtimeErrors: string[] = [];
-        const onPageError = (error: Error) => runtimeErrors.push(`pageerror: ${error.message}`);
-        const onConsole = (message: ConsoleMessage) => {
-            if (message.type() === "error") runtimeErrors.push(`console: ${message.text()}`);
-        };
-        page.on("pageerror", onPageError);
-        page.on("console", onConsole);
-        let dispatchState: Awaited<ReturnType<typeof openP2PStatusPane>> | undefined;
         const heading = page.getByRole("heading", { name: "Signalling Status" }).last();
-        try {
-            dispatchState = await openP2PStatusPane(page);
-            if (!dispatchState.opened) {
-                throw new Error("The P2P status command was not registered or could not be executed.");
-            }
-            if (
-                mobile &&
-                (dispatchState.appIsMobile !== true ||
-                    dispatchState.apiIsMobile !== true ||
-                    dispatchState.bodyIsMobile !== true)
-            ) {
-                throw new Error(
-                    `The mobile P2P command did not observe a fully mobile application state: ${JSON.stringify(dispatchState)}`
-                );
-            }
-            await heading.waitFor({ state: "visible", timeout: uiTimeoutMs });
-        } catch (error) {
-            const workspaceState = await collectP2PWorkspaceState(page);
-            console.error(
-                `P2P command state after failed open: ${JSON.stringify({ dispatchState, runtimeErrors })}`
-            );
-            console.error(`P2P workspace state after failed open: ${JSON.stringify(workspaceState)}`);
-            throw error;
-        } finally {
-            page.off("pageerror", onPageError);
-            page.off("console", onConsole);
-        }
-        if (mobile) {
-            await assertMobileP2PPlacement(page);
-        }
+        await heading.waitFor({ state: "visible", timeout: uiTimeoutMs });
         const pane = heading.locator(
             "xpath=ancestor::*[contains(concat(' ', normalize-space(@class), ' '), ' workspace-leaf-content ')][1]"
         );
@@ -186,14 +51,7 @@ async function verifyP2PStatusPane(filename: string, mobile: boolean): Promise<s
         });
         const remoteSelector = pane.getByRole("combobox", { name: "Select active P2P remote" });
         await remoteSelector.waitFor({ state: "visible", timeout: uiTimeoutMs });
-        const remoteSelectionDeadline = Date.now() + uiTimeoutMs;
-        let remoteConfigurationId = "";
-        while (Date.now() < remoteSelectionDeadline) {
-            remoteConfigurationId = (await remoteSelector.inputValue()).trim();
-            if (remoteConfigurationId !== "") break;
-            await page.waitForTimeout(50);
-        }
-        if (remoteConfigurationId === "") {
+        if ((await remoteSelector.inputValue()).trim() === "") {
             throw new Error("The configured P2P status pane did not select an active P2P remote.");
         }
         if (
@@ -226,7 +84,7 @@ async function assertP2PUIIsOptIn(): Promise<void> {
             throw new Error("The retired P2P pane command is still exposed.");
         }
         if ((await page.locator(".workspace-leaf-content[data-type='p2p-server-status']:visible").count()) !== 0) {
-            throw new Error("The P2P status pane opened automatically for a CouchDB user without P2P configured.");
+            throw new Error("The P2P status pane opened automatically for an unconfigured CouchDB user.");
         }
         if ((await page.locator(".livesync-ribbon-p2p-server-status").count()) !== 0) {
             throw new Error("The P2P ribbon icon was shown without a P2P configuration.");
@@ -246,43 +104,12 @@ async function assertConfiguredP2PUIIsAvailable(): Promise<void> {
     });
 }
 
-async function assertConfiguredP2PCommandIsAvailable(): Promise<void> {
-    await withObsidianPage(obsidianRemoteDebuggingPort(), async (page) => {
-        const state = await page.evaluate(() => {
-            const app = (globalThis as ObsidianTestGlobal).app;
-            const commands = app?.commands?.commands ?? {};
-            return {
-                commandRegistered: commands["obsidian-livesync:open-p2p-server-status"] !== undefined,
-                openPaneCount: app?.workspace?.getLeavesOfType?.("p2p-server-status").length ?? 0,
-            };
-        });
-        if (!state.commandRegistered) {
-            throw new Error("The configured P2P status command was not registered in mobile mode.");
-        }
-        if (state.openPaneCount !== 0) {
-            throw new Error("The configured P2P status pane opened before the mobile user requested it.");
-        }
-    });
-}
-
 async function dismissOpenNotices(page: Page): Promise<void> {
     const deadline = Date.now() + uiTimeoutMs;
     let quietSince = Date.now();
     while (Date.now() < deadline) {
-        const dismissed = await page.evaluate(() => {
-            const notices = (Array.from(document.querySelectorAll(".notice")) as HTMLElement[]).filter(
-                (notice) => notice.checkVisibility?.() ?? notice.offsetParent !== null
-            );
-            for (const notice of notices) {
-                const closeButton = notice.querySelector(".notice-close-button") as HTMLElement | null;
-                // Obsidian 1.12 does not render a separate close control for
-                // every Notice; clicking the Notice itself is its standard
-                // dismiss action.
-                (closeButton ?? notice).click();
-            }
-            return notices.length;
-        });
-        if (dismissed === 0) {
+        const notices = page.locator(".notice:visible");
+        if ((await notices.count()) === 0) {
             if (Date.now() - quietSince >= 500) {
                 return;
             }
@@ -290,7 +117,14 @@ async function dismissOpenNotices(page: Page): Promise<void> {
             continue;
         }
         quietSince = Date.now();
-        await page.waitForTimeout(50);
+        const closeButton = notices.first().locator(".notice-close-button");
+        if ((await closeButton.count()) > 0) {
+            await closeButton.click({ force: true, timeout: uiTimeoutMs });
+        } else {
+            // Obsidian 1.12 does not render a separate close control for every
+            // Notice; clicking the Notice itself is its standard dismiss action.
+            await notices.first().click({ force: true, position: { x: 2, y: 2 }, timeout: uiTimeoutMs });
+        }
     }
     throw new Error("Transient Obsidian notices did not become quiet before the P2P status screenshot.");
 }
@@ -335,8 +169,7 @@ async function withP2PSession(
     binary: string,
     cliBinary: string,
     pluginData: Record<string, unknown>,
-    verify: () => Promise<void>,
-    options: { mobileBeforePluginStart?: boolean } = {}
+    verify: () => Promise<void>
 ): Promise<void> {
     const vault = await createTemporaryVault();
     let session: ObsidianLiveSyncSession | undefined;
@@ -348,17 +181,6 @@ async function withP2PSession(
             startupGraceMs: Number(process.env.E2E_OBSIDIAN_STARTUP_GRACE_MS ?? 1000),
             pluginData,
             localStorageEntries: createE2eObsidianDeviceLocalState(vault.name),
-            lifecycle: options.mobileBeforePluginStart
-                ? {
-                      beforePluginStart: async ({ remoteDebuggingPort }) => {
-                          await setObsidianMobileTestModeBeforePluginStart(
-                              remoteDebuggingPort,
-                              true,
-                              uiTimeoutMs
-                          );
-                      },
-                  }
-                : undefined,
         });
         await waitForLiveSyncCoreReady(cliBinary, session.cliEnv);
         await verify();
@@ -388,25 +210,17 @@ async function main(): Promise<void> {
         async () => {
             await assertConfiguredP2PUIIsAvailable();
             const desktopScreenshot = await verifyP2PStatusPane("p2p-status-pane.png", false);
-            console.log(
-                `Configured P2P status UI remained opt-in and was reachable on desktop. Screenshot: ${desktopScreenshot}`
-            );
+            await setObsidianMobileTestMode(obsidianRemoteDebuggingPort(), true, uiTimeoutMs);
+            try {
+                const mobileScreenshot = await verifyP2PStatusPane("p2p-status-pane-mobile.png", true);
+                console.log(
+                    `Configured P2P status UI remained opt-in and was reachable on desktop and mobile. Screenshots: ${desktopScreenshot}, ${mobileScreenshot}`
+                );
+            } finally {
+                await setObsidianMobileTestMode(obsidianRemoteDebuggingPort(), false, uiTimeoutMs);
+            }
         }
     );
-
-    await withP2PSession(
-        binary,
-        cli.binary,
-        createConfiguredP2PPluginData(),
-        async () => {
-            await assertConfiguredP2PCommandIsAvailable();
-            const mobileScreenshot = await verifyP2PStatusPane("p2p-status-pane-mobile.png", true);
-            console.log(
-                `Configured P2P status UI remained opt-in and was reachable on mobile. Screenshot: ${mobileScreenshot}`
-            );
-        },
-        { mobileBeforePluginStart: true }
-    );
 }
 
 main().catch((error: unknown) => {

test/e2e-obsidian/scripts/review-harness.ts

@@ -1,5 +1,3 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
 import {
     assertLocatorHasMinimumTouchTarget,
     assertLocatorWithinSafeArea,
@@ -8,17 +6,11 @@ import {
 import { CURRENT_SETTING_VERSION } from "@vrtmrz/livesync-commonlib/compat/common/models/setting.const";
 import { REVIEW_HARNESS_STATE_KEY } from "../../../src/features/ReviewHarness/reviewHarnessController.ts";
 import { REVIEW_HARNESS_FIXTURE_ROOT } from "../../../src/features/ReviewHarness/reviewHarnessVaultFixture.ts";
-import { evalObsidianJson } from "../runner/cli.ts";
 import { discoverObsidianCli, requireObsidianBinary } from "../runner/environment.ts";
 import { waitForLiveSyncCoreReady } from "../runner/liveSyncWorkflow.ts";
 import { iPhoneSafeArea, setObsidianMobileTestMode } from "../runner/mobileUi.ts";
 import { startObsidianLiveSyncSession, type ObsidianLiveSyncSession } from "../runner/session.ts";
-import {
-    captureObsidianDialogue,
-    captureObsidianPage,
-    obsidianRemoteDebuggingPort,
-    withObsidianPage,
-} from "../runner/ui.ts";
+import { captureObsidianDialogue, obsidianRemoteDebuggingPort, withObsidianPage } from "../runner/ui.ts";
 import { createTemporaryVault } from "../runner/vault.ts";
 
 const uiTimeoutMs = Number(process.env.E2E_OBSIDIAN_REVIEW_HARNESS_TIMEOUT_MS ?? 15000);
@@ -34,135 +26,6 @@ type ReviewHarnessTestGlobal = typeof globalThis & {
     reviewHarnessCopiedReport?: string;
 };
 
-type ReviewHarnessReadinessSnapshot = {
-    coreAvailable: boolean;
-    databaseReady?: boolean;
-    appReady?: boolean;
-    configured?: boolean;
-    remoteType?: string;
-    settingVersion?: number;
-    suspended?: boolean;
-    unresolvedMessages: string[];
-};
-
-const sensitiveDiagnosticLine =
-    /security seed|passphrase|password|credential|secret|access.?key|jwt.?key|authori[sz]ation|obsidian:\/\/setuplivesync|sls\+/iu;
-const interruptedStartupMessages = [
-    "No replicator has been activated or has not been initialised yet.",
-    "Self-hosted LiveSync cannot be initialised, exiting loading.",
-];
-
-function redactDiagnosticLine(line: string): string {
-    if (sensitiveDiagnosticLine.test(line)) return "[REDACTED SENSITIVE LOG LINE]";
-    return line.replace(/\bhttps?:\/\/[^/\s:@]+:[^@\s/]+@/giu, "https://[REDACTED]@");
-}
-
-async function assertNoInterruptedStartupNotice(stage: string): Promise<void> {
-    const notices = await withObsidianPage(obsidianRemoteDebuggingPort(), async (page) => {
-        await page.waitForTimeout(1500);
-        return await page.locator(".notice").allTextContents();
-    });
-    const interrupted = notices.filter((notice) =>
-        interruptedStartupMessages.some((message) => notice.includes(message))
-    );
-    if (interrupted.length > 0) {
-        throw new Error(`LiveSync emitted an interrupted-startup Notice during ${stage}: ${interrupted.join(" | ")}`);
-    }
-    console.log(`No interrupted-startup Notice observed during ${stage}.`);
-}
-
-async function captureReadinessFailure(
-    cliBinary: string,
-    session: ObsidianLiveSyncSession,
-    readinessError: unknown
-): Promise<void> {
-    const outputDirectory = process.env.E2E_OBSIDIAN_DIAGNOSTICS_DIR ?? "/tmp/obsidian-livesync-e2e";
-    await mkdir(outputDirectory, { recursive: true });
-
-    const captureErrors: string[] = [];
-    let screenshotPath: string | undefined;
-    try {
-        screenshotPath = await captureObsidianPage(
-            obsidianRemoteDebuggingPort(),
-            "review-harness-core-not-ready.png",
-            async () => undefined
-        );
-    } catch (error) {
-        captureErrors.push(`screenshot: ${error instanceof Error ? error.message : String(error)}`);
-    }
-
-    let readiness: ReviewHarnessReadinessSnapshot | undefined;
-    try {
-        readiness = await evalObsidianJson<ReviewHarnessReadinessSnapshot>(
-            cliBinary,
-            [
-                "(async()=>{",
-                "const core=app.plugins.plugins['obsidian-livesync']?.core;",
-                "if(!core)return JSON.stringify({coreAvailable:false,unresolvedMessages:[]});",
-                "const settings=core.services.setting.currentSettings();",
-                "let unresolvedMessages=[];",
-                "try{",
-                "unresolvedMessages=(await core.services.appLifecycle.getUnresolvedMessages()).flat()",
-                ".filter((message)=>message!==undefined&&message!==null)",
-                ".map((message)=>String(message)).slice(-50);",
-                "}catch(error){unresolvedMessages=[`Could not inspect unresolved messages: ${String(error)}`];}",
-                "return JSON.stringify({",
-                "coreAvailable:true,",
-                "databaseReady:core.services.database.isDatabaseReady(),",
-                "appReady:core.services.appLifecycle.isReady(),",
-                "configured:settings?.isConfigured===true,",
-                "remoteType:settings?.remoteType??'',",
-                "settingVersion:settings?.settingVersion,",
-                "suspended:core.services.appLifecycle.isSuspended(),",
-                "unresolvedMessages,",
-                "});",
-                "})()",
-            ].join(""),
-            session.cliEnv
-        );
-        readiness.unresolvedMessages = readiness.unresolvedMessages.map(redactDiagnosticLine);
-    } catch (error) {
-        captureErrors.push(`readiness snapshot: ${error instanceof Error ? error.message : String(error)}`);
-    }
-
-    let recentLog: string[] = [];
-    try {
-        recentLog = await withObsidianPage(obsidianRemoteDebuggingPort(), async (page) => {
-            const opened = await page.evaluate(
-                (commandId) =>
-                    (globalThis as ReviewHarnessTestGlobal).app?.commands?.executeCommandById(commandId) === true,
-                "obsidian-livesync:view-log"
-            );
-            if (!opened) throw new Error("The Show log command was not registered.");
-            const logPane = page.locator(".logpane");
-            await logPane.waitFor({ state: "visible", timeout: 5000 });
-            return (await logPane.locator(".log pre").allTextContents()).slice(-80).map(redactDiagnosticLine);
-        });
-    } catch (error) {
-        captureErrors.push(`recent log: ${error instanceof Error ? error.message : String(error)}`);
-    }
-
-    const resultPath = join(outputDirectory, "review-harness-core-not-ready.json");
-    await writeFile(
-        resultPath,
-        `${JSON.stringify(
-            {
-                capturedAt: new Date().toISOString(),
-                failure: readinessError instanceof Error ? readinessError.message : String(readinessError),
-                screenshotPath,
-                readiness,
-                recentLog,
-                captureErrors,
-            },
-            null,
-            2
-        )}\n`,
-        "utf8"
-    );
-    if (screenshotPath) console.error(`Review Harness core readiness screenshot: ${screenshotPath}`);
-    console.error(`Review Harness core readiness diagnostics: ${resultPath}`);
-}
-
 async function openHarness(): Promise<void> {
     const opened = await withObsidianPage(obsidianRemoteDebuggingPort(), async (page) => {
         return await page.evaluate(
@@ -340,8 +203,6 @@ async function copyAndReadReport(): Promise<string> {
 async function verifyMobileHarness(): Promise<string> {
     await setObsidianMobileTestMode(obsidianRemoteDebuggingPort(), true, uiTimeoutMs);
     await withObsidianPage(obsidianRemoteDebuggingPort(), async (page) => {
-        const harness = page.locator('[data-testid="review-harness"]');
-        if (await harness.isVisible()) return;
         await page.evaluate(async (viewType) => {
             const plugin = (globalThis as ReviewHarnessTestGlobal).app?.plugins?.plugins["obsidian-livesync"];
             if (typeof plugin !== "object" || plugin === null || !("core" in plugin)) {
@@ -391,7 +252,7 @@ async function main(): Promise<void> {
             vault,
             startupGraceMs: Number(process.env.E2E_OBSIDIAN_STARTUP_GRACE_MS ?? 1000),
             pluginData: {
-                doctorProcessedVersion: "1.0.0",
+                doctorProcessedVersion: "0.25.27",
                 settingVersion: CURRENT_SETTING_VERSION,
                 isConfigured: true,
                 additionalSuffixOfDatabaseName: "",
@@ -408,20 +269,7 @@ async function main(): Promise<void> {
                 periodicReplication: true,
             },
         });
-        await assertNoInterruptedStartupNotice("plug-in session start");
-        try {
-            await waitForLiveSyncCoreReady(cli.binary, session.cliEnv);
-        } catch (error) {
-            await captureReadinessFailure(cli.binary, session, error).catch((diagnosticError: unknown) => {
-                console.error(
-                    `Could not capture Review Harness readiness diagnostics: ${
-                        diagnosticError instanceof Error ? diagnosticError.message : String(diagnosticError)
-                    }`
-                );
-            });
-            throw error;
-        }
-        await assertNoInterruptedStartupNotice("core readiness");
+        await waitForLiveSyncCoreReady(cli.binary, session.cliEnv);
         await keepCompatibilityPaused();
         await openHarness();
         await waitForHarness();

test/e2e-obsidian/scripts/revision-repair.ts

@@ -1,735 +0,0 @@
-import { discoverObsidianCli, requireObsidianBinary } from "../runner/environment.ts";
-import { evalObsidianJson } from "../runner/cli.ts";
-import {
-    createE2eObsidianDeviceLocalState,
-    waitForLiveSyncCoreReady,
-    waitForLocalDatabaseEntry,
-} from "../runner/liveSyncWorkflow.ts";
-import { startObsidianLiveSyncSession, type ObsidianLiveSyncSession } from "../runner/session.ts";
-import { captureObsidianElement, withObsidianPage } from "../runner/ui.ts";
-import { createTemporaryVault } from "../runner/vault.ts";
-import type { Locator, Page } from "playwright";
-
-const path = "revision-repair.md";
-const healthyDeletedPath = "healthy-logical-deletion.md";
-const baseContent = "Revision repair\n\nShared base.\n";
-const branchContents = [
-    `Revision repair\n\nLeft branch.\n${"L".repeat(4096)}\n`,
-    `Revision repair\n\nRight branch.\n${"R".repeat(4096)}\n`,
-] as const;
-const uiTimeoutMs = Number(process.env.E2E_OBSIDIAN_REVISION_REPAIR_TIMEOUT_MS ?? 15000);
-
-type BrokenRevisionFixture = {
-    winnerRevision: string;
-    conflictRevision: string;
-    missingChunkId: string;
-};
-
-type RevisionTree = {
-    winnerRevision: string;
-    conflictRevisions: string[];
-};
-
-type VaultWinnerState = {
-    matches: boolean;
-    winnerRevision: string;
-};
-
-type ObsidianSettingsController = {
-    open(): void;
-    openTabById(tabId: string): void;
-};
-
-type ObsidianTestGlobal = typeof globalThis & {
-    app?: {
-        setting?: ObsidianSettingsController;
-    };
-};
-
-async function createAndOpenBaseFile(cliBinary: string, env: NodeJS.ProcessEnv): Promise<void> {
-    await evalObsidianJson<unknown>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const path=${JSON.stringify(path)};`,
-            `const content=${JSON.stringify(baseContent)};`,
-            "let file=app.vault.getAbstractFileByPath(path);",
-            "if(!file) file=await app.vault.create(path,content);",
-            "await app.workspace.getLeaf(false).openFile(file);",
-            "return JSON.stringify({ok:true});",
-            "})()",
-        ].join(""),
-        env
-    );
-}
-
-async function createHealthyLogicalDeletion(cliBinary: string, env: NodeJS.ProcessEnv): Promise<string> {
-    await evalObsidianJson<unknown>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const path=${JSON.stringify(healthyDeletedPath)};`,
-            `const content=${JSON.stringify(`Healthy logical deletion\n\n${"D".repeat(4096)}\n`)};`,
-            "let file=app.vault.getAbstractFileByPath(path);",
-            "if(!file) file=await app.vault.create(path,content);",
-            "return JSON.stringify({ok:true});",
-            "})()",
-        ].join(""),
-        env
-    );
-    await waitForLocalDatabaseEntry(cliBinary, env, healthyDeletedPath);
-    return await evalObsidianJson<string>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const path=${JSON.stringify(healthyDeletedPath)};`,
-            `const timeoutMs=${JSON.stringify(uiTimeoutMs)};`,
-            "const core=app.plugins.plugins['obsidian-livesync'].core;",
-            "const file=app.vault.getAbstractFileByPath(path);",
-            "if(!file) throw new Error(`Logical-deletion fixture is missing from the Vault: ${path}`);",
-            "await app.vault.delete(file);",
-            "const id=await core.services.path.path2id(path);",
-            "const deadline=Date.now()+timeoutMs;",
-            "const sleep=(ms)=>new Promise((resolve)=>setTimeout(resolve,ms));",
-            "while(Date.now()<deadline){",
-            "  await core.services.fileProcessing.commitPendingFileEvents();",
-            "  const doc=await core.localDatabase.localDatabase.get(id,{conflicts:true}).catch(()=>false);",
-            "  if(!app.vault.getAbstractFileByPath(path)&&doc?.deleted&&(doc._conflicts??[]).length===0){",
-            "    return JSON.stringify(doc._rev);",
-            "  }",
-            "  await sleep(250);",
-            "}",
-            "throw new Error(`Timed out waiting for a healthy logical deletion: ${path}`);",
-            "})()",
-        ].join(""),
-        env
-    );
-}
-
-async function createBrokenConflict(
-    cliBinary: string,
-    env: NodeJS.ProcessEnv,
-    baseRevision: string
-): Promise<BrokenRevisionFixture> {
-    return await evalObsidianJson<BrokenRevisionFixture>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const path=${JSON.stringify(path)};`,
-            `const baseRevision=${JSON.stringify(baseRevision)};`,
-            `const contents=${JSON.stringify(branchContents)};`,
-            "const core=app.plugins.plugins['obsidian-livesync'].core;",
-            "const id=await core.services.path.path2id(path);",
-            "for(const [index,content] of contents.entries()){",
-            "  const blob=new Blob([content],{type:'text/plain'});",
-            "  const now=Date.now()+index;",
-            "  const result=await core.localDatabase.putDBEntry({",
-            "    _id:id,path,data:blob,ctime:now,mtime:now,",
-            "    size:(await blob.arrayBuffer()).byteLength,children:[],",
-            "    datatype:'plain',type:'plain',eden:{},",
-            "  },false,baseRevision);",
-            "  if(!result?.ok) throw new Error(`Could not create repair conflict: ${path}`);",
-            "}",
-            "const tree=await core.localDatabase.localDatabase.get(id,{conflicts:true});",
-            "const conflictRevision=tree._conflicts?.[0];",
-            "if(!tree._rev||!conflictRevision){",
-            "  throw new Error(`Repair fixture did not produce two live revisions: ${path}`);",
-            "}",
-            "const conflict=await core.localDatabase.localDatabase.get(id,{rev:conflictRevision});",
-            "const embedded=new Set(Object.keys(conflict.eden??{}));",
-            "const missingChunkId=(conflict.children??[]).find((child)=>!embedded.has(child));",
-            "if(!missingChunkId){",
-            "  throw new Error(`Repair fixture did not create an independent chunk: ${conflictRevision}`);",
-            "}",
-            "const chunk=await core.localDatabase.localDatabase.get(missingChunkId);",
-            "await core.localDatabase.localDatabase.remove(chunk);",
-            "core.localDatabase.clearCaches();",
-            "const unreadable=await core.localDatabase.getDBEntry(path,{rev:conflictRevision},false,true,true);",
-            "if(unreadable!==false){",
-            "  throw new Error(`The selected revision remained readable after its chunk was removed: ${conflictRevision}`);",
-            "}",
-            "return JSON.stringify({",
-            "  winnerRevision:tree._rev,",
-            "  conflictRevision,",
-            "  missingChunkId,",
-            "});",
-            "})()",
-        ].join(""),
-        env
-    );
-}
-
-async function readRevisionTree(cliBinary: string, env: NodeJS.ProcessEnv): Promise<RevisionTree> {
-    return await evalObsidianJson<RevisionTree>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const path=${JSON.stringify(path)};`,
-            "const core=app.plugins.plugins['obsidian-livesync'].core;",
-            "const id=await core.services.path.path2id(path);",
-            "const tree=await core.localDatabase.localDatabase.get(id,{conflicts:true});",
-            "return JSON.stringify({",
-            "  winnerRevision:tree._rev,",
-            "  conflictRevisions:tree._conflicts??[],",
-            "});",
-            "})()",
-        ].join(""),
-        env
-    );
-}
-
-async function readVaultWinnerState(cliBinary: string, env: NodeJS.ProcessEnv): Promise<VaultWinnerState> {
-    return await evalObsidianJson<VaultWinnerState>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const path=${JSON.stringify(path)};`,
-            "const core=app.plugins.plugins['obsidian-livesync'].core;",
-            "const file=app.vault.getAbstractFileByPath(path);",
-            "if(!file) throw new Error(`Vault file is missing: ${path}`);",
-            "const entry=await core.localDatabase.getDBEntry(path,undefined,false,true,true);",
-            "if(!entry||!entry._rev) throw new Error(`Database winner is missing: ${path}`);",
-            "const vaultContent=await app.vault.read(file);",
-            "const data=Array.isArray(entry.data)?entry.data:[entry.data];",
-            "const databaseContent=await new Blob(data).text();",
-            "return JSON.stringify({",
-            "  matches:vaultContent===databaseContent,",
-            "  winnerRevision:entry._rev,",
-            "});",
-            "})()",
-        ].join(""),
-        env
-    );
-}
-
-async function readFileReflectionProvenance(
-    cliBinary: string,
-    env: NodeJS.ProcessEnv,
-    targetPath = path
-): Promise<{ revision: string; observedStorageMtime?: number } | null> {
-    return await evalObsidianJson<{ revision: string; observedStorageMtime?: number } | null>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const path=${JSON.stringify(targetPath)};`,
-            "const core=app.plugins.plugins['obsidian-livesync'].core;",
-            "const store=core.services.keyValueDB.openSimpleStore('file-reflection-provenance-v1');",
-            "return JSON.stringify((await store.get(path))??null);",
-            "})()",
-        ].join(""),
-        env
-    );
-}
-
-function repairCard(settings: Locator): Locator {
-    return settings.locator(".sls-repair-result").filter({ hasText: path });
-}
-
-function revisionCard(settings: Locator, revision: string): Locator {
-    return repairCard(settings).locator(".sls-repair-revision").filter({ hasText: revision });
-}
-
-async function openRevisionActionMenu(page: Page, settings: Locator, revision: string): Promise<Locator> {
-    const actionButton = revisionCard(settings, revision).getByRole("button", {
-        name: `More actions for revision ${revision}`,
-        exact: true,
-    });
-    await actionButton.locator("svg.lucide-wrench").waitFor({
-        state: "visible",
-        timeout: uiTimeoutMs,
-    });
-    await actionButton.click({ timeout: uiTimeoutMs });
-    const menu = page.locator(".menu:visible").last();
-    await menu.waitFor({ state: "visible", timeout: uiTimeoutMs });
-    const box = await menu.boundingBox();
-    const viewport = await page.evaluate(() => ({
-        width: window.innerWidth,
-        height: window.innerHeight,
-    }));
-    if (
-        box === null ||
-        box.y < 0 ||
-        box.y + box.height > viewport.height - 4
-    ) {
-        throw new Error(
-            `Revision action menu is outside the viewport: ${JSON.stringify({
-                box,
-                viewport,
-            })}`
-        );
-    }
-    return menu;
-}
-
-async function selectRevisionAction(page: Page, settings: Locator, revision: string, action: string): Promise<void> {
-    const menu = await openRevisionActionMenu(page, settings, revision);
-    const item = menu.getByText(action, { exact: true });
-    await item.waitFor({ state: "visible", timeout: uiTimeoutMs });
-    await item.click({ timeout: uiTimeoutMs });
-}
-
-async function requestConflictCheck(cliBinary: string, env: NodeJS.ProcessEnv): Promise<void> {
-    await evalObsidianJson<unknown>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const path=${JSON.stringify(path)};`,
-            "const core=app.plugins.plugins['obsidian-livesync'].core;",
-            "core.localDatabase.clearCaches();",
-            "await core.services.conflict.queueCheckFor(path);",
-            "await core.services.conflict.ensureAllProcessed();",
-            "return JSON.stringify({ok:true});",
-            "})()",
-        ].join(""),
-        env
-    );
-}
-
-async function main(): Promise<void> {
-    const binary = requireObsidianBinary();
-    const cli = discoverObsidianCli();
-    if (!cli.binary) {
-        throw new Error(`Could not find obsidian-cli. Checked paths: ${cli.checked.join(", ")}`);
-    }
-    const cliBinary = cli.binary;
-    const vault = await createTemporaryVault("obsidian-livesync-revision-repair-");
-    let session: ObsidianLiveSyncSession | undefined;
-    try {
-        session = await startObsidianLiveSyncSession({
-            binary,
-            cliBinary,
-            vault,
-            startupGraceMs: Number(process.env.E2E_OBSIDIAN_STARTUP_GRACE_MS ?? 1000),
-            pluginData: {
-                doctorProcessedVersion: "1.0.0",
-                isConfigured: true,
-                liveSync: false,
-                remoteType: "",
-                couchDB_URI: "",
-                couchDB_DBNAME: "",
-                couchDB_USER: "",
-                couchDB_PASSWORD: "",
-                remoteConfigurations: {},
-                activeConfigurationId: "",
-                notifyThresholdOfRemoteStorageSize: -1,
-                periodicReplication: false,
-                syncAfterMerge: false,
-                syncOnEditorSave: false,
-                syncOnFileOpen: false,
-                syncOnSave: false,
-                syncOnStart: false,
-                disableMarkdownAutoMerge: true,
-                showMergeDialogOnlyOnActive: true,
-                useEden: false,
-            },
-            localStorageEntries: createE2eObsidianDeviceLocalState(vault.name),
-        });
-        await waitForLiveSyncCoreReady(cliBinary, session.cliEnv);
-        await createAndOpenBaseFile(cliBinary, session.cliEnv);
-        const base = await waitForLocalDatabaseEntry(cliBinary, session.cliEnv, path);
-        const healthyDeletionRevision = await createHealthyLogicalDeletion(cliBinary, session.cliEnv);
-        const fixture = await createBrokenConflict(cliBinary, session.cliEnv, base.rev);
-        const healthyDeletionProvenance = await readFileReflectionProvenance(
-            cliBinary,
-            session.cliEnv,
-            healthyDeletedPath
-        );
-        if (healthyDeletionProvenance !== null) {
-            throw new Error(
-                `A healthy logical deletion retained Vault provenance indefinitely: ${JSON.stringify({
-                    healthyDeletedPath,
-                    healthyDeletionRevision,
-                    healthyDeletionProvenance,
-                })}`
-            );
-        }
-
-        await requestConflictCheck(cliBinary, session.cliEnv);
-        const afterAutomaticCheck = await readRevisionTree(cliBinary, session.cliEnv);
-        if (
-            afterAutomaticCheck.winnerRevision !== fixture.winnerRevision ||
-            !afterAutomaticCheck.conflictRevisions.includes(fixture.conflictRevision)
-        ) {
-            throw new Error(
-                `Automatic conflict checking discarded the unreadable revision: ${JSON.stringify({
-                    fixture,
-                    afterAutomaticCheck,
-                })}`
-            );
-        }
-
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            await page.evaluate(() => {
-                const setting = (globalThis as ObsidianTestGlobal).app?.setting;
-                if (setting === undefined) throw new Error("Obsidian settings are unavailable");
-                setting.open();
-                setting.openTabById("obsidian-livesync");
-            });
-            const settings = page.locator(".sls-setting");
-            await settings.waitFor({ state: "visible", timeout: uiTimeoutMs });
-            await settings.locator('.sls-setting-menu-btn[title="Hatch"]').click({ timeout: uiTimeoutMs });
-            const verifySetting = settings.locator(".setting-item").filter({
-                has: page.getByText("Inspect conflicts and file/database differences", {
-                    exact: true,
-                }),
-            });
-            await verifySetting.getByRole("button", { name: "Begin inspection", exact: true }).click({
-                timeout: uiTimeoutMs,
-            });
-            const card = repairCard(settings);
-            await card.waitFor({ state: "visible", timeout: uiTimeoutMs });
-            if ((await settings.locator(".sls-repair-result").filter({ hasText: healthyDeletedPath }).count()) !== 0) {
-                throw new Error(
-                    `File/database inspection reported the healthy logical deletion ${healthyDeletedPath} (${healthyDeletionRevision}).`
-                );
-            }
-            const winnerRevision = revisionCard(settings, fixture.winnerRevision);
-            const brokenRevision = revisionCard(settings, fixture.conflictRevision);
-            await brokenRevision
-                .getByText(/🧩 Missing chunks: 1/u)
-                .waitFor({ state: "visible", timeout: uiTimeoutMs });
-            await brokenRevision.getByText(fixture.missingChunkId, { exact: false }).waitFor({
-                state: "visible",
-                timeout: uiTimeoutMs,
-            });
-            if ((await card.locator(".sls-repair-revision").count()) !== 2) {
-                throw new Error("Verify and Repair did not render the winner and conflict revision separately.");
-            }
-            for (const label of [
-                /📦 DB: recorded/u,
-                /📁 Vault:/u,
-                /Δsize vs DB/u,
-                /🕒 DB /u,
-                /Δtime /u,
-                /⚠️ Differs from Vault/u,
-            ]) {
-                await winnerRevision.getByText(label).waitFor({
-                    state: "visible",
-                    timeout: uiTimeoutMs,
-                });
-            }
-            await brokenRevision.getByText(/decoded unavailable/u).waitFor({
-                state: "visible",
-                timeout: uiTimeoutMs,
-            });
-            const winnerMenu = await openRevisionActionMenu(page, settings, fixture.winnerRevision);
-            for (const label of [
-                "Compare with Vault",
-                "Apply this revision to Vault",
-                "Store Vault file as a child of this revision",
-                "Discard this branch",
-            ]) {
-                await winnerMenu.getByText(label, { exact: true }).waitFor({
-                    state: "visible",
-                    timeout: uiTimeoutMs,
-                });
-            }
-            if (
-                (await winnerMenu
-                    .getByText("Mark this revision as the Vault version", {
-                        exact: true,
-                    })
-                    .count()) !== 0
-            ) {
-                throw new Error("A differing revision incorrectly offered to record an exact Vault match.");
-            }
-            await page.keyboard.press("Escape");
-        });
-
-        const repairCardScreenshot = await captureObsidianElement(
-            session.remoteDebuggingPort,
-            "revision-repair-unreadable-conflict.png",
-            (page) => page.locator(".sls-repair-result").filter({ hasText: path })
-        );
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            const card = page.locator(".sls-repair-result").filter({ hasText: path });
-            await card.evaluate((element) => {
-                const htmlElement = element as HTMLElement;
-                htmlElement.dataset.e2eOriginalStyle = htmlElement.getAttribute("style") ?? "";
-                htmlElement.style.width = "360px";
-                htmlElement.style.maxWidth = "100%";
-            });
-            const dimensions = await card.evaluate((element) => ({
-                clientWidth: element.clientWidth,
-                scrollWidth: element.scrollWidth,
-            }));
-            if (dimensions.scrollWidth > dimensions.clientWidth + 1) {
-                throw new Error(
-                    `Revision repair card overflowed at mobile width: ${JSON.stringify(dimensions)}`
-                );
-            }
-        });
-        const mobileWidthScreenshot = await captureObsidianElement(
-            session.remoteDebuggingPort,
-            "revision-repair-mobile-width.png",
-            (page) => page.locator(".sls-repair-result").filter({ hasText: path })
-        );
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            const card = page.locator(".sls-repair-result").filter({ hasText: path });
-            await card.evaluate((element) => {
-                const htmlElement = element as HTMLElement;
-                const originalStyle = htmlElement.dataset.e2eOriginalStyle ?? "";
-                if (originalStyle.length > 0) {
-                    htmlElement.setAttribute("style", originalStyle);
-                } else {
-                    htmlElement.removeAttribute("style");
-                }
-                delete htmlElement.dataset.e2eOriginalStyle;
-            });
-        });
-
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            const settings = page.locator(".sls-setting");
-            await openRevisionActionMenu(page, settings, fixture.winnerRevision);
-        });
-        const readableMenuScreenshot = await captureObsidianElement(
-            session.remoteDebuggingPort,
-            "revision-repair-readable-actions.png",
-            (page) => page.locator(".menu:visible").last()
-        );
-
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            await page.keyboard.press("Escape");
-            const settings = page.locator(".sls-setting");
-            await selectRevisionAction(page, settings, fixture.winnerRevision, "Compare with Vault");
-            const modal = page.locator(".modal-container").filter({
-                has: page.locator(".modal-title").filter({
-                    hasText: "Vault and database revision",
-                }),
-            });
-            await modal.waitFor({ state: "visible", timeout: uiTimeoutMs });
-            await modal.getByText(path, { exact: true }).waitFor({
-                state: "visible",
-                timeout: uiTimeoutMs,
-            });
-            await modal.getByText(/Vault file:/u).waitFor({
-                state: "visible",
-                timeout: uiTimeoutMs,
-            });
-            await modal.getByText(/Database revision:/u).waitFor({
-                state: "visible",
-                timeout: uiTimeoutMs,
-            });
-            const actions = modal.locator(".conflict-action-container");
-            await actions.getByRole("button", { name: "Close", exact: true }).waitFor({
-                state: "visible",
-                timeout: uiTimeoutMs,
-            });
-            for (const action of ["Use Vault file", "Use Database revision", "Concat both", "Not now"]) {
-                if ((await actions.getByRole("button", { name: action, exact: true }).count()) !== 0) {
-                    throw new Error(`Read-only comparison exposed the resolution action '${action}'.`);
-                }
-            }
-        });
-        const comparisonScreenshot = await captureObsidianElement(
-            session.remoteDebuggingPort,
-            "revision-repair-read-only-comparison.png",
-            (page) =>
-                page.locator(".modal-container").filter({
-                    has: page.locator(".modal-title").filter({
-                        hasText: "Vault and database revision",
-                    }),
-                })
-        );
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            const modal = page.locator(".modal-container").filter({
-                has: page.locator(".modal-title").filter({
-                    hasText: "Vault and database revision",
-                }),
-            });
-            await modal
-                .locator(".conflict-action-container")
-                .getByRole("button", { name: "Close", exact: true })
-                .click({ timeout: uiTimeoutMs });
-            await modal.waitFor({ state: "hidden", timeout: uiTimeoutMs });
-        });
-
-        const beforeApply = await readRevisionTree(cliBinary, session.cliEnv);
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            const settings = page.locator(".sls-setting");
-            await selectRevisionAction(page, settings, fixture.winnerRevision, "Apply this revision to Vault");
-            const confirmation = page.locator(".modal-container").filter({
-                has: page.locator(".modal-title").filter({
-                    hasText: "Apply database revision to Vault",
-                }),
-            });
-            await confirmation.waitFor({ state: "visible", timeout: uiTimeoutMs });
-            await confirmation.getByRole("button", { name: "Yes", exact: true }).click({ timeout: uiTimeoutMs });
-            await revisionCard(settings, fixture.winnerRevision)
-                .getByText("✅ Matches Vault", { exact: true })
-                .waitFor({ state: "visible", timeout: uiTimeoutMs });
-            const status = repairCard(settings).locator(".sls-repair-status");
-            await status
-                .getByText("✅ Vault matches winner", { exact: true })
-                .waitFor({ state: "visible", timeout: uiTimeoutMs });
-            await status
-                .getByText("⚠️ Conflicts: 1", { exact: true })
-                .waitFor({ state: "visible", timeout: uiTimeoutMs });
-        });
-        const matchedWinnerWithConflictScreenshot = await captureObsidianElement(
-            session.remoteDebuggingPort,
-            "revision-repair-winner-match-with-conflict.png",
-            (page) => page.locator(".sls-repair-result").filter({ hasText: path })
-        );
-        const afterApply = await readRevisionTree(cliBinary, session.cliEnv);
-        if (JSON.stringify(afterApply) !== JSON.stringify(beforeApply)) {
-            throw new Error(
-                `Applying a live revision to the Vault changed the revision tree: ${JSON.stringify({
-                    beforeApply,
-                    afterApply,
-                })}`
-            );
-        }
-        const vaultWinner = await readVaultWinnerState(cliBinary, session.cliEnv);
-        const appliedProvenance = await readFileReflectionProvenance(cliBinary, session.cliEnv);
-        if (
-            !vaultWinner.matches ||
-            vaultWinner.winnerRevision !== fixture.winnerRevision ||
-            appliedProvenance?.revision !== fixture.winnerRevision
-        ) {
-            throw new Error(
-                `Applying the winner did not preserve exact Vault provenance: ${JSON.stringify({
-                    vaultWinner,
-                    appliedProvenance,
-                    fixture,
-                })}`
-            );
-        }
-
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            const settings = page.locator(".sls-setting");
-            const menu = await openRevisionActionMenu(page, settings, fixture.winnerRevision);
-            await menu
-                .getByText("Mark this revision as the Vault version", { exact: true })
-                .waitFor({ state: "visible", timeout: uiTimeoutMs });
-            await menu
-                .getByText("Discard this branch", { exact: true })
-                .waitFor({ state: "visible", timeout: uiTimeoutMs });
-            await menu
-                .getByText("Mark this revision as the Vault version", { exact: true })
-                .click({ timeout: uiTimeoutMs });
-            await revisionCard(settings, fixture.winnerRevision)
-                .getByText("✅ Matches Vault", { exact: true })
-                .waitFor({ state: "visible", timeout: uiTimeoutMs });
-        });
-        const afterExactMark = await readRevisionTree(cliBinary, session.cliEnv);
-        const markedProvenance = await readFileReflectionProvenance(cliBinary, session.cliEnv);
-        if (
-            JSON.stringify(afterExactMark) !== JSON.stringify(beforeApply) ||
-            markedProvenance?.revision !== fixture.winnerRevision
-        ) {
-            throw new Error(
-                `Recording an exact Vault match changed the tree or lost provenance: ${JSON.stringify({
-                    beforeApply,
-                    afterExactMark,
-                    markedProvenance,
-                })}`
-            );
-        }
-
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            const settings = page.locator(".sls-setting");
-            const menu = await openRevisionActionMenu(page, settings, fixture.conflictRevision);
-            for (const label of [
-                "Store Vault file as a child of this revision",
-                "Retry reading revision",
-                "Discard this branch",
-            ]) {
-                await menu.getByText(label, { exact: true }).waitFor({
-                    state: "visible",
-                    timeout: uiTimeoutMs,
-                });
-            }
-        });
-        const unreadableMenuScreenshot = await captureObsidianElement(
-            session.remoteDebuggingPort,
-            "revision-repair-unreadable-actions-context.png",
-            (page) => page.locator("body")
-        );
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            await page.keyboard.press("Escape");
-            const settings = page.locator(".sls-setting");
-            await selectRevisionAction(page, settings, fixture.conflictRevision, "Retry reading revision");
-            await revisionCard(settings, fixture.conflictRevision)
-                .getByText(/🧩 Missing chunks:/u)
-                .waitFor({ state: "visible", timeout: uiTimeoutMs });
-        });
-
-        const afterRetry = await readRevisionTree(cliBinary, session.cliEnv);
-        if (JSON.stringify(afterRetry) !== JSON.stringify(beforeApply)) {
-            throw new Error(`Retry changed the revision tree: ${JSON.stringify(afterRetry)}`);
-        }
-
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            const settings = page.locator(".sls-setting");
-            await selectRevisionAction(page, settings, fixture.conflictRevision, "Discard this branch");
-            const confirmation = page.locator(".modal-container").filter({
-                has: page.locator(".modal-title").filter({ hasText: "Discard branch" }),
-            });
-            await confirmation.waitFor({ state: "visible", timeout: uiTimeoutMs });
-            await confirmation.getByRole("button", { name: "No", exact: true }).click({ timeout: uiTimeoutMs });
-            await confirmation.waitFor({ state: "hidden", timeout: uiTimeoutMs });
-        });
-
-        const afterCancellation = await readRevisionTree(cliBinary, session.cliEnv);
-        if (JSON.stringify(afterCancellation) !== JSON.stringify(beforeApply)) {
-            throw new Error(`Cancelling discard changed the revision tree: ${JSON.stringify(afterCancellation)}`);
-        }
-
-        await withObsidianPage(session.remoteDebuggingPort, async (page) => {
-            const settings = page.locator(".sls-setting");
-            await selectRevisionAction(page, settings, fixture.conflictRevision, "Discard this branch");
-            const confirmation = page.locator(".modal-container").filter({
-                has: page.locator(".modal-title").filter({ hasText: "Discard branch" }),
-            });
-            await confirmation.waitFor({ state: "visible", timeout: uiTimeoutMs });
-            await confirmation.getByRole("button", { name: "Yes", exact: true }).click({ timeout: uiTimeoutMs });
-            await repairCard(settings).waitFor({ state: "hidden", timeout: uiTimeoutMs });
-        });
-
-        const afterDiscard = await readRevisionTree(cliBinary, session.cliEnv);
-        if (afterDiscard.winnerRevision !== fixture.winnerRevision || afterDiscard.conflictRevisions.length !== 0) {
-            throw new Error(
-                `Explicit discard did not remove only the selected unreadable revision: ${JSON.stringify({
-                    fixture,
-                    afterDiscard,
-                })}`
-            );
-        }
-        const finalVaultWinner = await readVaultWinnerState(cliBinary, session.cliEnv);
-        const finalProvenance = await readFileReflectionProvenance(cliBinary, session.cliEnv);
-        if (
-            !finalVaultWinner.matches ||
-            finalVaultWinner.winnerRevision !== fixture.winnerRevision ||
-            finalProvenance?.revision !== fixture.winnerRevision
-        ) {
-            throw new Error(
-                `Discarding the unreadable branch disturbed the healthy Vault reflection: ${JSON.stringify({
-                    finalVaultWinner,
-                    finalProvenance,
-                    fixture,
-                })}`
-            );
-        }
-
-        console.log(
-            "Real Obsidian omitted a healthy logical deletion; rendered each live revision with compact actions and diagnostics; showed that the Vault matched the winner while one conflict remained; compared and applied an exact readable revision without changing the tree; preserved Vault provenance; kept an unreadable branch through automatic checking, retry, and cancelled discard; and discarded only the selected branch after confirmation."
-        );
-        console.log(`Repair card screenshot: ${repairCardScreenshot}`);
-        console.log(`Mobile-width repair card screenshot: ${mobileWidthScreenshot}`);
-        console.log(`Readable revision actions screenshot: ${readableMenuScreenshot}`);
-        console.log(`Read-only comparison screenshot: ${comparisonScreenshot}`);
-        console.log(`Matching winner with conflict screenshot: ${matchedWinnerWithConflictScreenshot}`);
-        console.log(`Unreadable revision actions screenshot: ${unreadableMenuScreenshot}`);
-    } finally {
-        if (session) {
-            await session.app.stop();
-        }
-        await vault.dispose();
-    }
-}
-
-main().catch((error: unknown) => {
-    console.error(error instanceof Error ? error.stack : error);
-    process.exit(1);
-});

test/e2e-obsidian/scripts/run-focused.ts

@@ -8,7 +8,6 @@ const focusedScenarios = new Set([
     "smoke",
     "onboarding-invitation",
     "dialog-mounts",
-    "revision-repair",
     "settings-ui",
     "review-harness",
     "p2p-pane",
@@ -22,7 +21,6 @@ const focusedScenarios = new Set([
     "startup-scan",
     "setup-uri-workflow",
     "two-vault-sync",
-    "security-seed-reconnect",
     "hidden-file-snippet-sync",
     "customisation-sync",
     "setting-markdown-export",

test/e2e-obsidian/scripts/security-seed-reconnect.ts

@@ -1,768 +0,0 @@
-/**
- * Provides release evidence for the Security Seed refresh behaviour shared by
- * supported platforms in real Obsidian. It verifies that an already-open
- * device keeps its deliberately stale cached Seed until replication, refreshes
- * from the managed CouchDB fixture before encrypting, and never restores the
- * old Seed to the remote synchronisation-parameter document.
- *
- * The scenario uses isolated Vaults, profiles, and a random database because
- * settings, the local database, the renderer process, and CouchDB must all
- * participate in the result. Device A is restarted with the same Vault and
- * profile, while device B is fresh. The devices run sequentially after the
- * same-process stale-cache assertion because desktop Obsidian may enforce a
- * single application instance; running them concurrently would test launcher
- * behaviour rather than LiveSync's shared plug-in implementation.
- *
- * Seed replacement, A-to-B decryption, B-to-A return synchronisation, final
- * remote-document comparison, error-log inspection, screenshots, and strict
- * teardown remain one scenario. Together they prove that the same replacement
- * Seed was used across the complete encrypted round trip and was not later
- * rolled back. Independent passing checks would not establish that continuity.
- * The result records fingerprints only and does not claim to cover an
- * iPadOS-specific background or reconnect lifecycle.
- */
-import { execFileSync } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { evalObsidianJson } from "../runner/cli.ts";
-import {
-    assertCouchDbReachable,
-    couchDbDatabaseExists,
-    createCouchDbDatabase,
-    deleteCouchDbDatabase,
-    fetchAllCouchDbDocs,
-    fetchCouchDbDocument,
-    loadCouchDbConfig,
-    makeUniqueDatabaseName,
-    putCouchDbDocument,
-    waitForCouchDbDocs,
-    type CouchDbConfig,
-    type CouchDbDocument,
-} from "../runner/couchdb.ts";
-import { discoverObsidianCli, requireObsidianBinary } from "../runner/environment.ts";
-import {
-    createE2eCouchDbPluginData,
-    createE2eObsidianDeviceLocalState,
-    prepareRemote,
-    pushLocalChanges,
-    waitForLiveSyncCoreReady,
-    waitForLocalDatabaseEntry,
-    type LocalDatabaseEntry,
-} from "../runner/liveSyncWorkflow.ts";
-import {
-    SECURITY_SEED_DOCUMENT_ID,
-    changedSynchronisationParameterFields,
-    createSecuritySeed,
-    fingerprintSecuritySeed,
-    replaceSecuritySeed,
-    requireSecuritySeedDocument,
-    snapshotSecuritySeedDocument,
-    type SecuritySeedDocument,
-    type SecuritySeedDocumentSnapshot,
-} from "../runner/securitySeed.ts";
-import { startObsidianLiveSyncSession, type ObsidianLiveSyncSession } from "../runner/session.ts";
-import { captureObsidianPage } from "../runner/ui.ts";
-import { createTemporaryVault, type TemporaryVault } from "../runner/vault.ts";
-
-process.env.E2E_OBSIDIAN_CLI_TIMEOUT_MS ??= "30000";
-process.env.E2E_OBSIDIAN_COUCHDB_TIMEOUT_MS ??= "20000";
-process.env.E2E_OBSIDIAN_FILE_TIMEOUT_MS ??= "15000";
-
-const outboundPath = "E2E/security-seed/device-a.md";
-const returnPath = "E2E/security-seed/device-b.md";
-const hkdfErrorMessages = [
-    "Encryption with HKDF failed",
-    "Decryption with HKDF failed",
-    "Failed to initialise the encryption key",
-    "Failed to obtain PBKDF2 salt",
-] as const;
-
-type RunnerContext = {
-    binary: string;
-    cliBinary: string;
-    artifactRoot: string;
-    couchDb: CouchDbConfig;
-    dbName: string;
-    activeSessions: Set<ObsidianLiveSyncSession>;
-    allSessions: ObsidianLiveSyncSession[];
-    screenshots: string[];
-};
-
-type DeviceLabel = "device-a" | "device-a-return" | "device-b";
-
-type SourceEvidence = {
-    exactCommit: string;
-    revisionSource: "git-worktree" | "provided-artifact";
-    workingTreeClean: boolean | null;
-    pluginVersion: string;
-    pluginArtifactSha256: string;
-};
-
-type ReplicationSettingsState = {
-    liveSync: boolean;
-    syncOnStart: boolean;
-    syncOnSave: boolean;
-    periodicReplication: boolean;
-    syncOnFileOpen: boolean;
-    syncOnEditorSave: boolean;
-};
-
-type SessionHealth = {
-    matchingErrorMessages: string[];
-};
-
-type ScenarioEvidence = {
-    source: SourceEvidence;
-    securitySeed: {
-        initial: SecuritySeedDocumentSnapshot;
-        replacement: SecuritySeedDocumentSnapshot;
-        final: SecuritySeedDocumentSnapshot;
-        cachedBeforeReplacement: string;
-        cachedAfterRemoteReplacement: string;
-        cachedAfterReplication: string;
-        replacementChangedFields: string[];
-        finalChangedFields: string[];
-    };
-    synchronisation: {
-        deviceAToDeviceB: boolean;
-        deviceBToDeviceA: boolean;
-        deviceAEncryptedPayload: boolean;
-        deviceBEncryptedPayload: boolean;
-    };
-    health: {
-        deviceA: SessionHealth;
-        deviceB: SessionHealth;
-    };
-    screenshots: string[];
-};
-
-type TeardownEvidence = {
-    sessionsStopped: boolean;
-    vaultRemoved: boolean;
-    profileRemoved: boolean;
-    databaseRemoved: boolean;
-    remainingTrackedSessions: number;
-};
-
-class MultipleErrors extends Error {
-    readonly errors: unknown[];
-
-    constructor(message: string, errors: unknown[]) {
-        super(message);
-        this.name = "MultipleErrors";
-        this.errors = errors;
-    }
-}
-
-function assertEqual(actual: unknown, expected: unknown, message: string): void {
-    if (actual !== expected) {
-        throw new Error(`${message}\nExpected: ${String(expected)}\nActual: ${String(actual)}`);
-    }
-}
-
-function inspectGitRevision(
-    artifactRoot: string
-): Pick<SourceEvidence, "exactCommit" | "revisionSource" | "workingTreeClean"> {
-    try {
-        const exactCommit = execFileSync("git", ["-C", artifactRoot, "rev-parse", "HEAD"], {
-            encoding: "utf-8",
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
-        const status = execFileSync("git", ["-C", artifactRoot, "status", "--porcelain"], {
-            encoding: "utf-8",
-            stdio: ["ignore", "pipe", "ignore"],
-        }).trim();
-        return {
-            exactCommit,
-            revisionSource: "git-worktree",
-            workingTreeClean: status.length === 0,
-        };
-    } catch {
-        const exactCommit = process.env.E2E_OBSIDIAN_ARTIFACT_REVISION?.trim();
-        if (!exactCommit) {
-            throw new Error(
-                "E2E_OBSIDIAN_ARTIFACT_REVISION is required when the plug-in artefact is not in a Git worktree."
-            );
-        }
-        return {
-            exactCommit,
-            revisionSource: "provided-artifact",
-            workingTreeClean: null,
-        };
-    }
-}
-
-async function inspectSourceEvidence(artifactRoot: string): Promise<SourceEvidence> {
-    const manifest = JSON.parse(await readFile(join(artifactRoot, "manifest.json"), "utf-8")) as {
-        version?: unknown;
-    };
-    if (typeof manifest.version !== "string" || manifest.version.length === 0) {
-        throw new Error("The plug-in manifest does not have a version.");
-    }
-    const mainJs = await readFile(join(artifactRoot, "main.js"));
-    return {
-        ...inspectGitRevision(artifactRoot),
-        pluginVersion: manifest.version,
-        pluginArtifactSha256: createHash("sha256").update(Uint8Array.from(mainJs)).digest("hex"),
-    };
-}
-
-function e2eeSettings(passphrase: string): Record<string, unknown> {
-    return {
-        encrypt: true,
-        passphrase,
-        usePathObfuscation: true,
-        E2EEAlgorithm: "v2",
-    };
-}
-
-async function captureStage(context: RunnerContext, session: ObsidianLiveSyncSession, filename: string): Promise<void> {
-    const screenshot = await captureObsidianPage(session.remoteDebuggingPort, filename, async () => undefined);
-    context.screenshots.push(screenshot);
-    console.log(`Security Seed E2E screenshot: ${screenshot}`);
-}
-
-async function startConfiguredSession(
-    context: RunnerContext,
-    vault: TemporaryVault,
-    passphrase: string,
-    deviceLabel: DeviceLabel
-): Promise<ObsidianLiveSyncSession> {
-    const couchDbSettings = {
-        uri: context.couchDb.uri,
-        username: context.couchDb.username,
-        password: context.couchDb.password,
-        dbName: context.dbName,
-    };
-    const overrides = e2eeSettings(passphrase);
-    const session = await startObsidianLiveSyncSession({
-        binary: context.binary,
-        cliBinary: context.cliBinary,
-        artifactRoot: context.artifactRoot,
-        vault,
-        startupGraceMs: Number(process.env.E2E_OBSIDIAN_STARTUP_GRACE_MS ?? 1000),
-        pluginData: createE2eCouchDbPluginData(couchDbSettings, overrides),
-        localStorageEntries: createE2eObsidianDeviceLocalState(vault.name),
-    });
-    context.activeSessions.add(session);
-    context.allSessions.push(session);
-    try {
-        await captureStage(context, session, `security-seed-${deviceLabel}-startup.png`);
-        await waitForLiveSyncCoreReady(context.cliBinary, session.cliEnv);
-        await prepareRemote(context.cliBinary, session.cliEnv);
-        await captureStage(context, session, `security-seed-${deviceLabel}-configured.png`);
-        return session;
-    } catch (error) {
-        await captureStage(context, session, `security-seed-${deviceLabel}-setup-failure.png`).catch(() => undefined);
-        await stopTrackedSession(context, session);
-        throw error;
-    }
-}
-
-async function stopTrackedSession(context: RunnerContext, session: ObsidianLiveSyncSession): Promise<void> {
-    if (!context.activeSessions.has(session)) {
-        return;
-    }
-    await session.app.stop();
-    context.activeSessions.delete(session);
-}
-
-async function stopTrackedSessions(context: RunnerContext): Promise<void> {
-    const errors: unknown[] = [];
-    for (const session of [...context.activeSessions]) {
-        try {
-            await stopTrackedSession(context, session);
-        } catch (error) {
-            errors.push(error);
-        }
-    }
-    if (errors.length > 0) {
-        throw new MultipleErrors("Could not stop every Real Obsidian session.", errors);
-    }
-}
-
-async function pauseAutomaticReplication(cliBinary: string, env: NodeJS.ProcessEnv): Promise<ReplicationSettingsState> {
-    const state = await evalObsidianJson<ReplicationSettingsState>(
-        cliBinary,
-        [
-            "(()=>{",
-            "const core=app.plugins.plugins['obsidian-livesync'].core;",
-            "core.services.replicator.getActiveReplicator()?.closeReplication();",
-            "const settings=core.services.setting.currentSettings();",
-            "return JSON.stringify({",
-            "liveSync:Boolean(settings.liveSync),",
-            "syncOnStart:Boolean(settings.syncOnStart),",
-            "syncOnSave:Boolean(settings.syncOnSave),",
-            "periodicReplication:Boolean(settings.periodicReplication),",
-            "syncOnFileOpen:Boolean(settings.syncOnFileOpen),",
-            "syncOnEditorSave:Boolean(settings.syncOnEditorSave),",
-            "});",
-            "})()",
-        ].join(""),
-        env
-    );
-    for (const [name, enabled] of Object.entries(state)) {
-        if (enabled) {
-            throw new Error(`Automatic replication remained enabled through ${name}.`);
-        }
-    }
-    return state;
-}
-
-async function cachedSecuritySeedFingerprint(cliBinary: string, env: NodeJS.ProcessEnv): Promise<string> {
-    const result = await evalObsidianJson<{ fingerprint: string }>(
-        cliBinary,
-        [
-            "(async()=>{",
-            "const core=app.plugins.plugins['obsidian-livesync'].core;",
-            "const settings=core.services.setting.currentSettings();",
-            "const replicator=core.services.replicator.getActiveReplicator();",
-            "const seed=await replicator.getReplicationPBKDF2Salt(settings,false);",
-            "const digest=await crypto.subtle.digest('SHA-256',seed);",
-            "const fingerprint='sha256:'+Array.from(new Uint8Array(digest))",
-            ".map((value)=>value.toString(16).padStart(2,'0')).join('').slice(0,16);",
-            "return JSON.stringify({fingerprint});",
-            "})()",
-        ].join(""),
-        env
-    );
-    return result.fingerprint;
-}
-
-async function writeNoteViaObsidian(
-    cliBinary: string,
-    env: NodeJS.ProcessEnv,
-    path: string,
-    content: string
-): Promise<void> {
-    await evalObsidianJson<unknown>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const path=${JSON.stringify(path)};`,
-            `const content=${JSON.stringify(content)};`,
-            "const folder=path.split('/').slice(0,-1).join('/');",
-            "if(folder&&!(await app.vault.adapter.exists(folder))) await app.vault.createFolder(folder);",
-            "const existing=app.vault.getAbstractFileByPath(path);",
-            "if(existing) await app.vault.modify(existing,content);",
-            "else await app.vault.create(path,content);",
-            "return JSON.stringify({ok:true});",
-            "})()",
-        ].join(""),
-        env
-    );
-}
-
-async function openNoteViaObsidian(cliBinary: string, env: NodeJS.ProcessEnv, path: string): Promise<void> {
-    await evalObsidianJson<unknown>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const path=${JSON.stringify(path)};`,
-            "const file=app.vault.getAbstractFileByPath(path);",
-            "if(!file) throw new Error(`Could not find note to open: ${path}`);",
-            "await app.workspace.getLeaf(false).openFile(file);",
-            "return JSON.stringify({ok:true});",
-            "})()",
-        ].join(""),
-        env
-    );
-}
-
-async function pathExists(path: string): Promise<boolean> {
-    try {
-        await access(path);
-        return true;
-    } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-            return false;
-        }
-        throw error;
-    }
-}
-
-async function waitForPathContent(
-    vaultPath: string,
-    path: string,
-    expected: string,
-    timeoutMs = Number(process.env.E2E_OBSIDIAN_FILE_TIMEOUT_MS ?? 15000)
-): Promise<void> {
-    const fullPath = join(vaultPath, path);
-    const deadline = Date.now() + timeoutMs;
-    let lastContent = "";
-    while (Date.now() < deadline) {
-        if (await pathExists(fullPath)) {
-            lastContent = await readFile(fullPath, "utf-8");
-            if (lastContent === expected) {
-                return;
-            }
-        }
-        await new Promise((resolve) => setTimeout(resolve, 250));
-    }
-    throw new Error(`Timed out waiting for ${path}. Last content:\n${lastContent}`);
-}
-
-function remoteContainsEntry(documents: CouchDbDocument[], entry: LocalDatabaseEntry): boolean {
-    const ids = new Set(documents.map((document) => document._id));
-    return ids.has(entry.id) && entry.children.every((childId) => ids.has(childId));
-}
-
-async function assertEntryNotRemote(context: RunnerContext, entry: LocalDatabaseEntry): Promise<void> {
-    const response = await fetchAllCouchDbDocs(context.couchDb, context.dbName);
-    const documents = response.rows.flatMap((row) => (row.doc ? [row.doc] : []));
-    if (remoteContainsEntry(documents, entry)) {
-        throw new Error("The pending device-A document reached CouchDB before the Security Seed replacement.");
-    }
-}
-
-async function waitForEncryptedRemoteEntry(context: RunnerContext, entry: LocalDatabaseEntry): Promise<boolean> {
-    const documents = await waitForCouchDbDocs(context.couchDb, context.dbName, (docs) =>
-        remoteContainsEntry(docs, entry)
-    );
-    const byId = new Map(documents.map((document) => [document._id, document]));
-    const encrypted = entry.children.every((childId) => {
-        const data = byId.get(childId)?.data;
-        return typeof data === "string" && data.startsWith("%=");
-    });
-    if (!encrypted) {
-        throw new Error("A replicated chunk did not use the expected HKDF-encrypted payload format.");
-    }
-    return true;
-}
-
-async function inspectSessionHealth(cliBinary: string, env: NodeJS.ProcessEnv): Promise<SessionHealth> {
-    return await evalObsidianJson<SessionHealth>(
-        cliBinary,
-        [
-            "(async()=>{",
-            `const patterns=${JSON.stringify(hkdfErrorMessages)};`,
-            "const core=app.plugins.plugins['obsidian-livesync'].core;",
-            "await core.services.API.showWindow('log-log');",
-            "const sleep=(ms)=>new Promise((resolve)=>setTimeout(resolve,ms));",
-            "let text='';",
-            "for(let i=0;i<20;i++){",
-            "text=Array.from(document.querySelectorAll('.logpane .log pre'))",
-            ".map((element)=>element.textContent??'').join('\\n');",
-            "if(text.length>0) break;",
-            "await sleep(50);",
-            "}",
-            "const unresolved=JSON.stringify((await core.services.appLifecycle.getUnresolvedMessages()).flat());",
-            "const matchingErrorMessages=patterns.filter((pattern)=>text.includes(pattern)||unresolved.includes(pattern));",
-            "for(const leaf of app.workspace.getLeavesOfType('log-log')) leaf.detach();",
-            "return JSON.stringify({matchingErrorMessages});",
-            "})()",
-        ].join(""),
-        env
-    );
-}
-
-async function fetchSecuritySeedDocument(context: RunnerContext): Promise<SecuritySeedDocument> {
-    return requireSecuritySeedDocument(
-        await fetchCouchDbDocument(context.couchDb, context.dbName, SECURITY_SEED_DOCUMENT_ID)
-    );
-}
-
-async function replaceRemoteSecuritySeed(
-    context: RunnerContext,
-    before: SecuritySeedDocument,
-    replacementSeed: string
-): Promise<SecuritySeedDocument> {
-    const replacement = replaceSecuritySeed(before, replacementSeed);
-    const putResult = await putCouchDbDocument(context.couchDb, context.dbName, replacement);
-    const after = await fetchSecuritySeedDocument(context);
-    assertEqual(after._rev, putResult.rev, "The replacement Security Seed revision was not stored.");
-    assertEqual(
-        fingerprintSecuritySeed(after.pbkdf2salt),
-        fingerprintSecuritySeed(replacementSeed),
-        "The replacement Security Seed was not stored."
-    );
-    const changedFields = changedSynchronisationParameterFields(before, after);
-    assertEqual(
-        JSON.stringify(changedFields),
-        JSON.stringify(["pbkdf2salt"]),
-        "Replacing the remote Security Seed changed another synchronisation parameter."
-    );
-    return after;
-}
-
-async function runScenario(
-    context: RunnerContext,
-    vaultA: TemporaryVault,
-    vaultB: TemporaryVault
-): Promise<ScenarioEvidence> {
-    const passphrase = `security-seed-e2e-${randomUUID()}`;
-    const source = await inspectSourceEvidence(context.artifactRoot);
-    let sessionA = await startConfiguredSession(context, vaultA, passphrase, "device-a");
-
-    await pushLocalChanges(context.cliBinary, sessionA.cliEnv);
-    await captureStage(context, sessionA, "security-seed-device-a-initial-sync.png");
-    const initialDocument = await fetchSecuritySeedDocument(context);
-    const initial = snapshotSecuritySeedDocument(initialDocument);
-    const cachedBeforeReplacement = await cachedSecuritySeedFingerprint(context.cliBinary, sessionA.cliEnv);
-    assertEqual(
-        cachedBeforeReplacement,
-        initial.fingerprint,
-        "Device A did not cache the initial remote Security Seed."
-    );
-
-    await pauseAutomaticReplication(context.cliBinary, sessionA.cliEnv);
-    const outboundContent = `Encrypted from device A: ${randomUUID()}\n`;
-    await writeNoteViaObsidian(context.cliBinary, sessionA.cliEnv, outboundPath, outboundContent);
-    const outboundEntry = await waitForLocalDatabaseEntry(context.cliBinary, sessionA.cliEnv, outboundPath);
-    await assertEntryNotRemote(context, outboundEntry);
-
-    const replacementSeed = createSecuritySeed();
-    const replacementDocument = await replaceRemoteSecuritySeed(context, initialDocument, replacementSeed);
-    const replacement = snapshotSecuritySeedDocument(replacementDocument);
-    await openNoteViaObsidian(context.cliBinary, sessionA.cliEnv, outboundPath);
-    await captureStage(context, sessionA, "security-seed-device-a-replacement-pending.png");
-    const cachedAfterRemoteReplacement = await cachedSecuritySeedFingerprint(context.cliBinary, sessionA.cliEnv);
-    assertEqual(
-        cachedAfterRemoteReplacement,
-        initial.fingerprint,
-        "Device A did not retain the deliberately stale Security Seed before replication."
-    );
-    assertEqual(
-        replacement.fingerprint,
-        fingerprintSecuritySeed(replacementSeed),
-        "The runner did not install the intended replacement Security Seed."
-    );
-
-    await pushLocalChanges(context.cliBinary, sessionA.cliEnv);
-    const cachedAfterReplication = await cachedSecuritySeedFingerprint(context.cliBinary, sessionA.cliEnv);
-    assertEqual(
-        cachedAfterReplication,
-        replacement.fingerprint,
-        "Device A did not refresh the Security Seed before replication."
-    );
-    const deviceAEncryptedPayload = await waitForEncryptedRemoteEntry(context, outboundEntry);
-    await captureStage(context, sessionA, "security-seed-device-a-refreshed-sync.png");
-    const deviceAHealthBeforeRestart = await inspectSessionHealth(context.cliBinary, sessionA.cliEnv);
-    await stopTrackedSession(context, sessionA);
-
-    const sessionB = await startConfiguredSession(context, vaultB, passphrase, "device-b");
-    await pushLocalChanges(context.cliBinary, sessionB.cliEnv);
-    await waitForPathContent(vaultB.path, outboundPath, outboundContent);
-    await openNoteViaObsidian(context.cliBinary, sessionB.cliEnv, outboundPath);
-    await captureStage(context, sessionB, "security-seed-device-b-received.png");
-
-    await pauseAutomaticReplication(context.cliBinary, sessionB.cliEnv);
-    const returnContent = `Encrypted from device B: ${randomUUID()}\n`;
-    await writeNoteViaObsidian(context.cliBinary, sessionB.cliEnv, returnPath, returnContent);
-    const returnEntry = await waitForLocalDatabaseEntry(context.cliBinary, sessionB.cliEnv, returnPath);
-    await pushLocalChanges(context.cliBinary, sessionB.cliEnv);
-    const deviceBEncryptedPayload = await waitForEncryptedRemoteEntry(context, returnEntry);
-    const deviceBHealth = await inspectSessionHealth(context.cliBinary, sessionB.cliEnv);
-    await stopTrackedSession(context, sessionB);
-
-    sessionA = await startConfiguredSession(context, vaultA, passphrase, "device-a-return");
-    await pushLocalChanges(context.cliBinary, sessionA.cliEnv);
-    await waitForPathContent(vaultA.path, returnPath, returnContent);
-    await openNoteViaObsidian(context.cliBinary, sessionA.cliEnv, returnPath);
-    await captureStage(context, sessionA, "security-seed-device-a-return-received.png");
-
-    const finalDocument = await fetchSecuritySeedDocument(context);
-    const final = snapshotSecuritySeedDocument(finalDocument);
-    assertEqual(
-        final.fingerprint,
-        replacement.fingerprint,
-        "A client rolled the remote Security Seed back after reconnecting."
-    );
-    const finalChangedFields = changedSynchronisationParameterFields(replacementDocument, finalDocument);
-    if (finalChangedFields.length > 0) {
-        throw new Error(
-            `A client rewrote unexpected synchronisation-parameter fields: ${finalChangedFields.join(", ")}`
-        );
-    }
-
-    const deviceAHealthAfterRestart = await inspectSessionHealth(context.cliBinary, sessionA.cliEnv);
-    const deviceAHealth = {
-        matchingErrorMessages: [
-            ...new Set([
-                ...deviceAHealthBeforeRestart.matchingErrorMessages,
-                ...deviceAHealthAfterRestart.matchingErrorMessages,
-            ]),
-        ],
-    };
-    if (deviceAHealth.matchingErrorMessages.length > 0 || deviceBHealth.matchingErrorMessages.length > 0) {
-        throw new Error(
-            `HKDF or Security Seed errors were logged: ${JSON.stringify({
-                deviceA: deviceAHealth.matchingErrorMessages,
-                deviceB: deviceBHealth.matchingErrorMessages,
-            })}`
-        );
-    }
-
-    return {
-        source,
-        securitySeed: {
-            initial,
-            replacement,
-            final,
-            cachedBeforeReplacement,
-            cachedAfterRemoteReplacement,
-            cachedAfterReplication,
-            replacementChangedFields: changedSynchronisationParameterFields(initialDocument, replacementDocument),
-            finalChangedFields,
-        },
-        synchronisation: {
-            deviceAToDeviceB: true,
-            deviceBToDeviceA: true,
-            deviceAEncryptedPayload,
-            deviceBEncryptedPayload,
-        },
-        health: {
-            deviceA: deviceAHealth,
-            deviceB: deviceBHealth,
-        },
-        screenshots: [...context.screenshots],
-    };
-}
-
-async function cleanupResources(
-    context: RunnerContext,
-    vaults: TemporaryVault[],
-    databaseCreated: boolean
-): Promise<TeardownEvidence> {
-    const errors: unknown[] = [];
-    try {
-        await stopTrackedSessions(context);
-    } catch (error) {
-        errors.push(error);
-    }
-    for (const vault of vaults) {
-        try {
-            await vault.dispose();
-        } catch (error) {
-            errors.push(error);
-        }
-    }
-    if (databaseCreated) {
-        try {
-            await deleteCouchDbDatabase(context.couchDb, context.dbName);
-        } catch (error) {
-            errors.push(error);
-        }
-    }
-
-    const sessionsStopped = context.allSessions.every(
-        (session) => session.app.process.exitCode !== null || session.app.process.signalCode !== null
-    );
-    const vaultRemoved = (await Promise.all(vaults.map(async (vault) => !(await pathExists(vault.path))))).every(
-        Boolean
-    );
-    const profileRemoved = (await Promise.all(vaults.map(async (vault) => !(await pathExists(vault.statePath))))).every(
-        Boolean
-    );
-    let databaseRemoved = !databaseCreated;
-    if (databaseCreated) {
-        try {
-            databaseRemoved = !(await couchDbDatabaseExists(context.couchDb, context.dbName));
-        } catch (error) {
-            errors.push(error);
-        }
-    }
-    const evidence = {
-        sessionsStopped,
-        vaultRemoved,
-        profileRemoved,
-        databaseRemoved,
-        remainingTrackedSessions: context.activeSessions.size,
-    };
-    if (!sessionsStopped || !vaultRemoved || !profileRemoved || !databaseRemoved || context.activeSessions.size > 0) {
-        errors.push(new Error(`Security Seed E2E teardown was incomplete: ${JSON.stringify(evidence)}`));
-    }
-    if (errors.length > 0) {
-        throw Object.assign(new MultipleErrors("Security Seed E2E teardown failed.", errors), {
-            evidence,
-        });
-    }
-    return evidence;
-}
-
-async function writeResult(result: unknown): Promise<string> {
-    const outputDirectory = process.env.E2E_OBSIDIAN_DIAGNOSTICS_DIR ?? "/tmp/obsidian-livesync-e2e";
-    const resultPath = join(outputDirectory, "security-seed-reconnect-result.json");
-    await mkdir(outputDirectory, { recursive: true });
-    await writeFile(resultPath, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
-    return resultPath;
-}
-
-async function main(): Promise<void> {
-    if (process.env.E2E_OBSIDIAN_KEEP_VAULT === "true" || process.env.E2E_OBSIDIAN_KEEP_COUCHDB === "true") {
-        throw new Error("The Security Seed reconnect scenario requires strict Vault, profile, and database cleanup.");
-    }
-
-    const binary = requireObsidianBinary();
-    const cli = discoverObsidianCli();
-    if (!cli.binary) {
-        throw new Error(`Could not find obsidian-cli. Checked paths: ${cli.checked.join(", ")}`);
-    }
-    const artifactRoot = resolve(process.env.E2E_OBSIDIAN_ARTIFACT_ROOT ?? process.cwd());
-    const couchDb = await loadCouchDbConfig();
-    const dbName = makeUniqueDatabaseName(couchDb.dbPrefix, "security-seed-reconnect");
-    const context: RunnerContext = {
-        binary,
-        cliBinary: cli.binary,
-        artifactRoot,
-        couchDb,
-        dbName,
-        activeSessions: new Set(),
-        allSessions: [],
-        screenshots: [],
-    };
-    const vaults: TemporaryVault[] = [];
-    let databaseCreated = false;
-    let evidence: ScenarioEvidence | undefined;
-    let scenarioError: unknown;
-    let teardown: TeardownEvidence | undefined;
-    let teardownError: unknown;
-
-    try {
-        await assertCouchDbReachable(couchDb);
-        await createCouchDbDatabase(couchDb, dbName);
-        databaseCreated = true;
-        vaults.push(await createTemporaryVault("obsidian-livesync-security-seed-a-"));
-        vaults.push(await createTemporaryVault("obsidian-livesync-security-seed-b-"));
-        evidence = await runScenario(context, vaults[0], vaults[1]);
-    } catch (error) {
-        scenarioError = error;
-    } finally {
-        try {
-            teardown = await cleanupResources(context, vaults, databaseCreated);
-        } catch (error) {
-            teardownError = error;
-        }
-    }
-
-    if (scenarioError !== undefined || teardownError !== undefined) {
-        const errors = [scenarioError, teardownError].filter((error) => error !== undefined);
-        if (errors.length === 1) {
-            throw errors[0];
-        }
-        throw new MultipleErrors("Security Seed reconnect scenario and teardown both failed.", errors);
-    }
-    if (!evidence || !teardown) {
-        throw new Error("Security Seed reconnect evidence was not produced.");
-    }
-
-    const result = {
-        scenario: "security-seed-reconnect",
-        ...evidence,
-        teardown,
-        limitations: {
-            platformCommonRealObsidian: true,
-            iPadOsBackgroundReconnect: false,
-            androidDeviceLifecycle: false,
-        },
-    };
-    const resultPath = await writeResult(result);
-    console.log(`Security Seed E2E result: ${resultPath}`);
-    console.log(JSON.stringify(result, null, 2));
-}
-
-main().catch((error: unknown) => {
-    console.error(error instanceof Error ? error.stack : error);
-    process.exitCode = 1;
-});

test/e2e-obsidian/scripts/settings-ui.ts

@@ -214,17 +214,6 @@ async function verifyEffectiveSettings(): Promise<void> {
             throw new Error("The Change Log still contains a compatibility or release-note acknowledgement control.");
         }
 
-        await liveSyncSettings.locator('.sls-setting-menu-btn[title="Remote Configuration"]').click();
-        const connectionPanel = liveSyncSettings
-            .locator("h4.sls-setting-panel-title")
-            .filter({ hasText: "Connection settings" })
-            .locator("..");
-        await connectionPanel.waitFor({ state: "visible", timeout: uiTimeoutMs });
-        await connectionPanel.getByText("Saved connections", { exact: true }).waitFor({
-            state: "visible",
-            timeout: uiTimeoutMs,
-        });
-
         await liveSyncSettings.locator('.sls-setting-menu-btn[title="Sync Settings"]').click();
         const deletionPanel = liveSyncSettings
             .locator("h4.sls-setting-panel-title")

test/e2e-obsidian/scripts/startup-scan.ts

@@ -1,13 +1,3 @@
-/**
- * Proves that a configured LiveSync Vault scans files created while Obsidian
- * was stopped. The first launch receives a CouchDB profile using current
- * settings and its acknowledged device-local compatibility marker before the
- * plug-in loads.
- *
- * The second launch reuses the same Vault, profile, local database, and
- * settings without rewriting plug-in data, so the assertion covers an
- * ordinary configured restart rather than the separate onboarding flow.
- */
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import {
@@ -21,8 +11,7 @@ import {
 import { discoverObsidianCli, requireObsidianBinary } from "../runner/environment.ts";
 import {
     assertEqual,
-    createE2eCouchDbPluginData,
-    createE2eObsidianDeviceLocalState,
+    configureCouchDb,
     prepareRemote,
     pushLocalChanges,
     waitForLiveSyncCoreReady,
@@ -58,12 +47,6 @@ async function main(): Promise<void> {
 
     const couchDb = await loadCouchDbConfig();
     const dbName = makeUniqueDatabaseName(couchDb.dbPrefix, "startup-scan");
-    const couchDbSettings = {
-        uri: couchDb.uri,
-        username: couchDb.username,
-        password: couchDb.password,
-        dbName,
-    };
     const vault = await createTemporaryVault();
     let session: ObsidianLiveSyncSession | undefined;
 
@@ -80,11 +63,15 @@ async function main(): Promise<void> {
             cliBinary: cli.binary,
             vault,
             startupGraceMs: Number(process.env.E2E_OBSIDIAN_STARTUP_GRACE_MS ?? 1000),
-            pluginData: createE2eCouchDbPluginData(couchDbSettings),
-            localStorageEntries: createE2eObsidianDeviceLocalState(vault.name),
         });
-        const initialReadiness = await waitForLiveSyncCoreReady(cli.binary, session.cliEnv);
-        assertEqual(initialReadiness.configured, true, "Self-hosted LiveSync did not start configured.");
+        await waitForLiveSyncCoreReady(cli.binary, session.cliEnv);
+        const configured = await configureCouchDb(cli.binary, session.cliEnv, {
+            uri: couchDb.uri,
+            username: couchDb.username,
+            password: couchDb.password,
+            dbName,
+        });
+        assertEqual(configured.isConfigured, true, "Self-hosted LiveSync was not configured.");
         await prepareRemote(cli.binary, session.cliEnv);
         await session.app.stop();
         session = undefined;
@@ -97,8 +84,7 @@ async function main(): Promise<void> {
             vault,
             startupGraceMs: Number(process.env.E2E_OBSIDIAN_STARTUP_GRACE_MS ?? 1000),
         });
-        const restartedReadiness = await waitForLiveSyncCoreReady(cli.binary, session.cliEnv);
-        assertEqual(restartedReadiness.configured, true, "Self-hosted LiveSync lost its configuration on restart.");
+        await waitForLiveSyncCoreReady(cli.binary, session.cliEnv);
 
         const localEntry = await waitForLocalDatabaseEntry(cli.binary, session.cliEnv, notePath);
         await pushLocalChanges(cli.binary, session.cliEnv);

updates.md

@@ -12,111 +12,6 @@ Earlier releases remain available in the 0.25 release history and the legacy rel
 
 ## Unreleased
 
-## 1.0.0-rc.0
-
-27th July, 2026
-
-The work towards 1.0 has become so substantial that I have written [an article about it](https://fancy-syncing.vrtmrz.net/blog/0036-livesync-1_0_0-en.html) (linked again here).
-
-### Important
-
-- This is the first 1.0 release candidate. It remains an opt-in pre-release for BRAT validation and does not replace the latest stable release. Update every participating device before resuming synchronisation, and continue to use a current backup while testing with an existing Vault.
-- An upgraded, copied, or restored Vault may pause replication for an explicit compatibility review. Existing automatic synchronisation choices are preserved and resume only after the decision has been saved.
-
-### Changes consolidated from beta.0 through beta.5
-
-#### Setup and compatibility
-
-- An unconfigured Vault now waits for the user to start setup. Onboarding is offered through a persistent Notice and remains available from **Self-hosted LiveSync settings** → **Setup**.
-- Setup now creates named CouchDB, Object Storage, and P2P connections. Setup URIs preserve their connection names and selections, and reserve Fetch or Rebuild before the ordinary start-up scan begins.
-- Existing Vaults retain their effective legacy settings, including the case-insensitive file-name fallback used when an older release had no explicit case setting.
-- Manual CouchDB setup distinguishes creating the first database from connecting another device. Onboarding requires a successful connection, while Settings can explicitly save an unverified connection and offers each server-setting correction separately.
-- Compatible differences limited to the chunk hash algorithm, chunk size, or splitter version are aligned automatically by default. Existing chunks remain readable, an explicit opt-out remains available, and differences involving incompatible settings still require review.
-
-#### Conflict handling and recovery
-
-- Automatic text and structured-data merge now uses the nearest revision actually shared by both branches. A resolution received from another device no longer recreates the same conflict merely because the Vault still contains the exact content of the removed branch.
-- Edits, logical deletions, and renames made while a file remains conflicted extend the revision displayed on that device. When the relationship cannot be proved, LiveSync preserves the branches for review.
-- **Not now** postpones repeated automatic merge dialogues while retaining the unresolved-conflict warning. Three or more live revisions are reviewed one reproducible pair at a time, completed pairs remain resolved across restart, and explicit commands can reopen a postponed conflict.
-- **Inspect conflicts and file/database differences** compares the Vault with the database winner and every live conflict revision. Compact indicators show missing chunks, `Δsize`, `Δtime`, whether the Vault matches the winner, and whether conflicts remain.
-- Each reported file and live revision has a compact wrench menu for comparison, applying an exact readable revision, recording an exact byte match, storing the Vault content as a child of a selected branch, retrying missing chunks without changing the tree, or explicitly discarding one selected live branch.
-- Unreadable live revisions are preserved during automatic handling. An absent Vault file and a winning logical deletion are treated as agreement unless another live branch still requires attention.
-- Garbage Collection V3 is limited to CouchDB and now protects every live conflict branch, required shared ancestry, and shared chunks. It stops when device progress cannot be verified and reports compaction failure without a contradictory success message.
-
-#### P2P and optional synchronisation features
-
-- P2P and Hidden File Sync remain supported opt-in features. Customisation Sync remains a supported Advanced workflow, while Data Compression remains available but disabled by default.
-- P2P controls remain outside the ordinary CouchDB experience until P2P is configured. The current status pane distinguishes announcing changes, following a peer, and persistent per-device actions.
-- First-device P2P setup can complete its signalling test without another peer online. Fetch on an additional device still requires an available source peer and a completed P2P Rebuild.
-- P2P setup and guidance now distinguish the required signalling relay from optional TURN, describe the replaceable public relay's privacy and availability limits, and reliably close and recreate relay connections across settings changes and database resets.
-- Enabling Hidden File Sync opens one progress Notice before saving the setting and reuses it until the initial scan has finished instead of stacking phase, reload, and restart messages.
-- Broadening selectors, ignore rules, size or modification-time limits, or file-name case handling now rechecks previously received files without requiring another remote update.
-
-#### Interface and operations
-
-- Command-palette actions now use clearer names and appear only when their feature and current context make them usable. Renamed commands retain their identifiers so that existing hotkeys continue to work.
-- Setup and review dialogue text can be selected for copying or translation. Applying an available interface translation no longer holds start-up behind an unsolicited dialogue; a persistent Notice opens the existing details on demand.
-- Action buttons are arranged for narrow mobile screens, long dialogues keep their controls reachable, and persistent Notices no longer cover close controls.
-- Remote-size warnings use persistent clickable Notices. Initial uploads and Rebuild no longer ask to send every chunk in advance; ordinary replication completes the transfer.
-- Obsolete controls for the plug-in trash setting and fixed chunk revisions were removed. The Change Log remains available but no longer opens automatically or tracks an unread count.
-
-#### Other fixes and security
-
-- The optional Custom HTTP Handler used by Object Storage sends the correct byte range from binary request bodies and reports unsupported body types instead of silently sending an empty request.
-- Fly.io setup generates CouchDB and Vault encryption secrets with cryptographically secure randomness. Dependency updates address excessive CPU use from crafted path patterns and `mailto:` links, and the CLI rejects detected path traversal and symbolic-link components before Vault operations.
-- Self-hosted LiveSync now owns its translation catalogue. Commonlib supplies canonical English to other consumers, while translation contributions can be made in the main Self-hosted LiveSync repository.
-
-### Changes since beta.5
-
-- The Hatch action for **Inspect conflicts and file/database differences** is now labelled **Begin inspection** so that its purpose is clear without repeating the setting name.
-- Start-up and full-inspection scans now omit built-in legacy LiveSync log files and recovery flag files before comparing Vault and local-database state. Existing ignored database records remain untouched, and user-configured ignore behaviour is unchanged.
-
-### Testing
-
-- Expanded automated Real Obsidian coverage for upgrades, two-device synchronisation, CouchDB, Object Storage, P2P, Hidden File Sync, mobile dialogues, conflict and revision recovery, failure diagnostics, and strict clean-up.
-- Real CouchDB integration coverage verifies logical deletion, shared and conflict chunk retention, compaction, downstream replication, and recreation of content-addressed chunks.
-- An encrypted Real Obsidian reconnect scenario replaces the remote Security Seed while one client retains the previous value, verifies that synchronisation adopts the replacement without restoring the old value, and proves a bidirectional encrypted round-trip.
-- The beta series was exercised through BRAT on macOS, iOS, and Android, including upgrade from 0.25.83, bidirectional synchronisation, P2P setup, conflict handling, recovery controls, mobile layouts, and start-up with existing configurations. The exact RC artefact will be validated separately after publication.
-
-## 1.0.0-beta.5
-
-26th July, 2026
-
-### Improved
-
-- **Inspect conflicts and file/database differences** now compares the current Vault file with the database winner and every live conflict revision. Compact, mobile-friendly indicators show missing chunks, `Δsize`, `Δtime`, whether the Vault matches the winner, and whether conflict branches remain.
-- Each reported file and live revision now has a compact wrench menu. Its available actions can compare readable text, apply the selected revision to the Vault, record an exact byte match, store the Vault content as a child of the selected branch, retry retrieving missing chunks without changing the revision tree, or discard only the selected live branch after confirmation.
-
-### Fixed
-
-- A winning logical deletion is no longer reported as a missing Vault file when the file is already absent.
-
-### Testing
-
-- Strengthened Real Obsidian coverage for start-up with an existing configuration, Security Seed readiness, failure diagnostics, and P2P status pane placement in separate desktop and mobile sessions.
-
-## 1.0.0-beta.4
-
-25th July, 2026
-
-### Improved
-
-- **Verify and repair all files** now reports the database winner, every conflict revision, missing chunks, and unavailable shared ancestors separately. It can retry an exact revision without changing the tree, while discarding an unreadable live revision requires explicit confirmation.
-- Command-palette actions now use clearer names and appear only when their feature and current context make them usable. Renamed commands keep their identifiers, so hotkeys already assigned to them continue to work. The onboarding wizard can be reopened from **Self-hosted LiveSync settings** → **Setup**.
-- Text in setup and review dialogues can now be selected for copying or translation.
-- When LiveSync adopts an available interface translation on first start-up, it now continues initialisation and leaves a persistent Notice from which the translation details can be opened, instead of waiting for an unsolicited dialogue.
-
-### Fixed
-
-- An unreadable conflict revision is no longer deleted automatically merely because its chunks are unavailable on the current device.
-- Garbage Collection V3 now protects chunks required by every live conflict branch and the available revision ancestry needed to review and merge conflicts, instead of considering only the database winner. The action is offered only for CouchDB because P2P has no central database to compact and does not provide the device inventory required by the workflow. Collection now stops when device progress cannot be verified, and a compaction timeout is no longer followed by a contradictory success message.
-
-### Testing
-
-- Added regressions for revision repair, command availability, selectable dialogues, conflict-aware chunk reachability, device-progress safeguards, and compaction timeouts.
-- Added a real CouchDB integration test for logical chunk deletion, shared and conflict chunk retention, compaction completion, downstream replication, and content-addressed chunk recreation.
-- Added a real Obsidian encrypted reconnect scenario which replaces the remote Security Seed while one client retains the previous value, verifies that synchronisation refreshes it without restoring the old value, and proves a bidirectional encrypted round-trip.
-
 ## 1.0.0-beta.3
 
 24th July, 2026

utils/release-pr-body.mjs

@@ -20,10 +20,9 @@ function inlineCode(value) {
 /**
  * Render the reader-facing checklist for a draft release pull request.
  *
- * The version decides whether the release commit is an immutable SemVer
- * pre-release or a stable version staged through a GitHub pre-release. The
- * base branch is included explicitly because integration previews can target
- * a reviewed integration branch rather than `main`.
+ * The version decides whether publication is stable or pre-release. The base
+ * branch is included explicitly because integration previews can target a
+ * reviewed integration branch rather than `main`.
  *
  * @param {string} version
  * @param {string} baseBranch
@@ -40,28 +39,13 @@ export function renderReleasePrBody(version, baseBranch) {
     const isPrerelease = selectedVersion.includes("-");
     const purpose = isPrerelease
         ? `an immutable pre-release for BRAT validation without replacing the latest stable release`
-        : `a stable version which will first be staged as a GitHub pre-release for BRAT validation`;
+        : `the next stable release`;
     const finaliseInstruction = isPrerelease
         ? "Run the finalise release workflow with this PR's fixed head SHA and `prerelease=true`"
-        : "Run the finalise release workflow with this PR's fixed head SHA, `prerelease=true`, and `publish_cli=false`";
+        : "Run the finalise release workflow with this PR's fixed head SHA and `prerelease=false`";
     const publicationInstruction = isPrerelease
         ? "Publish the GitHub Release as a pre-release without replacing the latest stable release, while keeping this pull request in draft"
-        : "Publish the GitHub Release initially as a pre-release without replacing the latest stable release, while keeping this pull request in draft";
-    const assetInstruction = isPrerelease
-        ? "Confirm the draft GitHub Release assets and the published CLI image, if selected"
-        : "Confirm the draft GitHub Release assets; keep stable CLI publication deferred until BRAT validation passes";
-    const holdInstruction = isPrerelease
-        ? `Publishing and validating this pre-release does not unblock this pull request. Keep it in draft and unmerged, and leave ${baseBranchCode} unchanged.`
-        : `Publishing the GitHub pre-release does not unblock this pull request. Keep it in draft, and leave ${baseBranchCode} unchanged, until the exact published build has passed BRAT validation and has been promoted to the latest stable release.`;
-    const completionInstructions = isPrerelease
-        ? [
-              "- [ ] Keep this pre-release pull request unmerged; close it only through a separate maintainer action",
-          ]
-        : [
-              "- [ ] Remove the pre-release designation and make this exact release the latest stable release",
-              "- [ ] Create the stable CLI tag and publish its `latest` and major-minor image tags, if selected, through a separate maintainer gate",
-              `- [ ] Mark this pull request ready and merge it into ${baseBranchCode} with a merge commit`,
-          ];
+        : "Publish the GitHub Release as the latest stable release while keeping this pull request in draft";
 
     return [
         `This release pull request prepares Self-hosted LiveSync ${versionCode} from ${baseBranchCode} as ${purpose}.`,
@@ -69,7 +53,7 @@ export function renderReleasePrBody(version, baseBranch) {
         "> [!IMPORTANT]",
         "> **Merge intentionally on hold**",
         ">",
-        `> ${holdInstruction}`,
+        `> Publishing the GitHub Release does not unblock this pull request. Keep this pull request in draft, and leave ${baseBranchCode} unchanged, until the exact published build has passed BRAT validation.`,
         "",
         "## Release checklist",
         "",
@@ -78,10 +62,10 @@ export function renderReleasePrBody(version, baseBranch) {
         "- [ ] Confirm `manifest.json`, `versions.json`, workspace package versions, and the locked Commonlib package version",
         "- [ ] Confirm CI has passed",
         `- [ ] ${finaliseInstruction}`,
-        `- [ ] ${assetInstruction}`,
+        "- [ ] Confirm the draft GitHub Release assets and the published CLI image, if selected",
         `- [ ] ${publicationInstruction}`,
         "- [ ] Validate the exact published release with BRAT",
-        ...completionInstructions,
+        `- [ ] Mark this pull request ready and merge it into ${baseBranchCode} with a merge commit`,
         "",
     ].join("\n");
 }

utils/release-process.unit.spec.ts

@@ -4,10 +4,10 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { renderReleasePrBody } from "./release-pr-body.mjs";
 import { ensureTags } from "./release-tags.mjs";
 
 const releaseNotesScript = fileURLToPath(new URL("./release-notes.mjs", import.meta.url));
+const releasePrBodyScript = fileURLToPath(new URL("./release-pr-body.mjs", import.meta.url));
 const versionBumpScript =
     process.env.VERSION_BUMP_SCRIPT || fileURLToPath(new URL("../version-bump.mjs", import.meta.url));
 const workspaceUpdateScript = fileURLToPath(new URL("../update-workspaces.mjs", import.meta.url));
@@ -160,12 +160,13 @@ describe("release notes", () => {
 describe("release workflow", () => {
     it("uses the locked Commonlib package instead of generated fallback declarations", () => {
         const workflow = readFileSync(prepareReleaseWorkflow, "utf8");
-        const body = renderReleasePrBody("1.0.0-beta.0", "integration");
+        const body = runNode(releasePrBodyScript, ["1.0.0-beta.0", "integration"], makeTemporaryDirectory());
 
         expect(workflow).not.toContain("npm run build:lib:types");
         expect(workflow).not.toMatch(/git add[^\n]*_types/);
         expect(workflow).toMatch(/git add[^\n]*package-lock\.json/);
-        expect(body).toContain("locked Commonlib package version");
+        expect(body.status, body.stderr).toBe(0);
+        expect(body.stdout).toContain("locked Commonlib package version");
     });
 
     it("reruns the version lifecycle when the integration branch already selects the release version", () => {
@@ -182,56 +183,36 @@ describe("release workflow", () => {
         expect(workflow).not.toContain("latest stable release");
     });
 
-    it("keeps an immutable pre-release out of its base branch after BRAT validation", () => {
-        const prerelease = renderReleasePrBody("1.0.0-rc.0", "common-library-package-boundary");
+    it("keeps the release PR in draft until BRAT validation", () => {
+        const prerelease = runNode(
+            releasePrBodyScript,
+            ["1.0.0-beta.0", "common-library-package-boundary"],
+            makeTemporaryDirectory()
+        );
 
-        expect(prerelease).toContain("Merge intentionally on hold");
-        expect(prerelease).toContain("Self-hosted LiveSync `1.0.0-rc.0`");
-        expect(prerelease).toContain("leave `common-library-package-boundary` unchanged");
-        expect(prerelease).toContain("prerelease=true");
-        expect(prerelease).toContain(
+        expect(prerelease.status, prerelease.stderr).toBe(0);
+        expect(prerelease.stdout).toContain("Merge intentionally on hold");
+        expect(prerelease.stdout).toContain("Self-hosted LiveSync `1.0.0-beta.0`");
+        expect(prerelease.stdout).toContain("leave `common-library-package-boundary` unchanged");
+        expect(prerelease.stdout).toContain("prerelease=true");
+        expect(prerelease.stdout).toContain(
             "Publish the GitHub Release as a pre-release without replacing the latest stable release"
         );
-        expect(prerelease).toContain("Validate the exact published release with BRAT");
-        expect(prerelease).toContain("Keep this pre-release pull request unmerged");
-        expect(prerelease).toContain("close it only through a separate maintainer action");
-        expect(prerelease).not.toContain("Mark this pull request ready and merge it");
+        expect(prerelease.stdout).toContain("Validate the exact published release with BRAT");
+        expect(prerelease.stdout).toContain(
+            "Mark this pull request ready and merge it into `common-library-package-boundary` with a merge commit"
+        );
     });
 
-    it("publishes a stable version initially as a GitHub pre-release for BRAT validation", () => {
-        const stable = renderReleasePrBody("1.0.0", "main");
+    it("keeps stable release instructions distinct from pre-release instructions", () => {
+        const stable = runNode(releasePrBodyScript, ["1.0.0", "main"], makeTemporaryDirectory());
 
-        expect(stable).toContain("prerelease=true");
-        expect(stable).toContain("publish_cli=false");
-        expect(stable).toContain(
-            "Publish the GitHub Release initially as a pre-release without replacing the latest stable release"
-        );
-        expect(stable).toContain(
-            "Remove the pre-release designation and make this exact release the latest stable release"
-        );
-        expect(stable).toContain(
-            "Create the stable CLI tag and publish its `latest` and major-minor image tags, if selected, through a separate maintainer gate"
-        );
-        expect(stable).toContain("Mark this pull request ready and merge it into `main` with a merge commit");
-        expect(stable).not.toContain("prerelease=false");
-    });
-
-    it("summarises immutable pre-releases separately from stable versions awaiting promotion", () => {
-        const workflow = readFileSync(finaliseReleaseWorkflow, "utf8");
-
-        expect(workflow).toContain('if [[ "${VERSION}" == *-* ]]; then');
-        expect(workflow).toContain(
-            "Keep the release pull request in draft and unmerged after BRAT validation; close it only through a separate maintainer action."
-        );
-        expect(workflow).toContain(
-            "After BRAT validation, remove the pre-release designation and make this exact release the latest stable release before merging the release pull request."
-        );
-        expect(workflow).toContain(
-            'if [[ "${VERSION}" != *-* && "${PRERELEASE}" == "true" && "${PUBLISH_CLI}" == "true" ]]; then'
-        );
-        expect(workflow).toContain(
-            "A stable version staged as a pre-release must use publish_cli=false so that the CLI latest and major-minor image tags do not advance before BRAT validation."
+        expect(stable.status, stable.stderr).toBe(0);
+        expect(stable.stdout).toContain("prerelease=false");
+        expect(stable.stdout).toContain(
+            "Publish the GitHub Release as the latest stable release while keeping this pull request in draft"
         );
+        expect(stable.stdout).not.toContain("as a pre-release without replacing");
     });
 
     it("dispatches the plug-in workflow and lets the CLI tag trigger its own workflow", () => {

versions.json

@@ -9,8 +9,5 @@
     "1.0.0-beta.0": "1.7.2",
     "1.0.0-beta.1": "1.7.2",
     "1.0.0-beta.2": "1.7.2",
-    "1.0.0-beta.3": "1.7.2",
-    "1.0.0-beta.4": "1.7.2",
-    "1.0.0-beta.5": "1.7.2",
-    "1.0.0-rc.0": "1.7.2"
+    "1.0.0-beta.3": "1.7.2"
 }