diff --git a/.github/actions/spelling/allow.txt b/.github/actions/spelling/allow.txt
index 8ef502636..75fe40a6c 100644
--- a/.github/actions/spelling/allow.txt
+++ b/.github/actions/spelling/allow.txt
@@ -56,6 +56,7 @@ blargh
 bools
 bpozdena
 brp
+bsftc
 Btrfs
 btw
 buflen
@@ -373,6 +374,7 @@ pastebin
 permessage
 pfa
 PFN
+pgrep
 phlibi
 phobos
 pidx
@@ -444,6 +446,7 @@ rsnapshot
 rsv
 rtud
 rul
+ruleset
 runstatedir
 runsvdir
 Ruppe
@@ -463,6 +466,7 @@ settime
 setxattr
 sev
 sfn
+sfptc
 sharedstatedir
 sharepoint
 shortnames
diff --git a/.github/workflows/e2e-business-shared-folders.yaml b/.github/workflows/e2e-business-shared-folders.yaml
new file mode 100644
index 000000000..f0203fff9
--- /dev/null
+++ b/.github/workflows/e2e-business-shared-folders.yaml
@@ -0,0 +1,194 @@
+name: E2E Testing - Business Account Shared Folders
+
+on:
+  push:
+    branches-ignore:
+      - master
+      - main
+    paths:
+      - 'src/**'
+      - 'ci/**'
+      - '.github/workflows/e2e-*.yaml'
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  e2e_business_shared_folders:
+    runs-on: ubuntu-latest
+    container: fedora:latest
+    environment:
+      name: e2e-business-shared-folders
+      deployment: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Dependencies
+        run: |
+          dnf -y update
+          dnf -y group install development-tools
+          dnf -y install python3 ldc libcurl-devel sqlite-devel dbus-devel jq
+
+      - name: Build + local install prefix
+        run: |
+          ./configure --prefix="$PWD/.ci/prefix"
+          make -j"$(nproc)"
+          make install
+          "$PWD/.ci/prefix/bin/onedrive" --version
+
+      - name: Prepare isolated HOME
+        run: |
+          set -euo pipefail
+          export HOME="$RUNNER_TEMP/home-business-shared-folders"
+          echo "HOME=$HOME" >> "$GITHUB_ENV"
+          echo "XDG_CONFIG_HOME=$HOME/.config" >> "$GITHUB_ENV"
+          echo "XDG_CACHE_HOME=$HOME/.cache" >> "$GITHUB_ENV"
+          mkdir -p "$HOME"
+
+      - name: Inject refresh token into onedrive config
+        env:
+          BUSINESS_SHARED_REFRESH_TOKEN: ${{ secrets.BUSINESS_SHARED_REFRESH_TOKEN }}
+        run: |
+          set -euo pipefail
+          mkdir -p "$XDG_CONFIG_HOME/onedrive"
+          umask 077
+          printf "%s" "$BUSINESS_SHARED_REFRESH_TOKEN" > "$XDG_CONFIG_HOME/onedrive/refresh_token"
+          chmod 600 "$XDG_CONFIG_HOME/onedrive/refresh_token"
+
+      - name: Run Business Shared Folder E2E harness
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: business-shared-folders
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          python3 -u ci/e2e/run_business_shared_folders.py
+
+      - name: Debug rerun failed Business Shared Folder E2E cases
+        if: always()
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: business-shared-folders
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          set -euo pipefail
+          if [ ! -f ci/e2e/out/results.json ]; then
+            echo "No primary results.json found; skipping debug rerun"
+            exit 0
+          fi
+
+          failed_cases="$(jq -r '[.cases[] | select(.status=="fail") | .id] | unique | join(",")' ci/e2e/out/results.json)"
+          if [ -z "$failed_cases" ]; then
+            echo "No failed Business Shared Folder cases; skipping debug rerun"
+            exit 0
+          fi
+
+          python3 -u ci/e2e/run_business_shared_folders.py \
+            --debug \
+            --output-subdir debug-rerun \
+            --run-label debug-rerun \
+            --case-id "$failed_cases"
+
+      - name: Upload Business Shared Folder E2E artefacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-business-shared-folders
+          path: ci/e2e/out/**
+
+  pr_comment:
+    name: Post PR summary comment
+    needs: [ e2e_business_shared_folders ]
+    runs-on: ubuntu-latest
+    if: always()
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download artefact
+        uses: actions/download-artifact@v4
+        with:
+          name: e2e-business-shared-folders
+          path: artifacts/e2e-business-shared-folders
+
+      - name: Build markdown summary
+        id: summary
+        run: |
+          set -euo pipefail
+
+          primary_results="artifacts/e2e-business-shared-folders/results.json"
+          if [ -f "$primary_results" ]; then
+            f="$primary_results"
+          else
+            f="$(find artifacts/e2e-business-shared-folders \
+              -path '*/debug-rerun/*' -prune -o \
+              -name results.json -type f -print | head -n 1 || true)"
+          fi
+          if [ -z "$f" ] || [ ! -f "$f" ]; then
+            echo "md=⚠️ Business Shared Folder E2E ran but results.json was not found." >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          total=$(jq -r '.cases | length' "$f")
+          passed=$(jq -r '[.cases[] | select(.status=="pass")] | length' "$f")
+          failed=$(jq -r '[.cases[] | select(.status=="fail")] | length' "$f")
+
+          failures=$(jq -r '.cases[]
+            | select(.status=="fail")
+            | "- Test Case \(.id // "????"): \(.name) — \(.reason // "no reason provided")"' "$f" || true)
+
+          md="## Business Account Shared Folder Testing\n"
+          md+="**${total}** Test Cases Run  \n"
+          md+="**${passed}** Test Cases Passed  \n"
+          md+="**${failed}** Test Cases Failed  \n\n"
+
+          if [ "$failed" -gt 0 ] && [ -n "$failures" ]; then
+            md+="### Business Shared Folder Test Failures\n"
+            md+="$failures\n"
+          fi
+
+          echo "md<<EOF" >> "$GITHUB_OUTPUT"
+          echo -e "$md" >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+      - name: Find PR associated with this commit
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const sha = context.sha;
+
+            const prs = await github.rest.repos.listPullRequestsAssociatedWithCommit({
+              owner, repo, commit_sha: sha
+            });
+
+            if (!prs.data.length) {
+              core.setOutput("found", "false");
+              return;
+            }
+
+            core.setOutput("found", "true");
+            core.setOutput("number", String(prs.data[0].number));
+
+      - name: Post PR comment
+        if: steps.pr.outputs.found == 'true'
+        uses: actions/github-script@v7
+        env:
+          COMMENT_MD: ${{ steps.summary.outputs.md }}
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const issue_number = Number("${{ steps.pr.outputs.number }}");
+            const md = process.env.COMMENT_MD || "⚠️ No summary text produced.";
+
+            await github.rest.issues.createComment({
+              owner,
+              repo,
+              issue_number,
+              body: md
+            });
diff --git a/.github/workflows/e2e-business.yaml b/.github/workflows/e2e-business.yaml
new file mode 100644
index 000000000..a72c14101
--- /dev/null
+++ b/.github/workflows/e2e-business.yaml
@@ -0,0 +1,189 @@
+name: E2E Testing - Business Account
+
+on:
+  push:
+    branches-ignore:
+      - master
+      - main
+    paths:
+      - 'src/**'
+      - 'ci/**'
+      - '.github/workflows/e2e-*.yaml'
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  e2e_business:
+    runs-on: ubuntu-latest
+    container: fedora:latest
+    environment:
+      name: e2e-business
+      deployment: false
+    
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Dependencies
+        run: |
+          dnf -y update
+          dnf -y group install development-tools
+          dnf -y install python3 ldc libcurl-devel sqlite-devel dbus-devel jq
+
+      - name: Build + local install prefix
+        run: |
+          ./configure --prefix="$PWD/.ci/prefix"
+          make -j"$(nproc)"
+          make install
+          "$PWD/.ci/prefix/bin/onedrive" --version
+
+      - name: Prepare isolated HOME
+        run: |
+          set -euo pipefail
+          export HOME="$RUNNER_TEMP/home-business"
+          echo "HOME=$HOME" >> "$GITHUB_ENV"
+          echo "XDG_CONFIG_HOME=$HOME/.config" >> "$GITHUB_ENV"
+          echo "XDG_CACHE_HOME=$HOME/.cache" >> "$GITHUB_ENV"
+          mkdir -p "$HOME"
+
+      - name: Inject refresh token into onedrive config
+        env:
+          REFRESH_TOKEN_BUSINESS: ${{ secrets.REFRESH_TOKEN_BUSINESS }}
+        run: |
+          set -euo pipefail
+          mkdir -p "$XDG_CONFIG_HOME/onedrive"
+          umask 077
+          printf "%s" "$REFRESH_TOKEN_BUSINESS" > "$XDG_CONFIG_HOME/onedrive/refresh_token"
+          chmod 600 "$XDG_CONFIG_HOME/onedrive/refresh_token"
+
+      - name: Run E2E harness
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: business
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          python3 -u ci/e2e/run.py
+
+      - name: Debug rerun failed E2E cases
+        if: always()
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: business
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          set -euo pipefail
+          if [ -f ci/e2e/out/results.json ]; then
+            python3 -u ci/e2e/rerun_failures.py \
+              --results ci/e2e/out/results.json \
+              --output-subdir debug-rerun \
+              --run-label debug-rerun \
+              --skip-suite-cleanup
+          else
+            echo "No primary results.json found; skipping debug rerun"
+          fi
+
+      - name: Upload E2E artefacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-business
+          path: ci/e2e/out/**
+
+  pr_comment:
+    name: Post PR summary comment
+    needs: [ e2e_business ]
+    runs-on: ubuntu-latest
+    if: always()
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download artefact
+        uses: actions/download-artifact@v4
+        with:
+          name: e2e-business
+          path: artifacts/e2e-business
+
+      - name: Build markdown summary
+        id: summary
+        run: |
+          set -euo pipefail
+
+          primary_results="artifacts/e2e-business/results.json"
+          if [ -f "$primary_results" ]; then
+            f="$primary_results"
+          else
+            f="$(find artifacts/e2e-business \
+              -path '*/debug-rerun/*' -prune -o \
+              -name results.json -type f -print | head -n 1 || true)"
+          fi
+          if [ -z "$f" ] || [ ! -f "$f" ]; then
+            echo "md=⚠️ E2E ran but results.json was not found." >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          target=$(jq -r '.target // "business"' "$f")
+          total=$(jq -r '.cases | length' "$f")
+          passed=$(jq -r '[.cases[] | select(.status=="pass")] | length' "$f")
+          failed=$(jq -r '[.cases[] | select(.status=="fail")] | length' "$f")
+
+          failures=$(jq -r '.cases[]
+            | select(.status=="fail")
+            | "- Test Case \(.id // "????"): \(.name) — \(.reason // "no reason provided")"' "$f" || true)
+
+          md="## ${target^} Account Testing\n"
+          md+="**${total}** Test Cases Run  \n"
+          md+="**${passed}** Test Cases Passed  \n"
+          md+="**${failed}** Test Cases Failed  \n\n"
+
+          if [ "$failed" -gt 0 ] && [ -n "$failures" ]; then
+            md+="### ${target^} Account Test Failures\n"
+            md+="$failures\n"
+          fi
+
+          echo "md<<EOF" >> "$GITHUB_OUTPUT"
+          echo -e "$md" >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+      - name: Find PR associated with this commit
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const sha = context.sha;
+
+            const prs = await github.rest.repos.listPullRequestsAssociatedWithCommit({
+              owner, repo, commit_sha: sha
+            });
+
+            if (!prs.data.length) {
+              core.setOutput("found", "false");
+              return;
+            }
+
+            core.setOutput("found", "true");
+            core.setOutput("number", String(prs.data[0].number));
+
+      - name: Post PR comment
+        if: steps.pr.outputs.found == 'true'
+        uses: actions/github-script@v7
+        env:
+          COMMENT_MD: ${{ steps.summary.outputs.md }}
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const issue_number = Number("${{ steps.pr.outputs.number }}");
+
+            const md = process.env.COMMENT_MD || "⚠️ No summary text produced.";
+
+            await github.rest.issues.createComment({
+              owner,
+              repo,
+              issue_number,
+              body: md
+            });
diff --git a/.github/workflows/e2e-personal-15char-check.yaml b/.github/workflows/e2e-personal-15char-check.yaml
new file mode 100644
index 000000000..3a0cc3cc4
--- /dev/null
+++ b/.github/workflows/e2e-personal-15char-check.yaml
@@ -0,0 +1,189 @@
+name: E2E Testing - Personal Account with 15 Character driveId Check
+
+on:
+  push:
+    branches-ignore:
+      - master
+      - main
+    paths:
+      - 'src/**'
+      - 'ci/**'
+      - '.github/workflows/e2e-*.yaml'
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  e2e_personal:
+    runs-on: ubuntu-latest
+    container: fedora:latest
+    environment:
+      name: e2e-personal-15char-check
+      deployment: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Dependencies
+        run: |
+          dnf -y update
+          dnf -y group install development-tools
+          dnf -y install python3 ldc libcurl-devel sqlite-devel dbus-devel jq
+
+      - name: Build + local install prefix
+        run: |
+          ./configure --prefix="$PWD/.ci/prefix"
+          make -j"$(nproc)"
+          make install
+          "$PWD/.ci/prefix/bin/onedrive" --version
+
+      - name: Prepare isolated HOME
+        run: |
+          set -euo pipefail
+          export HOME="$RUNNER_TEMP/home-personal"
+          echo "HOME=$HOME" >> "$GITHUB_ENV"
+          echo "XDG_CONFIG_HOME=$HOME/.config" >> "$GITHUB_ENV"
+          echo "XDG_CACHE_HOME=$HOME/.cache" >> "$GITHUB_ENV"
+          mkdir -p "$HOME"
+
+      - name: Inject refresh token into onedrive config
+        env:
+          REFRESH_TOKEN_PERSONAL: ${{ secrets.REFRESH_TOKEN_PERSONAL }}
+        run: |
+          set -euo pipefail
+          mkdir -p "$XDG_CONFIG_HOME/onedrive"
+          umask 077
+          printf "%s" "$REFRESH_TOKEN_PERSONAL" > "$XDG_CONFIG_HOME/onedrive/refresh_token"
+          chmod 600 "$XDG_CONFIG_HOME/onedrive/refresh_token"
+
+      - name: Run E2E harness
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: personal
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          python3 -u ci/e2e/run.py
+
+      - name: Debug rerun failed E2E cases
+        if: always()
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: personal
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          set -euo pipefail
+          if [ -f ci/e2e/out/results.json ]; then
+            python3 -u ci/e2e/rerun_failures.py \
+              --results ci/e2e/out/results.json \
+              --output-subdir debug-rerun \
+              --run-label debug-rerun \
+              --skip-suite-cleanup
+          else
+            echo "No primary results.json found; skipping debug rerun"
+          fi
+
+      - name: Upload E2E artefacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-personal-15char-check
+          path: ci/e2e/out/**
+
+  pr_comment:
+    name: Post PR summary comment
+    needs: [ e2e_personal ]
+    runs-on: ubuntu-latest
+    if: always()
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download artefact
+        uses: actions/download-artifact@v4
+        with:
+          name: e2e-personal-15char-check
+          path: artifacts/e2e-personal-15char-check
+
+      - name: Build markdown summary
+        id: summary
+        run: |
+          set -euo pipefail
+
+          primary_results="artifacts/e2e-personal-15char-check/results.json"
+          if [ -f "$primary_results" ]; then
+            f="$primary_results"
+          else
+            f="$(find artifacts/e2e-personal-15char-check \
+              -path '*/debug-rerun/*' -prune -o \
+              -name results.json -type f -print | head -n 1 || true)"
+          fi
+          if [ -z "$f" ] || [ ! -f "$f" ]; then
+            echo "md=⚠️ E2E ran but results.json was not found." >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          target=$(jq -r '.target // "personal"' "$f")
+          total=$(jq -r '.cases | length' "$f")
+          passed=$(jq -r '[.cases[] | select(.status=="pass")] | length' "$f")
+          failed=$(jq -r '[.cases[] | select(.status=="fail")] | length' "$f")
+
+          failures=$(jq -r '.cases[]
+            | select(.status=="fail")
+            | "- Test Case \(.id // "????"): \(.name) — \(.reason // "no reason provided")"' "$f" || true)
+
+          md="## ${target^} Account Testing - 15 Character 'driveId'\n"
+          md+="**${total}** Test Cases Run  \n"
+          md+="**${passed}** Test Cases Passed  \n"
+          md+="**${failed}** Test Cases Failed  \n\n"
+
+          if [ "$failed" -gt 0 ] && [ -n "$failures" ]; then
+            md+="### ${target^} Account Test Failures\n"
+            md+="$failures\n"
+          fi
+
+          echo "md<<EOF" >> "$GITHUB_OUTPUT"
+          echo -e "$md" >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+      - name: Find PR associated with this commit
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const sha = context.sha;
+
+            const prs = await github.rest.repos.listPullRequestsAssociatedWithCommit({
+              owner, repo, commit_sha: sha
+            });
+
+            if (!prs.data.length) {
+              core.setOutput("found", "false");
+              return;
+            }
+
+            core.setOutput("found", "true");
+            core.setOutput("number", String(prs.data[0].number));
+
+      - name: Post PR comment
+        if: steps.pr.outputs.found == 'true'
+        uses: actions/github-script@v7
+        env:
+          COMMENT_MD: ${{ steps.summary.outputs.md }}
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const issue_number = Number("${{ steps.pr.outputs.number }}");
+
+            const md = process.env.COMMENT_MD || "⚠️ No summary text produced.";
+
+            await github.rest.issues.createComment({
+              owner,
+              repo,
+              issue_number,
+              body: md
+            });
diff --git a/.github/workflows/e2e-personal-shared-folders.yaml b/.github/workflows/e2e-personal-shared-folders.yaml
new file mode 100644
index 000000000..abd614de7
--- /dev/null
+++ b/.github/workflows/e2e-personal-shared-folders.yaml
@@ -0,0 +1,194 @@
+name: E2E Testing - Personal Account Shared Folders
+
+on:
+  push:
+    branches-ignore:
+      - master
+      - main
+    paths:
+      - 'src/**'
+      - 'ci/**'
+      - '.github/workflows/e2e-*.yaml'
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  e2e_personal_shared_folders:
+    runs-on: ubuntu-latest
+    container: fedora:latest
+    environment:
+      name: e2e-personal-shared-folders
+      deployment: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Dependencies
+        run: |
+          dnf -y update
+          dnf -y group install development-tools
+          dnf -y install python3 ldc libcurl-devel sqlite-devel dbus-devel jq
+
+      - name: Build + local install prefix
+        run: |
+          ./configure --prefix="$PWD/.ci/prefix"
+          make -j"$(nproc)"
+          make install
+          "$PWD/.ci/prefix/bin/onedrive" --version
+
+      - name: Prepare isolated HOME
+        run: |
+          set -euo pipefail
+          export HOME="$RUNNER_TEMP/home-personal-shared-folders"
+          echo "HOME=$HOME" >> "$GITHUB_ENV"
+          echo "XDG_CONFIG_HOME=$HOME/.config" >> "$GITHUB_ENV"
+          echo "XDG_CACHE_HOME=$HOME/.cache" >> "$GITHUB_ENV"
+          mkdir -p "$HOME"
+
+      - name: Inject refresh token into onedrive config
+        env:
+          REFRESH_TOKEN_PERSONAL_SHARED_FOLDERS: ${{ secrets.REFRESH_TOKEN_PERSONAL_SHARED_FOLDERS }}
+        run: |
+          set -euo pipefail
+          mkdir -p "$XDG_CONFIG_HOME/onedrive"
+          umask 077
+          printf "%s" "$REFRESH_TOKEN_PERSONAL_SHARED_FOLDERS" > "$XDG_CONFIG_HOME/onedrive/refresh_token"
+          chmod 600 "$XDG_CONFIG_HOME/onedrive/refresh_token"
+
+      - name: Run Personal Shared Folder E2E harness
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: personal-shared-folders
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          python3 -u ci/e2e/run_personal_shared_folders.py
+
+      - name: Debug rerun failed Personal Shared Folder E2E cases
+        if: always()
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: personal-shared-folders
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          set -euo pipefail
+          if [ ! -f ci/e2e/out/results.json ]; then
+            echo "No primary results.json found; skipping debug rerun"
+            exit 0
+          fi
+
+          failed_cases="$(jq -r '[.cases[] | select(.status=="fail") | .id] | unique | join(",")' ci/e2e/out/results.json)"
+          if [ -z "$failed_cases" ]; then
+            echo "No failed Personal Shared Folder cases; skipping debug rerun"
+            exit 0
+          fi
+
+          python3 -u ci/e2e/run_personal_shared_folders.py \
+            --debug \
+            --output-subdir debug-rerun \
+            --run-label debug-rerun \
+            --case-id "$failed_cases"
+
+      - name: Upload Personal Shared Folder E2E artefacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-personal-shared-folders
+          path: ci/e2e/out/**
+
+  pr_comment:
+    name: Post PR summary comment
+    needs: [ e2e_personal_shared_folders ]
+    runs-on: ubuntu-latest
+    if: always()
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download artefact
+        uses: actions/download-artifact@v4
+        with:
+          name: e2e-personal-shared-folders
+          path: artifacts/e2e-personal-shared-folders
+
+      - name: Build markdown summary
+        id: summary
+        run: |
+          set -euo pipefail
+
+          primary_results="artifacts/e2e-personal-shared-folders/results.json"
+          if [ -f "$primary_results" ]; then
+            f="$primary_results"
+          else
+            f="$(find artifacts/e2e-personal-shared-folders \
+              -path '*/debug-rerun/*' -prune -o \
+              -name results.json -type f -print | head -n 1 || true)"
+          fi
+          if [ -z "$f" ] || [ ! -f "$f" ]; then
+            echo "md=⚠️ Personal Shared Folder E2E ran but results.json was not found." >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          total=$(jq -r '.cases | length' "$f")
+          passed=$(jq -r '[.cases[] | select(.status=="pass")] | length' "$f")
+          failed=$(jq -r '[.cases[] | select(.status=="fail")] | length' "$f")
+
+          failures=$(jq -r '.cases[]
+            | select(.status=="fail")
+            | "- Test Case \(.id // "????"): \(.name) — \(.reason // "no reason provided")"' "$f" || true)
+
+          md="## Personal Account Shared Folder Testing\n"
+          md+="**${total}** Test Cases Run  \n"
+          md+="**${passed}** Test Cases Passed  \n"
+          md+="**${failed}** Test Cases Failed  \n\n"
+
+          if [ "$failed" -gt 0 ] && [ -n "$failures" ]; then
+            md+="### Personal Shared Folder Test Failures\n"
+            md+="$failures\n"
+          fi
+
+          echo "md<<EOF" >> "$GITHUB_OUTPUT"
+          echo -e "$md" >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+      - name: Find PR associated with this commit
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const sha = context.sha;
+
+            const prs = await github.rest.repos.listPullRequestsAssociatedWithCommit({
+              owner, repo, commit_sha: sha
+            });
+
+            if (!prs.data.length) {
+              core.setOutput("found", "false");
+              return;
+            }
+
+            core.setOutput("found", "true");
+            core.setOutput("number", String(prs.data[0].number));
+
+      - name: Post PR comment
+        if: steps.pr.outputs.found == 'true'
+        uses: actions/github-script@v7
+        env:
+          COMMENT_MD: ${{ steps.summary.outputs.md }}
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const issue_number = Number("${{ steps.pr.outputs.number }}");
+            const md = process.env.COMMENT_MD || "⚠️ No summary text produced.";
+
+            await github.rest.issues.createComment({
+              owner,
+              repo,
+              issue_number,
+              body: md
+            });
diff --git a/.github/workflows/e2e-personal.yaml b/.github/workflows/e2e-personal.yaml
new file mode 100644
index 000000000..3a7e66dd2
--- /dev/null
+++ b/.github/workflows/e2e-personal.yaml
@@ -0,0 +1,189 @@
+name: E2E Testing - Personal Account
+
+on:
+  push:
+    branches-ignore:
+      - master
+      - main
+    paths:
+      - 'src/**'
+      - 'ci/**'
+      - '.github/workflows/e2e-*.yaml'
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  e2e_personal:
+    runs-on: ubuntu-latest
+    container: fedora:latest
+    environment:
+      name: e2e-personal
+      deployment: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Dependencies
+        run: |
+          dnf -y update
+          dnf -y group install development-tools
+          dnf -y install python3 ldc libcurl-devel sqlite-devel dbus-devel jq
+
+      - name: Build + local install prefix
+        run: |
+          ./configure --prefix="$PWD/.ci/prefix"
+          make -j"$(nproc)"
+          make install
+          "$PWD/.ci/prefix/bin/onedrive" --version
+
+      - name: Prepare isolated HOME
+        run: |
+          set -euo pipefail
+          export HOME="$RUNNER_TEMP/home-personal"
+          echo "HOME=$HOME" >> "$GITHUB_ENV"
+          echo "XDG_CONFIG_HOME=$HOME/.config" >> "$GITHUB_ENV"
+          echo "XDG_CACHE_HOME=$HOME/.cache" >> "$GITHUB_ENV"
+          mkdir -p "$HOME"
+
+      - name: Inject refresh token into onedrive config
+        env:
+          REFRESH_TOKEN_PERSONAL: ${{ secrets.REFRESH_TOKEN_PERSONAL }}
+        run: |
+          set -euo pipefail
+          mkdir -p "$XDG_CONFIG_HOME/onedrive"
+          umask 077
+          printf "%s" "$REFRESH_TOKEN_PERSONAL" > "$XDG_CONFIG_HOME/onedrive/refresh_token"
+          chmod 600 "$XDG_CONFIG_HOME/onedrive/refresh_token"
+
+      - name: Run E2E harness
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: personal
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          python3 -u ci/e2e/run.py
+
+      - name: Debug rerun failed E2E cases
+        if: always()
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: personal
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          set -euo pipefail
+          if [ -f ci/e2e/out/results.json ]; then
+            python3 -u ci/e2e/rerun_failures.py \
+              --results ci/e2e/out/results.json \
+              --output-subdir debug-rerun \
+              --run-label debug-rerun \
+              --skip-suite-cleanup
+          else
+            echo "No primary results.json found; skipping debug rerun"
+          fi
+
+      - name: Upload E2E artefacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-personal
+          path: ci/e2e/out/**
+
+  pr_comment:
+    name: Post PR summary comment
+    needs: [ e2e_personal ]
+    runs-on: ubuntu-latest
+    if: always()
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download artefact
+        uses: actions/download-artifact@v4
+        with:
+          name: e2e-personal
+          path: artifacts/e2e-personal
+
+      - name: Build markdown summary
+        id: summary
+        run: |
+          set -euo pipefail
+
+          primary_results="artifacts/e2e-personal/results.json"
+          if [ -f "$primary_results" ]; then
+            f="$primary_results"
+          else
+            f="$(find artifacts/e2e-personal \
+              -path '*/debug-rerun/*' -prune -o \
+              -name results.json -type f -print | head -n 1 || true)"
+          fi
+          if [ -z "$f" ] || [ ! -f "$f" ]; then
+            echo "md=⚠️ E2E ran but results.json was not found." >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          target=$(jq -r '.target // "personal"' "$f")
+          total=$(jq -r '.cases | length' "$f")
+          passed=$(jq -r '[.cases[] | select(.status=="pass")] | length' "$f")
+          failed=$(jq -r '[.cases[] | select(.status=="fail")] | length' "$f")
+
+          failures=$(jq -r '.cases[]
+            | select(.status=="fail")
+            | "- Test Case \(.id // "????"): \(.name) — \(.reason // "no reason provided")"' "$f" || true)
+
+          md="## ${target^} Account Testing\n"
+          md+="**${total}** Test Cases Run  \n"
+          md+="**${passed}** Test Cases Passed  \n"
+          md+="**${failed}** Test Cases Failed  \n\n"
+
+          if [ "$failed" -gt 0 ] && [ -n "$failures" ]; then
+            md+="### ${target^} Account Test Failures\n"
+            md+="$failures\n"
+          fi
+
+          echo "md<<EOF" >> "$GITHUB_OUTPUT"
+          echo -e "$md" >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+      - name: Find PR associated with this commit
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const sha = context.sha;
+
+            const prs = await github.rest.repos.listPullRequestsAssociatedWithCommit({
+              owner, repo, commit_sha: sha
+            });
+
+            if (!prs.data.length) {
+              core.setOutput("found", "false");
+              return;
+            }
+
+            core.setOutput("found", "true");
+            core.setOutput("number", String(prs.data[0].number));
+
+      - name: Post PR comment
+        if: steps.pr.outputs.found == 'true'
+        uses: actions/github-script@v7
+        env:
+          COMMENT_MD: ${{ steps.summary.outputs.md }}
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const issue_number = Number("${{ steps.pr.outputs.number }}");
+
+            const md = process.env.COMMENT_MD || "⚠️ No summary text produced.";
+
+            await github.rest.issues.createComment({
+              owner,
+              repo,
+              issue_number,
+              body: md
+            });
diff --git a/.github/workflows/e2e-sharepoint.yaml b/.github/workflows/e2e-sharepoint.yaml
new file mode 100644
index 000000000..0dc3ac022
--- /dev/null
+++ b/.github/workflows/e2e-sharepoint.yaml
@@ -0,0 +1,192 @@
+name: E2E Testing - SharePoint documentLibrary Configuration
+
+on:
+  push:
+    branches-ignore:
+      - master
+      - main
+    paths:
+      - 'src/**'
+      - 'ci/**'
+      - '.github/workflows/e2e-*.yaml'
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  e2e_sharepoint:
+    runs-on: ubuntu-latest
+    container: fedora:latest
+    environment:
+      name: e2e-sharepoint
+      deployment: false    
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Dependencies
+        run: |
+          dnf -y update
+          dnf -y group install development-tools
+          dnf -y install python3 ldc libcurl-devel sqlite-devel dbus-devel jq
+
+      - name: Build + local install prefix
+        run: |
+          ./configure --prefix="$PWD/.ci/prefix"
+          make -j"$(nproc)"
+          make install
+          "$PWD/.ci/prefix/bin/onedrive" --version
+
+      - name: Prepare isolated HOME
+        run: |
+          set -euo pipefail
+          export HOME="$RUNNER_TEMP/home-sharepoint"
+          echo "HOME=$HOME" >> "$GITHUB_ENV"
+          echo "XDG_CONFIG_HOME=$HOME/.config" >> "$GITHUB_ENV"
+          echo "XDG_CACHE_HOME=$HOME/.cache" >> "$GITHUB_ENV"
+          mkdir -p "$HOME"
+
+      - name: Inject refresh token and SharePoint drive_id into onedrive config
+        env:
+          REFRESH_TOKEN_BUSINESS: ${{ secrets.REFRESH_TOKEN_BUSINESS }}
+          SHAREPOINT_DRIVEID: ${{ secrets.SHAREPOINT_DRIVEID }}
+        run: |
+          set -euo pipefail
+          mkdir -p "$XDG_CONFIG_HOME/onedrive"
+          umask 077
+          printf "%s" "$REFRESH_TOKEN_BUSINESS" > "$XDG_CONFIG_HOME/onedrive/refresh_token"
+          chmod 600 "$XDG_CONFIG_HOME/onedrive/refresh_token"
+          printf 'drive_id = "%s"\n' "$SHAREPOINT_DRIVEID" > "$XDG_CONFIG_HOME/onedrive/config.sharepoint"
+          chmod 600 "$XDG_CONFIG_HOME/onedrive/config.sharepoint"
+
+      - name: Run E2E harness
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: sharepoint
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          python3 -u ci/e2e/run.py
+
+      - name: Debug rerun failed E2E cases
+        if: always()
+        env:
+          ONEDRIVE_BIN: ${{ github.workspace }}/.ci/prefix/bin/onedrive
+          E2E_TARGET: sharepoint
+          RUN_ID: ${{ github.run_id }}
+          PYTHONUNBUFFERED: "1"
+        run: |
+          set -euo pipefail
+          if [ -f ci/e2e/out/results.json ]; then
+            python3 -u ci/e2e/rerun_failures.py \
+              --results ci/e2e/out/results.json \
+              --output-subdir debug-rerun \
+              --run-label debug-rerun \
+              --skip-suite-cleanup
+          else
+            echo "No primary results.json found; skipping debug rerun"
+          fi
+
+      - name: Upload E2E artefacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-sharepoint
+          path: ci/e2e/out/**
+
+  pr_comment:
+    name: Post PR summary comment
+    needs: [ e2e_sharepoint ]
+    runs-on: ubuntu-latest
+    if: always()
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download artefact
+        uses: actions/download-artifact@v4
+        with:
+          name: e2e-sharepoint
+          path: artifacts/e2e-sharepoint
+
+      - name: Build markdown summary
+        id: summary
+        run: |
+          set -euo pipefail
+
+          primary_results="artifacts/e2e-sharepoint/results.json"
+          if [ -f "$primary_results" ]; then
+            f="$primary_results"
+          else
+            f="$(find artifacts/e2e-sharepoint \
+              -path '*/debug-rerun/*' -prune -o \
+              -name results.json -type f -print | head -n 1 || true)"
+          fi
+          if [ -z "$f" ] || [ ! -f "$f" ]; then
+            echo "md=⚠️ E2E ran but results.json was not found." >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          target=$(jq -r '.target // "sharepoint"' "$f")
+          total=$(jq -r '.cases | length' "$f")
+          passed=$(jq -r '[.cases[] | select(.status=="pass")] | length' "$f")
+          failed=$(jq -r '[.cases[] | select(.status=="fail")] | length' "$f")
+
+          failures=$(jq -r '.cases[]
+            | select(.status=="fail")
+            | "- Test Case \(.id // "????"): \(.name) — \(.reason // "no reason provided")"' "$f" || true)
+
+          md="## ${target^} Account Testing\n"
+          md+="**${total}** Test Cases Run  \n"
+          md+="**${passed}** Test Cases Passed  \n"
+          md+="**${failed}** Test Cases Failed  \n\n"
+
+          if [ "$failed" -gt 0 ] && [ -n "$failures" ]; then
+            md+="### ${target^} Account Test Failures\n"
+            md+="$failures\n"
+          fi
+
+          echo "md<<EOF" >> "$GITHUB_OUTPUT"
+          echo -e "$md" >> "$GITHUB_OUTPUT"
+          echo "EOF" >> "$GITHUB_OUTPUT"
+
+      - name: Find PR associated with this commit
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const sha = context.sha;
+
+            const prs = await github.rest.repos.listPullRequestsAssociatedWithCommit({
+              owner, repo, commit_sha: sha
+            });
+
+            if (!prs.data.length) {
+              core.setOutput("found", "false");
+              return;
+            }
+
+            core.setOutput("found", "true");
+            core.setOutput("number", String(prs.data[0].number));
+
+      - name: Post PR comment
+        if: steps.pr.outputs.found == 'true'
+        uses: actions/github-script@v7
+        env:
+          COMMENT_MD: ${{ steps.summary.outputs.md }}
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const issue_number = Number("${{ steps.pr.outputs.number }}");
+
+            const md = process.env.COMMENT_MD || "⚠️ No summary text produced.";
+
+            await github.rest.issues.createComment({
+              owner,
+              repo,
+              issue_number,
+              body: md
+            });
diff --git a/.github/workflows/smoke-test.yaml b/.github/workflows/smoke-test.yaml
index 61e1263ed..f087df872 100644
--- a/.github/workflows/smoke-test.yaml
+++ b/.github/workflows/smoke-test.yaml
@@ -5,7 +5,15 @@ on:
     branches:
       - master
       - feature/**
+    paths:
+      - 'src/**'
+      - '.github/workflows/smoke-test.yaml'
+      - '.github/gdb/**'
   pull_request:
+    paths:
+      - 'src/**'
+      - '.github/workflows/smoke-test.yaml'      
+      - '.github/gdb/**'
   workflow_dispatch:
 
 permissions:
@@ -538,4 +546,4 @@ jobs:
         with:
           name: smoke-monitor-fedora-${{ matrix.fedora }}-logs
           path: /tmp/onedrive-smoke/
-          if-no-files-found: warn
\ No newline at end of file
+          if-no-files-found: warn
diff --git a/.github/workflows/testbuild.yaml b/.github/workflows/testbuild.yaml
index 91c51691c..b64ca7d01 100644
--- a/.github/workflows/testbuild.yaml
+++ b/.github/workflows/testbuild.yaml
@@ -3,9 +3,14 @@ name: Test Build
 on:
   push:
     branches: [ "master" ]
+    paths:
+      - 'src/**'
+      - '.github/workflows/testbuild.yaml'
   pull_request:
     branches: [ "master" ]
-
+    paths:
+      - 'src/**'
+      - '.github/workflows/testbuild.yaml'
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -38,4 +43,4 @@ jobs:
       run: sudo make install
       
     - name: Run
-      run: onedrive --version
\ No newline at end of file
+      run: onedrive --version
diff --git a/Makefile.in b/Makefile.in
index 6e39b0a16..653687588 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -58,7 +58,7 @@ endif
 system_unit_files = contrib/systemd/onedrive@.service
 user_unit_files = contrib/systemd/onedrive.service
 
-DOCFILES = readme.md config LICENSE changelog.md docs/advanced-usage.md docs/application-config-options.md docs/application-security.md docs/business-shared-items.md docs/client-architecture.md docs/contributing.md docs/docker.md docs/install.md docs/national-cloud-deployments.md docs/podman.md docs/privacy-policy.md docs/sharepoint-libraries.md docs/terms-of-service.md docs/ubuntu-package-install.md docs/usage.md docs/known-issues.md docs/webhooks.md docs/server-side-filtering-limitations.md
+DOCFILES = readme.md config LICENSE changelog.md docs/advanced-usage.md docs/application-config-options.md docs/application-security.md docs/business-shared-items.md docs/client-architecture.md docs/contributing.md docs/docker.md docs/install.md docs/national-cloud-deployments.md docs/podman.md docs/privacy-policy.md docs/sharepoint-libraries.md docs/terms-of-service.md docs/ubuntu-package-install.md docs/usage.md docs/known-issues.md docs/webhooks.md docs/server-side-filtering-limitations.md docs/end_to_end_testing.md
 
 ifneq ("$(wildcard /etc/redhat-release)","")
 RHEL = $(shell cat /etc/redhat-release | grep -E "(Red Hat Enterprise Linux|CentOS|AlmaLinux)" | wc -l)
diff --git a/ci/e2e/README-rerun.md b/ci/e2e/README-rerun.md
new file mode 100644
index 000000000..1331b0c5f
--- /dev/null
+++ b/ci/e2e/README-rerun.md
@@ -0,0 +1,55 @@
+# E2E automatic failure rerun support
+
+This folder now supports a two-pass CI model:
+
+1. Run the primary E2E suite normally using `ci/e2e/run.py`
+2. Parse `results.json` and automatically rerun only failed cases/scenarios with debug enabled using `ci/e2e/rerun_failures.py`
+
+## Primary run
+
+```bash
+python3 -u ci/e2e/run.py
+```
+
+## Automatic debug rerun
+
+```bash
+python3 -u ci/e2e/rerun_failures.py   --results ci/e2e/out/results.json   --output-subdir debug-rerun   --run-label debug-rerun
+```
+
+This will:
+- read the failed cases from the primary `results.json`
+- narrow the rerun to only failed case IDs
+- narrow scenario-based cases to only failed scenario IDs when available
+- rerun with debug verbosity enabled
+- write rerun outputs into `ci/e2e/out/debug-rerun/`
+
+## Direct filtered reruns
+
+### Rerun one case
+
+```bash
+python3 -u ci/e2e/run.py --case-id 0024 --debug --output-subdir tc0024-debug
+```
+
+### Rerun multiple cases
+
+```bash
+python3 -u ci/e2e/run.py --case-id 0002,0021,0024 --debug --output-subdir targeted-debug
+```
+
+### Rerun only selected scenarios
+
+```bash
+python3 -u ci/e2e/run.py   --case-id 0002,0021   --scenario 0002:SL-0004,SL-0018   --scenario 0021:RT-0001   --debug   --output-subdir targeted-scenarios-debug
+```
+
+## Environment-driven controls
+
+These are also supported if you prefer using workflow env vars:
+- `E2E_DEBUG=1`
+- `E2E_OUTPUT_SUBDIR=<subdir>`
+- `E2E_RUN_LABEL=<label>`
+- `E2E_SKIP_SUITE_CLEANUP=1`
+- `E2E_SELECTED_CASES=0002,0021`
+- `E2E_SELECTED_SCENARIOS_JSON={"0002": ["SL-0004"], "0021": ["RT-0001"]}`
diff --git a/ci/e2e/framework/__init__.py b/ci/e2e/framework/__init__.py
new file mode 100644
index 000000000..92e2619c9
--- /dev/null
+++ b/ci/e2e/framework/__init__.py
@@ -0,0 +1 @@
+from framework.base import CaseLayout, E2ETestCase
diff --git a/ci/e2e/framework/base.py b/ci/e2e/framework/base.py
new file mode 100644
index 000000000..2d7558e15
--- /dev/null
+++ b/ci/e2e/framework/base.py
@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import reset_directory, write_text_file
+
+
+@dataclass(frozen=True)
+class CaseLayout:
+    """Standard per-case working layout inside the E2E harness."""
+
+    case_id: str
+    work_dir: Path
+    log_dir: Path
+    state_dir: Path
+
+
+class E2ETestCase(ABC):
+    """
+    Base class for all E2E test cases.
+
+    The class now provides a shared set of helper methods so every testcase can
+    follow the same harness process for:
+    - preparing per-case directories
+    - writing metadata/artifacts
+    - returning pass/fail results consistently
+    - performing basic filesystem assertions
+    """
+
+    case_id: str = ""
+    name: str = ""
+    description: str = ""
+
+    @abstractmethod
+    def run(self, context: E2EContext) -> TestResult:
+        """Execute the test case and return a structured TestResult."""
+        raise NotImplementedError
+
+    def prepare_case_layout(
+        self,
+        context: E2EContext,
+        *,
+        case_dir_name: str | None = None,
+        ensure_refresh_token: bool = True,
+        extra_reset_paths: Iterable[Path] | None = None,
+    ) -> CaseLayout:
+        """
+        Reset the standard work/log/state directories for a testcase and return
+        their paths in a single structured object.
+        """
+        directory_name = case_dir_name or f"tc{self.case_id}"
+        layout = CaseLayout(
+            case_id=self.case_id,
+            work_dir=context.work_root / directory_name,
+            log_dir=context.logs_dir / directory_name,
+            state_dir=context.state_dir / directory_name,
+        )
+
+        reset_directory(layout.work_dir)
+        reset_directory(layout.log_dir)
+        reset_directory(layout.state_dir)
+
+        if extra_reset_paths:
+            for path in extra_reset_paths:
+                reset_directory(path)
+
+        if ensure_refresh_token:
+            context.ensure_refresh_token_available()
+
+        return layout
+
+    def write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        """Backward-compatible alias used by existing testcase implementations."""
+        self.write_metadata(metadata_file, details)
+
+    def pass_result(self, *args, **kwargs) -> TestResult:
+        """
+        Return a passing TestResult while preserving compatibility with both the
+        original testcase call style and the newer helper style.
+
+        Supported forms:
+        - self.pass_result(self.case_id, self.name, artifacts, details)
+        - self.pass_result(case_id=..., name=..., artifacts=..., details=...)
+        - self.pass_result(artifacts=..., details=...)
+        """
+        if args:
+            return TestResult.pass_result(*args, **kwargs)
+
+        if "case_id" in kwargs or "name" in kwargs:
+            return TestResult.pass_result(**kwargs)
+
+        return TestResult.pass_result(
+            case_id=self.case_id,
+            name=self.name,
+            artifacts=kwargs.get("artifacts"),
+            details=kwargs.get("details"),
+        )
+
+    def fail_result(self, *args, **kwargs) -> TestResult:
+        """
+        Return a failing TestResult while preserving compatibility with both the
+        original testcase call style and the newer helper style.
+
+        Supported forms:
+        - self.fail_result(self.case_id, self.name, reason, artifacts, details)
+        - self.fail_result(case_id=..., name=..., reason=..., artifacts=..., details=...)
+        - self.fail_result(reason=..., artifacts=..., details=...)
+        """
+        if args:
+            return TestResult.fail_result(*args, **kwargs)
+
+        if "case_id" in kwargs or "name" in kwargs:
+            return TestResult.fail_result(**kwargs)
+
+        return TestResult.fail_result(
+            case_id=self.case_id,
+            name=self.name,
+            reason=kwargs.get("reason", ""),
+            artifacts=kwargs.get("artifacts"),
+            details=kwargs.get("details"),
+        )
+
+    def write_manifest_artifact(self, root: Path, output_file: Path) -> list[str]:
+        entries = build_manifest(root)
+        write_manifest(output_file, entries)
+        return entries
+
+    def assert_exists(self, path: Path, message: str | None = None) -> None:
+        if not path.exists():
+            raise AssertionError(message or f"Expected path to exist: {path}")
+
+    def assert_not_exists(self, path: Path, message: str | None = None) -> None:
+        if path.exists():
+            raise AssertionError(message or f"Expected path to be absent: {path}")
+
+    def assert_is_file(self, path: Path, message: str | None = None) -> None:
+        if not path.is_file():
+            raise AssertionError(message or f"Expected file to exist: {path}")
+
+    def assert_is_dir(self, path: Path, message: str | None = None) -> None:
+        if not path.is_dir():
+            raise AssertionError(message or f"Expected directory to exist: {path}")
+
+    def assert_file_text_equals(self, path: Path, expected: str, message: str | None = None) -> None:
+        self.assert_is_file(path, message)
+        actual = path.read_text(encoding="utf-8", errors="replace")
+        if actual != expected:
+            raise AssertionError(
+                message or f"Unexpected file content for {path}: expected {expected!r}, got {actual!r}"
+            )
+
+    def assert_manifest_contains(self, entries: list[str], relative_path: str, message: str | None = None) -> None:
+        if relative_path not in entries:
+            raise AssertionError(message or f"Expected manifest entry missing: {relative_path}")
+
+    def assert_manifest_not_contains(self, entries: list[str], relative_path: str, message: str | None = None) -> None:
+        if relative_path in entries:
+            raise AssertionError(message or f"Unexpected manifest entry present: {relative_path}")
diff --git a/ci/e2e/framework/context.py b/ci/e2e/framework/context.py
new file mode 100644
index 000000000..d25e75373
--- /dev/null
+++ b/ci/e2e/framework/context.py
@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from framework.utils import (
+    compute_quickxor_hash_file,
+    ensure_directory,
+    get_optional_base_config_text,
+    timestamp_now,
+    write_text_file,
+    write_text_file_append,
+)
+
+
+def _normalise_case_id(value: str) -> str:
+    text = value.strip()
+    if not text:
+        return ""
+    if text.lower().startswith("tc"):
+        text = text[2:]
+    if text.isdigit() and len(text) <= 4:
+        text = text.zfill(4)
+    return text
+
+
+def _parse_case_filter_env(raw: str) -> set[str]:
+    selected: set[str] = set()
+    for token in raw.split(","):
+        case_id = _normalise_case_id(token)
+        if case_id:
+            selected.add(case_id)
+    return selected
+
+
+def _parse_scenario_filter_env(raw: str) -> dict[str, set[str]]:
+    if not raw.strip():
+        return {}
+
+    decoded = json.loads(raw)
+    parsed: dict[str, set[str]] = {}
+
+    for raw_case_id, raw_scenarios in decoded.items():
+        case_id = _normalise_case_id(str(raw_case_id))
+        if not case_id:
+            continue
+
+        scenario_ids: set[str] = set()
+        for scenario_id in raw_scenarios:
+            scenario_text = str(scenario_id).strip()
+            if scenario_text:
+                scenario_ids.add(scenario_text)
+
+        if scenario_ids:
+            parsed[case_id] = scenario_ids
+
+    return parsed
+
+
+@dataclass
+class E2EContext:
+    """Runtime context for the E2E framework."""
+
+    real_onedrive_bin: str
+    onedrive_bin: str
+    e2e_target: str
+    run_id: str
+
+    repo_root: Path
+    out_dir: Path
+    logs_dir: Path
+    state_dir: Path
+    work_root: Path
+
+    debug_enabled: bool = False
+    skip_suite_cleanup: bool = False
+    run_label: str = "primary"
+    selected_case_ids: set[str] = field(default_factory=set)
+    selected_scenarios: dict[str, set[str]] = field(default_factory=dict)
+
+    @classmethod
+    def from_environment(cls) -> "E2EContext":
+        onedrive_bin = os.environ.get("ONEDRIVE_BIN", "").strip()
+        e2e_target = os.environ.get("E2E_TARGET", "").strip()
+        run_id = os.environ.get("RUN_ID", "").strip()
+
+        if not onedrive_bin:
+            raise RuntimeError("Environment variable ONEDRIVE_BIN must be set")
+        if not e2e_target:
+            raise RuntimeError("Environment variable E2E_TARGET must be set")
+        if not run_id:
+            raise RuntimeError("Environment variable RUN_ID must be set")
+
+        repo_root = Path.cwd()
+
+        output_subdir = os.environ.get("E2E_OUTPUT_SUBDIR", "").strip()
+        out_dir = repo_root / "ci" / "e2e" / "out"
+        if output_subdir:
+            out_dir = out_dir / output_subdir
+
+        logs_dir = out_dir / "logs"
+        state_dir = out_dir / "state"
+
+        runner_temp = os.environ.get("RUNNER_TEMP", "/tmp").strip()
+        work_root = Path(runner_temp) / f"onedrive-e2e-{e2e_target}"
+        if output_subdir:
+            safe_subdir = output_subdir.replace("/", "_")
+            work_root = work_root / safe_subdir
+
+        debug_enabled = os.environ.get("E2E_DEBUG", "").strip().lower() in {"1", "true", "yes", "on"}
+        skip_suite_cleanup = os.environ.get("E2E_SKIP_SUITE_CLEANUP", "").strip().lower() in {"1", "true", "yes", "on"}
+        run_label = os.environ.get("E2E_RUN_LABEL", "").strip() or "primary"
+        selected_case_ids = _parse_case_filter_env(os.environ.get("E2E_SELECTED_CASES", ""))
+        selected_scenarios = _parse_scenario_filter_env(os.environ.get("E2E_SELECTED_SCENARIOS_JSON", ""))
+
+        return cls(
+            real_onedrive_bin=onedrive_bin,
+            onedrive_bin=onedrive_bin,
+            e2e_target=e2e_target,
+            run_id=run_id,
+            repo_root=repo_root,
+            out_dir=out_dir,
+            logs_dir=logs_dir,
+            state_dir=state_dir,
+            work_root=work_root,
+            debug_enabled=debug_enabled,
+            skip_suite_cleanup=skip_suite_cleanup,
+            run_label=run_label,
+            selected_case_ids=selected_case_ids,
+            selected_scenarios=selected_scenarios,
+        )
+
+    @property
+    def master_log_file(self) -> Path:
+        return self.out_dir / "run.log"
+
+    @property
+    def default_onedrive_config_dir(self) -> Path:
+        xdg_config_home = os.environ.get("XDG_CONFIG_HOME", "").strip()
+        if xdg_config_home:
+            return Path(xdg_config_home) / "onedrive"
+
+        home = os.environ.get("HOME", "").strip()
+        if not home:
+            raise RuntimeError("Neither XDG_CONFIG_HOME nor HOME is set")
+
+        return Path(home) / ".config" / "onedrive"
+
+    @property
+    def default_refresh_token_path(self) -> Path:
+        return self.default_onedrive_config_dir / "refresh_token"
+
+    def prepare_runtime(self) -> None:
+        ensure_directory(self.out_dir)
+        ensure_directory(self.logs_dir)
+        ensure_directory(self.state_dir)
+        ensure_directory(self.work_root)
+
+        if not self.debug_enabled:
+            return
+
+        wrapper_path = self.work_root / "onedrive-debug-wrapper.sh"
+        wrapper_content = (
+            "#!/usr/bin/env bash\n"
+            "set -euo pipefail\n"
+            f"REAL_BIN={json.dumps(self.real_onedrive_bin)}\n"
+            "exec \"${REAL_BIN}\" --verbose \"$@\"\n"
+        )
+        write_text_file(wrapper_path, wrapper_content)
+        os.chmod(wrapper_path, 0o755)
+        self.onedrive_bin = str(wrapper_path)
+
+    def ensure_refresh_token_available(self) -> None:
+        if not self.default_refresh_token_path.is_file():
+            raise RuntimeError(
+                f"Required refresh_token file not found at: {self.default_refresh_token_path}"
+            )
+
+    def should_run_case(self, case_id: str) -> bool:
+        if not self.selected_case_ids:
+            return True
+        return _normalise_case_id(case_id) in self.selected_case_ids
+
+    def selected_scenarios_for_case(self, case_id: str) -> set[str]:
+        return set(self.selected_scenarios.get(_normalise_case_id(case_id), set()))
+
+    def should_run_scenario(self, case_id: str, scenario_id: str) -> bool:
+        selected = self.selected_scenarios_for_case(case_id)
+        if not selected:
+            return True
+        return scenario_id in selected
+
+    def _extract_config_value(self, config_text: str, key: str) -> str:
+        for raw_line in config_text.splitlines():
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" not in line:
+                continue
+
+            lhs, rhs = line.split("=", 1)
+            if lhs.strip() != key:
+                continue
+
+            value = rhs.strip()
+            if value.startswith('"') and value.endswith('"') and len(value) >= 2:
+                value = value[1:-1]
+            return value.strip()
+
+        return ""
+
+    def validate_generated_config_dir(self, config_dir: Path) -> None:
+        """
+        Validate a generated runtime config dir so target-specific bootstrap
+        mistakes fail immediately and explicitly.
+        Only SharePoint requires a seeded config containing drive_id.
+        """
+        if self.e2e_target != "sharepoint":
+            return
+
+        config_path = config_dir / "config"
+        if not config_path.is_file():
+            raise RuntimeError(
+                f"SharePoint target requested but generated config file is missing: {config_path}"
+            )
+
+        config_text = config_path.read_text(encoding="utf-8")
+        drive_id = self._extract_config_value(config_text, "drive_id")
+        if not drive_id:
+            raise RuntimeError(
+                f"SharePoint target requested but generated config has empty or missing drive_id: {config_path}"
+            )
+
+    def bootstrap_config_dir(self, config_dir: Path) -> Path:
+        """
+        Copy the existing refresh_token into a per-test/per-scenario config dir.
+        If a base config.sharepoint exists, seed config with that content so all
+        SharePoint scenarios inherit drive_id by default.
+        """
+        self.ensure_refresh_token_available()
+        ensure_directory(config_dir)
+
+        source = self.default_refresh_token_path
+        destination = config_dir / "refresh_token"
+        shutil.copy2(source, destination)
+        os.chmod(destination, 0o600)
+
+        base_config_text = get_optional_base_config_text()
+        if base_config_text:
+            write_text_file(config_dir / "config", base_config_text)
+            os.chmod(config_dir / "config", 0o600)
+
+        self.validate_generated_config_dir(config_dir)
+        return destination
+
+    def prepare_minimal_config_dir(self, config_dir: Path, config_text: str) -> Path:
+        """
+        Create a clean, runtime-ready OneDrive config dir containing only the
+        minimum artefacts required for the client to start without immediately
+        demanding a --resync.
+
+        Files created:
+        - refresh_token
+        - config
+        - .config.backup
+        - .config.hash
+        """
+        self.ensure_refresh_token_available()
+
+        if config_dir.exists():
+            shutil.rmtree(config_dir)
+
+        ensure_directory(config_dir)
+
+        refresh_token_destination = config_dir / "refresh_token"
+        shutil.copy2(self.default_refresh_token_path, refresh_token_destination)
+        os.chmod(refresh_token_destination, 0o600)
+
+        full_config_text = get_optional_base_config_text() + config_text
+
+        config_path = config_dir / "config"
+        config_path.write_text(full_config_text, encoding="utf-8")
+        os.chmod(config_path, 0o600)
+
+        backup_path = config_dir / ".config.backup"
+        backup_path.write_text(full_config_text, encoding="utf-8")
+        os.chmod(backup_path, 0o600)
+
+        hash_path = config_dir / ".config.hash"
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+        os.chmod(hash_path, 0o600)
+
+        self.validate_generated_config_dir(config_dir)
+        return config_path
+
+    def log(self, message: str) -> None:
+        ensure_directory(self.out_dir)
+        line = f"[{timestamp_now()}] {message}\n"
+        print(line, end="")
+        write_text_file_append(self.master_log_file, line)
+
+    @property
+    def default_sync_dir(self) -> Path:
+        home = os.environ.get("HOME", "").strip()
+        if not home:
+            raise RuntimeError("HOME is not set")
+        return Path(home) / "OneDrive"
+
+    @property
+    def suite_cleanup_config_dir(self) -> Path:
+        return self.work_root / "suite-cleanup-conf"
+
+    @property
+    def suite_cleanup_log_dir(self) -> Path:
+        return self.logs_dir / "_suite_cleanup"
+
+    def bootstrap_suite_cleanup_config_dir(self) -> Path:
+        if self.suite_cleanup_config_dir.exists():
+            shutil.rmtree(self.suite_cleanup_config_dir)
+        return self.bootstrap_config_dir(self.suite_cleanup_config_dir)
diff --git a/ci/e2e/framework/database_capture.py b/ci/e2e/framework/database_capture.py
new file mode 100644
index 000000000..00f414424
--- /dev/null
+++ b/ci/e2e/framework/database_capture.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from framework.context import E2EContext
+
+
+def _safe_path_fragment(value: str) -> str:
+    text = str(value).strip().replace("\\", "/")
+    text = text.strip("/")
+    if not text:
+        return "unknown"
+    return "_".join(part for part in text.split("/") if part) or "unknown"
+
+
+def capture_onedrive_databases(
+    context: E2EContext,
+    case_id: str,
+    *,
+    reason: str = "failure",
+) -> list[str]:
+    """
+    Capture OneDrive item database files from the active E2E work root.
+
+    The OneDrive client writes items.sqlite3 next to the refresh_token in the
+    runtime --confdir. Those config directories are testcase/scenario specific
+    and live under context.work_root for both the primary run and debug reruns.
+
+    Capture from context.work_root rather than guessing a testcase-specific
+    directory so this works consistently for:
+      - normal account tests
+      - SharePoint tests
+      - Business tests
+      - Personal 15-character driveId tests
+      - Personal Shared Folder tests
+      - primary failures and debug rerun failures
+    """
+    work_root = context.work_root
+    if not work_root.exists():
+        context.log(
+            f"No OneDrive database capture performed for {case_id}: "
+            f"work root does not exist: {work_root}"
+        )
+        return []
+
+    run_label = _safe_path_fragment(context.run_label)
+    reason_label = _safe_path_fragment(reason)
+    case_label = _safe_path_fragment(case_id)
+
+    capture_root = (
+        context.state_dir
+        / case_label
+        / "_database_captures"
+        / f"{run_label}-{reason_label}"
+    )
+
+    copied: list[str] = []
+    for source in sorted(work_root.rglob("items.sqlite3*")):
+        if not source.is_file():
+            continue
+
+        relative_source = source.relative_to(work_root)
+        destination = capture_root / relative_source
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, destination)
+        copied.append(str(destination))
+
+    if copied:
+        context.log(
+            f"Captured {len(copied)} OneDrive database file(s) for test case "
+            f"{case_id} from {work_root} under {capture_root}"
+        )
+    else:
+        context.log(
+            f"No OneDrive database files found to capture for test case {case_id} "
+            f"under active work root: {work_root}"
+        )
+
+    return copied
diff --git a/ci/e2e/framework/manifest.py b/ci/e2e/framework/manifest.py
new file mode 100644
index 000000000..6162a3d23
--- /dev/null
+++ b/ci/e2e/framework/manifest.py
@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def build_manifest(root: Path) -> list[str]:
+    """
+    Build a deterministic manifest of all files and directories beneath root.
+
+    Paths are returned relative to root using POSIX separators.
+    """
+    entries: list[str] = []
+
+    if not root.exists():
+        return entries
+
+    for path in sorted(root.rglob("*")):
+        rel = path.relative_to(root).as_posix()
+        entries.append(rel)
+
+    return entries
+
+
+def build_typed_manifest(root: Path) -> list[str]:
+    """
+    Build a deterministic manifest that preserves whether an entry is a file or
+    directory by suffixing directories with '/'.
+    """
+    entries: list[str] = []
+
+    if not root.exists():
+        return entries
+
+    for path in sorted(root.rglob("*")):
+        rel = path.relative_to(root).as_posix()
+        if path.is_dir():
+            rel += "/"
+        entries.append(rel)
+
+    return entries
+
+
+def manifest_contains_prefix(entries: list[str], relative_path: str) -> bool:
+    return any(entry == relative_path or entry.startswith(relative_path + "/") for entry in entries)
+
+
+def write_manifest(path: Path, entries: list[str]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(entries) + ("\n" if entries else ""), encoding="utf-8")
diff --git a/ci/e2e/framework/result.py b/ci/e2e/framework/result.py
new file mode 100644
index 000000000..ff6eb98ed
--- /dev/null
+++ b/ci/e2e/framework/result.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class TestResult:
+    """
+    Structured test result returned by each test case.
+    """
+
+    case_id: str
+    name: str
+    status: str
+    reason: str = ""
+    artifacts: list[str] = field(default_factory=list)
+    details: dict = field(default_factory=dict)
+
+    @staticmethod
+    def pass_result(
+        case_id: str,
+        name: str,
+        artifacts: list[str] | None = None,
+        details: dict | None = None,
+    ) -> "TestResult":
+        return TestResult(
+            case_id=case_id,
+            name=name,
+            status="pass",
+            reason="",
+            artifacts=artifacts or [],
+            details=details or {},
+        )
+
+    @staticmethod
+    def fail_result(
+        case_id: str,
+        name: str,
+        reason: str,
+        artifacts: list[str] | None = None,
+        details: dict | None = None,
+    ) -> "TestResult":
+        return TestResult(
+            case_id=case_id,
+            name=name,
+            status="fail",
+            reason=reason,
+            artifacts=artifacts or [],
+            details=details or {},
+        )
\ No newline at end of file
diff --git a/ci/e2e/framework/utils.py b/ci/e2e/framework/utils.py
new file mode 100644
index 000000000..6bda15c26
--- /dev/null
+++ b/ci/e2e/framework/utils.py
@@ -0,0 +1,452 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import base64
+import time
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+@dataclass
+class CommandResult:
+    command: list[str]
+    returncode: int
+    stdout: str
+    stderr: str
+
+    @property
+    def ok(self) -> bool:
+        return self.returncode == 0
+
+
+STARTUP_RETRY_ATTEMPTS = 3
+STARTUP_RETRY_SLEEP_SECONDS = 3.0
+STARTUP_DISCOVERY_FUNCTION_MARKERS = (
+    "Calling Function:    syncEngine.getDefaultRootDetails()",
+    "Calling Function:    syncEngine.getDefaultDriveDetails()",
+)
+STARTUP_TRANSIENT_HTTP_MARKERS = (
+    "HTTP request returned status code 403 (Forbidden)",
+    "HTTP request returned status code 408",
+    "HTTP request returned status code 429",
+    "HTTP request returned status code 500",
+    "HTTP request returned status code 502",
+    "HTTP request returned status code 503",
+    "HTTP request returned status code 504",
+    "Failed to reach the Microsoft OneDrive Service. HTTP status code: 408",
+    "Failed to reach the Microsoft OneDrive Service. HTTP status code: 429",
+    "Failed to reach the Microsoft OneDrive Service. HTTP status code: 500",
+    "Failed to reach the Microsoft OneDrive Service. HTTP status code: 502",
+    "Failed to reach the Microsoft OneDrive Service. HTTP status code: 503",
+    "Failed to reach the Microsoft OneDrive Service. HTTP status code: 504",
+)
+STARTUP_TRANSIENT_ERROR_MARKERS = (
+    "Error Code:          accessDenied",
+    "Unable to reach the Microsoft OneDrive API service, unable to initialise application",
+    "Connection timeout",
+    "Operation timed out",
+    "Timeout was reached",
+)
+
+
+def _combined_output(stdout: str, stderr: str) -> str:
+    return f"{stdout}\n{stderr}"
+
+
+def is_transient_startup_discovery_failure(stdout: str, stderr: str) -> bool:
+    content = _combined_output(stdout, stderr)
+    has_transient_markers = (
+        any(marker in content for marker in STARTUP_TRANSIENT_HTTP_MARKERS)
+        or any(marker in content for marker in STARTUP_TRANSIENT_ERROR_MARKERS)
+    )
+
+    has_discovery_failure = (
+        any(marker in content for marker in STARTUP_DISCOVERY_FUNCTION_MARKERS)
+        and has_transient_markers
+    )
+
+    has_generic_startup_service_failure = (
+        "Attempting to contact the Microsoft OneDrive Service" in content
+        and "unable to initialise application" in content.lower()
+        and has_transient_markers
+    )
+
+    return has_discovery_failure or has_generic_startup_service_failure
+
+
+def should_retry_startup_failure(stdout: str, stderr: str, attempt: int, max_attempts: int) -> bool:
+    return attempt < max_attempts and is_transient_startup_discovery_failure(stdout, stderr)
+
+
+def run_command_with_startup_retry(
+    command: list[str],
+    cwd: Path | None = None,
+    env: dict[str, str] | None = None,
+    input_text: str | None = None,
+    *,
+    max_attempts: int = STARTUP_RETRY_ATTEMPTS,
+    retry_sleep_seconds: float = STARTUP_RETRY_SLEEP_SECONDS,
+) -> CommandResult:
+    last_result: CommandResult | None = None
+
+    for attempt in range(1, max_attempts + 1):
+        completed = subprocess.run(
+            command,
+            cwd=str(cwd) if cwd else None,
+            env=(lambda merged_env: merged_env)(dict(os.environ, **(env or {}))),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+            input=input_text,
+        )
+
+        last_result = CommandResult(
+            command=command,
+            returncode=completed.returncode,
+            stdout=completed.stdout,
+            stderr=completed.stderr,
+        )
+
+        if not should_retry_startup_failure(last_result.stdout, last_result.stderr, attempt, max_attempts):
+            return last_result
+
+        time.sleep(retry_sleep_seconds)
+
+    assert last_result is not None
+    return last_result
+
+
+def timestamp_now() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
+
+
+def ensure_directory(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def reset_directory(path: Path) -> None:
+    if path.exists():
+        shutil.rmtree(path)
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def write_text_file(path: Path, content: str) -> None:
+    ensure_directory(path.parent)
+    path.write_text(content, encoding="utf-8")
+
+
+def write_text_file_append(path: Path, content: str) -> None:
+    ensure_directory(path.parent)
+    with path.open("a", encoding="utf-8") as fp:
+        fp.write(content)
+
+
+def run_command(
+    command: list[str],
+    cwd: Path | None = None,
+    env: dict[str, str] | None = None,
+    input_text: str | None = None,
+) -> CommandResult:
+    return run_command_with_startup_retry(
+        command=command,
+        cwd=cwd,
+        env=env,
+        input_text=input_text,
+    )
+
+
+def command_to_string(command: list[str]) -> str:
+    return " ".join(command)
+
+PROTECTED_SUITE_CLEANUP_PREFIXES = (
+    "ZZ_SHARED_SEED",
+)
+
+
+def is_protected_suite_cleanup_path(path: Path) -> bool:
+    """
+    Return True when a top-level local path represents durable online seed
+    data that must never be removed by suite-wide cleanup.
+
+    This intentionally protects any top-level name beginning with
+    ZZ_SHARED_SEED so both the current 15-character driveId seed
+    (ZZ_SHARED_SEED_15CHAR) and future shared-folder seed roots are
+    preserved.
+    """
+    return any(path.name.startswith(prefix) for prefix in PROTECTED_SUITE_CLEANUP_PREFIXES)
+
+
+def purge_directory_contents(path: Path) -> list[str]:
+    """
+    Delete files and folders inside 'path', but do not delete 'path' itself.
+
+    Durable shared-folder seed roots are explicitly preserved.  This is
+    required because the cleanup syncroot is populated from the account root;
+    deleting a preserved local seed root and then running a normal sync would
+    delete that online fixture.
+    """
+    ensure_directory(path)
+
+    preserved: list[str] = []
+    for child in path.iterdir():
+        if is_protected_suite_cleanup_path(child):
+            preserved.append(child.name)
+            continue
+
+        if child.is_dir() and not child.is_symlink():
+            shutil.rmtree(child)
+        else:
+            child.unlink(missing_ok=True)
+
+    return sorted(preserved)
+
+
+def run_command_logged(
+    command: list[str],
+    stdout_file: Path,
+    stderr_file: Path,
+    cwd: Path | None = None,
+    env: dict[str, str] | None = None,
+    input_text: str | None = None,
+) -> CommandResult:
+    result = run_command(
+        command=command,
+        cwd=cwd,
+        env=env,
+        input_text=input_text,
+    )
+    write_text_file(stdout_file, result.stdout)
+    write_text_file(stderr_file, result.stderr)
+    return result
+
+
+def perform_full_account_cleanup(
+    *,
+    onedrive_bin: str,
+    repo_root: Path,
+    config_dir: Path,
+    sync_dir: Path,
+    log_dir: Path,
+) -> tuple[bool, str, list[str], dict]:
+    """
+    Clean the account by:
+    1. Running a full resync to establish local state from remote
+    2. Deleting everything locally
+    3. Running a normal sync to propagate deletions online
+    4. Validating that the local sync directory is empty
+
+    Returns:
+        (success, reason, artifacts, details)
+    """
+    ensure_directory(log_dir)
+    ensure_directory(sync_dir)
+
+    phase1_stdout = log_dir / "cleanup_phase1_resync_stdout.log"
+    phase1_stderr = log_dir / "cleanup_phase1_resync_stderr.log"
+    phase2_state = log_dir / "cleanup_phase2_local_purge_state.txt"
+    phase3_stdout = log_dir / "cleanup_phase3_sync_stdout.log"
+    phase3_stderr = log_dir / "cleanup_phase3_sync_stderr.log"
+
+    artifacts = [
+        str(phase1_stdout),
+        str(phase1_stderr),
+        str(phase2_state),
+        str(phase3_stdout),
+        str(phase3_stderr),
+    ]
+
+    # Phase 1: establish local state from remote
+    phase1_command = [
+        onedrive_bin,
+        "--sync",
+        "--verbose",
+        "--resync",
+        "--resync-auth",
+        "--confdir",
+        str(config_dir),
+    ]
+    phase1 = run_command_logged(
+        phase1_command,
+        stdout_file=phase1_stdout,
+        stderr_file=phase1_stderr,
+        cwd=repo_root,
+    )
+    if phase1.returncode != 0:
+        return (
+            False,
+            f"Cleanup phase 1 failed with status {phase1.returncode}",
+            artifacts,
+            {
+                "phase1_returncode": phase1.returncode,
+                "phase1_command": command_to_string(phase1_command),
+            },
+        )
+
+    # Phase 2: delete local content that is safe for suite cleanup.
+    #
+    # IMPORTANT: do not delete durable shared-folder seed roots. If those
+    # directories are removed locally here, phase 3 will propagate that delete
+    # to OneDrive and destroy the online shared-folder fixture.
+    preserved_after_purge = purge_directory_contents(sync_dir)
+
+    remaining_after_purge = sorted(str(child.name) for child in sync_dir.iterdir())
+    write_text_file(
+        phase2_state,
+        "\n".join(
+            ["Preserved by suite cleanup guard:"]
+            + preserved_after_purge
+            + ["", "Remaining after purge:"]
+            + remaining_after_purge
+        )
+        + "\n",
+    )
+
+    unsafe_remaining_after_purge = [
+        name for name in remaining_after_purge
+        if not name.startswith(PROTECTED_SUITE_CLEANUP_PREFIXES)
+    ]
+    if unsafe_remaining_after_purge:
+        return (
+            False,
+            "Cleanup phase 2 failed: unsafe local sync directory entries remain after purge",
+            artifacts,
+            {
+                "remaining_after_purge": remaining_after_purge,
+                "unsafe_remaining_after_purge": unsafe_remaining_after_purge,
+                "preserved_after_purge": preserved_after_purge,
+            },
+        )
+
+    # Phase 3: propagate deletions online
+    phase3_command = [
+        onedrive_bin,
+        "--sync",
+        "--verbose",
+        "--confdir",
+        str(config_dir),
+    ]
+    phase3 = run_command_logged(
+        phase3_command,
+        stdout_file=phase3_stdout,
+        stderr_file=phase3_stderr,
+        cwd=repo_root,
+    )
+    if phase3.returncode != 0:
+        return (
+            False,
+            f"Cleanup phase 3 failed with status {phase3.returncode}",
+            artifacts,
+            {
+                "phase3_returncode": phase3.returncode,
+                "phase3_command": command_to_string(phase3_command),
+            },
+        )
+
+    # Phase 4: validate that only explicitly protected seed roots remain.
+    remaining_after_sync = sorted(str(child.name) for child in sync_dir.iterdir())
+    unsafe_remaining_after_sync = [
+        name for name in remaining_after_sync
+        if not name.startswith(PROTECTED_SUITE_CLEANUP_PREFIXES)
+    ]
+    if unsafe_remaining_after_sync:
+        return (
+            False,
+            "Cleanup phase 4 failed: unsafe local sync directory entries remain after sync",
+            artifacts,
+            {
+                "remaining_after_sync": remaining_after_sync,
+                "unsafe_remaining_after_sync": unsafe_remaining_after_sync,
+            },
+        )
+
+    return (
+        True,
+        "",
+        artifacts,
+        {
+            "phase1_returncode": phase1.returncode,
+            "phase3_returncode": phase3.returncode,
+            "phase1_command": command_to_string(phase1_command),
+            "phase3_command": command_to_string(phase3_command),
+            "preserved_after_purge": preserved_after_purge,
+            "remaining_after_sync": remaining_after_sync,
+        },
+    )
+
+def default_onedrive_config_dir_from_env() -> Path:
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME", "").strip()
+    if xdg_config_home:
+        return Path(xdg_config_home) / "onedrive"
+
+    home = os.environ.get("HOME", "").strip()
+    if not home:
+        raise RuntimeError("Neither XDG_CONFIG_HOME nor HOME is set")
+
+    return Path(home) / ".config" / "onedrive"
+
+
+def get_optional_base_config_text() -> str:
+    """
+    Return the optional base config content used to seed SharePoint-specific
+    configuration such as drive_id. For personal/business testing this returns
+    an empty string.
+    """
+    base_config_path = default_onedrive_config_dir_from_env() / "config.sharepoint"
+    if not base_config_path.is_file():
+        return ""
+
+    text = base_config_path.read_text(encoding="utf-8")
+    if text and not text.endswith("\n"):
+        text += "\n"
+    return text
+
+
+def write_onedrive_config(path: Path, content: str) -> None:
+    """
+    Write a test config file, automatically prepending any optional base config
+    such as SharePoint drive_id settings from config.sharepoint.
+    """
+    base_config_text = get_optional_base_config_text()
+    write_text_file(path, base_config_text + content)
+
+
+def compute_quickxor_hash_bytes(data: bytes) -> str:
+    """
+    Compute Microsoft QuickXorHash and return the same base64 string style used
+    by the OneDrive client for .config.hash and .sync_list.hash files.
+
+    This implementation is sufficient for small text config files used by the
+    E2E harness.
+    """
+    width_bits = 160
+    shift = 11
+    cell_count = width_bits // 8
+    out = [0] * cell_count
+
+    for i, b in enumerate(data):
+        bit_index = (i * shift) % width_bits
+        byte_index = bit_index // 8
+        bit_offset = bit_index % 8
+
+        value = b & 0xFF
+
+        out[byte_index] ^= (value << bit_offset) & 0xFF
+        if bit_offset > 0:
+            out[(byte_index + 1) % cell_count] ^= (value >> (8 - bit_offset)) & 0xFF
+
+    length = len(data)
+    for i in range(8):
+        out[cell_count - 8 + i] ^= (length >> (8 * i)) & 0xFF
+
+    return base64.b64encode(bytes(out)).decode("ascii")
+
+
+def compute_quickxor_hash_file(path: Path) -> str:
+    return compute_quickxor_hash_bytes(path.read_bytes())
+
diff --git a/ci/e2e/rerun_failures.py b/ci/e2e/rerun_failures.py
new file mode 100644
index 000000000..61cc63770
--- /dev/null
+++ b/ci/e2e/rerun_failures.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def _normalise_case_id(value: str) -> str:
+    text = value.strip()
+    if text.lower().startswith("tc"):
+        text = text[2:]
+    if text.isdigit() and len(text) <= 4:
+        text = text.zfill(4)
+    return text
+
+
+def _extract_failed_plan(results: dict) -> tuple[list[str], dict[str, list[str]]]:
+    failed_cases: list[str] = []
+    scenario_filters: dict[str, list[str]] = {}
+
+    for case in results.get("cases", []):
+        if case.get("status") == "pass":
+            continue
+
+        case_id = _normalise_case_id(str(case.get("id", "")))
+        if not case_id or case_id == "0000":
+            continue
+
+        failed_cases.append(case_id)
+        details = case.get("details") or {}
+
+        failed_scenario_ids = details.get("failed_scenario_ids")
+        if isinstance(failed_scenario_ids, list):
+            filtered = [str(value).strip() for value in failed_scenario_ids if str(value).strip()]
+            if filtered:
+                scenario_filters[case_id] = filtered
+
+    return sorted(set(failed_cases)), dict(sorted(scenario_filters.items()))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Automatically rerun failed E2E cases with debug enabled")
+    parser.add_argument("--results", required=True, help="Path to the primary run results.json")
+    parser.add_argument("--run-script", default="ci/e2e/run.py", help="Path to the E2E run.py entrypoint")
+    parser.add_argument("--output-subdir", default="debug-rerun", help="Output subdirectory under ci/e2e/out for rerun artifacts")
+    parser.add_argument("--run-label", default="debug-rerun", help="Logical label for the rerun")
+    parser.add_argument("--skip-suite-cleanup", action="store_true", help="Skip suite cleanup during the debug rerun")
+    parser.add_argument("--plan-file", default="ci/e2e/out/debug_rerun_plan.json", help="Where to write the rerun plan JSON")
+    args = parser.parse_args()
+
+    results_path = Path(args.results)
+    if not results_path.is_file():
+        raise RuntimeError(f"Results file not found: {results_path}")
+
+    results = json.loads(results_path.read_text(encoding="utf-8"))
+    failed_cases, scenario_filters = _extract_failed_plan(results)
+
+    plan = {
+        "source_results": str(results_path),
+        "failed_case_ids": failed_cases,
+        "scenario_filters": scenario_filters,
+        "output_subdir": args.output_subdir,
+        "run_label": args.run_label,
+        "skip_suite_cleanup": args.skip_suite_cleanup,
+    }
+
+    plan_file = Path(args.plan_file)
+    plan_file.parent.mkdir(parents=True, exist_ok=True)
+    plan_file.write_text(json.dumps(plan, indent=2, sort_keys=False) + "\n", encoding="utf-8")
+
+    if not failed_cases:
+        print("No failed E2E cases detected; skipping debug rerun")
+        return 0
+
+    command = [sys.executable, args.run_script, "--debug", "--output-subdir", args.output_subdir, "--run-label", args.run_label]
+    if args.skip_suite_cleanup:
+        command.append("--skip-suite-cleanup")
+    command.extend(["--case-id", ",".join(failed_cases)])
+
+    for case_id, scenario_ids in scenario_filters.items():
+        command.extend(["--scenario", f"{case_id}:{','.join(scenario_ids)}"])
+
+    print("Debug rerun plan written to:", plan_file)
+    print("Executing:", " ".join(command))
+
+    env = os.environ.copy()
+    completed = subprocess.run(command, env=env, check=False)
+    return completed.returncode
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/ci/e2e/run.py b/ci/e2e/run.py
new file mode 100644
index 000000000..15890066d
--- /dev/null
+++ b/ci/e2e/run.py
@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import traceback
+from pathlib import Path
+
+from framework.context import E2EContext
+from framework.database_capture import capture_onedrive_databases
+from framework.result import TestResult
+from framework.utils import ensure_directory, perform_full_account_cleanup, write_text_file
+from testcases.tc0001_basic_resync import TestCase0001BasicResync
+from testcases.tc0002_sync_list_validation import TestCase0002SyncListValidation
+from testcases.tc0003_dry_run_validation import TestCase0003DryRunValidation
+from testcases.tc0004_single_directory_sync import TestCase0004SingleDirectorySync
+from testcases.tc0005_force_sync_override import TestCase0005ForceSyncOverride
+from testcases.tc0006_download_only import TestCase0006DownloadOnly
+from testcases.tc0007_download_only_cleanup_local_files import TestCase0007DownloadOnlyCleanupLocalFiles
+from testcases.tc0008_upload_only import TestCase0008UploadOnly
+from testcases.tc0009_upload_only_no_remote_delete import TestCase0009UploadOnlyNoRemoteDelete
+from testcases.tc0010_upload_only_remove_source_files import TestCase0010UploadOnlyRemoveSourceFiles
+from testcases.tc0011_skip_file_validation import TestCase0011SkipFileValidation
+from testcases.tc0012_skip_dir_validation import TestCase0012SkipDirValidation
+from testcases.tc0013_skip_dotfiles_validation import TestCase0013SkipDotfilesValidation
+from testcases.tc0014_skip_size_validation import TestCase0014SkipSizeValidation
+from testcases.tc0015_skip_symlinks_validation import TestCase0015SkipSymlinksValidation
+from testcases.tc0016_check_nosync_validation import TestCase0016CheckNosyncValidation
+from testcases.tc0017_check_nomount_validation import TestCase0017CheckNomountValidation
+from testcases.tc0018_recycle_bin_validation import TestCase0018RecycleBinValidation
+from testcases.tc0019_logging_and_running_config import TestCase0019LoggingAndRunningConfig
+from testcases.tc0020_monitor_mode_validation import TestCase0020MonitorModeValidation
+from testcases.tc0021_resumable_transfers_validation import TestCase0021ResumableTransfersValidation
+from testcases.tc0022_local_first_validation import TestCase0022LocalFirstValidation
+from testcases.tc0023_bypass_data_preservation_validation import TestCase0023BypassDataPreservationValidation
+from testcases.tc0024_big_delete_safeguard_validation import TestCase0024BigDeleteSafeguardValidation
+from testcases.tc0025_invalid_character_filename_validation import TestCase0025InvalidCharacterFilenameValidation
+from testcases.tc0026_reserved_device_name_validation import TestCase0026ReservedDeviceNameValidation
+from testcases.tc0027_whitespace_trailing_dot_validation import TestCase0027WhitespaceTrailingDotValidation
+from testcases.tc0028_control_character_non_utf8_filename_validation import TestCase0028ControlCharacterNonUtf8FilenameValidation
+from testcases.tc0029_local_first_upload_only_timestamp_preservation_validation import TestCase0029LocalFirstUploadOnlyTimestampPreservationValidation
+from testcases.tc0030_local_rename_propagation_validation import TestCase0030LocalRenamePropagationValidation
+from testcases.tc0031_local_directory_rename_propagation_validation import TestCase0031LocalDirectoryRenamePropagationValidation
+from testcases.tc0032_remote_rename_reconciliation import TestCase0032RemoteRenameReconciliation
+from testcases.tc0033_remote_directory_rename_reconciliation import TestCase0033RemoteDirectoryRenameReconciliation
+from testcases.tc0034_local_move_between_directories_validation import TestCase0034LocalMoveBetweenDirectoriesValidation
+from testcases.tc0035_remote_move_between_directories_reconciliation import TestCase0035RemoteMoveBetweenDirectoriesReconciliation
+from testcases.tc0036_overwrite_replace_existing_file_content_validation import TestCase0036OverwriteReplaceExistingFileContentValidation
+from testcases.tc0037_mtime_only_local_change_handling import TestCase0037MtimeOnlyLocalChangeHandling
+from testcases.tc0038_delete_and_recreate_with_same_name_validation import TestCase0038DeleteAndRecreateWithSameNameValidation
+from testcases.tc0039_empty_directory_handling_validation import TestCase0039EmptyDirectoryHandling
+from testcases.tc0040_nested_tree_rename_and_delete_stress_validation import TestCase0040NestedTreeRenameAndDeleteStressValidation
+from testcases.tc0041_monitor_mode_local_create_upload import TestCase0041MonitorModeLocalCreateUpload
+from testcases.tc0042_monitor_mode_local_modify_upload import TestCase0042MonitorModeLocalModifyUpload
+from testcases.tc0043_monitor_mode_local_delete_propagation import TestCase0043MonitorModeLocalDeletePropagation
+from testcases.tc0044_monitor_mode_local_rename_propagation import TestCase0044MonitorModeLocalRenamePropagation
+from testcases.tc0045_monitor_mode_local_directory_create_propagation import TestCase0045MonitorModeLocalDirectoryCreatePropagation
+from testcases.tc0046_monitor_mode_local_directory_rename_propagation import TestCase0046MonitorModeLocalDirectoryRenamePropagation
+from testcases.tc0047_monitor_mode_local_directory_delete_propagation import TestCase0047MonitorModeLocalDirectoryDeletePropagation
+from testcases.tc0048_monitor_mode_burst_local_file_creates import TestCase0048MonitorModeBurstLocalFileCreates
+from testcases.tc0049_monitor_mode_mixed_burst_operations import TestCase0049MonitorModeMixedBurstOperations
+from testcases.tc0050_monitor_mode_nested_file_create_inside_new_directory import TestCase0050MonitorModeNestedFileCreateInsideNewDirectory
+from testcases.tc0051_monitor_mode_mtime_only_local_change_handling import TestCase0051MonitorModeMtimeOnlyLocalChangeHandling
+from testcases.tc0052_monitor_mode_large_file_create_session_upload import TestCase0052MonitorModeLargeFileCreateSessionUpload
+from testcases.tc0053_monitor_mode_rename_then_modify import TestCase0053MonitorModeRenameThenModify
+from testcases.tc0054_monitor_mode_atomic_save_editor_replace_workflow import TestCase0054MonitorModeAtomicSaveEditorReplaceWorkflow
+from testcases.tc0055_upload_only_remove_source_folders import TestCase0055UploadOnlyRemoveSourceFolders
+from testcases.tc0056_monitor_mode_create_then_delete_quickly import TestCase0056MonitorModeCreateThenDeleteQuickly
+from testcases.tc0057_recycle_bin_delete_behaviour_validation import TestCase0057RecycleBinDeleteBehaviourValidation
+
+def build_test_suite() -> list:
+    return [
+        TestCase0001BasicResync(),
+        TestCase0002SyncListValidation(),
+        TestCase0003DryRunValidation(),
+        TestCase0004SingleDirectorySync(),
+        TestCase0005ForceSyncOverride(),
+        TestCase0006DownloadOnly(),
+        TestCase0007DownloadOnlyCleanupLocalFiles(),
+        TestCase0008UploadOnly(),
+        TestCase0009UploadOnlyNoRemoteDelete(),
+        TestCase0010UploadOnlyRemoveSourceFiles(),
+        TestCase0011SkipFileValidation(),
+        TestCase0012SkipDirValidation(),
+        TestCase0013SkipDotfilesValidation(),
+        TestCase0014SkipSizeValidation(),
+        TestCase0015SkipSymlinksValidation(),
+        TestCase0016CheckNosyncValidation(),
+        TestCase0017CheckNomountValidation(),
+        TestCase0018RecycleBinValidation(),
+        TestCase0019LoggingAndRunningConfig(),
+        TestCase0020MonitorModeValidation(),
+        TestCase0021ResumableTransfersValidation(),
+        TestCase0022LocalFirstValidation(),
+        TestCase0023BypassDataPreservationValidation(),
+        TestCase0024BigDeleteSafeguardValidation(),
+        TestCase0025InvalidCharacterFilenameValidation(),
+        TestCase0026ReservedDeviceNameValidation(),
+        TestCase0027WhitespaceTrailingDotValidation(),
+        TestCase0028ControlCharacterNonUtf8FilenameValidation(),
+        TestCase0029LocalFirstUploadOnlyTimestampPreservationValidation(),
+        TestCase0030LocalRenamePropagationValidation(),
+        TestCase0031LocalDirectoryRenamePropagationValidation(),
+        TestCase0032RemoteRenameReconciliation(),
+        TestCase0033RemoteDirectoryRenameReconciliation(),
+        TestCase0034LocalMoveBetweenDirectoriesValidation(),
+        TestCase0035RemoteMoveBetweenDirectoriesReconciliation(),
+        TestCase0036OverwriteReplaceExistingFileContentValidation(),
+        TestCase0037MtimeOnlyLocalChangeHandling(),
+        TestCase0038DeleteAndRecreateWithSameNameValidation(),
+        TestCase0039EmptyDirectoryHandling(),
+        TestCase0040NestedTreeRenameAndDeleteStressValidation(),
+        TestCase0041MonitorModeLocalCreateUpload(),
+        TestCase0042MonitorModeLocalModifyUpload(),
+        TestCase0043MonitorModeLocalDeletePropagation(),
+        TestCase0044MonitorModeLocalRenamePropagation(),
+        TestCase0045MonitorModeLocalDirectoryCreatePropagation(),
+        TestCase0046MonitorModeLocalDirectoryRenamePropagation(),
+        TestCase0047MonitorModeLocalDirectoryDeletePropagation(),
+        TestCase0048MonitorModeBurstLocalFileCreates(),
+        TestCase0049MonitorModeMixedBurstOperations(),
+        TestCase0050MonitorModeNestedFileCreateInsideNewDirectory(),
+        TestCase0051MonitorModeMtimeOnlyLocalChangeHandling(),
+        TestCase0052MonitorModeLargeFileCreateSessionUpload(),
+        TestCase0053MonitorModeRenameThenModify(),
+        TestCase0054MonitorModeAtomicSaveEditorReplaceWorkflow(),
+        TestCase0055UploadOnlyRemoveSourceFolders(),
+        TestCase0056MonitorModeCreateThenDeleteQuickly(),
+        TestCase0057RecycleBinDeleteBehaviourValidation(),
+    ]
+
+
+def _normalise_case_id(value: str) -> str:
+    text = value.strip()
+    if not text:
+        return ""
+    if text.lower().startswith("tc"):
+        text = text[2:]
+    if text.isdigit() and len(text) <= 4:
+        text = text.zfill(4)
+    return text
+
+
+def _apply_cli_overrides(args: argparse.Namespace) -> None:
+    if args.debug:
+        os.environ["E2E_DEBUG"] = "1"
+    if args.skip_suite_cleanup:
+        os.environ["E2E_SKIP_SUITE_CLEANUP"] = "1"
+    if args.output_subdir:
+        os.environ["E2E_OUTPUT_SUBDIR"] = args.output_subdir
+    if args.run_label:
+        os.environ["E2E_RUN_LABEL"] = args.run_label
+
+    if args.case_id:
+        selected: list[str] = []
+        for raw_value in args.case_id:
+            for token in raw_value.split(","):
+                case_id = _normalise_case_id(token)
+                if case_id:
+                    selected.append(case_id)
+        if selected:
+            os.environ["E2E_SELECTED_CASES"] = ",".join(sorted(set(selected)))
+
+    if args.scenario:
+        mapping: dict[str, set[str]] = {}
+        for raw_value in args.scenario:
+            case_part, separator, scenario_part = raw_value.partition(":")
+            if separator != ":":
+                raise RuntimeError(f"Invalid --scenario value '{raw_value}'. Expected CASE:SCENARIO[,SCENARIO]")
+            case_id = _normalise_case_id(case_part)
+            if not case_id:
+                raise RuntimeError(f"Invalid case id in --scenario value '{raw_value}'")
+            mapping.setdefault(case_id, set())
+            for token in scenario_part.split(","):
+                scenario_id = token.strip()
+                if scenario_id:
+                    mapping[case_id].add(scenario_id)
+        if mapping:
+            os.environ["E2E_SELECTED_SCENARIOS_JSON"] = json.dumps({key: sorted(value) for key, value in mapping.items()}, sort_keys=True)
+
+
+
+
+def result_to_actions_case(result: TestResult) -> dict:
+    output = {
+        "id": result.case_id,
+        "name": result.name,
+        "status": result.status,
+    }
+
+    if result.reason:
+        output["reason"] = result.reason
+
+    if result.artifacts:
+        output["artifacts"] = result.artifacts
+
+    if result.details:
+        output["details"] = result.details
+
+    return output
+
+
+def _build_metadata(context: E2EContext, selected_case_ids: list[str], executed_case_ids: list[str]) -> dict:
+    return {
+        "target": context.e2e_target,
+        "run_id": context.run_id,
+        "run_label": context.run_label,
+        "debug_enabled": context.debug_enabled,
+        "skip_suite_cleanup": context.skip_suite_cleanup,
+        "selected_case_ids": selected_case_ids,
+        "selected_scenarios": {case_id: sorted(values) for case_id, values in sorted(context.selected_scenarios.items())},
+        "executed_case_ids": executed_case_ids,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run OneDrive E2E test cases")
+    parser.add_argument("--case-id", action="append", help="Run only the specified case id(s). Supports comma-separated values.")
+    parser.add_argument("--scenario", action="append", help="Run only the specified scenario(s) for a case. Format: CASE:SCENARIO[,SCENARIO]")
+    parser.add_argument("--debug", action="store_true", help="Rerun with debug verbosity enabled")
+    parser.add_argument("--skip-suite-cleanup", action="store_true", help="Skip initial full-account cleanup")
+    parser.add_argument("--output-subdir", help="Write results into ci/e2e/out/<subdir>")
+    parser.add_argument("--run-label", help="Logical label for this run (for metadata/logging)")
+    args = parser.parse_args()
+
+    _apply_cli_overrides(args)
+    context = E2EContext.from_environment()
+    context.prepare_runtime()
+
+    selected_case_ids = sorted(context.selected_case_ids)
+    cases_to_run = [testcase for testcase in build_test_suite() if context.should_run_case(testcase.case_id)]
+    executed_case_ids = [testcase.case_id for testcase in cases_to_run]
+
+    suite_metadata = _build_metadata(context, selected_case_ids, executed_case_ids)
+
+    if not context.skip_suite_cleanup:
+        context.bootstrap_suite_cleanup_config_dir()
+        context.log("Starting suite-wide cleanup of local and remote OneDrive content")
+
+        cleanup_ok, cleanup_reason, cleanup_artifacts, cleanup_details = perform_full_account_cleanup(
+            onedrive_bin=context.onedrive_bin,
+            repo_root=context.repo_root,
+            config_dir=context.suite_cleanup_config_dir,
+            sync_dir=context.default_sync_dir,
+            log_dir=context.suite_cleanup_log_dir,
+        )
+
+        if not cleanup_ok:
+            context.log(f"Suite cleanup FAILED: {cleanup_reason}")
+
+            results = {
+                **suite_metadata,
+                "cases": [
+                    {
+                        "id": "0000",
+                        "name": "suite cleanup",
+                        "status": "fail",
+                        "reason": cleanup_reason,
+                        "artifacts": cleanup_artifacts,
+                        "details": cleanup_details,
+                    }
+                ],
+            }
+
+            results_file = context.out_dir / "results.json"
+            results_json = json.dumps(results, indent=2, sort_keys=False)
+            write_text_file(results_file, results_json)
+            return 1
+
+        context.log("Suite-wide cleanup completed successfully")
+    else:
+        context.log("Skipping suite-wide cleanup because E2E_SKIP_SUITE_CLEANUP is enabled")
+
+    context.log(
+        f"Initialising E2E framework for target='{context.e2e_target}', "
+        f"run_id='{context.run_id}', run_label='{context.run_label}', debug_enabled={context.debug_enabled}"
+    )
+
+    cases = []
+    failed = False
+
+    for testcase in cases_to_run:
+        context.log(f"Starting test case {testcase.case_id}: {testcase.name}")
+
+        try:
+            result = testcase.run(context)
+
+            if result.case_id != testcase.case_id:
+                raise RuntimeError(
+                    f"Test case returned mismatched case_id: expected '{testcase.case_id}', got '{result.case_id}'"
+                )
+
+            cases.append(result_to_actions_case(result))
+
+            if result.status != "pass":
+                failed = True
+                captured_databases = capture_onedrive_databases(context, testcase.case_id, reason="failure")
+                if captured_databases:
+                    result.artifacts.extend(captured_databases)
+                    result.details.setdefault("captured_database_files", captured_databases)
+                    cases[-1] = result_to_actions_case(result)
+                context.log(f"Test case {testcase.case_id} FAILED: {result.reason or 'no reason provided'}")
+            else:
+                context.log(f"Test case {testcase.case_id} PASSED")
+
+        except Exception as exc:
+            failed = True
+            tb = traceback.format_exc()
+
+            context.log(f"Unhandled exception in test case {testcase.case_id}: {exc}")
+            context.log(tb)
+
+            error_log = context.logs_dir / f"{testcase.case_id}_exception.log"
+            write_text_file(error_log, tb)
+
+            failure_result = TestResult(
+                case_id=testcase.case_id,
+                name=testcase.name,
+                status="fail",
+                reason=f"Unhandled exception: {exc}",
+                artifacts=[str(error_log)],
+                details={"exception_type": type(exc).__name__},
+            )
+            captured_databases = capture_onedrive_databases(context, testcase.case_id, reason="failure")
+            if captured_databases:
+                failure_result.artifacts.extend(captured_databases)
+                failure_result.details["captured_database_files"] = captured_databases
+            cases.append(result_to_actions_case(failure_result))
+
+    results = {
+        **suite_metadata,
+        "cases": cases,
+    }
+
+    results_file = context.out_dir / "results.json"
+    results_json = json.dumps(results, indent=2, sort_keys=False)
+    write_text_file(results_file, results_json)
+
+    context.log(f"Wrote results to {results_file}")
+
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/ci/e2e/run_business_shared_folders.py b/ci/e2e/run_business_shared_folders.py
new file mode 100644
index 000000000..c51019ddb
--- /dev/null
+++ b/ci/e2e/run_business_shared_folders.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import traceback
+
+from framework.context import E2EContext
+from framework.database_capture import capture_onedrive_databases
+from framework.result import TestResult
+from framework.utils import write_text_file
+from testcases_business_shared_folders.bsftc0001_clean_sync_pull_down import (
+    BusinessSharedFolderTestCase0001CleanSyncPullDown,
+)
+from testcases_business_shared_folders.bsftc0002_clean_monitor_pull_down import (
+    BusinessSharedFolderTestCase0002CleanMonitorPullDown,
+)
+from testcases_business_shared_folders.bsftc0003_sync_list_validation import (
+    BusinessSharedFolderTestCase0003SyncListValidation,
+)
+
+
+def build_test_suite() -> list:
+    return [
+        BusinessSharedFolderTestCase0001CleanSyncPullDown(),
+        BusinessSharedFolderTestCase0002CleanMonitorPullDown(),
+        BusinessSharedFolderTestCase0003SyncListValidation(),
+    ]
+
+
+def _normalise_case_id(value: str) -> str:
+    text = value.strip().lower()
+    if not text:
+        return ""
+    if text.startswith("bsftc"):
+        suffix = text[5:]
+        if suffix.isdigit() and len(suffix) <= 4:
+            return f"bsftc{suffix.zfill(4)}"
+        return text
+    if text.startswith("bsf"):
+        suffix = text[3:]
+        if suffix.isdigit() and len(suffix) <= 4:
+            return f"bsftc{suffix.zfill(4)}"
+        return text
+    if text.isdigit() and len(text) <= 4:
+        return f"bsftc{text.zfill(4)}"
+    return text
+
+
+def _apply_cli_overrides(args: argparse.Namespace) -> None:
+    if args.debug:
+        os.environ["E2E_DEBUG"] = "1"
+    if args.output_subdir:
+        os.environ["E2E_OUTPUT_SUBDIR"] = args.output_subdir
+    if args.run_label:
+        os.environ["E2E_RUN_LABEL"] = args.run_label
+
+    if args.case_id:
+        selected: list[str] = []
+        for raw_value in args.case_id:
+            for token in raw_value.split(","):
+                case_id = _normalise_case_id(token)
+                if case_id:
+                    selected.append(case_id)
+        if selected:
+            os.environ["E2E_SELECTED_CASES"] = ",".join(sorted(set(selected)))
+
+
+def _should_run_case(context: E2EContext, case_id: str) -> bool:
+    if not context.selected_case_ids:
+        return True
+    return _normalise_case_id(case_id) in {_normalise_case_id(value) for value in context.selected_case_ids}
+
+
+def result_to_actions_case(result: TestResult) -> dict:
+    output = {
+        "id": result.case_id,
+        "name": result.name,
+        "status": result.status,
+    }
+    if result.reason:
+        output["reason"] = result.reason
+    if result.artifacts:
+        output["artifacts"] = result.artifacts
+    if result.details:
+        output["details"] = result.details
+    return output
+
+
+def _build_metadata(context: E2EContext, selected_case_ids: list[str], executed_case_ids: list[str]) -> dict:
+    return {
+        "target": context.e2e_target,
+        "run_id": context.run_id,
+        "run_label": context.run_label,
+        "debug_enabled": context.debug_enabled,
+        "suite_cleanup_enabled": False,
+        "selected_case_ids": selected_case_ids,
+        "executed_case_ids": executed_case_ids,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run OneDrive Business Account Shared Folder E2E test cases")
+    parser.add_argument("--case-id", action="append", help="Run only the specified Business shared-folder case id(s). Supports bsftc0001, bsf0001, or 0001.")
+    parser.add_argument("--debug", action="store_true", help="Rerun with debug verbosity enabled")
+    parser.add_argument("--output-subdir", help="Write results into ci/e2e/out/<subdir>")
+    parser.add_argument("--run-label", help="Logical label for this run")
+    args = parser.parse_args()
+
+    _apply_cli_overrides(args)
+    context = E2EContext.from_environment()
+    context.prepare_runtime()
+
+    if context.e2e_target != "business-shared-folders":
+        raise RuntimeError(
+            "run_business_shared_folders.py must be executed with E2E_TARGET=business-shared-folders"
+        )
+
+    selected_case_ids = sorted(context.selected_case_ids)
+    cases_to_run = [testcase for testcase in build_test_suite() if _should_run_case(context, testcase.case_id)]
+    executed_case_ids = [testcase.case_id for testcase in cases_to_run]
+
+    context.log(
+        f"Initialising Business Shared Folder E2E framework for target='{context.e2e_target}', "
+        f"run_id='{context.run_id}', run_label='{context.run_label}', debug_enabled={context.debug_enabled}"
+    )
+    context.log("Suite-wide cleanup is intentionally disabled for Business Shared Folder testing")
+
+    cases = []
+    failed = False
+
+    for testcase in cases_to_run:
+        context.log(f"Starting test case {testcase.case_id}: {testcase.name}")
+        try:
+            result = testcase.run(context)
+            if result.case_id != testcase.case_id:
+                raise RuntimeError(
+                    f"Test case returned mismatched case_id: expected '{testcase.case_id}', got '{result.case_id}'"
+                )
+            cases.append(result_to_actions_case(result))
+            if result.status != "pass":
+                failed = True
+                captured_databases = capture_onedrive_databases(context, testcase.case_id, reason="failure")
+                if captured_databases:
+                    result.artifacts.extend(captured_databases)
+                    result.details.setdefault("captured_database_files", captured_databases)
+                    cases[-1] = result_to_actions_case(result)
+                context.log(f"Test case {testcase.case_id} FAILED: {result.reason or 'no reason provided'}")
+            else:
+                context.log(f"Test case {testcase.case_id} PASSED")
+        except Exception as exc:
+            failed = True
+            tb = traceback.format_exc()
+            context.log(f"Unhandled exception in test case {testcase.case_id}: {exc}")
+            context.log(tb)
+            error_log = context.logs_dir / f"{testcase.case_id}_exception.log"
+            write_text_file(error_log, tb)
+            failure_result = TestResult(
+                case_id=testcase.case_id,
+                name=testcase.name,
+                status="fail",
+                reason=f"Unhandled exception: {exc}",
+                artifacts=[str(error_log)],
+                details={"exception_type": type(exc).__name__},
+            )
+            captured_databases = capture_onedrive_databases(context, testcase.case_id, reason="failure")
+            if captured_databases:
+                failure_result.artifacts.extend(captured_databases)
+                failure_result.details["captured_database_files"] = captured_databases
+            cases.append(result_to_actions_case(failure_result))
+
+    results = {
+        **_build_metadata(context, selected_case_ids, executed_case_ids),
+        "cases": cases,
+    }
+    results_file = context.out_dir / "results.json"
+    write_text_file(results_file, json.dumps(results, indent=2, sort_keys=False))
+    context.log(f"Wrote results to {results_file}")
+
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/ci/e2e/run_personal_shared_folders.py b/ci/e2e/run_personal_shared_folders.py
new file mode 100644
index 000000000..f8f0d5e5e
--- /dev/null
+++ b/ci/e2e/run_personal_shared_folders.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import traceback
+from pathlib import Path
+
+from framework.context import E2EContext
+from framework.database_capture import capture_onedrive_databases
+from framework.result import TestResult
+from framework.utils import write_text_file
+from testcases_personal_shared_folders.sfptc0001_clean_sync_pull_down import (
+    SharedFolderPersonalTestCase0001CleanSyncPullDown,
+)
+from testcases_personal_shared_folders.sfptc0002_clean_monitor_pull_down import (
+    SharedFolderPersonalTestCase0002CleanMonitorPullDown,
+)
+from testcases_personal_shared_folders.sfptc0003_sync_list_validation import (
+    SharedFolderPersonalTestCase0003SyncListValidation,
+)
+
+
+def build_test_suite() -> list:
+    return [
+        SharedFolderPersonalTestCase0001CleanSyncPullDown(),
+        SharedFolderPersonalTestCase0002CleanMonitorPullDown(),
+        SharedFolderPersonalTestCase0003SyncListValidation(),
+    ]
+
+
+def _normalise_case_id(value: str) -> str:
+    text = value.strip().lower()
+    if not text:
+        return ""
+    if text.startswith("sfptc"):
+        suffix = text[5:]
+        if suffix.isdigit() and len(suffix) <= 4:
+            return f"sfptc{suffix.zfill(4)}"
+        return text
+    if text.startswith("sfp"):
+        suffix = text[3:]
+        if suffix.isdigit() and len(suffix) <= 4:
+            return f"sfptc{suffix.zfill(4)}"
+        return text
+    if text.isdigit() and len(text) <= 4:
+        return f"sfptc{text.zfill(4)}"
+    return text
+
+
+def _apply_cli_overrides(args: argparse.Namespace) -> None:
+    if args.debug:
+        os.environ["E2E_DEBUG"] = "1"
+    if args.output_subdir:
+        os.environ["E2E_OUTPUT_SUBDIR"] = args.output_subdir
+    if args.run_label:
+        os.environ["E2E_RUN_LABEL"] = args.run_label
+
+    if args.case_id:
+        selected: list[str] = []
+        for raw_value in args.case_id:
+            for token in raw_value.split(","):
+                case_id = _normalise_case_id(token)
+                if case_id:
+                    selected.append(case_id)
+        if selected:
+            os.environ["E2E_SELECTED_CASES"] = ",".join(sorted(set(selected)))
+
+
+def _should_run_case(context: E2EContext, case_id: str) -> bool:
+    if not context.selected_case_ids:
+        return True
+    return _normalise_case_id(case_id) in {_normalise_case_id(value) for value in context.selected_case_ids}
+
+
+
+
+def result_to_actions_case(result: TestResult) -> dict:
+    output = {
+        "id": result.case_id,
+        "name": result.name,
+        "status": result.status,
+    }
+    if result.reason:
+        output["reason"] = result.reason
+    if result.artifacts:
+        output["artifacts"] = result.artifacts
+    if result.details:
+        output["details"] = result.details
+    return output
+
+
+def _build_metadata(context: E2EContext, selected_case_ids: list[str], executed_case_ids: list[str]) -> dict:
+    return {
+        "target": context.e2e_target,
+        "run_id": context.run_id,
+        "run_label": context.run_label,
+        "debug_enabled": context.debug_enabled,
+        "suite_cleanup_enabled": False,
+        "selected_case_ids": selected_case_ids,
+        "executed_case_ids": executed_case_ids,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run OneDrive Personal Account Shared Folder E2E test cases")
+    parser.add_argument("--case-id", action="append", help="Run only the specified shared-folder case id(s). Supports sfptc0001, sfp0001, or 0001.")
+    parser.add_argument("--debug", action="store_true", help="Rerun with debug verbosity enabled")
+    parser.add_argument("--output-subdir", help="Write results into ci/e2e/out/<subdir>")
+    parser.add_argument("--run-label", help="Logical label for this run")
+    args = parser.parse_args()
+
+    _apply_cli_overrides(args)
+    context = E2EContext.from_environment()
+    context.prepare_runtime()
+
+    if context.e2e_target != "personal-shared-folders":
+        raise RuntimeError(
+            "run_personal_shared_folders.py must be executed with E2E_TARGET=personal-shared-folders"
+        )
+
+    selected_case_ids = sorted(context.selected_case_ids)
+    cases_to_run = [testcase for testcase in build_test_suite() if _should_run_case(context, testcase.case_id)]
+    executed_case_ids = [testcase.case_id for testcase in cases_to_run]
+
+    context.log(
+        f"Initialising Personal Shared Folder E2E framework for target='{context.e2e_target}', "
+        f"run_id='{context.run_id}', run_label='{context.run_label}', debug_enabled={context.debug_enabled}"
+    )
+    context.log("Suite-wide cleanup is intentionally disabled for Personal Shared Folder testing")
+
+    cases = []
+    failed = False
+
+    for testcase in cases_to_run:
+        context.log(f"Starting test case {testcase.case_id}: {testcase.name}")
+        try:
+            result = testcase.run(context)
+            if result.case_id != testcase.case_id:
+                raise RuntimeError(
+                    f"Test case returned mismatched case_id: expected '{testcase.case_id}', got '{result.case_id}'"
+                )
+            cases.append(result_to_actions_case(result))
+            if result.status != "pass":
+                failed = True
+                captured_databases = capture_onedrive_databases(context, testcase.case_id, reason="failure")
+                if captured_databases:
+                    result.artifacts.extend(captured_databases)
+                    result.details.setdefault("captured_database_files", captured_databases)
+                    cases[-1] = result_to_actions_case(result)
+                context.log(f"Test case {testcase.case_id} FAILED: {result.reason or 'no reason provided'}")
+            else:
+                context.log(f"Test case {testcase.case_id} PASSED")
+        except Exception as exc:
+            failed = True
+            tb = traceback.format_exc()
+            context.log(f"Unhandled exception in test case {testcase.case_id}: {exc}")
+            context.log(tb)
+            error_log = context.logs_dir / f"{testcase.case_id}_exception.log"
+            write_text_file(error_log, tb)
+            failure_result = TestResult(
+                case_id=testcase.case_id,
+                name=testcase.name,
+                status="fail",
+                reason=f"Unhandled exception: {exc}",
+                artifacts=[str(error_log)],
+                details={"exception_type": type(exc).__name__},
+            )
+            captured_databases = capture_onedrive_databases(context, testcase.case_id, reason="failure")
+            if captured_databases:
+                failure_result.artifacts.extend(captured_databases)
+                failure_result.details["captured_database_files"] = captured_databases
+            cases.append(result_to_actions_case(failure_result))
+
+    results = {
+        **_build_metadata(context, selected_case_ids, executed_case_ids),
+        "cases": cases,
+    }
+    results_file = context.out_dir / "results.json"
+    write_text_file(results_file, json.dumps(results, indent=2, sort_keys=False))
+    context.log(f"Wrote results to {results_file}")
+
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/ci/e2e/testcases/__init__.py b/ci/e2e/testcases/__init__.py
new file mode 100644
index 000000000..3db46e2ba
--- /dev/null
+++ b/ci/e2e/testcases/__init__.py
@@ -0,0 +1,3 @@
+"""
+E2E test case package.
+"""
\ No newline at end of file
diff --git a/ci/e2e/testcases/monitor_case_base.py b/ci/e2e/testcases/monitor_case_base.py
new file mode 100644
index 000000000..f2538aad6
--- /dev/null
+++ b/ci/e2e/testcases/monitor_case_base.py
@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.utils import (
+    STARTUP_RETRY_ATTEMPTS,
+    STARTUP_RETRY_SLEEP_SECONDS,
+    is_transient_startup_discovery_failure,
+    run_command,
+    write_text_file,
+)
+
+
+class MonitorModeTestCaseBase(E2ETestCase):
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def _build_config_text(
+        self,
+        sync_dir: Path,
+        app_log_dir: Path,
+        extra_config_lines: list[str] | None = None,
+    ) -> str:
+        config_lines = [
+            f"# tc{self.case_id} config",
+            f'sync_dir = "{sync_dir}"',
+            'bypass_data_preservation = "true"',
+            'enable_logging = "true"',
+            f'log_dir = "{app_log_dir}"',
+            'monitor_interval = "5"',
+            'monitor_fullscan_frequency = "1"',
+        ]
+        if extra_config_lines:
+            config_lines.extend(extra_config_lines)
+        return "\n".join(config_lines) + "\n"
+
+    def _read_stdout(self, stdout_file: Path) -> str:
+        if not stdout_file.exists():
+            return ""
+        try:
+            return stdout_file.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return ""
+
+    def _wait_for_initial_sync_complete(
+        self,
+        stdout_file: Path,
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+        marker = "Sync with Microsoft OneDrive is complete"
+
+        while time.time() < deadline:
+            if marker in self._read_stdout(stdout_file):
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def _wait_for_monitor_patterns(
+        self,
+        stdout_file: Path,
+        required_patterns: list[str],
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+
+        while time.time() < deadline:
+            content = self._read_stdout(stdout_file)
+            if all(pattern in content for pattern in required_patterns):
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def _wait_for_any_monitor_pattern_group(
+        self,
+        stdout_file: Path,
+        alternative_pattern_groups: list[list[str]],
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> tuple[bool, int]:
+        deadline = time.time() + timeout_seconds
+
+        while time.time() < deadline:
+            content = self._read_stdout(stdout_file)
+            for idx, group in enumerate(alternative_pattern_groups):
+                if all(pattern in content for pattern in group):
+                    return True, idx
+            time.sleep(poll_interval)
+
+        return False, -1
+
+    def _launch_monitor_process_raw(
+        self,
+        context: E2EContext,
+        monitor_command: list[str],
+        monitor_stdout: Path,
+        monitor_stderr: Path,
+    ) -> subprocess.Popen[str]:
+        stdout_fp = monitor_stdout.open("w", encoding="utf-8")
+        stderr_fp = monitor_stderr.open("w", encoding="utf-8")
+        process = subprocess.Popen(
+            monitor_command,
+            cwd=str(context.repo_root),
+            stdout=stdout_fp,
+            stderr=stderr_fp,
+            text=True,
+        )
+        process._tc_stdout_fp = stdout_fp  # type: ignore[attr-defined]
+        process._tc_stderr_fp = stderr_fp  # type: ignore[attr-defined]
+        return process
+
+    def _wait_for_initial_sync_complete_or_transient_failure(
+        self,
+        process: subprocess.Popen[str],
+        stdout_file: Path,
+        stderr_file: Path,
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> str:
+        deadline = time.time() + timeout_seconds
+        marker = "Sync with Microsoft OneDrive is complete"
+
+        while time.time() < deadline:
+            stdout_content = self._read_stdout(stdout_file)
+            stderr_content = self._read_stdout(stderr_file)
+
+            if marker in stdout_content:
+                return "complete"
+
+            if is_transient_startup_discovery_failure(stdout_content, stderr_content):
+                return "transient_failure"
+
+            if process.poll() is not None:
+                return "process_exited"
+
+            time.sleep(poll_interval)
+
+        return "timeout"
+
+    def _launch_monitor_process(
+        self,
+        context: E2EContext,
+        monitor_command: list[str],
+        monitor_stdout: Path,
+        monitor_stderr: Path,
+        *,
+        startup_timeout_seconds: int = 120,
+        startup_retry_attempts: int = STARTUP_RETRY_ATTEMPTS,
+        startup_retry_sleep_seconds: float = STARTUP_RETRY_SLEEP_SECONDS,
+    ) -> tuple[subprocess.Popen[str], bool]:
+        last_process: subprocess.Popen[str] | None = None
+
+        for attempt in range(1, startup_retry_attempts + 1):
+            monitor_stdout.parent.mkdir(parents=True, exist_ok=True)
+            monitor_stderr.parent.mkdir(parents=True, exist_ok=True)
+            monitor_stdout.write_text("", encoding="utf-8")
+            monitor_stderr.write_text("", encoding="utf-8")
+
+            process = self._launch_monitor_process_raw(context, monitor_command, monitor_stdout, monitor_stderr)
+            status = self._wait_for_initial_sync_complete_or_transient_failure(
+                process,
+                monitor_stdout,
+                monitor_stderr,
+                timeout_seconds=startup_timeout_seconds,
+            )
+
+            if status == "complete":
+                return process, True
+
+            self._shutdown_monitor_process(process, {})
+            last_process = process
+
+            if status != "transient_failure" or attempt >= startup_retry_attempts:
+                return process, False
+
+            time.sleep(startup_retry_sleep_seconds)
+
+        assert last_process is not None
+        return last_process, False
+
+    def _shutdown_monitor_process(self, process: subprocess.Popen[str], details: dict[str, object]) -> None:
+        try:
+            if process.poll() is None:
+                process.send_signal(signal.SIGINT)
+                try:
+                    process.wait(timeout=30)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait(timeout=30)
+            details["monitor_returncode"] = process.returncode
+        finally:
+            stdout_fp = getattr(process, "_tc_stdout_fp", None)
+            stderr_fp = getattr(process, "_tc_stderr_fp", None)
+            if stdout_fp is not None:
+                stdout_fp.close()
+            if stderr_fp is not None:
+                stderr_fp.close()
+
+    def _run_verify_command(
+        self,
+        context: E2EContext,
+        verify_command: list[str],
+        verify_stdout: Path,
+        verify_stderr: Path,
+    ):
+        result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, result.stdout)
+        write_text_file(verify_stderr, result.stderr)
+        return result
+
+    def _write_file_with_exact_size(self, path: Path, size_bytes: int, header_text: str) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        header_bytes = header_text.encode("utf-8")
+        if len(header_bytes) > size_bytes:
+            raise ValueError(f"header_text is larger than requested file size for {path}")
+
+        filler_size = size_bytes - len(header_bytes)
+        filler_chunk = b"0123456789ABCDEF" * 4096
+
+        with path.open("wb") as handle:
+            handle.write(header_bytes)
+            while filler_size > 0:
+                chunk = filler_chunk[: min(len(filler_chunk), filler_size)]
+                handle.write(chunk)
+                filler_size -= len(chunk)
diff --git a/ci/e2e/testcases/tc0001_basic_resync.py b/ci/e2e/testcases/tc0001_basic_resync.py
new file mode 100644
index 000000000..b9ef487c2
--- /dev/null
+++ b/ci/e2e/testcases/tc0001_basic_resync.py
@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0001BasicResync(E2ETestCase):
+    """
+    Test Case 0001: basic resync
+
+    Purpose:
+    - validate that the E2E framework can invoke the client
+    - validate that the configured environment is sufficient to run a basic sync
+    - provide a simple baseline smoke test before more advanced E2E scenarios
+    """
+
+    case_id = "0001"
+    name = "basic resync"
+    description = "Run a basic --sync --resync --resync-auth operation and capture the outcome"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name=f"tc{self.case_id}",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        conf_dir = case_work_dir / "conf-main"
+
+        reset_directory(sync_root)
+        reset_directory(conf_dir)
+        context.bootstrap_config_dir(conf_dir)
+
+        stdout_file = case_log_dir / "stdout.log"
+        stderr_file = case_log_dir / "stderr.log"
+        metadata_file = state_dir / "metadata.txt"
+
+        write_onedrive_config(
+            conf_dir / "config",
+            "# tc0001 config\n",
+        )
+
+        command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_dir),
+        ]
+
+        context.log(
+            f"Executing Test Case {self.case_id}: {command_to_string(command)}"
+        )
+
+        result = run_command(command, cwd=context.repo_root)
+
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+
+        metadata_lines = [
+            f"case_id={self.case_id}",
+            f"name={self.name}",
+            f"command={command_to_string(command)}",
+            f"returncode={result.returncode}",
+            f"sync_root={sync_root}",
+            f"conf_dir={conf_dir}",
+        ]
+        write_text_file(metadata_file, "\n".join(metadata_lines) + "\n")
+
+        artifacts = [
+            str(stdout_file),
+            str(stderr_file),
+            str(metadata_file),
+        ]
+
+        details = {
+            "command": command,
+            "returncode": result.returncode,
+            "sync_root": str(sync_root),
+            "conf_dir": str(conf_dir),
+        }
+
+        if result.returncode != 0:
+            reason = f"onedrive exited with non-zero status {result.returncode}"
+            return self.fail_result(
+                case_id=self.case_id,
+                name=self.name,
+                reason=reason,
+                artifacts=artifacts,
+                details=details,
+            )
+
+        return self.pass_result(
+            case_id=self.case_id,
+            name=self.name,
+            artifacts=artifacts,
+            details=details,
+        )
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0002_sync_list_validation.py b/ci/e2e/testcases/tc0002_sync_list_validation.py
new file mode 100644
index 000000000..5a51244bc
--- /dev/null
+++ b/ci/e2e/testcases/tc0002_sync_list_validation.py
@@ -0,0 +1,2271 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+FIXTURE_ROOT_NAME = "ZZ_E2E_SYNC_LIST"
+CONFIG_FILE_NAME = "config"
+
+
+@dataclass
+class ParsedEvent:
+    event_type: str
+    raw_path: str
+    normalised_path: str
+    line: str
+
+
+@dataclass
+class SyncListScenario:
+    scenario_id: str
+    description: str
+    sync_list: list[str]
+
+    # Standard policy validation rules
+    allowed_exact: list[str] = field(default_factory=list)
+    allowed_prefixes: list[str] = field(default_factory=list)
+    forbidden_exact: list[str] = field(default_factory=list)
+    forbidden_prefixes: list[str] = field(default_factory=list)
+    required_processed: list[str] = field(default_factory=list)
+    required_skipped: list[str] = field(default_factory=list)
+
+    # Execution mode
+    execution_mode: str = "single"
+
+    # Phase-specific config overrides
+    phase1_config_overrides: list[str] = field(default_factory=list)
+    phase2_config_overrides: list[str] = field(default_factory=list)
+
+    # Cleanup regression expectations
+    expected_present_after: list[str] = field(default_factory=list)
+    expected_absent_after: list[str] = field(default_factory=list)
+    required_removed: list[str] = field(default_factory=list)
+    forbidden_removed: list[str] = field(default_factory=list)
+
+    def path_matches_prefix(self, path: str, prefix: str) -> bool:
+        prefix = prefix.strip("/")
+        if not prefix:
+            return False
+        return path == prefix or path.startswith(prefix + "/")
+
+    def is_forbidden(self, path: str) -> bool:
+        path = path.strip("/")
+
+        if path in [item.strip("/") for item in self.forbidden_exact]:
+            return True
+
+        for prefix in self.forbidden_prefixes:
+            if self.path_matches_prefix(path, prefix):
+                return True
+
+        return False
+
+    def is_allowed_non_skip(self, path: str) -> bool:
+        path = path.strip("/")
+
+        if self.is_forbidden(path):
+            return False
+
+        if path in [item.strip("/") for item in self.allowed_exact]:
+            return True
+
+        for prefix in self.allowed_prefixes:
+            if self.path_matches_prefix(path, prefix):
+                return True
+
+        return False
+
+    def is_allowed_container(self, path: str) -> bool:
+        path = path.strip("/")
+
+        if path == FIXTURE_ROOT_NAME:
+            return True
+
+        for item in self.allowed_exact:
+            item = item.strip("/")
+            if item.startswith(path + "/"):
+                return True
+
+        for prefix in self.allowed_prefixes:
+            prefix = prefix.strip("/")
+            if prefix.startswith(path + "/"):
+                return True
+
+        return False
+
+
+class TestCase0002SyncListValidation(E2ETestCase):
+    """
+    Test Case 0002: sync_list validation
+
+    This validates sync_list as a policy-conformance test.
+    The Issue #3655 scenarios additionally reproduce the reported lifecycle:
+
+    1. Seed the entire fixture tree remotely with no sync_list restrictions.
+    2. Re-run with download_only + cleanup_local_files + issue-style sync_list.
+    3. Validate both debug log decisions and final local filesystem state.
+    """
+
+    case_id = "0002"
+    name = "sync_list validation"
+    description = "Validate sync_list behaviour across a scenario matrix"
+
+
+    EVENT_PATTERNS = [
+        (
+            "skip",
+            re.compile(r"^(?:DEBUG:\s+)?Skipping path - excluded by sync_list config: (.+)$"),
+        ),
+        (
+            "skip",
+            re.compile(r"^(?:DEBUG:\s+)?Skipping file - excluded by sync_list config: (.+)$"),
+        ),
+        (
+            "include_dir",
+            re.compile(r"^(?:DEBUG:\s+)?Including path - included by sync_list config: (.+)$"),
+        ),
+        (
+            "include_file",
+            re.compile(r"^(?:DEBUG:\s+)?Including file - included by sync_list config: (.+)$"),
+        ),
+        (
+            "retain_path",
+            re.compile(r"^(?:DEBUG:\s+)?Path retained due to 'sync_list' inclusion: (.+)$"),
+        ),
+        (
+            "retain_existing",
+            re.compile(r"^(?:DEBUG:\s+)?Path already marked for retention - retaining path: (.+)$"),
+        ),
+        (
+            "retain_local_file",
+            re.compile(
+                r"^(?:DEBUG:\s+)?Local file should be retained due to 'sync_list' inclusion: (.+)$"
+            ),
+        ),
+        (
+            "retain_local_dir",
+            re.compile(
+                r"^(?:DEBUG:\s+)?Local directory should be retained due to 'sync_list' inclusion: (.+)$"
+            ),
+        ),
+        (
+            "retain_local_parent_dir",
+            re.compile(
+                r"^(?:DEBUG:\s+)?Local parent directory should be retained due to 'sync_list' inclusion: (.+)$"
+            ),
+        ),
+        (
+            "retain_sync_root_file",
+            re.compile(
+                r"^(?:DEBUG:\s+)?Path retained due to 'sync_root_files' override for logical root file: (.+)$"
+            ),
+        ),
+        (
+            "upload_file",
+            re.compile(r"^(?:DEBUG:\s+)?Uploading new file: (.+?) \.\.\."),
+        ),
+        (
+            "create_remote_dir",
+            re.compile(
+                r"^(?:DEBUG:\s+)?OneDrive Client requested to create this directory online: (.+)$"
+            ),
+        ),
+    ]
+
+    REMOVAL_PATTERNS = [
+        (
+            "remove_local_file",
+            re.compile(r"^(?:DEBUG:\s+)?Removing local file: (.+)$"),
+        ),
+        (
+            "remove_local_dir",
+            re.compile(r"^(?:DEBUG:\s+)?Removing local directory: (.+)$"),
+        ),
+        (
+            "attempt_remove_local_file",
+            re.compile(r"^(?:DEBUG:\s+)?Attempting removal of local file: (.+)$"),
+        ),
+        (
+            "attempt_remove_local_dir",
+            re.compile(r"^(?:DEBUG:\s+)?Attempting removal of local directory: (.+)$"),
+        ),
+        (
+            "removed_local_file",
+            re.compile(r"^(?:DEBUG:\s+)?Removed local file: (.+)$"),
+        ),
+        (
+            "removed_local_dir",
+            re.compile(r"^(?:DEBUG:\s+)?Removed local directory: (.+)$"),
+        ),
+        (
+            "remove_parent_local_dir",
+            re.compile(r"^(?:DEBUG:\s+)?Removing parental local directory: (.+)$"),
+        ),
+    ]
+
+    def _refresh_tree_mtimes(self, root: Path) -> None:
+        now = None
+        for path in sorted(root.rglob("*"), reverse=True):
+            os.utime(path, now)
+        os.utime(root, now)
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name=f"tc{self.case_id}",
+            ensure_refresh_token=False,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        fixture_root = case_work_dir / "fixture"
+        sync_root = case_work_dir / "syncroot"
+
+        context.ensure_refresh_token_available()
+        self._create_fixture_tree(fixture_root)
+
+        scenarios = [
+            scenario for scenario in self._build_scenarios()
+            if context.should_run_scenario(self.case_id, scenario.scenario_id)
+        ]
+
+        failures: list[str] = []
+        all_artifacts: list[str] = []
+
+        for scenario in scenarios:
+            context.log(
+                f"Running Test Case {self.case_id} scenario {scenario.scenario_id}: "
+                f"{scenario.description}"
+            )
+
+            scenario_dir = state_dir / scenario.scenario_id
+            scenario_log_dir = case_log_dir / scenario.scenario_id
+            config_dir = case_work_dir / f"config-{scenario.scenario_id}"
+
+            reset_directory(scenario_dir)
+            reset_directory(scenario_log_dir)
+            reset_directory(config_dir)
+            reset_directory(sync_root)
+
+            copied_refresh_token = context.bootstrap_config_dir(config_dir)
+
+            config_path = config_dir / CONFIG_FILE_NAME
+            existing_config_text = (
+                config_path.read_text(encoding="utf-8") if config_path.exists() else ""
+            )
+            base_config_text = self._build_base_config_text(existing_config_text)
+            write_text_file(config_path, base_config_text)
+
+            context.log(
+                f"Scenario {scenario.scenario_id} bootstrapped config dir: {config_dir}"
+            )
+            context.log(
+                f"Scenario {scenario.scenario_id} wrote tc0002 base config: {config_path}"
+            )
+
+            shutil.copytree(fixture_root, sync_root, dirs_exist_ok=True)
+            
+            self._refresh_tree_mtimes(sync_root)
+
+            sync_list_path = config_dir / "sync_list"
+            metadata_file = scenario_dir / "metadata.txt"
+            actual_manifest_file = scenario_dir / "actual_manifest.txt"
+            diff_file = scenario_dir / "diff.txt"
+
+            metadata_lines = [
+                f"scenario_id={scenario.scenario_id}",
+                f"description={scenario.description}",
+                f"config_dir={config_dir}",
+                f"config_path={config_path}",
+                f"refresh_token_path={copied_refresh_token}",
+                f"execution_mode={scenario.execution_mode}",
+            ]
+
+            all_artifacts.extend(
+                [
+                    str(config_path),
+                    str(sync_list_path),
+                    str(metadata_file),
+                    str(actual_manifest_file),
+                ]
+            )
+
+            if scenario.execution_mode == "cleanup_regression":
+                diffs, artifacts, extra_metadata = self._run_cleanup_regression_scenario(
+                    context=context,
+                    scenario=scenario,
+                    sync_root=sync_root,
+                    config_dir=config_dir,
+                    config_path=config_path,
+                    base_config_text=base_config_text,
+                    sync_list_path=sync_list_path,
+                    scenario_dir=scenario_dir,
+                    scenario_log_dir=scenario_log_dir,
+                )
+            else:
+                diffs, artifacts, extra_metadata = self._run_standard_scenario(
+                    context=context,
+                    scenario=scenario,
+                    sync_root=sync_root,
+                    config_dir=config_dir,
+                    config_path=config_path,
+                    base_config_text=base_config_text,
+                    sync_list_path=sync_list_path,
+                    scenario_dir=scenario_dir,
+                    scenario_log_dir=scenario_log_dir,
+                )
+
+            all_artifacts.extend(artifacts)
+            metadata_lines.extend(extra_metadata)
+            write_text_file(metadata_file, "\n".join(metadata_lines) + "\n")
+
+            actual_manifest = build_manifest(sync_root)
+            write_manifest(actual_manifest_file, actual_manifest)
+
+            if diffs:
+                write_text_file(diff_file, "\n".join(diffs) + "\n")
+                all_artifacts.append(str(diff_file))
+
+                failure_message = f"{scenario.scenario_id}: " + "; ".join(diffs)
+                failures.append(failure_message)
+                context.log(f"Scenario {scenario.scenario_id} FAILED: {failure_message}")
+            else:
+                context.log(f"Scenario {scenario.scenario_id} PASSED")
+
+        details = {
+            "scenario_count": len(scenarios),
+            "executed_scenario_ids": [scenario.scenario_id for scenario in scenarios],
+            "failed_scenarios": len(failures),
+            "failed_scenario_ids": [failure.split(":", 1)[0] for failure in failures],
+        }
+
+        if failures:
+            reason = (
+                f"{len(failures)} of {len(scenarios)} sync_list scenarios failed: "
+                + ", ".join(failure.split(":")[0] for failure in failures)
+            )
+            details["failures"] = failures
+            return self.fail_result(
+                case_id=self.case_id,
+                name=self.name,
+                reason=reason,
+                artifacts=all_artifacts,
+                details=details,
+            )
+
+        return self.pass_result(
+            case_id=self.case_id,
+            name=self.name,
+            artifacts=all_artifacts,
+            details=details,
+        )
+
+    def _build_base_config_text(self, existing_config_text: str = "") -> str:
+        sections: list[str] = []
+
+        existing_config_text = existing_config_text.strip("\n")
+        if existing_config_text.strip():
+            sections.append(existing_config_text)
+
+        sections.append(
+            "\n".join(
+                [
+                    "# tc0002 base config",
+                    'bypass_data_preservation = "true"',
+                    'skip_file = "~*|.~*|*.tmp|*.swp|*.partial|*-safeBackup-*"',
+                ]
+            )
+        )
+
+        return "\n\n".join(sections).rstrip("\n") + "\n"
+
+    def _run_standard_scenario(
+        self,
+        context: E2EContext,
+        scenario: SyncListScenario,
+        sync_root: Path,
+        config_dir: Path,
+        config_path: Path,
+        base_config_text: str,
+        sync_list_path: Path,
+        scenario_dir: Path,
+        scenario_log_dir: Path,
+    ) -> tuple[list[str], list[str], list[str]]:
+        artifacts: list[str] = []
+        metadata: list[str] = []
+
+        self._write_config_with_overrides(config_path, base_config_text, scenario.phase2_config_overrides)
+        self._write_sync_list(sync_list_path, scenario.sync_list)
+
+        stdout_file = scenario_log_dir / "stdout.log"
+        stderr_file = scenario_log_dir / "stderr.log"
+        events_file = scenario_dir / "events.json"
+
+        command = self._build_sync_command(context, sync_root, config_dir)
+        result = run_command(command, cwd=context.repo_root)
+
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+        artifacts.extend([str(stdout_file), str(stderr_file), str(events_file)])
+        metadata.extend(
+            [
+                f"command={command_to_string(command)}",
+                f"returncode={result.returncode}",
+            ]
+        )
+
+        if result.returncode != 0:
+            return [
+                f"onedrive exited with non-zero status {result.returncode}"
+            ], artifacts, metadata
+
+        events = self._parse_events(result.stdout)
+        fixture_events = [event for event in events if self._is_fixture_path(event.normalised_path)]
+
+        write_text_file(
+            events_file,
+            json.dumps(
+                [
+                    {
+                        "event_type": event.event_type,
+                        "raw_path": event.raw_path,
+                        "normalised_path": event.normalised_path,
+                        "line": event.line,
+                    }
+                    for event in fixture_events
+                ],
+                indent=2,
+            )
+            + "\n",
+        )
+
+        diffs = self._validate_scenario(scenario, fixture_events)
+        return diffs, artifacts, metadata
+
+    def _run_cleanup_regression_scenario(
+        self,
+        context: E2EContext,
+        scenario: SyncListScenario,
+        sync_root: Path,
+        config_dir: Path,
+        config_path: Path,
+        base_config_text: str,
+        sync_list_path: Path,
+        scenario_dir: Path,
+        scenario_log_dir: Path,
+    ) -> tuple[list[str], list[str], list[str]]:
+        artifacts: list[str] = []
+        metadata: list[str] = []
+        diffs: list[str] = []
+
+        phase1_stdout = scenario_log_dir / "phase1_stdout.log"
+        phase1_stderr = scenario_log_dir / "phase1_stderr.log"
+        phase1_manifest = scenario_dir / "phase1_manifest.txt"
+        phase2_stdout = scenario_log_dir / "phase2_stdout.log"
+        phase2_stderr = scenario_log_dir / "phase2_stderr.log"
+        phase2_events_file = scenario_dir / "phase2_events.json"
+        phase2_removals_file = scenario_dir / "phase2_removals.json"
+        pre_cleanup_manifest = scenario_dir / "pre_cleanup_manifest.txt"
+        post_cleanup_manifest = scenario_dir / "post_cleanup_manifest.txt"
+
+        artifacts.extend(
+            [
+                str(phase1_stdout),
+                str(phase1_stderr),
+                str(phase1_manifest),
+                str(phase2_stdout),
+                str(phase2_stderr),
+                str(phase2_events_file),
+                str(phase2_removals_file),
+                str(pre_cleanup_manifest),
+                str(post_cleanup_manifest),
+            ]
+        )
+
+        # Phase 1: unrestricted seed to create the full remote dataset.
+        self._write_config_with_overrides(config_path, base_config_text, scenario.phase1_config_overrides)
+        if sync_list_path.exists():
+            sync_list_path.unlink()
+
+        phase1_command = self._build_sync_command(context, sync_root, config_dir)
+        phase1_result = run_command(phase1_command, cwd=context.repo_root)
+        write_text_file(phase1_stdout, phase1_result.stdout)
+        write_text_file(phase1_stderr, phase1_result.stderr)
+        metadata.extend(
+            [
+                f"phase1_command={command_to_string(phase1_command)}",
+                f"phase1_returncode={phase1_result.returncode}",
+            ]
+        )
+
+        if phase1_result.returncode != 0:
+            diffs.append(f"Phase 1 unrestricted seed failed with status {phase1_result.returncode}")
+            return diffs, artifacts, metadata
+
+        write_manifest(phase1_manifest, build_manifest(sync_root))
+        write_manifest(pre_cleanup_manifest, build_manifest(sync_root))
+
+        # Phase 2: issue-style restrictive cleanup.
+        self._write_config_with_overrides(config_path, base_config_text, scenario.phase2_config_overrides)
+        self._write_sync_list(sync_list_path, scenario.sync_list)
+
+        phase2_command = self._build_sync_command(context, sync_root, config_dir)
+        phase2_result = run_command(phase2_command, cwd=context.repo_root)
+        write_text_file(phase2_stdout, phase2_result.stdout)
+        write_text_file(phase2_stderr, phase2_result.stderr)
+        metadata.extend(
+            [
+                f"phase2_command={command_to_string(phase2_command)}",
+                f"phase2_returncode={phase2_result.returncode}",
+            ]
+        )
+
+        if phase2_result.returncode != 0:
+            diffs.append(f"Phase 2 cleanup validation failed with status {phase2_result.returncode}")
+            return diffs, artifacts, metadata
+
+        phase2_events = self._parse_events(phase2_result.stdout)
+        fixture_events = [event for event in phase2_events if self._is_fixture_path(event.normalised_path)]
+        removals = self._parse_removals(phase2_result.stdout)
+        fixture_removals = [event for event in removals if self._is_fixture_path(event.normalised_path)]
+
+        write_text_file(
+            phase2_events_file,
+            json.dumps(
+                [
+                    {
+                        "event_type": event.event_type,
+                        "raw_path": event.raw_path,
+                        "normalised_path": event.normalised_path,
+                        "line": event.line,
+                    }
+                    for event in fixture_events
+                ],
+                indent=2,
+            )
+            + "\n",
+        )
+        write_text_file(
+            phase2_removals_file,
+            json.dumps(
+                [
+                    {
+                        "event_type": event.event_type,
+                        "raw_path": event.raw_path,
+                        "normalised_path": event.normalised_path,
+                        "line": event.line,
+                    }
+                    for event in fixture_removals
+                ],
+                indent=2,
+            )
+            + "\n",
+        )
+        write_manifest(post_cleanup_manifest, build_manifest(sync_root))
+
+        diffs.extend(self._validate_scenario(scenario, fixture_events))
+        diffs.extend(
+            self._validate_cleanup_required_skipped(
+                scenario,
+                sync_root,
+                fixture_events,
+                fixture_removals,
+            )
+        )
+        diffs.extend(self._validate_cleanup_expectations(scenario, sync_root, fixture_removals))
+
+        return diffs, artifacts, metadata
+
+    def _build_sync_command(self, context: E2EContext, sync_root: Path, config_dir: Path) -> list[str]:
+        return [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(config_dir),
+        ]
+
+    def _write_config_with_overrides(
+        self,
+        config_path: Path,
+        base_config_text: str,
+        overrides: list[str],
+    ) -> None:
+        text = base_config_text.rstrip("\n")
+        if overrides:
+            text += "\n\n# tc0002 scenario overrides\n" + "\n".join(overrides)
+        if text and not text.endswith("\n"):
+            text += "\n"
+        write_text_file(config_path, text)
+
+    def _write_sync_list(self, sync_list_path: Path, sync_list: list[str]) -> None:
+        write_text_file(sync_list_path, "\n".join(sync_list) + "\n")
+
+    def _normalise_log_path(self, raw_path: str) -> str:
+        path = raw_path.strip()
+        if path.startswith("./"):
+            path = path[2:]
+        path = path.replace("\\", "/")
+        path = re.sub(r"/+", "/", path)
+        path = path.rstrip("/")
+        return path
+
+    def _parse_events(self, stdout: str) -> list[ParsedEvent]:
+        events: list[ParsedEvent] = []
+
+        for line in stdout.splitlines():
+            stripped = line.strip()
+
+            for event_type, pattern in self.EVENT_PATTERNS:
+                match = pattern.match(stripped)
+                if not match:
+                    continue
+
+                raw_path = match.group(1).strip()
+                normalised_path = self._normalise_log_path(raw_path)
+
+                events.append(
+                    ParsedEvent(
+                        event_type=event_type,
+                        raw_path=raw_path,
+                        normalised_path=normalised_path,
+                        line=stripped,
+                    )
+                )
+                break
+
+        return events
+
+    def _parse_removals(self, stdout: str) -> list[ParsedEvent]:
+        removals: list[ParsedEvent] = []
+
+        for line in stdout.splitlines():
+            stripped = line.strip()
+
+            for event_type, pattern in self.REMOVAL_PATTERNS:
+                match = pattern.match(stripped)
+                if not match:
+                    continue
+
+                raw_path = match.group(1).strip()
+                normalised_path = self._normalise_log_path(raw_path)
+                removals.append(
+                    ParsedEvent(
+                        event_type=event_type,
+                        raw_path=raw_path,
+                        normalised_path=normalised_path,
+                        line=stripped,
+                    )
+                )
+                break
+
+        return removals
+
+    def _is_fixture_path(self, path: str) -> bool:
+        return path == FIXTURE_ROOT_NAME or path.startswith(FIXTURE_ROOT_NAME + "/")
+
+    def _path_matches(self, path: str, prefix: str) -> bool:
+        prefix = prefix.strip("/")
+        if not prefix:
+            return False
+        return path == prefix or path.startswith(prefix + "/")
+
+    def _find_matching_events(
+        self,
+        events: list[ParsedEvent],
+        wanted_path: str,
+        event_type: str | None = None,
+        non_skip_only: bool = False,
+    ) -> list[ParsedEvent]:
+        matches: list[ParsedEvent] = []
+
+        for event in events:
+            if event_type and event.event_type != event_type:
+                continue
+            if non_skip_only and event.event_type == "skip":
+                continue
+            if self._path_matches(event.normalised_path, wanted_path):
+                matches.append(event)
+
+        return matches
+
+
+    def _validate_scenario(
+        self,
+        scenario: SyncListScenario,
+        events: list[ParsedEvent],
+    ) -> list[str]:
+        diffs: list[str] = []
+
+        if not events:
+            diffs.append("No fixture-related sync_list events were captured")
+            return diffs
+
+        for event in events:
+            path = event.normalised_path
+
+            if event.event_type == "skip":
+                continue
+
+            if scenario.is_forbidden(path):
+                diffs.append(
+                    f"Forbidden path was processed by sync_list: {path} "
+                    f"(line: {event.line})"
+                )
+                continue
+
+            if not scenario.is_allowed_non_skip(path) and not scenario.is_allowed_container(path):
+                diffs.append(
+                    f"Unexpected path was processed by sync_list: {path} "
+                    f"(line: {event.line})"
+                )
+
+        for required in scenario.required_processed:
+            matches = self._find_matching_events(events, required, non_skip_only=True)
+            if not matches:
+                diffs.append(
+                    f"Expected allowed processing was not observed for: {required}"
+                )
+
+        if scenario.execution_mode != "cleanup_regression":
+            for required in scenario.required_skipped:
+                matches = self._find_matching_events(events, required, event_type="skip")
+                if not matches:
+                    diffs.append(
+                        f"Expected excluded skip was not observed for: {required}"
+                    )
+
+        return diffs
+
+
+    def _cleanup_path_absent(self, sync_root: Path, rel_path: str) -> bool:
+        return not (sync_root / rel_path).exists()
+
+
+    def _validate_cleanup_required_skipped(
+        self,
+        scenario: SyncListScenario,
+        sync_root: Path,
+        events: list[ParsedEvent],
+        removals: list[ParsedEvent],
+    ) -> list[str]:
+        diffs: list[str] = []
+
+        for rel_path in scenario.required_skipped:
+            skip_matches = self._find_matching_events(events, rel_path, event_type="skip")
+            if skip_matches:
+                continue
+
+            removal_matches = self._find_matching_events(removals, rel_path)
+            if removal_matches:
+                continue
+
+            if self._cleanup_path_absent(sync_root, rel_path):
+                continue
+
+            diffs.append(f"Expected excluded skip was not observed for: {rel_path}")
+
+        return diffs
+
+
+
+    def _validate_cleanup_expectations(
+        self,
+        scenario: SyncListScenario,
+        sync_root: Path,
+        removals: list[ParsedEvent],
+    ) -> list[str]:
+        diffs: list[str] = []
+
+        for rel_path in scenario.expected_present_after:
+            if not (sync_root / rel_path).exists():
+                diffs.append(f"Expected path missing after cleanup: {rel_path}")
+
+        for rel_path in scenario.expected_absent_after:
+            if (sync_root / rel_path).exists():
+                diffs.append(f"Excluded path still exists after cleanup: {rel_path}")
+
+        for rel_path in scenario.required_removed:
+            matches = self._find_matching_events(removals, rel_path)
+            if not matches and (sync_root / rel_path).exists():
+                diffs.append(f"Expected local removal not observed for: {rel_path}")
+
+        for rel_path in scenario.forbidden_removed:
+            matches = self._find_matching_events(removals, rel_path)
+            if matches:
+                diffs.append(f"Unexpected local removal observed for: {rel_path}")
+
+        return diffs
+
+
+    def _safe_name_fragment(self, value: str) -> str:
+        return re.sub(r"[^A-Za-z0-9]+", "_", value).strip("_").lower() or "root"
+
+    def _dummy_filename_for_dir(self, rel_dir: str) -> str:
+        fragment = self._safe_name_fragment(rel_dir.replace("/", "_"))
+        extensions = [".bin", ".dat", ".cache", ".blob"]
+        ext = extensions[len(fragment) % len(extensions)]
+        return f"zz_e2e_{fragment}{ext}"
+
+    def _write_random_file(self, path: Path, size_bytes: int = 50 * 1024) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(os.urandom(size_bytes))
+
+    def _ensure_every_directory_has_direct_file(
+        self,
+        root: Path,
+        dirs: list[str],
+        existing_files: dict[str, str],
+    ) -> None:
+        dirs_set = {d.strip("/") for d in dirs}
+
+        dirs_with_direct_files: set[str] = set()
+        for rel_file in existing_files.keys():
+            rel_file = rel_file.strip("/")
+            parent = str(Path(rel_file).parent).replace("\\", "/")
+            if parent == ".":
+                parent = ""
+            dirs_with_direct_files.add(parent)
+
+        for rel_dir in sorted(dirs_set):
+            if rel_dir in dirs_with_direct_files:
+                continue
+
+            dummy_name = self._dummy_filename_for_dir(rel_dir)
+            dummy_path = root / rel_dir / dummy_name
+            self._write_random_file(dummy_path)
+
+    def _create_fixture_tree(self, root: Path) -> None:
+        reset_directory(root)
+
+        dirs = [
+            FIXTURE_ROOT_NAME,
+            f"{FIXTURE_ROOT_NAME}/Backup",
+            f"{FIXTURE_ROOT_NAME}/Blender",
+            f"{FIXTURE_ROOT_NAME}/Documents",
+            f"{FIXTURE_ROOT_NAME}/Documents/.Libraries",
+            f"{FIXTURE_ROOT_NAME}/Documents/.Templates",
+            f"{FIXTURE_ROOT_NAME}/Documents/Notes",
+            f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+            f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash",
+            f"{FIXTURE_ROOT_NAME}/Documents/Notes/temp123",
+            f"{FIXTURE_ROOT_NAME}/Work",
+            f"{FIXTURE_ROOT_NAME}/Work/ProjectA",
+            f"{FIXTURE_ROOT_NAME}/Work/ProjectA/.gradle",
+            f"{FIXTURE_ROOT_NAME}/Work/ProjectB",
+            f"{FIXTURE_ROOT_NAME}/Secret_data",
+            f"{FIXTURE_ROOT_NAME}/Random",
+            f"{FIXTURE_ROOT_NAME}/Random/Backup",
+            f"{FIXTURE_ROOT_NAME}/Wallpapers",
+            f"{FIXTURE_ROOT_NAME}/0.1.Backups",
+            f"{FIXTURE_ROOT_NAME}/1.0.Resources",
+            f"{FIXTURE_ROOT_NAME}/Projects",
+            f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+            f"{FIXTURE_ROOT_NAME}/Projects/Audio/Samples",
+            f"{FIXTURE_ROOT_NAME}/Projects/Video",
+            f"{FIXTURE_ROOT_NAME}/Projects/Video/Renders",
+            f"{FIXTURE_ROOT_NAME}/Projects/Code",
+            f"{FIXTURE_ROOT_NAME}/Projects/Code-Archive",
+            f"{FIXTURE_ROOT_NAME}/Projects/Codecs",
+            f"{FIXTURE_ROOT_NAME}/Projects/Coder",
+            f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ",
+            f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+            f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source",
+            f"{FIXTURE_ROOT_NAME}/Programming",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build/intermediates",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx/tmp",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/build",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/.cxx",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/src",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build/assets",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/build",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/src",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/.venv",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/.venv/bin",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/venv",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/venv/bin",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/__pycache__",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/src",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/.gradle",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build/kotlin",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules/pkg",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/src",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/.next",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/src",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/libraries",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/caches",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/src",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/.cache",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/src",
+            f"{FIXTURE_ROOT_NAME}/RuleLab",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeA",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeA/A",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeA/A/B",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeA/A/B/C",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeB",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeB/A",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeB/A/B",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeB/A/B/C",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/temp",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/With Spaces",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/With Spaces/Family pictures",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/With Spaces/Family pictures/Annas pictures",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/With Spaces/Family pictures/Bens pictures",
+        ]
+
+        for rel in dirs:
+            (root / rel).mkdir(parents=True, exist_ok=True)
+
+        files = {
+            f"{FIXTURE_ROOT_NAME}/Backup/root-backup.txt": "backup-root\n",
+            f"{FIXTURE_ROOT_NAME}/Blender/scene.blend": "blend-scene\n",
+            f"{FIXTURE_ROOT_NAME}/Documents/latest_report.docx": "latest report\n",
+            f"{FIXTURE_ROOT_NAME}/Documents/report.pdf": "report pdf\n",
+            f"{FIXTURE_ROOT_NAME}/Documents/.Libraries/library-index.txt": "libraries\n",
+            f"{FIXTURE_ROOT_NAME}/Documents/.Templates/base-template.dotx": "template\n",
+            f"{FIXTURE_ROOT_NAME}/Documents/Notes/keep.txt": "keep\n",
+            f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config/app.json": '{"ok": true}\n',
+            f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash/old.txt": "old\n",
+            f"{FIXTURE_ROOT_NAME}/Documents/Notes/temp123/ignored.txt": "ignored\n",
+            f"{FIXTURE_ROOT_NAME}/Work/ProjectA/keep.txt": "project a\n",
+            f"{FIXTURE_ROOT_NAME}/Work/ProjectA/.gradle/state.bin": "gradle\n",
+            f"{FIXTURE_ROOT_NAME}/Work/ProjectB/latest_report.docx": "project b report\n",
+            f"{FIXTURE_ROOT_NAME}/Secret_data/secret.txt": "secret\n",
+            f"{FIXTURE_ROOT_NAME}/Random/Backup/nested-backup.txt": "nested backup\n",
+            f"{FIXTURE_ROOT_NAME}/Wallpapers/wallpaper1.jpg": "wallpaper\n",
+            f"{FIXTURE_ROOT_NAME}/0.1.Backups/archive1.bin": "archive\n",
+            f"{FIXTURE_ROOT_NAME}/1.0.Resources/resource1.dat": "resource\n",
+            f"{FIXTURE_ROOT_NAME}/Projects/Audio/song.wav": "audio\n",
+            f"{FIXTURE_ROOT_NAME}/Projects/Audio/Samples/sample.wav": "sample\n",
+            f"{FIXTURE_ROOT_NAME}/Projects/Video/movie.mp4": "video\n",
+            f"{FIXTURE_ROOT_NAME}/Projects/Video/Renders/render.mov": "render\n",
+            f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav": "export wav\n",
+            f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt": "source\n",
+            f"{FIXTURE_ROOT_NAME}/Projects/Code-Archive/archive.txt": "archived code\n",
+            f"{FIXTURE_ROOT_NAME}/Projects/Codecs/readme.txt": "codecs info\n",
+            f"{FIXTURE_ROOT_NAME}/Projects/Coder/profile.txt": "coder profile\n",
+            f"{FIXTURE_ROOT_NAME}/README.txt": "fixture readme\n",
+            f"{FIXTURE_ROOT_NAME}/loose.bin": "fixture loose data\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build/output.apk": "android app1 build\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build/intermediates/classes.dex": "classes dex\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx/tmp/native.o": "native object\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src/main.kt": "fun main() {}\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/build/obj.o": "android app2 build\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/.cxx/state.bin": "android app2 cxx\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/src/app.kt": "class App\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build/bundle.js": "bundle\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build/assets/chunk.js": "chunk\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src/index.ts": "console.log('site1');\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/build/app.js": "site2 build\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/src/app.ts": "console.log('site2');\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/.venv/bin/python": "venv python\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/venv/bin/python": "venv python 2\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/__pycache__/main.pyc": "pyc\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/src/main.py": "print('tool1')\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/.gradle/cache.bin": "gradle cache\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build/kotlin/output.class": "class bytes\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src/Main.java": "class Main {}\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules/pkg/index.js": "module.exports = {};\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/src/index.js": "console.log('node');\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/.next/cache.dat": "next cache\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/src/page.tsx": "export default function Page() {}\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/libraries/lib.xml": "<xml />\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/caches/cache.db": "cache db\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/src/App.kt": "class IdeaApp\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/.cache/tool.cache": "misc cache\n",
+            f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/src/readme.txt": "misc src\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET/file00.txt": "wide set file 00\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET/file01.txt": "wide set file 01\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET/file02.txt": "wide set file 02\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file00.txt": "wide set 15 file 00\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file01.txt": "wide set 15 file 01\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeA/A/B/C/tree.txt": "tree a\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeB/A/B/C/tree.txt": "tree b\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeB/A/B/C/other.txt": "tree b other\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/data.txt": "core data\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/image0.png": "image zero\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/image1.png": "image one\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/temp/transient.tmp": "temporary\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/With Spaces/Family pictures/Annas pictures/image0.png": "anna image\n",
+            f"{FIXTURE_ROOT_NAME}/RuleLab/With Spaces/Family pictures/Bens pictures/image0.png": "ben image\n",
+        }
+
+        for rel, content in files.items():
+            path = root / rel
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content, encoding="utf-8")
+
+        self._ensure_every_directory_has_direct_file(root, dirs, files)
+
+    def _build_scenarios(self) -> list[SyncListScenario]:
+        return [
+            SyncListScenario(
+                scenario_id="SL-0001",
+                description="root directory include with trailing slash",
+                sync_list=[f"/{FIXTURE_ROOT_NAME}/Backup/"],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Backup"],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                    f"{FIXTURE_ROOT_NAME}/Backup/root-backup.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Blender",
+                    f"{FIXTURE_ROOT_NAME}/Documents",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0002",
+                description="root include without trailing slash",
+                sync_list=[f"/{FIXTURE_ROOT_NAME}/Blender"],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Blender"],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Blender",
+                    f"{FIXTURE_ROOT_NAME}/Blender/scene.blend",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                    f"{FIXTURE_ROOT_NAME}/Documents",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0003",
+                description="non-root include by name",
+                sync_list=["Backup"],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                    f"{FIXTURE_ROOT_NAME}/Random/Backup",
+                    f"{FIXTURE_ROOT_NAME}/0.1.Backups",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                    f"{FIXTURE_ROOT_NAME}/Backup/root-backup.txt",
+                    f"{FIXTURE_ROOT_NAME}/Random/Backup",
+                    f"{FIXTURE_ROOT_NAME}/Random/Backup/nested-backup.txt",
+                    f"{FIXTURE_ROOT_NAME}/0.1.Backups",
+                    f"{FIXTURE_ROOT_NAME}/0.1.Backups/archive1.bin",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Blender",
+                    f"{FIXTURE_ROOT_NAME}/Documents",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0004",
+                description="include tree with nested exclusion",
+                execution_mode="cleanup_regression",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Documents/Notes/.config/*",
+                    f"/{FIXTURE_ROOT_NAME}/Documents/",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Documents"],
+                forbidden_prefixes=[f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config"],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/latest_report.docx",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/keep.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                ],
+                phase1_config_overrides=[
+                    'download_only = "false"',
+                    'cleanup_local_files = "false"',
+                ],
+                phase2_config_overrides=[
+                    'download_only = "true"',
+                    'cleanup_local_files = "false"',
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0005",
+                description="included tree with hidden directory excluded",
+                sync_list=["!.gradle/*", f"/{FIXTURE_ROOT_NAME}/Work/"],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Work"],
+                forbidden_prefixes=[f"{FIXTURE_ROOT_NAME}/Work/ProjectA/.gradle"],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Work/ProjectA/keep.txt",
+                    f"{FIXTURE_ROOT_NAME}/Work/ProjectB/latest_report.docx",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Work/ProjectA/.gradle",
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0006",
+                description="file-specific include inside named directory",
+                sync_list=[f"{FIXTURE_ROOT_NAME}/Documents/latest_report.docx"],
+                allowed_exact=[f"{FIXTURE_ROOT_NAME}/Documents/latest_report.docx"],
+                required_processed=[f"{FIXTURE_ROOT_NAME}/Documents/latest_report.docx"],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes",
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0007",
+                description="rooted include of Programming tree",
+                sync_list=[f"/{FIXTURE_ROOT_NAME}/Programming"],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming"],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src/main.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src/index.ts",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/src/main.py",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                    f"{FIXTURE_ROOT_NAME}/Documents",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0008",
+                description="exclude Android recursive build output and include Programming",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Android/**/build/*",
+                    f"/{FIXTURE_ROOT_NAME}/Programming",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/build",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src/main.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/src/app.kt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/build",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0009",
+                description="exclude Android recursive .cxx content and include Programming",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Android/**/.cxx/*",
+                    f"/{FIXTURE_ROOT_NAME}/Programming",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/.cxx",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src/main.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/src/app.kt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/.cxx",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0010",
+                description="exclude Web recursive build output and include Programming",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Web/**/build/*",
+                    f"/{FIXTURE_ROOT_NAME}/Programming",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/build",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src/index.ts",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/src/app.ts",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/build",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0011",
+                description="exclude .gradle anywhere and include Programming",
+                sync_list=["!.gradle/*", f"/{FIXTURE_ROOT_NAME}/Programming"],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming"],
+                forbidden_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/.gradle"],
+                required_processed=[f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src/Main.java"],
+                required_skipped=[f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/.gradle"],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0012",
+                description="exclude build/kotlin anywhere and include Programming",
+                sync_list=["!build/kotlin/*", f"/{FIXTURE_ROOT_NAME}/Programming"],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming"],
+                forbidden_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build/kotlin"],
+                required_processed=[f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src/Main.java"],
+                required_skipped=[f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build/kotlin"],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0013",
+                description="exclude .venv and venv anywhere and include Programming",
+                sync_list=["!.venv/*", "!venv/*", f"/{FIXTURE_ROOT_NAME}/Programming"],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/.venv",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/venv",
+                ],
+                required_processed=[f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/src/main.py"],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/.venv",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/venv",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0014",
+                description="exclude common cache and vendor directories and include Programming",
+                sync_list=[
+                    "!__pycache__/*",
+                    "!node_modules/*",
+                    "!.next/*",
+                    "!.idea/libraries/*",
+                    "!.idea/caches/*",
+                    "!.cache/*",
+                    f"/{FIXTURE_ROOT_NAME}/Programming",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/__pycache__",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/.next",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/libraries",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/caches",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/.cache",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/src/main.py",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/src/index.js",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/src/page.tsx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/src/App.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/src/readme.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/__pycache__",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/.next",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/libraries",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/caches",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/.cache",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0015",
+                description="complex style Programming ruleset",
+                sync_list=[
+                    "!build/kotlin/*",
+                    "!.kotlin/*",
+                    "!venv/*",
+                    "!.venv/*",
+                    "!.gradle/*",
+                    "!.idea/libraries/*",
+                    "!.idea/caches/*",
+                    "!.cache/*",
+                    "!__pycache__/*",
+                    "!node_modules/*",
+                    "!.next/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Android/**/build/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Android/**/.cxx/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Web/**/build/*",
+                    f"/{FIXTURE_ROOT_NAME}/Programming",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/venv",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/.venv",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/.gradle",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/.next",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/libraries",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/caches",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/.cache",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/__pycache__",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build/kotlin",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src/main.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/src/app.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src/index.ts",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/src/app.ts",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/src/main.py",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src/Main.java",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/src/index.js",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/src/page.tsx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/src/App.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/src/readme.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/.venv",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/venv",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/.gradle",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build/kotlin",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/.next",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/libraries",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/caches",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/.cache",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/__pycache__",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0016",
+                description="massive mixed rule set across Programming Documents and Work",
+                execution_mode="cleanup_regression",
+                sync_list=[
+                    "!build/kotlin/*",
+                    "!.gradle/*",
+                    "!.cache/*",
+                    "!__pycache__/*",
+                    "!node_modules/*",
+                    "!.next/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Android/**/build/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Android/**/.cxx/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Web/**/build/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Documents/Notes/.config/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Work/ProjectA/.gradle/*",
+                    f"/{FIXTURE_ROOT_NAME}/Programming",
+                    f"/{FIXTURE_ROOT_NAME}/Documents/",
+                    f"/{FIXTURE_ROOT_NAME}/Work/",
+                ],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming",
+                    f"{FIXTURE_ROOT_NAME}/Documents",
+                    f"{FIXTURE_ROOT_NAME}/Work",
+                ],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/.gradle",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build/kotlin",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/.next",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/.cache",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/__pycache__",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Work/ProjectA/.gradle",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/latest_report.docx",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/keep.txt",
+                    f"{FIXTURE_ROOT_NAME}/Work/ProjectA/keep.txt",
+                    f"{FIXTURE_ROOT_NAME}/Work/ProjectB/latest_report.docx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src/main.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src/index.ts",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src/Main.java",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Work/ProjectA/.gradle",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/.gradle",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build/kotlin",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/.next",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/.cache",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/__pycache__",
+                ],
+                phase1_config_overrides=[
+                    'download_only = "false"',
+                    'cleanup_local_files = "false"',
+                ],
+                phase2_config_overrides=[
+                    'download_only = "true"',
+                    'cleanup_local_files = "false"',
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0017",
+                description="stress test kitchen sink rule set with broad include and targeted file include",
+                sync_list=[
+                    "!build/kotlin/*",
+                    "!.kotlin/*",
+                    "!venv/*",
+                    "!.venv/*",
+                    "!.gradle/*",
+                    "!.idea/libraries/*",
+                    "!.idea/caches/*",
+                    "!.cache/*",
+                    "!__pycache__/*",
+                    "!node_modules/*",
+                    "!.next/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Android/**/build/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Android/**/.cxx/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/Web/**/build/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Documents/Notes/.config/*",
+                    f"!/{FIXTURE_ROOT_NAME}/Work/ProjectA/.gradle/*",
+                    f"/{FIXTURE_ROOT_NAME}/Programming",
+                    f"/{FIXTURE_ROOT_NAME}/Documents/",
+                    f"/{FIXTURE_ROOT_NAME}/Work/",
+                    f"/{FIXTURE_ROOT_NAME}/Backup/",
+                    f"{FIXTURE_ROOT_NAME}/Blender/scene.blend",
+                ],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming",
+                    f"{FIXTURE_ROOT_NAME}/Documents",
+                    f"{FIXTURE_ROOT_NAME}/Work",
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                ],
+                allowed_exact=[f"{FIXTURE_ROOT_NAME}/Blender/scene.blend"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/venv",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/.venv",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/__pycache__",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/.gradle",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build/kotlin",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/.next",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/libraries",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/caches",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/.cache",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Work/ProjectA/.gradle",
+                    f"{FIXTURE_ROOT_NAME}/Secret_data",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Backup/root-backup.txt",
+                    f"{FIXTURE_ROOT_NAME}/Blender/scene.blend",
+                    f"{FIXTURE_ROOT_NAME}/Documents/latest_report.docx",
+                    f"{FIXTURE_ROOT_NAME}/Work/ProjectB/latest_report.docx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src/main.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src/index.ts",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/src/main.py",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src/Main.java",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Work/ProjectA/.gradle",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/.venv",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/venv",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/__pycache__",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/.gradle",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build/kotlin",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/node_modules",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/.next",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/libraries",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/.idea/caches",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/.cache",
+                    f"{FIXTURE_ROOT_NAME}/Secret_data",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0018",
+                description="Issue #3655 exact trailing slash configuration with cleanup validation",
+                execution_mode="cleanup_regression",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Documents/Notes/.config/",
+                    f"!/{FIXTURE_ROOT_NAME}/Documents/Notes/.trash/",
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Audio/",
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Video/",
+                    f"/{FIXTURE_ROOT_NAME}/Projects/",
+                    f"/{FIXTURE_ROOT_NAME}/Documents/.Libraries/",
+                    f"/{FIXTURE_ROOT_NAME}/Documents/.Templates/",
+                    f"/{FIXTURE_ROOT_NAME}/Documents/Notes/",
+                    f"/{FIXTURE_ROOT_NAME}/Wallpapers/",
+                    f"/{FIXTURE_ROOT_NAME}/0.1.Backups/",
+                    f"/{FIXTURE_ROOT_NAME}/1.0.Resources/",
+                ],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Projects",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Libraries",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Templates",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes",
+                    f"{FIXTURE_ROOT_NAME}/Wallpapers",
+                    f"{FIXTURE_ROOT_NAME}/0.1.Backups",
+                    f"{FIXTURE_ROOT_NAME}/1.0.Resources",
+                ],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Libraries/library-index.txt",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Templates/base-template.dotx",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/keep.txt",
+                    f"{FIXTURE_ROOT_NAME}/Wallpapers/wallpaper1.jpg",
+                    f"{FIXTURE_ROOT_NAME}/0.1.Backups/archive1.bin",
+                    f"{FIXTURE_ROOT_NAME}/1.0.Resources/resource1.dat",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                phase1_config_overrides=[
+                    'download_only = "false"',
+                    'cleanup_local_files = "false"',
+                ],
+                phase2_config_overrides=[
+                    'download_only = "true"',
+                    'cleanup_local_files = "true"',
+                ],
+                expected_present_after=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Libraries/library-index.txt",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Templates/base-template.dotx",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/keep.txt",
+                    f"{FIXTURE_ROOT_NAME}/Wallpapers/wallpaper1.jpg",
+                    f"{FIXTURE_ROOT_NAME}/0.1.Backups/archive1.bin",
+                    f"{FIXTURE_ROOT_NAME}/1.0.Resources/resource1.dat",
+                ],
+                expected_absent_after=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio/song.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video/movie.mp4",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config/app.json",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash/old.txt",
+                ],
+                required_removed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash",
+                ],
+                forbidden_removed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/keep.txt",
+                    f"{FIXTURE_ROOT_NAME}/Wallpapers/wallpaper1.jpg",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0019",
+                description="Issue #3655 no trailing slash workaround with cleanup validation",
+                execution_mode="cleanup_regression",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"!/{FIXTURE_ROOT_NAME}/Documents/Notes/.trash",
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Video",
+                    f"/{FIXTURE_ROOT_NAME}/Projects",
+                    f"/{FIXTURE_ROOT_NAME}/Documents/.Libraries",
+                    f"/{FIXTURE_ROOT_NAME}/Documents/.Templates",
+                    f"/{FIXTURE_ROOT_NAME}/Documents/Notes",
+                    f"/{FIXTURE_ROOT_NAME}/Wallpapers",
+                    f"/{FIXTURE_ROOT_NAME}/0.1.Backups",
+                    f"/{FIXTURE_ROOT_NAME}/1.0.Resources",
+                ],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Projects",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Libraries",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Templates",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes",
+                    f"{FIXTURE_ROOT_NAME}/Wallpapers",
+                    f"{FIXTURE_ROOT_NAME}/0.1.Backups",
+                    f"{FIXTURE_ROOT_NAME}/1.0.Resources",
+                ],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Libraries/library-index.txt",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Templates/base-template.dotx",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/keep.txt",
+                    f"{FIXTURE_ROOT_NAME}/Wallpapers/wallpaper1.jpg",
+                    f"{FIXTURE_ROOT_NAME}/0.1.Backups/archive1.bin",
+                    f"{FIXTURE_ROOT_NAME}/1.0.Resources/resource1.dat",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                phase1_config_overrides=[
+                    'download_only = "false"',
+                    'cleanup_local_files = "false"',
+                ],
+                phase2_config_overrides=[
+                    'download_only = "true"',
+                    'cleanup_local_files = "true"',
+                ],
+                expected_present_after=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Libraries/library-index.txt",
+                    f"{FIXTURE_ROOT_NAME}/Documents/.Templates/base-template.dotx",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/keep.txt",
+                    f"{FIXTURE_ROOT_NAME}/Wallpapers/wallpaper1.jpg",
+                    f"{FIXTURE_ROOT_NAME}/0.1.Backups/archive1.bin",
+                    f"{FIXTURE_ROOT_NAME}/1.0.Resources/resource1.dat",
+                ],
+                expected_absent_after=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio/song.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video/movie.mp4",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config/app.json",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash/old.txt",
+                ],
+                required_removed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.trash",
+                ],
+                forbidden_removed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/keep.txt",
+                    f"{FIXTURE_ROOT_NAME}/Wallpapers/wallpaper1.jpg",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0020",
+                description="Focused trailing slash Projects regression for sibling path survival",
+                execution_mode="cleanup_regression",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Audio/",
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Video/",
+                    f"/{FIXTURE_ROOT_NAME}/Projects/",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Projects"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                phase1_config_overrides=[
+                    'download_only = "false"',
+                    'cleanup_local_files = "false"',
+                ],
+                phase2_config_overrides=[
+                    'download_only = "true"',
+                    'cleanup_local_files = "true"',
+                ],
+                expected_present_after=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                ],
+                expected_absent_after=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                required_removed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                forbidden_removed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0021",
+                description="Focused no trailing slash Projects regression for sibling path survival",
+                execution_mode="cleanup_regression",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Video",
+                    f"/{FIXTURE_ROOT_NAME}/Projects",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Projects"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                phase1_config_overrides=[
+                    'download_only = "false"',
+                    'cleanup_local_files = "false"',
+                ],
+                phase2_config_overrides=[
+                    'download_only = "true"',
+                    'cleanup_local_files = "true"',
+                ],
+                expected_present_after=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                ],
+                expected_absent_after=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                required_removed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                forbidden_removed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0022",
+                description="root file exact include only",
+                sync_list=[f"{FIXTURE_ROOT_NAME}/README.txt"],
+                allowed_exact=[f"{FIXTURE_ROOT_NAME}/README.txt"],
+                required_processed=[f"{FIXTURE_ROOT_NAME}/README.txt"],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                    f"{FIXTURE_ROOT_NAME}/Documents",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0023",
+                description="sync_root_files true retains logical root files alongside included Projects subtree",
+                execution_mode="cleanup_regression",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Video",
+                    f"/{FIXTURE_ROOT_NAME}/Projects",
+                ],
+                allowed_exact=[
+                    f"{FIXTURE_ROOT_NAME}/README.txt",
+                    f"{FIXTURE_ROOT_NAME}/loose.bin",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Projects"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/README.txt",
+                    f"{FIXTURE_ROOT_NAME}/loose.bin",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                ],
+                phase1_config_overrides=[
+                    'download_only = "false"',
+                    'cleanup_local_files = "false"',
+                    'sync_root_files = "true"',
+                ],
+                phase2_config_overrides=[
+                    'download_only = "true"',
+                    'cleanup_local_files = "false"',
+                    'sync_root_files = "true"',
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0024",
+                description="cleanup regression with sync_root_files true prunes non-included sibling files and excluded Projects subtrees",
+                execution_mode="cleanup_regression",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Video",
+                    f"/{FIXTURE_ROOT_NAME}/Projects",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Projects"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/README.txt",
+                    f"{FIXTURE_ROOT_NAME}/loose.bin",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                phase1_config_overrides=[
+                    'download_only = "false"',
+                    'cleanup_local_files = "false"',
+                    'sync_root_files = "true"',
+                ],
+                phase2_config_overrides=[
+                    'download_only = "true"',
+                    'cleanup_local_files = "true"',
+                    'sync_root_files = "true"',
+                ],
+                expected_present_after=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                ],
+                expected_absent_after=[
+                    f"{FIXTURE_ROOT_NAME}/README.txt",
+                    f"{FIXTURE_ROOT_NAME}/loose.bin",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                required_removed=[
+                    f"{FIXTURE_ROOT_NAME}/README.txt",
+                    f"{FIXTURE_ROOT_NAME}/loose.bin",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+                forbidden_removed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0025",
+                description="prefix collision safety for Projects Code versus similarly named siblings",
+                sync_list=[f"/{FIXTURE_ROOT_NAME}/Projects/Code"],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Projects/Code"],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code-Archive",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Codecs",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Coder",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0026",
+                description="mixed rooted subtree include plus exact root file include",
+                sync_list=[
+                    f"/{FIXTURE_ROOT_NAME}/Projects",
+                    f"{FIXTURE_ROOT_NAME}/README.txt",
+                ],
+                allowed_exact=[f"{FIXTURE_ROOT_NAME}/README.txt"],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Projects"],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/README.txt",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Backup",
+                    f"{FIXTURE_ROOT_NAME}/Documents",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0027",
+                description="wildcard directory include across similarly named Project Code folders",
+                sync_list=[f"/{FIXTURE_ROOT_NAME}/Projects/Code*"],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code-Archive",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Codecs",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Coder",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports/file.wav",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code-Archive/archive.txt",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Codecs/readme.txt",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Coder/profile.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Video",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0028",
+                description="globbing directory include for src directories across nested project depths",
+                sync_list=[f"/{FIXTURE_ROOT_NAME}/Programming/Projects/**/src/"],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/src",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src/main.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/src/app.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src/index.ts",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/src/app.ts",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/src/main.py",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src/Main.java",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/src/index.js",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/src/page.tsx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/src/App.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/src/readme.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/.venv",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0029",
+                description="wildcard directory include with deeper wildcard exclusion",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Projects/Code*/JOBXYZ/Exports/*",
+                    f"/{FIXTURE_ROOT_NAME}/Projects/Code*",
+                ],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code-Archive",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Codecs",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Coder",
+                ],
+                forbidden_prefixes=[f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports"],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Source/main.txt",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code-Archive/archive.txt",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Codecs/readme.txt",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Coder/profile.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Projects/Code/JOBXYZ/Exports",
+                    f"{FIXTURE_ROOT_NAME}/Projects/Audio",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0030",
+                description="globbing directory include with recursive globbing exclusion",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/**/build/*",
+                    f"/{FIXTURE_ROOT_NAME}/Programming/Projects/**/src/",
+                ],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Python/Tool1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Node/App1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Next/App1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Idea/App1/src",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Misc/App1/src",
+                ],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site2/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src/main.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/src/index.ts",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/src/Main.java",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Web/Site1/build",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Java/Project1/build",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0031",
+                description="normal directory include with deeper wildcard exclusion must not exclude ancestor",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Documents/Notes/.config/*",
+                    f"/{FIXTURE_ROOT_NAME}/Documents/Notes/",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Documents/Notes"],
+                forbidden_prefixes=[f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config"],
+                required_processed=[f"{FIXTURE_ROOT_NAME}/Documents/Notes/keep.txt"],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Documents/Notes/.config",
+                    f"{FIXTURE_ROOT_NAME}/Documents/latest_report.docx",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0032",
+                description="normal directory include with deeper globbing exclusion must not exclude ancestor",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/Programming/Projects/**/.cxx/*",
+                    f"/{FIXTURE_ROOT_NAME}/Programming/Projects/Android/",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/.cxx",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/src/main.kt",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/src/app.kt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App1/.cxx",
+                    f"{FIXTURE_ROOT_NAME}/Programming/Projects/Android/App2/.cxx",
+                ],
+            ),
+
+            SyncListScenario(
+                scenario_id="SL-0033",
+                description="generic wildcard include with per-matched-container child exclusion",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/*",
+                    f"/{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_*/",
+                ],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET",
+                ],
+                allowed_exact=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15",
+                ],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file00.txt",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file01.txt",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET/file00.txt",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET/file02.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file00.txt",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Trees",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0034",
+                description="generic globbing include traverses multiple seeded trees without premature pruning",
+                sync_list=[f"/{FIXTURE_ROOT_NAME}/RuleLab/Trees/**/tree.txt"],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/RuleLab/Trees"],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeA/A/B/C/tree.txt",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Trees/TreeB/A/B/C/tree.txt",
+                ],
+                required_skipped=[f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard"],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0035",
+                description="generic exact file include with sibling wildcard exclusion",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/image*",
+                    f"/{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/data.txt",
+                ],
+                allowed_exact=[f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/data.txt"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/image0.png",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/image1.png",
+                ],
+                required_processed=[f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/data.txt"],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/image0.png",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0036",
+                description="generic path with spaces using wildcard and globbing include",
+                sync_list=[f"/{FIXTURE_ROOT_NAME}/RuleLab/With Spaces/Family pictures/* pictures/**"],
+                allowed_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/With Spaces/Family pictures/Annas pictures",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/With Spaces/Family pictures/Bens pictures",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/With Spaces/Family pictures/Annas pictures/image0.png",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/With Spaces/Family pictures/Bens pictures/image0.png",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0037",
+                description="generic cleanup_local_files with included root and excluded child subtree",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/temp/*",
+                    f"/{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE"],
+                forbidden_prefixes=[f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/temp"],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/data.txt",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/temp",
+                ],
+                execution_mode="cleanup_regression",
+                phase1_config_overrides=[
+                    'download_only = "false"',
+                    'cleanup_local_files = "false"',
+                ],
+                phase2_config_overrides=[
+                    'download_only = "true"',
+                    'cleanup_local_files = "true"',
+                ],
+                expected_present_after=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/data.txt",
+                ],
+                expected_absent_after=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/temp/transient.tmp",
+                ],
+                required_removed=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/temp/transient.tmp",
+                ],
+                forbidden_removed=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/data.txt",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0038",
+                description="generic cleanup_local_files with wildcard include and excluded sibling container children",
+                sync_list=[
+                    f"!/{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/*",
+                    f"/{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_*/",
+                ],
+                allowed_prefixes=[f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET"],
+                allowed_exact=[f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15"],
+                forbidden_prefixes=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file00.txt",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file01.txt",
+                ],
+                required_processed=[f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET/file00.txt"],
+                required_skipped=[f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file00.txt"],
+                execution_mode="cleanup_regression",
+                phase1_config_overrides=[
+                    'download_only = "false"',
+                    'cleanup_local_files = "false"',
+                ],
+                phase2_config_overrides=[
+                    'download_only = "true"',
+                    'cleanup_local_files = "true"',
+                ],
+                expected_present_after=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET/file00.txt",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET/file02.txt",
+                ],
+                expected_absent_after=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file00.txt",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file01.txt",
+                ],
+                required_removed=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET_15/file00.txt",
+                ],
+                forbidden_removed=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard/WIDE_SET/file00.txt",
+                ],
+            ),
+            SyncListScenario(
+                scenario_id="SL-0039",
+                description="generic sync_root_files override retains logical root files without entering unrelated fixture subtrees",
+                sync_list=[f"/{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/data.txt"],
+                allowed_exact=[
+                    f"{FIXTURE_ROOT_NAME}/README.txt",
+                    f"{FIXTURE_ROOT_NAME}/loose.bin",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/zz_e2e_zz_e2e_sync_list_rulelab.bin",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/zz_e2e_zz_e2e_sync_list_rulelab_filespecific.dat",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/zz_e2e_zz_e2e_sync_list_rulelab_filespecific_core.cache",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/data.txt",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/image0.png",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/image1.png",
+                ],
+                required_processed=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/files/data.txt",
+                    f"{FIXTURE_ROOT_NAME}/README.txt",
+                    f"{FIXTURE_ROOT_NAME}/loose.bin",
+                ],
+                required_skipped=[
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/FileSpecific/CORE/temp",
+                    f"{FIXTURE_ROOT_NAME}/RuleLab/Wildcard",
+                ],
+                phase2_config_overrides=['sync_root_files = "true"'],
+            ),
+        ]
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0003_dry_run_validation.py b/ci/e2e/testcases/tc0003_dry_run_validation.py
new file mode 100644
index 000000000..7c4c91453
--- /dev/null
+++ b/ci/e2e/testcases/tc0003_dry_run_validation.py
@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0003DryRunValidation(E2ETestCase):
+    case_id = "0003"
+    name = "dry-run validation"
+    description = "Validate that --dry-run performs no changes locally or remotely"
+
+    def _root_name(self, context: E2EContext) -> str:
+        return f"ZZ_E2E_TC0003_{context.run_id}_{os.getpid()}"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0003 config\nbypass_data_preservation = \"true\"\n")
+
+    def _bootstrap_confdir(self, context: E2EContext, confdir: Path) -> Path:
+        copied_refresh_token = context.bootstrap_config_dir(confdir)
+        self._write_config(confdir / "config")
+        return copied_refresh_token
+
+    def _create_local_fixture(self, sync_root: Path, root_name: str) -> None:
+        reset_directory(sync_root)
+        write_text_file(sync_root / root_name / "Upload" / "file1.txt", "tc0003 file1\n")
+        write_text_file(sync_root / root_name / "Upload" / "file2.bin", "tc0003 file2\n")
+        write_text_file(sync_root / root_name / "Notes" / "draft.md", "# tc0003\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0003",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        seed_confdir = case_work_dir / "conf-seed"
+        verify_root = case_work_dir / "verifyroot"
+        verify_confdir = case_work_dir / "conf-verify"
+        root_name = self._root_name(context)
+        self._create_local_fixture(sync_root, root_name)
+        copied_refresh_token = self._bootstrap_confdir(context, seed_confdir)
+        self._bootstrap_confdir(context, verify_confdir)
+
+        before_manifest = build_manifest(sync_root)
+        before_manifest_file = state_dir / "before_manifest.txt"
+        after_manifest_file = state_dir / "after_manifest.txt"
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+        stdout_file = case_log_dir / "seed_stdout.log"
+        stderr_file = case_log_dir / "seed_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        write_manifest(before_manifest_file, before_manifest)
+
+        command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--dry-run",
+            "--resync",
+            "--resync-auth",
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(seed_confdir),
+        ]
+        context.log(f"Executing Test Case {self.case_id}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+
+        after_manifest = build_manifest(sync_root)
+        write_manifest(after_manifest_file, after_manifest)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(verify_confdir),
+        ]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+
+        metadata_lines = [
+            f"case_id={self.case_id}",
+            f"name={self.name}",
+            f"root_name={root_name}",
+            f"copied_refresh_token={copied_refresh_token}",
+            f"command={command_to_string(command)}",
+            f"returncode={result.returncode}",
+            f"verify_command={command_to_string(verify_command)}",
+            f"verify_returncode={verify_result.returncode}",
+        ]
+        write_text_file(metadata_file, "\n".join(metadata_lines) + "\n")
+
+        artifacts = [
+            str(stdout_file),
+            str(stderr_file),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(before_manifest_file),
+            str(after_manifest_file),
+            str(remote_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "command": command,
+            "returncode": result.returncode,
+            "verify_command": verify_command,
+            "verify_returncode": verify_result.returncode,
+            "root_name": root_name,
+        }
+
+        if result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote seed failed with status {result.returncode}", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if before_manifest != after_manifest:
+            return self.fail_result(self.case_id, self.name, "Local filesystem changed during --dry-run", artifacts, details)
+        if any(entry == root_name or entry.startswith(root_name + "/") for entry in remote_manifest):
+            return self.fail_result(self.case_id, self.name, f"Dry-run unexpectedly synchronised remote content: {root_name}", artifacts, details)
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0004_single_directory_sync.py b/ci/e2e/testcases/tc0004_single_directory_sync.py
new file mode 100644
index 000000000..ed77beb22
--- /dev/null
+++ b/ci/e2e/testcases/tc0004_single_directory_sync.py
@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0004SingleDirectorySync(E2ETestCase):
+    case_id = "0004"
+    name = "single-directory synchronisation"
+    description = "Validate that only the nominated subtree is synchronised"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0004 config\nbypass_data_preservation = \"true\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0004",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        confdir = case_work_dir / "conf-main"
+        verify_root = case_work_dir / "verifyroot"
+        verify_confdir = case_work_dir / "conf-verify"
+
+        target_dir = f"ZZ_E2E_TC0004_TARGET_{context.run_id}_{os.getpid()}"
+        other_dir = f"ZZ_E2E_TC0004_OTHER_{context.run_id}_{os.getpid()}"
+
+        write_text_file(sync_root / target_dir / "keep.txt", "target\n")
+        write_text_file(sync_root / target_dir / "nested" / "inside.md", "nested\n")
+        write_text_file(sync_root / other_dir / "skip.txt", "other\n")
+
+        context.bootstrap_config_dir(confdir)
+        self._write_config(confdir / "config")
+        context.bootstrap_config_dir(verify_confdir)
+        self._write_config(verify_confdir / "config")
+
+        stdout_file = case_log_dir / "single_directory_stdout.log"
+        stderr_file = case_log_dir / "single_directory_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        local_manifest_file = state_dir / "local_after_manifest.txt"
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        metadata_file = state_dir / "single_directory_metadata.txt"
+
+        command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            target_dir,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(confdir),
+        ]
+        context.log(f"Executing Test Case {self.case_id}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+        write_manifest(local_manifest_file, build_manifest(sync_root))
+
+        verify_command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(verify_confdir),
+        ]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+
+        metadata = [
+            f"case_id={self.case_id}",
+            f"target_dir={target_dir}",
+            f"other_dir={other_dir}",
+            f"command={command_to_string(command)}",
+            f"returncode={result.returncode}",
+            f"verify_command={command_to_string(verify_command)}",
+            f"verify_returncode={verify_result.returncode}",
+        ]
+        write_text_file(metadata_file, "\n".join(metadata) + "\n")
+
+        artifacts = [
+            str(stdout_file),
+            str(stderr_file),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(local_manifest_file),
+            str(remote_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "command": command,
+            "returncode": result.returncode,
+            "verify_returncode": verify_result.returncode,
+            "target_dir": target_dir,
+            "other_dir": other_dir,
+        }
+
+        if result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"--single-directory sync failed with status {result.returncode}", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if not any(e == target_dir or e.startswith(target_dir + "/") for e in remote_manifest):
+            return self.fail_result(self.case_id, self.name, f"Target directory was not synchronised: {target_dir}", artifacts, details)
+        if any(e == other_dir or e.startswith(other_dir + "/") for e in remote_manifest):
+            return self.fail_result(self.case_id, self.name, f"Non-target directory was unexpectedly synchronised: {other_dir}", artifacts, details)
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0005_force_sync_override.py b/ci/e2e/testcases/tc0005_force_sync_override.py
new file mode 100644
index 000000000..55768d058
--- /dev/null
+++ b/ci/e2e/testcases/tc0005_force_sync_override.py
@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0005ForceSyncOverride(E2ETestCase):
+    case_id = "0005"
+    name = "force-sync override"
+    description = "Validate that --force-sync overrides skip_dir for blocked single-directory sync"
+
+    def _write_config(self, config_path: Path, blocked_dir: str) -> None:
+        write_onedrive_config(config_path, f"# tc0005 config\nbypass_data_preservation = \"true\"\nskip_dir = \"{blocked_dir}\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0005",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        confdir = case_work_dir / "conf-seed"
+        verify_root = case_work_dir / "verifyroot"
+        verify_confdir = case_work_dir / "conf-verify"
+
+        blocked_dir = f"ZZ_E2E_TC0005_BLOCKED_{context.run_id}_{os.getpid()}"
+        write_text_file(sync_root / blocked_dir / "allowed_via_force.txt", "force\n")
+
+        context.bootstrap_config_dir(confdir)
+        self._write_config(confdir / "config", blocked_dir)
+        context.bootstrap_config_dir(verify_confdir)
+        write_onedrive_config(verify_confdir / "config", "# tc0005 verify\nbypass_data_preservation = \"true\"\n")
+
+        stdout_file = case_log_dir / "seed_stdout.log"
+        stderr_file = case_log_dir / "seed_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        metadata_file = state_dir / "seed_metadata.txt"
+
+        command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            blocked_dir,
+            "--force-sync",
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(confdir),
+        ]
+        result = run_command(command, cwd=context.repo_root, input_text="Y\n")
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(verify_confdir),
+        ]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+
+        write_text_file(metadata_file, "\n".join([
+            f"blocked_dir={blocked_dir}",
+            f"command={command_to_string(command)}",
+            f"returncode={result.returncode}",
+            f"verify_returncode={verify_result.returncode}",
+        ]) + "\n")
+
+        artifacts = [str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(remote_manifest_file), str(metadata_file)]
+        details = {"command": command, "returncode": result.returncode, "verify_returncode": verify_result.returncode, "blocked_dir": blocked_dir}
+
+        if result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Blocked single-directory sync with --force-sync failed with status {result.returncode}", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if f"{blocked_dir}/allowed_via_force.txt" not in remote_manifest:
+            return self.fail_result(self.case_id, self.name, f"--force-sync did not synchronise blocked path: {blocked_dir}/allowed_via_force.txt", artifacts, details)
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0006_download_only.py b/ci/e2e/testcases/tc0006_download_only.py
new file mode 100644
index 000000000..14b51c864
--- /dev/null
+++ b/ci/e2e/testcases/tc0006_download_only.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0006DownloadOnly(E2ETestCase):
+    case_id = "0006"
+    name = "download-only behaviour"
+    description = "Validate that download-only populates local content from remote data"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0006 config\nbypass_data_preservation = \"true\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0006",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir; case_log_dir = layout.log_dir; state_dir = layout.state_dir
+        seed_root = case_work_dir / "seedroot"; seed_conf = case_work_dir / "conf-seed"; download_root = case_work_dir / "downloadroot"; download_conf = case_work_dir / "conf-download"; root_name = f"ZZ_E2E_TC0006_{context.run_id}_{os.getpid()}"
+        write_text_file(seed_root / root_name / "remote.txt", "remote\n"); write_text_file(seed_root / root_name / "subdir" / "nested.txt", "nested\n")
+        context.bootstrap_config_dir(seed_conf); self._write_config(seed_conf / "config")
+        context.bootstrap_config_dir(download_conf); self._write_config(download_conf / "config")
+        seed_stdout = case_log_dir / "seed_stdout.log"; seed_stderr = case_log_dir / "seed_stderr.log"; dl_stdout = case_log_dir / "download_stdout.log"; dl_stderr = case_log_dir / "download_stderr.log"; local_manifest_file = state_dir / "download_manifest.txt"; metadata_file = state_dir / "seed_metadata.txt"
+        seed_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--resync", "--resync-auth", "--syncdir", str(seed_root), "--confdir", str(seed_conf)]
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout); write_text_file(seed_stderr, seed_result.stderr)
+        download_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(download_root), "--confdir", str(download_conf)]
+        download_result = run_command(download_command, cwd=context.repo_root)
+        write_text_file(dl_stdout, download_result.stdout); write_text_file(dl_stderr, download_result.stderr); local_manifest = build_manifest(download_root); write_manifest(local_manifest_file, local_manifest)
+        write_text_file(metadata_file, "\n".join([f"root_name={root_name}", f"seed_command={command_to_string(seed_command)}", f"seed_returncode={seed_result.returncode}", f"download_command={command_to_string(download_command)}", f"download_returncode={download_result.returncode}"]) + "\n")
+        artifacts = [str(seed_stdout), str(seed_stderr), str(dl_stdout), str(dl_stderr), str(local_manifest_file), str(metadata_file)]
+        details = {"seed_returncode": seed_result.returncode, "download_returncode": download_result.returncode, "root_name": root_name}
+        if seed_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote seed failed with status {seed_result.returncode}", artifacts, details)
+        if download_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"--download-only failed with status {download_result.returncode}", artifacts, details)
+        wanted = [root_name, f"{root_name}/remote.txt", f"{root_name}/subdir", f"{root_name}/subdir/nested.txt"]
+        missing = [w for w in wanted if w not in local_manifest]
+        if missing: return self.fail_result(self.case_id, self.name, "Downloaded manifest missing expected content: " + ", ".join(missing), artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0007_download_only_cleanup_local_files.py b/ci/e2e/testcases/tc0007_download_only_cleanup_local_files.py
new file mode 100644
index 000000000..10d593de3
--- /dev/null
+++ b/ci/e2e/testcases/tc0007_download_only_cleanup_local_files.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0007DownloadOnlyCleanupLocalFiles(E2ETestCase):
+    case_id = "0007"
+    name = "download-only cleanup-local-files"
+    description = "Validate that cleanup_local_files removes stale local content in download-only mode"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0007 config\nbypass_data_preservation = \"true\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0007",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir; case_log_dir = layout.log_dir; state_dir = layout.state_dir
+        sync_root = case_work_dir / "syncroot"; seed_conf = case_work_dir / "conf-seed"; cleanup_conf = case_work_dir / "conf-cleanup"; root_name = f"ZZ_E2E_TC0007_{context.run_id}_{os.getpid()}"
+        write_text_file(sync_root / root_name / "keep.txt", "keep\n")
+        context.bootstrap_config_dir(seed_conf); self._write_config(seed_conf / "config")
+        context.bootstrap_config_dir(cleanup_conf); self._write_config(cleanup_conf / "config")
+        seed_stdout = case_log_dir / "seed_stdout.log"; seed_stderr = case_log_dir / "seed_stderr.log"; cleanup_stdout = case_log_dir / "cleanup_stdout.log"; cleanup_stderr = case_log_dir / "cleanup_stderr.log"; post_manifest_file = state_dir / "post_cleanup_manifest.txt"; metadata_file = state_dir / "seed_metadata.txt"
+        seed_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(seed_conf)]
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout); write_text_file(seed_stderr, seed_result.stderr)
+        stale = sync_root / root_name / "stale-local.txt"; write_text_file(stale, "stale\n")
+        cleanup_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--cleanup-local-files", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(cleanup_conf)]
+        cleanup_result = run_command(cleanup_command, cwd=context.repo_root)
+        write_text_file(cleanup_stdout, cleanup_result.stdout); write_text_file(cleanup_stderr, cleanup_result.stderr); post_manifest = build_manifest(sync_root); write_manifest(post_manifest_file, post_manifest)
+        write_text_file(metadata_file, "\n".join([f"root_name={root_name}", f"seed_returncode={seed_result.returncode}", f"cleanup_returncode={cleanup_result.returncode}"]) + "\n")
+        artifacts = [str(seed_stdout), str(seed_stderr), str(cleanup_stdout), str(cleanup_stderr), str(post_manifest_file), str(metadata_file)]
+        details = {"seed_returncode": seed_result.returncode, "cleanup_returncode": cleanup_result.returncode, "root_name": root_name}
+        if seed_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote seed failed with status {seed_result.returncode}", artifacts, details)
+        if cleanup_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"cleanup_local_files processing failed with status {cleanup_result.returncode}", artifacts, details)
+        if stale.exists() or f"{root_name}/stale-local.txt" in post_manifest: return self.fail_result(self.case_id, self.name, "Stale local file still exists after cleanup_local_files processing", artifacts, details)
+        if f"{root_name}/keep.txt" not in post_manifest: return self.fail_result(self.case_id, self.name, "Expected remote-backed file missing after cleanup_local_files processing", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0008_upload_only.py b/ci/e2e/testcases/tc0008_upload_only.py
new file mode 100644
index 000000000..3b399bf1f
--- /dev/null
+++ b/ci/e2e/testcases/tc0008_upload_only.py
@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0008UploadOnly(E2ETestCase):
+    case_id = "0008"
+    name = "upload-only behaviour"
+    description = "Validate that upload-only pushes local content remotely"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0008 config\nbypass_data_preservation = \"true\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0008",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir; case_log_dir = layout.log_dir; state_dir = layout.state_dir
+        upload_root = case_work_dir / "uploadroot"; upload_conf = case_work_dir / "conf-upload"; verify_root = case_work_dir / "verifyroot"; verify_conf = case_work_dir / "conf-verify"; root_name = f"ZZ_E2E_TC0008_{context.run_id}_{os.getpid()}"
+        write_text_file(upload_root / root_name / "upload.txt", "upload only\n")
+        context.bootstrap_config_dir(upload_conf); self._write_config(upload_conf / "config")
+        context.bootstrap_config_dir(verify_conf); self._write_config(verify_conf / "config")
+        stdout_file = case_log_dir / "upload_only_stdout.log"; stderr_file = case_log_dir / "upload_only_stderr.log"; verify_stdout = case_log_dir / "verify_stdout.log"; verify_stderr = case_log_dir / "verify_stderr.log"; remote_manifest_file = state_dir / "remote_verify_manifest.txt"; metadata_file = state_dir / "upload_metadata.txt"
+        command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--upload-only", "--resync", "--resync-auth", "--syncdir", str(upload_root), "--confdir", str(upload_conf)]
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout); write_text_file(stderr_file, result.stderr)
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(verify_root), "--confdir", str(verify_conf)]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout); write_text_file(verify_stderr, verify_result.stderr); remote_manifest = build_manifest(verify_root); write_manifest(remote_manifest_file, remote_manifest)
+        write_text_file(metadata_file, "\n".join([f"root_name={root_name}", f"returncode={result.returncode}", f"verify_returncode={verify_result.returncode}"]) + "\n")
+        artifacts = [str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(remote_manifest_file), str(metadata_file)]
+        details = {"returncode": result.returncode, "verify_returncode": verify_result.returncode, "root_name": root_name}
+        if result.returncode != 0: return self.fail_result(self.case_id, self.name, f"--upload-only failed with status {result.returncode}", artifacts, details)
+        if verify_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if f"{root_name}/upload.txt" not in remote_manifest: return self.fail_result(self.case_id, self.name, f"Upload-only did not synchronise expected remote file: {root_name}/upload.txt", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0009_upload_only_no_remote_delete.py b/ci/e2e/testcases/tc0009_upload_only_no_remote_delete.py
new file mode 100644
index 000000000..8d449ef31
--- /dev/null
+++ b/ci/e2e/testcases/tc0009_upload_only_no_remote_delete.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0009UploadOnlyNoRemoteDelete(E2ETestCase):
+    case_id = "0009"
+    name = "upload-only no-remote-delete"
+    description = "Validate that no_remote_delete preserves remote content in upload-only mode"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0009 config\nbypass_data_preservation = \"true\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0009",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir; case_log_dir = layout.log_dir; state_dir = layout.state_dir
+        sync_root = case_work_dir / "syncroot"; seed_conf = case_work_dir / "conf-seed"; upload_conf = case_work_dir / "conf-upload"; verify_root = case_work_dir / "verifyroot"; verify_conf = case_work_dir / "conf-verify"; root_name = f"ZZ_E2E_TC0009_{context.run_id}_{os.getpid()}"
+        keep_file = sync_root / root_name / "keep.txt"; write_text_file(keep_file, "keep remote\n")
+        context.bootstrap_config_dir(seed_conf); self._write_config(seed_conf / "config")
+        context.bootstrap_config_dir(upload_conf); self._write_config(upload_conf / "config")
+        context.bootstrap_config_dir(verify_conf); self._write_config(verify_conf / "config")
+        seed_stdout = case_log_dir / "seed_stdout.log"; seed_stderr = case_log_dir / "seed_stderr.log"; upload_stdout = case_log_dir / "upload_only_stdout.log"; upload_stderr = case_log_dir / "upload_only_stderr.log"; verify_stdout = case_log_dir / "verify_stdout.log"; verify_stderr = case_log_dir / "verify_stderr.log"; remote_manifest_file = state_dir / "remote_verify_manifest.txt"; metadata_file = state_dir / "seed_metadata.txt"
+        seed_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(seed_conf)]
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout); write_text_file(seed_stderr, seed_result.stderr)
+        if keep_file.exists(): keep_file.unlink()
+        upload_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--upload-only", "--no-remote-delete", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(upload_conf)]
+        upload_result = run_command(upload_command, cwd=context.repo_root)
+        write_text_file(upload_stdout, upload_result.stdout); write_text_file(upload_stderr, upload_result.stderr)
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(verify_root), "--confdir", str(verify_conf)]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout); write_text_file(verify_stderr, verify_result.stderr); remote_manifest = build_manifest(verify_root); write_manifest(remote_manifest_file, remote_manifest)
+        write_text_file(metadata_file, "\n".join([f"root_name={root_name}", f"seed_returncode={seed_result.returncode}", f"upload_returncode={upload_result.returncode}", f"verify_returncode={verify_result.returncode}"]) + "\n")
+        artifacts = [str(seed_stdout), str(seed_stderr), str(upload_stdout), str(upload_stderr), str(verify_stdout), str(verify_stderr), str(remote_manifest_file), str(metadata_file)]
+        details = {"seed_returncode": seed_result.returncode, "upload_returncode": upload_result.returncode, "verify_returncode": verify_result.returncode, "root_name": root_name}
+        if seed_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote seed failed with status {seed_result.returncode}", artifacts, details)
+        if upload_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"--upload-only --no-remote-delete failed with status {upload_result.returncode}", artifacts, details)
+        if verify_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if f"{root_name}/keep.txt" not in remote_manifest: return self.fail_result(self.case_id, self.name, f"Remote file was unexpectedly deleted despite --no-remote-delete: {root_name}/keep.txt", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0010_upload_only_remove_source_files.py b/ci/e2e/testcases/tc0010_upload_only_remove_source_files.py
new file mode 100644
index 000000000..525165aea
--- /dev/null
+++ b/ci/e2e/testcases/tc0010_upload_only_remove_source_files.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0010UploadOnlyRemoveSourceFiles(E2ETestCase):
+    case_id = "0010"
+    name = "upload-only remove-source-files"
+    description = "Validate that remove_source_files removes local files after upload-only succeeds"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0010 config\nbypass_data_preservation = \"true\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0010",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir; case_log_dir = layout.log_dir; state_dir = layout.state_dir
+        sync_root = case_work_dir / "syncroot"; upload_conf = case_work_dir / "conf-upload"; verify_root = case_work_dir / "verifyroot"; verify_conf = case_work_dir / "conf-verify"; root_name = f"ZZ_E2E_TC0010_{context.run_id}_{os.getpid()}"
+        source_file = sync_root / root_name / "source.txt"; write_text_file(source_file, "remove after upload\n")
+        context.bootstrap_config_dir(upload_conf); self._write_config(upload_conf / "config")
+        context.bootstrap_config_dir(verify_conf); self._write_config(verify_conf / "config")
+        stdout_file = case_log_dir / "upload_only_remove_source_stdout.log"; stderr_file = case_log_dir / "upload_only_remove_source_stderr.log"; verify_stdout = case_log_dir / "verify_stdout.log"; verify_stderr = case_log_dir / "verify_stderr.log"; post_manifest_file = state_dir / "post_upload_manifest.txt"; remote_manifest_file = state_dir / "remote_verify_manifest.txt"; metadata_file = state_dir / "upload_metadata.txt"
+        command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--upload-only", "--remove-source-files", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(upload_conf)]
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout); write_text_file(stderr_file, result.stderr); post_manifest = build_manifest(sync_root); write_manifest(post_manifest_file, post_manifest)
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(verify_root), "--confdir", str(verify_conf)]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout); write_text_file(verify_stderr, verify_result.stderr); remote_manifest = build_manifest(verify_root); write_manifest(remote_manifest_file, remote_manifest)
+        write_text_file(metadata_file, "\n".join([f"root_name={root_name}", f"returncode={result.returncode}", f"verify_returncode={verify_result.returncode}"]) + "\n")
+        artifacts = [str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(post_manifest_file), str(remote_manifest_file), str(metadata_file)]
+        details = {"returncode": result.returncode, "verify_returncode": verify_result.returncode, "root_name": root_name}
+        if result.returncode != 0: return self.fail_result(self.case_id, self.name, f"--upload-only with remove_source_files failed with status {result.returncode}", artifacts, details)
+        if verify_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if source_file.exists() or f"{root_name}/source.txt" in post_manifest: return self.fail_result(self.case_id, self.name, "Local source file still exists after remove_source_files processing", artifacts, details)
+        if f"{root_name}/source.txt" not in remote_manifest: return self.fail_result(self.case_id, self.name, f"Remote file missing after upload-only remove_source_files: {root_name}/source.txt", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0011_skip_file_validation.py b/ci/e2e/testcases/tc0011_skip_file_validation.py
new file mode 100644
index 000000000..fc4592249
--- /dev/null
+++ b/ci/e2e/testcases/tc0011_skip_file_validation.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0011SkipFileValidation(E2ETestCase):
+    case_id = "0011"
+    name = "skip_file validation"
+    description = "Validate that skip_file patterns prevent matching files from synchronising"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0011 config\nbypass_data_preservation = \"true\"\nskip_file = \"*.tmp|*.swp\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0011",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir; case_log_dir = layout.log_dir; state_dir = layout.state_dir
+        sync_root = case_work_dir / "syncroot"; confdir = case_work_dir / "conf-main"; verify_root = case_work_dir / "verifyroot"; verify_conf = case_work_dir / "conf-verify"; root_name = f"ZZ_E2E_TC0011_{context.run_id}_{os.getpid()}"
+        write_text_file(sync_root / root_name / "keep.txt", "keep\n"); write_text_file(sync_root / root_name / "skip.tmp", "skip\n"); write_text_file(sync_root / root_name / "editor.swp", "swap\n")
+        context.bootstrap_config_dir(confdir); self._write_config(confdir / "config")
+        context.bootstrap_config_dir(verify_conf); write_onedrive_config(verify_conf / "config", "# tc0011 verify\nbypass_data_preservation = \"true\"\n")
+        stdout_file = case_log_dir / "skip_file_stdout.log"; stderr_file = case_log_dir / "skip_file_stderr.log"; verify_stdout = case_log_dir / "verify_stdout.log"; verify_stderr = case_log_dir / "verify_stderr.log"; remote_manifest_file = state_dir / "remote_verify_manifest.txt"; metadata_file = state_dir / "metadata.txt"
+        command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(confdir)]
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout); write_text_file(stderr_file, result.stderr)
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(verify_root), "--confdir", str(verify_conf)]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout); write_text_file(verify_stderr, verify_result.stderr); remote_manifest = build_manifest(verify_root); write_manifest(remote_manifest_file, remote_manifest)
+        write_text_file(metadata_file, f"root_name={root_name}\nreturncode={result.returncode}\nverify_returncode={verify_result.returncode}\n")
+        artifacts = [str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(remote_manifest_file), str(metadata_file)]
+        details = {"returncode": result.returncode, "verify_returncode": verify_result.returncode, "root_name": root_name}
+        if result.returncode != 0: return self.fail_result(self.case_id, self.name, f"skip_file validation failed with status {result.returncode}", artifacts, details)
+        if verify_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if f"{root_name}/keep.txt" not in remote_manifest: return self.fail_result(self.case_id, self.name, f"Expected non-skipped file missing remotely: {root_name}/keep.txt", artifacts, details)
+        for unwanted in [f"{root_name}/skip.tmp", f"{root_name}/editor.swp"]:
+            if unwanted in remote_manifest: return self.fail_result(self.case_id, self.name, f"skip_file pattern failed, file was synchronised: {unwanted}", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0012_skip_dir_validation.py b/ci/e2e/testcases/tc0012_skip_dir_validation.py
new file mode 100644
index 000000000..1e7a6fa32
--- /dev/null
+++ b/ci/e2e/testcases/tc0012_skip_dir_validation.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0012SkipDirValidation(E2ETestCase):
+    case_id = "0012"
+    name = "skip_dir validation"
+    description = "Validate skip_dir loose matching and skip_dir_strict_match behaviour"
+
+    def _write_config(self, config_path: Path, skip_dir_value: str, strict: bool) -> None:
+        lines = ["# tc0012 config", "bypass_data_preservation = \"true\"", f"skip_dir = \"{skip_dir_value}\""]
+        if strict:
+            lines.append("skip_dir_strict_match = \"true\"")
+        write_onedrive_config(config_path, "\n".join(lines) + "\n")
+
+    def _run_loose(self, context: E2EContext, case_log_dir: Path, all_artifacts: list[str], failures: list[str]) -> None:
+        scenario_root = context.work_root / "tc0012" / "loose_match"; scenario_state = context.state_dir / "tc0012" / "loose_match"
+        reset_directory(scenario_root); reset_directory(scenario_state)
+        sync_root = scenario_root / "syncroot"; confdir = scenario_root / "conf-loose"; verify_root = scenario_root / "verifyroot"; verify_conf = scenario_root / "conf-verify-loose"
+        root = f"ZZ_E2E_TC0012_LOOSE_{context.run_id}_{os.getpid()}"
+        write_text_file(sync_root / root / "Cache" / "top.txt", "skip top\n")
+        write_text_file(sync_root / root / "App" / "Cache" / "nested.txt", "skip nested\n")
+        write_text_file(sync_root / root / "Keep" / "ok.txt", "ok\n")
+        context.bootstrap_config_dir(confdir); self._write_config(confdir / "config", "Cache", False)
+        context.bootstrap_config_dir(verify_conf); write_onedrive_config(verify_conf / "config", "# verify\nbypass_data_preservation = \"true\"\n")
+        stdout_file = case_log_dir / "loose_match_stdout.log"; stderr_file = case_log_dir / "loose_match_stderr.log"; verify_stdout = case_log_dir / "loose_match_verify_stdout.log"; verify_stderr = case_log_dir / "loose_match_verify_stderr.log"; manifest_file = scenario_state / "remote_verify_manifest.txt"
+        result = run_command([context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(confdir)], cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout); write_text_file(stderr_file, result.stderr)
+        verify_result = run_command([context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(verify_root), "--confdir", str(verify_conf)], cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout); write_text_file(verify_stderr, verify_result.stderr); manifest = build_manifest(verify_root); write_manifest(manifest_file, manifest)
+        all_artifacts.extend([str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(manifest_file)])
+        if result.returncode != 0: failures.append(f"Loose skip_dir scenario failed with status {result.returncode}"); return
+        if verify_result.returncode != 0: failures.append(f"Loose skip_dir verification failed with status {verify_result.returncode}"); return
+        if f"{root}/Keep/ok.txt" not in manifest: failures.append("Loose skip_dir scenario did not synchronise expected non-skipped content")
+        for unwanted in [f"{root}/Cache/top.txt", f"{root}/App/Cache/nested.txt"]:
+            if unwanted in manifest: failures.append(f"Loose skip_dir scenario unexpectedly synchronised skipped directory content: {unwanted}")
+
+    def _run_strict(self, context: E2EContext, case_log_dir: Path, all_artifacts: list[str], failures: list[str]) -> None:
+        scenario_root = context.work_root / "tc0012" / "strict_match"; scenario_state = context.state_dir / "tc0012" / "strict_match"
+        reset_directory(scenario_root); reset_directory(scenario_state)
+        sync_root = scenario_root / "syncroot"; confdir = scenario_root / "conf-strict"; verify_root = scenario_root / "verifyroot"; verify_conf = scenario_root / "conf-verify-strict"
+        root = f"ZZ_E2E_TC0012_STRICT_{context.run_id}_{os.getpid()}"
+        write_text_file(sync_root / root / "Cache" / "top.txt", "top should remain\n")
+        write_text_file(sync_root / root / "App" / "Cache" / "nested.txt", "nested should skip\n")
+        write_text_file(sync_root / root / "Keep" / "ok.txt", "ok\n")
+        context.bootstrap_config_dir(confdir); self._write_config(confdir / "config", f"{root}/App/Cache", True)
+        context.bootstrap_config_dir(verify_conf); write_onedrive_config(verify_conf / "config", "# verify\nbypass_data_preservation = \"true\"\n")
+        stdout_file = case_log_dir / "strict_match_stdout.log"; stderr_file = case_log_dir / "strict_match_stderr.log"; verify_stdout = case_log_dir / "strict_match_verify_stdout.log"; verify_stderr = case_log_dir / "strict_match_verify_stderr.log"; manifest_file = scenario_state / "remote_verify_manifest.txt"
+        result = run_command([context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(confdir)], cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout); write_text_file(stderr_file, result.stderr)
+        verify_result = run_command([context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(verify_root), "--confdir", str(verify_conf)], cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout); write_text_file(verify_stderr, verify_result.stderr); manifest = build_manifest(verify_root); write_manifest(manifest_file, manifest)
+        all_artifacts.extend([str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(manifest_file)])
+        if result.returncode != 0: failures.append(f"Strict skip_dir scenario failed with status {result.returncode}"); return
+        if verify_result.returncode != 0: failures.append(f"Strict skip_dir verification failed with status {verify_result.returncode}"); return
+        if f"{root}/Keep/ok.txt" not in manifest: failures.append("Strict skip_dir scenario did not synchronise expected non-skipped content")
+        if f"{root}/Cache/top.txt" not in manifest: failures.append("Strict skip_dir scenario incorrectly skipped top-level Cache directory")
+        if f"{root}/App/Cache/nested.txt" in manifest: failures.append("Strict skip_dir scenario unexpectedly synchronised strict-matched directory content")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0012",
+            ensure_refresh_token=True,
+        )
+        case_log_dir = layout.log_dir
+        all_artifacts = []; failures = []
+        self._run_loose(context, case_log_dir, all_artifacts, failures)
+        self._run_strict(context, case_log_dir, all_artifacts, failures)
+        details = {"failures": failures}
+        if failures: return self.fail_result(self.case_id, self.name, "; ".join(failures), all_artifacts, details)
+        return self.pass_result(self.case_id, self.name, all_artifacts, details)
diff --git a/ci/e2e/testcases/tc0013_skip_dotfiles_validation.py b/ci/e2e/testcases/tc0013_skip_dotfiles_validation.py
new file mode 100644
index 000000000..498cbb470
--- /dev/null
+++ b/ci/e2e/testcases/tc0013_skip_dotfiles_validation.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0013SkipDotfilesValidation(E2ETestCase):
+    case_id = "0013"
+    name = "skip_dotfiles validation"
+    description = "Validate that skip_dotfiles prevents dotfiles and dot-directories from synchronising"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0013 config\nbypass_data_preservation = \"true\"\nskip_dotfiles = \"true\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0013",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir; case_log_dir = layout.log_dir; state_dir = layout.state_dir
+        sync_root = case_work_dir / "syncroot"; confdir = case_work_dir / "conf-main"; verify_root = case_work_dir / "verifyroot"; verify_conf = case_work_dir / "conf-verify"; root_name = f"ZZ_E2E_TC0013_{context.run_id}_{os.getpid()}"
+        write_text_file(sync_root / root_name / "visible.txt", "visible\n"); write_text_file(sync_root / root_name / ".hidden.txt", "hidden\n"); write_text_file(sync_root / root_name / ".dotdir" / "inside.txt", "inside\n")
+        context.bootstrap_config_dir(confdir); self._write_config(confdir / "config")
+        context.bootstrap_config_dir(verify_conf); write_onedrive_config(verify_conf / "config", "# verify\nbypass_data_preservation = \"true\"\n")
+        stdout_file = case_log_dir / "skip_dotfiles_stdout.log"; stderr_file = case_log_dir / "skip_dotfiles_stderr.log"; verify_stdout = case_log_dir / "verify_stdout.log"; verify_stderr = case_log_dir / "verify_stderr.log"; remote_manifest_file = state_dir / "remote_verify_manifest.txt"; metadata_file = state_dir / "metadata.txt"
+        command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(confdir)]
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout); write_text_file(stderr_file, result.stderr)
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(verify_root), "--confdir", str(verify_conf)]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout); write_text_file(verify_stderr, verify_result.stderr); remote_manifest = build_manifest(verify_root); write_manifest(remote_manifest_file, remote_manifest)
+        write_text_file(metadata_file, f"root_name={root_name}\nreturncode={result.returncode}\nverify_returncode={verify_result.returncode}\n")
+        artifacts = [str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(remote_manifest_file), str(metadata_file)]
+        details = {"returncode": result.returncode, "verify_returncode": verify_result.returncode, "root_name": root_name}
+        if result.returncode != 0: return self.fail_result(self.case_id, self.name, f"skip_dotfiles validation failed with status {result.returncode}", artifacts, details)
+        if verify_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if f"{root_name}/visible.txt" not in remote_manifest: return self.fail_result(self.case_id, self.name, "Visible file missing after skip_dotfiles processing", artifacts, details)
+        for unwanted in [f"{root_name}/.hidden.txt", f"{root_name}/.dotdir", f"{root_name}/.dotdir/inside.txt"]:
+            if unwanted in remote_manifest: return self.fail_result(self.case_id, self.name, f"Dotfile content was unexpectedly synchronised: {unwanted}", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0014_skip_size_validation.py b/ci/e2e/testcases/tc0014_skip_size_validation.py
new file mode 100644
index 000000000..31d10a237
--- /dev/null
+++ b/ci/e2e/testcases/tc0014_skip_size_validation.py
@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0014SkipSizeValidation(E2ETestCase):
+    case_id = "0014"
+    name = "skip_size validation"
+    description = "Validate that skip_size prevents oversized files from synchronising"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0014 config\nbypass_data_preservation = \"true\"\nenable_logging = \"true\"\nskip_size = \"1\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0014",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir; case_log_dir = layout.log_dir; state_dir = layout.state_dir
+        sync_root = case_work_dir / "syncroot"; confdir = case_work_dir / "conf-main"; verify_root = case_work_dir / "verifyroot"; verify_conf = case_work_dir / "conf-verify"; root_name = f"ZZ_E2E_TC0014_{context.run_id}_{os.getpid()}"; app_log_dir = case_log_dir / "app-logs"
+        write_text_file(sync_root / root_name / "small.bin", "a" * 16384)
+        big_path = sync_root / root_name / "large.bin"; big_path.parent.mkdir(parents=True, exist_ok=True); big_path.write_bytes(b"B" * (2 * 1024 * 1024))
+        context.bootstrap_config_dir(confdir); self._write_config(confdir / "config")
+        write_text_file(confdir / "config", (confdir / "config").read_text(encoding="utf-8") + f'log_dir = "{app_log_dir}"\n')
+        context.bootstrap_config_dir(verify_conf); write_onedrive_config(verify_conf / "config", "# verify\nbypass_data_preservation = \"true\"\n")
+        stdout_file = case_log_dir / "skip_size_stdout.log"; stderr_file = case_log_dir / "skip_size_stderr.log"; verify_stdout = case_log_dir / "verify_stdout.log"; verify_stderr = case_log_dir / "verify_stderr.log"; remote_manifest_file = state_dir / "remote_verify_manifest.txt"; metadata_file = state_dir / "metadata.txt"; config_copy = state_dir / "config_used.txt"; verify_config_copy = state_dir / "verify_config_used.txt"
+        command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(confdir)]
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout); write_text_file(stderr_file, result.stderr)
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(verify_root), "--confdir", str(verify_conf)]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout); write_text_file(verify_stderr, verify_result.stderr); remote_manifest = build_manifest(verify_root); write_manifest(remote_manifest_file, remote_manifest)
+        write_text_file(config_copy, (confdir / "config").read_text(encoding="utf-8"))
+        write_text_file(verify_config_copy, (verify_conf / "config").read_text(encoding="utf-8"))
+        write_text_file(metadata_file, f"root_name={root_name}\nlarge_size={big_path.stat().st_size}\nlarge_size_mb_decimal={big_path.stat().st_size / 1000 / 1000:.3f}\nlarge_size_mib_binary={big_path.stat().st_size / 1024 / 1024:.3f}\nreturncode={result.returncode}\nverify_returncode={verify_result.returncode}\n")
+        artifacts = [str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(remote_manifest_file), str(metadata_file), str(config_copy), str(verify_config_copy)]
+        if app_log_dir.exists():
+            artifacts.append(str(app_log_dir))
+        details = {"returncode": result.returncode, "verify_returncode": verify_result.returncode, "root_name": root_name, "large_size": big_path.stat().st_size, "large_size_mb_decimal": round(big_path.stat().st_size / 1000 / 1000, 3), "large_size_mib_binary": round(big_path.stat().st_size / 1024 / 1024, 3), "skip_size": 1}
+        if result.returncode != 0: return self.fail_result(self.case_id, self.name, f"skip_size validation failed with status {result.returncode}", artifacts, details)
+        if verify_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if f"{root_name}/small.bin" not in remote_manifest: return self.fail_result(self.case_id, self.name, "Small file missing after skip_size processing", artifacts, details)
+        if f"{root_name}/large.bin" in remote_manifest: return self.fail_result(self.case_id, self.name, "Large file exceeded configured skip_size threshold but was synchronised; review display-running-config output and debug logs", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0015_skip_symlinks_validation.py b/ci/e2e/testcases/tc0015_skip_symlinks_validation.py
new file mode 100644
index 000000000..3f5950a24
--- /dev/null
+++ b/ci/e2e/testcases/tc0015_skip_symlinks_validation.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0015SkipSymlinksValidation(E2ETestCase):
+    case_id = "0015"
+    name = "skip_symlinks validation"
+    description = "Validate that skip_symlinks prevents symbolic links from synchronising"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0015 config\nbypass_data_preservation = \"true\"\nskip_symlinks = \"true\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0015",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir; case_log_dir = layout.log_dir; state_dir = layout.state_dir
+        sync_root = case_work_dir / "syncroot"; confdir = case_work_dir / "conf-main"; verify_root = case_work_dir / "verifyroot"; verify_conf = case_work_dir / "conf-verify"; root_name = f"ZZ_E2E_TC0015_{context.run_id}_{os.getpid()}"
+        target = sync_root / root_name / "real.txt"; write_text_file(target, "real\n"); link = sync_root / root_name / "linked.txt"; link.parent.mkdir(parents=True, exist_ok=True); link.symlink_to(target.name)
+        context.bootstrap_config_dir(confdir); self._write_config(confdir / "config")
+        context.bootstrap_config_dir(verify_conf); write_onedrive_config(verify_conf / "config", "# verify\nbypass_data_preservation = \"true\"\n")
+        stdout_file = case_log_dir / "skip_symlinks_stdout.log"; stderr_file = case_log_dir / "skip_symlinks_stderr.log"; verify_stdout = case_log_dir / "verify_stdout.log"; verify_stderr = case_log_dir / "verify_stderr.log"; remote_manifest_file = state_dir / "remote_verify_manifest.txt"; metadata_file = state_dir / "metadata.txt"
+        command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(confdir)]
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout); write_text_file(stderr_file, result.stderr)
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(verify_root), "--confdir", str(verify_conf)]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout); write_text_file(verify_stderr, verify_result.stderr); remote_manifest = build_manifest(verify_root); write_manifest(remote_manifest_file, remote_manifest)
+        write_text_file(metadata_file, f"root_name={root_name}\nreturncode={result.returncode}\nverify_returncode={verify_result.returncode}\n")
+        artifacts = [str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(remote_manifest_file), str(metadata_file)]
+        details = {"returncode": result.returncode, "verify_returncode": verify_result.returncode, "root_name": root_name}
+        if result.returncode != 0: return self.fail_result(self.case_id, self.name, f"skip_symlinks validation failed with status {result.returncode}", artifacts, details)
+        if verify_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if f"{root_name}/real.txt" not in remote_manifest: return self.fail_result(self.case_id, self.name, "Regular file missing after skip_symlinks processing", artifacts, details)
+        if f"{root_name}/linked.txt" in remote_manifest: return self.fail_result(self.case_id, self.name, "Symbolic link was unexpectedly synchronised", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0016_check_nosync_validation.py b/ci/e2e/testcases/tc0016_check_nosync_validation.py
new file mode 100644
index 000000000..095d1f969
--- /dev/null
+++ b/ci/e2e/testcases/tc0016_check_nosync_validation.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0016CheckNosyncValidation(E2ETestCase):
+    case_id = "0016"
+    name = "check_nosync validation"
+    description = "Validate that check_nosync prevents directories containing .nosync from synchronising"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(config_path, "# tc0016 config\nbypass_data_preservation = \"true\"\ncheck_nosync = \"true\"\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0016",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir; case_log_dir = layout.log_dir; state_dir = layout.state_dir
+        sync_root = case_work_dir / "syncroot"; confdir = case_work_dir / "conf-main"; verify_root = case_work_dir / "verifyroot"; verify_conf = case_work_dir / "conf-verify"; root_name = f"ZZ_E2E_TC0016_{context.run_id}_{os.getpid()}"
+        write_text_file(sync_root / root_name / "Allowed" / "ok.txt", "ok\n"); write_text_file(sync_root / root_name / "Blocked" / ".nosync", ""); write_text_file(sync_root / root_name / "Blocked" / "blocked.txt", "blocked\n")
+        context.bootstrap_config_dir(confdir); self._write_config(confdir / "config")
+        context.bootstrap_config_dir(verify_conf); write_onedrive_config(verify_conf / "config", "# verify\nbypass_data_preservation = \"true\"\n")
+        stdout_file = case_log_dir / "check_nosync_stdout.log"; stderr_file = case_log_dir / "check_nosync_stderr.log"; verify_stdout = case_log_dir / "verify_stdout.log"; verify_stderr = case_log_dir / "verify_stderr.log"; remote_manifest_file = state_dir / "remote_verify_manifest.txt"; metadata_file = state_dir / "metadata.txt"
+        command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--resync", "--resync-auth", "--syncdir", str(sync_root), "--confdir", str(confdir)]
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout); write_text_file(stderr_file, result.stderr)
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--download-only", "--resync", "--resync-auth", "--syncdir", str(verify_root), "--confdir", str(verify_conf)]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout); write_text_file(verify_stderr, verify_result.stderr); remote_manifest = build_manifest(verify_root); write_manifest(remote_manifest_file, remote_manifest)
+        write_text_file(metadata_file, f"root_name={root_name}\nreturncode={result.returncode}\nverify_returncode={verify_result.returncode}\n")
+        artifacts = [str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(remote_manifest_file), str(metadata_file)]
+        details = {"returncode": result.returncode, "verify_returncode": verify_result.returncode, "root_name": root_name}
+        if result.returncode != 0: return self.fail_result(self.case_id, self.name, f"check_nosync validation failed with status {result.returncode}", artifacts, details)
+        if verify_result.returncode != 0: return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if f"{root_name}/Allowed/ok.txt" not in remote_manifest: return self.fail_result(self.case_id, self.name, "Allowed content missing after check_nosync processing", artifacts, details)
+        for unwanted in [f"{root_name}/Blocked", f"{root_name}/Blocked/.nosync", f"{root_name}/Blocked/blocked.txt"]:
+            if unwanted in remote_manifest: return self.fail_result(self.case_id, self.name, f".nosync directory content was unexpectedly synchronised: {unwanted}", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0017_check_nomount_validation.py b/ci/e2e/testcases/tc0017_check_nomount_validation.py
new file mode 100644
index 000000000..fff2f2444
--- /dev/null
+++ b/ci/e2e/testcases/tc0017_check_nomount_validation.py
@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0017CheckNomountValidation(E2ETestCase):
+    case_id = "0017"
+    name = "check_nomount validation"
+    description = "Validate that check_nomount aborts synchronisation when .nosync exists in the sync_dir mount point"
+
+    def _write_config(self, config_path: Path) -> None:
+        write_onedrive_config(
+            config_path,
+            "# tc0017 config\n"
+            'bypass_data_preservation = "true"\n'
+            'check_nomount = "true"\n',
+        )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0017",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        confdir = case_work_dir / "conf-main"
+        root_name = f"ZZ_E2E_TC0017_{context.run_id}_{os.getpid()}"
+
+        write_text_file(sync_root / ".nosync", "")
+        write_text_file(sync_root / root_name / "should_not_upload.txt", "blocked by check_nomount\n")
+
+        context.bootstrap_config_dir(confdir)
+        self._write_config(confdir / "config")
+
+        stdout_file = case_log_dir / "check_nomount_stdout.log"
+        stderr_file = case_log_dir / "check_nomount_stderr.log"
+        metadata_file = state_dir / "metadata.txt"
+
+        command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(confdir),
+        ]
+        context.log(f"Executing Test Case {self.case_id}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"root_name={root_name}",
+                    f"command={command_to_string(command)}",
+                    f"returncode={result.returncode}",
+                ]
+            )
+            + "\n",
+        )
+
+        artifacts = [str(stdout_file), str(stderr_file), str(metadata_file)]
+        details = {
+            "command": command,
+            "returncode": result.returncode,
+            "root_name": root_name,
+        }
+
+        combined_output = (result.stdout + "\n" + result.stderr).lower()
+
+        if result.returncode == 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "check_nomount did not abort synchronisation when .nosync existed in the sync_dir mount point",
+                artifacts,
+                details,
+            )
+
+        if ".nosync file found" not in combined_output and "aborting synchronization process to safeguard data" not in combined_output:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "check_nomount did not emit the expected .nosync safeguard message",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0018_recycle_bin_validation.py b/ci/e2e/testcases/tc0018_recycle_bin_validation.py
new file mode 100644
index 000000000..4861a67fd
--- /dev/null
+++ b/ci/e2e/testcases/tc0018_recycle_bin_validation.py
@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0018RecycleBinValidation(E2ETestCase):
+    case_id = "0018"
+    name = "recycle bin validation"
+    description = "Validate that online deletions are moved into a FreeDesktop-compliant recycle bin when enabled"
+
+    def _write_runtime_base_config(self, config_path: Path, sync_dir: Path) -> None:
+        write_onedrive_config(
+            config_path,
+            "# tc0018 runtime base config\n"
+            f'sync_dir = "{sync_dir}"\n',
+        )
+
+    def _write_runtime_cleanup_config(self, config_path: Path, sync_dir: Path, recycle_bin_path: Path) -> None:
+        write_onedrive_config(
+            config_path,
+            "# tc0018 runtime cleanup config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'cleanup_local_files = "true"\n'
+            'download_only = "true"\n'
+            'use_recycle_bin = "true"\n'
+            f'recycle_bin_path = "{recycle_bin_path}"\n',
+        )
+
+    def _write_verify_config(self, config_path: Path, sync_dir: Path) -> None:
+        write_onedrive_config(
+            config_path,
+            "# tc0018 verify config\n"
+            f'sync_dir = "{sync_dir}"\n',
+        )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0018",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        recycle_bin_root = case_work_dir / "RecycleBin"
+
+        conf_runtime = case_work_dir / "conf-runtime"
+        conf_verify = case_work_dir / "conf-verify"
+
+        root_name = f"ZZ_E2E_TC0018_{context.run_id}_{os.getpid()}"
+
+        reset_directory(sync_root)
+        reset_directory(verify_root)
+        reset_directory(recycle_bin_root)
+
+        # Create initial local content to seed remotely
+        write_text_file(sync_root / root_name / "Keep" / "keep.txt", "keep\n")
+        write_text_file(sync_root / root_name / "OldData" / "old.txt", "old\n")
+
+        # Shared runtime config for seed -> remove -> cleanup
+        context.bootstrap_config_dir(conf_runtime)
+        self._write_runtime_base_config(conf_runtime / "config", sync_root)
+
+        # Fresh verify config for clean remote validation
+        context.bootstrap_config_dir(conf_verify)
+        self._write_verify_config(conf_verify / "config", verify_root)
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        remove_stdout = case_log_dir / "remove_stdout.log"
+        remove_stderr = case_log_dir / "remove_stderr.log"
+        cleanup_stdout = case_log_dir / "cleanup_stdout.log"
+        cleanup_stderr = case_log_dir / "cleanup_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+
+        recycle_manifest_file = state_dir / "recycle_manifest.txt"
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        local_manifest_file = state_dir / "local_manifest_after_cleanup.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--upload-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_runtime),
+        ]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+
+        remove_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--verbose",
+            "--remove-directory",
+            f"{root_name}/OldData",
+            "--confdir",
+            str(conf_runtime),
+        ]
+        context.log(f"Executing Test Case {self.case_id} remove: {command_to_string(remove_command)}")
+        remove_result = run_command(remove_command, cwd=context.repo_root)
+        write_text_file(remove_stdout, remove_result.stdout)
+        write_text_file(remove_stderr, remove_result.stderr)
+
+        # Rewrite the same runtime config so cleanup reuses the same DB / delta state
+        self._write_runtime_cleanup_config(conf_runtime / "config", sync_root, recycle_bin_root)
+
+        cleanup_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--cleanup-local-files",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_runtime),
+        ]
+        context.log(f"Executing Test Case {self.case_id} cleanup: {command_to_string(cleanup_command)}")
+        cleanup_result = run_command(cleanup_command, cwd=context.repo_root)
+        write_text_file(cleanup_stdout, cleanup_result.stdout)
+        write_text_file(cleanup_stderr, cleanup_result.stderr)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+
+        recycle_manifest = build_manifest(recycle_bin_root)
+        remote_manifest = build_manifest(verify_root)
+        local_manifest = build_manifest(sync_root)
+
+        write_manifest(recycle_manifest_file, recycle_manifest)
+        write_manifest(remote_manifest_file, remote_manifest)
+        write_manifest(local_manifest_file, local_manifest)
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"root_name={root_name}",
+                    f"sync_root={sync_root}",
+                    f"verify_root={verify_root}",
+                    f"recycle_bin_root={recycle_bin_root}",
+                    f"runtime_confdir={conf_runtime}",
+                    f"verify_confdir={conf_verify}",
+                    f"seed_returncode={seed_result.returncode}",
+                    f"remove_returncode={remove_result.returncode}",
+                    f"cleanup_returncode={cleanup_result.returncode}",
+                    f"verify_returncode={verify_result.returncode}",
+                ]
+            )
+            + "\n",
+        )
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(remove_stdout),
+            str(remove_stderr),
+            str(cleanup_stdout),
+            str(cleanup_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(recycle_manifest_file),
+            str(remote_manifest_file),
+            str(local_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "seed_returncode": seed_result.returncode,
+            "remove_returncode": remove_result.returncode,
+            "cleanup_returncode": cleanup_result.returncode,
+            "verify_returncode": verify_result.returncode,
+            "root_name": root_name,
+        }
+
+        if seed_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote seed failed with status {seed_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if remove_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Online directory removal failed with status {remove_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if cleanup_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Recycle bin cleanup sync failed with status {cleanup_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if (sync_root / root_name / "OldData").exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "OldData still exists locally after online deletion cleanup",
+                artifacts,
+                details,
+            )
+
+        if not (sync_root / root_name / "Keep" / "keep.txt").is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Keep file is missing locally after recycle bin processing",
+                artifacts,
+                details,
+            )
+
+        recycle_has_file = any(path.endswith("old.txt") for path in recycle_manifest)
+        recycle_has_info = any(path.endswith(".trashinfo") for path in recycle_manifest)
+
+        if not recycle_has_file:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Deleted content was not moved into the configured recycle bin",
+                artifacts,
+                details,
+            )
+
+        if not recycle_has_info:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Recycle bin metadata .trashinfo file was not created",
+                artifacts,
+                details,
+            )
+
+        if f"{root_name}/Keep/keep.txt" not in remote_manifest:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Keep file is missing online after recycle bin processing",
+                artifacts,
+                details,
+            )
+
+        if any(entry == f"{root_name}/OldData" or entry.startswith(f"{root_name}/OldData/") for entry in remote_manifest):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "OldData still exists online after explicit online removal",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0019_logging_and_running_config.py b/ci/e2e/testcases/tc0019_logging_and_running_config.py
new file mode 100644
index 000000000..9c90d9672
--- /dev/null
+++ b/ci/e2e/testcases/tc0019_logging_and_running_config.py
@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0019LoggingAndRunningConfig(E2ETestCase):
+    case_id = "0019"
+    name = "logging and running config validation"
+    description = "Validate custom log_dir output and display-running-config visibility"
+
+    def _write_config(self, config_path: Path, app_log_dir: Path) -> None:
+        write_onedrive_config(
+            config_path,
+            "# tc0019 config\n"
+            'bypass_data_preservation = "true"\n'
+            'enable_logging = "true"\n'
+            f'log_dir = "{app_log_dir}"\n',
+        )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0019",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        confdir = case_work_dir / "conf-main"
+        root_name = f"ZZ_E2E_TC0019_{context.run_id}_{os.getpid()}"
+        app_log_dir = case_log_dir / "app-logs"
+
+        write_text_file(sync_root / root_name / "logging.txt", "log me\n")
+
+        context.bootstrap_config_dir(confdir)
+        self._write_config(confdir / "config", app_log_dir)
+
+        stdout_file = case_log_dir / "logging_stdout.log"
+        stderr_file = case_log_dir / "logging_stderr.log"
+        metadata_file = state_dir / "metadata.txt"
+
+        command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(confdir),
+        ]
+        context.log(f"Executing Test Case {self.case_id}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+
+        log_entries = sorted(str(p.relative_to(app_log_dir)) for p in app_log_dir.rglob("*") if p.is_file()) if app_log_dir.exists() else []
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"root_name={root_name}",
+                    f"returncode={result.returncode}",
+                ] + [f"log_file={entry}" for entry in log_entries]
+            ) + "\n",
+        )
+
+        artifacts = [str(stdout_file), str(stderr_file), str(metadata_file)]
+        if app_log_dir.exists():
+            artifacts.append(str(app_log_dir))
+        details = {
+            "returncode": result.returncode,
+            "root_name": root_name,
+            "log_file_count": len(log_entries),
+        }
+
+        if result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Logging validation failed with status {result.returncode}", artifacts, details)
+        if not log_entries:
+            return self.fail_result(self.case_id, self.name, "No application log files were created in the configured log_dir", artifacts, details)
+
+        stdout_lower = result.stdout.lower()
+        if "display_running_config" not in stdout_lower and "log_dir" not in stdout_lower:
+            return self.fail_result(self.case_id, self.name, "display-running-config output did not expose the active runtime configuration", artifacts, details)
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0020_monitor_mode_validation.py b/ci/e2e/testcases/tc0020_monitor_mode_validation.py
new file mode 100644
index 000000000..960322522
--- /dev/null
+++ b/ci/e2e/testcases/tc0020_monitor_mode_validation.py
@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0020MonitorModeValidation(E2ETestCase):
+    case_id = "0020"
+    name = "monitor mode validation"
+    description = "Validate that monitor mode uploads local changes without manually re-running --sync"
+
+    def _write_config(self, config_path: Path, app_log_dir: Path) -> None:
+        write_onedrive_config(
+            config_path,
+            "# tc0020 config\n"
+            'bypass_data_preservation = "true"\n'
+            'enable_logging = "true"\n'
+            f'log_dir = "{app_log_dir}"\n'
+            'monitor_interval = "5"\n'
+            'monitor_fullscan_frequency = "1"\n',
+        )
+
+    def _wait_for_initial_sync_complete(
+        self,
+        stdout_file: Path,
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+        success_marker = "Sync with Microsoft OneDrive is complete"
+
+        while time.time() < deadline:
+            if stdout_file.exists():
+                try:
+                    content = stdout_file.read_text(encoding="utf-8", errors="replace")
+                except OSError:
+                    content = ""
+                if success_marker in content:
+                    return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0020",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        confdir = case_work_dir / "conf-main"
+        verify_root = case_work_dir / "verifyroot"
+        verify_conf = case_work_dir / "conf-verify"
+        root_name = f"ZZ_E2E_TC0020_{context.run_id}_{os.getpid()}"
+        app_log_dir = case_log_dir / "app-logs"
+
+        write_text_file(sync_root / root_name / "baseline.txt", "baseline\n")
+
+        context.bootstrap_config_dir(confdir)
+        self._write_config(confdir / "config", app_log_dir)
+        context.bootstrap_config_dir(verify_conf)
+        write_onedrive_config(verify_conf / "config", "# tc0020 verify\n" 'bypass_data_preservation = "true"\n')
+
+        stdout_file = case_log_dir / "monitor_stdout.log"
+        stderr_file = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--monitor",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(confdir),
+        ]
+        context.log(f"Executing Test Case {self.case_id}: {command_to_string(command)}")
+
+        with stdout_file.open("w", encoding="utf-8") as stdout_fp, stderr_file.open("w", encoding="utf-8") as stderr_fp:
+            process = subprocess.Popen(
+                command,
+                cwd=str(context.repo_root),
+                stdout=stdout_fp,
+                stderr=stderr_fp,
+                text=True,
+            )
+
+            initial_sync_complete = self._wait_for_initial_sync_complete(stdout_file)
+            if initial_sync_complete:
+                write_text_file(sync_root / root_name / "monitor-added.txt", "added while monitor mode was running\n")
+                time.sleep(12)
+
+            process.send_signal(signal.SIGINT)
+            try:
+                process.wait(timeout=30)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                process.wait(timeout=30)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(verify_conf),
+        ]
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"root_name={root_name}",
+                    f"monitor_returncode={process.returncode}",
+                    f"verify_returncode={verify_result.returncode}",
+                    f"initial_sync_complete={initial_sync_complete}",
+                ]
+            ) + "\n",
+        )
+
+        artifacts = [str(stdout_file), str(stderr_file), str(verify_stdout), str(verify_stderr), str(remote_manifest_file), str(metadata_file)]
+        if app_log_dir.exists():
+            artifacts.append(str(app_log_dir))
+        details = {
+            "monitor_returncode": process.returncode,
+            "verify_returncode": verify_result.returncode,
+            "root_name": root_name,
+            "initial_sync_complete": initial_sync_complete,
+        }
+
+        if not initial_sync_complete:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Monitor mode did not complete the initial sync within the expected time",
+                artifacts,
+                details,
+            )
+
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+
+        if f"{root_name}/monitor-added.txt" not in remote_manifest:
+            return self.fail_result(self.case_id, self.name, "Monitor mode did not upload the file created while the process was running", artifacts, details)
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0021_resumable_transfers_validation.py b/ci/e2e/testcases/tc0021_resumable_transfers_validation.py
new file mode 100644
index 000000000..55bd32e16
--- /dev/null
+++ b/ci/e2e/testcases/tc0021_resumable_transfers_validation.py
@@ -0,0 +1,1130 @@
+from __future__ import annotations
+
+import os
+import re
+import signal
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import CommandResult, command_to_string, reset_directory, write_onedrive_config, write_text_file
+
+
+@dataclass
+class ScenarioResult:
+    scenario_id: str
+    description: str
+    passed: bool
+    failure_message: str = ""
+    artifacts: list[str] | None = None
+    details: dict | None = None
+
+
+class TestCase0021ResumableTransfersValidation(E2ETestCase):
+    case_id = "0021"
+    name = "resumable transfers validation"
+    description = "Validate interrupted upload and download recovery for resumable transfers"
+
+    LARGE_FILE_SIZE = 100 * 1024 * 1024
+    INTERRUPT_THRESHOLD_PERCENT = 15.0
+    TRANSFER_WAIT_TIMEOUT = 300
+    PROCESS_EXIT_TIMEOUT = 120
+    PHASE_COMMAND_TIMEOUT = 1200
+
+    # Use 10 MB/s to deliberately slow both upload and download so the 15% threshold
+    # is reached with ample time to deliver SIGINT before the transfer can complete.
+    RATE_LIMIT: str | None = "10485760"
+
+    # Force active upload / download transfer abortion on SIGINT so resumable state is
+    # actually persisted for recovery testing. This must only be enabled for tc0021.
+    FORCE_XFER_ABORT = True
+
+    # Poll frequently to reduce brittleness caused by buffered log writes.
+    TRANSFER_POLL_INTERVAL_SECONDS = 0.25
+
+    def _write_config(
+        self,
+        config_path: Path,
+        sync_dir: Path,
+        app_log_dir: Path,
+    ) -> None:
+        lines = [
+            "# tc0021 config",
+            f'sync_dir = "{sync_dir}"',
+            'enable_logging = "true"',
+            f'log_dir = "{app_log_dir}"',
+        ]
+        if self.RATE_LIMIT:
+            lines.append(f'rate_limit = "{self.RATE_LIMIT}"')
+        if self.FORCE_XFER_ABORT:
+            lines.append('force_xfer_abort = "true"')
+        write_onedrive_config(config_path, "\n".join(lines) + "\n")
+
+    def _read_text_if_exists(self, path: Path) -> str:
+        if not path.exists():
+            return ""
+        return path.read_text(encoding="utf-8", errors="replace")
+
+    def _append_if_exists(self, artifacts: list[str], path: Path) -> None:
+        if path.exists():
+            artifacts.append(str(path))
+
+    def _snapshot_tree(self, root: Path, output: Path) -> None:
+        lines: list[str] = []
+        if root.exists():
+            for path in sorted(root.rglob("*")):
+                rel = path.relative_to(root).as_posix()
+                if path.is_dir():
+                    lines.append(rel + "/")
+                else:
+                    lines.append(rel)
+        write_text_file(output, "\n".join(lines) + ("\n" if lines else ""))
+
+    def _create_large_file(self, path: Path, size_bytes: int) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        chunk = b"R" * (1024 * 1024)
+        chunk_count = size_bytes // len(chunk)
+        with path.open("wb") as fp:
+            for _ in range(chunk_count):
+                fp.write(chunk)
+            remainder = size_bytes % len(chunk)
+            if remainder:
+                fp.write(chunk[:remainder])
+
+    def _contains_any_marker(self, text: str, markers: list[str]) -> bool:
+        return any(marker in text for marker in markers)
+
+    def _extract_max_progress_percent(self, text: str) -> float:
+        max_percent = 0.0
+        for match in re.finditer(r"(?P<percent>\d{1,3}(?:\.\d+)?)\s*%", text):
+            try:
+                value = float(match.group("percent"))
+            except ValueError:
+                continue
+            if 0.0 <= value <= 100.0 and value > max_percent:
+                max_percent = value
+        return max_percent
+
+    def _build_transfer_observation(
+        self,
+        stdout_file: Path,
+        stderr_file: Path,
+        app_log_file: Path,
+        target_filename: str,
+    ) -> tuple[str, float]:
+        stdout_text = self._read_text_if_exists(stdout_file)
+        stderr_text = self._read_text_if_exists(stderr_file)
+        app_log_text = self._read_text_if_exists(app_log_file)
+
+        combined_text = stdout_text + "\n" + stderr_text + "\n" + app_log_text
+
+        relevant_lines: list[str] = []
+        for line in combined_text.splitlines():
+            if target_filename in line:
+                relevant_lines.append(line)
+
+        relevant_text = "\n".join(relevant_lines)
+        max_percent = 0.0
+
+        if relevant_text:
+            max_percent = self._extract_max_progress_percent(relevant_text)
+
+        if max_percent == 0.0:
+            max_percent = self._extract_max_progress_percent(combined_text)
+
+        return combined_text, max_percent
+
+    def _interrupt_process_at_transfer_threshold(
+        self,
+        context: E2EContext,
+        label: str,
+        command: list[str],
+        stdout_file: Path,
+        stderr_file: Path,
+        app_log_file: Path,
+        target_filename: str,
+        threshold_percent: float,
+        wait_timeout: int,
+        exit_timeout: int,
+    ) -> tuple[int, str, str, bool, float]:
+        context.log(f"Executing Test Case {self.case_id} {label}: {command_to_string(command)}")
+
+        threshold_reached = False
+        observed_max_percent = 0.0
+
+        with stdout_file.open("w", encoding="utf-8") as stdout_fp, stderr_file.open(
+            "w", encoding="utf-8"
+        ) as stderr_fp:
+            process = subprocess.Popen(
+                command,
+                cwd=str(context.repo_root),
+                stdout=stdout_fp,
+                stderr=stderr_fp,
+                text=True,
+            )
+
+            start_time = time.time()
+
+            while True:
+                if process.poll() is not None:
+                    break
+
+                _, current_max = self._build_transfer_observation(
+                    stdout_file,
+                    stderr_file,
+                    app_log_file,
+                    target_filename,
+                )
+
+                if current_max > observed_max_percent:
+                    observed_max_percent = current_max
+
+                if current_max >= threshold_percent:
+                    threshold_reached = True
+                    process.send_signal(signal.SIGINT)
+                    break
+
+                if (time.time() - start_time) > wait_timeout:
+                    process.send_signal(signal.SIGINT)
+                    break
+
+                time.sleep(self.TRANSFER_POLL_INTERVAL_SECONDS)
+
+            try:
+                process.wait(timeout=exit_timeout)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                process.wait(timeout=30)
+
+        stdout_text = self._read_text_if_exists(stdout_file)
+        stderr_text = self._read_text_if_exists(stderr_file)
+        return process.returncode, stdout_text, stderr_text, threshold_reached, observed_max_percent
+
+    def _run_and_capture(
+        self,
+        context: E2EContext,
+        label: str,
+        command: list[str],
+        stdout_file: Path,
+        stderr_file: Path,
+        timeout_seconds: int | None = None,
+    ) -> CommandResult:
+        timeout = timeout_seconds or self.PHASE_COMMAND_TIMEOUT
+        context.log(
+            f"Executing Test Case {self.case_id} {label}: {command_to_string(command)} "
+            f"(timeout {timeout}s)"
+        )
+
+        try:
+            completed = subprocess.run(
+                command,
+                cwd=str(context.repo_root),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=timeout,
+            )
+            result = CommandResult(
+                command=command,
+                returncode=completed.returncode,
+                stdout=completed.stdout or "",
+                stderr=completed.stderr or "",
+            )
+        except subprocess.TimeoutExpired as exc:
+            stdout = exc.stdout or ""
+            stderr = exc.stderr or ""
+            if isinstance(stdout, bytes):
+                stdout = stdout.decode("utf-8", errors="replace")
+            if isinstance(stderr, bytes):
+                stderr = stderr.decode("utf-8", errors="replace")
+            stderr = (
+                f"{stderr}\n"
+                f"Test Case {self.case_id} {label} timed out after {timeout} seconds; "
+                "the onedrive process was terminated by the harness.\n"
+            )
+            result = CommandResult(
+                command=command,
+                returncode=124,
+                stdout=stdout,
+                stderr=stderr,
+            )
+
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+        return result
+
+    def _scenario_fail(
+        self,
+        scenario_id: str,
+        description: str,
+        message: str,
+        artifacts: list[str],
+        details: dict,
+    ) -> ScenarioResult:
+        return ScenarioResult(
+            scenario_id=scenario_id,
+            description=description,
+            passed=False,
+            failure_message=message,
+            artifacts=artifacts,
+            details=details,
+        )
+
+    def _scenario_pass(
+        self,
+        scenario_id: str,
+        description: str,
+        artifacts: list[str],
+        details: dict,
+    ) -> ScenarioResult:
+        return ScenarioResult(
+            scenario_id=scenario_id,
+            description=description,
+            passed=True,
+            artifacts=artifacts,
+            details=details,
+        )
+
+    def _phase_app_log_file(self, phase_app_log_dir: Path) -> Path:
+        return phase_app_log_dir / "root.onedrive.log"
+
+    def _phase1_interruption_acceptable(self, combined_phase1_output: str, phase1_returncode: int) -> tuple[bool, str]:
+        crash_markers = [
+            "Segmentation fault",
+            "core dumped",
+            "SIGSEGV",
+        ]
+
+        crash_marker_seen = ""
+        for marker in crash_markers:
+            if marker in combined_phase1_output:
+                crash_marker_seen = marker
+                break
+
+        interrupted_as_expected = (
+            phase1_returncode in (-2, 2, 130, -11, 139)
+            or crash_marker_seen in {"Segmentation fault", "core dumped", "SIGSEGV"}
+        )
+
+        return interrupted_as_expected, crash_marker_seen
+
+    def _target_transfer_completed_in_phase1(
+        self,
+        combined_phase1_output: str,
+        target_filename: str,
+        transfer_kind: str,
+    ) -> bool:
+        for line in combined_phase1_output.splitlines():
+            if target_filename not in line:
+                continue
+
+            line_lower = line.lower()
+
+            if transfer_kind == "upload":
+                if "upload" in line_lower and "done" in line_lower:
+                    return True
+            elif transfer_kind == "download":
+                if "download" in line_lower and "done" in line_lower:
+                    return True
+
+        return False
+
+    def _find_resumable_state_files(self, conf_dir: Path, patterns: list[str]) -> list[str]:
+        matches: list[str] = []
+        for pattern in patterns:
+            for path in sorted(conf_dir.glob(pattern)):
+                if path.is_file():
+                    matches.append(str(path))
+        return matches
+
+    def _write_resumable_state_listing(self, output: Path, resumable_files: list[str]) -> None:
+        if resumable_files:
+            write_text_file(output, "\n".join(resumable_files) + "\n")
+        else:
+            write_text_file(output, "")
+
+    def _run_upload_resume_scenario(
+        self,
+        context: E2EContext,
+        root_name: str,
+        sync_root: Path,
+        verify_root: Path,
+        scenario_work_dir: Path,
+        scenario_log_dir: Path,
+        scenario_state_dir: Path,
+    ) -> ScenarioResult:
+        scenario_id = "RT-0001"
+        description = "resumable upload"
+
+        conf_dir = scenario_work_dir / "conf"
+        verify_conf_dir = scenario_work_dir / "verify-conf"
+
+        app_log_dir = scenario_log_dir / "app-logs"
+        verify_app_log_dir = scenario_log_dir / "verify-app-logs"
+
+        app_log_file = self._phase_app_log_file(app_log_dir)
+        verify_app_log_file = self._phase_app_log_file(verify_app_log_dir)
+
+        reset_directory(conf_dir)
+        reset_directory(verify_conf_dir)
+        context.bootstrap_config_dir(conf_dir)
+        context.bootstrap_config_dir(verify_conf_dir)
+
+        self._write_config(conf_dir / "config", sync_root, app_log_dir)
+        self._write_config(verify_conf_dir / "config", verify_root, verify_app_log_dir)
+
+        relative_path = f"{root_name}/{scenario_id}/session-large.bin"
+        local_file = sync_root / relative_path
+        self._create_large_file(local_file, self.LARGE_FILE_SIZE)
+
+        phase1_stdout = scenario_log_dir / "phase1_stdout.log"
+        phase1_stderr = scenario_log_dir / "phase1_stderr.log"
+        phase2_stdout = scenario_log_dir / "phase2_stdout.log"
+        phase2_stderr = scenario_log_dir / "phase2_stderr.log"
+        verify_stdout = scenario_log_dir / "verify_stdout.log"
+        verify_stderr = scenario_log_dir / "verify_stderr.log"
+
+        local_tree_before = scenario_state_dir / "local_tree_before_phase1.txt"
+        local_tree_after_phase1 = scenario_state_dir / "local_tree_after_phase1.txt"
+        local_tree_after_phase2 = scenario_state_dir / "local_tree_after_phase2.txt"
+        remote_manifest_file = scenario_state_dir / "remote_verify_manifest.txt"
+        resumable_state_file = scenario_state_dir / "phase1_resumable_state_files.txt"
+        metadata_file = scenario_state_dir / "metadata.txt"
+
+        self._snapshot_tree(sync_root, local_tree_before)
+
+        upload_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            f"{root_name}/{scenario_id}",
+            "--confdir",
+            str(conf_dir),
+        ]
+
+        (
+            phase1_returncode,
+            phase1_stdout_text,
+            phase1_stderr_text,
+            threshold_reached,
+            observed_max_percent,
+        ) = self._interrupt_process_at_transfer_threshold(
+            context,
+            f"{scenario_id} phase 1",
+            upload_command,
+            phase1_stdout,
+            phase1_stderr,
+            app_log_file,
+            "session-large.bin",
+            self.INTERRUPT_THRESHOLD_PERCENT,
+            self.TRANSFER_WAIT_TIMEOUT,
+            self.PROCESS_EXIT_TIMEOUT,
+        )
+
+        self._snapshot_tree(sync_root, local_tree_after_phase1)
+
+        phase1_app_log_text = self._read_text_if_exists(app_log_file)
+        combined_phase1_output = phase1_stdout_text + "\n" + phase1_stderr_text + "\n" + phase1_app_log_text
+
+        phase1_completed_transfer = self._target_transfer_completed_in_phase1(
+            combined_phase1_output,
+            "session-large.bin",
+            "upload",
+        )
+
+        resumable_state_files = self._find_resumable_state_files(
+            conf_dir,
+            [
+                "session_upload*",
+                "session_upload.*",
+            ],
+        )
+        self._write_resumable_state_listing(resumable_state_file, resumable_state_files)
+
+        phase2_result = self._run_and_capture(
+            context,
+            f"{scenario_id} phase 2",
+            upload_command,
+            phase2_stdout,
+            phase2_stderr,
+        )
+
+        phase2_stdout_text = self._read_text_if_exists(phase2_stdout)
+        phase2_stderr_text = self._read_text_if_exists(phase2_stderr)
+        phase2_app_log_text = self._read_text_if_exists(app_log_file)
+        combined_phase2_output = phase2_stdout_text + "\n" + phase2_stderr_text + "\n" + phase2_app_log_text
+
+        self._snapshot_tree(sync_root, local_tree_after_phase2)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            f"{root_name}/{scenario_id}",
+            "--confdir",
+            str(verify_conf_dir),
+        ]
+
+        verify_result = self._run_and_capture(
+            context,
+            f"{scenario_id} verify",
+            verify_command,
+            verify_stdout,
+            verify_stderr,
+        )
+
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+
+        interrupted_as_expected, crash_marker_seen = self._phase1_interruption_acceptable(
+            combined_phase1_output,
+            phase1_returncode,
+        )
+
+        artifacts = [
+            str(phase1_stdout),
+            str(phase1_stderr),
+            str(phase2_stdout),
+            str(phase2_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(local_tree_before),
+            str(local_tree_after_phase1),
+            str(local_tree_after_phase2),
+            str(remote_manifest_file),
+            str(resumable_state_file),
+            str(metadata_file),
+        ]
+        self._append_if_exists(artifacts, app_log_dir)
+        self._append_if_exists(artifacts, verify_app_log_dir)
+
+        details = {
+            "scenario_id": scenario_id,
+            "phase1_returncode": phase1_returncode,
+            "phase2_returncode": phase2_result.returncode,
+            "verify_returncode": verify_result.returncode,
+            "relative_path": relative_path,
+            "large_size": self.LARGE_FILE_SIZE,
+            "interrupt_threshold_percent": self.INTERRUPT_THRESHOLD_PERCENT,
+            "threshold_reached": threshold_reached,
+            "observed_max_percent": observed_max_percent,
+            "phase1_transfer_completed": phase1_completed_transfer,
+            "phase1_resumable_state_files": resumable_state_files,
+            "phase1_crash_marker_seen": crash_marker_seen,
+            "phase1_interrupted_as_expected": interrupted_as_expected,
+            "rate_limit": self.RATE_LIMIT or "disabled",
+            "force_xfer_abort": self.FORCE_XFER_ABORT,
+            "conf_dir": str(conf_dir),
+            "app_log_file": str(app_log_file),
+        }
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"scenario_id={scenario_id}",
+                    f"phase1_returncode={phase1_returncode}",
+                    f"phase2_returncode={phase2_result.returncode}",
+                    f"verify_returncode={verify_result.returncode}",
+                    f"relative_path={relative_path}",
+                    f"large_size={self.LARGE_FILE_SIZE}",
+                    f"interrupt_threshold_percent={self.INTERRUPT_THRESHOLD_PERCENT}",
+                    f"threshold_reached={threshold_reached}",
+                    f"observed_max_percent={observed_max_percent}",
+                    f"phase1_transfer_completed={phase1_completed_transfer}",
+                    f"phase1_resumable_state_files={len(resumable_state_files)}",
+                    f"phase1_crash_marker_seen={crash_marker_seen}",
+                    f"phase1_interrupted_as_expected={interrupted_as_expected}",
+                    f"rate_limit={self.RATE_LIMIT or 'disabled'}",
+                    f"force_xfer_abort={self.FORCE_XFER_ABORT}",
+                    f"conf_dir={conf_dir}",
+                    f"app_log_file={app_log_file}",
+                ]
+            )
+            + "\n",
+        )
+
+        if not threshold_reached:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                f"Interrupted upload phase never reached {self.INTERRUPT_THRESHOLD_PERCENT}% transfer progress before shutdown; observed maximum was {observed_max_percent:.2f}%",
+                artifacts,
+                details,
+            )
+
+        if phase1_completed_transfer:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                "Interrupted upload phase completed the target file transfer before SIGINT landed, so no resumable upload state was guaranteed",
+                artifacts,
+                details,
+            )
+
+        if not interrupted_as_expected:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                f"Interrupted upload phase did not terminate as expected after threshold was reached; return code was {phase1_returncode}",
+                artifacts,
+                details,
+            )
+
+        if not resumable_state_files:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                "Interrupted upload phase did not leave resumable upload session state on disk",
+                artifacts,
+                details,
+            )
+
+        if phase2_result.returncode != 0:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                f"Resumable upload recovery phase failed with status {phase2_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if verify_result.returncode != 0:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                f"Remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        upload_resume_markers = [
+            "There are interrupted session uploads that need to be resumed",
+            "Attempting to restore file upload session using this session data file",
+            "Attempting to restore file upload session",
+        ]
+        if not self._contains_any_marker(combined_phase2_output, upload_resume_markers):
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                "Subsequent upload run did not show evidence of resumable upload recovery",
+                artifacts,
+                details,
+            )
+
+        if relative_path not in remote_manifest:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                "Interrupted resumable upload did not complete successfully on the subsequent run",
+                artifacts,
+                details,
+            )
+
+        return self._scenario_pass(scenario_id, description, artifacts, details)
+
+    def _run_download_resume_scenario(
+        self,
+        context: E2EContext,
+        root_name: str,
+        scenario_work_dir: Path,
+        scenario_log_dir: Path,
+        scenario_state_dir: Path,
+    ) -> ScenarioResult:
+        scenario_id = "RT-0002"
+        description = "resumable download"
+
+        seed_root = scenario_work_dir / "seedroot"
+        download_root = scenario_work_dir / "downloadroot"
+        verify_root = scenario_work_dir / "verifyroot"
+
+        seed_conf_dir = scenario_work_dir / "seed-conf"
+        conf_dir = scenario_work_dir / "conf"
+        verify_conf_dir = scenario_work_dir / "verify-conf"
+
+        seed_app_log_dir = scenario_log_dir / "seed-app-logs"
+        app_log_dir = scenario_log_dir / "app-logs"
+        verify_app_log_dir = scenario_log_dir / "verify-app-logs"
+
+        seed_app_log_file = self._phase_app_log_file(seed_app_log_dir)
+        app_log_file = self._phase_app_log_file(app_log_dir)
+        verify_app_log_file = self._phase_app_log_file(verify_app_log_dir)
+
+        reset_directory(seed_root)
+        reset_directory(download_root)
+        reset_directory(verify_root)
+        reset_directory(seed_conf_dir)
+        reset_directory(conf_dir)
+        reset_directory(verify_conf_dir)
+
+        context.bootstrap_config_dir(seed_conf_dir)
+        context.bootstrap_config_dir(conf_dir)
+        context.bootstrap_config_dir(verify_conf_dir)
+
+        self._write_config(seed_conf_dir / "config", seed_root, seed_app_log_dir)
+        self._write_config(conf_dir / "config", download_root, app_log_dir)
+        self._write_config(verify_conf_dir / "config", verify_root, verify_app_log_dir)
+
+        relative_path = f"{root_name}/{scenario_id}/session-large.bin"
+        seed_file = seed_root / relative_path
+        self._create_large_file(seed_file, self.LARGE_FILE_SIZE)
+
+        seed_stdout = scenario_log_dir / "seed_stdout.log"
+        seed_stderr = scenario_log_dir / "seed_stderr.log"
+        phase1_stdout = scenario_log_dir / "phase1_stdout.log"
+        phase1_stderr = scenario_log_dir / "phase1_stderr.log"
+        phase2_stdout = scenario_log_dir / "phase2_stdout.log"
+        phase2_stderr = scenario_log_dir / "phase2_stderr.log"
+        verify_stdout = scenario_log_dir / "verify_stdout.log"
+        verify_stderr = scenario_log_dir / "verify_stderr.log"
+
+        local_tree_before = scenario_state_dir / "local_tree_before_phase1.txt"
+        local_tree_after_phase1 = scenario_state_dir / "local_tree_after_phase1.txt"
+        local_tree_after_phase2 = scenario_state_dir / "local_tree_after_phase2.txt"
+        local_tree_after_verify = scenario_state_dir / "local_tree_after_verify.txt"
+        verify_manifest_file = scenario_state_dir / "verify_manifest.txt"
+        resumable_state_file = scenario_state_dir / "phase1_resumable_state_files.txt"
+        metadata_file = scenario_state_dir / "metadata.txt"
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            f"{root_name}/{scenario_id}",
+            "--confdir",
+            str(seed_conf_dir),
+        ]
+        seed_result = self._run_and_capture(
+            context,
+            f"{scenario_id} seed",
+            seed_command,
+            seed_stdout,
+            seed_stderr,
+        )
+
+        if seed_result.returncode != 0:
+            artifacts = [str(seed_stdout), str(seed_stderr)]
+            self._append_if_exists(artifacts, seed_app_log_dir)
+            details = {
+                "scenario_id": scenario_id,
+                "seed_returncode": seed_result.returncode,
+                "relative_path": relative_path,
+                "rate_limit": self.RATE_LIMIT or "disabled",
+                "force_xfer_abort": self.FORCE_XFER_ABORT,
+            }
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                f"Seed upload phase failed with status {seed_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        reset_directory(download_root)
+
+        items_db = conf_dir / "items.sqlite3"
+        items_db_wal = conf_dir / "items.sqlite3-wal"
+        items_db_shm = conf_dir / "items.sqlite3-shm"
+        for db_file in (items_db, items_db_wal, items_db_shm):
+            if db_file.exists():
+                db_file.unlink()
+
+        self._snapshot_tree(download_root, local_tree_before)
+
+        download_command_phase1 = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            f"{root_name}/{scenario_id}",
+            "--confdir",
+            str(conf_dir),
+        ]
+
+        (
+            phase1_returncode,
+            phase1_stdout_text,
+            phase1_stderr_text,
+            threshold_reached,
+            observed_max_percent,
+        ) = self._interrupt_process_at_transfer_threshold(
+            context,
+            f"{scenario_id} phase 1",
+            download_command_phase1,
+            phase1_stdout,
+            phase1_stderr,
+            app_log_file,
+            "session-large.bin",
+            self.INTERRUPT_THRESHOLD_PERCENT,
+            self.TRANSFER_WAIT_TIMEOUT,
+            self.PROCESS_EXIT_TIMEOUT,
+        )
+
+        self._snapshot_tree(download_root, local_tree_after_phase1)
+
+        phase1_app_log_text = self._read_text_if_exists(app_log_file)
+        combined_phase1_output = phase1_stdout_text + "\n" + phase1_stderr_text + "\n" + phase1_app_log_text
+
+        phase1_completed_transfer = self._target_transfer_completed_in_phase1(
+            combined_phase1_output,
+            "session-large.bin",
+            "download",
+        )
+
+        resumable_state_files = self._find_resumable_state_files(
+            conf_dir,
+            [
+                "resume_download*",
+                "resume_download.*",
+            ],
+        )
+        self._write_resumable_state_listing(resumable_state_file, resumable_state_files)
+
+        download_command_phase2 = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            f"{root_name}/{scenario_id}",
+            "--confdir",
+            str(conf_dir),
+        ]
+
+        phase2_result = self._run_and_capture(
+            context,
+            f"{scenario_id} phase 2",
+            download_command_phase2,
+            phase2_stdout,
+            phase2_stderr,
+        )
+
+        phase2_stdout_text = self._read_text_if_exists(phase2_stdout)
+        phase2_stderr_text = self._read_text_if_exists(phase2_stderr)
+        phase2_app_log_text = self._read_text_if_exists(app_log_file)
+        combined_phase2_output = phase2_stdout_text + "\n" + phase2_stderr_text + "\n" + phase2_app_log_text
+
+        self._snapshot_tree(download_root, local_tree_after_phase2)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            f"{root_name}/{scenario_id}",
+            "--confdir",
+            str(verify_conf_dir),
+        ]
+        verify_result = self._run_and_capture(
+            context,
+            f"{scenario_id} verify",
+            verify_command,
+            verify_stdout,
+            verify_stderr,
+        )
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        self._snapshot_tree(verify_root, local_tree_after_verify)
+
+        downloaded_file = download_root / relative_path
+
+        interrupted_as_expected, crash_marker_seen = self._phase1_interruption_acceptable(
+            combined_phase1_output,
+            phase1_returncode,
+        )
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(phase1_stdout),
+            str(phase1_stderr),
+            str(phase2_stdout),
+            str(phase2_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(local_tree_before),
+            str(local_tree_after_phase1),
+            str(local_tree_after_phase2),
+            str(local_tree_after_verify),
+            str(verify_manifest_file),
+            str(resumable_state_file),
+            str(metadata_file),
+        ]
+        self._append_if_exists(artifacts, seed_app_log_dir)
+        self._append_if_exists(artifacts, app_log_dir)
+        self._append_if_exists(artifacts, verify_app_log_dir)
+
+        details = {
+            "scenario_id": scenario_id,
+            "seed_returncode": seed_result.returncode,
+            "phase1_returncode": phase1_returncode,
+            "phase2_returncode": phase2_result.returncode,
+            "verify_returncode": verify_result.returncode,
+            "relative_path": relative_path,
+            "large_size": self.LARGE_FILE_SIZE,
+            "interrupt_threshold_percent": self.INTERRUPT_THRESHOLD_PERCENT,
+            "threshold_reached": threshold_reached,
+            "observed_max_percent": observed_max_percent,
+            "phase1_transfer_completed": phase1_completed_transfer,
+            "phase1_resumable_state_files": resumable_state_files,
+            "downloaded_file_exists_after_phase2": downloaded_file.exists(),
+            "phase1_crash_marker_seen": crash_marker_seen,
+            "phase1_interrupted_as_expected": interrupted_as_expected,
+            "rate_limit": self.RATE_LIMIT or "disabled",
+            "force_xfer_abort": self.FORCE_XFER_ABORT,
+            "conf_dir": str(conf_dir),
+            "app_log_file": str(app_log_file),
+        }
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"scenario_id={scenario_id}",
+                    f"seed_returncode={seed_result.returncode}",
+                    f"phase1_returncode={phase1_returncode}",
+                    f"phase2_returncode={phase2_result.returncode}",
+                    f"verify_returncode={verify_result.returncode}",
+                    f"relative_path={relative_path}",
+                    f"large_size={self.LARGE_FILE_SIZE}",
+                    f"interrupt_threshold_percent={self.INTERRUPT_THRESHOLD_PERCENT}",
+                    f"threshold_reached={threshold_reached}",
+                    f"observed_max_percent={observed_max_percent}",
+                    f"phase1_transfer_completed={phase1_completed_transfer}",
+                    f"phase1_resumable_state_files={len(resumable_state_files)}",
+                    f"downloaded_file_exists_after_phase2={downloaded_file.exists()}",
+                    f"phase1_crash_marker_seen={crash_marker_seen}",
+                    f"phase1_interrupted_as_expected={interrupted_as_expected}",
+                    f"rate_limit={self.RATE_LIMIT or 'disabled'}",
+                    f"force_xfer_abort={self.FORCE_XFER_ABORT}",
+                    f"conf_dir={conf_dir}",
+                    f"app_log_file={app_log_file}",
+                ]
+            )
+            + "\n",
+        )
+
+        if not threshold_reached:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                f"Interrupted download phase never reached {self.INTERRUPT_THRESHOLD_PERCENT}% transfer progress before shutdown; observed maximum was {observed_max_percent:.2f}%",
+                artifacts,
+                details,
+            )
+
+        if phase1_completed_transfer:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                "Interrupted download phase completed the target file transfer before SIGINT landed, so no resumable download state was guaranteed",
+                artifacts,
+                details,
+            )
+
+        if not interrupted_as_expected:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                f"Interrupted download phase did not terminate as expected after threshold was reached; return code was {phase1_returncode}",
+                artifacts,
+                details,
+            )
+
+        if not resumable_state_files:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                "Interrupted download phase did not leave resumable download state on disk",
+                artifacts,
+                details,
+            )
+
+        if phase2_result.returncode != 0:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                f"Resumable download recovery phase failed with status {phase2_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if verify_result.returncode != 0:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                f"Download verification phase failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        download_resume_markers = [
+            "There are interrupted downloads that need to be resumed",
+            "Attempting to resume file download using this 'resumable data' file",
+            "Attempting to resume file download using this resumable data file",
+        ]
+        if not self._contains_any_marker(combined_phase2_output, download_resume_markers):
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                "Subsequent download run did not show evidence of resumable download recovery",
+                artifacts,
+                details,
+            )
+
+        if not downloaded_file.exists():
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                "Interrupted resumable download did not produce the expected local file on the subsequent run",
+                artifacts,
+                details,
+            )
+
+        if downloaded_file.stat().st_size != self.LARGE_FILE_SIZE:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                "Downloaded file size after resumed download did not match expected size",
+                artifacts,
+                details,
+            )
+
+        if relative_path not in verify_manifest:
+            return self._scenario_fail(
+                scenario_id,
+                description,
+                "Verification download did not contain the expected remote file",
+                artifacts,
+                details,
+            )
+
+        return self._scenario_pass(scenario_id, description, artifacts, details)
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0021",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        root_name = f"ZZ_E2E_TC0021_{context.run_id}_{os.getpid()}"
+
+        upload_sync_root = case_work_dir / "upload-syncroot"
+        upload_verify_root = case_work_dir / "upload-verifyroot"
+        upload_work_dir = case_work_dir / "rt0001-upload"
+        upload_log_dir = case_log_dir / "rt0001-upload"
+        upload_state_dir = state_dir / "rt0001-upload"
+
+        reset_directory(upload_sync_root)
+        reset_directory(upload_verify_root)
+        reset_directory(upload_work_dir)
+        reset_directory(upload_log_dir)
+        reset_directory(upload_state_dir)
+
+        results: list[ScenarioResult] = []
+
+        if context.should_run_scenario(self.case_id, "RT-0001"):
+            results.append(
+                self._run_upload_resume_scenario(
+                    context,
+                    root_name,
+                    upload_sync_root,
+                    upload_verify_root,
+                    upload_work_dir,
+                    upload_log_dir,
+                    upload_state_dir,
+                )
+            )
+
+        download_work_dir = case_work_dir / "rt0002-download"
+        download_log_dir = case_log_dir / "rt0002-download"
+        download_state_dir = state_dir / "rt0002-download"
+
+        reset_directory(download_work_dir)
+        reset_directory(download_log_dir)
+        reset_directory(download_state_dir)
+
+        if context.should_run_scenario(self.case_id, "RT-0002"):
+            results.append(
+                self._run_download_resume_scenario(
+                    context,
+                    root_name,
+                    download_work_dir,
+                    download_log_dir,
+                    download_state_dir,
+                )
+            )
+
+        failed = [result for result in results if not result.passed]
+        artifacts: list[str] = []
+        details: dict = {
+            "root_name": root_name,
+            "executed_scenario_ids": [result.scenario_id for result in results],
+            "failed_scenario_ids": [result.scenario_id for result in failed],
+            "scenario_results": {},
+        }
+
+        for result in results:
+            if result.artifacts:
+                artifacts.extend(result.artifacts)
+            if result.details:
+                details["scenario_results"][result.scenario_id] = result.details
+
+        deduped_artifacts = []
+        seen = set()
+        for artifact in artifacts:
+            if artifact not in seen:
+                deduped_artifacts.append(artifact)
+                seen.add(artifact)
+
+        summary_file = state_dir / "scenario_summary.txt"
+        summary_lines = []
+        for result in results:
+            status = "PASS" if result.passed else "FAIL"
+            line = f"{result.scenario_id} [{status}] {result.description}"
+            if result.failure_message:
+                line += f" — {result.failure_message}"
+            summary_lines.append(line)
+        write_text_file(summary_file, "\n".join(summary_lines) + "\n")
+        deduped_artifacts.append(str(summary_file))
+
+        if failed:
+            failed_ids = ", ".join(result.scenario_id for result in failed)
+            first_failure = failed[0].failure_message or "scenario failure"
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"{len(failed)} of {len(results)} resumable transfer scenarios failed: {failed_ids} — {first_failure}",
+                deduped_artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, deduped_artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0022_local_first_validation.py b/ci/e2e/testcases/tc0022_local_first_validation.py
new file mode 100644
index 000000000..3403ddfce
--- /dev/null
+++ b/ci/e2e/testcases/tc0022_local_first_validation.py
@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.manifest import build_manifest, write_manifest
+from framework.context import E2EContext
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0022LocalFirstValidation(E2ETestCase):
+    case_id = "0022"
+    name = "local_first validation"
+    description = "Validate that local_first treats local content as the source of truth during a conflict"
+
+    def _write_config(self, config_path: Path, sync_dir: Path, local_first: bool = False) -> None:
+        content = (
+            "# tc0022 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+        )
+        if local_first:
+            content += 'local_first = "true"\n'
+        write_onedrive_config(config_path, content)
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0022",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        seed_root = case_work_dir / "seedroot"
+        local_root = case_work_dir / "localroot"
+        remote_update_root = case_work_dir / "remoteupdateroot"
+        verify_root = case_work_dir / "verifyroot"
+
+        conf_seed = case_work_dir / "conf-seed"
+        conf_local = case_work_dir / "conf-local"
+        conf_remote = case_work_dir / "conf-remote"
+        conf_verify = case_work_dir / "conf-verify"
+
+        root_name = f"ZZ_E2E_TC0022_{context.run_id}_{os.getpid()}"
+        relative_file = f"{root_name}/conflict.txt"
+
+        reset_directory(seed_root)
+        reset_directory(local_root)
+        reset_directory(remote_update_root)
+        reset_directory(verify_root)
+
+        write_text_file(seed_root / relative_file, "base\n")
+        write_text_file(remote_update_root / relative_file, "remote wins unless local_first applies\n")
+
+        context.bootstrap_config_dir(conf_seed)
+        self._write_config(conf_seed / "config", seed_root)
+
+        context.bootstrap_config_dir(conf_local)
+        self._write_config(conf_local / "config", local_root)
+
+        context.bootstrap_config_dir(conf_remote)
+        self._write_config(conf_remote / "config", remote_update_root)
+
+        context.bootstrap_config_dir(conf_verify)
+        self._write_config(conf_verify / "config", verify_root)
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        download_stdout = case_log_dir / "download_stdout.log"
+        download_stderr = case_log_dir / "download_stderr.log"
+        remote_stdout = case_log_dir / "remote_update_stdout.log"
+        remote_stderr = case_log_dir / "remote_update_stderr.log"
+        final_stdout = case_log_dir / "final_sync_stdout.log"
+        final_stderr = case_log_dir / "final_sync_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--upload-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_seed),
+        ]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+
+        download_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_local),
+        ]
+        context.log(f"Executing Test Case {self.case_id} download: {command_to_string(download_command)}")
+        download_result = run_command(download_command, cwd=context.repo_root)
+        write_text_file(download_stdout, download_result.stdout)
+        write_text_file(download_stderr, download_result.stderr)
+
+        remote_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--upload-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_remote),
+        ]
+        context.log(f"Executing Test Case {self.case_id} remote update: {command_to_string(remote_command)}")
+        remote_result = run_command(remote_command, cwd=context.repo_root)
+        write_text_file(remote_stdout, remote_result.stdout)
+        write_text_file(remote_stderr, remote_result.stderr)
+
+        # Ensure the local edit is definitively later than the remote update.
+        # This is critical so the final sync actually exercises local_first.
+        time.sleep(2)
+
+        local_file = local_root / relative_file
+        expected = "local wins because local_first is enabled\n"
+        write_text_file(local_file, expected)
+
+        now = time.time()
+        os.utime(local_file, (now, now))
+
+        # Reuse the same local DB / delta state, but enable local_first
+        self._write_config(conf_local / "config", local_root, local_first=True)
+
+        final_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_local),
+        ]
+        context.log(f"Executing Test Case {self.case_id} final sync: {command_to_string(final_command)}")
+        final_result = run_command(final_command, cwd=context.repo_root)
+        write_text_file(final_stdout, final_result.stdout)
+        write_text_file(final_stderr, final_result.stderr)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+
+        local_content = (local_root / relative_file).read_text(encoding="utf-8") if (local_root / relative_file).is_file() else ""
+        remote_content = (verify_root / relative_file).read_text(encoding="utf-8") if (verify_root / relative_file).is_file() else ""
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"root_name={root_name}",
+                    f"seed_root={seed_root}",
+                    f"local_root={local_root}",
+                    f"remote_update_root={remote_update_root}",
+                    f"verify_root={verify_root}",
+                    f"seed_confdir={conf_seed}",
+                    f"local_confdir={conf_local}",
+                    f"remote_confdir={conf_remote}",
+                    f"verify_confdir={conf_verify}",
+                    f"seed_returncode={seed_result.returncode}",
+                    f"download_returncode={download_result.returncode}",
+                    f"remote_returncode={remote_result.returncode}",
+                    f"final_returncode={final_result.returncode}",
+                    f"verify_returncode={verify_result.returncode}",
+                    f"local_content={local_content!r}",
+                    f"remote_content={remote_content!r}",
+                    f"local_mtime={local_file.stat().st_mtime if local_file.exists() else 0}",
+                ]
+            )
+            + "\n",
+        )
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(download_stdout),
+            str(download_stderr),
+            str(remote_stdout),
+            str(remote_stderr),
+            str(final_stdout),
+            str(final_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(remote_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "seed_returncode": seed_result.returncode,
+            "download_returncode": download_result.returncode,
+            "remote_returncode": remote_result.returncode,
+            "final_returncode": final_result.returncode,
+            "verify_returncode": verify_result.returncode,
+            "root_name": root_name,
+        }
+
+        for label, rc in [
+            ("seed", seed_result.returncode),
+            ("download", download_result.returncode),
+            ("remote update", remote_result.returncode),
+            ("final sync", final_result.returncode),
+            ("verify", verify_result.returncode),
+        ]:
+            if rc != 0:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"{label} phase failed with status {rc}",
+                    artifacts,
+                    details,
+                )
+
+        if local_content != expected:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Local content was not retained after conflict resolution with local_first enabled",
+                artifacts,
+                details,
+            )
+
+        if remote_content != expected:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Remote content did not converge to the local source-of-truth content when local_first was enabled",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0023_bypass_data_preservation_validation.py b/ci/e2e/testcases/tc0023_bypass_data_preservation_validation.py
new file mode 100644
index 000000000..cd296296c
--- /dev/null
+++ b/ci/e2e/testcases/tc0023_bypass_data_preservation_validation.py
@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0023BypassDataPreservationValidation(E2ETestCase):
+    case_id = "0023"
+    name = "bypass_data_preservation validation"
+    description = "Validate that bypass_data_preservation suppresses safe-backup preservation during resync conflict resolution"
+
+    def _write_config(self, config_path: Path, sync_dir: Path, bypass_data_preservation: bool = False) -> None:
+        content = (
+            "# tc0023 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+        )
+        if bypass_data_preservation:
+            content += 'bypass_data_preservation = "true"\n'
+        write_onedrive_config(config_path, content)
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0023",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        seed_root = case_work_dir / "seedroot"
+        local_root = case_work_dir / "localroot"
+
+        conf_seed = case_work_dir / "conf-seed"
+        conf_local = case_work_dir / "conf-local"
+
+        root_name = f"ZZ_E2E_TC0023_{context.run_id}_{os.getpid()}"
+        relative_file = f"{root_name}/conflict.txt"
+
+        reset_directory(seed_root)
+        reset_directory(local_root)
+
+        original_remote_content = "base\n"
+        local_conflicting_content = "local conflicting content\n"
+
+        # Seed the remote with the original content
+        write_text_file(seed_root / relative_file, original_remote_content)
+
+        context.bootstrap_config_dir(conf_seed)
+        self._write_config(conf_seed / "config", seed_root)
+
+        context.bootstrap_config_dir(conf_local)
+        self._write_config(conf_local / "config", local_root)
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        download_stdout = case_log_dir / "download_stdout.log"
+        download_stderr = case_log_dir / "download_stderr.log"
+        final_stdout = case_log_dir / "final_sync_stdout.log"
+        final_stderr = case_log_dir / "final_sync_stderr.log"
+        metadata_file = state_dir / "metadata.txt"
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--upload-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_seed),
+        ]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+
+        download_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_local),
+        ]
+        context.log(f"Executing Test Case {self.case_id} download: {command_to_string(download_command)}")
+        download_result = run_command(download_command, cwd=context.repo_root)
+        write_text_file(download_stdout, download_result.stdout)
+        write_text_file(download_stderr, download_result.stderr)
+
+        local_file = local_root / relative_file
+        if not local_file.is_file():
+            artifacts = [
+                str(seed_stdout),
+                str(seed_stderr),
+                str(download_stdout),
+                str(download_stderr),
+            ]
+            details = {
+                "seed_returncode": seed_result.returncode,
+                "download_returncode": download_result.returncode,
+                "root_name": root_name,
+            }
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Initial download phase did not create the expected local file",
+                artifacts,
+                details,
+            )
+
+        initial_local_content = local_file.read_text(encoding="utf-8")
+        if initial_local_content != original_remote_content:
+            artifacts = [
+                str(seed_stdout),
+                str(seed_stderr),
+                str(download_stdout),
+                str(download_stderr),
+            ]
+            details = {
+                "seed_returncode": seed_result.returncode,
+                "download_returncode": download_result.returncode,
+                "root_name": root_name,
+                "initial_local_content": initial_local_content,
+            }
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Initial download phase did not produce the expected baseline file content",
+                artifacts,
+                details,
+            )
+
+        # Ensure the local conflicting edit has a clearly newer local timestamp.
+        # This helps force the resync path to treat the local file as modified
+        # relative to the unchanged online copy.
+        time.sleep(2)
+        write_text_file(local_file, local_conflicting_content)
+        os.utime(local_file, None)
+
+        # Re-write the local config to enable bypass behaviour. The final sync
+        # must use --resync so the known local DB state is discarded and the
+        # client evaluates the local modified file against the existing remote file.
+        self._write_config(conf_local / "config", local_root, bypass_data_preservation=True)
+
+        final_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_local),
+        ]
+        context.log(f"Executing Test Case {self.case_id} final sync: {command_to_string(final_command)}")
+        final_result = run_command(final_command, cwd=context.repo_root)
+        write_text_file(final_stdout, final_result.stdout)
+        write_text_file(final_stderr, final_result.stderr)
+
+        final_local_content = local_file.read_text(encoding="utf-8") if local_file.is_file() else ""
+
+        safe_backup_files = sorted(
+            str(path.relative_to(local_root))
+            for path in local_root.rglob("*safeBackup*")
+            if path.is_file()
+        )
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"root_name={root_name}",
+                    f"seed_root={seed_root}",
+                    f"local_root={local_root}",
+                    f"seed_confdir={conf_seed}",
+                    f"local_confdir={conf_local}",
+                    f"seed_returncode={seed_result.returncode}",
+                    f"download_returncode={download_result.returncode}",
+                    f"final_returncode={final_result.returncode}",
+                    f"initial_local_content={initial_local_content!r}",
+                    f"local_conflicting_content={local_conflicting_content!r}",
+                    f"final_local_content={final_local_content!r}",
+                    f"safe_backup_files={safe_backup_files!r}",
+                ]
+            )
+            + "\n",
+        )
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(download_stdout),
+            str(download_stderr),
+            str(final_stdout),
+            str(final_stderr),
+            str(metadata_file),
+        ]
+        details = {
+            "seed_returncode": seed_result.returncode,
+            "download_returncode": download_result.returncode,
+            "final_returncode": final_result.returncode,
+            "root_name": root_name,
+            "safe_backup_count": len(safe_backup_files),
+        }
+
+        for label, rc in [
+            ("seed", seed_result.returncode),
+            ("download", download_result.returncode),
+            ("final sync", final_result.returncode),
+        ]:
+            if rc != 0:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"{label} phase failed with status {rc}",
+                    artifacts,
+                    details,
+                )
+
+        # With bypass_data_preservation enabled, the unchanged online version
+        # should overwrite the locally modified file during the resync.
+        if final_local_content != original_remote_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Local content was not overwritten by the remote file when bypass_data_preservation was enabled",
+                artifacts,
+                details,
+            )
+
+        if safe_backup_files:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Safe-backup files were created despite bypass_data_preservation being enabled",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0024_big_delete_safeguard_validation.py b/ci/e2e/testcases/tc0024_big_delete_safeguard_validation.py
new file mode 100644
index 000000000..77267e662
--- /dev/null
+++ b/ci/e2e/testcases/tc0024_big_delete_safeguard_validation.py
@@ -0,0 +1,524 @@
+from __future__ import annotations
+
+import os
+import shutil
+import time
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0024BigDeleteSafeguardValidation(E2ETestCase):
+    case_id = "0024"
+    name = "big delete safeguard validation"
+    description = "Validate classify_as_big_delete protection and forced acknowledgement via --force"
+
+    def _write_config(
+        self,
+        config_path: Path,
+        sync_dir: Path,
+        classify_as_big_delete: int,
+    ) -> None:
+        config_lines = [
+            "# tc0024 config",
+            f'sync_dir = "{sync_dir}"',
+            f'classify_as_big_delete = "{classify_as_big_delete}"',
+        ]
+        write_onedrive_config(config_path, "\n".join(config_lines) + "\n")
+
+    def _run_and_capture(
+        self,
+        context: E2EContext,
+        label: str,
+        command: list[str],
+        stdout_file: Path,
+        stderr_file: Path,
+    ):
+        context.log(f"Executing Test Case {self.case_id} {label}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+        return result
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0024",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        local_root = case_work_dir / "localroot"
+        verify_root = case_work_dir / "verifyroot"
+
+        conf_local = case_work_dir / "conf-local"
+        conf_verify = case_work_dir / "conf-verify"
+
+        reset_directory(local_root)
+        reset_directory(verify_root)
+
+        context.bootstrap_config_dir(conf_local)
+        context.bootstrap_config_dir(conf_verify)
+
+        parent_dir_name = "random_1K_files"
+        initial_threshold = 1000
+        classify_threshold = 5
+        sibling_dir_count = 10
+        files_per_dir = 10
+        delete_dir_index = 2
+        keep_dir_index = 7
+
+        dir_names = [
+            "q0NToXSgyrO8R5XO9t3jkzmVfEu4WCVh",
+            "RlWYV0dKiI096pt5F9eXg6jGZGUejI30",
+            "70M1EMwQUqzzQU4c8ua7C4DVvzo7KUWO",
+            "9systOMPHWQ7TozssIbYZFPGgPhQA9vt",
+            "ilmjoysWYI1EnbLscBmYxc5H9ikqLZ4Z",
+            "ZNZnjOCA83dutD8d3SD6j87CGeYMnCMH",
+            "qtkaQHpZcMbM7GJnNUBfBwJ4YLxfmxp3",
+            "YwTfxsBmSgSaCS39vpgEswNU27wJcogI",
+            "oWvTo5vd9rLJI3KB1RErqAH8fy4sjQjp",
+            "aUmMwbQVWImEHEr555QyHqHveKMT0XGJ",
+        ]
+
+        delete_dir_name = dir_names[delete_dir_index]
+        keep_dir_name = dir_names[keep_dir_index]
+
+        delete_dir_relative = f"{parent_dir_name}/{delete_dir_name}"
+        keep_file_relative = f"{parent_dir_name}/{keep_dir_name}/file0.data"
+
+        remote_delete_dir = delete_dir_relative
+        remote_deleted_probe_file = f"{delete_dir_relative}/file0.data"
+        remote_keep_file = keep_file_relative
+
+        delete_dir_local = local_root / parent_dir_name / delete_dir_name
+
+        for dir_name in dir_names:
+            child_dir = local_root / parent_dir_name / dir_name
+            for file_index in range(files_per_dir):
+                write_text_file(
+                    child_dir / f"file{file_index}.data",
+                    f"tc0024 dir={dir_name} file={file_index}\n",
+                )
+
+        self._write_config(conf_local / "config", local_root, initial_threshold)
+        self._write_config(conf_verify / "config", verify_root, classify_threshold)
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+
+        option_change_stdout = case_log_dir / "option_change_stdout.log"
+        option_change_stderr = case_log_dir / "option_change_stderr.log"
+
+        blocked_stdout = case_log_dir / "blocked_stdout.log"
+        blocked_stderr = case_log_dir / "blocked_stderr.log"
+
+        blocked_verify_stdout = case_log_dir / "blocked_verify_stdout.log"
+        blocked_verify_stderr = case_log_dir / "blocked_verify_stderr.log"
+
+        forced_stdout = case_log_dir / "forced_stdout.log"
+        forced_stderr = case_log_dir / "forced_stderr.log"
+
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_retry_manifest_file = state_dir / "remote_verify_retry_manifest.txt"
+
+        blocked_verify_manifest_file = state_dir / "blocked_verify_manifest.txt"
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        residual_deleted_paths_file = state_dir / "residual_deleted_paths.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--upload-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(conf_local),
+        ]
+        seed_result = self._run_and_capture(
+            context,
+            "seed",
+            seed_command,
+            seed_stdout,
+            seed_stderr,
+        )
+
+        if seed_result.returncode != 0:
+            artifacts = [str(seed_stdout), str(seed_stderr)]
+            details = {"seed_returncode": seed_result.returncode}
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed phase failed with status {seed_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        self._write_config(conf_local / "config", local_root, classify_threshold)
+
+        option_change_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(conf_local),
+        ]
+        option_change_result = self._run_and_capture(
+            context,
+            "option change validation",
+            option_change_command,
+            option_change_stdout,
+            option_change_stderr,
+        )
+
+        if option_change_result.returncode != 0:
+            artifacts = [
+                str(seed_stdout),
+                str(seed_stderr),
+                str(option_change_stdout),
+                str(option_change_stderr),
+            ]
+            details = {
+                "seed_returncode": seed_result.returncode,
+                "option_change_returncode": option_change_result.returncode,
+            }
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"option change validation phase failed with status {option_change_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not delete_dir_local.is_dir():
+            artifacts = [
+                str(seed_stdout),
+                str(seed_stderr),
+                str(option_change_stdout),
+                str(option_change_stderr),
+            ]
+            details = {
+                "seed_returncode": seed_result.returncode,
+                "option_change_returncode": option_change_result.returncode,
+                "delete_dir_local": str(delete_dir_local),
+            }
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Expected local delete directory was not present before delete phase",
+                artifacts,
+                details,
+            )
+
+        shutil.rmtree(delete_dir_local)
+
+        blocked_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(conf_local),
+        ]
+        blocked_result = self._run_and_capture(
+            context,
+            "blocked sync",
+            blocked_command,
+            blocked_stdout,
+            blocked_stderr,
+        )
+
+        blocked_output = blocked_result.stdout + "\n" + blocked_result.stderr
+
+        reset_directory(verify_root)
+        self._write_config(conf_verify / "config", verify_root, classify_threshold)
+
+        blocked_verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(conf_verify),
+        ]
+        blocked_verify_result = self._run_and_capture(
+            context,
+            "blocked verify",
+            blocked_verify_command,
+            blocked_verify_stdout,
+            blocked_verify_stderr,
+        )
+
+        blocked_remote_manifest = build_manifest(verify_root)
+        write_manifest(blocked_verify_manifest_file, blocked_remote_manifest)
+
+        delete_dir_recreated_before_force = delete_dir_local.exists()
+        if delete_dir_recreated_before_force:
+            if delete_dir_local.is_dir():
+                shutil.rmtree(delete_dir_local)
+            else:
+                delete_dir_local.unlink()
+
+        forced_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--force",
+            "--confdir",
+            str(conf_local),
+        ]
+        forced_result = self._run_and_capture(
+            context,
+            "forced sync",
+            forced_command,
+            forced_stdout,
+            forced_stderr,
+        )
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(conf_verify),
+        ]
+
+        verify_attempts = 0
+        verify_result = None
+        remote_manifest: list[str] = []
+        residual_deleted_paths: list[str] = []
+
+        max_verify_attempts = 6
+        verify_retry_sleep_seconds = 20
+
+        for attempt in range(1, max_verify_attempts + 1):
+            verify_attempts = attempt
+            reset_directory(verify_root)
+            self._write_config(conf_verify / "config", verify_root, classify_threshold)
+
+            attempt_stdout = verify_stdout if attempt == 1 else case_log_dir / f"verify_retry_{attempt}_stdout.log"
+            attempt_stderr = verify_stderr if attempt == 1 else case_log_dir / f"verify_retry_{attempt}_stderr.log"
+
+            verify_result = self._run_and_capture(
+                context,
+                "verify" if attempt == 1 else f"verify retry {attempt}",
+                verify_command,
+                attempt_stdout,
+                attempt_stderr,
+            )
+
+            remote_manifest = build_manifest(verify_root)
+            residual_deleted_paths = [
+                path for path in remote_manifest
+                if path == remote_delete_dir or path.startswith(remote_delete_dir + "/")
+            ]
+
+            if attempt == 1:
+                write_manifest(remote_manifest_file, remote_manifest)
+            else:
+                write_manifest(verify_retry_manifest_file, remote_manifest)
+
+            write_manifest(residual_deleted_paths_file, residual_deleted_paths)
+
+            if verify_result.returncode != 0:
+                break
+
+            # Personal OneDrive can expose an empty parent directory briefly after
+            # the forced delete has completed. The authoritative condition for this
+            # testcase is that no deleted child content remains. A lingering empty
+            # directory is treated as backend visibility lag, not as failed deletion.
+            residual_child_paths = [
+                path for path in residual_deleted_paths
+                if path.startswith(remote_delete_dir + "/")
+            ]
+
+            if not residual_child_paths:
+                break
+
+            if attempt < max_verify_attempts:
+                context.log(
+                    f"Test Case {self.case_id} final verify still sees deleted child content "
+                    f"after forced delete; retrying final verification in {verify_retry_sleep_seconds} seconds "
+                    f"(attempt {attempt}/{max_verify_attempts}). "
+                    f"Residual deleted paths: {residual_deleted_paths}"
+                )
+                time.sleep(verify_retry_sleep_seconds)
+
+        assert verify_result is not None
+
+        write_manifest(remote_manifest_file, remote_manifest)
+        write_manifest(residual_deleted_paths_file, residual_deleted_paths)
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"local_root={local_root}",
+                    f"verify_root={verify_root}",
+                    f"local_confdir={conf_local}",
+                    f"verify_confdir={conf_verify}",
+                    f"initial_threshold={initial_threshold}",
+                    f"classify_as_big_delete={classify_threshold}",
+                    f"parent_dir_name={parent_dir_name}",
+                    f"sibling_dir_count={sibling_dir_count}",
+                    f"files_per_dir={files_per_dir}",
+                    f"delete_dir_relative={delete_dir_relative}",
+                    f"keep_file_relative={keep_file_relative}",
+                    f"remote_delete_dir={remote_delete_dir}",
+                    f"remote_deleted_probe_file={remote_deleted_probe_file}",
+                    f"remote_keep_file={remote_keep_file}",
+                    f"delete_dir_recreated_before_force={delete_dir_recreated_before_force}",
+                    f"seed_returncode={seed_result.returncode}",
+                    f"option_change_returncode={option_change_result.returncode}",
+                    f"blocked_returncode={blocked_result.returncode}",
+                    f"blocked_verify_returncode={blocked_verify_result.returncode}",
+                    f"forced_returncode={forced_result.returncode}",
+                    f"verify_returncode={verify_result.returncode}",
+                    f"verify_attempts={verify_attempts}",
+                    f"max_verify_attempts={max_verify_attempts}",
+                    f"verify_retry_sleep_seconds={verify_retry_sleep_seconds}",
+                    f"residual_deleted_paths_count={len(residual_deleted_paths)}",
+                    f"residual_deleted_paths_file={residual_deleted_paths_file}",
+                ]
+            )
+            + "\n",
+        )
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(option_change_stdout),
+            str(option_change_stderr),
+            str(blocked_stdout),
+            str(blocked_stderr),
+            str(blocked_verify_stdout),
+            str(blocked_verify_stderr),
+            str(forced_stdout),
+            str(forced_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(blocked_verify_manifest_file),
+            str(remote_manifest_file),
+            str(verify_retry_manifest_file),
+            str(residual_deleted_paths_file),
+            str(metadata_file),
+        ]
+        details = {
+            "seed_returncode": seed_result.returncode,
+            "option_change_returncode": option_change_result.returncode,
+            "blocked_returncode": blocked_result.returncode,
+            "blocked_verify_returncode": blocked_verify_result.returncode,
+            "forced_returncode": forced_result.returncode,
+            "verify_returncode": verify_result.returncode,
+            "verify_attempts": verify_attempts,
+            "residual_deleted_paths_count": len(residual_deleted_paths),
+        }
+
+        for label, rc in [
+            ("blocked verify", blocked_verify_result.returncode),
+            ("forced sync", forced_result.returncode),
+            ("verify", verify_result.returncode),
+        ]:
+            if rc != 0:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"{label} phase failed with status {rc}",
+                    artifacts,
+                    details,
+                )
+
+        safeguard_markers = [
+            "ERROR: An attempt to remove a large volume of data from OneDrive has been detected",
+            "ERROR: The total number of items being deleted is:",
+            "ERROR: To delete a large volume of data use --force",
+        ]
+        if not all(marker in blocked_output for marker in safeguard_markers):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Blocked sync did not emit the expected big delete safeguard warning",
+                artifacts,
+                details,
+            )
+
+        if remote_delete_dir not in blocked_remote_manifest:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Remote delete directory was modified before forced acknowledgement",
+                artifacts,
+                details,
+            )
+
+        if remote_deleted_probe_file not in blocked_remote_manifest:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"{remote_deleted_probe_file} was modified before forced acknowledgement",
+                artifacts,
+                details,
+            )
+
+        if remote_keep_file not in blocked_remote_manifest:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Keep content disappeared during blocked safeguard processing",
+                artifacts,
+                details,
+            )
+
+        residual_child_paths = [
+            path for path in residual_deleted_paths
+            if path.startswith(remote_delete_dir + "/")
+        ]
+
+        if residual_child_paths:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Deleted child content still exists online after acknowledged forced delete",
+                artifacts,
+                details,
+            )
+
+        if remote_deleted_probe_file in remote_manifest:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"{remote_deleted_probe_file} still exists online after acknowledged forced delete",
+                artifacts,
+                details,
+            )
+
+        if remote_keep_file not in remote_manifest:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Keep content disappeared during big delete safeguard processing",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0025_invalid_character_filename_validation.py b/ci/e2e/testcases/tc0025_invalid_character_filename_validation.py
new file mode 100644
index 000000000..4ecaf0c75
--- /dev/null
+++ b/ci/e2e/testcases/tc0025_invalid_character_filename_validation.py
@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0025InvalidCharacterFilenameValidation(E2ETestCase):
+    case_id = "0025"
+    name = "invalid character filename validation"
+    description = "Validate invalid filename characters are blocked while valid sibling files still synchronise"
+
+    def _write_config(self, config_path: Path, sync_dir: Path) -> None:
+        write_onedrive_config(
+            config_path,
+            "\n".join(
+                [
+                    "# tc0025 config",
+                    f'sync_dir = "{sync_dir}"',
+                    'bypass_data_preservation = "true"',
+                    'classify_as_big_delete = "1000"',
+                ]
+            )
+            + "\n",
+        )
+
+    def _create_binary_file(self, path: Path, size_kb: int = 8) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        payload = os.urandom(size_kb * 1024)
+        path.write_bytes(payload)
+
+    def _run_and_capture(
+        self,
+        context: E2EContext,
+        label: str,
+        command: list[str],
+        stdout_file: Path,
+        stderr_file: Path,
+    ):
+        context.log(f"Executing Test Case {self.case_id} {label}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+        return result
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0025",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        confdir = case_work_dir / "conf-main"
+        verify_conf = case_work_dir / "conf-verify"
+
+        reset_directory(sync_root)
+        reset_directory(verify_root)
+
+        context.bootstrap_config_dir(confdir)
+        context.bootstrap_config_dir(verify_conf)
+
+        self._write_config(confdir / "config", sync_root)
+        self._write_config(verify_conf / "config", verify_root)
+
+        root_name = f"ZZ_E2E_TC0025_{context.run_id}_{os.getpid()}"
+
+        valid_files = [
+            f"{root_name}/valid_file_1.bin",
+            f"{root_name}/valid_file_2.txt",
+            f"{root_name}/valid_subdir/nested_valid_file.dat",
+        ]
+
+        invalid_files = [
+            f"{root_name}/includes < in the filename",
+            f"{root_name}/includes > in the filename",
+            f'{root_name}/includes " in the filename',
+            f"{root_name}/includes | in the filename",
+            f"{root_name}/includes ? in the filename",
+            f"{root_name}/includes * in the filename",
+        ]
+
+        for rel_path in valid_files + invalid_files:
+            self._create_binary_file(sync_root / rel_path, size_kb=8)
+
+        initial_stdout = case_log_dir / "initial_sync_stdout.log"
+        initial_stderr = case_log_dir / "initial_sync_stderr.log"
+
+        second_stdout = case_log_dir / "second_sync_stdout.log"
+        second_stderr = case_log_dir / "second_sync_stderr.log"
+
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        initial_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(confdir),
+        ]
+        initial_result = self._run_and_capture(
+            context,
+            "initial sync",
+            initial_command,
+            initial_stdout,
+            initial_stderr,
+        )
+
+        second_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(confdir),
+        ]
+        second_result = self._run_and_capture(
+            context,
+            "second sync",
+            second_command,
+            second_stdout,
+            second_stderr,
+        )
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(verify_conf),
+        ]
+        verify_result = self._run_and_capture(
+            context,
+            "remote verify",
+            verify_command,
+            verify_stdout,
+            verify_stderr,
+        )
+
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+
+        combined_output = (
+            initial_result.stdout
+            + "\n"
+            + initial_result.stderr
+            + "\n"
+            + second_result.stdout
+            + "\n"
+            + second_result.stderr
+        )
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"root_name={root_name}",
+                    f"initial_returncode={initial_result.returncode}",
+                    f"second_returncode={second_result.returncode}",
+                    f"verify_returncode={verify_result.returncode}",
+                    f"valid_files={valid_files!r}",
+                    f"invalid_files={invalid_files!r}",
+                ]
+            )
+            + "\n",
+        )
+
+        artifacts = [
+            str(initial_stdout),
+            str(initial_stderr),
+            str(second_stdout),
+            str(second_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(remote_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "initial_returncode": initial_result.returncode,
+            "second_returncode": second_result.returncode,
+            "verify_returncode": verify_result.returncode,
+            "root_name": root_name,
+        }
+
+        for label, rc in [
+            ("initial sync", initial_result.returncode),
+            ("second sync", second_result.returncode),
+            ("remote verification", verify_result.returncode),
+        ]:
+            if rc != 0:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"{label} failed with status {rc}",
+                    artifacts,
+                    details,
+                )
+
+        for expected in valid_files:
+            if expected not in remote_manifest:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Expected valid file missing remotely: {expected}",
+                    artifacts,
+                    details,
+                )
+
+        for unwanted in invalid_files:
+            if unwanted in remote_manifest:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Invalid filename was synchronised remotely: {unwanted}",
+                    artifacts,
+                    details,
+                )
+
+        expected_skip_markers = [
+            'Skipping item - invalid name (Microsoft Naming Convention): ./'
+            + f"{root_name}/includes < in the filename",
+            'Skipping item - invalid name (Microsoft Naming Convention): ./'
+            + f"{root_name}/includes > in the filename",
+            'Skipping item - invalid name (Microsoft Naming Convention): ./'
+            + f'{root_name}/includes " in the filename',
+            'Skipping item - invalid name (Microsoft Naming Convention): ./'
+            + f"{root_name}/includes | in the filename",
+            'Skipping item - invalid name (Microsoft Naming Convention): ./'
+            + f"{root_name}/includes ? in the filename",
+            'Skipping item - invalid name (Microsoft Naming Convention): ./'
+            + f"{root_name}/includes * in the filename",
+        ]
+        for marker in expected_skip_markers:
+            if marker not in combined_output:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Expected invalid filename skip marker not found: {marker}",
+                    artifacts,
+                    details,
+                )
+
+        crash_markers = [
+            "Segmentation fault",
+            "Traceback",
+            "core dumped",
+            "std.conv.ConvException",
+            "std.utf.UTFException",
+        ]
+        for marker in crash_markers:
+            if marker in combined_output:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Client output indicates crash or exception: {marker}",
+                    artifacts,
+                    details,
+                )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0026_reserved_device_name_validation.py b/ci/e2e/testcases/tc0026_reserved_device_name_validation.py
new file mode 100644
index 000000000..441400dd5
--- /dev/null
+++ b/ci/e2e/testcases/tc0026_reserved_device_name_validation.py
@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0026ReservedDeviceNameValidation(E2ETestCase):
+    case_id = "0026"
+    name = "reserved device name validation"
+    description = "Validate reserved Windows device names are blocked while valid lookalike names still synchronise"
+
+    def _write_config(self, config_path: Path, sync_dir: Path) -> None:
+        write_onedrive_config(
+            config_path,
+            "\n".join(
+                [
+                    "# tc0026 config",
+                    f'sync_dir = "{sync_dir}"',
+                    'bypass_data_preservation = "true"',
+                    'classify_as_big_delete = "1000"',
+                ]
+            )
+            + "\n",
+        )
+
+    def _create_binary_file(self, path: Path, size_kb: int = 8) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        payload = os.urandom(size_kb * 1024)
+        path.write_bytes(payload)
+
+    def _run_and_capture(
+        self,
+        context: E2EContext,
+        label: str,
+        command: list[str],
+        stdout_file: Path,
+        stderr_file: Path,
+    ):
+        context.log(f"Executing Test Case {self.case_id} {label}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+        return result
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0026",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        confdir = case_work_dir / "conf-main"
+        verify_conf = case_work_dir / "conf-verify"
+
+        reset_directory(sync_root)
+        reset_directory(verify_root)
+
+        context.bootstrap_config_dir(confdir)
+        context.bootstrap_config_dir(verify_conf)
+
+        self._write_config(confdir / "config", sync_root)
+        self._write_config(verify_conf / "config", verify_root)
+
+        root_name = f"ZZ_E2E_TC0026_{context.run_id}_{os.getpid()}"
+
+        valid_files = [
+            f"{root_name}/HelloCOM2.rar",
+            f"{root_name}/Report_CON_v2.txt",
+            f"{root_name}/LPT_notes.txt",
+            f"{root_name}/valid_subdir/nested_valid_file.dat",
+        ]
+
+        invalid_files = [
+            f"{root_name}/CON",
+            f"{root_name}/CON.text",
+            f"{root_name}/PRN",
+            f"{root_name}/AUX",
+            f"{root_name}/NUL",
+            f"{root_name}/COM1",
+            f"{root_name}/COM2",
+            f"{root_name}/COM3",
+            f"{root_name}/COM9",
+            f"{root_name}/LPT1",
+            f"{root_name}/LPT2",
+            f"{root_name}/LPT9",
+        ]
+
+        for rel_path in valid_files + invalid_files:
+            self._create_binary_file(sync_root / rel_path, size_kb=8)
+
+        initial_stdout = case_log_dir / "initial_sync_stdout.log"
+        initial_stderr = case_log_dir / "initial_sync_stderr.log"
+
+        second_stdout = case_log_dir / "second_sync_stdout.log"
+        second_stderr = case_log_dir / "second_sync_stderr.log"
+
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        initial_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(confdir),
+        ]
+        initial_result = self._run_and_capture(
+            context,
+            "initial sync",
+            initial_command,
+            initial_stdout,
+            initial_stderr,
+        )
+
+        second_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(confdir),
+        ]
+        second_result = self._run_and_capture(
+            context,
+            "second sync",
+            second_command,
+            second_stdout,
+            second_stderr,
+        )
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(verify_conf),
+        ]
+        verify_result = self._run_and_capture(
+            context,
+            "remote verify",
+            verify_command,
+            verify_stdout,
+            verify_stderr,
+        )
+
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+
+        combined_output = (
+            initial_result.stdout
+            + "\n"
+            + initial_result.stderr
+            + "\n"
+            + second_result.stdout
+            + "\n"
+            + second_result.stderr
+        )
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"root_name={root_name}",
+                    f"initial_returncode={initial_result.returncode}",
+                    f"second_returncode={second_result.returncode}",
+                    f"verify_returncode={verify_result.returncode}",
+                    f"valid_files={valid_files!r}",
+                    f"invalid_files={invalid_files!r}",
+                ]
+            )
+            + "\n",
+        )
+
+        artifacts = [
+            str(initial_stdout),
+            str(initial_stderr),
+            str(second_stdout),
+            str(second_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(remote_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "initial_returncode": initial_result.returncode,
+            "second_returncode": second_result.returncode,
+            "verify_returncode": verify_result.returncode,
+            "root_name": root_name,
+        }
+
+        for label, rc in [
+            ("initial sync", initial_result.returncode),
+            ("second sync", second_result.returncode),
+            ("remote verification", verify_result.returncode),
+        ]:
+            if rc != 0:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"{label} failed with status {rc}",
+                    artifacts,
+                    details,
+                )
+
+        for expected in valid_files:
+            if expected not in remote_manifest:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Expected valid file missing remotely: {expected}",
+                    artifacts,
+                    details,
+                )
+
+        for unwanted in invalid_files:
+            if unwanted in remote_manifest:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Reserved device name was synchronised remotely: {unwanted}",
+                    artifacts,
+                    details,
+                )
+
+        expected_skip_markers = [
+            'Skipping item - invalid name (Microsoft Naming Convention): ./' + item
+            for item in invalid_files
+        ]
+        for marker in expected_skip_markers:
+            if marker not in combined_output:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Expected reserved-name skip marker not found: {marker}",
+                    artifacts,
+                    details,
+                )
+
+        crash_markers = [
+            "Segmentation fault",
+            "Traceback",
+            "core dumped",
+            "std.conv.ConvException",
+            "std.utf.UTFException",
+        ]
+        for marker in crash_markers:
+            if marker in combined_output:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Client output indicates crash or exception: {marker}",
+                    artifacts,
+                    details,
+                )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0027_whitespace_trailing_dot_validation.py b/ci/e2e/testcases/tc0027_whitespace_trailing_dot_validation.py
new file mode 100644
index 000000000..63afea501
--- /dev/null
+++ b/ci/e2e/testcases/tc0027_whitespace_trailing_dot_validation.py
@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0027WhitespaceTrailingDotValidation(E2ETestCase):
+    case_id = "0027"
+    name = "whitespace and trailing dot validation"
+    description = "Validate trailing whitespace and trailing dot names are blocked while valid sibling files still synchronise"
+
+    def _write_config(self, config_path: Path, sync_dir: Path) -> None:
+        write_onedrive_config(
+            config_path,
+            "\n".join(
+                [
+                    "# tc0027 config",
+                    f'sync_dir = "{sync_dir}"',
+                    'bypass_data_preservation = "true"',
+                    'classify_as_big_delete = "1000"',
+                ]
+            )
+            + "\n",
+        )
+
+    def _create_binary_file(self, path: Path, size_kb: int = 8) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        payload = os.urandom(size_kb * 1024)
+        path.write_bytes(payload)
+
+    def _run_and_capture(
+        self,
+        context: E2EContext,
+        label: str,
+        command: list[str],
+        stdout_file: Path,
+        stderr_file: Path,
+    ):
+        context.log(f"Executing Test Case {self.case_id} {label}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+        return result
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0027",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        confdir = case_work_dir / "conf-main"
+        verify_conf = case_work_dir / "conf-verify"
+
+        reset_directory(sync_root)
+        reset_directory(verify_root)
+
+        context.bootstrap_config_dir(confdir)
+        context.bootstrap_config_dir(verify_conf)
+
+        self._write_config(confdir / "config", sync_root)
+        self._write_config(verify_conf / "config", verify_root)
+
+        root_name = f"ZZ_E2E_TC0027_{context.run_id}_{os.getpid()}"
+
+        valid_files = [
+            f"{root_name}/valid_file_1.bin",
+            f"{root_name}/middle space valid.txt",
+            f"{root_name}/name.with.periods.txt",
+            f"{root_name}/valid_subdir/nested_valid_file.dat",
+        ]
+
+        invalid_files = [
+            f"{root_name}/trailing-space.txt ",
+            f"{root_name}/trailing-dot.txt.",
+            f"{root_name}/trailing-space-dir /child.txt",
+            f"{root_name}/trailing-dot-dir./child.txt",
+        ]
+
+        for rel_path in valid_files + invalid_files:
+            self._create_binary_file(sync_root / rel_path, size_kb=8)
+
+        initial_stdout = case_log_dir / "initial_sync_stdout.log"
+        initial_stderr = case_log_dir / "initial_sync_stderr.log"
+
+        second_stdout = case_log_dir / "second_sync_stdout.log"
+        second_stderr = case_log_dir / "second_sync_stderr.log"
+
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        initial_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(confdir),
+        ]
+        initial_result = self._run_and_capture(
+            context,
+            "initial sync",
+            initial_command,
+            initial_stdout,
+            initial_stderr,
+        )
+
+        second_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(confdir),
+        ]
+        second_result = self._run_and_capture(
+            context,
+            "second sync",
+            second_command,
+            second_stdout,
+            second_stderr,
+        )
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(verify_conf),
+        ]
+        verify_result = self._run_and_capture(
+            context,
+            "remote verify",
+            verify_command,
+            verify_stdout,
+            verify_stderr,
+        )
+
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+
+        combined_output = (
+            initial_result.stdout
+            + "\n"
+            + initial_result.stderr
+            + "\n"
+            + second_result.stdout
+            + "\n"
+            + second_result.stderr
+        )
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"root_name={root_name}",
+                    f"initial_returncode={initial_result.returncode}",
+                    f"second_returncode={second_result.returncode}",
+                    f"verify_returncode={verify_result.returncode}",
+                    f"valid_files={valid_files!r}",
+                    f"invalid_files={invalid_files!r}",
+                ]
+            )
+            + "\n",
+        )
+
+        artifacts = [
+            str(initial_stdout),
+            str(initial_stderr),
+            str(second_stdout),
+            str(second_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(remote_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "initial_returncode": initial_result.returncode,
+            "second_returncode": second_result.returncode,
+            "verify_returncode": verify_result.returncode,
+            "root_name": root_name,
+        }
+
+        for label, rc in [
+            ("initial sync", initial_result.returncode),
+            ("second sync", second_result.returncode),
+            ("remote verification", verify_result.returncode),
+        ]:
+            if rc != 0:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"{label} failed with status {rc}",
+                    artifacts,
+                    details,
+                )
+
+        for expected in valid_files:
+            if expected not in remote_manifest:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Expected valid file missing remotely: {expected}",
+                    artifacts,
+                    details,
+                )
+
+        for unwanted in invalid_files:
+            if unwanted in remote_manifest:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Invalid whitespace or trailing dot name was synchronised remotely: {unwanted}",
+                    artifacts,
+                    details,
+                )
+
+        expected_skip_markers = [
+            'Skipping item - invalid name (Microsoft Naming Convention): ./'
+            + f"{root_name}/trailing-space.txt ",
+            'Skipping item - invalid name (Microsoft Naming Convention): ./'
+            + f"{root_name}/trailing-dot.txt.",
+            'Skipping item - invalid name (Microsoft Naming Convention): ./'
+            + f"{root_name}/trailing-space-dir ",
+            'Skipping item - invalid name (Microsoft Naming Convention): ./'
+            + f"{root_name}/trailing-dot-dir.",
+        ]
+        for marker in expected_skip_markers:
+            if marker not in combined_output:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Expected whitespace/trailing-dot skip marker not found: {marker}",
+                    artifacts,
+                    details,
+                )
+
+        disallowed_remote_failure_markers = [
+            "HTTP 400",
+            "The resource name is invalid",
+            "invalidRequest",
+        ]
+        for marker in disallowed_remote_failure_markers:
+            if marker in combined_output:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Client attempted remote invalid-name operation instead of local skip: {marker}",
+                    artifacts,
+                    details,
+                )
+
+        crash_markers = [
+            "Segmentation fault",
+            "Traceback",
+            "core dumped",
+            "std.conv.ConvException",
+            "std.utf.UTFException",
+        ]
+        for marker in crash_markers:
+            if marker in combined_output:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Client output indicates crash or exception: {marker}",
+                    artifacts,
+                    details,
+                )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0028_control_character_non_utf8_filename_validation.py b/ci/e2e/testcases/tc0028_control_character_non_utf8_filename_validation.py
new file mode 100644
index 000000000..8d4f8346e
--- /dev/null
+++ b/ci/e2e/testcases/tc0028_control_character_non_utf8_filename_validation.py
@@ -0,0 +1,387 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0028ControlCharacterNonUtf8FilenameValidation(E2ETestCase):
+    case_id = "0028"
+    name = "control character and non-UTF8 filename validation"
+    description = "Validate control character and non-UTF8 filenames are safely skipped without client crash while valid sibling files still synchronise"
+
+    def _write_config(self, config_path: Path, sync_dir: Path) -> None:
+        write_onedrive_config(
+            config_path,
+            "\n".join(
+                [
+                    "# tc0028 config",
+                    f'sync_dir = "{sync_dir}"',
+                    'bypass_data_preservation = "true"',
+                    'classify_as_big_delete = "1000"',
+                ]
+            )
+            + "\n",
+        )
+
+    def _create_binary_file(self, path: Path, size_kb: int = 8) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        payload = os.urandom(size_kb * 1024)
+        path.write_bytes(payload)
+
+    def _run_and_capture(
+        self,
+        context: E2EContext,
+        label: str,
+        command: list[str],
+        stdout_file: Path,
+        stderr_file: Path,
+    ):
+        context.log(f"Executing Test Case {self.case_id} {label}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+        return result
+
+    def _extract_bad_filename_archive(
+        self,
+        context: E2EContext,
+        archive_path: Path,
+        destination: Path,
+        stdout_file: Path,
+        stderr_file: Path,
+    ):
+        destination.mkdir(parents=True, exist_ok=True)
+        command = [
+            "tar",
+            "-xJf",
+            str(archive_path),
+            "-C",
+            str(destination),
+        ]
+        return self._run_and_capture(context, "archive extract", command, stdout_file, stderr_file)
+
+    def _collect_extracted_file_entries(self, root_name: str, extract_root: Path) -> list[str]:
+        extracted_files: list[str] = []
+
+        if not extract_root.exists():
+            return extracted_files
+
+        for current_root, _, filenames in os.walk(str(extract_root)):
+            for filename in filenames:
+                full_path = Path(current_root) / filename
+                relative_path = full_path.relative_to(extract_root)
+                extracted_files.append(f"{root_name}/archive_payload/{relative_path.as_posix()}")
+
+        extracted_files.sort()
+        return extracted_files
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0028",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        confdir = case_work_dir / "conf-main"
+        verify_conf = case_work_dir / "conf-verify"
+
+        reset_directory(sync_root)
+        reset_directory(verify_root)
+
+        context.bootstrap_config_dir(confdir)
+        context.bootstrap_config_dir(verify_conf)
+
+        self._write_config(confdir / "config", sync_root)
+        self._write_config(verify_conf / "config", verify_root)
+
+        root_name = f"ZZ_E2E_TC0028_{context.run_id}_{os.getpid()}"
+        archive_path = context.repo_root / "tests" / "bad-file-name.tar.xz"
+
+        if not archive_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Required archive not found: {archive_path}",
+                [],
+                {"archive_path": str(archive_path)},
+            )
+
+        valid_files = [
+            f"{root_name}/valid_file_1.bin",
+            f"{root_name}/valid_file_2.txt",
+            f"{root_name}/valid_subdir/nested_valid_file.dat",
+        ]
+
+        for rel_path in valid_files:
+            self._create_binary_file(sync_root / rel_path, size_kb=8)
+
+        archive_extract_root = sync_root / root_name / "archive_payload"
+
+        extract_stdout = case_log_dir / "archive_extract_stdout.log"
+        extract_stderr = case_log_dir / "archive_extract_stderr.log"
+
+        extract_result = self._extract_bad_filename_archive(
+            context,
+            archive_path,
+            archive_extract_root,
+            extract_stdout,
+            extract_stderr,
+        )
+
+        initial_stdout = case_log_dir / "initial_sync_stdout.log"
+        initial_stderr = case_log_dir / "initial_sync_stderr.log"
+
+        second_stdout = case_log_dir / "second_sync_stdout.log"
+        second_stderr = case_log_dir / "second_sync_stderr.log"
+
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+
+        remote_manifest_file = state_dir / "remote_verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        if extract_result.returncode != 0:
+            artifacts = [
+                str(extract_stdout),
+                str(extract_stderr),
+            ]
+            details = {
+                "archive_path": str(archive_path),
+                "extract_returncode": extract_result.returncode,
+            }
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Archive extraction failed with status {extract_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        extracted_file_entries = self._collect_extracted_file_entries(root_name, archive_extract_root)
+
+        initial_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(confdir),
+        ]
+        initial_result = self._run_and_capture(
+            context,
+            "initial sync",
+            initial_command,
+            initial_stdout,
+            initial_stderr,
+        )
+
+        second_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(confdir),
+        ]
+        second_result = self._run_and_capture(
+            context,
+            "second sync",
+            second_command,
+            second_stdout,
+            second_stderr,
+        )
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(verify_conf),
+        ]
+        verify_result = self._run_and_capture(
+            context,
+            "remote verify",
+            verify_command,
+            verify_stdout,
+            verify_stderr,
+        )
+
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+
+        combined_output = (
+            extract_result.stdout
+            + "\n"
+            + extract_result.stderr
+            + "\n"
+            + initial_result.stdout
+            + "\n"
+            + initial_result.stderr
+            + "\n"
+            + second_result.stdout
+            + "\n"
+            + second_result.stderr
+        )
+
+        write_text_file(
+            metadata_file,
+            "\n".join(
+                [
+                    f"case_id={self.case_id}",
+                    f"root_name={root_name}",
+                    f"archive_path={archive_path}",
+                    f"extract_returncode={extract_result.returncode}",
+                    f"initial_returncode={initial_result.returncode}",
+                    f"second_returncode={second_result.returncode}",
+                    f"verify_returncode={verify_result.returncode}",
+                    f"valid_files={valid_files!r}",
+                    f"extracted_file_entries={extracted_file_entries!r}",
+                ]
+            )
+            + "\n",
+        )
+
+        artifacts = [
+            str(extract_stdout),
+            str(extract_stderr),
+            str(initial_stdout),
+            str(initial_stderr),
+            str(second_stdout),
+            str(second_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(remote_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "extract_returncode": extract_result.returncode,
+            "initial_returncode": initial_result.returncode,
+            "second_returncode": second_result.returncode,
+            "verify_returncode": verify_result.returncode,
+            "root_name": root_name,
+            "archive_path": str(archive_path),
+            "extracted_file_count": len(extracted_file_entries),
+        }
+
+        for label, rc in [
+            ("archive extraction", extract_result.returncode),
+            ("initial sync", initial_result.returncode),
+            ("second sync", second_result.returncode),
+            ("remote verification", verify_result.returncode),
+        ]:
+            if rc != 0:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"{label} failed with status {rc}",
+                    artifacts,
+                    details,
+                )
+
+        for expected in valid_files:
+            if expected not in remote_manifest:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Expected valid file missing remotely: {expected}",
+                    artifacts,
+                    details,
+                )
+
+        for unwanted in extracted_file_entries:
+            if unwanted in remote_manifest:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Control character or non-UTF8 filename was synchronised remotely: {unwanted!r}",
+                    artifacts,
+                    details,
+                )
+
+        if len(extracted_file_entries) == 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Archive extraction produced no test files under archive_payload",
+                artifacts,
+                details,
+            )
+
+        if (
+            f"./{root_name}/archive_payload" not in combined_output
+            and f"{root_name}/archive_payload" not in combined_output
+        ):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Client output does not reference the extracted archive payload paths",
+                artifacts,
+                details,
+            )
+
+        skip_indicators = [
+            "Skipping item - invalid name",
+            "Microsoft Naming Convention",
+            "Skipping item",
+        ]
+        if not any(indicator in combined_output for indicator in skip_indicators):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Expected skip behaviour was not observed in client output",
+                artifacts,
+                details,
+            )
+
+        disallowed_remote_failure_markers = [
+            "HTTP 400",
+            "The resource name is invalid",
+            "invalidRequest",
+        ]
+        for marker in disallowed_remote_failure_markers:
+            if marker in combined_output:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Client attempted remote invalid-name operation instead of safe local skip: {marker}",
+                    artifacts,
+                    details,
+                )
+
+        crash_markers = [
+            "Segmentation fault",
+            "Traceback",
+            "core dumped",
+            "std.conv.ConvException",
+            "std.utf.UTFException",
+            "UnicodeDecodeError",
+            "UnicodeEncodeError",
+        ]
+        for marker in crash_markers:
+            if marker in combined_output:
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"Client output indicates crash or exception: {marker}",
+                    artifacts,
+                    details,
+                )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0029_local_first_upload_only_timestamp_preservation_validation.py b/ci/e2e/testcases/tc0029_local_first_upload_only_timestamp_preservation_validation.py
new file mode 100644
index 000000000..75fde870a
--- /dev/null
+++ b/ci/e2e/testcases/tc0029_local_first_upload_only_timestamp_preservation_validation.py
@@ -0,0 +1,414 @@
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_onedrive_config, write_text_file
+
+
+class TestCase0029LocalFirstUploadOnlyTimestampPreservationValidation(E2ETestCase):
+    case_id = "0029"
+    name = "local_first upload_only timestamp preservation validation"
+    description = (
+        "Validate that --local-first --upload-only uploads local content without "
+        "rewriting local file timestamps from Microsoft API response data"
+    )
+
+    FIXED_MTIME_INITIAL = 1577882096  # 2020-01-01 12:34:56 UTC
+    FIXED_MTIME_UPDATED = 1577968496  # 2020-01-02 12:34:56 UTC
+
+    def _write_config(self, config_path: Path, sync_dir: Path) -> None:
+        content = (
+            "# tc0029 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'upload_only = "true"\n'
+            'local_first = "true"\n'
+            'cleanup_local_files = "false"\n'
+            'bypass_data_preservation = "false"\n'
+        )
+        write_onedrive_config(config_path, content)
+
+    def _set_file_mtime(self, path: Path, epoch_seconds: int) -> None:
+        os.utime(path, (epoch_seconds, epoch_seconds))
+
+    def _file_stat_snapshot(self, path: Path) -> dict[str, object]:
+        stat_data = path.stat()
+        return {
+            "mtime": int(stat_data.st_mtime),
+            "size": stat_data.st_size,
+        }
+
+    def _assert_local_file_state(
+        self,
+        path: Path,
+        expected_content: str,
+        expected_mtime: int,
+        phase_name: str,
+        artifacts: list[str],
+        details: dict[str, object],
+    ) -> TestResult | None:
+        if not path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"{phase_name} did not leave the expected local file in place",
+                artifacts,
+                details,
+            )
+
+        actual_content = path.read_text(encoding="utf-8")
+        actual_mtime = int(path.stat().st_mtime)
+
+        details[f"{phase_name}_actual_content"] = actual_content
+        details[f"{phase_name}_actual_mtime"] = actual_mtime
+        details[f"{phase_name}_expected_content"] = expected_content
+        details[f"{phase_name}_expected_mtime"] = expected_mtime
+
+        if actual_content != expected_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"{phase_name} changed the local file content unexpectedly",
+                artifacts,
+                details,
+            )
+
+        if actual_mtime != expected_mtime:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"{phase_name} changed the local file timestamp unexpectedly",
+                artifacts,
+                details,
+            )
+
+        return None
+
+    def _assert_no_download_activity(
+        self,
+        stdout_text: str,
+        phase_name: str,
+        artifacts: list[str],
+        details: dict[str, object],
+    ) -> TestResult | None:
+        unexpected_markers = [
+            "Downloading file:",
+            "Creating local directory",
+        ]
+        for marker in unexpected_markers:
+            if marker in stdout_text:
+                details[f"{phase_name}_unexpected_download_marker"] = marker
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"{phase_name} showed unexpected download-side local reconciliation activity in upload-only mode",
+                    artifacts,
+                    details,
+                )
+        return None
+
+    def _assert_no_upload_activity(
+        self,
+        stdout_text: str,
+        phase_name: str,
+        artifacts: list[str],
+        details: dict[str, object],
+    ) -> TestResult | None:
+        unexpected_markers = [
+            "Uploading new file:",
+            "Uploading modified file:",
+            "Uploading file:",
+        ]
+        for marker in unexpected_markers:
+            if marker in stdout_text:
+                details[f"{phase_name}_unexpected_upload_marker"] = marker
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    f"{phase_name} unexpectedly attempted another upload despite no local changes",
+                    artifacts,
+                    details,
+                )
+        return None
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0029",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        conf_dir = case_work_dir / "conf"
+        reset_directory(sync_root)
+
+        context.bootstrap_config_dir(conf_dir)
+        self._write_config(conf_dir / "config", sync_root)
+
+        root_name = f"ZZ_E2E_TC0029_{context.run_id}_{os.getpid()}"
+        relative_file = f"{root_name}/timestamp-probe.txt"
+        local_file = sync_root / relative_file
+
+        initial_content = (
+            "TC0029 initial content\n"
+            "This file is uploaded with --upload-only --local-first.\n"
+        )
+        updated_content = (
+            "TC0029 updated content\n"
+            "This file is uploaded again with a newer local timestamp.\n"
+        )
+
+        phase1_stdout = case_log_dir / "phase1_initial_upload_stdout.log"
+        phase1_stderr = case_log_dir / "phase1_initial_upload_stderr.log"
+        phase2_stdout = case_log_dir / "phase2_modified_upload_stdout.log"
+        phase2_stderr = case_log_dir / "phase2_modified_upload_stderr.log"
+        phase3_stdout = case_log_dir / "phase3_noop_sync_stdout.log"
+        phase3_stderr = case_log_dir / "phase3_noop_sync_stderr.log"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(phase1_stdout),
+            str(phase1_stderr),
+            str(phase2_stdout),
+            str(phase2_stderr),
+            str(phase3_stdout),
+            str(phase3_stderr),
+            str(metadata_file),
+        ]
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "relative_file": relative_file,
+        }
+
+        # Phase 1: create the initial file, set a fixed local timestamp, and upload it.
+        write_text_file(local_file, initial_content)
+        self._set_file_mtime(local_file, self.FIXED_MTIME_INITIAL)
+        phase1_before = self._file_stat_snapshot(local_file)
+
+        phase1_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--upload-only",
+            "--local-first",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_dir),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase1: {command_to_string(phase1_command)}")
+        phase1_result = run_command(phase1_command, cwd=context.repo_root)
+        write_text_file(phase1_stdout, phase1_result.stdout)
+        write_text_file(phase1_stderr, phase1_result.stderr)
+        phase1_after = self._file_stat_snapshot(local_file)
+
+        details["phase1_returncode"] = phase1_result.returncode
+        details["phase1_before"] = phase1_before
+        details["phase1_after"] = phase1_after
+
+        if phase1_result.returncode != 0:
+            write_text_file(
+                metadata_file,
+                "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+            )
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"initial upload phase failed with status {phase1_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        failure = self._assert_no_download_activity(
+            phase1_result.stdout,
+            "Initial upload phase",
+            artifacts,
+            details,
+        )
+        if failure is not None:
+            write_text_file(
+                metadata_file,
+                "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+            )
+            return failure
+
+        failure = self._assert_local_file_state(
+            local_file,
+            initial_content,
+            self.FIXED_MTIME_INITIAL,
+            "Initial upload phase",
+            artifacts,
+            details,
+        )
+        if failure is not None:
+            write_text_file(
+                metadata_file,
+                "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+            )
+            return failure
+
+        # Phase 2: modify the local file, set a newer fixed local timestamp, and upload again.
+        time.sleep(2)
+        write_text_file(local_file, updated_content)
+        self._set_file_mtime(local_file, self.FIXED_MTIME_UPDATED)
+        phase2_before = self._file_stat_snapshot(local_file)
+
+        phase2_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--upload-only",
+            "--local-first",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_dir),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase2: {command_to_string(phase2_command)}")
+        phase2_result = run_command(phase2_command, cwd=context.repo_root)
+        write_text_file(phase2_stdout, phase2_result.stdout)
+        write_text_file(phase2_stderr, phase2_result.stderr)
+        phase2_after = self._file_stat_snapshot(local_file)
+
+        details["phase2_returncode"] = phase2_result.returncode
+        details["phase2_before"] = phase2_before
+        details["phase2_after"] = phase2_after
+
+        if phase2_result.returncode != 0:
+            write_text_file(
+                metadata_file,
+                "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+            )
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"modified upload phase failed with status {phase2_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        failure = self._assert_no_download_activity(
+            phase2_result.stdout,
+            "Modified upload phase",
+            artifacts,
+            details,
+        )
+        if failure is not None:
+            write_text_file(
+                metadata_file,
+                "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+            )
+            return failure
+
+        failure = self._assert_local_file_state(
+            local_file,
+            updated_content,
+            self.FIXED_MTIME_UPDATED,
+            "Modified upload phase",
+            artifacts,
+            details,
+        )
+        if failure is not None:
+            write_text_file(
+                metadata_file,
+                "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+            )
+            return failure
+
+        # Phase 3: run again with no local changes; the local file must remain untouched.
+        time.sleep(2)
+        phase3_before = self._file_stat_snapshot(local_file)
+
+        phase3_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--upload-only",
+            "--local-first",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_dir),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase3: {command_to_string(phase3_command)}")
+        phase3_result = run_command(phase3_command, cwd=context.repo_root)
+        write_text_file(phase3_stdout, phase3_result.stdout)
+        write_text_file(phase3_stderr, phase3_result.stderr)
+        phase3_after = self._file_stat_snapshot(local_file)
+
+        details["phase3_returncode"] = phase3_result.returncode
+        details["phase3_before"] = phase3_before
+        details["phase3_after"] = phase3_after
+
+        if phase3_result.returncode != 0:
+            write_text_file(
+                metadata_file,
+                "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+            )
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"no-op sync phase failed with status {phase3_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        failure = self._assert_no_download_activity(
+            phase3_result.stdout,
+            "No-op sync phase",
+            artifacts,
+            details,
+        )
+        if failure is not None:
+            write_text_file(
+                metadata_file,
+                "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+            )
+            return failure
+
+        failure = self._assert_local_file_state(
+            local_file,
+            updated_content,
+            self.FIXED_MTIME_UPDATED,
+            "No-op sync phase",
+            artifacts,
+            details,
+        )
+        if failure is not None:
+            write_text_file(
+                metadata_file,
+                "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+            )
+            return failure
+
+        failure = self._assert_no_upload_activity(
+            phase3_result.stdout,
+            "No-op sync phase",
+            artifacts,
+            details,
+        )
+        if failure is not None:
+            write_text_file(
+                metadata_file,
+                "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+            )
+            return failure
+
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0030_local_rename_propagation_validation.py b/ci/e2e/testcases/tc0030_local_rename_propagation_validation.py
new file mode 100644
index 000000000..e55e80b13
--- /dev/null
+++ b/ci/e2e/testcases/tc0030_local_rename_propagation_validation.py
@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0030LocalRenamePropagationValidation(E2ETestCase):
+    case_id = "0030"
+    name = "local rename propagation validation"
+    description = "Validate that renaming a local file is correctly propagated to remote state"
+
+    def _write_config(self, config_dir: Path, sync_dir: Path) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_text = (
+            "# tc0030 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+        )
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0030",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        local_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+
+        reset_directory(local_root)
+        reset_directory(verify_root)
+
+        context.prepare_minimal_config_dir(conf_main, "")
+        context.prepare_minimal_config_dir(conf_verify, "")
+
+        self._write_config(conf_main, local_root)
+        self._write_config(conf_verify, verify_root)
+
+        root_name = f"ZZ_E2E_TC0030_{context.run_id}_{os.getpid()}"
+        old_relative = f"{root_name}/original-name.txt"
+        new_relative = f"{root_name}/renamed-file.txt"
+
+        old_local_path = local_root / old_relative
+        new_local_path = local_root / new_relative
+
+        initial_content = (
+            "TC0030 local rename propagation validation\n"
+            "This content must survive the rename operation unchanged.\n"
+        )
+
+        phase1_stdout = case_log_dir / "phase1_seed_stdout.log"
+        phase1_stderr = case_log_dir / "phase1_seed_stderr.log"
+        phase2_stdout = case_log_dir / "phase2_rename_stdout.log"
+        phase2_stderr = case_log_dir / "phase2_rename_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(phase1_stdout),
+            str(phase1_stderr),
+            str(phase2_stdout),
+            str(phase2_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "old_relative": old_relative,
+            "new_relative": new_relative,
+            "main_conf_dir": str(conf_main),
+            "verify_conf_dir": str(conf_verify),
+            "local_root": str(local_root),
+            "verify_root": str(verify_root),
+        }
+
+        write_text_file(old_local_path, initial_content)
+
+        phase1_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase1: {command_to_string(phase1_command)}")
+        phase1_result = run_command(phase1_command, cwd=context.repo_root)
+        write_text_file(phase1_stdout, phase1_result.stdout)
+        write_text_file(phase1_stderr, phase1_result.stderr)
+        details["phase1_returncode"] = phase1_result.returncode
+
+        if phase1_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id, self.name, f"seed phase failed with status {phase1_result.returncode}", artifacts, details
+            )
+
+        old_local_path.rename(new_local_path)
+
+        if old_local_path.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id, self.name, "local old filename still exists immediately after rename", artifacts, details
+            )
+
+        if not new_local_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id, self.name, "local renamed file does not exist immediately after rename", artifacts, details
+            )
+
+        phase2_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase2: {command_to_string(phase2_command)}")
+        phase2_result = run_command(phase2_command, cwd=context.repo_root)
+        write_text_file(phase2_stdout, phase2_result.stdout)
+        write_text_file(phase2_stderr, phase2_result.stderr)
+        details["phase2_returncode"] = phase2_result.returncode
+
+        if phase2_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id, self.name, f"rename propagation phase failed with status {phase2_result.returncode}", artifacts, details
+            )
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        verified_old_path = verify_root / old_relative
+        verified_new_path = verify_root / new_relative
+
+        details["verified_old_exists"] = verified_old_path.exists()
+        details["verified_new_exists"] = verified_new_path.exists()
+
+        verified_content = verified_new_path.read_text(encoding="utf-8") if verified_new_path.is_file() else ""
+        details["verified_content"] = verified_content
+
+        self._write_metadata(metadata_file, details)
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id, self.name, f"remote verification failed with status {verify_result.returncode}", artifacts, details
+            )
+
+        if verified_old_path.exists():
+            return self.fail_result(
+                self.case_id, self.name, f"remote verification still contains old filename: {old_relative}", artifacts, details
+            )
+
+        if not verified_new_path.is_file():
+            return self.fail_result(
+                self.case_id, self.name, f"remote verification is missing renamed file: {new_relative}", artifacts, details
+            )
+
+        if verified_content != initial_content:
+            return self.fail_result(
+                self.case_id, self.name, "renamed file content did not match the original content after remote verification", artifacts, details
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0031_local_directory_rename_propagation_validation.py b/ci/e2e/testcases/tc0031_local_directory_rename_propagation_validation.py
new file mode 100644
index 000000000..1e57e45ac
--- /dev/null
+++ b/ci/e2e/testcases/tc0031_local_directory_rename_propagation_validation.py
@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0031LocalDirectoryRenamePropagationValidation(E2ETestCase):
+    case_id = "0031"
+    name = "local directory rename propagation validation"
+    description = "Validate that renaming a local directory tree is correctly propagated to remote state"
+
+    def _write_config(self, config_dir: Path, sync_dir: Path) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_text = (
+            "# tc0031 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+        )
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0031",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        local_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+
+        reset_directory(local_root)
+        reset_directory(verify_root)
+
+        context.prepare_minimal_config_dir(conf_main, "")
+        context.prepare_minimal_config_dir(conf_verify, "")
+
+        self._write_config(conf_main, local_root)
+        self._write_config(conf_verify, verify_root)
+
+        root_name = f"ZZ_E2E_TC0031_{context.run_id}_{os.getpid()}"
+        source_dir_relative = f"{root_name}/SourceDirectory"
+        renamed_dir_relative = f"{root_name}/RenamedDirectory"
+
+        source_dir = local_root / source_dir_relative
+        renamed_dir = local_root / renamed_dir_relative
+
+        source_file_1_relative = f"{source_dir_relative}/top-level.txt"
+        source_file_2_relative = f"{source_dir_relative}/Nested/child.txt"
+        renamed_file_1_relative = f"{renamed_dir_relative}/top-level.txt"
+        renamed_file_2_relative = f"{renamed_dir_relative}/Nested/child.txt"
+
+        source_file_1 = local_root / source_file_1_relative
+        source_file_2 = local_root / source_file_2_relative
+
+        file1_content = "top\n"
+        file2_content = "child\n"
+
+        phase1_stdout = case_log_dir / "phase1_seed_stdout.log"
+        phase1_stderr = case_log_dir / "phase1_seed_stderr.log"
+        phase1_settle_stdout = case_log_dir / "phase1_settle_stdout.log"
+        phase1_settle_stderr = case_log_dir / "phase1_settle_stderr.log"
+        phase2_stdout = case_log_dir / "phase2_directory_rename_stdout.log"
+        phase2_stderr = case_log_dir / "phase2_directory_rename_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(phase1_stdout),
+            str(phase1_stderr),
+            str(phase1_settle_stdout),
+            str(phase1_settle_stderr),
+            str(phase2_stdout),
+            str(phase2_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "source_dir_relative": source_dir_relative,
+            "renamed_dir_relative": renamed_dir_relative,
+            "main_conf_dir": str(conf_main),
+            "verify_conf_dir": str(conf_verify),
+            "local_root": str(local_root),
+            "verify_root": str(verify_root),
+        }
+
+        write_text_file(source_file_1, file1_content)
+        write_text_file(source_file_2, file2_content)
+
+        phase1_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase1: {command_to_string(phase1_command)}")
+        phase1_result = run_command(phase1_command, cwd=context.repo_root)
+        write_text_file(phase1_stdout, phase1_result.stdout)
+        write_text_file(phase1_stderr, phase1_result.stderr)
+        details["phase1_returncode"] = phase1_result.returncode
+
+        if phase1_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed phase failed with status {phase1_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Stabilise the just-created remote tree before performing the local rename.
+        # This prevents Graph delta timing from rehydrating the original source
+        # directory locally during the subsequent rename propagation phase.
+        phase1_settle_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase1 settle: {command_to_string(phase1_settle_command)}")
+        phase1_settle_result = run_command(phase1_settle_command, cwd=context.repo_root)
+        write_text_file(phase1_settle_stdout, phase1_settle_result.stdout)
+        write_text_file(phase1_settle_stderr, phase1_settle_result.stderr)
+        details["phase1_settle_returncode"] = phase1_settle_result.returncode
+
+        if phase1_settle_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed settle phase failed with status {phase1_settle_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        source_dir.rename(renamed_dir)
+
+        if source_dir.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local original directory still exists immediately after rename",
+                artifacts,
+                details,
+            )
+
+        if not renamed_dir.is_dir():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local renamed directory does not exist immediately after rename",
+                artifacts,
+                details,
+            )
+
+        phase2_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase2: {command_to_string(phase2_command)}")
+        phase2_result = run_command(phase2_command, cwd=context.repo_root)
+        write_text_file(phase2_stdout, phase2_result.stdout)
+        write_text_file(phase2_stderr, phase2_result.stderr)
+        details["phase2_returncode"] = phase2_result.returncode
+        details["phase2_deleted_old_directory_online"] = (
+            f"Deleting item from Microsoft OneDrive: {source_dir_relative}" in phase2_result.stdout
+        )
+
+        if phase2_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"directory rename propagation phase failed with status {phase2_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        verify_old_dir = verify_root / source_dir_relative
+        verify_new_dir = verify_root / renamed_dir_relative
+        verify_old_file_1 = verify_root / source_file_1_relative
+        verify_old_file_2 = verify_root / source_file_2_relative
+        verify_new_file_1 = verify_root / renamed_file_1_relative
+        verify_new_file_2 = verify_root / renamed_file_2_relative
+
+        details["verify_old_dir_exists"] = verify_old_dir.exists()
+        details["verify_new_dir_exists"] = verify_new_dir.exists()
+        details["verify_old_file_1_exists"] = verify_old_file_1.exists()
+        details["verify_old_file_2_exists"] = verify_old_file_2.exists()
+        details["verify_new_file_1_exists"] = verify_new_file_1.exists()
+        details["verify_new_file_2_exists"] = verify_new_file_2.exists()
+
+        verify_new_file_1_content = verify_new_file_1.read_text(encoding="utf-8") if verify_new_file_1.is_file() else ""
+        verify_new_file_2_content = verify_new_file_2.read_text(encoding="utf-8") if verify_new_file_2.is_file() else ""
+
+        details["verify_new_file_1_content"] = verify_new_file_1_content
+        details["verify_new_file_2_content"] = verify_new_file_2_content
+
+        self._write_metadata(metadata_file, details)
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if verify_old_dir.exists() or verify_old_file_1.exists() or verify_old_file_2.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification still contains original directory tree: {source_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_new_dir.is_dir():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing renamed directory: {renamed_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_new_file_1.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing renamed top-level file: {renamed_file_1_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_new_file_2.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing renamed nested file: {renamed_file_2_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_new_file_1_content != file1_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "renamed top-level file content did not match expected content",
+                artifacts,
+                details,
+            )
+
+        if verify_new_file_2_content != file2_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "renamed nested file content did not match expected content",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0032_remote_rename_reconciliation.py b/ci/e2e/testcases/tc0032_remote_rename_reconciliation.py
new file mode 100644
index 000000000..ca10880b6
--- /dev/null
+++ b/ci/e2e/testcases/tc0032_remote_rename_reconciliation.py
@@ -0,0 +1,369 @@
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0032RemoteRenameReconciliation(E2ETestCase):
+    case_id = "0032"
+    name = "remote rename reconciliation"
+    description = (
+        "Validate that a stale local client correctly reconciles a remote-side "
+        "file rename without leaving stale local leftovers"
+    )
+
+    def _write_config(self, config_dir: Path, sync_dir: Path) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_text = (
+            "# tc0032 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+        )
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0032",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        seed_root = case_work_dir / "seedroot"
+        stale_root = case_work_dir / "staleroot"
+        verify_root = case_work_dir / "verifyroot"
+
+        conf_seed = case_work_dir / "conf-seed"
+        conf_stale = case_work_dir / "conf-stale"
+        conf_verify = case_work_dir / "conf-verify"
+
+        reset_directory(seed_root)
+        reset_directory(verify_root)
+
+        context.prepare_minimal_config_dir(conf_seed, "")
+        context.prepare_minimal_config_dir(conf_verify, "")
+
+        self._write_config(conf_seed, seed_root)
+        self._write_config(conf_verify, verify_root)
+
+        root_name = f"ZZ_E2E_TC0032_{context.run_id}_{os.getpid()}"
+        old_relative = f"{root_name}/remote-original-name.txt"
+        new_relative = f"{root_name}/remote-renamed-name.txt"
+
+        seed_old_path = seed_root / old_relative
+        seed_new_path = seed_root / new_relative
+        stale_old_path = stale_root / old_relative
+        stale_new_path = stale_root / new_relative
+        verify_old_path = verify_root / old_relative
+        verify_new_path = verify_root / new_relative
+
+        initial_content = (
+            "TC0032 remote rename reconciliation\n"
+            "This file is renamed remotely and must reconcile locally.\n"
+        )
+
+        seed_stdout = case_log_dir / "phase1_seed_stdout.log"
+        seed_stderr = case_log_dir / "phase1_seed_stderr.log"
+        remote_rename_stdout = case_log_dir / "phase2_remote_rename_stdout.log"
+        remote_rename_stderr = case_log_dir / "phase2_remote_rename_stderr.log"
+        stale_sync_stdout = case_log_dir / "phase3_stale_reconcile_stdout.log"
+        stale_sync_stderr = case_log_dir / "phase3_stale_reconcile_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        stale_manifest_file = state_dir / "stale_manifest.txt"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(remote_rename_stdout),
+            str(remote_rename_stderr),
+            str(stale_sync_stdout),
+            str(stale_sync_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(stale_manifest_file),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "old_relative": old_relative,
+            "new_relative": new_relative,
+            "seed_root": str(seed_root),
+            "stale_root": str(stale_root),
+            "verify_root": str(verify_root),
+            "seed_conf_dir": str(conf_seed),
+            "stale_conf_dir": str(conf_stale),
+            "verify_conf_dir": str(conf_verify),
+        }
+
+        # Phase 1: seed original remote state
+        write_text_file(seed_old_path, initial_content)
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_seed),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase1 seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed phase failed with status {seed_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Snapshot the synchronised local + config/db state to create a stale client.
+        # This stale client represents a second machine that has not yet seen the rename.
+        if conf_stale.exists():
+            shutil.rmtree(conf_stale)
+        if stale_root.exists():
+            shutil.rmtree(stale_root)
+
+        shutil.copytree(conf_seed, conf_stale)
+        shutil.copytree(seed_root, stale_root)
+
+        # Rewrite stale runtime config so it points at stale_root while preserving DB state.
+        self._write_config(conf_stale, stale_root)
+
+        details["stale_snapshot_old_exists_before_reconcile"] = stale_old_path.exists()
+        details["stale_snapshot_new_exists_before_reconcile"] = stale_new_path.exists()
+
+        if not stale_old_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "stale snapshot did not preserve original local file before reconciliation",
+                artifacts,
+                details,
+            )
+
+        # Phase 2: perform the rename through the seed client.
+        # This is our remote-side rename mechanism.
+        seed_old_path.rename(seed_new_path)
+
+        if seed_old_path.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "seed local old filename still exists immediately after rename",
+                artifacts,
+                details,
+            )
+
+        if not seed_new_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "seed local renamed file does not exist immediately after rename",
+                artifacts,
+                details,
+            )
+
+        remote_rename_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_seed),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase2 remote rename: {command_to_string(remote_rename_command)}")
+        remote_rename_result = run_command(remote_rename_command, cwd=context.repo_root)
+        write_text_file(remote_rename_stdout, remote_rename_result.stdout)
+        write_text_file(remote_rename_stderr, remote_rename_result.stderr)
+        details["remote_rename_returncode"] = remote_rename_result.returncode
+
+        if remote_rename_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote rename propagation phase failed with status {remote_rename_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 3: stale client reconciles the remote rename using existing DB/local state.
+        # No --resync here, because this is specifically a reconciliation test.
+        stale_sync_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_stale),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase3 stale reconcile: {command_to_string(stale_sync_command)}")
+        stale_sync_result = run_command(stale_sync_command, cwd=context.repo_root)
+        write_text_file(stale_sync_stdout, stale_sync_result.stdout)
+        write_text_file(stale_sync_stderr, stale_sync_result.stderr)
+        details["stale_reconcile_returncode"] = stale_sync_result.returncode
+
+        stale_manifest = build_manifest(stale_root)
+        write_manifest(stale_manifest_file, stale_manifest)
+
+        details["stale_old_exists_after_reconcile"] = stale_old_path.exists()
+        details["stale_new_exists_after_reconcile"] = stale_new_path.exists()
+        stale_new_content = stale_new_path.read_text(encoding="utf-8") if stale_new_path.is_file() else ""
+        details["stale_new_content"] = stale_new_content
+
+        if stale_sync_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"stale reconciliation phase failed with status {stale_sync_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Final clean remote verification from scratch.
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_old_exists"] = verify_old_path.exists()
+        details["verify_new_exists"] = verify_new_path.exists()
+        verify_new_content = verify_new_path.read_text(encoding="utf-8") if verify_new_path.is_file() else ""
+        details["verify_new_content"] = verify_new_content
+
+        self._write_metadata(metadata_file, details)
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if stale_old_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"stale client still contains old filename after reconciliation: {old_relative}",
+                artifacts,
+                details,
+            )
+
+        if not stale_new_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"stale client is missing renamed file after reconciliation: {new_relative}",
+                artifacts,
+                details,
+            )
+
+        if stale_new_content != initial_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "stale client renamed file content did not match expected content after reconciliation",
+                artifacts,
+                details,
+            )
+
+        if verify_old_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"fresh remote verification still contains old filename: {old_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_new_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"fresh remote verification is missing renamed file: {new_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_new_content != initial_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "fresh remote verification file content did not match expected content",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0033_remote_directory_rename_reconciliation.py b/ci/e2e/testcases/tc0033_remote_directory_rename_reconciliation.py
new file mode 100644
index 000000000..22fd56781
--- /dev/null
+++ b/ci/e2e/testcases/tc0033_remote_directory_rename_reconciliation.py
@@ -0,0 +1,641 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0033RemoteDirectoryRenameReconciliation(E2ETestCase):
+    case_id = "0033"
+    name = "remote directory rename reconciliation"
+    description = (
+        "Validate that a second client with existing local and database state correctly "
+        "reconciles a remote directory rename propagated by another synchronising client"
+    )
+
+    def _write_config(self, config_dir: Path, sync_dir: Path) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_text = (
+            "# tc0033 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+        )
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def _list_files_under(self, root: Path) -> list[str]:
+        if not root.exists():
+            return []
+        return sorted(str(path.relative_to(root)) for path in root.rglob("*") if path.is_file())
+
+    def _list_dirs_under(self, root: Path) -> list[str]:
+        if not root.exists():
+            return []
+        return sorted(str(path.relative_to(root)) for path in root.rglob("*") if path.is_dir())
+
+    def _extract_deleted_remote_paths(self, stdout: str) -> list[str]:
+        prefix = "Deleting item from Microsoft OneDrive: "
+        deleted_paths: list[str] = []
+
+        for line in stdout.splitlines():
+            line = line.strip()
+            if line.startswith(prefix):
+                deleted_paths.append(line[len(prefix):].strip())
+
+        return deleted_paths
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0033",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        seeder_root = case_work_dir / "seeder-root"
+        validator_root = case_work_dir / "validator-root"
+        verify_root = case_work_dir / "verify-root"
+
+        conf_seeder = case_work_dir / "conf-seeder"
+        conf_validator = case_work_dir / "conf-validator"
+        conf_verify = case_work_dir / "conf-verify"
+
+        reset_directory(seeder_root)
+        reset_directory(validator_root)
+        reset_directory(verify_root)
+
+        context.prepare_minimal_config_dir(conf_seeder, "")
+        context.prepare_minimal_config_dir(conf_validator, "")
+        context.prepare_minimal_config_dir(conf_verify, "")
+
+        self._write_config(conf_seeder, seeder_root)
+        self._write_config(conf_validator, validator_root)
+        self._write_config(conf_verify, verify_root)
+
+        root_name = f"ZZ_E2E_TC0033_{context.run_id}_{os.getpid()}"
+        source_dir_relative = f"{root_name}/SourceDirectory"
+        renamed_dir_relative = f"{root_name}/RenamedDirectory"
+
+        source_file_1_relative = f"{source_dir_relative}/top-level.txt"
+        source_file_2_relative = f"{source_dir_relative}/Nested/child.txt"
+        renamed_file_1_relative = f"{renamed_dir_relative}/top-level.txt"
+        renamed_file_2_relative = f"{renamed_dir_relative}/Nested/child.txt"
+
+        seeder_source_dir = seeder_root / source_dir_relative
+        seeder_renamed_dir = seeder_root / renamed_dir_relative
+
+        validator_source_dir = validator_root / source_dir_relative
+        validator_renamed_dir = validator_root / renamed_dir_relative
+
+        verify_source_dir = verify_root / source_dir_relative
+        verify_renamed_dir = verify_root / renamed_dir_relative
+
+        validator_source_file_1 = validator_root / source_file_1_relative
+        validator_source_file_2 = validator_root / source_file_2_relative
+        validator_renamed_file_1 = validator_root / renamed_file_1_relative
+        validator_renamed_file_2 = validator_root / renamed_file_2_relative
+
+        verify_source_file_1 = verify_root / source_file_1_relative
+        verify_source_file_2 = verify_root / source_file_2_relative
+        verify_renamed_file_1 = verify_root / renamed_file_1_relative
+        verify_renamed_file_2 = verify_root / renamed_file_2_relative
+
+        file1_content = "top\n"
+        file2_content = "child\n"
+
+        phase1_seed_stdout = case_log_dir / "phase1_seed_stdout.log"
+        phase1_seed_stderr = case_log_dir / "phase1_seed_stderr.log"
+        phase2_validator_initial_stdout = case_log_dir / "phase2_validator_initial_stdout.log"
+        phase2_validator_initial_stderr = case_log_dir / "phase2_validator_initial_stderr.log"
+        phase3_rename_stdout = case_log_dir / "phase3_directory_rename_stdout.log"
+        phase3_rename_stderr = case_log_dir / "phase3_directory_rename_stderr.log"
+        phase3_converge_stdout = case_log_dir / "phase3_converge_stdout.log"
+        phase3_converge_stderr = case_log_dir / "phase3_converge_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        phase4_validator_reconcile_stdout = case_log_dir / "phase4_validator_reconcile_stdout.log"
+        phase4_validator_reconcile_stderr = case_log_dir / "phase4_validator_reconcile_stderr.log"
+        validator_manifest_file = state_dir / "validator_manifest.txt"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(phase1_seed_stdout),
+            str(phase1_seed_stderr),
+            str(phase2_validator_initial_stdout),
+            str(phase2_validator_initial_stderr),
+            str(phase3_rename_stdout),
+            str(phase3_rename_stderr),
+            str(phase3_converge_stdout),
+            str(phase3_converge_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(phase4_validator_reconcile_stdout),
+            str(phase4_validator_reconcile_stderr),
+            str(validator_manifest_file),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "source_dir_relative": source_dir_relative,
+            "renamed_dir_relative": renamed_dir_relative,
+            "source_file_1_relative": source_file_1_relative,
+            "source_file_2_relative": source_file_2_relative,
+            "renamed_file_1_relative": renamed_file_1_relative,
+            "renamed_file_2_relative": renamed_file_2_relative,
+            "seeder_conf_dir": str(conf_seeder),
+            "validator_conf_dir": str(conf_validator),
+            "verify_conf_dir": str(conf_verify),
+            "seeder_root": str(seeder_root),
+            "validator_root": str(validator_root),
+            "verify_root": str(verify_root),
+        }
+
+        # Phase 1: Seeder creates the original local directory tree and syncs it online.
+        write_text_file(seeder_root / source_file_1_relative, file1_content)
+        write_text_file(seeder_root / source_file_2_relative, file2_content)
+
+        phase1_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(conf_seeder),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase1 seed: {command_to_string(phase1_command)}")
+        phase1_result = run_command(phase1_command, cwd=context.repo_root)
+        write_text_file(phase1_seed_stdout, phase1_result.stdout)
+        write_text_file(phase1_seed_stderr, phase1_result.stderr)
+        details["phase1_returncode"] = phase1_result.returncode
+
+        if phase1_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed phase failed with status {phase1_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 2: Validator downloads the original tree into its own local/database state.
+        phase2_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_validator),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase2 validator initial download: "
+            f"{command_to_string(phase2_command)}"
+        )
+        phase2_result = run_command(phase2_command, cwd=context.repo_root)
+        write_text_file(phase2_validator_initial_stdout, phase2_result.stdout)
+        write_text_file(phase2_validator_initial_stderr, phase2_result.stderr)
+        details["phase2_returncode"] = phase2_result.returncode
+
+        details["validator_initial_source_dir_exists"] = validator_source_dir.is_dir()
+        details["validator_initial_source_file_1_exists"] = validator_source_file_1.is_file()
+        details["validator_initial_source_file_2_exists"] = validator_source_file_2.is_file()
+        details["validator_initial_renamed_dir_exists"] = validator_renamed_dir.exists()
+
+        if phase2_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator initial download phase failed with status {phase2_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not validator_source_dir.is_dir():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator failed to download original directory: {source_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if not validator_source_file_1.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator failed to download original top-level file: {source_file_1_relative}",
+                artifacts,
+                details,
+            )
+
+        if not validator_source_file_2.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator failed to download original nested file: {source_file_2_relative}",
+                artifacts,
+                details,
+            )
+
+        # Phase 3: Seeder renames the directory locally and syncs the change online.
+        seeder_source_dir.rename(seeder_renamed_dir)
+
+        details["seeder_source_dir_exists_after_local_rename"] = seeder_source_dir.exists()
+        details["seeder_renamed_dir_exists_after_local_rename"] = seeder_renamed_dir.is_dir()
+
+        if seeder_source_dir.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "seeder original directory still exists immediately after rename",
+                artifacts,
+                details,
+            )
+
+        if not seeder_renamed_dir.is_dir():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "seeder renamed directory does not exist immediately after rename",
+                artifacts,
+                details,
+            )
+
+        phase3_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(conf_seeder),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase3 rename sync: {command_to_string(phase3_command)}")
+        phase3_result = run_command(phase3_command, cwd=context.repo_root)
+        write_text_file(phase3_rename_stdout, phase3_result.stdout)
+        write_text_file(phase3_rename_stderr, phase3_result.stderr)
+        details["phase3_returncode"] = phase3_result.returncode
+
+        phase3_deleted_paths = self._extract_deleted_remote_paths(phase3_result.stdout)
+        details["phase3_deleted_remote_paths"] = phase3_deleted_paths
+        details["phase3_deleted_old_root_exact"] = source_dir_relative in phase3_deleted_paths
+        details["phase3_deleted_old_nested_exact"] = f"{source_dir_relative}/Nested" in phase3_deleted_paths
+        details["phase3_deleted_old_file_1_exact"] = source_file_1_relative in phase3_deleted_paths
+        details["phase3_deleted_old_file_2_exact"] = source_file_2_relative in phase3_deleted_paths
+
+        if phase3_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"directory rename propagation phase failed with status {phase3_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 3b: Run a second seeder sync pass to converge any residual remote state.
+        phase3_converge_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--confdir",
+            str(conf_seeder),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase3 converge sync: "
+            f"{command_to_string(phase3_converge_command)}"
+        )
+        phase3_converge_result = run_command(phase3_converge_command, cwd=context.repo_root)
+        write_text_file(phase3_converge_stdout, phase3_converge_result.stdout)
+        write_text_file(phase3_converge_stderr, phase3_converge_result.stderr)
+        details["phase3_converge_returncode"] = phase3_converge_result.returncode
+
+        phase3_converge_deleted_paths = self._extract_deleted_remote_paths(phase3_converge_result.stdout)
+        details["phase3_converge_deleted_remote_paths"] = phase3_converge_deleted_paths
+        details["phase3_converge_deleted_old_root_exact"] = source_dir_relative in phase3_converge_deleted_paths
+        details["phase3_converge_deleted_old_nested_exact"] = (
+            f"{source_dir_relative}/Nested" in phase3_converge_deleted_paths
+        )
+
+        if phase3_converge_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"directory rename convergence phase failed with status {phase3_converge_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Verify remote truth independently before judging validator reconciliation.
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify remote truth: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_source_dir_exists"] = verify_source_dir.exists()
+        details["verify_renamed_dir_exists"] = verify_renamed_dir.exists()
+        details["verify_source_file_1_exists"] = verify_source_file_1.exists()
+        details["verify_source_file_2_exists"] = verify_source_file_2.exists()
+        details["verify_renamed_file_1_exists"] = verify_renamed_file_1.exists()
+        details["verify_renamed_file_2_exists"] = verify_renamed_file_2.exists()
+
+        verify_old_tree_files = self._list_files_under(verify_source_dir)
+        verify_old_tree_dirs = self._list_dirs_under(verify_source_dir)
+        details["verify_old_tree_files"] = verify_old_tree_files
+        details["verify_old_tree_dirs"] = verify_old_tree_dirs
+
+        verify_new_file_1_content = (
+            verify_renamed_file_1.read_text(encoding="utf-8")
+            if verify_renamed_file_1.is_file()
+            else ""
+        )
+        verify_new_file_2_content = (
+            verify_renamed_file_2.read_text(encoding="utf-8")
+            if verify_renamed_file_2.is_file()
+            else ""
+        )
+        details["verify_renamed_file_1_content"] = verify_new_file_1_content
+        details["verify_renamed_file_2_content"] = verify_new_file_2_content
+
+        if verify_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Remote truth assertions: the old tree must be fully absent before validator is judged.
+        if verify_source_dir.exists() or verify_source_file_1.exists() or verify_source_file_2.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote rename propagation incomplete: original directory tree still exists online: {source_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_old_tree_files:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote rename propagation incomplete: old files still exist online under original directory tree: {verify_old_tree_files}",
+                artifacts,
+                details,
+            )
+
+        if verify_old_tree_dirs:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote rename propagation incomplete: old directories still exist online under original directory tree: {verify_old_tree_dirs}",
+                artifacts,
+                details,
+            )
+
+        if not verify_renamed_dir.is_dir():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing renamed directory: {renamed_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_renamed_file_1.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing renamed top-level file: {renamed_file_1_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_renamed_file_2.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing renamed nested file: {renamed_file_2_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_new_file_1_content != file1_content:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "remote verification renamed top-level file content did not match expected content",
+                artifacts,
+                details,
+            )
+
+        if verify_new_file_2_content != file2_content:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "remote verification renamed nested file content did not match expected content",
+                artifacts,
+                details,
+            )
+
+        # Phase 4: Validator re-runs download-only against its existing local/database state,
+        # but only after remote truth has been proven clean.
+        phase4_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_validator),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase4 validator reconcile: "
+            f"{command_to_string(phase4_command)}"
+        )
+        phase4_result = run_command(phase4_command, cwd=context.repo_root)
+        write_text_file(phase4_validator_reconcile_stdout, phase4_result.stdout)
+        write_text_file(phase4_validator_reconcile_stderr, phase4_result.stderr)
+        details["phase4_returncode"] = phase4_result.returncode
+
+        validator_manifest = build_manifest(validator_root)
+        write_manifest(validator_manifest_file, validator_manifest)
+
+        details["validator_source_dir_exists_after_reconcile"] = validator_source_dir.exists()
+        details["validator_renamed_dir_exists_after_reconcile"] = validator_renamed_dir.exists()
+        details["validator_source_file_1_exists_after_reconcile"] = validator_source_file_1.exists()
+        details["validator_source_file_2_exists_after_reconcile"] = validator_source_file_2.exists()
+        details["validator_renamed_file_1_exists_after_reconcile"] = validator_renamed_file_1.exists()
+        details["validator_renamed_file_2_exists_after_reconcile"] = validator_renamed_file_2.exists()
+
+        validator_old_tree_files = self._list_files_under(validator_source_dir)
+        validator_old_tree_dirs = self._list_dirs_under(validator_source_dir)
+        details["validator_old_tree_files_after_reconcile"] = validator_old_tree_files
+        details["validator_old_tree_dirs_after_reconcile"] = validator_old_tree_dirs
+
+        validator_new_file_1_content = (
+            validator_renamed_file_1.read_text(encoding="utf-8")
+            if validator_renamed_file_1.is_file()
+            else ""
+        )
+        validator_new_file_2_content = (
+            validator_renamed_file_2.read_text(encoding="utf-8")
+            if validator_renamed_file_2.is_file()
+            else ""
+        )
+        details["validator_renamed_file_1_content"] = validator_new_file_1_content
+        details["validator_renamed_file_2_content"] = validator_new_file_2_content
+
+        self._write_metadata(metadata_file, details)
+
+        if phase4_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator reconcile phase failed with status {phase4_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if validator_source_dir.exists() or validator_source_file_1.exists() or validator_source_file_2.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator still contains original directory tree after reconciliation: {source_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if validator_old_tree_files:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator retained old files under original directory tree after reconciliation: {validator_old_tree_files}",
+                artifacts,
+                details,
+            )
+
+        if validator_old_tree_dirs:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator retained old directories under original directory tree after reconciliation: {validator_old_tree_dirs}",
+                artifacts,
+                details,
+            )
+
+        if not validator_renamed_dir.is_dir():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator is missing renamed directory after reconciliation: {renamed_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if not validator_renamed_file_1.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator is missing renamed top-level file after reconciliation: {renamed_file_1_relative}",
+                artifacts,
+                details,
+            )
+
+        if not validator_renamed_file_2.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"validator is missing renamed nested file after reconciliation: {renamed_file_2_relative}",
+                artifacts,
+                details,
+            )
+
+        if validator_new_file_1_content != file1_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "validator renamed top-level file content did not match expected content",
+                artifacts,
+                details,
+            )
+
+        if validator_new_file_2_content != file2_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "validator renamed nested file content did not match expected content",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0034_local_move_between_directories_validation.py b/ci/e2e/testcases/tc0034_local_move_between_directories_validation.py
new file mode 100644
index 000000000..85e47d429
--- /dev/null
+++ b/ci/e2e/testcases/tc0034_local_move_between_directories_validation.py
@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0034LocalMoveBetweenDirectoriesValidation(E2ETestCase):
+    case_id = "0034"
+    name = "local move between directories validation"
+    description = (
+        "Validate that moving a local file from one directory to another "
+        "is correctly propagated to remote state"
+    )
+
+    def _write_config(self, config_dir: Path, sync_dir: Path) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_text = (
+            "# tc0034 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+        )
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0034",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        local_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+
+        reset_directory(local_root)
+        reset_directory(verify_root)
+
+        context.prepare_minimal_config_dir(conf_main, "")
+        context.prepare_minimal_config_dir(conf_verify, "")
+
+        self._write_config(conf_main, local_root)
+        self._write_config(conf_verify, verify_root)
+
+        root_name = f"ZZ_E2E_TC0034_{context.run_id}_{os.getpid()}"
+        source_relative = f"{root_name}/SourceDirectory/move-me.txt"
+        destination_relative = f"{root_name}/DestinationDirectory/move-me.txt"
+        anchor_relative = f"{root_name}/DestinationDirectory/anchor.txt"
+
+        local_source_path = local_root / source_relative
+        local_destination_path = local_root / destination_relative
+        local_anchor_path = local_root / anchor_relative
+
+        verify_source_path = verify_root / source_relative
+        verify_destination_path = verify_root / destination_relative
+        verify_anchor_path = verify_root / anchor_relative
+
+        initial_content = (
+            "TC0034 local move between directories validation\n"
+            "This content must survive the directory move unchanged.\n"
+        )
+        anchor_content = (
+            "TC0034 destination directory anchor\n"
+            "This ensures the destination directory exists before the move.\n"
+        )
+
+        phase1_stdout = case_log_dir / "phase1_seed_stdout.log"
+        phase1_stderr = case_log_dir / "phase1_seed_stderr.log"
+        phase2_stdout = case_log_dir / "phase2_move_stdout.log"
+        phase2_stderr = case_log_dir / "phase2_move_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(phase1_stdout),
+            str(phase1_stderr),
+            str(phase2_stdout),
+            str(phase2_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "source_relative": source_relative,
+            "destination_relative": destination_relative,
+            "anchor_relative": anchor_relative,
+            "main_conf_dir": str(conf_main),
+            "verify_conf_dir": str(conf_verify),
+            "local_root": str(local_root),
+            "verify_root": str(verify_root),
+        }
+
+        # Phase 1: seed original state with source file and destination anchor
+        write_text_file(local_source_path, initial_content)
+        write_text_file(local_anchor_path, anchor_content)
+
+        phase1_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase1: {command_to_string(phase1_command)}")
+        phase1_result = run_command(phase1_command, cwd=context.repo_root)
+        write_text_file(phase1_stdout, phase1_result.stdout)
+        write_text_file(phase1_stderr, phase1_result.stderr)
+        details["phase1_returncode"] = phase1_result.returncode
+
+        if phase1_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed phase failed with status {phase1_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 2: move the file locally between directories without renaming it
+        local_destination_path.parent.mkdir(parents=True, exist_ok=True)
+        local_source_path.rename(local_destination_path)
+
+        details["local_source_exists_after_move"] = local_source_path.exists()
+        details["local_destination_exists_after_move"] = local_destination_path.is_file()
+        details["local_anchor_exists_after_move"] = local_anchor_path.is_file()
+
+        if local_source_path.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local source file still exists immediately after move",
+                artifacts,
+                details,
+            )
+
+        if not local_destination_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local destination file does not exist immediately after move",
+                artifacts,
+                details,
+            )
+
+        phase2_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase2: {command_to_string(phase2_command)}")
+        phase2_result = run_command(phase2_command, cwd=context.repo_root)
+        write_text_file(phase2_stdout, phase2_result.stdout)
+        write_text_file(phase2_stderr, phase2_result.stderr)
+        details["phase2_returncode"] = phase2_result.returncode
+
+        if phase2_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"move propagation phase failed with status {phase2_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 3: verify remote truth from a fresh client
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_source_exists"] = verify_source_path.exists()
+        details["verify_destination_exists"] = verify_destination_path.is_file()
+        details["verify_anchor_exists"] = verify_anchor_path.is_file()
+
+        verify_destination_content = (
+            verify_destination_path.read_text(encoding="utf-8")
+            if verify_destination_path.is_file()
+            else ""
+        )
+        details["verify_destination_content"] = verify_destination_content
+
+        self._write_metadata(metadata_file, details)
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if verify_source_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification still contains source file path: {source_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_destination_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing moved file at destination path: {destination_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_destination_content != initial_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "moved file content did not match the original content after remote verification",
+                artifacts,
+                details,
+            )
+
+        if not verify_anchor_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing destination anchor file: {anchor_relative}",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0035_remote_move_between_directories_reconciliation.py b/ci/e2e/testcases/tc0035_remote_move_between_directories_reconciliation.py
new file mode 100644
index 000000000..fb8dff0dc
--- /dev/null
+++ b/ci/e2e/testcases/tc0035_remote_move_between_directories_reconciliation.py
@@ -0,0 +1,448 @@
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0035RemoteMoveBetweenDirectoriesReconciliation(E2ETestCase):
+    case_id = "0035"
+    name = "remote move between directories reconciliation"
+    description = (
+        "Validate that a stale local client correctly reconciles a remote-side "
+        "file move between directories without leaving stale local file leftovers"
+    )
+
+    def _write_config(self, config_dir: Path, sync_dir: Path) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_text = (
+            "# tc0035 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+        )
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def _list_files_under(self, root: Path) -> list[str]:
+        if not root.exists():
+            return []
+        return sorted(str(path.relative_to(root)) for path in root.rglob("*") if path.is_file())
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0035",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        seed_root = case_work_dir / "seedroot"
+        stale_root = case_work_dir / "staleroot"
+        verify_root = case_work_dir / "verifyroot"
+
+        conf_seed = case_work_dir / "conf-seed"
+        conf_stale = case_work_dir / "conf-stale"
+        conf_verify = case_work_dir / "conf-verify"
+
+        reset_directory(seed_root)
+        reset_directory(verify_root)
+
+        context.prepare_minimal_config_dir(conf_seed, "")
+        context.prepare_minimal_config_dir(conf_verify, "")
+
+        self._write_config(conf_seed, seed_root)
+        self._write_config(conf_verify, verify_root)
+
+        root_name = f"ZZ_E2E_TC0035_{context.run_id}_{os.getpid()}"
+
+        source_relative = f"{root_name}/SourceDirectory/move-me.txt"
+        destination_relative = f"{root_name}/DestinationDirectory/move-me.txt"
+        anchor_relative = f"{root_name}/DestinationDirectory/anchor.txt"
+
+        seed_source_path = seed_root / source_relative
+        seed_destination_path = seed_root / destination_relative
+        seed_anchor_path = seed_root / anchor_relative
+
+        stale_source_path = stale_root / source_relative
+        stale_destination_path = stale_root / destination_relative
+        stale_anchor_path = stale_root / anchor_relative
+
+        verify_source_path = verify_root / source_relative
+        verify_destination_path = verify_root / destination_relative
+        verify_anchor_path = verify_root / anchor_relative
+
+        stale_source_dir = stale_root / f"{root_name}/SourceDirectory"
+        verify_source_dir = verify_root / f"{root_name}/SourceDirectory"
+
+        initial_content = (
+            "TC0035 remote move between directories reconciliation\n"
+            "This file is moved remotely and must reconcile locally.\n"
+        )
+        anchor_content = (
+            "TC0035 destination directory anchor\n"
+            "This ensures the destination directory exists before the move.\n"
+        )
+
+        seed_stdout = case_log_dir / "phase1_seed_stdout.log"
+        seed_stderr = case_log_dir / "phase1_seed_stderr.log"
+        remote_move_stdout = case_log_dir / "phase2_remote_move_stdout.log"
+        remote_move_stderr = case_log_dir / "phase2_remote_move_stderr.log"
+        stale_sync_stdout = case_log_dir / "phase3_stale_reconcile_stdout.log"
+        stale_sync_stderr = case_log_dir / "phase3_stale_reconcile_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        stale_manifest_file = state_dir / "stale_manifest.txt"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(remote_move_stdout),
+            str(remote_move_stderr),
+            str(stale_sync_stdout),
+            str(stale_sync_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(stale_manifest_file),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "source_relative": source_relative,
+            "destination_relative": destination_relative,
+            "anchor_relative": anchor_relative,
+            "seed_root": str(seed_root),
+            "stale_root": str(stale_root),
+            "verify_root": str(verify_root),
+            "seed_conf_dir": str(conf_seed),
+            "stale_conf_dir": str(conf_stale),
+            "verify_conf_dir": str(conf_verify),
+        }
+
+        # Phase 1: seed original remote state
+        write_text_file(seed_source_path, initial_content)
+        write_text_file(seed_anchor_path, anchor_content)
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_seed),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase1 seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed phase failed with status {seed_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Snapshot synchronised local + config/db state to create a stale client.
+        # This stale client represents a second machine that has not yet seen the move.
+        if conf_stale.exists():
+            shutil.rmtree(conf_stale)
+        if stale_root.exists():
+            shutil.rmtree(stale_root)
+
+        shutil.copytree(conf_seed, conf_stale)
+        shutil.copytree(seed_root, stale_root)
+
+        # Rewrite stale runtime config so it points at stale_root while preserving DB state.
+        self._write_config(conf_stale, stale_root)
+
+        details["stale_snapshot_source_exists_before_reconcile"] = stale_source_path.is_file()
+        details["stale_snapshot_destination_exists_before_reconcile"] = stale_destination_path.exists()
+        details["stale_snapshot_anchor_exists_before_reconcile"] = stale_anchor_path.is_file()
+
+        if not stale_source_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "stale snapshot did not preserve original source file before reconciliation",
+                artifacts,
+                details,
+            )
+
+        # Phase 2: perform the move through the seed client.
+        # This is our remote-side move mechanism.
+        seed_destination_path.parent.mkdir(parents=True, exist_ok=True)
+        seed_source_path.rename(seed_destination_path)
+
+        details["seed_source_exists_after_local_move"] = seed_source_path.exists()
+        details["seed_destination_exists_after_local_move"] = seed_destination_path.is_file()
+        details["seed_anchor_exists_after_local_move"] = seed_anchor_path.is_file()
+
+        if seed_source_path.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "seed local source path still exists immediately after move",
+                artifacts,
+                details,
+            )
+
+        if not seed_destination_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "seed local destination path does not exist immediately after move",
+                artifacts,
+                details,
+            )
+
+        remote_move_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_seed),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase2 remote move: {command_to_string(remote_move_command)}")
+        remote_move_result = run_command(remote_move_command, cwd=context.repo_root)
+        write_text_file(remote_move_stdout, remote_move_result.stdout)
+        write_text_file(remote_move_stderr, remote_move_result.stderr)
+        details["remote_move_returncode"] = remote_move_result.returncode
+
+        if remote_move_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote move propagation phase failed with status {remote_move_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 3: stale client reconciles the remote move using existing DB/local state.
+        # No --resync here, because this is specifically a reconciliation test.
+        stale_sync_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_stale),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase3 stale reconcile: {command_to_string(stale_sync_command)}")
+        stale_sync_result = run_command(stale_sync_command, cwd=context.repo_root)
+        write_text_file(stale_sync_stdout, stale_sync_result.stdout)
+        write_text_file(stale_sync_stderr, stale_sync_result.stderr)
+        details["stale_reconcile_returncode"] = stale_sync_result.returncode
+
+        stale_manifest = build_manifest(stale_root)
+        write_manifest(stale_manifest_file, stale_manifest)
+
+        details["stale_source_exists_after_reconcile"] = stale_source_path.exists()
+        details["stale_destination_exists_after_reconcile"] = stale_destination_path.is_file()
+        details["stale_anchor_exists_after_reconcile"] = stale_anchor_path.is_file()
+        details["stale_source_dir_files_after_reconcile"] = self._list_files_under(stale_source_dir)
+
+        stale_destination_content = (
+            stale_destination_path.read_text(encoding="utf-8")
+            if stale_destination_path.is_file()
+            else ""
+        )
+        details["stale_destination_content"] = stale_destination_content
+
+        if stale_sync_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"stale reconciliation phase failed with status {stale_sync_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Final clean remote verification from scratch.
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_source_exists"] = verify_source_path.exists()
+        details["verify_destination_exists"] = verify_destination_path.is_file()
+        details["verify_anchor_exists"] = verify_anchor_path.is_file()
+        details["verify_source_dir_files"] = self._list_files_under(verify_source_dir)
+
+        verify_destination_content = (
+            verify_destination_path.read_text(encoding="utf-8")
+            if verify_destination_path.is_file()
+            else ""
+        )
+        details["verify_destination_content"] = verify_destination_content
+
+        self._write_metadata(metadata_file, details)
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Stale client assertions: existing-state client must reconcile cleanly.
+        if stale_source_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"stale client still contains original source file after reconciliation: {source_relative}",
+                artifacts,
+                details,
+            )
+
+        if details["stale_source_dir_files_after_reconcile"]:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"stale client retained old files under source directory after reconciliation: {details['stale_source_dir_files_after_reconcile']}",
+                artifacts,
+                details,
+            )
+
+        if not stale_destination_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"stale client is missing moved file after reconciliation: {destination_relative}",
+                artifacts,
+                details,
+            )
+
+        if stale_destination_content != initial_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "stale client moved file content did not match expected content after reconciliation",
+                artifacts,
+                details,
+            )
+
+        if not stale_anchor_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"stale client is missing destination anchor after reconciliation: {anchor_relative}",
+                artifacts,
+                details,
+            )
+
+        # Verify assertions: fresh remote truth must also be correct.
+        if verify_source_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification still contains original source file path: {source_relative}",
+                artifacts,
+                details,
+            )
+
+        if details["verify_source_dir_files"]:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification retained old files under source directory: {details['verify_source_dir_files']}",
+                artifacts,
+                details,
+            )
+
+        if not verify_destination_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing moved file at destination path: {destination_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_destination_content != initial_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "remote verification moved file content did not match expected content",
+                artifacts,
+                details,
+            )
+
+        if not verify_anchor_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing destination anchor file: {anchor_relative}",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0036_overwrite_replace_existing_file_content_validation.py b/ci/e2e/testcases/tc0036_overwrite_replace_existing_file_content_validation.py
new file mode 100644
index 000000000..17e54dfec
--- /dev/null
+++ b/ci/e2e/testcases/tc0036_overwrite_replace_existing_file_content_validation.py
@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0036OverwriteReplaceExistingFileContentValidation(E2ETestCase):
+    case_id = "0036"
+    name = "overwrite / replace existing file content validation"
+    description = (
+        "Validate that replacing the contents of an existing local file with the same "
+        "name correctly updates remote content without leaving stale content or "
+        "metadata confusion"
+    )
+
+    def _write_config(self, config_dir: Path, sync_dir: Path) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_text = (
+            "# tc0036 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+        )
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0036",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        local_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+
+        reset_directory(local_root)
+        reset_directory(verify_root)
+
+        context.prepare_minimal_config_dir(conf_main, "")
+        context.prepare_minimal_config_dir(conf_verify, "")
+
+        self._write_config(conf_main, local_root)
+        self._write_config(conf_verify, verify_root)
+
+        root_name = f"ZZ_E2E_TC0036_{context.run_id}_{os.getpid()}"
+        relative_path = f"{root_name}/replace-me.txt"
+
+        local_file_path = local_root / relative_path
+        verify_file_path = verify_root / relative_path
+
+        initial_content = (
+            "TC0036 overwrite replace existing file content validation\n"
+            "INITIAL VERSION\n"
+            "This content must be fully replaced.\n"
+        )
+        replacement_content = (
+            "TC0036 overwrite replace existing file content validation\n"
+            "REPLACED VERSION\n"
+            "This content must be the only final content present.\n"
+        )
+
+        phase1_stdout = case_log_dir / "phase1_seed_stdout.log"
+        phase1_stderr = case_log_dir / "phase1_seed_stderr.log"
+        phase2_stdout = case_log_dir / "phase2_replace_stdout.log"
+        phase2_stderr = case_log_dir / "phase2_replace_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(phase1_stdout),
+            str(phase1_stderr),
+            str(phase2_stdout),
+            str(phase2_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "relative_path": relative_path,
+            "main_conf_dir": str(conf_main),
+            "verify_conf_dir": str(conf_verify),
+            "local_root": str(local_root),
+            "verify_root": str(verify_root),
+        }
+
+        # Phase 1: seed initial file content
+        write_text_file(local_file_path, initial_content)
+
+        phase1_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase1: {command_to_string(phase1_command)}")
+        phase1_result = run_command(phase1_command, cwd=context.repo_root)
+        write_text_file(phase1_stdout, phase1_result.stdout)
+        write_text_file(phase1_stderr, phase1_result.stderr)
+        details["phase1_returncode"] = phase1_result.returncode
+
+        if phase1_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed phase failed with status {phase1_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 2: replace the file contents locally with same filename.
+        # Graph file timestamps are second-granular and this testcase uses
+        # same-sized initial/replacement content by design. Ensure phase 2 has
+        # a distinct local modified timestamp so the overwrite is detected
+        # deterministically rather than depending on CI timing.
+        time.sleep(2)
+        write_text_file(local_file_path, replacement_content)
+
+        details["local_file_exists_after_replace"] = local_file_path.is_file()
+        details["local_file_size_after_replace"] = local_file_path.stat().st_size if local_file_path.is_file() else -1
+
+        if not local_file_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local file does not exist immediately after content replacement",
+                artifacts,
+                details,
+            )
+
+        phase2_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} phase2: {command_to_string(phase2_command)}")
+        phase2_result = run_command(phase2_command, cwd=context.repo_root)
+        write_text_file(phase2_stdout, phase2_result.stdout)
+        write_text_file(phase2_stderr, phase2_result.stderr)
+        details["phase2_returncode"] = phase2_result.returncode
+
+        if phase2_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"replace propagation phase failed with status {phase2_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 3: verify remote truth from a fresh client
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_manifest"] = verify_manifest
+        details["verified_file_exists"] = verify_file_path.exists()
+
+        verified_content = verify_file_path.read_text(encoding="utf-8") if verify_file_path.is_file() else ""
+        details["verified_content"] = verified_content
+
+        expected_manifest = [
+            root_name,
+            relative_path,
+        ]
+        details["expected_manifest"] = expected_manifest
+
+        self._write_metadata(metadata_file, details)
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not verify_file_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing expected file: {relative_path}",
+                artifacts,
+                details,
+            )
+
+        if verified_content != replacement_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "verified file content did not match the replacement content after remote verification",
+                artifacts,
+                details,
+            )
+
+        if initial_content == verified_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "verified file content still matches the initial content after replacement",
+                artifacts,
+                details,
+            )
+
+        if verify_manifest != expected_manifest:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "remote verification manifest did not match the expected single-file structure after content replacement",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0037_mtime_only_local_change_handling.py b/ci/e2e/testcases/tc0037_mtime_only_local_change_handling.py
new file mode 100644
index 000000000..a9e2af6f6
--- /dev/null
+++ b/ci/e2e/testcases/tc0037_mtime_only_local_change_handling.py
@@ -0,0 +1,570 @@
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0037MtimeOnlyLocalChangeHandling(E2ETestCase):
+    case_id = "0037"
+    name = "mtime-only local change handling"
+    description = (
+        "Validate mtime-only local file changes across direct upload, automatic "
+        "session upload for files larger than 4 MiB, and forced session upload "
+        "behaviour without changing file content"
+    )
+
+    def _write_config(self, config_dir: Path, sync_dir: Path, extra_config_lines: list[str] | None = None) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_lines = [
+            "# tc0037 config",
+            f'sync_dir = "{sync_dir}"',
+            'bypass_data_preservation = "true"',
+        ]
+
+        if extra_config_lines:
+            config_lines.extend(extra_config_lines)
+
+        config_text = "\n".join(config_lines) + "\n"
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def _write_file_with_exact_size(self, path: Path, size_bytes: int, header_text: str) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        header_bytes = header_text.encode("utf-8")
+        if len(header_bytes) > size_bytes:
+            raise ValueError(f"header_text is larger than requested file size for {path}")
+
+        filler_size = size_bytes - len(header_bytes)
+        filler_chunk = b"0123456789ABCDEF" * 4096
+
+        with path.open("wb") as handle:
+            handle.write(header_bytes)
+            while filler_size > 0:
+                chunk = filler_chunk[: min(len(filler_chunk), filler_size)]
+                handle.write(chunk)
+                filler_size -= len(chunk)
+
+    def _run_logged_command(
+        self,
+        context: E2EContext,
+        command: list[str],
+        stdout_path: Path,
+        stderr_path: Path,
+    ):
+        context.log(f"Executing Test Case {self.case_id}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_path, result.stdout)
+        write_text_file(stderr_path, result.stderr)
+        return result
+
+    def _scenario_uses_session_upload(self, file_size_bytes: int, force_session_upload: bool) -> bool:
+        if force_session_upload:
+            return True
+        return file_size_bytes > (4 * 1024 * 1024)
+
+    def _run_scenario(
+        self,
+        context: E2EContext,
+        case_work_dir: Path,
+        case_log_dir: Path,
+        state_dir: Path,
+        scenario_id: str,
+        scenario_name: str,
+        file_size_bytes: int,
+        force_session_upload: bool,
+        artifacts: list[str],
+    ) -> tuple[bool, str, dict[str, object]]:
+        scenario_work_dir = case_work_dir / scenario_id
+        scenario_log_dir = case_log_dir / scenario_id
+        scenario_state_dir = state_dir / scenario_id
+
+        reset_directory(scenario_work_dir)
+        reset_directory(scenario_log_dir)
+        reset_directory(scenario_state_dir)
+
+        local_root = scenario_work_dir / "syncroot"
+        verify_initial_root = scenario_work_dir / "verify-initial-root"
+        verify_final_root = scenario_work_dir / "verify-final-root"
+
+        conf_main = scenario_work_dir / "conf-main"
+        conf_verify_initial = scenario_work_dir / "conf-verify-initial"
+        conf_verify_final = scenario_work_dir / "conf-verify-final"
+
+        reset_directory(local_root)
+        reset_directory(verify_initial_root)
+        reset_directory(verify_final_root)
+
+        context.prepare_minimal_config_dir(conf_main, "")
+        context.prepare_minimal_config_dir(conf_verify_initial, "")
+        context.prepare_minimal_config_dir(conf_verify_final, "")
+
+        extra_config_lines: list[str] = []
+        if force_session_upload:
+            extra_config_lines.append('force_session_upload = "true"')
+
+        self._write_config(conf_main, local_root, extra_config_lines)
+        self._write_config(conf_verify_initial, verify_initial_root)
+        self._write_config(conf_verify_final, verify_final_root)
+
+        root_name = f"ZZ_E2E_TC0037_{scenario_id}_{context.run_id}_{os.getpid()}"
+        relative_path = f"{root_name}/mtime-only.txt"
+
+        local_file_path = local_root / relative_path
+        verify_initial_file_path = verify_initial_root / relative_path
+        verify_final_file_path = verify_final_root / relative_path
+
+        expected_manifest = [
+            root_name,
+            relative_path,
+        ]
+
+        uses_session_upload = self._scenario_uses_session_upload(file_size_bytes, force_session_upload)
+
+        phase1_stdout = scenario_log_dir / "phase1_seed_stdout.log"
+        phase1_stderr = scenario_log_dir / "phase1_seed_stderr.log"
+        phase2_stdout = scenario_log_dir / "phase2_verify_initial_stdout.log"
+        phase2_stderr = scenario_log_dir / "phase2_verify_initial_stderr.log"
+        phase3_stdout = scenario_log_dir / "phase3_touch_sync_stdout.log"
+        phase3_stderr = scenario_log_dir / "phase3_touch_sync_stderr.log"
+        phase4_stdout = scenario_log_dir / "phase4_verify_final_stdout.log"
+        phase4_stderr = scenario_log_dir / "phase4_verify_final_stderr.log"
+
+        verify_initial_manifest_file = scenario_state_dir / "verify_initial_manifest.txt"
+        verify_final_manifest_file = scenario_state_dir / "verify_final_manifest.txt"
+        metadata_file = scenario_state_dir / "metadata.txt"
+
+        artifacts.extend(
+            [
+                str(phase1_stdout),
+                str(phase1_stderr),
+                str(phase2_stdout),
+                str(phase2_stderr),
+                str(phase3_stdout),
+                str(phase3_stderr),
+                str(phase4_stdout),
+                str(phase4_stderr),
+                str(verify_initial_manifest_file),
+                str(verify_final_manifest_file),
+                str(metadata_file),
+            ]
+        )
+
+        details: dict[str, object] = {
+            "scenario_id": scenario_id,
+            "scenario_name": scenario_name,
+            "root_name": root_name,
+            "relative_path": relative_path,
+            "file_size_bytes": file_size_bytes,
+            "force_session_upload": force_session_upload,
+            "uses_session_upload": uses_session_upload,
+            "main_conf_dir": str(conf_main),
+            "verify_initial_conf_dir": str(conf_verify_initial),
+            "verify_final_conf_dir": str(conf_verify_final),
+            "local_root": str(local_root),
+            "verify_initial_root": str(verify_initial_root),
+            "verify_final_root": str(verify_final_root),
+            "expected_manifest": expected_manifest,
+        }
+
+        initial_header = (
+            f"TC0037 {scenario_id} {scenario_name}\n"
+            "This file content must remain unchanged.\n"
+            "Only the local modification timestamp is altered.\n"
+        )
+        self._write_file_with_exact_size(local_file_path, file_size_bytes, initial_header)
+
+        initial_local_hash = compute_quickxor_hash_file(local_file_path)
+        initial_local_size = local_file_path.stat().st_size
+
+        details["initial_local_hash"] = initial_local_hash
+        details["initial_local_size"] = initial_local_size
+
+        # Phase 1: seed
+        phase1_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        phase1_result = self._run_logged_command(context, phase1_command, phase1_stdout, phase1_stderr)
+        details["phase1_returncode"] = phase1_result.returncode
+
+        if phase1_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} seed phase failed with status {phase1_result.returncode}",
+                details,
+            )
+
+        # Phase 2: initial fresh remote verification
+        phase2_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify_initial),
+        ]
+        phase2_result = self._run_logged_command(context, phase2_command, phase2_stdout, phase2_stderr)
+        details["phase2_returncode"] = phase2_result.returncode
+
+        verify_initial_manifest = build_manifest(verify_initial_root)
+        write_manifest(verify_initial_manifest_file, verify_initial_manifest)
+        details["verify_initial_manifest"] = verify_initial_manifest
+        details["verify_initial_file_exists"] = verify_initial_file_path.is_file()
+
+        if phase2_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} initial remote verification failed with status {phase2_result.returncode}",
+                details,
+            )
+
+        if not verify_initial_file_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} initial remote verification is missing expected file: {relative_path}",
+                details,
+            )
+
+        baseline_verified_hash = compute_quickxor_hash_file(verify_initial_file_path)
+        baseline_verified_size = verify_initial_file_path.stat().st_size
+        baseline_verified_mtime = int(verify_initial_file_path.stat().st_mtime)
+
+        details["baseline_verified_hash"] = baseline_verified_hash
+        details["baseline_verified_size"] = baseline_verified_size
+        details["baseline_verified_mtime"] = baseline_verified_mtime
+
+        if verify_initial_manifest != expected_manifest:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} initial remote verification manifest did not match expected structure",
+                details,
+            )
+
+        if baseline_verified_hash != initial_local_hash:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} initial remote verification hash did not match seeded local file",
+                details,
+            )
+
+        if baseline_verified_size != initial_local_size:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} initial remote verification size did not match seeded local file",
+                details,
+            )
+
+        # Phase 3: touch local file only by explicitly setting a later mtime
+        local_hash_before_touch = compute_quickxor_hash_file(local_file_path)
+        local_mtime_before_touch = int(local_file_path.stat().st_mtime)
+
+        touched_epoch = max(int(time.time()), local_mtime_before_touch, baseline_verified_mtime) + 120
+        os.utime(local_file_path, (touched_epoch, touched_epoch))
+
+        local_hash_after_touch = compute_quickxor_hash_file(local_file_path)
+        local_mtime_after_touch = int(local_file_path.stat().st_mtime)
+
+        details["local_hash_before_touch"] = local_hash_before_touch
+        details["local_hash_after_touch"] = local_hash_after_touch
+        details["local_mtime_before_touch"] = local_mtime_before_touch
+        details["local_mtime_after_touch"] = local_mtime_after_touch
+        details["touched_epoch"] = touched_epoch
+
+        if local_hash_after_touch != local_hash_before_touch:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} local file hash changed after mtime-only touch",
+                details,
+            )
+
+        if local_mtime_after_touch <= local_mtime_before_touch:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} local file mtime did not advance after touch",
+                details,
+            )
+
+        phase3_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        phase3_result = self._run_logged_command(context, phase3_command, phase3_stdout, phase3_stderr)
+        details["phase3_returncode"] = phase3_result.returncode
+
+        phase3_combined_output = phase3_result.stdout + "\n" + phase3_result.stderr
+        content_unchanged_marker = (
+            "The last modified timestamp has changed however the file content has not changed"
+        )
+        same_hash_marker = "The local item has the same hash value as the item online"
+        correcting_timestamp_marker = "correcting online timestamp"
+
+        details["phase3_detected_content_unchanged_marker"] = content_unchanged_marker in phase3_combined_output
+        details["phase3_detected_same_hash_marker"] = same_hash_marker in phase3_combined_output
+        details["phase3_detected_correcting_timestamp_marker"] = correcting_timestamp_marker in phase3_combined_output
+
+        if phase3_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} mtime-only sync phase failed with status {phase3_result.returncode}",
+                details,
+            )
+
+        if content_unchanged_marker not in phase3_combined_output:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} did not log the expected content-unchanged timestamp handling marker",
+                details,
+            )
+
+        if same_hash_marker not in phase3_combined_output:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} did not log the expected same-hash timestamp handling marker",
+                details,
+            )
+
+        # Phase 4: final fresh remote verification
+        phase4_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify_final),
+        ]
+        phase4_result = self._run_logged_command(context, phase4_command, phase4_stdout, phase4_stderr)
+        details["phase4_returncode"] = phase4_result.returncode
+
+        verify_final_manifest = build_manifest(verify_final_root)
+        write_manifest(verify_final_manifest_file, verify_final_manifest)
+        details["verify_final_manifest"] = verify_final_manifest
+        details["verify_final_file_exists"] = verify_final_file_path.is_file()
+
+        if phase4_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} final remote verification failed with status {phase4_result.returncode}",
+                details,
+            )
+
+        if not verify_final_file_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return (
+                False,
+                f"{scenario_id} final remote verification is missing expected file: {relative_path}",
+                details,
+            )
+
+        final_verified_hash = compute_quickxor_hash_file(verify_final_file_path)
+        final_verified_size = verify_final_file_path.stat().st_size
+        final_verified_mtime = int(verify_final_file_path.stat().st_mtime)
+
+        details["final_verified_hash"] = final_verified_hash
+        details["final_verified_size"] = final_verified_size
+        details["final_verified_mtime"] = final_verified_mtime
+
+        self._write_metadata(metadata_file, details)
+
+        if verify_final_manifest != expected_manifest:
+            return (
+                False,
+                f"{scenario_id} final remote verification manifest did not match expected structure",
+                details,
+            )
+
+        if final_verified_hash != initial_local_hash:
+            return (
+                False,
+                f"{scenario_id} final verified file hash did not match original file content",
+                details,
+            )
+
+        if final_verified_size != initial_local_size:
+            return (
+                False,
+                f"{scenario_id} final verified file size did not match original file size",
+                details,
+            )
+
+        # Scenario-specific timestamp assertions
+        if uses_session_upload:
+            if abs(final_verified_mtime - touched_epoch) > 2:
+                return (
+                    False,
+                    f"{scenario_id} final remote mtime {final_verified_mtime} did not match touched local timestamp {touched_epoch} within tolerance",
+                    details,
+                )
+        else:
+            if final_verified_mtime <= baseline_verified_mtime:
+                return (
+                    False,
+                    f"{scenario_id} final remote mtime {final_verified_mtime} did not advance beyond baseline {baseline_verified_mtime}",
+                    details,
+                )
+
+            if correcting_timestamp_marker not in phase3_combined_output:
+                return (
+                    False,
+                    f"{scenario_id} did not log the expected online timestamp correction marker for direct upload handling",
+                    details,
+                )
+
+        return (True, f"{scenario_id} passed", details)
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0037",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        artifacts: list[str] = []
+        details: dict[str, object] = {}
+
+        scenarios = [
+            {
+                "scenario_id": "MT-0001",
+                "scenario_name": "small file with default upload behaviour",
+                "file_size_bytes": 1 * 1024 * 1024,
+                "force_session_upload": False,
+            },
+            {
+                "scenario_id": "MT-0002",
+                "scenario_name": "large file greater than 4 MiB with automatic session upload behaviour",
+                "file_size_bytes": 5 * 1024 * 1024,
+                "force_session_upload": False,
+            },
+            {
+                "scenario_id": "MT-0003",
+                "scenario_name": "small file with force_session_upload enabled",
+                "file_size_bytes": 1 * 1024 * 1024,
+                "force_session_upload": True,
+            },
+            {
+                "scenario_id": "MT-0004",
+                "scenario_name": "large file greater than 4 MiB with force_session_upload enabled",
+                "file_size_bytes": 5 * 1024 * 1024,
+                "force_session_upload": True,
+            },
+        ]
+
+        scenarios = [
+            scenario for scenario in scenarios if context.should_run_scenario(self.case_id, scenario["scenario_id"])
+        ]
+
+        failed_scenarios: list[str] = []
+
+        for scenario in scenarios:
+            passed, message, scenario_details = self._run_scenario(
+                context=context,
+                case_work_dir=case_work_dir,
+                case_log_dir=case_log_dir,
+                state_dir=state_dir,
+                scenario_id=scenario["scenario_id"],
+                scenario_name=scenario["scenario_name"],
+                file_size_bytes=scenario["file_size_bytes"],
+                force_session_upload=scenario["force_session_upload"],
+                artifacts=artifacts,
+            )
+
+            details[scenario["scenario_id"]] = scenario_details
+            details[f"{scenario['scenario_id']}_passed"] = passed
+            details[f"{scenario['scenario_id']}_message"] = message
+
+            if not passed:
+                failed_scenarios.append(scenario["scenario_id"])
+
+        details["executed_scenario_ids"] = [scenario["scenario_id"] for scenario in scenarios]
+        details["failed_scenario_ids"] = list(failed_scenarios)
+
+        summary_file = state_dir / "scenario-summary.txt"
+        write_text_file(
+            summary_file,
+            "\n".join(
+                f"{scenario_id}: passed={details.get(f'{scenario_id}_passed')} message={details.get(f'{scenario_id}_message')!r}"
+                for scenario_id in [scenario["scenario_id"] for scenario in scenarios]
+            )
+            + "\n",
+        )
+        artifacts.append(str(summary_file))
+
+        metadata_file = state_dir / "metadata.txt"
+        self._write_metadata(metadata_file, details)
+        artifacts.append(str(metadata_file))
+
+        if failed_scenarios:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"{len(failed_scenarios)} of {len(scenarios)} mtime-only scenarios failed: {', '.join(failed_scenarios)}",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0038_delete_and_recreate_with_same_name_validation.py b/ci/e2e/testcases/tc0038_delete_and_recreate_with_same_name_validation.py
new file mode 100644
index 000000000..d812a197c
--- /dev/null
+++ b/ci/e2e/testcases/tc0038_delete_and_recreate_with_same_name_validation.py
@@ -0,0 +1,372 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0038DeleteAndRecreateWithSameNameValidation(E2ETestCase):
+    case_id = "0038"
+    name = "delete and recreate with same name validation"
+    description = (
+        "Validate that deleting a file, syncing that deletion, then recreating "
+        "a different file with the same name correctly results in the final "
+        "remote and local state without stale item-id or state database issues"
+    )
+
+    def _write_config(self, config_dir: Path, sync_dir: Path) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_text = (
+            "# tc0038 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+        )
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0038",
+            ensure_refresh_token=False,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        context.ensure_refresh_token_available()
+
+        local_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+
+        reset_directory(local_root)
+        reset_directory(verify_root)
+
+        context.prepare_minimal_config_dir(conf_main, "")
+        context.prepare_minimal_config_dir(conf_verify, "")
+
+        self._write_config(conf_main, local_root)
+        self._write_config(conf_verify, verify_root)
+
+        root_name = f"ZZ_E2E_TC0038_{context.run_id}_{os.getpid()}"
+        target_relative = f"{root_name}/same-name-target.txt"
+        anchor_relative = f"{root_name}/anchor.txt"
+
+        local_target_path = local_root / target_relative
+        local_anchor_path = local_root / anchor_relative
+
+        verify_target_path = verify_root / target_relative
+        verify_anchor_path = verify_root / anchor_relative
+
+        initial_content = (
+            "TC0038 delete and recreate with same name validation\n"
+            "INITIAL VERSION\n"
+            "This file must be deleted and removed from remote state.\n"
+        )
+        recreated_content = (
+            "TC0038 delete and recreate with same name validation\n"
+            "RECREATED VERSION\n"
+            "This is a different file with the same name and must be the final state.\n"
+        )
+        anchor_content = (
+            "TC0038 anchor file\n"
+            "This file keeps the directory present throughout the delete/recreate cycle.\n"
+        )
+
+        phase1_stdout = case_log_dir / "phase1_seed_stdout.log"
+        phase1_stderr = case_log_dir / "phase1_seed_stderr.log"
+        phase2_stdout = case_log_dir / "phase2_delete_stdout.log"
+        phase2_stderr = case_log_dir / "phase2_delete_stderr.log"
+        phase3_stdout = case_log_dir / "phase3_recreate_stdout.log"
+        phase3_stderr = case_log_dir / "phase3_recreate_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(phase1_stdout),
+            str(phase1_stderr),
+            str(phase2_stdout),
+            str(phase2_stderr),
+            str(phase3_stdout),
+            str(phase3_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "target_relative": target_relative,
+            "anchor_relative": anchor_relative,
+            "main_conf_dir": str(conf_main),
+            "verify_conf_dir": str(conf_verify),
+            "local_root": str(local_root),
+            "verify_root": str(verify_root),
+        }
+
+        # Phase 1: seed initial remote state with target file + anchor file
+        write_text_file(local_target_path, initial_content)
+        write_text_file(local_anchor_path, anchor_content)
+
+        phase1_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase1: {command_to_string(phase1_command)}"
+        )
+        phase1_result = run_command(phase1_command, cwd=context.repo_root)
+        write_text_file(phase1_stdout, phase1_result.stdout)
+        write_text_file(phase1_stderr, phase1_result.stderr)
+        details["phase1_returncode"] = phase1_result.returncode
+
+        if phase1_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed phase failed with status {phase1_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 2: delete the target file and sync the deletion
+        if local_target_path.exists():
+            local_target_path.unlink()
+
+        details["local_target_exists_after_delete"] = local_target_path.exists()
+        details["local_anchor_exists_after_delete"] = local_anchor_path.is_file()
+
+        if local_target_path.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local target file still exists immediately after delete",
+                artifacts,
+                details,
+            )
+
+        if not local_anchor_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local anchor file is missing immediately after delete phase preparation",
+                artifacts,
+                details,
+            )
+
+        phase2_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase2: {command_to_string(phase2_command)}"
+        )
+        phase2_result = run_command(phase2_command, cwd=context.repo_root)
+        write_text_file(phase2_stdout, phase2_result.stdout)
+        write_text_file(phase2_stderr, phase2_result.stderr)
+        details["phase2_returncode"] = phase2_result.returncode
+
+        if phase2_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"delete propagation phase failed with status {phase2_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 3: recreate a different file with the same name and sync again
+        write_text_file(local_target_path, recreated_content)
+
+        details["local_target_exists_after_recreate"] = local_target_path.is_file()
+        details["local_target_size_after_recreate"] = (
+            local_target_path.stat().st_size if local_target_path.is_file() else -1
+        )
+        details["local_anchor_exists_after_recreate"] = local_anchor_path.is_file()
+
+        if not local_target_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local target file does not exist immediately after recreate",
+                artifacts,
+                details,
+            )
+
+        phase3_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase3: {command_to_string(phase3_command)}"
+        )
+        phase3_result = run_command(phase3_command, cwd=context.repo_root)
+        write_text_file(phase3_stdout, phase3_result.stdout)
+        write_text_file(phase3_stderr, phase3_result.stderr)
+        details["phase3_returncode"] = phase3_result.returncode
+
+        if phase3_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"recreate propagation phase failed with status {phase3_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 4: verify remote truth from a fresh client
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}"
+        )
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_manifest"] = verify_manifest
+        details["verified_target_exists"] = verify_target_path.is_file()
+        details["verified_anchor_exists"] = verify_anchor_path.is_file()
+
+        verified_target_content = (
+            verify_target_path.read_text(encoding="utf-8")
+            if verify_target_path.is_file()
+            else ""
+        )
+        details["verified_target_content"] = verified_target_content
+
+        expected_manifest = [
+            root_name,
+            anchor_relative,
+            target_relative,
+        ]
+        details["expected_manifest"] = expected_manifest
+
+        self._write_metadata(metadata_file, details)
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not verify_anchor_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing anchor file: {anchor_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_target_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification is missing recreated file: {target_relative}",
+                artifacts,
+                details,
+            )
+
+        if verified_target_content != recreated_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "verified file content did not match the recreated content after delete/recreate cycle",
+                artifacts,
+                details,
+            )
+
+        if verified_target_content == initial_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "verified file content still matches the initial content after delete/recreate cycle",
+                artifacts,
+                details,
+            )
+
+        if verify_manifest != expected_manifest:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "remote verification manifest did not match the expected final structure after delete/recreate cycle",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0039_empty_directory_handling_validation.py b/ci/e2e/testcases/tc0039_empty_directory_handling_validation.py
new file mode 100644
index 000000000..1b741ed03
--- /dev/null
+++ b/ci/e2e/testcases/tc0039_empty_directory_handling_validation.py
@@ -0,0 +1,508 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0039EmptyDirectoryHandling(E2ETestCase):
+    case_id = "0039"
+    name = "empty directory handling"
+    description = (
+        "Validate creation, sync, verification, and cleanup behaviour for "
+        "empty directories, including nested empty directories, to ensure "
+        "directory-only state is created and removed correctly"
+    )
+
+    def _write_config(self, config_dir: Path, sync_dir: Path) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_text = (
+            "# tc0039 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+        )
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def _write_tree_snapshot(self, root: Path, output_file: Path) -> None:
+        lines: list[str] = []
+
+        if not root.exists():
+            lines.append(f"MISSING {root}")
+            write_text_file(output_file, "\n".join(lines) + "\n")
+            return
+
+        lines.append(f"ROOT {root}")
+
+        for current_root, dirnames, filenames in os.walk(root):
+            dirnames.sort()
+            filenames.sort()
+
+            current_path = Path(current_root)
+            rel_root = current_path.relative_to(root)
+
+            if rel_root == Path("."):
+                lines.append(".")
+            else:
+                lines.append(str(rel_root) + "/")
+
+            for dirname in dirnames:
+                child = current_path / dirname
+                child_rel = child.relative_to(root)
+                lines.append(f"DIR  {child_rel}/")
+
+            for filename in filenames:
+                child = current_path / filename
+                child_rel = child.relative_to(root)
+                lines.append(f"FILE {child_rel}")
+
+        write_text_file(output_file, "\n".join(lines) + "\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0039",
+            ensure_refresh_token=False,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        context.ensure_refresh_token_available()
+
+        local_root = case_work_dir / "syncroot"
+        verify_create_root = case_work_dir / "verify-create-root"
+        verify_cleanup_root = case_work_dir / "verify-cleanup-root"
+
+        conf_main = case_work_dir / "conf-main"
+        conf_verify_create = case_work_dir / "conf-verify-create"
+        conf_verify_cleanup = case_work_dir / "conf-verify-cleanup"
+
+        reset_directory(local_root)
+        reset_directory(verify_create_root)
+        reset_directory(verify_cleanup_root)
+
+        context.prepare_minimal_config_dir(conf_main, "")
+        context.prepare_minimal_config_dir(conf_verify_create, "")
+        context.prepare_minimal_config_dir(conf_verify_cleanup, "")
+
+        self._write_config(conf_main, local_root)
+        self._write_config(conf_verify_create, verify_create_root)
+        self._write_config(conf_verify_cleanup, verify_cleanup_root)
+
+        root_name = f"ZZ_E2E_TC0039_{context.run_id}_{os.getpid()}"
+
+        anchor_relative = f"{root_name}/anchor.txt"
+        empty_dir_relative = f"{root_name}/EmptyDirectory"
+        nested_parent_relative = f"{root_name}/NestedParent"
+        nested_empty_relative = f"{root_name}/NestedParent/ChildEmptyDirectory"
+
+        local_anchor_path = local_root / anchor_relative
+        local_empty_dir_path = local_root / empty_dir_relative
+        local_nested_parent_path = local_root / nested_parent_relative
+        local_nested_empty_path = local_root / nested_empty_relative
+
+        verify_create_anchor_path = verify_create_root / anchor_relative
+        verify_create_empty_dir_path = verify_create_root / empty_dir_relative
+        verify_create_nested_parent_path = verify_create_root / nested_parent_relative
+        verify_create_nested_empty_path = verify_create_root / nested_empty_relative
+
+        verify_cleanup_anchor_path = verify_cleanup_root / anchor_relative
+        verify_cleanup_empty_dir_path = verify_cleanup_root / empty_dir_relative
+        verify_cleanup_nested_parent_path = verify_cleanup_root / nested_parent_relative
+        verify_cleanup_nested_empty_path = verify_cleanup_root / nested_empty_relative
+
+        anchor_content = (
+            "TC0039 anchor file\n"
+            "This file keeps the testcase root present while validating empty directory handling.\n"
+        )
+
+        phase1_stdout = case_log_dir / "phase1_seed_stdout.log"
+        phase1_stderr = case_log_dir / "phase1_seed_stderr.log"
+        phase2_stdout = case_log_dir / "phase2_verify_creation_stdout.log"
+        phase2_stderr = case_log_dir / "phase2_verify_creation_stderr.log"
+        phase3_stdout = case_log_dir / "phase3_cleanup_stdout.log"
+        phase3_stderr = case_log_dir / "phase3_cleanup_stderr.log"
+        phase4_stdout = case_log_dir / "phase4_verify_cleanup_stdout.log"
+        phase4_stderr = case_log_dir / "phase4_verify_cleanup_stderr.log"
+
+        verify_create_manifest_file = state_dir / "verify_create_manifest.txt"
+        verify_cleanup_manifest_file = state_dir / "verify_cleanup_manifest.txt"
+        local_tree_before_phase3_file = state_dir / "local_tree_before_phase3.txt"
+        local_manifest_before_phase3_file = state_dir / "local_manifest_before_phase3.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(phase1_stdout),
+            str(phase1_stderr),
+            str(phase2_stdout),
+            str(phase2_stderr),
+            str(phase3_stdout),
+            str(phase3_stderr),
+            str(phase4_stdout),
+            str(phase4_stderr),
+            str(verify_create_manifest_file),
+            str(verify_cleanup_manifest_file),
+            str(local_tree_before_phase3_file),
+            str(local_manifest_before_phase3_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "anchor_relative": anchor_relative,
+            "empty_dir_relative": empty_dir_relative,
+            "nested_parent_relative": nested_parent_relative,
+            "nested_empty_relative": nested_empty_relative,
+            "main_conf_dir": str(conf_main),
+            "verify_create_conf_dir": str(conf_verify_create),
+            "verify_cleanup_conf_dir": str(conf_verify_cleanup),
+            "local_root": str(local_root),
+            "verify_create_root": str(verify_create_root),
+            "verify_cleanup_root": str(verify_cleanup_root),
+        }
+
+        # Phase 1: create anchor file and empty directories, then sync
+        write_text_file(local_anchor_path, anchor_content)
+        local_empty_dir_path.mkdir(parents=True, exist_ok=True)
+        local_nested_empty_path.mkdir(parents=True, exist_ok=True)
+
+        details["local_anchor_exists_before_seed"] = local_anchor_path.is_file()
+        details["local_empty_dir_exists_before_seed"] = local_empty_dir_path.is_dir()
+        details["local_nested_parent_exists_before_seed"] = local_nested_parent_path.is_dir()
+        details["local_nested_empty_exists_before_seed"] = local_nested_empty_path.is_dir()
+
+        expected_creation_manifest = [
+            root_name,
+            anchor_relative,
+            empty_dir_relative,
+            nested_parent_relative,
+            nested_empty_relative,
+        ]
+        details["expected_creation_manifest"] = expected_creation_manifest
+
+        phase1_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase1: {command_to_string(phase1_command)}"
+        )
+        phase1_result = run_command(phase1_command, cwd=context.repo_root)
+        write_text_file(phase1_stdout, phase1_result.stdout)
+        write_text_file(phase1_stderr, phase1_result.stderr)
+        details["phase1_returncode"] = phase1_result.returncode
+
+        if phase1_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed phase failed with status {phase1_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 2: verify remote creation with a fresh client
+        phase2_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify_create),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase2: {command_to_string(phase2_command)}"
+        )
+        phase2_result = run_command(phase2_command, cwd=context.repo_root)
+        write_text_file(phase2_stdout, phase2_result.stdout)
+        write_text_file(phase2_stderr, phase2_result.stderr)
+        details["phase2_returncode"] = phase2_result.returncode
+
+        verify_create_manifest = build_manifest(verify_create_root)
+        write_manifest(verify_create_manifest_file, verify_create_manifest)
+        details["verify_create_manifest"] = verify_create_manifest
+        details["verify_create_anchor_exists"] = verify_create_anchor_path.is_file()
+        details["verify_create_empty_dir_exists"] = verify_create_empty_dir_path.is_dir()
+        details["verify_create_nested_parent_exists"] = verify_create_nested_parent_path.is_dir()
+        details["verify_create_nested_empty_exists"] = verify_create_nested_empty_path.is_dir()
+
+        if phase2_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"creation verification failed with status {phase2_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not verify_create_anchor_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"creation verification is missing anchor file: {anchor_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_create_empty_dir_path.is_dir():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"creation verification is missing empty directory: {empty_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_create_nested_parent_path.is_dir():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"creation verification is missing nested parent directory: {nested_parent_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_create_nested_empty_path.is_dir():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"creation verification is missing nested empty directory: {nested_empty_relative}",
+                artifacts,
+                details,
+            )
+
+        if sorted(verify_create_manifest) != sorted(expected_creation_manifest):
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "creation verification manifest did not match expected structure",
+                artifacts,
+                details,
+            )
+
+        # Phase 3: remove the empty directories locally and sync cleanup
+        if local_nested_empty_path.exists():
+            local_nested_empty_path.rmdir()
+        if local_empty_dir_path.exists():
+            local_empty_dir_path.rmdir()
+        if local_nested_parent_path.exists():
+            local_nested_parent_path.rmdir()
+
+        details["local_empty_dir_exists_after_cleanup_prep"] = local_empty_dir_path.exists()
+        details["local_nested_parent_exists_after_cleanup_prep"] = local_nested_parent_path.exists()
+        details["local_nested_empty_exists_after_cleanup_prep"] = local_nested_empty_path.exists()
+        details["local_anchor_exists_after_cleanup_prep"] = local_anchor_path.is_file()
+
+        expected_local_before_phase3_manifest = [
+            root_name,
+            anchor_relative,
+        ]
+        details["expected_local_before_phase3_manifest"] = expected_local_before_phase3_manifest
+
+        local_manifest_before_phase3 = build_manifest(local_root)
+        write_manifest(local_manifest_before_phase3_file, local_manifest_before_phase3)
+        self._write_tree_snapshot(local_root, local_tree_before_phase3_file)
+
+        details["local_manifest_before_phase3"] = local_manifest_before_phase3
+
+        if (
+            local_empty_dir_path.exists()
+            or local_nested_parent_path.exists()
+            or local_nested_empty_path.exists()
+        ):
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local empty directory cleanup preparation failed before sync",
+                artifacts,
+                details,
+            )
+
+        if not local_anchor_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local anchor file is missing before cleanup sync",
+                artifacts,
+                details,
+            )
+
+        if sorted(local_manifest_before_phase3) != sorted(expected_local_before_phase3_manifest):
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local filesystem manifest before cleanup sync did not match expected structure",
+                artifacts,
+                details,
+            )
+
+        phase3_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase3: {command_to_string(phase3_command)}"
+        )
+        phase3_result = run_command(phase3_command, cwd=context.repo_root)
+        write_text_file(phase3_stdout, phase3_result.stdout)
+        write_text_file(phase3_stderr, phase3_result.stderr)
+        details["phase3_returncode"] = phase3_result.returncode
+
+        if phase3_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"cleanup propagation phase failed with status {phase3_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 4: verify remote cleanup with a fresh client
+        expected_cleanup_manifest = [
+            root_name,
+            anchor_relative,
+        ]
+        details["expected_cleanup_manifest"] = expected_cleanup_manifest
+
+        phase4_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify_cleanup),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase4: {command_to_string(phase4_command)}"
+        )
+        phase4_result = run_command(phase4_command, cwd=context.repo_root)
+        write_text_file(phase4_stdout, phase4_result.stdout)
+        write_text_file(phase4_stderr, phase4_result.stderr)
+        details["phase4_returncode"] = phase4_result.returncode
+
+        verify_cleanup_manifest = build_manifest(verify_cleanup_root)
+        write_manifest(verify_cleanup_manifest_file, verify_cleanup_manifest)
+        details["verify_cleanup_manifest"] = verify_cleanup_manifest
+        details["verify_cleanup_anchor_exists"] = verify_cleanup_anchor_path.is_file()
+        details["verify_cleanup_empty_dir_exists"] = verify_cleanup_empty_dir_path.exists()
+        details["verify_cleanup_nested_parent_exists"] = verify_cleanup_nested_parent_path.exists()
+        details["verify_cleanup_nested_empty_exists"] = verify_cleanup_nested_empty_path.exists()
+
+        self._write_metadata(metadata_file, details)
+
+        if phase4_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"cleanup verification failed with status {phase4_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not verify_cleanup_anchor_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"cleanup verification is missing anchor file: {anchor_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_cleanup_empty_dir_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"cleanup verification still contains removed empty directory: {empty_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_cleanup_nested_parent_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"cleanup verification still contains removed nested parent directory: {nested_parent_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_cleanup_nested_empty_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"cleanup verification still contains removed nested empty directory: {nested_empty_relative}",
+                artifacts,
+                details,
+            )
+
+        if sorted(verify_cleanup_manifest) != sorted(expected_cleanup_manifest):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "cleanup verification manifest did not match expected final structure",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0040_nested_tree_rename_and_delete_stress_validation.py b/ci/e2e/testcases/tc0040_nested_tree_rename_and_delete_stress_validation.py
new file mode 100644
index 000000000..5a2f47951
--- /dev/null
+++ b/ci/e2e/testcases/tc0040_nested_tree_rename_and_delete_stress_validation.py
@@ -0,0 +1,582 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import (
+    command_to_string,
+    compute_quickxor_hash_file,
+    reset_directory,
+    run_command,
+    write_onedrive_config,
+    write_text_file,
+)
+
+
+class TestCase0040NestedTreeRenameAndDeleteStressValidation(E2ETestCase):
+    case_id = "0040"
+    name = "nested tree rename and delete stress validation"
+    description = (
+        "Validate a combined nested-tree mutation scenario involving multiple renames, "
+        "one deletion, and one new file creation before a single sync, ensuring the "
+        "final remote and fresh-download state is correct with no stale paths left behind"
+    )
+
+    def _write_config(self, config_dir: Path, sync_dir: Path) -> None:
+        config_path = config_dir / "config"
+        backup_path = config_dir / ".config.backup"
+        hash_path = config_dir / ".config.hash"
+
+        config_text = (
+            "# tc0040 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+        )
+
+        write_onedrive_config(config_path, config_text)
+        write_onedrive_config(backup_path, config_text)
+        hash_path.write_text(compute_quickxor_hash_file(config_path), encoding="utf-8")
+
+        os.chmod(config_path, 0o600)
+        os.chmod(backup_path, 0o600)
+        os.chmod(hash_path, 0o600)
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0040",
+            ensure_refresh_token=False,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        context.ensure_refresh_token_available()
+
+        local_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+
+        reset_directory(local_root)
+        reset_directory(verify_root)
+
+        context.prepare_minimal_config_dir(conf_main, "")
+        context.prepare_minimal_config_dir(conf_verify, "")
+
+        self._write_config(conf_main, local_root)
+        self._write_config(conf_verify, verify_root)
+
+        root_name = f"ZZ_E2E_TC0040_{context.run_id}_{os.getpid()}"
+
+        anchor_relative = f"{root_name}/anchor.txt"
+
+        original_parent_dir_relative = f"{root_name}/TreeAlpha"
+        original_nested_dir_relative = f"{root_name}/TreeAlpha/Level1A"
+        original_file_alpha_relative = f"{root_name}/TreeAlpha/Level1A/Level2A/file-alpha.txt"
+        original_file_beta_relative = f"{root_name}/TreeAlpha/Level1A/Level2B/file-beta.txt"
+        original_file_gamma_relative = f"{root_name}/TreeAlpha/Level1B/file-gamma.txt"
+
+        renamed_parent_dir_relative = f"{root_name}/TreeOmega"
+        renamed_nested_dir_relative = f"{root_name}/TreeOmega/Level1A_Renamed"
+        renamed_file_alpha_relative = f"{root_name}/TreeOmega/Level1A_Renamed/Level2A/file-alpha.txt"
+        deleted_file_beta_relative = f"{root_name}/TreeOmega/Level1A_Renamed/Level2B/file-beta.txt"
+        renamed_file_gamma_relative = f"{root_name}/TreeOmega/Level1B/file-gamma-renamed.txt"
+        new_file_delta_relative = f"{root_name}/TreeOmega/Level1A_Renamed/Level2B/new-delta.txt"
+
+        local_anchor_path = local_root / anchor_relative
+        local_original_parent_dir_path = local_root / original_parent_dir_relative
+        local_original_nested_dir_path = local_root / original_nested_dir_relative
+        local_original_file_alpha_path = local_root / original_file_alpha_relative
+        local_original_file_beta_path = local_root / original_file_beta_relative
+        local_original_file_gamma_path = local_root / original_file_gamma_relative
+
+        local_renamed_parent_dir_path = local_root / renamed_parent_dir_relative
+        local_renamed_nested_dir_path = local_root / renamed_nested_dir_relative
+        local_renamed_file_alpha_path = local_root / renamed_file_alpha_relative
+        local_deleted_file_beta_path = local_root / deleted_file_beta_relative
+        local_renamed_file_gamma_path = local_root / renamed_file_gamma_relative
+        local_new_file_delta_path = local_root / new_file_delta_relative
+
+        verify_anchor_path = verify_root / anchor_relative
+        verify_original_parent_dir_path = verify_root / original_parent_dir_relative
+        verify_original_nested_dir_path = verify_root / original_nested_dir_relative
+        verify_original_file_alpha_path = verify_root / original_file_alpha_relative
+        verify_original_file_beta_path = verify_root / original_file_beta_relative
+        verify_original_file_gamma_path = verify_root / original_file_gamma_relative
+
+        verify_renamed_parent_dir_path = verify_root / renamed_parent_dir_relative
+        verify_renamed_nested_dir_path = verify_root / renamed_nested_dir_relative
+        verify_renamed_file_alpha_path = verify_root / renamed_file_alpha_relative
+        verify_deleted_file_beta_path = verify_root / deleted_file_beta_relative
+        verify_renamed_file_gamma_path = verify_root / renamed_file_gamma_relative
+        verify_new_file_delta_path = verify_root / new_file_delta_relative
+
+        anchor_content = (
+            "TC0040 anchor file\n"
+            "This file keeps the testcase root stable while nested tree mutations occur.\n"
+        )
+        file_alpha_content = (
+            "TC0040 nested tree rename and delete stress validation\n"
+            "FILE ALPHA\n"
+            "This file should survive parent and nested directory renames unchanged.\n"
+        )
+        file_beta_content = (
+            "TC0040 nested tree rename and delete stress validation\n"
+            "FILE BETA\n"
+            "This file should be deleted before the second sync.\n"
+        )
+        file_gamma_content = (
+            "TC0040 nested tree rename and delete stress validation\n"
+            "FILE GAMMA\n"
+            "This file should be renamed before the second sync.\n"
+        )
+        new_file_delta_content = (
+            "TC0040 nested tree rename and delete stress validation\n"
+            "FILE DELTA\n"
+            "This file is newly created inside the renamed nested directory before the second sync.\n"
+        )
+
+        phase1_stdout = case_log_dir / "phase1_seed_stdout.log"
+        phase1_stderr = case_log_dir / "phase1_seed_stderr.log"
+        phase2_stdout = case_log_dir / "phase2_mutation_stdout.log"
+        phase2_stderr = case_log_dir / "phase2_mutation_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+
+        local_manifest_before_phase2_file = state_dir / "local_manifest_before_phase2.txt"
+        local_manifest_after_mutation_file = state_dir / "local_manifest_after_mutation.txt"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(phase1_stdout),
+            str(phase1_stderr),
+            str(phase2_stdout),
+            str(phase2_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(local_manifest_before_phase2_file),
+            str(local_manifest_after_mutation_file),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "anchor_relative": anchor_relative,
+            "original_parent_dir_relative": original_parent_dir_relative,
+            "original_nested_dir_relative": original_nested_dir_relative,
+            "original_file_alpha_relative": original_file_alpha_relative,
+            "original_file_beta_relative": original_file_beta_relative,
+            "original_file_gamma_relative": original_file_gamma_relative,
+            "renamed_parent_dir_relative": renamed_parent_dir_relative,
+            "renamed_nested_dir_relative": renamed_nested_dir_relative,
+            "renamed_file_alpha_relative": renamed_file_alpha_relative,
+            "deleted_file_beta_relative": deleted_file_beta_relative,
+            "renamed_file_gamma_relative": renamed_file_gamma_relative,
+            "new_file_delta_relative": new_file_delta_relative,
+            "main_conf_dir": str(conf_main),
+            "verify_conf_dir": str(conf_verify),
+            "local_root": str(local_root),
+            "verify_root": str(verify_root),
+        }
+
+        # Phase 1: seed the original nested tree
+        write_text_file(local_anchor_path, anchor_content)
+        write_text_file(local_original_file_alpha_path, file_alpha_content)
+        write_text_file(local_original_file_beta_path, file_beta_content)
+        write_text_file(local_original_file_gamma_path, file_gamma_content)
+
+        phase1_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase1: {command_to_string(phase1_command)}"
+        )
+        phase1_result = run_command(phase1_command, cwd=context.repo_root)
+        write_text_file(phase1_stdout, phase1_result.stdout)
+        write_text_file(phase1_stderr, phase1_result.stderr)
+        details["phase1_returncode"] = phase1_result.returncode
+
+        if phase1_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"seed phase failed with status {phase1_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        local_manifest_before_phase2 = build_manifest(local_root)
+        write_manifest(local_manifest_before_phase2_file, local_manifest_before_phase2)
+
+        # Phase 2 preparation: perform all local mutations before a single sync
+        local_original_parent_dir_path.rename(local_renamed_parent_dir_path)
+        local_renamed_parent_dir_path.joinpath("Level1A").rename(local_renamed_nested_dir_path)
+        local_renamed_parent_dir_path.joinpath("Level1B", "file-gamma.txt").rename(local_renamed_file_gamma_path)
+
+        if local_deleted_file_beta_path.exists():
+            local_deleted_file_beta_path.unlink()
+
+        write_text_file(local_new_file_delta_path, new_file_delta_content)
+
+        local_manifest_after_mutation = build_manifest(local_root)
+        write_manifest(local_manifest_after_mutation_file, local_manifest_after_mutation)
+
+        details["local_original_parent_dir_exists_after_mutation"] = local_original_parent_dir_path.exists()
+        details["local_original_nested_dir_exists_after_mutation"] = local_original_nested_dir_path.exists()
+        details["local_original_file_alpha_exists_after_mutation"] = local_original_file_alpha_path.exists()
+        details["local_original_file_beta_exists_after_mutation"] = local_original_file_beta_path.exists()
+        details["local_original_file_gamma_exists_after_mutation"] = local_original_file_gamma_path.exists()
+
+        details["local_renamed_parent_dir_exists_after_mutation"] = local_renamed_parent_dir_path.is_dir()
+        details["local_renamed_nested_dir_exists_after_mutation"] = local_renamed_nested_dir_path.is_dir()
+        details["local_renamed_file_alpha_exists_after_mutation"] = local_renamed_file_alpha_path.is_file()
+        details["local_deleted_file_beta_exists_after_mutation"] = local_deleted_file_beta_path.exists()
+        details["local_renamed_file_gamma_exists_after_mutation"] = local_renamed_file_gamma_path.is_file()
+        details["local_new_file_delta_exists_after_mutation"] = local_new_file_delta_path.is_file()
+
+        if local_original_parent_dir_path.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local original parent directory still exists immediately after mutation",
+                artifacts,
+                details,
+            )
+
+        if local_original_nested_dir_path.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local original nested directory still exists immediately after mutation",
+                artifacts,
+                details,
+            )
+
+        if local_original_file_gamma_path.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local original gamma filename still exists immediately after mutation",
+                artifacts,
+                details,
+            )
+
+        if local_deleted_file_beta_path.exists():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local beta file still exists immediately after delete mutation",
+                artifacts,
+                details,
+            )
+
+        if not local_renamed_parent_dir_path.is_dir():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local renamed parent directory is missing immediately after mutation",
+                artifacts,
+                details,
+            )
+
+        if not local_renamed_nested_dir_path.is_dir():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local renamed nested directory is missing immediately after mutation",
+                artifacts,
+                details,
+            )
+
+        if not local_renamed_file_alpha_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local alpha file is missing after parent and nested directory renames",
+                artifacts,
+                details,
+            )
+
+        if not local_renamed_file_gamma_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local renamed gamma file is missing immediately after mutation",
+                artifacts,
+                details,
+            )
+
+        if not local_new_file_delta_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "local new delta file is missing immediately after mutation",
+                artifacts,
+                details,
+            )
+
+        phase2_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} phase2: {command_to_string(phase2_command)}"
+        )
+        phase2_result = run_command(phase2_command, cwd=context.repo_root)
+        write_text_file(phase2_stdout, phase2_result.stdout)
+        write_text_file(phase2_stderr, phase2_result.stderr)
+        details["phase2_returncode"] = phase2_result.returncode
+
+        if phase2_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"mutation propagation phase failed with status {phase2_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        # Phase 3: verify the final remote truth from a fresh client
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(
+            f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}"
+        )
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_anchor_exists"] = verify_anchor_path.is_file()
+
+        details["verify_original_parent_dir_exists"] = verify_original_parent_dir_path.exists()
+        details["verify_original_nested_dir_exists"] = verify_original_nested_dir_path.exists()
+        details["verify_original_file_alpha_exists"] = verify_original_file_alpha_path.exists()
+        details["verify_original_file_beta_exists"] = verify_original_file_beta_path.exists()
+        details["verify_original_file_gamma_exists"] = verify_original_file_gamma_path.exists()
+
+        details["verify_renamed_parent_dir_exists"] = verify_renamed_parent_dir_path.is_dir()
+        details["verify_renamed_nested_dir_exists"] = verify_renamed_nested_dir_path.is_dir()
+        details["verify_renamed_file_alpha_exists"] = verify_renamed_file_alpha_path.is_file()
+        details["verify_deleted_file_beta_exists"] = verify_deleted_file_beta_path.exists()
+        details["verify_renamed_file_gamma_exists"] = verify_renamed_file_gamma_path.is_file()
+        details["verify_new_file_delta_exists"] = verify_new_file_delta_path.is_file()
+
+        verify_renamed_file_alpha_content = (
+            verify_renamed_file_alpha_path.read_text(encoding="utf-8")
+            if verify_renamed_file_alpha_path.is_file()
+            else ""
+        )
+        verify_renamed_file_gamma_content = (
+            verify_renamed_file_gamma_path.read_text(encoding="utf-8")
+            if verify_renamed_file_gamma_path.is_file()
+            else ""
+        )
+        verify_new_file_delta_content = (
+            verify_new_file_delta_path.read_text(encoding="utf-8")
+            if verify_new_file_delta_path.is_file()
+            else ""
+        )
+
+        details["verify_renamed_file_alpha_content"] = verify_renamed_file_alpha_content
+        details["verify_renamed_file_gamma_content"] = verify_renamed_file_gamma_content
+        details["verify_new_file_delta_content"] = verify_new_file_delta_content
+
+        self._write_metadata(metadata_file, details)
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not verify_anchor_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification is missing anchor file: {anchor_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_original_parent_dir_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification still contains original parent directory: {original_parent_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_original_nested_dir_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification still contains original nested directory: {original_nested_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_original_file_alpha_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification still contains original alpha path: {original_file_alpha_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_original_file_beta_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification still contains deleted beta path: {original_file_beta_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_original_file_gamma_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification still contains original gamma path: {original_file_gamma_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_renamed_parent_dir_path.is_dir():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification is missing renamed parent directory: {renamed_parent_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_renamed_nested_dir_path.is_dir():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification is missing renamed nested directory: {renamed_nested_dir_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_renamed_file_alpha_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification is missing alpha file at renamed path: {renamed_file_alpha_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_deleted_file_beta_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification still contains deleted beta file: {deleted_file_beta_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_renamed_file_gamma_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification is missing renamed gamma file: {renamed_file_gamma_relative}",
+                artifacts,
+                details,
+            )
+
+        if not verify_new_file_delta_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"verification is missing new delta file: {new_file_delta_relative}",
+                artifacts,
+                details,
+            )
+
+        if verify_renamed_file_alpha_content != file_alpha_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "alpha file content did not survive nested directory renames unchanged",
+                artifacts,
+                details,
+            )
+
+        if verify_renamed_file_gamma_content != file_gamma_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "renamed gamma file content did not match the original content",
+                artifacts,
+                details,
+            )
+
+        if verify_new_file_delta_content != new_file_delta_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "new delta file content did not match the created content",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0041_monitor_mode_local_create_upload.py b/ci/e2e/testcases/tc0041_monitor_mode_local_create_upload.py
new file mode 100644
index 000000000..95ee2caa5
--- /dev/null
+++ b/ci/e2e/testcases/tc0041_monitor_mode_local_create_upload.py
@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+
+
+class TestCase0041MonitorModeLocalCreateUpload(MonitorModeTestCaseBase):
+    case_id = "0041"
+    name = "monitor mode local create upload"
+    description = "Start --monitor, create a local file, and validate it uploads without restarting the client"
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def _build_config_text(self, sync_dir: Path, app_log_dir: Path) -> str:
+        return (
+            "# tc0041 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+            'enable_logging = "true"\n'
+            f'log_dir = "{app_log_dir}"\n'
+            'monitor_interval = "5"\n'
+            'monitor_fullscan_frequency = "1"\n'
+        )
+
+    def _read_stdout(self, stdout_file: Path) -> str:
+        if not stdout_file.exists():
+            return ""
+        try:
+            return stdout_file.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return ""
+
+    def _wait_for_initial_sync_complete(
+        self,
+        stdout_file: Path,
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+        marker = "Sync with Microsoft OneDrive is complete"
+
+        while time.time() < deadline:
+            if marker in self._read_stdout(stdout_file):
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def _wait_for_monitor_patterns(
+        self,
+        stdout_file: Path,
+        required_patterns: list[str],
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+
+        while time.time() < deadline:
+            content = self._read_stdout(stdout_file)
+            if all(pattern in content for pattern in required_patterns):
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0041",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0041_{context.run_id}_{os.getpid()}"
+        baseline_relative = f"{root_name}/baseline.txt"
+        created_relative = f"{root_name}/monitor-created.txt"
+
+        baseline_local_path = sync_root / baseline_relative
+        created_local_path = sync_root / created_relative
+        created_verify_path = verify_root / created_relative
+
+        baseline_content = "TC0041 baseline\n"
+        created_content = (
+            "TC0041 monitor mode local create upload\n"
+            "This file was created while --monitor was already running.\n"
+        )
+
+        context.bootstrap_config_dir(conf_main)
+        write_text_file(conf_main / "config", self._build_config_text(sync_root, app_log_dir))
+
+        context.bootstrap_config_dir(conf_verify)
+        write_text_file(
+            conf_verify / "config",
+            (
+                "# tc0041 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        write_text_file(baseline_local_path, baseline_content)
+
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(monitor_stdout),
+            str(monitor_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+        if app_log_dir.exists():
+            artifacts.append(str(app_log_dir))
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "baseline_relative": baseline_relative,
+            "created_relative": created_relative,
+            "sync_root": str(sync_root),
+            "verify_root": str(verify_root),
+            "conf_main": str(conf_main),
+            "conf_verify": str(conf_verify),
+        }
+
+        monitor_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--monitor",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+
+        process, initial_sync_complete = self._launch_monitor_process(
+            context,
+            monitor_command,
+            monitor_stdout,
+            monitor_stderr,
+        )
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    "Monitor mode did not complete the initial sync within the expected time",
+                    artifacts,
+                    details,
+                )
+
+            context.log(f"Test Case {self.case_id}: creating local file while monitor is running: {created_relative}")
+            write_text_file(created_local_path, created_content)
+            details["created_local_exists_after_write"] = created_local_path.is_file()
+
+            required_patterns = [
+                f"Uploading new file: {created_relative} ... done",
+            ]
+            mutation_processed = self._wait_for_monitor_patterns(
+                monitor_stdout,
+                required_patterns=required_patterns,
+                timeout_seconds=120,
+            )
+            details["mutation_processed"] = mutation_processed
+            details["mutation_required_patterns"] = required_patterns
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_created_exists"] = created_verify_path.is_file()
+        details["verify_created_content"] = (
+            created_verify_path.read_text(encoding="utf-8")
+            if created_verify_path.is_file()
+            else ""
+        )
+
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Monitor mode did not process the local create event before shutdown",
+                artifacts,
+                details,
+            )
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not created_verify_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification is missing created file: {created_relative}",
+                artifacts,
+                details,
+            )
+
+        if details["verify_created_content"] != created_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Created file content did not match after remote verification",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0042_monitor_mode_local_modify_upload.py b/ci/e2e/testcases/tc0042_monitor_mode_local_modify_upload.py
new file mode 100644
index 000000000..98baee07e
--- /dev/null
+++ b/ci/e2e/testcases/tc0042_monitor_mode_local_modify_upload.py
@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+
+
+class TestCase0042MonitorModeLocalModifyUpload(MonitorModeTestCaseBase):
+    case_id = "0042"
+    name = "monitor mode local modify upload"
+    description = "Modify an existing local file under --monitor and validate the update propagates"
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def _build_config_text(self, sync_dir: Path, app_log_dir: Path) -> str:
+        return (
+            "# tc0042 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+            'enable_logging = "true"\n'
+            f'log_dir = "{app_log_dir}"\n'
+            'monitor_interval = "5"\n'
+            'monitor_fullscan_frequency = "1"\n'
+        )
+
+    def _read_stdout(self, stdout_file: Path) -> str:
+        if not stdout_file.exists():
+            return ""
+        try:
+            return stdout_file.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return ""
+
+    def _wait_for_initial_sync_complete(
+        self,
+        stdout_file: Path,
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+        marker = "Sync with Microsoft OneDrive is complete"
+
+        while time.time() < deadline:
+            if marker in self._read_stdout(stdout_file):
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def _wait_for_monitor_patterns(
+        self,
+        stdout_file: Path,
+        required_patterns: list[str],
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+
+        while time.time() < deadline:
+            content = self._read_stdout(stdout_file)
+            if all(pattern in content for pattern in required_patterns):
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0042",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0042_{context.run_id}_{os.getpid()}"
+        relative_path = f"{root_name}/modify-me.txt"
+
+        local_file_path = sync_root / relative_path
+        verify_file_path = verify_root / relative_path
+
+        initial_content = (
+            "TC0042 monitor mode local modify upload\n"
+            "INITIAL CONTENT\n"
+        )
+        modified_content = (
+            "TC0042 monitor mode local modify upload\n"
+            "MODIFIED CONTENT\n"
+            "This update occurred while --monitor was active.\n"
+        )
+
+        context.bootstrap_config_dir(conf_main)
+        write_text_file(conf_main / "config", self._build_config_text(sync_root, app_log_dir))
+
+        context.bootstrap_config_dir(conf_verify)
+        write_text_file(
+            conf_verify / "config",
+            (
+                "# tc0042 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(monitor_stdout),
+            str(monitor_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+        if app_log_dir.exists():
+            artifacts.append(str(app_log_dir))
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "relative_path": relative_path,
+            "sync_root": str(sync_root),
+            "verify_root": str(verify_root),
+            "conf_main": str(conf_main),
+            "conf_verify": str(conf_verify),
+        }
+
+        write_text_file(local_file_path, initial_content)
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Seed phase failed with status {seed_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        monitor_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--monitor",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+
+        process, initial_sync_complete = self._launch_monitor_process(
+            context,
+            monitor_command,
+            monitor_stdout,
+            monitor_stderr,
+        )
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    "Monitor mode did not complete the initial sync within the expected time",
+                    artifacts,
+                    details,
+                )
+
+            context.log(f"Test Case {self.case_id}: modifying local file while monitor is running: {relative_path}")
+            time.sleep(1.5)
+            write_text_file(local_file_path, modified_content)
+            details["local_file_exists_after_modify"] = local_file_path.is_file()
+
+            required_patterns = [
+                f"Uploading modified file: {relative_path} ... done",
+            ]
+            mutation_processed = self._wait_for_monitor_patterns(
+                monitor_stdout,
+                required_patterns=required_patterns,
+                timeout_seconds=120,
+            )
+            details["mutation_processed"] = mutation_processed
+            details["mutation_required_patterns"] = required_patterns
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_file_exists"] = verify_file_path.is_file()
+        details["verify_content"] = verify_file_path.read_text(encoding="utf-8") if verify_file_path.is_file() else ""
+
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Monitor mode did not process the local modify event before shutdown",
+                artifacts,
+                details,
+            )
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not verify_file_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification is missing modified file: {relative_path}",
+                artifacts,
+                details,
+            )
+
+        if details["verify_content"] != modified_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Modified file content did not match after remote verification",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0043_monitor_mode_local_delete_propagation.py b/ci/e2e/testcases/tc0043_monitor_mode_local_delete_propagation.py
new file mode 100644
index 000000000..30735ed8c
--- /dev/null
+++ b/ci/e2e/testcases/tc0043_monitor_mode_local_delete_propagation.py
@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+
+
+class TestCase0043MonitorModeLocalDeletePropagation(MonitorModeTestCaseBase):
+    case_id = "0043"
+    name = "monitor mode local delete propagation"
+    description = "Delete a local file under --monitor and validate the remote delete occurs as expected"
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def _build_config_text(self, sync_dir: Path, app_log_dir: Path) -> str:
+        return (
+            "# tc0043 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+            'enable_logging = "true"\n'
+            f'log_dir = "{app_log_dir}"\n'
+            'monitor_interval = "5"\n'
+            'monitor_fullscan_frequency = "1"\n'
+        )
+
+    def _read_stdout(self, stdout_file: Path) -> str:
+        if not stdout_file.exists():
+            return ""
+        try:
+            return stdout_file.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return ""
+
+    def _wait_for_initial_sync_complete(
+        self,
+        stdout_file: Path,
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+        marker = "Sync with Microsoft OneDrive is complete"
+
+        while time.time() < deadline:
+            if marker in self._read_stdout(stdout_file):
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def _wait_for_monitor_patterns(
+        self,
+        stdout_file: Path,
+        required_patterns: list[str],
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+
+        while time.time() < deadline:
+            content = self._read_stdout(stdout_file)
+            if all(pattern in content for pattern in required_patterns):
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0043",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0043_{context.run_id}_{os.getpid()}"
+        keep_relative = f"{root_name}/anchor.txt"
+        delete_relative = f"{root_name}/delete-me.txt"
+
+        keep_local_path = sync_root / keep_relative
+        delete_local_path = sync_root / delete_relative
+
+        keep_verify_path = verify_root / keep_relative
+        delete_verify_path = verify_root / delete_relative
+
+        keep_content = "TC0043 anchor\n"
+        delete_content = (
+            "TC0043 monitor mode local delete propagation\n"
+            "This file should be removed while --monitor is active.\n"
+        )
+
+        context.bootstrap_config_dir(conf_main)
+        write_text_file(conf_main / "config", self._build_config_text(sync_root, app_log_dir))
+
+        context.bootstrap_config_dir(conf_verify)
+        write_text_file(
+            conf_verify / "config",
+            (
+                "# tc0043 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(monitor_stdout),
+            str(monitor_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+        if app_log_dir.exists():
+            artifacts.append(str(app_log_dir))
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "keep_relative": keep_relative,
+            "delete_relative": delete_relative,
+            "sync_root": str(sync_root),
+            "verify_root": str(verify_root),
+            "conf_main": str(conf_main),
+            "conf_verify": str(conf_verify),
+        }
+
+        write_text_file(keep_local_path, keep_content)
+        write_text_file(delete_local_path, delete_content)
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Seed phase failed with status {seed_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        monitor_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--monitor",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+
+        process, initial_sync_complete = self._launch_monitor_process(
+            context,
+            monitor_command,
+            monitor_stdout,
+            monitor_stderr,
+        )
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    "Monitor mode did not complete the initial sync within the expected time",
+                    artifacts,
+                    details,
+                )
+
+            context.log(f"Test Case {self.case_id}: deleting local file while monitor is running: {delete_relative}")
+            if delete_local_path.exists():
+                delete_local_path.unlink()
+
+            details["local_deleted_exists_after_unlink"] = delete_local_path.exists()
+
+            required_patterns = [
+                f"Deleting item from Microsoft OneDrive: {delete_relative}",
+            ]
+            mutation_processed = self._wait_for_monitor_patterns(
+                monitor_stdout,
+                required_patterns=required_patterns,
+                timeout_seconds=120,
+            )
+            details["mutation_processed"] = mutation_processed
+            details["mutation_required_patterns"] = required_patterns
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_keep_exists"] = keep_verify_path.is_file()
+        details["verify_deleted_exists"] = delete_verify_path.exists()
+
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Monitor mode did not process the local delete event before shutdown",
+                artifacts,
+                details,
+            )
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not keep_verify_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification is missing retained anchor file: {keep_relative}",
+                artifacts,
+                details,
+            )
+
+        if delete_verify_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification still contains deleted file: {delete_relative}",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0044_monitor_mode_local_rename_propagation.py b/ci/e2e/testcases/tc0044_monitor_mode_local_rename_propagation.py
new file mode 100644
index 000000000..e2b6f098b
--- /dev/null
+++ b/ci/e2e/testcases/tc0044_monitor_mode_local_rename_propagation.py
@@ -0,0 +1,317 @@
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+
+
+class TestCase0044MonitorModeLocalRenamePropagation(MonitorModeTestCaseBase):
+    case_id = "0044"
+    name = "monitor mode local rename propagation"
+    description = "Rename a local file while --monitor is active and validate correct behaviour"
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(
+            metadata_file,
+            "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n",
+        )
+
+    def _build_config_text(self, sync_dir: Path, app_log_dir: Path) -> str:
+        return (
+            "# tc0044 config\n"
+            f'sync_dir = "{sync_dir}"\n'
+            'bypass_data_preservation = "true"\n'
+            'enable_logging = "true"\n'
+            f'log_dir = "{app_log_dir}"\n'
+            'monitor_interval = "5"\n'
+            'monitor_fullscan_frequency = "1"\n'
+        )
+
+    def _read_stdout(self, stdout_file: Path) -> str:
+        if not stdout_file.exists():
+            return ""
+        try:
+            return stdout_file.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return ""
+
+    def _wait_for_initial_sync_complete(
+        self,
+        stdout_file: Path,
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+        marker = "Sync with Microsoft OneDrive is complete"
+
+        while time.time() < deadline:
+            if marker in self._read_stdout(stdout_file):
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def _wait_for_monitor_patterns(
+        self,
+        stdout_file: Path,
+        required_patterns: list[str],
+        timeout_seconds: int = 120,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        deadline = time.time() + timeout_seconds
+
+        while time.time() < deadline:
+            content = self._read_stdout(stdout_file)
+            if all(pattern in content for pattern in required_patterns):
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0044",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0044_{context.run_id}_{os.getpid()}"
+        old_relative = f"{root_name}/original-name.txt"
+        new_relative = f"{root_name}/renamed-file.txt"
+
+        old_local_path = sync_root / old_relative
+        new_local_path = sync_root / new_relative
+        old_verify_path = verify_root / old_relative
+        new_verify_path = verify_root / new_relative
+
+        file_content = (
+            "TC0044 monitor mode local rename propagation\n"
+            "This content must survive the rename unchanged.\n"
+        )
+
+        context.bootstrap_config_dir(conf_main)
+        write_text_file(conf_main / "config", self._build_config_text(sync_root, app_log_dir))
+
+        context.bootstrap_config_dir(conf_verify)
+        write_text_file(
+            conf_verify / "config",
+            (
+                "# tc0044 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(monitor_stdout),
+            str(monitor_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+        if app_log_dir.exists():
+            artifacts.append(str(app_log_dir))
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "old_relative": old_relative,
+            "new_relative": new_relative,
+            "sync_root": str(sync_root),
+            "verify_root": str(verify_root),
+            "conf_main": str(conf_main),
+            "conf_verify": str(conf_verify),
+        }
+
+        write_text_file(old_local_path, file_content)
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Seed phase failed with status {seed_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        monitor_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--monitor",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+
+        process, initial_sync_complete = self._launch_monitor_process(
+            context,
+            monitor_command,
+            monitor_stdout,
+            monitor_stderr,
+        )
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    "Monitor mode did not complete the initial sync within the expected time",
+                    artifacts,
+                    details,
+                )
+
+            context.log(f"Test Case {self.case_id}: renaming local file while monitor is running: {old_relative} -> {new_relative}")
+            old_local_path.rename(new_local_path)
+            details["old_local_exists_after_rename"] = old_local_path.exists()
+            details["new_local_exists_after_rename"] = new_local_path.is_file()
+
+            pattern_groups = [
+                [
+                    f"[M] Local item moved: {old_relative} -> {new_relative}",
+                    f"Moving {old_relative} to {new_relative}",
+                ],
+                [
+                    f"Uploading new file: {new_relative} ... done",
+                ],
+            ]
+            mutation_processed, matched_group = self._wait_for_any_monitor_pattern_group(
+                monitor_stdout,
+                alternative_pattern_groups=pattern_groups,
+                timeout_seconds=120,
+            )
+            details["mutation_processed"] = mutation_processed
+            details["matched_pattern_group_index"] = matched_group
+            details["mutation_pattern_groups"] = pattern_groups
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+
+        details["verify_old_exists"] = old_verify_path.exists()
+        details["verify_new_exists"] = new_verify_path.is_file()
+        details["verify_new_content"] = new_verify_path.read_text(encoding="utf-8") if new_verify_path.is_file() else ""
+
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Monitor mode did not process the local rename event before shutdown",
+                artifacts,
+                details,
+            )
+
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if old_verify_path.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification still contains old filename: {old_relative}",
+                artifacts,
+                details,
+            )
+
+        if not new_verify_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification is missing renamed file: {new_relative}",
+                artifacts,
+                details,
+            )
+
+        if details["verify_new_content"] != file_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Renamed file content did not match after remote verification",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0045_monitor_mode_local_directory_create_propagation.py b/ci/e2e/testcases/tc0045_monitor_mode_local_directory_create_propagation.py
new file mode 100644
index 000000000..384709b4f
--- /dev/null
+++ b/ci/e2e/testcases/tc0045_monitor_mode_local_directory_create_propagation.py
@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0045MonitorModeLocalDirectoryCreatePropagation(MonitorModeTestCaseBase):
+    case_id = "0045"
+    name = "monitor mode local directory create propagation"
+    description = "Create a new local directory and child file under --monitor and validate the remote state"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0045",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0045_{context.run_id}_{os.getpid()}"
+        baseline_relative = f"{root_name}/baseline.txt"
+        created_dir_relative = f"{root_name}/created-directory"
+        created_file_relative = f"{created_dir_relative}/inside.txt"
+
+        baseline_local_path = sync_root / baseline_relative
+        created_dir_local_path = sync_root / created_dir_relative
+        created_file_local_path = sync_root / created_file_relative
+        created_dir_verify_path = verify_root / created_dir_relative
+        created_file_verify_path = verify_root / created_file_relative
+
+        baseline_content = "TC0045 baseline\n"
+        created_file_content = (
+            "TC0045 monitor mode local directory create propagation\n"
+            "This file was created inside a new directory while --monitor was running.\n"
+        )
+
+        context.prepare_minimal_config_dir(conf_main, self._build_config_text(sync_root, app_log_dir))
+        context.prepare_minimal_config_dir(
+            conf_verify,
+            (
+                "# tc0045 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        write_text_file(baseline_local_path, baseline_content)
+
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(monitor_stdout),
+            str(monitor_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+
+        details = {
+            "root_name": root_name,
+            "baseline_relative": baseline_relative,
+            "created_dir_relative": created_dir_relative,
+            "created_file_relative": created_file_relative,
+        }
+
+        monitor_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--monitor",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(self.case_id, self.name, "Monitor mode did not complete the initial sync within the expected time", artifacts, details)
+
+            created_dir_local_path.mkdir(parents=True, exist_ok=True)
+            write_text_file(created_file_local_path, created_file_content)
+
+            required_patterns = [
+                f"Uploading new file: {created_file_relative} ... done",
+            ]
+            mutation_processed = self._wait_for_monitor_patterns(monitor_stdout, required_patterns)
+            details["mutation_processed"] = mutation_processed
+            details["mutation_required_patterns"] = required_patterns
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = self._run_verify_command(context, verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        details["verify_created_dir_exists"] = created_dir_verify_path.is_dir()
+        details["verify_created_file_exists"] = created_file_verify_path.is_file()
+        details["verify_created_file_content"] = created_file_verify_path.read_text(encoding="utf-8") if created_file_verify_path.is_file() else ""
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(self.case_id, self.name, "Monitor mode did not process the local directory create event before shutdown", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if not created_dir_verify_path.is_dir():
+            return self.fail_result(self.case_id, self.name, f"Remote verification is missing created directory: {created_dir_relative}", artifacts, details)
+        if not created_file_verify_path.is_file():
+            return self.fail_result(self.case_id, self.name, f"Remote verification is missing created file: {created_file_relative}", artifacts, details)
+        if details["verify_created_file_content"] != created_file_content:
+            return self.fail_result(self.case_id, self.name, "Created directory child file content did not match after remote verification", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0046_monitor_mode_local_directory_rename_propagation.py b/ci/e2e/testcases/tc0046_monitor_mode_local_directory_rename_propagation.py
new file mode 100644
index 000000000..1d62e64d7
--- /dev/null
+++ b/ci/e2e/testcases/tc0046_monitor_mode_local_directory_rename_propagation.py
@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0046MonitorModeLocalDirectoryRenamePropagation(MonitorModeTestCaseBase):
+    case_id = "0046"
+    name = "monitor mode local directory rename propagation"
+    description = "Rename a populated local directory while --monitor is active and validate the final remote state"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0046",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0046_{context.run_id}_{os.getpid()}"
+        old_dir_relative = f"{root_name}/original-dir"
+        new_dir_relative = f"{root_name}/renamed-dir"
+        old_file_relative = f"{old_dir_relative}/inside.txt"
+        new_file_relative = f"{new_dir_relative}/inside.txt"
+
+        old_dir_local_path = sync_root / old_dir_relative
+        new_dir_local_path = sync_root / new_dir_relative
+        old_file_local_path = sync_root / old_file_relative
+        old_dir_verify_path = verify_root / old_dir_relative
+        new_dir_verify_path = verify_root / new_dir_relative
+        old_file_verify_path = verify_root / old_file_relative
+        new_file_verify_path = verify_root / new_file_relative
+
+        file_content = (
+            "TC0046 monitor mode local directory rename propagation\n"
+            "This file must survive the directory rename unchanged.\n"
+        )
+
+        context.prepare_minimal_config_dir(conf_main, self._build_config_text(sync_root, app_log_dir))
+        context.prepare_minimal_config_dir(
+            conf_verify,
+            (
+                "# tc0046 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        write_text_file(old_file_local_path, file_content)
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [str(seed_stdout), str(seed_stderr), str(monitor_stdout), str(monitor_stderr), str(verify_stdout), str(verify_stderr), str(verify_manifest_file), str(metadata_file)]
+        details = {"root_name": root_name, "old_dir_relative": old_dir_relative, "new_dir_relative": new_dir_relative, "old_file_relative": old_file_relative, "new_file_relative": new_file_relative}
+
+        seed_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(self.case_id, self.name, f"Seed phase failed with status {seed_result.returncode}", artifacts, details)
+
+        monitor_command = [context.onedrive_bin, "--display-running-config", "--monitor", "--verbose", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(self.case_id, self.name, "Monitor mode did not complete the initial sync within the expected time", artifacts, details)
+
+            old_dir_local_path.rename(new_dir_local_path)
+            groups = [
+                [f"[M] Local item moved: {old_dir_relative} -> {new_dir_relative}", f"Moving {old_dir_relative} to {new_dir_relative}"],
+                [f"Deleting item from Microsoft OneDrive: {old_file_relative}", f"Uploading new file: {new_file_relative} ... done"],
+            ]
+            mutation_processed, matched_group = self._wait_for_any_monitor_pattern_group(monitor_stdout, groups)
+            details["mutation_processed"] = mutation_processed
+            details["matched_pattern_group_index"] = matched_group
+            details["mutation_pattern_groups"] = groups
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--download-only", "--verbose", "--resync", "--resync-auth", "--single-directory", root_name, "--syncdir", str(verify_root), "--confdir", str(conf_verify)]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = self._run_verify_command(context, verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        details["verify_old_dir_exists"] = old_dir_verify_path.exists()
+        details["verify_new_dir_exists"] = new_dir_verify_path.is_dir()
+        details["verify_old_file_exists"] = old_file_verify_path.exists()
+        details["verify_new_file_exists"] = new_file_verify_path.is_file()
+        details["verify_new_file_content"] = new_file_verify_path.read_text(encoding="utf-8") if new_file_verify_path.is_file() else ""
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(self.case_id, self.name, "Monitor mode did not process the local directory rename event before shutdown", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if old_dir_verify_path.exists() or old_file_verify_path.exists():
+            return self.fail_result(self.case_id, self.name, f"Remote verification still contains old directory path: {old_dir_relative}", artifacts, details)
+        if not new_dir_verify_path.is_dir() or not new_file_verify_path.is_file():
+            return self.fail_result(self.case_id, self.name, f"Remote verification is missing renamed directory content at: {new_dir_relative}", artifacts, details)
+        if details["verify_new_file_content"] != file_content:
+            return self.fail_result(self.case_id, self.name, "Renamed directory child file content did not match after remote verification", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0047_monitor_mode_local_directory_delete_propagation.py b/ci/e2e/testcases/tc0047_monitor_mode_local_directory_delete_propagation.py
new file mode 100644
index 000000000..e4be49c9f
--- /dev/null
+++ b/ci/e2e/testcases/tc0047_monitor_mode_local_directory_delete_propagation.py
@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import os
+import shutil
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0047MonitorModeLocalDirectoryDeletePropagation(MonitorModeTestCaseBase):
+    case_id = "0047"
+    name = "monitor mode local directory delete propagation"
+    description = "Delete a populated local directory tree under --monitor and validate the remote delete"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0047",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0047_{context.run_id}_{os.getpid()}"
+        keep_relative = f"{root_name}/anchor.txt"
+        delete_dir_relative = f"{root_name}/delete-directory"
+        delete_file1_relative = f"{delete_dir_relative}/file1.txt"
+        delete_file2_relative = f"{delete_dir_relative}/nested/file2.txt"
+
+        keep_local_path = sync_root / keep_relative
+        delete_dir_local_path = sync_root / delete_dir_relative
+        delete_file1_local_path = sync_root / delete_file1_relative
+        delete_file2_local_path = sync_root / delete_file2_relative
+        keep_verify_path = verify_root / keep_relative
+        delete_dir_verify_path = verify_root / delete_dir_relative
+
+        context.prepare_minimal_config_dir(conf_main, self._build_config_text(sync_root, app_log_dir))
+        context.prepare_minimal_config_dir(
+            conf_verify,
+            (
+                "# tc0047 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        write_text_file(keep_local_path, "TC0047 anchor\n")
+        write_text_file(delete_file1_local_path, "TC0047 delete file 1\n")
+        write_text_file(delete_file2_local_path, "TC0047 delete file 2\n")
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [str(seed_stdout), str(seed_stderr), str(monitor_stdout), str(monitor_stderr), str(verify_stdout), str(verify_stderr), str(verify_manifest_file), str(metadata_file)]
+        details = {"root_name": root_name, "keep_relative": keep_relative, "delete_dir_relative": delete_dir_relative, "delete_file1_relative": delete_file1_relative, "delete_file2_relative": delete_file2_relative}
+
+        seed_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(self.case_id, self.name, f"Seed phase failed with status {seed_result.returncode}", artifacts, details)
+
+        monitor_command = [context.onedrive_bin, "--display-running-config", "--monitor", "--verbose", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(self.case_id, self.name, "Monitor mode did not complete the initial sync within the expected time", artifacts, details)
+
+            shutil.rmtree(delete_dir_local_path)
+            groups = [
+                [f"Deleting item from Microsoft OneDrive: {delete_file1_relative}"],
+                [f"Deleting item from Microsoft OneDrive: {delete_file2_relative}"],
+                [f"Deleting item from Microsoft OneDrive: {delete_dir_relative}"],
+            ]
+            mutation_processed, matched_group = self._wait_for_any_monitor_pattern_group(monitor_stdout, groups)
+            details["mutation_processed"] = mutation_processed
+            details["matched_pattern_group_index"] = matched_group
+            details["mutation_pattern_groups"] = groups
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--download-only", "--verbose", "--resync", "--resync-auth", "--single-directory", root_name, "--syncdir", str(verify_root), "--confdir", str(conf_verify)]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = self._run_verify_command(context, verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        details["verify_keep_exists"] = keep_verify_path.is_file()
+        details["verify_deleted_dir_exists"] = delete_dir_verify_path.exists()
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(self.case_id, self.name, "Monitor mode did not process the local directory delete event before shutdown", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if not keep_verify_path.is_file():
+            return self.fail_result(self.case_id, self.name, f"Remote verification is missing retained anchor file: {keep_relative}", artifacts, details)
+        if delete_dir_verify_path.exists():
+            return self.fail_result(self.case_id, self.name, f"Remote verification still contains deleted directory tree: {delete_dir_relative}", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0048_monitor_mode_burst_local_file_creates.py b/ci/e2e/testcases/tc0048_monitor_mode_burst_local_file_creates.py
new file mode 100644
index 000000000..fe52e1c9c
--- /dev/null
+++ b/ci/e2e/testcases/tc0048_monitor_mode_burst_local_file_creates.py
@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import os
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0048MonitorModeBurstLocalFileCreates(MonitorModeTestCaseBase):
+    case_id = "0048"
+    name = "monitor mode burst local file creates"
+    description = "Rapidly create multiple local files under --monitor and validate they all upload correctly"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0048",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0048_{context.run_id}_{os.getpid()}"
+        baseline_relative = f"{root_name}/baseline.txt"
+        burst_relatives = [f"{root_name}/burst-{index}.txt" for index in range(1, 6)]
+        burst_contents = {relative: f"TC0048 burst file {relative}\n" for relative in burst_relatives}
+
+        baseline_local_path = sync_root / baseline_relative
+        verify_paths = {relative: verify_root / relative for relative in burst_relatives}
+
+        context.prepare_minimal_config_dir(conf_main, self._build_config_text(sync_root, app_log_dir))
+        context.prepare_minimal_config_dir(
+            conf_verify,
+            (
+                "# tc0048 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        write_text_file(baseline_local_path, "TC0048 baseline\n")
+
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [str(monitor_stdout), str(monitor_stderr), str(verify_stdout), str(verify_stderr), str(verify_manifest_file), str(metadata_file)]
+        details = {"root_name": root_name, "baseline_relative": baseline_relative, "burst_relatives": burst_relatives}
+
+        monitor_command = [context.onedrive_bin, "--display-running-config", "--monitor", "--verbose", "--resync", "--resync-auth", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(self.case_id, self.name, "Monitor mode did not complete the initial sync within the expected time", artifacts, details)
+
+            for relative in burst_relatives:
+                write_text_file(sync_root / relative, burst_contents[relative])
+
+            required_patterns = [f"Uploading new file: {relative} ... done" for relative in burst_relatives]
+            mutation_processed = self._wait_for_monitor_patterns(monitor_stdout, required_patterns)
+            details["mutation_processed"] = mutation_processed
+            details["mutation_required_patterns"] = required_patterns
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--download-only", "--verbose", "--resync", "--resync-auth", "--single-directory", root_name, "--syncdir", str(verify_root), "--confdir", str(conf_verify)]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = self._run_verify_command(context, verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        for relative in burst_relatives:
+            details[f"verify_exists::{relative}"] = verify_paths[relative].is_file()
+            details[f"verify_content::{relative}"] = verify_paths[relative].read_text(encoding="utf-8") if verify_paths[relative].is_file() else ""
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(self.case_id, self.name, "Monitor mode did not process the burst local create events before shutdown", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        for relative in burst_relatives:
+            if not verify_paths[relative].is_file():
+                return self.fail_result(self.case_id, self.name, f"Remote verification is missing burst-created file: {relative}", artifacts, details)
+            if details[f"verify_content::{relative}"] != burst_contents[relative]:
+                return self.fail_result(self.case_id, self.name, f"Burst-created file content did not match for: {relative}", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0049_monitor_mode_mixed_burst_operations.py b/ci/e2e/testcases/tc0049_monitor_mode_mixed_burst_operations.py
new file mode 100644
index 000000000..873d919a1
--- /dev/null
+++ b/ci/e2e/testcases/tc0049_monitor_mode_mixed_burst_operations.py
@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import os
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0049MonitorModeMixedBurstOperations(MonitorModeTestCaseBase):
+    case_id = "0049"
+    name = "monitor mode mixed burst operations"
+    description = "Perform create, modify, delete, and rename operations in one burst under --monitor and validate the final state"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0049",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0049_{context.run_id}_{os.getpid()}"
+        anchor_relative = f"{root_name}/anchor.txt"
+        modify_relative = f"{root_name}/modify-me.txt"
+        delete_relative = f"{root_name}/delete-me.txt"
+        rename_old_relative = f"{root_name}/rename-me.txt"
+        rename_new_relative = f"{root_name}/renamed-result.txt"
+        create_relative = f"{root_name}/new-created.txt"
+
+        anchor_local = sync_root / anchor_relative
+        modify_local = sync_root / modify_relative
+        delete_local = sync_root / delete_relative
+        rename_old_local = sync_root / rename_old_relative
+        rename_new_local = sync_root / rename_new_relative
+        create_local = sync_root / create_relative
+
+        modify_verify = verify_root / modify_relative
+        delete_verify = verify_root / delete_relative
+        rename_old_verify = verify_root / rename_old_relative
+        rename_new_verify = verify_root / rename_new_relative
+        create_verify = verify_root / create_relative
+
+        initial_modify = "TC0049 initial modify content\n"
+        final_modify = "TC0049 final modify content\n"
+        rename_content = "TC0049 rename content\n"
+        create_content = "TC0049 create content\n"
+
+        context.prepare_minimal_config_dir(conf_main, self._build_config_text(sync_root, app_log_dir))
+        context.prepare_minimal_config_dir(conf_verify, ("# tc0049 verify\n" f'sync_dir = "{verify_root}"\n' 'bypass_data_preservation = "true"\n'))
+
+        write_text_file(anchor_local, "TC0049 anchor\n")
+        write_text_file(modify_local, initial_modify)
+        write_text_file(delete_local, "TC0049 delete me\n")
+        write_text_file(rename_old_local, rename_content)
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [str(seed_stdout), str(seed_stderr), str(monitor_stdout), str(monitor_stderr), str(verify_stdout), str(verify_stderr), str(verify_manifest_file), str(metadata_file)]
+        details = {"root_name": root_name, "modify_relative": modify_relative, "delete_relative": delete_relative, "rename_old_relative": rename_old_relative, "rename_new_relative": rename_new_relative, "create_relative": create_relative}
+
+        seed_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(self.case_id, self.name, f"Seed phase failed with status {seed_result.returncode}", artifacts, details)
+
+        monitor_command = [context.onedrive_bin, "--display-running-config", "--monitor", "--verbose", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(self.case_id, self.name, "Monitor mode did not complete the initial sync within the expected time", artifacts, details)
+
+            write_text_file(create_local, create_content)
+            write_text_file(modify_local, final_modify)
+            if delete_local.exists():
+                delete_local.unlink()
+            rename_old_local.rename(rename_new_local)
+
+            fixed_patterns = [
+                f"Uploading new file: {create_relative} ... done",
+                f"Uploading modified file: {modify_relative} ... done",
+                f"Deleting item from Microsoft OneDrive: {delete_relative}",
+            ]
+            rename_groups = [
+                [f"[M] Local item moved: {rename_old_relative} -> {rename_new_relative}", f"Moving {rename_old_relative} to {rename_new_relative}"],
+                [f"Deleting item from Microsoft OneDrive: {rename_old_relative}", f"Uploading new file: {rename_new_relative} ... done"],
+            ]
+            fixed_ok = self._wait_for_monitor_patterns(monitor_stdout, fixed_patterns)
+            rename_ok, matched_group = self._wait_for_any_monitor_pattern_group(monitor_stdout, rename_groups)
+            details["fixed_patterns_observed"] = fixed_ok
+            details["rename_patterns_observed"] = rename_ok
+            details["matched_rename_pattern_group_index"] = matched_group
+            details["mutation_processed"] = bool(fixed_ok and rename_ok)
+            details["fixed_patterns"] = fixed_patterns
+            details["rename_pattern_groups"] = rename_groups
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--download-only", "--verbose", "--resync", "--resync-auth", "--single-directory", root_name, "--syncdir", str(verify_root), "--confdir", str(conf_verify)]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = self._run_verify_command(context, verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        details["verify_modify_exists"] = modify_verify.is_file()
+        details["verify_modify_content"] = modify_verify.read_text(encoding="utf-8") if modify_verify.is_file() else ""
+        details["verify_delete_exists"] = delete_verify.exists()
+        details["verify_rename_old_exists"] = rename_old_verify.exists()
+        details["verify_rename_new_exists"] = rename_new_verify.is_file()
+        details["verify_rename_new_content"] = rename_new_verify.read_text(encoding="utf-8") if rename_new_verify.is_file() else ""
+        details["verify_create_exists"] = create_verify.is_file()
+        details["verify_create_content"] = create_verify.read_text(encoding="utf-8") if create_verify.is_file() else ""
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(self.case_id, self.name, "Monitor mode did not process the mixed burst operations before shutdown", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if not modify_verify.is_file() or details["verify_modify_content"] != final_modify:
+            return self.fail_result(self.case_id, self.name, f"Remote verification did not preserve modified file state: {modify_relative}", artifacts, details)
+        if delete_verify.exists():
+            return self.fail_result(self.case_id, self.name, f"Remote verification still contains deleted file: {delete_relative}", artifacts, details)
+        if rename_old_verify.exists() or not rename_new_verify.is_file() or details["verify_rename_new_content"] != rename_content:
+            return self.fail_result(self.case_id, self.name, "Remote verification did not preserve renamed file state correctly", artifacts, details)
+        if not create_verify.is_file() or details["verify_create_content"] != create_content:
+            return self.fail_result(self.case_id, self.name, f"Remote verification did not preserve created file state: {create_relative}", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0050_monitor_mode_nested_file_create_inside_new_directory.py b/ci/e2e/testcases/tc0050_monitor_mode_nested_file_create_inside_new_directory.py
new file mode 100644
index 000000000..c62f1f75e
--- /dev/null
+++ b/ci/e2e/testcases/tc0050_monitor_mode_nested_file_create_inside_new_directory.py
@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import os
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0050MonitorModeNestedFileCreateInsideNewDirectory(MonitorModeTestCaseBase):
+    case_id = "0050"
+    name = "monitor mode nested file create inside new directory"
+    description = "Create a nested directory tree and deep file under --monitor and validate the remote state"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0050",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0050_{context.run_id}_{os.getpid()}"
+        anchor_relative = f"{root_name}/anchor.txt"
+        deep_dir_relative = f"{root_name}/new-root/child/grandchild"
+        deep_file_relative = f"{deep_dir_relative}/deep-file.txt"
+
+        anchor_local = sync_root / anchor_relative
+        deep_dir_local = sync_root / deep_dir_relative
+        deep_file_local = sync_root / deep_file_relative
+        deep_file_verify = verify_root / deep_file_relative
+
+        deep_file_content = (
+            "TC0050 monitor mode nested file create inside new directory\n"
+            "This file was created at a nested path while --monitor was active.\n"
+        )
+
+        context.prepare_minimal_config_dir(conf_main, self._build_config_text(sync_root, app_log_dir))
+        context.prepare_minimal_config_dir(conf_verify, ("# tc0050 verify\n" f'sync_dir = "{verify_root}"\n' 'bypass_data_preservation = "true"\n'))
+        write_text_file(anchor_local, "TC0050 anchor\n")
+
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+        artifacts = [str(monitor_stdout), str(monitor_stderr), str(verify_stdout), str(verify_stderr), str(verify_manifest_file), str(metadata_file)]
+        details = {"root_name": root_name, "anchor_relative": anchor_relative, "deep_dir_relative": deep_dir_relative, "deep_file_relative": deep_file_relative}
+
+        monitor_command = [context.onedrive_bin, "--display-running-config", "--monitor", "--verbose", "--resync", "--resync-auth", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(self.case_id, self.name, "Monitor mode did not complete the initial sync within the expected time", artifacts, details)
+            deep_dir_local.mkdir(parents=True, exist_ok=True)
+            write_text_file(deep_file_local, deep_file_content)
+            required_patterns = [f"Uploading new file: {deep_file_relative} ... done"]
+            mutation_processed = self._wait_for_monitor_patterns(monitor_stdout, required_patterns)
+            details["mutation_processed"] = mutation_processed
+            details["mutation_required_patterns"] = required_patterns
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--download-only", "--verbose", "--resync", "--resync-auth", "--single-directory", root_name, "--syncdir", str(verify_root), "--confdir", str(conf_verify)]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = self._run_verify_command(context, verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        details["verify_deep_file_exists"] = deep_file_verify.is_file()
+        details["verify_deep_file_content"] = deep_file_verify.read_text(encoding="utf-8") if deep_file_verify.is_file() else ""
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(self.case_id, self.name, "Monitor mode did not process the nested create event before shutdown", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if not deep_file_verify.is_file() or details["verify_deep_file_content"] != deep_file_content:
+            return self.fail_result(self.case_id, self.name, f"Remote verification is missing deep nested file state: {deep_file_relative}", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0051_monitor_mode_mtime_only_local_change_handling.py b/ci/e2e/testcases/tc0051_monitor_mode_mtime_only_local_change_handling.py
new file mode 100644
index 000000000..cc291c57c
--- /dev/null
+++ b/ci/e2e/testcases/tc0051_monitor_mode_mtime_only_local_change_handling.py
@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import os
+import time
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, compute_quickxor_hash_file, reset_directory, run_command, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0051MonitorModeMtimeOnlyLocalChangeHandling(MonitorModeTestCaseBase):
+    case_id = "0051"
+    name = "monitor mode mtime-only local change handling"
+    description = "Touch an existing local file under --monitor without changing content and validate that no new upload occurs"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0051",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_initial_root = case_work_dir / "verify-initial-root"
+        verify_final_root = case_work_dir / "verify-final-root"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify_initial = case_work_dir / "conf-verify-initial"
+        conf_verify_final = case_work_dir / "conf-verify-final"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0051_{context.run_id}_{os.getpid()}"
+        relative_path = f"{root_name}/mtime-only.txt"
+        local_file_path = sync_root / relative_path
+        verify_initial_file_path = verify_initial_root / relative_path
+        verify_final_file_path = verify_final_root / relative_path
+
+        initial_content = (
+            "TC0051 monitor mode mtime-only local change handling\n"
+            "This file content must remain unchanged; only the local mtime is updated.\n"
+        )
+
+        extra_config_lines = ['force_session_upload = "true"']
+        context.prepare_minimal_config_dir(
+            conf_main,
+            self._build_config_text(sync_root, app_log_dir, extra_config_lines=extra_config_lines),
+        )
+        context.prepare_minimal_config_dir(
+            conf_verify_initial,
+            (
+                "# tc0051 verify initial\n"
+                f'sync_dir = "{verify_initial_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+        context.prepare_minimal_config_dir(
+            conf_verify_final,
+            (
+                "# tc0051 verify final\n"
+                f'sync_dir = "{verify_final_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        write_text_file(local_file_path, initial_content)
+        initial_local_hash = compute_quickxor_hash_file(local_file_path)
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        verify_initial_stdout = case_log_dir / "verify_initial_stdout.log"
+        verify_initial_stderr = case_log_dir / "verify_initial_stderr.log"
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_final_stdout = case_log_dir / "verify_final_stdout.log"
+        verify_final_stderr = case_log_dir / "verify_final_stderr.log"
+        verify_initial_manifest_file = state_dir / "verify_initial_manifest.txt"
+        verify_final_manifest_file = state_dir / "verify_final_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(verify_initial_stdout),
+            str(verify_initial_stderr),
+            str(monitor_stdout),
+            str(monitor_stderr),
+            str(verify_final_stdout),
+            str(verify_final_stderr),
+            str(verify_initial_manifest_file),
+            str(verify_final_manifest_file),
+            str(metadata_file),
+        ]
+
+        details: dict[str, object] = {
+            "root_name": root_name,
+            "relative_path": relative_path,
+            "initial_local_hash": initial_local_hash,
+        }
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Seed phase failed with status {seed_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        verify_initial_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(verify_initial_root),
+            "--confdir",
+            str(conf_verify_initial),
+        ]
+        context.log(f"Executing Test Case {self.case_id} initial verify: {command_to_string(verify_initial_command)}")
+        verify_initial_result = self._run_verify_command(
+            context,
+            verify_initial_command,
+            verify_initial_stdout,
+            verify_initial_stderr,
+        )
+        details["verify_initial_returncode"] = verify_initial_result.returncode
+
+        verify_initial_manifest = build_manifest(verify_initial_root)
+        write_manifest(verify_initial_manifest_file, verify_initial_manifest)
+
+        if verify_initial_result.returncode != 0 or not verify_initial_file_path.is_file():
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Initial remote verification failed before monitor mtime-only negative validation",
+                artifacts,
+                details,
+            )
+
+        baseline_verified_mtime = int(verify_initial_file_path.stat().st_mtime)
+        details["baseline_verified_mtime"] = baseline_verified_mtime
+        details["verify_initial_hash"] = compute_quickxor_hash_file(verify_initial_file_path)
+        details["verify_initial_content"] = verify_initial_file_path.read_text(encoding="utf-8")
+
+        monitor_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--monitor",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    "Monitor mode did not complete the initial sync within the expected time",
+                    artifacts,
+                    details,
+                )
+
+            local_mtime_before_touch = int(local_file_path.stat().st_mtime)
+            touched_epoch = max(int(time.time()), local_mtime_before_touch, baseline_verified_mtime) + 120
+            os.utime(local_file_path, (touched_epoch, touched_epoch))
+
+            local_hash_after_touch = compute_quickxor_hash_file(local_file_path)
+            local_mtime_after_touch = int(local_file_path.stat().st_mtime)
+
+            details["local_mtime_before_touch"] = local_mtime_before_touch
+            details["local_mtime_after_touch"] = local_mtime_after_touch
+            details["touched_epoch"] = touched_epoch
+            details["local_hash_after_touch"] = local_hash_after_touch
+
+            if local_hash_after_touch != initial_local_hash:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    "Local file hash changed after mtime-only touch",
+                    artifacts,
+                    details,
+                )
+
+            # Give monitor mode enough time to observe and reconcile the touched file.
+            time.sleep(15)
+
+            monitor_stdout_content = self._read_stdout(monitor_stdout)
+            details["monitor_observed_processing"] = f"Processing: {relative_path}" in monitor_stdout_content
+            details["monitor_reported_no_change"] = "The file has not changed" in monitor_stdout_content
+            details["monitor_reported_upload"] = f"Uploading modified file: {relative_path} ... done" in monitor_stdout_content
+            details["monitor_reported_local_change_event"] = f"[M] Local file changed: {relative_path}" in monitor_stdout_content
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_final_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(verify_final_root),
+            "--confdir",
+            str(conf_verify_final),
+        ]
+        context.log(f"Executing Test Case {self.case_id} final verify: {command_to_string(verify_final_command)}")
+        verify_final_result = self._run_verify_command(
+            context,
+            verify_final_command,
+            verify_final_stdout,
+            verify_final_stderr,
+        )
+        details["verify_final_returncode"] = verify_final_result.returncode
+
+        verify_final_manifest = build_manifest(verify_final_root)
+        write_manifest(verify_final_manifest_file, verify_final_manifest)
+
+        details["verify_final_file_exists"] = verify_final_file_path.is_file()
+        details["verify_final_hash"] = (
+            compute_quickxor_hash_file(verify_final_file_path)
+            if verify_final_file_path.is_file()
+            else ""
+        )
+        details["verify_final_content"] = (
+            verify_final_file_path.read_text(encoding="utf-8")
+            if verify_final_file_path.is_file()
+            else ""
+        )
+        details["final_verified_mtime"] = (
+            int(verify_final_file_path.stat().st_mtime)
+            if verify_final_file_path.is_file()
+            else -1
+        )
+
+        self._write_metadata(metadata_file, details)
+
+        if verify_final_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Final remote verification failed with status {verify_final_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        if not verify_final_file_path.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification is missing mtime-only file: {relative_path}",
+                artifacts,
+                details,
+            )
+
+        if details["verify_final_hash"] != initial_local_hash:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Remote file hash changed after mtime-only local touch",
+                artifacts,
+                details,
+            )
+
+        if details["verify_final_content"] != initial_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Remote file content changed after mtime-only local touch",
+                artifacts,
+                details,
+            )
+
+        if details["final_verified_mtime"] != details["baseline_verified_mtime"]:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Remote mtime changed after mtime-only local touch; expected no new upload",
+                artifacts,
+                details,
+            )
+
+        if details["monitor_reported_upload"]:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Monitor mode uploaded the file after an mtime-only local touch",
+                artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
\ No newline at end of file
diff --git a/ci/e2e/testcases/tc0052_monitor_mode_large_file_create_session_upload.py b/ci/e2e/testcases/tc0052_monitor_mode_large_file_create_session_upload.py
new file mode 100644
index 000000000..0237cb43a
--- /dev/null
+++ b/ci/e2e/testcases/tc0052_monitor_mode_large_file_create_session_upload.py
@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import os
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, compute_quickxor_hash_file, reset_directory, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0052MonitorModeLargeFileCreateSessionUpload(MonitorModeTestCaseBase):
+    case_id = "0052"
+    name = "monitor mode large file create session upload"
+    description = "Create a large file under --monitor and validate session upload behaviour and remote integrity"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0052",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0052_{context.run_id}_{os.getpid()}"
+        anchor_relative = f"{root_name}/anchor.txt"
+        large_relative = f"{root_name}/large-session-upload.bin"
+        anchor_local = sync_root / anchor_relative
+        large_local = sync_root / large_relative
+        large_verify = verify_root / large_relative
+        large_size_bytes = 6 * 1024 * 1024
+
+        context.prepare_minimal_config_dir(conf_main, self._build_config_text(sync_root, app_log_dir, extra_config_lines=['force_session_upload = "true"']))
+        context.prepare_minimal_config_dir(conf_verify, ("# tc0052 verify\n" f'sync_dir = "{verify_root}"\n' 'bypass_data_preservation = "true"\n'))
+        write_text_file(anchor_local, "TC0052 anchor\n")
+
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+        artifacts = [str(monitor_stdout), str(monitor_stderr), str(verify_stdout), str(verify_stderr), str(verify_manifest_file), str(metadata_file)]
+        details = {"root_name": root_name, "anchor_relative": anchor_relative, "large_relative": large_relative, "large_size_bytes": large_size_bytes}
+
+        monitor_command = [context.onedrive_bin, "--display-running-config", "--monitor", "--verbose", "--resync", "--resync-auth", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(self.case_id, self.name, "Monitor mode did not complete the initial sync within the expected time", artifacts, details)
+
+            self._write_file_with_exact_size(large_local, large_size_bytes, "TC0052 monitor mode large file create session upload\n")
+            details["local_large_hash"] = compute_quickxor_hash_file(large_local)
+            details["local_large_size"] = large_local.stat().st_size
+            required_patterns = [f"Uploading new file: {large_relative} ... done"]
+            mutation_processed = self._wait_for_monitor_patterns(monitor_stdout, required_patterns, timeout_seconds=240)
+            details["mutation_processed"] = mutation_processed
+            details["mutation_required_patterns"] = required_patterns
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--download-only", "--verbose", "--resync", "--resync-auth", "--single-directory", root_name, "--syncdir", str(verify_root), "--confdir", str(conf_verify)]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = self._run_verify_command(context, verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        details["verify_large_exists"] = large_verify.is_file()
+        details["verify_large_size"] = large_verify.stat().st_size if large_verify.is_file() else -1
+        details["verify_large_hash"] = compute_quickxor_hash_file(large_verify) if large_verify.is_file() else ""
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(self.case_id, self.name, "Monitor mode did not process the large file create event before shutdown", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if not large_verify.is_file():
+            return self.fail_result(self.case_id, self.name, f"Remote verification is missing large uploaded file: {large_relative}", artifacts, details)
+        if details["verify_large_size"] != details["local_large_size"] or details["verify_large_hash"] != details["local_large_hash"]:
+            return self.fail_result(self.case_id, self.name, "Large file session upload did not preserve expected size/hash after remote verification", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0053_monitor_mode_rename_then_modify.py b/ci/e2e/testcases/tc0053_monitor_mode_rename_then_modify.py
new file mode 100644
index 000000000..a2dd503fc
--- /dev/null
+++ b/ci/e2e/testcases/tc0053_monitor_mode_rename_then_modify.py
@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import os
+import time
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0053MonitorModeRenameThenModify(MonitorModeTestCaseBase):
+    case_id = "0053"
+    name = "monitor mode rename then modify"
+    description = "Rename a file and then modify the renamed file under --monitor and validate the final remote state"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0053",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0053_{context.run_id}_{os.getpid()}"
+        old_relative = f"{root_name}/before.txt"
+        new_relative = f"{root_name}/after.txt"
+        old_local = sync_root / old_relative
+        new_local = sync_root / new_relative
+        old_verify = verify_root / old_relative
+        new_verify = verify_root / new_relative
+
+        initial_content = "TC0053 initial content\n"
+        final_content = "TC0053 final content after rename then modify\n"
+
+        context.prepare_minimal_config_dir(conf_main, self._build_config_text(sync_root, app_log_dir))
+        context.prepare_minimal_config_dir(conf_verify, ("# tc0053 verify\n" f'sync_dir = "{verify_root}"\n' 'bypass_data_preservation = "true"\n'))
+        write_text_file(old_local, initial_content)
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+        artifacts = [str(seed_stdout), str(seed_stderr), str(monitor_stdout), str(monitor_stderr), str(verify_stdout), str(verify_stderr), str(verify_manifest_file), str(metadata_file)]
+        details = {"root_name": root_name, "old_relative": old_relative, "new_relative": new_relative}
+
+        seed_command = [context.onedrive_bin, "--display-running-config", "--sync", "--verbose", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(self.case_id, self.name, f"Seed phase failed with status {seed_result.returncode}", artifacts, details)
+
+        monitor_command = [context.onedrive_bin, "--display-running-config", "--monitor", "--verbose", "--single-directory", root_name, "--syncdir", str(sync_root), "--confdir", str(conf_main)]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(self.case_id, self.name, "Monitor mode did not complete the initial sync within the expected time", artifacts, details)
+
+            old_local.rename(new_local)
+            time.sleep(1.0)
+            write_text_file(new_local, final_content)
+            groups = [
+                [f"[M] Local item moved: {old_relative} -> {new_relative}", f"Uploading modified file: {new_relative} ... done"],
+                [f"Moving {old_relative} to {new_relative}", f"Uploading modified file: {new_relative} ... done"],
+                [f"Deleting item from Microsoft OneDrive: {old_relative}", f"Uploading new file: {new_relative} ... done"],
+            ]
+            mutation_processed, matched_group = self._wait_for_any_monitor_pattern_group(monitor_stdout, groups, timeout_seconds=180)
+            details["mutation_processed"] = mutation_processed
+            details["matched_pattern_group_index"] = matched_group
+            details["mutation_pattern_groups"] = groups
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [context.onedrive_bin, "--display-running-config", "--sync", "--download-only", "--verbose", "--resync", "--resync-auth", "--single-directory", root_name, "--syncdir", str(verify_root), "--confdir", str(conf_verify)]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = self._run_verify_command(context, verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        details["verify_old_exists"] = old_verify.exists()
+        details["verify_new_exists"] = new_verify.is_file()
+        details["verify_new_content"] = new_verify.read_text(encoding="utf-8") if new_verify.is_file() else ""
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(self.case_id, self.name, "Monitor mode did not process the rename-then-modify event before shutdown", artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(self.case_id, self.name, f"Remote verification failed with status {verify_result.returncode}", artifacts, details)
+        if old_verify.exists() or not new_verify.is_file() or details["verify_new_content"] != final_content:
+            return self.fail_result(self.case_id, self.name, "Remote verification did not preserve final rename-then-modify state correctly", artifacts, details)
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0054_monitor_mode_atomic_save_editor_replace_workflow.py b/ci/e2e/testcases/tc0054_monitor_mode_atomic_save_editor_replace_workflow.py
new file mode 100644
index 000000000..2a1b80c09
--- /dev/null
+++ b/ci/e2e/testcases/tc0054_monitor_mode_atomic_save_editor_replace_workflow.py
@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import os
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0054MonitorModeAtomicSaveEditorReplaceWorkflow(MonitorModeTestCaseBase):
+    case_id = "0054"
+    name = "monitor mode atomic-save editor replace workflow"
+    description = "Replace an existing file via temp-file save and atomic rename under --monitor and validate the final remote state"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0054",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0054_{context.run_id}_{os.getpid()}"
+        target_relative = f"{root_name}/document.txt"
+        temp_relative = f"{root_name}/.document.txt.swp"
+
+        target_local = sync_root / target_relative
+        temp_local = sync_root / temp_relative
+        target_verify = verify_root / target_relative
+        temp_verify = verify_root / temp_relative
+
+        original_content = (
+            "TC0054 monitor mode atomic-save editor replace workflow\n"
+            "ORIGINAL CONTENT\n"
+        )
+        updated_content = (
+            "TC0054 monitor mode atomic-save editor replace workflow\n"
+            "UPDATED CONTENT VIA TEMP FILE REPLACE\n"
+        )
+
+        context.prepare_minimal_config_dir(conf_main, self._build_config_text(sync_root, app_log_dir))
+        context.prepare_minimal_config_dir(
+            conf_verify,
+            (
+                "# tc0054 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        write_text_file(target_local, original_content)
+
+        seed_stdout = case_log_dir / "seed_stdout.log"
+        seed_stderr = case_log_dir / "seed_stderr.log"
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(monitor_stdout),
+            str(monitor_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "root_name": root_name,
+            "target_relative": target_relative,
+            "temp_relative": temp_relative,
+        }
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} seed: {command_to_string(seed_command)}")
+        seed_result = run_command(seed_command, cwd=context.repo_root)
+        write_text_file(seed_stdout, seed_result.stdout)
+        write_text_file(seed_stderr, seed_result.stderr)
+        details["seed_returncode"] = seed_result.returncode
+        if seed_result.returncode != 0:
+            self._write_metadata(metadata_file, details)
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Seed phase failed with status {seed_result.returncode}",
+                artifacts,
+                details,
+            )
+
+        monitor_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--monitor",
+            "--verbose",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    "Monitor mode did not complete the initial sync within the expected time",
+                    artifacts,
+                    details,
+                )
+
+            write_text_file(temp_local, updated_content)
+            os.replace(temp_local, target_local)
+            details["temp_local_exists_after_replace"] = temp_local.exists()
+            details["target_local_exists_after_replace"] = target_local.is_file()
+
+            pattern_groups = [
+                [f"Uploading modified file: {target_relative} ... done"],
+                [f"Uploading new file: {target_relative} ... done"],
+            ]
+            mutation_processed, matched_group = self._wait_for_any_monitor_pattern_group(
+                monitor_stdout,
+                pattern_groups,
+                timeout_seconds=120,
+            )
+            details["mutation_processed"] = mutation_processed
+            details["matched_pattern_group_index"] = matched_group
+            details["pattern_groups"] = pattern_groups
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = self._run_verify_command(context, verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        details["verify_target_exists"] = target_verify.is_file()
+        details["verify_target_content"] = target_verify.read_text(encoding="utf-8") if target_verify.is_file() else ""
+        details["verify_temp_exists"] = temp_verify.exists()
+        self._write_metadata(metadata_file, details)
+
+        if not details.get("mutation_processed", False):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Monitor mode did not process the atomic-save editor replace workflow before shutdown",
+                artifacts,
+                details,
+            )
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+        if not target_verify.is_file() or details["verify_target_content"] != updated_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification did not preserve the updated editor-save content: {target_relative}",
+                artifacts,
+                details,
+            )
+        if temp_verify.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification still contains temporary editor-save file: {temp_relative}",
+                artifacts,
+                details,
+            )
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0055_upload_only_remove_source_folders.py b/ci/e2e/testcases/tc0055_upload_only_remove_source_folders.py
new file mode 100644
index 000000000..8cc0ef486
--- /dev/null
+++ b/ci/e2e/testcases/tc0055_upload_only_remove_source_folders.py
@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+
+
+class TestCase0055UploadOnlyRemoveSourceFolders(E2ETestCase):
+    case_id = "0055"
+    name = "upload-only remove-source-folders"
+    description = "Validate that remove_source_folders removes empty local directory structure after upload-only succeeds"
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(metadata_file, "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n")
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0055",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_upload = case_work_dir / "conf-upload"
+        conf_verify = case_work_dir / "conf-verify"
+
+        root_name = f"ZZ_E2E_TC0055_{context.run_id}_{os.getpid()}"
+        top_dir_relative = f"{root_name}/payload"
+        file_one_relative = f"{top_dir_relative}/alpha.txt"
+        file_two_relative = f"{top_dir_relative}/nested/beta.txt"
+
+        top_dir_local = sync_root / top_dir_relative
+        file_one_local = sync_root / file_one_relative
+        file_two_local = sync_root / file_two_relative
+        file_one_verify = verify_root / file_one_relative
+        file_two_verify = verify_root / file_two_relative
+
+        file_one_content = "TC0055 remove_source_folders alpha\n"
+        file_two_content = "TC0055 remove_source_folders beta\n"
+
+        context.prepare_minimal_config_dir(
+            conf_upload,
+            (
+                "# tc0055 upload\n"
+                f'sync_dir = "{sync_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+        context.prepare_minimal_config_dir(
+            conf_verify,
+            (
+                "# tc0055 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+
+        write_text_file(file_one_local, file_one_content)
+        write_text_file(file_two_local, file_two_content)
+
+        upload_stdout = case_log_dir / "upload_stdout.log"
+        upload_stderr = case_log_dir / "upload_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        local_manifest_file = state_dir / "local_manifest_after_upload.txt"
+        remote_manifest_file = state_dir / "remote_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(upload_stdout),
+            str(upload_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(local_manifest_file),
+            str(remote_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "root_name": root_name,
+            "top_dir_relative": top_dir_relative,
+            "file_one_relative": file_one_relative,
+            "file_two_relative": file_two_relative,
+        }
+
+        upload_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--upload-only",
+            "--remove-source-files",
+            "--remove-source-folders",
+            "--resync",
+            "--resync-auth",
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_upload),
+        ]
+        context.log(f"Executing Test Case {self.case_id} upload: {command_to_string(upload_command)}")
+        upload_result = run_command(upload_command, cwd=context.repo_root)
+        write_text_file(upload_stdout, upload_result.stdout)
+        write_text_file(upload_stderr, upload_result.stderr)
+        details["upload_returncode"] = upload_result.returncode
+
+        local_manifest = build_manifest(sync_root)
+        write_manifest(local_manifest_file, local_manifest)
+        details["local_top_dir_exists_after_upload"] = top_dir_local.exists()
+        details["local_file_one_exists_after_upload"] = file_one_local.exists()
+        details["local_file_two_exists_after_upload"] = file_two_local.exists()
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = run_command(verify_command, cwd=context.repo_root)
+        write_text_file(verify_stdout, verify_result.stdout)
+        write_text_file(verify_stderr, verify_result.stderr)
+        details["verify_returncode"] = verify_result.returncode
+
+        remote_manifest = build_manifest(verify_root)
+        write_manifest(remote_manifest_file, remote_manifest)
+        details["verify_file_one_exists"] = file_one_verify.is_file()
+        details["verify_file_one_content"] = file_one_verify.read_text(encoding="utf-8") if file_one_verify.is_file() else ""
+        details["verify_file_two_exists"] = file_two_verify.is_file()
+        details["verify_file_two_content"] = file_two_verify.read_text(encoding="utf-8") if file_two_verify.is_file() else ""
+        self._write_metadata(metadata_file, details)
+
+        if upload_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"--upload-only with remove_source_folders failed with status {upload_result.returncode}",
+                artifacts,
+                details,
+            )
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+        if top_dir_local.exists() or file_one_local.exists() or file_two_local.exists() or any(entry.startswith(f"{root_name}/") for entry in local_manifest):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Local directory structure still exists after remove_source_folders processing",
+                artifacts,
+                details,
+            )
+        if not file_one_verify.is_file() or details["verify_file_one_content"] != file_one_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification missing uploaded file state: {file_one_relative}",
+                artifacts,
+                details,
+            )
+        if not file_two_verify.is_file() or details["verify_file_two_content"] != file_two_content:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification missing uploaded file state: {file_two_relative}",
+                artifacts,
+                details,
+            )
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0056_monitor_mode_create_then_delete_quickly.py b/ci/e2e/testcases/tc0056_monitor_mode_create_then_delete_quickly.py
new file mode 100644
index 000000000..43eb68137
--- /dev/null
+++ b/ci/e2e/testcases/tc0056_monitor_mode_create_then_delete_quickly.py
@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import os
+import time
+
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, write_text_file
+from testcases.monitor_case_base import MonitorModeTestCaseBase
+
+
+class TestCase0056MonitorModeCreateThenDeleteQuickly(MonitorModeTestCaseBase):
+    case_id = "0056"
+    name = "monitor mode create then delete quickly"
+    description = "Create and delete a local file quickly under --monitor and validate stability and final remote state"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0056",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        sync_root = case_work_dir / "syncroot"
+        verify_root = case_work_dir / "verifyroot"
+        conf_main = case_work_dir / "conf-main"
+        conf_verify = case_work_dir / "conf-verify"
+        app_log_dir = case_log_dir / "app-logs"
+
+        root_name = f"ZZ_E2E_TC0056_{context.run_id}_{os.getpid()}"
+        anchor_relative = f"{root_name}/anchor.txt"
+        transient_relative = f"{root_name}/transient.txt"
+
+        anchor_local = sync_root / anchor_relative
+        transient_local = sync_root / transient_relative
+        anchor_verify = verify_root / anchor_relative
+        transient_verify = verify_root / transient_relative
+
+        transient_content = (
+            "TC0056 monitor mode create then delete quickly\n"
+            "This file should not remain remotely after the rapid local delete.\n"
+        )
+
+        context.prepare_minimal_config_dir(conf_main, self._build_config_text(sync_root, app_log_dir))
+        context.prepare_minimal_config_dir(
+            conf_verify,
+            (
+                "# tc0056 verify\n"
+                f'sync_dir = "{verify_root}"\n'
+                'bypass_data_preservation = "true"\n'
+            ),
+        )
+        write_text_file(anchor_local, "TC0056 anchor\n")
+
+        monitor_stdout = case_log_dir / "monitor_stdout.log"
+        monitor_stderr = case_log_dir / "monitor_stderr.log"
+        verify_stdout = case_log_dir / "verify_stdout.log"
+        verify_stderr = case_log_dir / "verify_stderr.log"
+        verify_manifest_file = state_dir / "verify_manifest.txt"
+        metadata_file = state_dir / "metadata.txt"
+
+        artifacts = [
+            str(monitor_stdout),
+            str(monitor_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(verify_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "root_name": root_name,
+            "anchor_relative": anchor_relative,
+            "transient_relative": transient_relative,
+        }
+
+        monitor_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--monitor",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(sync_root),
+            "--confdir",
+            str(conf_main),
+        ]
+        context.log(f"Executing Test Case {self.case_id} monitor: {command_to_string(monitor_command)}")
+        process, initial_sync_complete = self._launch_monitor_process(context, monitor_command, monitor_stdout, monitor_stderr)
+        early_failure: str | None = None
+        try:
+            details["initial_sync_complete"] = initial_sync_complete
+            if not initial_sync_complete:
+                self._write_metadata(metadata_file, details)
+                return self.fail_result(
+                    self.case_id,
+                    self.name,
+                    "Monitor mode did not complete the initial sync within the expected time",
+                    artifacts,
+                    details,
+                )
+
+            write_text_file(transient_local, transient_content)
+            time.sleep(0.2)
+            if transient_local.exists():
+                transient_local.unlink()
+            details["transient_exists_after_local_delete"] = transient_local.exists()
+
+            time.sleep(12)
+            if process.poll() is not None:
+                early_failure = f"Monitor process exited before shutdown with status {process.returncode} after transient create/delete workflow"
+
+            stdout_content = self._read_stdout(monitor_stdout)
+            details["monitor_observed_new_file"] = f"[M] New local file added: {transient_relative}" in stdout_content
+            details["monitor_observed_delete"] = f"[M] Local item deleted: {transient_relative}" in stdout_content
+            details["monitor_observed_upload"] = f"Uploading new file: {transient_relative} ... done" in stdout_content
+            details["monitor_observed_remote_delete"] = f"Deleting item from Microsoft OneDrive: {transient_relative}" in stdout_content
+        finally:
+            self._shutdown_monitor_process(process, details)
+
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--download-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--syncdir",
+            str(verify_root),
+            "--confdir",
+            str(conf_verify),
+        ]
+        context.log(f"Executing Test Case {self.case_id} verify: {command_to_string(verify_command)}")
+        verify_result = self._run_verify_command(context, verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+        verify_manifest = build_manifest(verify_root)
+        write_manifest(verify_manifest_file, verify_manifest)
+        details["verify_anchor_exists"] = anchor_verify.is_file()
+        details["verify_transient_exists"] = transient_verify.exists()
+        self._write_metadata(metadata_file, details)
+
+        if early_failure is not None:
+            return self.fail_result(self.case_id, self.name, early_failure, artifacts, details)
+        if verify_result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification failed with status {verify_result.returncode}",
+                artifacts,
+                details,
+            )
+        if not anchor_verify.is_file():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification is missing retained anchor file: {anchor_relative}",
+                artifacts,
+                details,
+            )
+        if transient_verify.exists():
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"Remote verification still contains transient file after rapid create/delete: {transient_relative}",
+                artifacts,
+                details,
+            )
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases/tc0057_recycle_bin_delete_behaviour_validation.py b/ci/e2e/testcases/tc0057_recycle_bin_delete_behaviour_validation.py
new file mode 100644
index 000000000..d82409c24
--- /dev/null
+++ b/ci/e2e/testcases/tc0057_recycle_bin_delete_behaviour_validation.py
@@ -0,0 +1,407 @@
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+
+
+class TestCase0057RecycleBinDeleteBehaviourValidation(E2ETestCase):
+    case_id = "0057"
+    name = "recycle bin delete behaviour validation"
+    description = "Validate use_recycle_bin behaviour for online-origin deletes and local-origin delete propagation"
+
+    def _write_metadata(self, metadata_file: Path, details: dict[str, object]) -> None:
+        write_text_file(metadata_file, "\n".join(f"{key}={value!r}" for key, value in sorted(details.items())) + "\n")
+
+    def _prepare_config(
+        self,
+        context: E2EContext,
+        config_dir: Path,
+        sync_dir: Path,
+        *,
+        use_recycle_bin: bool,
+        recycle_bin_path: Path,
+        extra_config: str = "",
+    ) -> None:
+        context.prepare_minimal_config_dir(
+            config_dir,
+            (
+                "# tc0057 config\n"
+                f'sync_dir = "{sync_dir}"\n'
+                f'use_recycle_bin = "{str(use_recycle_bin).lower()}"\n'
+                f'recycle_bin_path = "{recycle_bin_path}"\n'
+                f"{extra_config}"
+            ),
+        )
+
+    def _run_and_capture(
+        self,
+        context: E2EContext,
+        label: str,
+        command: list[str],
+        stdout_file: Path,
+        stderr_file: Path,
+    ):
+        context.log(f"Executing Test Case {self.case_id} {label}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+        return result
+
+    def _contains_path_prefix(self, manifest: list[str], relative_path: str) -> bool:
+        return any(entry == relative_path or entry.startswith(relative_path + "/") for entry in manifest)
+
+    def _recycle_bin_has_payload(self, manifest: list[str], filename: str) -> bool:
+        return any(entry.endswith(filename) for entry in manifest)
+
+    def _recycle_bin_has_trashinfo(self, manifest: list[str]) -> bool:
+        return any(entry.endswith(".trashinfo") for entry in manifest)
+
+    def _run_scenario(
+        self,
+        context: E2EContext,
+        *,
+        scenario_id: str,
+        scenario_name: str,
+        delete_origin: str,
+        use_recycle_bin: bool,
+        case_work_dir: Path,
+        case_log_dir: Path,
+        state_dir: Path,
+    ) -> tuple[list[str], list[str], dict[str, object]]:
+        scenario_work_dir = case_work_dir / scenario_id
+        sync_root = scenario_work_dir / "syncroot"
+        verify_root = scenario_work_dir / "verifyroot"
+        recycle_bin_root = scenario_work_dir / "RecycleBin"
+        conf_runtime = scenario_work_dir / "conf-runtime"
+        conf_verify = scenario_work_dir / "conf-verify"
+
+        reset_directory(sync_root)
+        reset_directory(verify_root)
+        reset_directory(recycle_bin_root)
+
+        root_name = f"ZZ_E2E_TC0057_{context.run_id}_{os.getpid()}_{scenario_id}"
+        delete_dir_relative = f"{root_name}/DeleteMe"
+        keep_file_relative = f"{root_name}/Keep/keep.txt"
+        delete_file_relative = f"{delete_dir_relative}/delete-me.txt"
+
+        write_text_file(sync_root / keep_file_relative, f"tc0057 {scenario_id} keep\n")
+        write_text_file(sync_root / delete_file_relative, f"tc0057 {scenario_id} delete me\n")
+
+        self._prepare_config(
+            context,
+            conf_runtime,
+            sync_root,
+            use_recycle_bin=use_recycle_bin,
+            recycle_bin_path=recycle_bin_root,
+        )
+        self._prepare_config(
+            context,
+            conf_verify,
+            verify_root,
+            use_recycle_bin=False,
+            recycle_bin_path=recycle_bin_root,
+        )
+
+        scenario_log_dir = case_log_dir / scenario_id
+        scenario_state_dir = state_dir / scenario_id
+        scenario_log_dir.mkdir(parents=True, exist_ok=True)
+        scenario_state_dir.mkdir(parents=True, exist_ok=True)
+
+        seed_stdout = scenario_log_dir / "seed_stdout.log"
+        seed_stderr = scenario_log_dir / "seed_stderr.log"
+        delete_stdout = scenario_log_dir / "delete_stdout.log"
+        delete_stderr = scenario_log_dir / "delete_stderr.log"
+        process_stdout = scenario_log_dir / "process_stdout.log"
+        process_stderr = scenario_log_dir / "process_stderr.log"
+        verify_stdout = scenario_log_dir / "verify_stdout.log"
+        verify_stderr = scenario_log_dir / "verify_stderr.log"
+        local_manifest_file = scenario_state_dir / "local_manifest.txt"
+        remote_manifest_file = scenario_state_dir / "remote_manifest.txt"
+        recycle_manifest_file = scenario_state_dir / "recycle_manifest.txt"
+        metadata_file = scenario_state_dir / "metadata.txt"
+
+        artifacts = [
+            str(seed_stdout),
+            str(seed_stderr),
+            str(delete_stdout),
+            str(delete_stderr),
+            str(process_stdout),
+            str(process_stderr),
+            str(verify_stdout),
+            str(verify_stderr),
+            str(local_manifest_file),
+            str(remote_manifest_file),
+            str(recycle_manifest_file),
+            str(metadata_file),
+        ]
+        details: dict[str, object] = {
+            "scenario_id": scenario_id,
+            "scenario_name": scenario_name,
+            "delete_origin": delete_origin,
+            "use_recycle_bin": use_recycle_bin,
+            "root_name": root_name,
+            "delete_dir_relative": delete_dir_relative,
+            "delete_file_relative": delete_file_relative,
+            "keep_file_relative": keep_file_relative,
+        }
+        failures: list[str] = []
+
+        seed_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--upload-only",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_runtime),
+        ]
+        seed_result = self._run_and_capture(context, f"{scenario_id} seed", seed_command, seed_stdout, seed_stderr)
+        details["seed_returncode"] = seed_result.returncode
+        if seed_result.returncode != 0:
+            failures.append(f"{scenario_id}: seed phase failed with status {seed_result.returncode}")
+            self._write_metadata(metadata_file, details)
+            return failures, artifacts, details
+
+        if delete_origin == "online":
+            delete_command = [
+                context.onedrive_bin,
+                "--display-running-config",
+                "--verbose",
+                "--remove-directory",
+                delete_dir_relative,
+                "--confdir",
+                str(conf_runtime),
+            ]
+            delete_result = self._run_and_capture(context, f"{scenario_id} online delete", delete_command, delete_stdout, delete_stderr)
+            details["delete_returncode"] = delete_result.returncode
+            if delete_result.returncode != 0:
+                failures.append(f"{scenario_id}: online delete failed with status {delete_result.returncode}")
+                self._write_metadata(metadata_file, details)
+                return failures, artifacts, details
+
+            process_command = [
+                context.onedrive_bin,
+                "--display-running-config",
+                "--sync",
+                "--verbose",
+                "--download-only",
+                "--cleanup-local-files",
+                "--single-directory",
+                root_name,
+                "--confdir",
+                str(conf_runtime),
+            ]
+        elif delete_origin == "local":
+            delete_local_path = sync_root / delete_dir_relative
+            if not delete_local_path.is_dir():
+                failures.append(f"{scenario_id}: expected local delete directory missing before local delete: {delete_local_path}")
+                self._write_metadata(metadata_file, details)
+                return failures, artifacts, details
+
+            shutil.rmtree(delete_local_path)
+            write_text_file(delete_stdout, f"Deleted local path: {delete_local_path}\n")
+            write_text_file(delete_stderr, "")
+            details["delete_returncode"] = 0
+
+            process_command = [
+                context.onedrive_bin,
+                "--display-running-config",
+                "--sync",
+                "--verbose",
+                "--single-directory",
+                root_name,
+                "--confdir",
+                str(conf_runtime),
+            ]
+        else:
+            failures.append(f"{scenario_id}: invalid delete_origin: {delete_origin}")
+            self._write_metadata(metadata_file, details)
+            return failures, artifacts, details
+
+        process_result = self._run_and_capture(context, f"{scenario_id} process delete", process_command, process_stdout, process_stderr)
+        details["process_returncode"] = process_result.returncode
+        if process_result.returncode != 0:
+            failures.append(f"{scenario_id}: delete processing failed with status {process_result.returncode}")
+
+        reset_directory(verify_root)
+        self._prepare_config(
+            context,
+            conf_verify,
+            verify_root,
+            use_recycle_bin=False,
+            recycle_bin_path=recycle_bin_root,
+        )
+        verify_command = [
+            context.onedrive_bin,
+            "--display-running-config",
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--resync",
+            "--resync-auth",
+            "--single-directory",
+            root_name,
+            "--confdir",
+            str(conf_verify),
+        ]
+        verify_result = self._run_and_capture(context, f"{scenario_id} verify", verify_command, verify_stdout, verify_stderr)
+        details["verify_returncode"] = verify_result.returncode
+        if verify_result.returncode != 0:
+            failures.append(f"{scenario_id}: remote verification failed with status {verify_result.returncode}")
+
+        local_manifest = build_manifest(sync_root)
+        remote_manifest = build_manifest(verify_root)
+        recycle_manifest = build_manifest(recycle_bin_root)
+        write_manifest(local_manifest_file, local_manifest)
+        write_manifest(remote_manifest_file, remote_manifest)
+        write_manifest(recycle_manifest_file, recycle_manifest)
+
+        local_has_delete_dir = self._contains_path_prefix(local_manifest, delete_dir_relative)
+        remote_has_delete_dir = self._contains_path_prefix(remote_manifest, delete_dir_relative)
+        local_has_keep_file = keep_file_relative in local_manifest
+        remote_has_keep_file = keep_file_relative in remote_manifest
+        recycle_has_payload = self._recycle_bin_has_payload(recycle_manifest, "delete-me.txt")
+        recycle_has_trashinfo = self._recycle_bin_has_trashinfo(recycle_manifest)
+
+        details.update(
+            {
+                "local_has_delete_dir": local_has_delete_dir,
+                "remote_has_delete_dir": remote_has_delete_dir,
+                "local_has_keep_file": local_has_keep_file,
+                "remote_has_keep_file": remote_has_keep_file,
+                "recycle_has_payload": recycle_has_payload,
+                "recycle_has_trashinfo": recycle_has_trashinfo,
+                "expected_recycle_bin_payload": delete_origin == "online" and use_recycle_bin,
+                "expected_local_delete_propagation": delete_origin == "local",
+                "local_manifest_count": len(local_manifest),
+                "remote_manifest_count": len(remote_manifest),
+                "recycle_manifest_count": len(recycle_manifest),
+            }
+        )
+
+        if local_has_delete_dir:
+            failures.append(f"{scenario_id}: deleted directory still exists locally after delete processing")
+        if remote_has_delete_dir:
+            failures.append(f"{scenario_id}: deleted directory still exists online after delete processing")
+        if not local_has_keep_file:
+            failures.append(f"{scenario_id}: keep file missing locally after delete processing")
+        if not remote_has_keep_file:
+            failures.append(f"{scenario_id}: keep file missing online after delete processing")
+
+        if delete_origin == "online" and use_recycle_bin:
+            if not recycle_has_payload:
+                failures.append(f"{scenario_id}: online-origin deleted payload was not moved into the configured recycle bin")
+            if not recycle_has_trashinfo:
+                failures.append(f"{scenario_id}: online-origin delete did not create recycle bin metadata .trashinfo file")
+        else:
+            if recycle_has_payload or recycle_has_trashinfo:
+                if delete_origin == "local" and use_recycle_bin:
+                    failures.append(
+                        f"{scenario_id}: local-origin delete unexpectedly created configured recycle bin data; "
+                        "local deletes are already removed before the client observes them and should be propagated online"
+                    )
+                else:
+                    failures.append(f"{scenario_id}: recycle bin contains deleted data even though use_recycle_bin=false")
+
+        self._write_metadata(metadata_file, details)
+        return failures, artifacts, details
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name="tc0057",
+            ensure_refresh_token=True,
+        )
+        case_work_dir = layout.work_dir
+        case_log_dir = layout.log_dir
+        state_dir = layout.state_dir
+
+        scenarios = [
+            {
+                "scenario_id": "S01_online_delete_recycle_bin_false",
+                "scenario_name": "online delete with use_recycle_bin=false",
+                "delete_origin": "online",
+                "use_recycle_bin": False,
+            },
+            {
+                "scenario_id": "S02_online_delete_recycle_bin_true",
+                "scenario_name": "online delete with use_recycle_bin=true",
+                "delete_origin": "online",
+                "use_recycle_bin": True,
+            },
+            {
+                "scenario_id": "S03_local_delete_recycle_bin_false",
+                "scenario_name": "local delete with use_recycle_bin=false",
+                "delete_origin": "local",
+                "use_recycle_bin": False,
+            },
+            {
+                "scenario_id": "S04_local_delete_recycle_bin_true",
+                "scenario_name": "local delete with use_recycle_bin=true",
+                "delete_origin": "local",
+                "use_recycle_bin": True,
+            },
+        ]
+
+        selected_scenarios = [
+            scenario
+            for scenario in scenarios
+            if context.should_run_scenario(self.case_id, str(scenario["scenario_id"]))
+        ]
+
+        all_failures: list[str] = []
+        all_artifacts: list[str] = []
+        details: dict[str, object] = {
+            "scenario_count": len(selected_scenarios),
+            "selected_scenarios": [scenario["scenario_id"] for scenario in selected_scenarios],
+        }
+
+        for scenario in selected_scenarios:
+            failures, artifacts, scenario_details = self._run_scenario(
+                context,
+                scenario_id=str(scenario["scenario_id"]),
+                scenario_name=str(scenario["scenario_name"]),
+                delete_origin=str(scenario["delete_origin"]),
+                use_recycle_bin=bool(scenario["use_recycle_bin"]),
+                case_work_dir=case_work_dir,
+                case_log_dir=case_log_dir,
+                state_dir=state_dir,
+            )
+            all_failures.extend(failures)
+            all_artifacts.extend(artifacts)
+            details[str(scenario["scenario_id"])] = scenario_details
+
+        metadata_file = state_dir / "metadata.txt"
+        self._write_metadata(metadata_file, details)
+        all_artifacts.append(str(metadata_file))
+
+        if not selected_scenarios:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "No tc0057 scenarios were selected to run",
+                all_artifacts,
+                details,
+            )
+
+        if all_failures:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "; ".join(all_failures),
+                all_artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, all_artifacts, details)
diff --git a/ci/e2e/testcases_business_shared_folders/__init__.py b/ci/e2e/testcases_business_shared_folders/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/ci/e2e/testcases_business_shared_folders/bsftc0001_clean_sync_pull_down.py b/ci/e2e/testcases_business_shared_folders/bsftc0001_clean_sync_pull_down.py
new file mode 100644
index 000000000..f2a2e145b
--- /dev/null
+++ b/ci/e2e/testcases_business_shared_folders/bsftc0001_clean_sync_pull_down.py
@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.result import TestResult
+from framework.utils import command_to_string, run_command, write_text_file
+from testcases_business_shared_folders.shared_folder_common import (
+    case_sync_root,
+    manifest_failure_reason,
+    reset_local_sync_root,
+    validate_required_manifest,
+    write_case_config,
+    write_common_metadata,
+)
+
+
+class BusinessSharedFolderTestCase0001CleanSyncPullDown(E2ETestCase):
+    case_id = "bsftc0001"
+    name = "business shared folders clean sync pull down"
+    description = "Validate that --sync --verbose pulls down the preserved Business Account shared-folder topology"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name=self.case_id,
+            ensure_refresh_token=True,
+        )
+
+        sync_root = case_sync_root(self.case_id)
+        confdir = layout.work_dir / "conf"
+        reset_local_sync_root(sync_root)
+        write_case_config(context, confdir, self.case_id)
+
+        stdout_file = layout.log_dir / "stdout.log"
+        stderr_file = layout.log_dir / "stderr.log"
+        manifest_file = layout.state_dir / "local_typed_manifest.txt"
+        expected_manifest_file = layout.state_dir / "expected_required_typed_manifest.txt"
+        missing_manifest_file = layout.state_dir / "missing_expected_entries.txt"
+        metadata_file = layout.state_dir / "metadata.txt"
+
+        command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(confdir),
+        ]
+
+        context.log(f"Executing Test Case {self.case_id}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+
+        validation = validate_required_manifest(
+            sync_root=sync_root,
+            stdout_text=result.stdout,
+            manifest_file=manifest_file,
+            expected_manifest_file=expected_manifest_file,
+            missing_manifest_file=missing_manifest_file,
+        )
+
+        write_common_metadata(
+            metadata_file,
+            case_id=self.case_id,
+            name=self.name,
+            command=command,
+            returncode=result.returncode,
+            sync_root=sync_root,
+            config_dir=confdir,
+            validation=validation,
+        )
+
+        artifacts = [
+            str(stdout_file),
+            str(stderr_file),
+            str(manifest_file),
+            str(expected_manifest_file),
+            str(missing_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "command": command,
+            "returncode": result.returncode,
+            "sync_root": str(sync_root),
+            "config_dir": str(confdir),
+            **validation,
+        }
+
+        if result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"onedrive exited with non-zero status {result.returncode}",
+                artifacts,
+                details,
+            )
+
+        reason = manifest_failure_reason(validation)
+        if reason:
+            return self.fail_result(self.case_id, self.name, reason, artifacts, details)
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases_business_shared_folders/bsftc0002_clean_monitor_pull_down.py b/ci/e2e/testcases_business_shared_folders/bsftc0002_clean_monitor_pull_down.py
new file mode 100644
index 000000000..eca4cea0b
--- /dev/null
+++ b/ci/e2e/testcases_business_shared_folders/bsftc0002_clean_monitor_pull_down.py
@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import subprocess
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.result import TestResult
+from framework.utils import command_to_string, write_text_file
+from testcases_business_shared_folders.shared_folder_common import (
+    case_sync_root,
+    manifest_failure_reason,
+    reset_local_sync_root,
+    stop_monitor_process,
+    validate_required_manifest,
+    wait_for_stdout_marker,
+    write_case_config,
+    write_common_metadata,
+)
+
+
+class BusinessSharedFolderTestCase0002CleanMonitorPullDown(E2ETestCase):
+    case_id = "bsftc0002"
+    name = "business shared folders clean monitor pull down"
+    description = "Validate that --monitor --verbose pulls down the preserved Business Account shared-folder topology"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name=self.case_id,
+            ensure_refresh_token=True,
+        )
+
+        sync_root = case_sync_root(self.case_id)
+        confdir = layout.work_dir / "conf"
+        reset_local_sync_root(sync_root)
+        write_case_config(context, confdir, self.case_id)
+
+        stdout_file = layout.log_dir / "stdout.log"
+        stderr_file = layout.log_dir / "stderr.log"
+        manifest_file = layout.state_dir / "local_typed_manifest.txt"
+        expected_manifest_file = layout.state_dir / "expected_required_typed_manifest.txt"
+        missing_manifest_file = layout.state_dir / "missing_expected_entries.txt"
+        metadata_file = layout.state_dir / "metadata.txt"
+
+        command = [
+            context.onedrive_bin,
+            "--monitor",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(confdir),
+        ]
+
+        context.log(f"Executing Test Case {self.case_id}: {command_to_string(command)}")
+
+        with stdout_file.open("w", encoding="utf-8") as stdout_fp, stderr_file.open("w", encoding="utf-8") as stderr_fp:
+            process = subprocess.Popen(
+                command,
+                cwd=str(context.repo_root),
+                stdout=stdout_fp,
+                stderr=stderr_fp,
+                text=True,
+            )
+            initial_sync_complete = wait_for_stdout_marker(
+                stdout_file,
+                "Sync with Microsoft OneDrive is complete",
+                timeout_seconds=1200,
+            )
+            monitor_returncode = stop_monitor_process(process)
+
+        stdout_text = stdout_file.read_text(encoding="utf-8", errors="replace") if stdout_file.exists() else ""
+        validation = validate_required_manifest(
+            sync_root=sync_root,
+            stdout_text=stdout_text,
+            manifest_file=manifest_file,
+            expected_manifest_file=expected_manifest_file,
+            missing_manifest_file=missing_manifest_file,
+        )
+
+        write_common_metadata(
+            metadata_file,
+            case_id=self.case_id,
+            name=self.name,
+            command=command,
+            returncode=monitor_returncode,
+            sync_root=sync_root,
+            config_dir=confdir,
+            validation=validation,
+            extra_lines=[f"initial_sync_complete={initial_sync_complete}"],
+        )
+
+        artifacts = [
+            str(stdout_file),
+            str(stderr_file),
+            str(manifest_file),
+            str(expected_manifest_file),
+            str(missing_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "command": command,
+            "monitor_returncode": monitor_returncode,
+            "initial_sync_complete": initial_sync_complete,
+            "sync_root": str(sync_root),
+            "config_dir": str(confdir),
+            **validation,
+        }
+
+        if not initial_sync_complete:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Monitor mode did not complete the initial Business shared-folder sync within the expected time",
+                artifacts,
+                details,
+            )
+
+        if monitor_returncode not in (0, 130, -2):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"monitor mode exited with unexpected status {monitor_returncode}",
+                artifacts,
+                details,
+            )
+
+        reason = manifest_failure_reason(validation)
+        if reason:
+            return self.fail_result(self.case_id, self.name, reason, artifacts, details)
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases_business_shared_folders/bsftc0003_sync_list_validation.py b/ci/e2e/testcases_business_shared_folders/bsftc0003_sync_list_validation.py
new file mode 100644
index 000000000..6da3f7e21
--- /dev/null
+++ b/ci/e2e/testcases_business_shared_folders/bsftc0003_sync_list_validation.py
@@ -0,0 +1,801 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_typed_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+from testcases_business_shared_folders.shared_folder_common import (
+    REQUIRED_TYPED_MANIFEST_ENTRIES,
+    case_sync_root,
+    reset_local_sync_root,
+)
+
+
+CONFIG_FILE_NAME = "config"
+SYNC_LIST_FILE_NAME = "sync_list"
+
+
+@dataclass
+class BusinessSharedFolderSyncListScenario:
+    scenario_id: str
+    description: str
+    sync_list: list[str]
+    expected_entries: list[str]
+    required_present: list[str] = field(default_factory=list)
+    required_absent: list[str] = field(default_factory=list)
+    required_stdout_markers: list[str] = field(default_factory=list)
+    cleanup_local_stale_files: list[str] = field(default_factory=list)
+
+
+class BusinessSharedFolderTestCase0003SyncListValidation(E2ETestCase):
+    case_id = "bsftc0003"
+    name = "business shared folders sync_list validation"
+    description = (
+        "Validate sync_list include/exclude behaviour across preserved Business Account "
+        "shared-folder shortcut topology without leaking unrelated account content"
+    )
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name=self.case_id,
+            ensure_refresh_token=True,
+        )
+
+        sync_root = case_sync_root(self.case_id)
+        reset_local_sync_root(sync_root)
+
+        scenarios = [
+            scenario for scenario in self._build_scenarios()
+            if context.should_run_scenario(self.case_id, scenario.scenario_id)
+        ]
+
+        failures: list[str] = []
+        all_artifacts: list[str] = []
+
+        for scenario in scenarios:
+            context.log(
+                f"Running Test Case {self.case_id} scenario {scenario.scenario_id}: "
+                f"{scenario.description}"
+            )
+
+            scenario_sync_root = sync_root / scenario.scenario_id
+            scenario_dir = layout.state_dir / scenario.scenario_id
+            scenario_log_dir = layout.log_dir / scenario.scenario_id
+            confdir = layout.work_dir / f"conf-{scenario.scenario_id}"
+
+            reset_local_sync_root(scenario_sync_root)
+            reset_directory(scenario_dir)
+            reset_directory(scenario_log_dir)
+            reset_directory(confdir)
+
+            config_path = self._write_scenario_config(
+                context,
+                confdir,
+                scenario_sync_root,
+                cleanup_local_files=bool(scenario.cleanup_local_stale_files),
+            )
+            sync_list_path = confdir / SYNC_LIST_FILE_NAME
+            self._write_sync_list(sync_list_path, scenario.sync_list)
+
+            stdout_file = scenario_log_dir / "stdout.log"
+            stderr_file = scenario_log_dir / "stderr.log"
+            actual_manifest_file = scenario_dir / "actual_typed_manifest.txt"
+            expected_manifest_file = scenario_dir / "expected_typed_manifest.txt"
+            missing_manifest_file = scenario_dir / "missing_expected_entries.txt"
+            unexpected_manifest_file = scenario_dir / "unexpected_extra_entries.txt"
+            required_present_file = scenario_dir / "missing_required_present_entries.txt"
+            required_absent_file = scenario_dir / "unexpected_required_absent_entries.txt"
+            metadata_file = scenario_dir / "metadata.txt"
+            diff_file = scenario_dir / "diff.txt"
+
+            command = [
+                context.onedrive_bin,
+                "--sync",
+                "--verbose",
+                "--download-only",
+                "--resync",
+                "--resync-auth",
+                "--confdir",
+                str(confdir),
+            ]
+
+            context.log(f"Executing {self.case_id} {scenario.scenario_id}: {command_to_string(command)}")
+            result = run_command(command, cwd=context.repo_root)
+
+            write_text_file(stdout_file, result.stdout)
+            write_text_file(stderr_file, result.stderr)
+
+            actual_manifest = build_typed_manifest(scenario_sync_root)
+            expected_manifest = sorted(set(scenario.expected_entries))
+            write_manifest(actual_manifest_file, actual_manifest)
+            write_manifest(expected_manifest_file, expected_manifest)
+
+            actual_set = set(actual_manifest)
+            expected_set = set(expected_manifest)
+            missing_entries = sorted(expected_set - actual_set)
+            unexpected_entries = sorted(actual_set - expected_set)
+            missing_required_present = sorted(
+                entry for entry in scenario.required_present if entry not in actual_set
+            )
+            unexpected_required_absent = sorted(
+                entry for entry in scenario.required_absent if entry in actual_set
+            )
+            missing_stdout_markers = [
+                marker for marker in scenario.required_stdout_markers if marker not in result.stdout
+            ]
+
+            write_manifest(missing_manifest_file, missing_entries)
+            write_manifest(unexpected_manifest_file, unexpected_entries)
+            write_manifest(required_present_file, missing_required_present)
+            write_manifest(required_absent_file, unexpected_required_absent)
+
+            cleanup_failures: list[str] = []
+            cleanup_artifacts: list[str] = []
+            if scenario.cleanup_local_stale_files:
+                if result.returncode != 0 or missing_entries or unexpected_entries or missing_required_present or unexpected_required_absent:
+                    cleanup_failures.append(
+                        "Skipping cleanup_local_files validation because initial immutable baseline validation failed"
+                    )
+                else:
+                    cleanup_failures.extend(
+                        self._run_local_stale_cleanup_check(
+                            context=context,
+                            confdir=confdir,
+                            sync_root=scenario_sync_root,
+                            scenario_log_dir=scenario_log_dir,
+                            scenario=scenario,
+                            artifacts=cleanup_artifacts,
+                        )
+                    )
+
+            diffs: list[str] = []
+            if result.returncode != 0:
+                diffs.append(f"onedrive exited with non-zero status {result.returncode}")
+            if missing_stdout_markers:
+                diffs.append(
+                    "Expected Business shared-folder stdout markers were not present: "
+                    + ", ".join(missing_stdout_markers)
+                )
+            if missing_entries:
+                diffs.append(f"Missing expected local entries: {missing_entries[:20]!r}")
+            if unexpected_entries:
+                diffs.append(
+                    "Unexpected local entries were created; possible sync_list leak: "
+                    + repr(unexpected_entries[:20])
+                )
+            if missing_required_present:
+                diffs.append(f"Required included entries were missing: {missing_required_present!r}")
+            if unexpected_required_absent:
+                diffs.append(f"Required excluded entries were present locally: {unexpected_required_absent!r}")
+            if cleanup_failures:
+                diffs.append("cleanup_local_files validation failed: " + "; ".join(cleanup_failures))
+
+            metadata_lines = [
+                f"case_id={self.case_id}",
+                f"scenario_id={scenario.scenario_id}",
+                f"description={scenario.description}",
+                f"command={command_to_string(command)}",
+                f"returncode={result.returncode}",
+                f"sync_root={scenario_sync_root}",
+                f"config_dir={confdir}",
+                f"config_path={config_path}",
+                f"sync_list_path={sync_list_path}",
+                f"expected_entries={len(expected_manifest)}",
+                f"actual_entries={len(actual_manifest)}",
+                f"missing_entries={len(missing_entries)}",
+                f"unexpected_entries={len(unexpected_entries)}",
+                f"missing_required_present={missing_required_present!r}",
+                f"unexpected_required_absent={unexpected_required_absent!r}",
+                f"missing_stdout_markers={missing_stdout_markers!r}",
+                f"cleanup_local_stale_files={scenario.cleanup_local_stale_files!r}",
+                f"cleanup_failures={cleanup_failures!r}",
+            ]
+            write_text_file(metadata_file, "\n".join(metadata_lines) + "\n")
+
+            scenario_artifacts = [
+                str(config_path),
+                str(sync_list_path),
+                str(stdout_file),
+                str(stderr_file),
+                str(actual_manifest_file),
+                str(expected_manifest_file),
+                str(missing_manifest_file),
+                str(unexpected_manifest_file),
+                str(required_present_file),
+                str(required_absent_file),
+                str(metadata_file),
+            ]
+            scenario_artifacts.extend(cleanup_artifacts)
+            all_artifacts.extend(scenario_artifacts)
+
+            if diffs:
+                write_text_file(diff_file, "\n".join(diffs) + "\n")
+                all_artifacts.append(str(diff_file))
+                failure_message = f"{scenario.scenario_id}: " + "; ".join(diffs)
+                failures.append(failure_message)
+                context.log(f"Scenario {scenario.scenario_id} FAILED: {failure_message}")
+            else:
+                context.log(f"Scenario {scenario.scenario_id} PASSED")
+
+        details = {
+            "scenario_count": len(scenarios),
+            "executed_scenario_ids": [scenario.scenario_id for scenario in scenarios],
+            "failed_scenarios": len(failures),
+            "failed_scenario_ids": [failure.split(":", 1)[0] for failure in failures],
+        }
+
+        if failures:
+            details["failures"] = failures
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"{len(failures)} of {len(scenarios)} Business shared-folder sync_list scenarios failed: "
+                + ", ".join(failure.split(":", 1)[0] for failure in failures),
+                all_artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, all_artifacts, details)
+
+    def _run_local_stale_cleanup_check(
+        self,
+        context: E2EContext,
+        confdir: Path,
+        sync_root: Path,
+        scenario_log_dir: Path,
+        scenario: BusinessSharedFolderSyncListScenario,
+        artifacts: list[str],
+    ) -> list[str]:
+        failures: list[str] = []
+        before_manifest = build_typed_manifest(sync_root)
+
+        cleanup_stdout_file = scenario_log_dir / "cleanup-local-files-stdout.log"
+        cleanup_stderr_file = scenario_log_dir / "cleanup-local-files-stderr.log"
+        cleanup_before_manifest_file = scenario_log_dir / "cleanup-local-files-before-manifest.txt"
+        cleanup_after_manifest_file = scenario_log_dir / "cleanup-local-files-after-manifest.txt"
+        artifacts.extend([
+            str(cleanup_stdout_file),
+            str(cleanup_stderr_file),
+            str(cleanup_before_manifest_file),
+            str(cleanup_after_manifest_file),
+        ])
+
+        write_manifest(cleanup_before_manifest_file, before_manifest)
+
+        created_files: list[Path] = []
+        for rel_file in scenario.cleanup_local_stale_files:
+            rel_file = rel_file.strip("/")
+            if not rel_file or rel_file.endswith("/") or "/../" in f"/{rel_file}/":
+                failures.append(f"Refusing unsafe cleanup-local stale file path: {rel_file!r}")
+                continue
+
+            local_file = sync_root / rel_file
+            if not local_file.parent.is_dir():
+                failures.append(
+                    f"Refusing cleanup-local stale file because immutable parent is missing: {rel_file}"
+                )
+                continue
+            if local_file.exists():
+                failures.append(
+                    f"Refusing cleanup-local stale file because path already exists: {rel_file}"
+                )
+                continue
+            if not local_file.name.startswith("bsftc0003-"):
+                failures.append(
+                    f"Refusing cleanup-local stale file without bsftc0003- prefix: {rel_file}"
+                )
+                continue
+
+            write_text_file(local_file, f"local stale cleanup validation for {scenario.scenario_id}\n")
+            created_files.append(local_file)
+
+        if failures:
+            for local_file in created_files:
+                if local_file.exists():
+                    local_file.unlink()
+            return failures
+
+        cleanup_command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--confdir",
+            str(confdir),
+        ]
+        context.log(
+            f"Executing {self.case_id} {scenario.scenario_id} cleanup_local_files "
+            f"validation: {command_to_string(cleanup_command)}"
+        )
+        cleanup_result = run_command(cleanup_command, cwd=context.repo_root)
+        write_text_file(cleanup_stdout_file, cleanup_result.stdout)
+        write_text_file(cleanup_stderr_file, cleanup_result.stderr)
+
+        if cleanup_result.returncode != 0:
+            failures.append(
+                f"cleanup_local_files validation sync exited with non-zero status {cleanup_result.returncode}"
+            )
+
+        for local_file in created_files:
+            if local_file.exists():
+                failures.append(
+                    f"Local stale file was not removed by cleanup_local_files: "
+                    f"{local_file.relative_to(sync_root)}"
+                )
+                local_file.unlink()
+
+        after_manifest = build_typed_manifest(sync_root)
+        write_manifest(cleanup_after_manifest_file, after_manifest)
+
+        before_set = set(before_manifest)
+        after_set = set(after_manifest)
+        missing_after = sorted(before_set - after_set)
+        unexpected_after = sorted(after_set - before_set)
+        if missing_after:
+            failures.append(
+                f"Immutable baseline changed during cleanup_local_files; missing entries: {missing_after[:20]!r}"
+            )
+        if unexpected_after:
+            failures.append(
+                f"Unexpected entries after cleanup_local_files: {unexpected_after[:20]!r}"
+            )
+
+        return failures
+
+    def _write_scenario_config(
+        self,
+        context: E2EContext,
+        config_dir: Path,
+        sync_root: Path,
+        cleanup_local_files: bool = False,
+    ) -> Path:
+        cleanup_value = "true" if cleanup_local_files else "false"
+        config_path = context.prepare_minimal_config_dir(
+            config_dir,
+            "# bsftc0003 Business Shared Folder sync_list config\n"
+            f'sync_dir = "{sync_root}"\n'
+            'threads = "2"\n'
+            'download_only = "true"\n'
+            f'cleanup_local_files = "{cleanup_value}"\n'
+            'sync_business_shared_items = "true"\n'
+            'bypass_data_preservation = "true"\n',
+        )
+        return config_path
+
+    def _write_sync_list(self, sync_list_path: Path, sync_list: list[str]) -> None:
+        write_text_file(sync_list_path, "\n".join(sync_list) + "\n")
+
+    def _parent_entries_for(self, path: str) -> list[str]:
+        parts = path.strip("/").split("/")
+        parents: list[str] = []
+        for index in range(1, len(parts)):
+            parents.append("/".join(parts[:index]) + "/")
+        return [entry for entry in parents if entry in REQUIRED_TYPED_MANIFEST_ENTRIES]
+
+    def _entries_under(self, *prefixes: str) -> list[str]:
+        normalised_prefixes = [prefix.strip("/") for prefix in prefixes]
+        entries: list[str] = []
+        for prefix in normalised_prefixes:
+            entries.extend(self._parent_entries_for(prefix))
+        for entry in REQUIRED_TYPED_MANIFEST_ENTRIES:
+            clean_entry = entry.rstrip("/")
+            for prefix in normalised_prefixes:
+                if clean_entry == prefix or clean_entry.startswith(prefix + "/"):
+                    entries.append(entry)
+                    break
+        return sorted(set(entries))
+
+    def _entries_exact(self, *entries: str) -> list[str]:
+        expected_set = set(REQUIRED_TYPED_MANIFEST_ENTRIES)
+        selected: list[str] = []
+        for entry in entries:
+            clean_entry = entry.strip("/")
+            selected.extend(self._parent_entries_for(clean_entry))
+            if entry in expected_set:
+                selected.append(entry)
+            elif entry + "/" in expected_set:
+                selected.append(entry + "/")
+            elif clean_entry in expected_set:
+                selected.append(clean_entry)
+            elif clean_entry + "/" in expected_set:
+                selected.append(clean_entry + "/")
+            else:
+                selected.append(entry)
+        return sorted(set(selected))
+
+    def _exclude_entries(self, entries: list[str], *prefixes: str) -> list[str]:
+        normalised_prefixes = [prefix.strip("/") for prefix in prefixes]
+        filtered: list[str] = []
+        for entry in entries:
+            clean_entry = entry.rstrip("/")
+            excluded = any(
+                clean_entry == prefix or clean_entry.startswith(prefix + "/")
+                for prefix in normalised_prefixes
+            )
+            if not excluded:
+                filtered.append(entry)
+        return sorted(set(filtered))
+
+    def _marker(self, shared_folder_path: str) -> str:
+        return f"Syncing this OneDrive Business Shared Folder: {shared_folder_path.strip('/')}"
+
+    def _build_scenarios(self) -> list[BusinessSharedFolderSyncListScenario]:
+        core = "Documents/BSF_CORE"
+        mixed = "Documents/BSF_MIXED_FILES"
+        core_dataset_a = f"{core}/DATASET_A"
+        core_dataset_b = f"{core}/DATASET_B"
+        core_files = f"{core_dataset_b}/files"
+        core_nested = f"{core_dataset_b}/nested"
+        core_keep = f"{core_nested}/keep"
+        core_exclude = f"{core_nested}/exclude"
+        core_upload_target = f"{core_nested}/upload-target"
+        core_deep = f"{core}/TOP_LEVEL/PROJECTS/2026/Week10"
+        core_deep_log = f"{core_deep}/debug_output.log"
+        mixed_dataset_a = f"{mixed}/DATASET_A"
+        mixed_dataset_b = f"{mixed}/DATASET_B"
+        mixed_deep = f"{mixed_dataset_b}/L1/L2/L3"
+        mixed_deep_file = f"{mixed_deep}/deepfile.txt"
+        mixed_upload_target = f"{mixed_deep}/upload-target"
+
+        core_without_exclude = self._exclude_entries(
+            self._entries_under(core),
+            core_exclude,
+        )
+        core_dataset_b_without_images = self._exclude_entries(
+            self._entries_under(core_dataset_b),
+            f"{core_files}/image0.png",
+            f"{core_files}/image1.png",
+        )
+        presentation_subset = self._entries_exact(
+            f"{mixed_dataset_a}/Presentation1.pptx",
+            f"{mixed_dataset_a}/Presentation2.pptx",
+            f"{mixed_dataset_a}/Presentation3.pptx",
+        )
+        mixed_presentations = self._entries_exact(
+            f"{mixed_dataset_a}/Presentation1.pptx",
+            f"{mixed_dataset_a}/Presentation2.pptx",
+            f"{mixed_dataset_a}/Presentation3.pptx",
+            f"{mixed_dataset_a}/Presentation4.pptx",
+            f"{mixed_dataset_a}/Presentation5.pptx",
+        )
+        multi_tree = sorted(set(
+            self._entries_under(core_keep)
+            + self._entries_exact(mixed_deep_file)
+            + self._entries_exact(core_deep_log)
+        ))
+        both_shared_folders = sorted(set(self._entries_under(core) + self._entries_under(mixed)))
+        dataset_b_pair = sorted(set(self._entries_under(core_dataset_b) + self._entries_under(mixed_dataset_b)))
+        dataset_b_pair_without_core_images = sorted(set(
+            self._exclude_entries(self._entries_under(core_dataset_b), f"{core_files}/image0.png", f"{core_files}/image1.png")
+            + self._entries_under(mixed_dataset_b)
+        ))
+        exact_data_and_presentations = sorted(set(
+            self._entries_exact(f"{core_files}/data.txt")
+            + mixed_presentations
+        ))
+        upload_targets = sorted(set(
+            self._entries_under(core_upload_target)
+            + self._entries_under(mixed_upload_target)
+        ))
+        core_dataset_a_root_only = self._entries_exact(f"{core_dataset_a}/")
+        dataset_b_pair_without_core_images_and_mixed_deep_file = self._exclude_entries(
+            dataset_b_pair_without_core_images,
+            mixed_deep_file,
+        )
+
+        return [
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0001",
+                description="rooted include of BSF_CORE shared folder tree with trailing slash",
+                sync_list=[f"/{core}/"],
+                expected_entries=self._entries_under(core),
+                required_present=[f"{core}/DATASET_A/Document1.docx", f"{core_dataset_b}/README.txt"],
+                required_absent=[f"{mixed_dataset_a}/Document2.docx", "Documents/BSF_FILTER_MATRIX/MINIMAL/single.txt"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0002",
+                description="rooted include of BSF_MIXED_FILES shared folder tree without trailing slash",
+                sync_list=[f"/{mixed}"],
+                expected_entries=self._entries_under(mixed),
+                required_present=[f"{mixed_dataset_a}/Document2.docx", mixed_deep_file],
+                required_absent=[f"{core_dataset_b}/README.txt", "Documents/BSF_FILTER_MATRIX/MINIMAL/single.txt"],
+                required_stdout_markers=[self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0003",
+                description="rooted include of deep path below a Business shared folder",
+                sync_list=[f"/{mixed_deep}/"],
+                expected_entries=self._entries_under(mixed_deep),
+                required_present=[mixed_deep_file, f"{mixed_deep}/upload-target/"],
+                required_absent=[f"{mixed_dataset_a}/Document2.docx", f"{core_dataset_b}/README.txt"],
+                required_stdout_markers=[self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0004",
+                description="include BSF_CORE shared folder tree with nested exclusion",
+                sync_list=[
+                    f"!/{core_exclude}/*",
+                    f"/{core}/",
+                ],
+                expected_entries=core_without_exclude,
+                required_present=[f"{core_keep}/keep.txt", f"{core_files}/data.txt"],
+                required_absent=[f"{core_exclude}/exclude.txt", f"{mixed_dataset_a}/Document2.docx"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0005",
+                description="file-specific include inside a Business shared folder",
+                sync_list=[f"/{core_files}/data.txt"],
+                expected_entries=self._entries_exact(f"{core_files}/data.txt"),
+                required_present=[f"{core_files}/data.txt"],
+                required_absent=[f"{core_files}/image0.png", f"{core_dataset_b}/README.txt", f"{mixed_dataset_a}/Document2.docx"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0006",
+                description="multiple file-specific includes within one Business shared folder",
+                sync_list=[
+                    f"/{mixed_dataset_a}/Presentation1.pptx",
+                    f"/{mixed_dataset_a}/Presentation2.pptx",
+                    f"/{mixed_dataset_a}/Presentation3.pptx",
+                ],
+                expected_entries=presentation_subset,
+                required_present=[f"{mixed_dataset_a}/Presentation1.pptx", f"{mixed_dataset_a}/Presentation3.pptx"],
+                required_absent=[f"{mixed_dataset_a}/Presentation4.pptx", f"{mixed_dataset_a}/Document2.docx", f"{core_dataset_b}/README.txt"],
+                required_stdout_markers=[self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0007",
+                description="include nested Business shared-folder tree and exclude sibling shared folder trees",
+                sync_list=[f"/{core_deep}/"],
+                expected_entries=self._entries_under(core_deep),
+                required_present=[core_deep_log],
+                required_absent=[mixed_deep_file, f"{core_dataset_b}/README.txt"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0008",
+                description="mixed explicit includes across both Business shared folders",
+                sync_list=[
+                    f"/{core_keep}/",
+                    f"/{mixed_deep_file}",
+                    f"/{core_deep_log}",
+                ],
+                expected_entries=multi_tree,
+                required_present=[f"{core_keep}/keep.txt", mixed_deep_file, core_deep_log],
+                required_absent=[f"{core_exclude}/exclude.txt", f"{mixed_dataset_a}/Document2.docx"],
+                required_stdout_markers=[self._marker(core), self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0009",
+                description="wildcard include within a Business shared folder subtree",
+                sync_list=[f"/{mixed_dataset_a}/Presentation*.pptx"],
+                expected_entries=mixed_presentations,
+                required_present=[f"{mixed_dataset_a}/Presentation1.pptx", f"{mixed_dataset_a}/Presentation5.pptx"],
+                required_absent=[f"{mixed_dataset_a}/Document2.docx", f"{core_dataset_b}/README.txt"],
+                required_stdout_markers=[self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0010",
+                description="wildcard exclusion below an included Business shared folder subtree",
+                sync_list=[
+                    f"!/{core_files}/image*",
+                    f"/{core_dataset_b}/",
+                ],
+                expected_entries=core_dataset_b_without_images,
+                required_present=[f"{core_dataset_b}/README.txt", f"{core_files}/data.txt", f"{core_keep}/keep.txt"],
+                required_absent=[f"{core_files}/image0.png", f"{core_files}/image1.png", f"{mixed_dataset_a}/Document2.docx"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0011",
+                description="include empty upload-target directory inside a Business shared folder",
+                sync_list=[f"/{core_upload_target}/"],
+                expected_entries=self._entries_under(core_upload_target),
+                required_present=[f"{core_upload_target}/"],
+                required_absent=[f"{core_keep}/keep.txt", f"{core_exclude}/exclude.txt", mixed_deep_file],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0012",
+                description="multiple explicit Business shared-folder shortcut includes only",
+                sync_list=[
+                    f"/{core}/",
+                    f"/{mixed}/",
+                ],
+                expected_entries=both_shared_folders,
+                required_present=[f"{core_dataset_b}/README.txt", f"{mixed_dataset_a}/Document2.docx", mixed_deep_file],
+                required_absent=["Documents/BSF_FILTER_MATRIX/MINIMAL/single.txt"],
+                required_stdout_markers=[self._marker(core), self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0013",
+                description="wildcard Business shared-folder child include across DATASET_B branches",
+                sync_list=[f"/{core}/DATASET_*/", f"/{mixed}/DATASET_B/"],
+                expected_entries=dataset_b_pair + self._entries_under(core_dataset_a),
+                required_present=[f"{core_dataset_a}/Document1.docx", f"{core_dataset_b}/README.txt", mixed_deep_file],
+                required_absent=[f"{mixed_dataset_a}/Document2.docx", "Documents/BSF_FILTER_MATRIX/MINIMAL/single.txt"],
+                required_stdout_markers=[self._marker(core), self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0014",
+                description="globbing include for one file below a Business shared-folder directory tree",
+                sync_list=[f"/{core}/TOP_LEVEL/**/debug_output.log"],
+                expected_entries=self._entries_exact(core_deep_log),
+                required_present=[core_deep_log],
+                required_absent=[f"{core_dataset_b}/README.txt", mixed_deep_file],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0015",
+                description="normal Business shared-folder include with deeper wildcard exclusion",
+                sync_list=[
+                    f"!/{core}/DATASET_B/nested/excl*/*",
+                    f"/{core}/",
+                ],
+                expected_entries=core_without_exclude,
+                required_present=[f"{core_dataset_b}/README.txt", f"{core_keep}/keep.txt"],
+                required_absent=[f"{core_exclude}/exclude.txt", f"{mixed_dataset_a}/Document2.docx"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0016",
+                description="normal Business shared-folder include with deeper globbing exclusion",
+                sync_list=[
+                    f"!/{core}/**/exclude/*",
+                    f"/{core}/",
+                ],
+                expected_entries=core_without_exclude,
+                required_present=[f"{core_dataset_b}/README.txt", f"{core_keep}/keep.txt"],
+                required_absent=[f"{core_exclude}/exclude.txt", f"{mixed_dataset_a}/Document2.docx"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0017",
+                description="wildcard Business shared-folder include with wildcard exclusion of one matched branch",
+                sync_list=[
+                    f"!/{core}/DATASET_A/*",
+                    f"/{core}/DATASET_*/",
+                ],
+                expected_entries=sorted(set(core_dataset_a_root_only + self._entries_under(core_dataset_b))),
+                required_present=[f"{core_dataset_b}/README.txt", f"{core_files}/data.txt"],
+                required_absent=[f"{core_dataset_a}/Document1.docx", f"{mixed_dataset_a}/Document2.docx"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0018",
+                description="wildcard Business shared-folder include with globbing exclusion of one matched file",
+                sync_list=[
+                    f"!/{mixed}/**/deepfile.txt",
+                    f"/{mixed_dataset_b}/",
+                ],
+                expected_entries=self._exclude_entries(self._entries_under(mixed_dataset_b), mixed_deep_file),
+                required_present=[f"{mixed_upload_target}/"],
+                required_absent=[mixed_deep_file, f"{mixed_dataset_a}/Document2.docx"],
+                required_stdout_markers=[self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0019",
+                description="Business shared-folder dataset name collision with different per-branch exclusions",
+                sync_list=[
+                    f"!/{core}/DATASET_B/files/image*",
+                    f"!/{mixed}/DATASET_B/**/deepfile.txt",
+                    f"/{core_dataset_b}/",
+                    f"/{mixed_dataset_b}/",
+                ],
+                expected_entries=dataset_b_pair_without_core_images_and_mixed_deep_file,
+                required_present=[f"{core_files}/data.txt", f"{core_keep}/keep.txt", f"{mixed_upload_target}/"],
+                required_absent=[f"{core_files}/image0.png", mixed_deep_file, f"{mixed_dataset_a}/Document2.docx"],
+                required_stdout_markers=[self._marker(core), self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0020",
+                description="Business shared-folder exact file include with sibling wildcard exclusion",
+                sync_list=[
+                    f"!/{core}/DATASET_B/files/image*",
+                    f"/{core}/DATASET_B/files/data.txt",
+                ],
+                expected_entries=self._entries_exact(f"{core_files}/data.txt"),
+                required_present=[f"{core_files}/data.txt"],
+                required_absent=[f"{core_files}/image0.png", f"{core_files}/image1.png", f"{core_dataset_b}/README.txt"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0021",
+                description="Business shared-folder globbing include across file-type and exact-file patterns",
+                sync_list=[
+                    f"/{mixed_dataset_a}/Presentation*.pptx",
+                    f"/{core_files}/data.txt",
+                ],
+                expected_entries=exact_data_and_presentations,
+                required_present=[f"{core_files}/data.txt", f"{mixed_dataset_a}/Presentation1.pptx", f"{mixed_dataset_a}/Presentation5.pptx"],
+                required_absent=[f"{mixed_dataset_a}/Document2.docx", f"{core_dataset_b}/README.txt"],
+                required_stdout_markers=[self._marker(core), self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0022",
+                description="Business shared-folder include remains anchored without ghost sibling creation",
+                sync_list=[
+                    f"!/{core}_RENAMED/*",
+                    f"/{core}/",
+                ],
+                expected_entries=self._entries_under(core),
+                required_present=[f"{core_dataset_b}/README.txt", f"{core_upload_target}/"],
+                required_absent=[f"{core}_RENAMED/", f"{mixed_dataset_a}/Document2.docx", "Documents/BSF_FILTER_MATRIX/MINIMAL/single.txt"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0023",
+                description="Business shared-folder globbing include anchored to the verified deep DATASET_B branch",
+                sync_list=[f"/{mixed}/DATASET_B/**/deepfile.txt"],
+                expected_entries=sorted(set(
+                    self._entries_exact(mixed_deep_file)
+                    + self._entries_under(mixed_upload_target)
+                )),
+                required_present=[mixed_deep_file, f"{mixed_upload_target}/"],
+                required_absent=[f"{core_dataset_b}/README.txt", f"{mixed_dataset_a}/Document2.docx", "Documents/BSF_FILTER_MATRIX/DEEP_SOURCE/L1/L2/L3/deepfile.txt"],
+                required_stdout_markers=[self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0024",
+                description="cleanup_local_files removes local-only stale file under included Business shared-folder parent",
+                sync_list=[
+                    f"!/{core}/DATASET_B/files/bsftc0003-*",
+                    f"/{core}/",
+                ],
+                expected_entries=self._entries_under(core),
+                required_present=[f"{core_dataset_b}/README.txt", f"{core_files}/", f"{core_files}/data.txt"],
+                required_absent=[f"{mixed_dataset_a}/Document2.docx", "Documents/BSF_FILTER_MATRIX/MINIMAL/single.txt"],
+                required_stdout_markers=[self._marker(core)],
+                cleanup_local_stale_files=[f"{core}/DATASET_B/files/bsftc0003-local-stale.txt"],
+            ),
+
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0025",
+                description="Business shared-folder explicit file include across verified shared-folder DATASET_A document files",
+                sync_list=[
+                    f"/{core_dataset_a}/Document1.docx",
+                    f"/{mixed_dataset_a}/Document2.docx",
+                ],
+                expected_entries=sorted(set(
+                    self._entries_exact(f"{core_dataset_a}/Document1.docx")
+                    + self._entries_exact(f"{mixed_dataset_a}/Document2.docx")
+                )),
+                required_present=[f"{core_dataset_a}/Document1.docx", f"{mixed_dataset_a}/Document2.docx"],
+                required_absent=[f"{core_dataset_a}/image0.png", f"{mixed_dataset_a}/Presentation1.pptx", f"{core_dataset_b}/README.txt"],
+                required_stdout_markers=[self._marker(core), self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0026",
+                description="Business shared-folder explicit subtree include across verified shared-folder DATASET_A trees",
+                sync_list=[
+                    f"/{core_dataset_a}/",
+                    f"/{mixed_dataset_a}/",
+                ],
+                expected_entries=sorted(set(self._entries_under(core_dataset_a) + self._entries_under(mixed_dataset_a))),
+                required_present=[f"{core_dataset_a}/Document1.docx", f"{mixed_dataset_a}/Document2.docx", f"{mixed_dataset_a}/Presentation5.pptx"],
+                required_absent=[f"{core_dataset_b}/README.txt", mixed_deep_file, "Documents/BSF_FILTER_MATRIX/MINIMAL/single.txt"],
+                required_stdout_markers=[self._marker(core), self._marker(mixed)],
+            ),
+            BusinessSharedFolderSyncListScenario(
+                scenario_id="SL-0027",
+                description="Business shared-folder mixed backend exact includes without sibling leakage",
+                sync_list=[
+                    f"/{core_dataset_b}/README.txt",
+                    f"/{mixed_deep_file}",
+                ],
+                expected_entries=sorted(set(
+                    self._entries_exact(f"{core_dataset_b}/README.txt")
+                    + self._entries_exact(mixed_deep_file)
+                )),
+                required_present=[f"{core_dataset_b}/README.txt", mixed_deep_file],
+                required_absent=[f"{core_files}/data.txt", f"{mixed_dataset_a}/Document2.docx", "Documents/BSF_FILTER_MATRIX/MINIMAL/single.txt"],
+                required_stdout_markers=[self._marker(core), self._marker(mixed)],
+            ),
+        ]
diff --git a/ci/e2e/testcases_business_shared_folders/shared_folder_common.py b/ci/e2e/testcases_business_shared_folders/shared_folder_common.py
new file mode 100644
index 000000000..43472c439
--- /dev/null
+++ b/ci/e2e/testcases_business_shared_folders/shared_folder_common.py
@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import os
+import shutil
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+from framework.context import E2EContext
+from framework.manifest import build_typed_manifest, write_manifest
+from framework.utils import command_to_string, ensure_directory, write_text_file
+
+
+# Keep this suite intentionally focused on the stable Business Shared Folder
+# fixtures. The backing Business account contains other ad-hoc / legacy data;
+# validating the entire account tree would make these tests brittle for no
+# additional coverage value.
+REQUIRED_TYPED_MANIFEST_ENTRIES = [
+    'Documents/',
+    'Documents/BSF_CORE/',
+    'Documents/BSF_CORE/DATASET_A/',
+    'Documents/BSF_CORE/DATASET_A/Document1.docx',
+    'Documents/BSF_CORE/DATASET_A/image0.png',
+    'Documents/BSF_CORE/DATASET_A/image1.png',
+    'Documents/BSF_CORE/DATASET_A/image2.png',
+    'Documents/BSF_CORE/DATASET_A/image3.png',
+    'Documents/BSF_CORE/DATASET_A/image4.png',
+    'Documents/BSF_CORE/DATASET_B/',
+    'Documents/BSF_CORE/DATASET_B/README.txt',
+    'Documents/BSF_CORE/DATASET_B/empty-dir/',
+    'Documents/BSF_CORE/DATASET_B/files/',
+    'Documents/BSF_CORE/DATASET_B/files/data.txt',
+    'Documents/BSF_CORE/DATASET_B/files/image0.png',
+    'Documents/BSF_CORE/DATASET_B/files/image1.png',
+    'Documents/BSF_CORE/DATASET_B/nested/',
+    'Documents/BSF_CORE/DATASET_B/nested/exclude/',
+    'Documents/BSF_CORE/DATASET_B/nested/exclude/exclude.txt',
+    'Documents/BSF_CORE/DATASET_B/nested/keep/',
+    'Documents/BSF_CORE/DATASET_B/nested/keep/keep.txt',
+    'Documents/BSF_CORE/DATASET_B/nested/upload-target/',
+    'Documents/BSF_CORE/TOP_LEVEL/',
+    'Documents/BSF_CORE/TOP_LEVEL/PROJECTS/',
+    'Documents/BSF_CORE/TOP_LEVEL/PROJECTS/2026/',
+    'Documents/BSF_CORE/TOP_LEVEL/PROJECTS/2026/Week10/',
+    'Documents/BSF_CORE/TOP_LEVEL/PROJECTS/2026/Week10/debug_output.log',
+    'Documents/BSF_FILTER_MATRIX/',
+    'Documents/BSF_FILTER_MATRIX/CORE/',
+    'Documents/BSF_FILTER_MATRIX/CORE/README.txt',
+    'Documents/BSF_FILTER_MATRIX/CORE/empty-dir/',
+    'Documents/BSF_FILTER_MATRIX/CORE/files/',
+    'Documents/BSF_FILTER_MATRIX/CORE/files/data.txt',
+    'Documents/BSF_FILTER_MATRIX/CORE/files/image0.png',
+    'Documents/BSF_FILTER_MATRIX/CORE/files/image1.png',
+    'Documents/BSF_FILTER_MATRIX/CORE/nested/',
+    'Documents/BSF_FILTER_MATRIX/CORE/nested/exclude/',
+    'Documents/BSF_FILTER_MATRIX/CORE/nested/exclude/exclude.txt',
+    'Documents/BSF_FILTER_MATRIX/CORE/nested/keep/',
+    'Documents/BSF_FILTER_MATRIX/CORE/nested/keep/keep.txt',
+    'Documents/BSF_FILTER_MATRIX/CORE/nested/upload-target/',
+    'Documents/BSF_FILTER_MATRIX/DEEP_SOURCE/',
+    'Documents/BSF_FILTER_MATRIX/DEEP_SOURCE/L1/',
+    'Documents/BSF_FILTER_MATRIX/DEEP_SOURCE/L1/L2/',
+    'Documents/BSF_FILTER_MATRIX/DEEP_SOURCE/L1/L2/L3/',
+    'Documents/BSF_FILTER_MATRIX/DEEP_SOURCE/L1/L2/L3/deepfile.txt',
+    'Documents/BSF_FILTER_MATRIX/DEEP_SOURCE/L1/L2/L3/upload-target/',
+    'Documents/BSF_FILTER_MATRIX/MINIMAL/',
+    'Documents/BSF_FILTER_MATRIX/MINIMAL/single.txt',
+    'Documents/BSF_FILTER_MATRIX/RENAME_ME/',
+    'Documents/BSF_FILTER_MATRIX/RENAME_ME/original.txt',
+    'Documents/BSF_FILTER_MATRIX/RENAME_ME/upload-target/',
+    'Documents/BSF_FILTER_MATRIX/TREE/',
+    'Documents/BSF_FILTER_MATRIX/TREE/A/',
+    'Documents/BSF_FILTER_MATRIX/TREE/A/B/',
+    'Documents/BSF_FILTER_MATRIX/TREE/A/B/C/',
+    'Documents/BSF_FILTER_MATRIX/TREE/A/B/C/tree.txt',
+    'Documents/BSF_FILTER_MATRIX/WIDE_SET/',
+    *[f'Documents/BSF_FILTER_MATRIX/WIDE_SET/file{i:02d}.txt' for i in range(50)],
+    'Documents/BSF_MIXED_FILES/',
+    'Documents/BSF_MIXED_FILES/DATASET_A/',
+    'Documents/BSF_MIXED_FILES/DATASET_A/Document2.docx',
+    'Documents/BSF_MIXED_FILES/DATASET_A/Presentation1.pptx',
+    'Documents/BSF_MIXED_FILES/DATASET_A/Presentation2.pptx',
+    'Documents/BSF_MIXED_FILES/DATASET_A/Presentation3.pptx',
+    'Documents/BSF_MIXED_FILES/DATASET_A/Presentation4.pptx',
+    'Documents/BSF_MIXED_FILES/DATASET_A/Presentation5.pptx',
+    'Documents/BSF_MIXED_FILES/DATASET_B/',
+    'Documents/BSF_MIXED_FILES/DATASET_B/L1/',
+    'Documents/BSF_MIXED_FILES/DATASET_B/L1/L2/',
+    'Documents/BSF_MIXED_FILES/DATASET_B/L1/L2/L3/',
+    'Documents/BSF_MIXED_FILES/DATASET_B/L1/L2/L3/deepfile.txt',
+    'Documents/BSF_MIXED_FILES/DATASET_B/L1/L2/L3/upload-target/',
+]
+
+REQUIRED_STDOUT_MARKERS = [
+    'Account Type:          business',
+    # Only folders that the client identifies as shortcut-backed Business Shared
+    # Folders are required to emit this marker. BSF_FILTER_MATRIX is validated
+    # via manifest presence below, but the current online fixture is enumerated
+    # as normal default-drive content rather than reported as a Business Shared
+    # Folder marker in stdout.
+    'Syncing this OneDrive Business Shared Folder: Documents/BSF_CORE',
+    'Syncing this OneDrive Business Shared Folder: Documents/BSF_MIXED_FILES',
+    'Sync with Microsoft OneDrive is complete',
+]
+
+
+def case_sync_root(case_id: str) -> Path:
+    home = os.environ.get("HOME", "").strip()
+    if not home:
+        raise RuntimeError("HOME is not set")
+    return Path(home) / case_id
+
+
+def reset_local_sync_root(sync_root: Path) -> None:
+    if sync_root.exists():
+        shutil.rmtree(sync_root)
+    ensure_directory(sync_root)
+
+
+def write_case_config(context: E2EContext, config_dir: Path, case_id: str) -> Path:
+    """Create a per-test config directory using a per-test sync_dir under HOME."""
+    sync_dir_config_value = f"~/{case_id}/"
+    return context.prepare_minimal_config_dir(
+        config_dir,
+        f"# {case_id} Business Shared Folder config\n"
+        f'sync_dir = "{sync_dir_config_value}"\n'
+        'sync_business_shared_items = "true"\n'
+        'threads = "2"\n'
+    )
+
+
+def wait_for_stdout_marker(stdout_file: Path, marker: str, timeout_seconds: int = 600, poll_interval: float = 0.5) -> bool:
+    deadline = time.time() + timeout_seconds
+    while time.time() < deadline:
+        if stdout_file.exists():
+            try:
+                if marker in stdout_file.read_text(encoding="utf-8", errors="replace"):
+                    return True
+            except OSError:
+                pass
+        time.sleep(poll_interval)
+    return False
+
+
+def validate_required_manifest(
+    *,
+    sync_root: Path,
+    stdout_text: str,
+    manifest_file: Path,
+    expected_manifest_file: Path,
+    missing_manifest_file: Path,
+) -> dict[str, object]:
+    actual_manifest = build_typed_manifest(sync_root)
+    expected_manifest = sorted(REQUIRED_TYPED_MANIFEST_ENTRIES)
+    write_manifest(manifest_file, actual_manifest)
+    write_manifest(expected_manifest_file, expected_manifest)
+
+    actual_set = set(actual_manifest)
+    expected_set = set(expected_manifest)
+    missing_entries = sorted(expected_set - actual_set)
+    write_manifest(missing_manifest_file, missing_entries)
+
+    missing_stdout_markers = [
+        marker for marker in REQUIRED_STDOUT_MARKERS if marker not in stdout_text
+    ]
+
+    return {
+        "expected_required_entries": len(expected_manifest),
+        "actual_entries": len(actual_manifest),
+        "missing_entries": missing_entries,
+        "missing_stdout_markers": missing_stdout_markers,
+    }
+
+
+def write_common_metadata(
+    metadata_file: Path,
+    *,
+    case_id: str,
+    name: str,
+    command: list[str],
+    returncode: int | None,
+    sync_root: Path,
+    config_dir: Path,
+    validation: dict[str, object],
+    extra_lines: list[str] | None = None,
+) -> None:
+    lines = [
+        f"case_id={case_id}",
+        f"name={name}",
+        f"command={command_to_string(command)}",
+        f"returncode={returncode}",
+        f"sync_root={sync_root}",
+        f"config_dir={config_dir}",
+        f"expected_required_entries={validation['expected_required_entries']}",
+        f"actual_entries={validation['actual_entries']}",
+        f"missing_entries={len(validation['missing_entries'])}",
+        f"missing_stdout_markers={validation['missing_stdout_markers']!r}",
+    ]
+    if extra_lines:
+        lines.extend(extra_lines)
+    write_text_file(metadata_file, "\n".join(lines) + "\n")
+
+
+def manifest_failure_reason(validation: dict[str, object]) -> str:
+    if validation["missing_stdout_markers"]:
+        return "Expected Business Shared Folder sync markers were not present in stdout"
+    if validation["missing_entries"]:
+        return "Expected Business shared-folder local paths were missing after sync"
+    return ""
+
+
+def stop_monitor_process(process: subprocess.Popen, timeout_seconds: int = 30) -> int | None:
+    if process.poll() is None:
+        process.send_signal(signal.SIGINT)
+        try:
+            process.wait(timeout=timeout_seconds)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait(timeout=timeout_seconds)
+    return process.returncode
diff --git a/ci/e2e/testcases_personal_shared_folders/__init__.py b/ci/e2e/testcases_personal_shared_folders/__init__.py
new file mode 100644
index 000000000..a12e3b9cb
--- /dev/null
+++ b/ci/e2e/testcases_personal_shared_folders/__init__.py
@@ -0,0 +1 @@
+"""Personal Account Shared Folder E2E test cases."""
diff --git a/ci/e2e/testcases_personal_shared_folders/sfptc0001_clean_sync_pull_down.py b/ci/e2e/testcases_personal_shared_folders/sfptc0001_clean_sync_pull_down.py
new file mode 100644
index 000000000..543345449
--- /dev/null
+++ b/ci/e2e/testcases_personal_shared_folders/sfptc0001_clean_sync_pull_down.py
@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.result import TestResult
+from framework.utils import command_to_string, run_command, write_text_file
+from testcases_personal_shared_folders.shared_folder_common import (
+    case_sync_root,
+    manifest_failure_reason,
+    reset_local_sync_root,
+    validate_expected_manifest,
+    write_case_config,
+    write_common_metadata,
+)
+
+
+class SharedFolderPersonalTestCase0001CleanSyncPullDown(E2ETestCase):
+    case_id = "sfptc0001"
+    name = "personal shared folders clean sync pull down"
+    description = "Validate that --sync --verbose pulls down the preserved Personal Account shared-folder topology without ghost folders"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name=self.case_id,
+            ensure_refresh_token=True,
+        )
+
+        sync_root = case_sync_root(self.case_id)
+        confdir = layout.work_dir / "conf"
+        reset_local_sync_root(sync_root)
+        write_case_config(context, confdir, self.case_id)
+
+        stdout_file = layout.log_dir / "stdout.log"
+        stderr_file = layout.log_dir / "stderr.log"
+        manifest_file = layout.state_dir / "local_typed_manifest.txt"
+        expected_manifest_file = layout.state_dir / "expected_typed_manifest.txt"
+        missing_manifest_file = layout.state_dir / "missing_expected_entries.txt"
+        unexpected_manifest_file = layout.state_dir / "unexpected_extra_entries.txt"
+        metadata_file = layout.state_dir / "metadata.txt"
+
+        command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(confdir),
+        ]
+
+        context.log(f"Executing Test Case {self.case_id}: {command_to_string(command)}")
+        result = run_command(command, cwd=context.repo_root)
+
+        write_text_file(stdout_file, result.stdout)
+        write_text_file(stderr_file, result.stderr)
+
+        validation = validate_expected_manifest(
+            sync_root=sync_root,
+            stdout_text=result.stdout,
+            manifest_file=manifest_file,
+            expected_manifest_file=expected_manifest_file,
+            missing_manifest_file=missing_manifest_file,
+            unexpected_manifest_file=unexpected_manifest_file,
+        )
+
+        write_common_metadata(
+            metadata_file,
+            case_id=self.case_id,
+            name=self.name,
+            command=command,
+            returncode=result.returncode,
+            sync_root=sync_root,
+            config_dir=confdir,
+            validation=validation,
+        )
+
+        artifacts = [
+            str(stdout_file),
+            str(stderr_file),
+            str(manifest_file),
+            str(expected_manifest_file),
+            str(missing_manifest_file),
+            str(unexpected_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "command": command,
+            "returncode": result.returncode,
+            "sync_root": str(sync_root),
+            "config_dir": str(confdir),
+            **validation,
+        }
+
+        if result.returncode != 0:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"onedrive exited with non-zero status {result.returncode}",
+                artifacts,
+                details,
+            )
+
+        reason = manifest_failure_reason(validation)
+        if reason:
+            return self.fail_result(self.case_id, self.name, reason, artifacts, details)
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases_personal_shared_folders/sfptc0002_clean_monitor_pull_down.py b/ci/e2e/testcases_personal_shared_folders/sfptc0002_clean_monitor_pull_down.py
new file mode 100644
index 000000000..be4530b1c
--- /dev/null
+++ b/ci/e2e/testcases_personal_shared_folders/sfptc0002_clean_monitor_pull_down.py
@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import subprocess
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.result import TestResult
+from framework.utils import command_to_string, write_text_file
+from testcases_personal_shared_folders.shared_folder_common import (
+    case_sync_root,
+    manifest_failure_reason,
+    reset_local_sync_root,
+    stop_monitor_process,
+    validate_expected_manifest,
+    wait_for_stdout_marker,
+    write_case_config,
+    write_common_metadata,
+)
+
+
+class SharedFolderPersonalTestCase0002CleanMonitorPullDown(E2ETestCase):
+    case_id = "sfptc0002"
+    name = "personal shared folders clean monitor pull down"
+    description = "Validate that --monitor --verbose pulls down the preserved Personal Account shared-folder topology without ghost folders"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name=self.case_id,
+            ensure_refresh_token=True,
+        )
+
+        sync_root = case_sync_root(self.case_id)
+        confdir = layout.work_dir / "conf"
+        reset_local_sync_root(sync_root)
+        write_case_config(context, confdir, self.case_id)
+
+        stdout_file = layout.log_dir / "stdout.log"
+        stderr_file = layout.log_dir / "stderr.log"
+        manifest_file = layout.state_dir / "local_typed_manifest.txt"
+        expected_manifest_file = layout.state_dir / "expected_typed_manifest.txt"
+        missing_manifest_file = layout.state_dir / "missing_expected_entries.txt"
+        unexpected_manifest_file = layout.state_dir / "unexpected_extra_entries.txt"
+        metadata_file = layout.state_dir / "metadata.txt"
+
+        command = [
+            context.onedrive_bin,
+            "--monitor",
+            "--verbose",
+            "--resync",
+            "--resync-auth",
+            "--confdir",
+            str(confdir),
+        ]
+
+        context.log(f"Executing Test Case {self.case_id}: {command_to_string(command)}")
+
+        with stdout_file.open("w", encoding="utf-8") as stdout_fp, stderr_file.open("w", encoding="utf-8") as stderr_fp:
+            process = subprocess.Popen(
+                command,
+                cwd=str(context.repo_root),
+                stdout=stdout_fp,
+                stderr=stderr_fp,
+                text=True,
+            )
+            initial_sync_complete = wait_for_stdout_marker(stdout_file, "Sync with Microsoft OneDrive is complete", timeout_seconds=1200)
+            monitor_returncode = stop_monitor_process(process)
+
+        stdout_text = stdout_file.read_text(encoding="utf-8", errors="replace") if stdout_file.exists() else ""
+        validation = validate_expected_manifest(
+            sync_root=sync_root,
+            stdout_text=stdout_text,
+            manifest_file=manifest_file,
+            expected_manifest_file=expected_manifest_file,
+            missing_manifest_file=missing_manifest_file,
+            unexpected_manifest_file=unexpected_manifest_file,
+        )
+
+        write_common_metadata(
+            metadata_file,
+            case_id=self.case_id,
+            name=self.name,
+            command=command,
+            returncode=monitor_returncode,
+            sync_root=sync_root,
+            config_dir=confdir,
+            validation=validation,
+            extra_lines=[f"initial_sync_complete={initial_sync_complete}"],
+        )
+
+        artifacts = [
+            str(stdout_file),
+            str(stderr_file),
+            str(manifest_file),
+            str(expected_manifest_file),
+            str(missing_manifest_file),
+            str(unexpected_manifest_file),
+            str(metadata_file),
+        ]
+        details = {
+            "command": command,
+            "monitor_returncode": monitor_returncode,
+            "initial_sync_complete": initial_sync_complete,
+            "sync_root": str(sync_root),
+            "config_dir": str(confdir),
+            **validation,
+        }
+
+        if not initial_sync_complete:
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                "Monitor mode did not complete the initial shared-folder sync within the expected time",
+                artifacts,
+                details,
+            )
+
+        if monitor_returncode not in (0, 130, -2):
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"monitor mode exited with unexpected status {monitor_returncode}",
+                artifacts,
+                details,
+            )
+
+        reason = manifest_failure_reason(validation)
+        if reason:
+            return self.fail_result(self.case_id, self.name, reason, artifacts, details)
+
+        return self.pass_result(self.case_id, self.name, artifacts, details)
diff --git a/ci/e2e/testcases_personal_shared_folders/sfptc0003_sync_list_validation.py b/ci/e2e/testcases_personal_shared_folders/sfptc0003_sync_list_validation.py
new file mode 100644
index 000000000..9fb6ffa27
--- /dev/null
+++ b/ci/e2e/testcases_personal_shared_folders/sfptc0003_sync_list_validation.py
@@ -0,0 +1,1046 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from framework.base import E2ETestCase
+from framework.context import E2EContext
+from framework.manifest import build_typed_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, reset_directory, run_command, write_text_file
+from testcases_personal_shared_folders.shared_folder_common import (
+    EXPECTED_TYPED_MANIFEST,
+    case_sync_root,
+    reset_local_sync_root,
+)
+
+
+CONFIG_FILE_NAME = "config"
+SYNC_LIST_FILE_NAME = "sync_list"
+
+
+@dataclass
+class SharedFolderMutationCheck:
+    parent_relative_path: str
+    directory_name: str
+    file_name: str
+    content: str
+
+
+@dataclass
+class SharedFolderSyncListScenario:
+    scenario_id: str
+    description: str
+    sync_list: list[str]
+    expected_entries: list[str]
+    required_present: list[str] = field(default_factory=list)
+    required_absent: list[str] = field(default_factory=list)
+    required_stdout_markers: list[str] = field(default_factory=list)
+    mutation_checks: list[SharedFolderMutationCheck] = field(default_factory=list)
+    cleanup_local_stale_files: list[str] = field(default_factory=list)
+
+
+class SharedFolderPersonalTestCase0003SyncListValidation(E2ETestCase):
+    case_id = "sfptc0003"
+    name = "personal shared folders sync_list validation"
+    description = "Validate sync_list include/exclude behaviour across preserved Personal Account shared-folder topology without ghost folders"
+
+    def run(self, context: E2EContext) -> TestResult:
+        layout = self.prepare_case_layout(
+            context,
+            case_dir_name=self.case_id,
+            ensure_refresh_token=True,
+        )
+
+        sync_root = case_sync_root(self.case_id)
+        reset_local_sync_root(sync_root)
+
+        scenarios = [
+            scenario for scenario in self._build_scenarios()
+            if context.should_run_scenario(self.case_id, scenario.scenario_id)
+        ]
+
+        failures: list[str] = []
+        all_artifacts: list[str] = []
+
+        for scenario in scenarios:
+            context.log(
+                f"Running Test Case {self.case_id} scenario {scenario.scenario_id}: "
+                f"{scenario.description}"
+            )
+
+            scenario_sync_root = sync_root / scenario.scenario_id
+            scenario_dir = layout.state_dir / scenario.scenario_id
+            scenario_log_dir = layout.log_dir / scenario.scenario_id
+            confdir = layout.work_dir / f"conf-{scenario.scenario_id}"
+
+            reset_local_sync_root(scenario_sync_root)
+            reset_directory(scenario_dir)
+            reset_directory(scenario_log_dir)
+            reset_directory(confdir)
+
+            config_path = self._write_scenario_config(
+                context,
+                confdir,
+                scenario_sync_root,
+                cleanup_local_files=bool(scenario.cleanup_local_stale_files),
+            )
+            sync_list_path = confdir / SYNC_LIST_FILE_NAME
+            self._write_sync_list(sync_list_path, scenario.sync_list)
+
+            stdout_file = scenario_log_dir / "stdout.log"
+            stderr_file = scenario_log_dir / "stderr.log"
+            actual_manifest_file = scenario_dir / "actual_typed_manifest.txt"
+            expected_manifest_file = scenario_dir / "expected_typed_manifest.txt"
+            missing_manifest_file = scenario_dir / "missing_expected_entries.txt"
+            unexpected_manifest_file = scenario_dir / "unexpected_extra_entries.txt"
+            required_present_file = scenario_dir / "missing_required_present_entries.txt"
+            required_absent_file = scenario_dir / "unexpected_required_absent_entries.txt"
+            metadata_file = scenario_dir / "metadata.txt"
+            diff_file = scenario_dir / "diff.txt"
+
+            command = [
+                context.onedrive_bin,
+                "--sync",
+                "--verbose",
+                "--download-only",
+                "--resync",
+                "--resync-auth",
+                "--confdir",
+                str(confdir),
+            ]
+
+            context.log(f"Executing {self.case_id} {scenario.scenario_id}: {command_to_string(command)}")
+            result = run_command(command, cwd=context.repo_root)
+
+            write_text_file(stdout_file, result.stdout)
+            write_text_file(stderr_file, result.stderr)
+
+            actual_manifest = build_typed_manifest(scenario_sync_root)
+            expected_manifest = sorted(set(scenario.expected_entries))
+            write_manifest(actual_manifest_file, actual_manifest)
+            write_manifest(expected_manifest_file, expected_manifest)
+
+            actual_set = set(actual_manifest)
+            expected_set = set(expected_manifest)
+            missing_entries = sorted(expected_set - actual_set)
+            unexpected_entries = sorted(actual_set - expected_set)
+            missing_required_present = sorted(
+                entry for entry in scenario.required_present if entry not in actual_set
+            )
+            unexpected_required_absent = sorted(
+                entry for entry in scenario.required_absent if entry in actual_set
+            )
+            missing_stdout_markers = [
+                marker for marker in scenario.required_stdout_markers if marker not in result.stdout
+            ]
+
+            write_manifest(missing_manifest_file, missing_entries)
+            write_manifest(unexpected_manifest_file, unexpected_entries)
+            write_manifest(required_present_file, missing_required_present)
+            write_manifest(required_absent_file, unexpected_required_absent)
+
+            mutation_failures: list[str] = []
+            mutation_artifacts: list[str] = []
+            cleanup_failures: list[str] = []
+            cleanup_artifacts: list[str] = []
+            if scenario.mutation_checks:
+                if result.returncode != 0 or missing_entries or unexpected_entries or missing_required_present or unexpected_required_absent:
+                    mutation_failures.append(
+                        "Skipping mutation validation because initial immutable baseline validation failed"
+                    )
+                else:
+                    mutation_failures.extend(
+                        self._run_mutation_checks(
+                            context=context,
+                            confdir=confdir,
+                            sync_root=scenario_sync_root,
+                            scenario_log_dir=scenario_log_dir,
+                            scenario=scenario,
+                            artifacts=mutation_artifacts,
+                        )
+                    )
+
+            if scenario.cleanup_local_stale_files:
+                if result.returncode != 0 or missing_entries or unexpected_entries or missing_required_present or unexpected_required_absent:
+                    cleanup_failures.append(
+                        "Skipping cleanup_local_files validation because initial immutable baseline validation failed"
+                    )
+                else:
+                    cleanup_failures.extend(
+                        self._run_local_stale_cleanup_check(
+                            context=context,
+                            confdir=confdir,
+                            config_path=config_path,
+                            sync_root=scenario_sync_root,
+                            scenario_log_dir=scenario_log_dir,
+                            scenario=scenario,
+                            artifacts=cleanup_artifacts,
+                        )
+                    )
+
+            diffs: list[str] = []
+            if result.returncode != 0:
+                diffs.append(f"onedrive exited with non-zero status {result.returncode}")
+            if missing_stdout_markers:
+                diffs.append(
+                    "Expected shared-folder stdout markers were not present: "
+                    + ", ".join(missing_stdout_markers)
+                )
+            if missing_entries:
+                diffs.append(f"Missing expected local entries: {missing_entries[:20]!r}")
+            if unexpected_entries:
+                diffs.append(
+                    "Unexpected local entries were created; possible ghost folder or sync_list leak: "
+                    + repr(unexpected_entries[:20])
+                )
+            if missing_required_present:
+                diffs.append(f"Required included entries were missing: {missing_required_present!r}")
+            if unexpected_required_absent:
+                diffs.append(f"Required excluded entries were present locally: {unexpected_required_absent!r}")
+            if mutation_failures:
+                diffs.append("Mutation validation failed: " + "; ".join(mutation_failures))
+            if cleanup_failures:
+                diffs.append("cleanup_local_files validation failed: " + "; ".join(cleanup_failures))
+
+            metadata_lines = [
+                f"case_id={self.case_id}",
+                f"scenario_id={scenario.scenario_id}",
+                f"description={scenario.description}",
+                f"command={command_to_string(command)}",
+                f"returncode={result.returncode}",
+                f"sync_root={scenario_sync_root}",
+                f"config_dir={confdir}",
+                f"config_path={config_path}",
+                f"sync_list_path={sync_list_path}",
+                f"expected_entries={len(expected_manifest)}",
+                f"actual_entries={len(actual_manifest)}",
+                f"missing_entries={len(missing_entries)}",
+                f"unexpected_entries={len(unexpected_entries)}",
+                f"missing_required_present={missing_required_present!r}",
+                f"unexpected_required_absent={unexpected_required_absent!r}",
+                f"missing_stdout_markers={missing_stdout_markers!r}",
+                f"mutation_checks={len(scenario.mutation_checks)}",
+                f"mutation_failures={mutation_failures!r}",
+                f"cleanup_local_stale_files={scenario.cleanup_local_stale_files!r}",
+                f"cleanup_failures={cleanup_failures!r}",
+            ]
+            write_text_file(metadata_file, "\n".join(metadata_lines) + "\n")
+
+            scenario_artifacts = [
+                str(config_path),
+                str(sync_list_path),
+                str(stdout_file),
+                str(stderr_file),
+                str(actual_manifest_file),
+                str(expected_manifest_file),
+                str(missing_manifest_file),
+                str(unexpected_manifest_file),
+                str(required_present_file),
+                str(required_absent_file),
+                str(metadata_file),
+            ]
+            scenario_artifacts.extend(mutation_artifacts)
+            scenario_artifacts.extend(cleanup_artifacts)
+            all_artifacts.extend(scenario_artifacts)
+
+            if diffs:
+                write_text_file(diff_file, "\n".join(diffs) + "\n")
+                all_artifacts.append(str(diff_file))
+                failure_message = f"{scenario.scenario_id}: " + "; ".join(diffs)
+                failures.append(failure_message)
+                context.log(f"Scenario {scenario.scenario_id} FAILED: {failure_message}")
+            else:
+                context.log(f"Scenario {scenario.scenario_id} PASSED")
+
+        details = {
+            "scenario_count": len(scenarios),
+            "executed_scenario_ids": [scenario.scenario_id for scenario in scenarios],
+            "failed_scenarios": len(failures),
+            "failed_scenario_ids": [failure.split(":", 1)[0] for failure in failures],
+        }
+
+        if failures:
+            details["failures"] = failures
+            return self.fail_result(
+                self.case_id,
+                self.name,
+                f"{len(failures)} of {len(scenarios)} shared-folder sync_list scenarios failed: "
+                + ", ".join(failure.split(":", 1)[0] for failure in failures),
+                all_artifacts,
+                details,
+            )
+
+        return self.pass_result(self.case_id, self.name, all_artifacts, details)
+
+    def _run_mutation_checks(
+        self,
+        context: E2EContext,
+        confdir: Path,
+        sync_root: Path,
+        scenario_log_dir: Path,
+        scenario: SharedFolderSyncListScenario,
+        artifacts: list[str],
+    ) -> list[str]:
+        failures: list[str] = []
+
+        for index, mutation_check in enumerate(scenario.mutation_checks, start=1):
+            parent_relative_path = mutation_check.parent_relative_path.strip("/")
+            local_parent_path = sync_root / parent_relative_path
+            local_test_dir = local_parent_path / mutation_check.directory_name
+            local_test_file = local_test_dir / mutation_check.file_name
+
+            upload_stdout_file = scenario_log_dir / f"mutation-upload-{index:02d}-stdout.log"
+            upload_stderr_file = scenario_log_dir / f"mutation-upload-{index:02d}-stderr.log"
+            cleanup_stdout_file = scenario_log_dir / f"mutation-cleanup-{index:02d}-stdout.log"
+            cleanup_stderr_file = scenario_log_dir / f"mutation-cleanup-{index:02d}-stderr.log"
+            verify_stdout_file = scenario_log_dir / f"mutation-cleanup-verify-{index:02d}-stdout.log"
+            verify_stderr_file = scenario_log_dir / f"mutation-cleanup-verify-{index:02d}-stderr.log"
+            baseline_manifest_file = scenario_log_dir / f"mutation-baseline-{index:02d}-manifest.txt"
+            verify_manifest_file = scenario_log_dir / f"mutation-verify-{index:02d}-manifest.txt"
+            mutation_diff_file = scenario_log_dir / f"mutation-diff-{index:02d}.txt"
+
+            artifacts.extend([
+                str(upload_stdout_file),
+                str(upload_stderr_file),
+                str(cleanup_stdout_file),
+                str(cleanup_stderr_file),
+                str(verify_stdout_file),
+                str(verify_stderr_file),
+                str(baseline_manifest_file),
+                str(verify_manifest_file),
+                str(mutation_diff_file),
+            ])
+
+            if "/" in mutation_check.directory_name or mutation_check.directory_name in {"", ".", ".."}:
+                failures.append(
+                    f"{parent_relative_path}: refusing mutation because tracked directory "
+                    f"name is unsafe: {mutation_check.directory_name!r}"
+                )
+                continue
+
+            if "/" in mutation_check.file_name or mutation_check.file_name in {"", ".", ".."}:
+                failures.append(
+                    f"{parent_relative_path}: refusing mutation because tracked file "
+                    f"name is unsafe: {mutation_check.file_name!r}"
+                )
+                continue
+
+            if not mutation_check.directory_name.startswith("sfptc0003-"):
+                failures.append(
+                    f"{parent_relative_path}: refusing mutation because tracked directory "
+                    "does not use the sfptc0003- safety prefix"
+                )
+                continue
+
+            if not mutation_check.file_name.startswith("sfptc0003-"):
+                failures.append(
+                    f"{parent_relative_path}: refusing mutation because tracked file "
+                    "does not use the sfptc0003- safety prefix"
+                )
+                continue
+
+            if not local_parent_path.is_dir():
+                failures.append(
+                    f"{parent_relative_path}: refusing mutation because parent directory "
+                    f"does not already exist locally: {local_parent_path}"
+                )
+                continue
+
+            if local_test_dir.exists():
+                failures.append(
+                    f"{parent_relative_path}: refusing mutation because tracked test "
+                    f"directory already exists: {local_test_dir}"
+                )
+                continue
+
+            if local_test_file.exists():
+                failures.append(
+                    f"{parent_relative_path}: refusing mutation because tracked test "
+                    f"file already exists: {local_test_file}"
+                )
+                continue
+
+            immutable_before_manifest = build_typed_manifest(sync_root)
+            write_manifest(baseline_manifest_file, immutable_before_manifest)
+
+            # Safety rule for shared-folder mutation testing:
+            # - parent path must already exist from the initial download-only sync
+            # - never create shared-folder parent paths
+            # - create only one exact tracked child directory below that parent
+            # - delete only the exact tracked file and directory created here
+            local_test_dir.mkdir()
+            write_text_file(local_test_file, mutation_check.content)
+
+            upload_command = [
+                context.onedrive_bin,
+                "--sync",
+                "--verbose",
+                "--confdir",
+                str(confdir),
+            ]
+            context.log(
+                f"Executing {self.case_id} {scenario.scenario_id} mutation upload "
+                f"for {local_test_file.relative_to(sync_root)}: {command_to_string(upload_command)}"
+            )
+            upload_result = run_command(upload_command, cwd=context.repo_root)
+            write_text_file(upload_stdout_file, upload_result.stdout)
+            write_text_file(upload_stderr_file, upload_result.stderr)
+
+            if upload_result.returncode != 0:
+                failures.append(
+                    f"{local_test_file.relative_to(sync_root)}: upload sync exited with "
+                    f"non-zero status {upload_result.returncode}"
+                )
+
+            if not local_test_file.exists():
+                failures.append(
+                    f"{local_test_file.relative_to(sync_root)}: tracked test file "
+                    "disappeared unexpectedly after upload sync"
+                )
+
+            if local_test_file.exists():
+                local_test_file.unlink()
+
+            if local_test_dir.exists():
+                try:
+                    local_test_dir.rmdir()
+                except OSError as exc:
+                    failures.append(
+                        f"{local_test_dir.relative_to(sync_root)}: unable to remove exact "
+                        f"tracked test directory after deleting tracked test file: {exc}"
+                    )
+
+            cleanup_command = [
+                context.onedrive_bin,
+                "--sync",
+                "--verbose",
+                "--confdir",
+                str(confdir),
+            ]
+            context.log(
+                f"Executing {self.case_id} {scenario.scenario_id} mutation cleanup "
+                f"for {parent_relative_path}/{mutation_check.directory_name}: "
+                f"{command_to_string(cleanup_command)}"
+            )
+            cleanup_result = run_command(cleanup_command, cwd=context.repo_root)
+            write_text_file(cleanup_stdout_file, cleanup_result.stdout)
+            write_text_file(cleanup_stderr_file, cleanup_result.stderr)
+
+            if cleanup_result.returncode != 0:
+                failures.append(
+                    f"{parent_relative_path}/{mutation_check.directory_name}: cleanup "
+                    f"sync exited with non-zero status {cleanup_result.returncode}"
+                )
+
+            verify_command = [
+                context.onedrive_bin,
+                "--sync",
+                "--verbose",
+                "--download-only",
+                "--resync",
+                "--resync-auth",
+                "--confdir",
+                str(confdir),
+            ]
+            context.log(
+                f"Executing {self.case_id} {scenario.scenario_id} mutation cleanup "
+                f"verification for {parent_relative_path}/{mutation_check.directory_name}: "
+                f"{command_to_string(verify_command)}"
+            )
+            verify_result = run_command(verify_command, cwd=context.repo_root)
+            write_text_file(verify_stdout_file, verify_result.stdout)
+            write_text_file(verify_stderr_file, verify_result.stderr)
+
+            if verify_result.returncode != 0:
+                failures.append(
+                    f"{parent_relative_path}/{mutation_check.directory_name}: cleanup "
+                    f"verification sync exited with non-zero status {verify_result.returncode}"
+                )
+
+            immutable_after_manifest = build_typed_manifest(sync_root)
+            write_manifest(verify_manifest_file, immutable_after_manifest)
+
+            before_set = set(immutable_before_manifest)
+            after_set = set(immutable_after_manifest)
+            missing_after = sorted(before_set - after_set)
+            unexpected_after = sorted(after_set - before_set)
+
+            mutation_diff_lines: list[str] = []
+            if missing_after:
+                mutation_diff_lines.append(
+                    "Immutable baseline entries disappeared after tracked mutation cleanup: "
+                    + repr(missing_after[:50])
+                )
+            if unexpected_after:
+                mutation_diff_lines.append(
+                    "Unexpected entries remain after tracked mutation cleanup: "
+                    + repr(unexpected_after[:50])
+                )
+            write_text_file(mutation_diff_file, "\n".join(mutation_diff_lines) + ("\n" if mutation_diff_lines else ""))
+
+            if missing_after:
+                failures.append(
+                    f"{parent_relative_path}/{mutation_check.directory_name}: immutable "
+                    f"baseline changed; missing entries after cleanup: {missing_after[:20]!r}"
+                )
+            if unexpected_after:
+                failures.append(
+                    f"{parent_relative_path}/{mutation_check.directory_name}: immutable "
+                    f"baseline changed; unexpected entries after cleanup: {unexpected_after[:20]!r}"
+                )
+
+            if local_test_file.exists():
+                failures.append(
+                    f"{local_test_file.relative_to(sync_root)}: tracked test file still "
+                    "exists after cleanup verification; remote cleanup may have failed"
+                )
+                local_test_file.unlink()
+
+            if local_test_dir.exists():
+                failures.append(
+                    f"{local_test_dir.relative_to(sync_root)}: tracked test directory still "
+                    "exists after cleanup verification; remote cleanup may have failed"
+                )
+                try:
+                    local_test_dir.rmdir()
+                except OSError:
+                    pass
+
+        return failures
+
+    def _run_local_stale_cleanup_check(
+        self,
+        context: E2EContext,
+        confdir: Path,
+        config_path: Path,
+        sync_root: Path,
+        scenario_log_dir: Path,
+        scenario: SharedFolderSyncListScenario,
+        artifacts: list[str],
+    ) -> list[str]:
+        failures: list[str] = []
+        before_manifest = build_typed_manifest(sync_root)
+
+        cleanup_stdout_file = scenario_log_dir / "cleanup-local-files-stdout.log"
+        cleanup_stderr_file = scenario_log_dir / "cleanup-local-files-stderr.log"
+        cleanup_before_manifest_file = scenario_log_dir / "cleanup-local-files-before-manifest.txt"
+        cleanup_after_manifest_file = scenario_log_dir / "cleanup-local-files-after-manifest.txt"
+        artifacts.extend([
+            str(cleanup_stdout_file),
+            str(cleanup_stderr_file),
+            str(cleanup_before_manifest_file),
+            str(cleanup_after_manifest_file),
+        ])
+
+        write_manifest(cleanup_before_manifest_file, before_manifest)
+
+        created_files: list[Path] = []
+        for rel_file in scenario.cleanup_local_stale_files:
+            rel_file = rel_file.strip("/")
+            if not rel_file or rel_file.endswith("/") or "/../" in f"/{rel_file}/":
+                failures.append(f"Refusing unsafe cleanup-local stale file path: {rel_file!r}")
+                continue
+
+            local_file = sync_root / rel_file
+            if not local_file.parent.is_dir():
+                failures.append(
+                    f"Refusing cleanup-local stale file because immutable parent is missing: {rel_file}"
+                )
+                continue
+            if local_file.exists():
+                failures.append(
+                    f"Refusing cleanup-local stale file because path already exists: {rel_file}"
+                )
+                continue
+            if not local_file.name.startswith("sfptc0003-"):
+                failures.append(
+                    f"Refusing cleanup-local stale file without sfptc0003- prefix: {rel_file}"
+                )
+                continue
+
+            write_text_file(local_file, f"local stale cleanup validation for {scenario.scenario_id}\n")
+            created_files.append(local_file)
+
+        if failures:
+            for local_file in created_files:
+                if local_file.exists():
+                    local_file.unlink()
+            return failures
+
+        cleanup_command = [
+            context.onedrive_bin,
+            "--sync",
+            "--verbose",
+            "--download-only",
+            "--confdir",
+            str(confdir),
+        ]
+        context.log(
+            f"Executing {self.case_id} {scenario.scenario_id} cleanup_local_files "
+            f"validation: {command_to_string(cleanup_command)}"
+        )
+        cleanup_result = run_command(cleanup_command, cwd=context.repo_root)
+        write_text_file(cleanup_stdout_file, cleanup_result.stdout)
+        write_text_file(cleanup_stderr_file, cleanup_result.stderr)
+
+        if cleanup_result.returncode != 0:
+            failures.append(
+                f"cleanup_local_files validation sync exited with non-zero status {cleanup_result.returncode}"
+            )
+
+        for local_file in created_files:
+            if local_file.exists():
+                failures.append(
+                    f"Local stale file was not removed by cleanup_local_files: "
+                    f"{local_file.relative_to(sync_root)}"
+                )
+                local_file.unlink()
+
+        after_manifest = build_typed_manifest(sync_root)
+        write_manifest(cleanup_after_manifest_file, after_manifest)
+
+        before_without_stale = set(before_manifest)
+        after_set = set(after_manifest)
+        missing_after = sorted(before_without_stale - after_set)
+        unexpected_after = sorted(after_set - before_without_stale)
+        if missing_after:
+            failures.append(
+                f"Immutable baseline changed during cleanup_local_files; missing entries: {missing_after[:20]!r}"
+            )
+        if unexpected_after:
+            failures.append(
+                f"Unexpected entries after cleanup_local_files: {unexpected_after[:20]!r}"
+            )
+
+        return failures
+
+    def _write_scenario_config(
+        self,
+        context: E2EContext,
+        config_dir: Path,
+        sync_root: Path,
+        cleanup_local_files: bool = False,
+    ) -> Path:
+        cleanup_value = "true" if cleanup_local_files else "false"
+        config_path = context.prepare_minimal_config_dir(
+            config_dir,
+            "# sfptc0003 Personal Shared Folder sync_list config\n"
+            f'sync_dir = "{sync_root}"\n'
+            'threads = "2"\n'
+            'download_only = "true"\n'
+            f'cleanup_local_files = "{cleanup_value}"\n'
+            'bypass_data_preservation = "true"\n',
+        )
+        return config_path
+
+    def _write_sync_list(self, sync_list_path: Path, sync_list: list[str]) -> None:
+        write_text_file(sync_list_path, "\n".join(sync_list) + "\n")
+
+    def _parent_entries_for(self, path: str) -> list[str]:
+        parts = path.strip("/").split("/")
+        parents: list[str] = []
+        for index in range(1, len(parts)):
+            parents.append("/".join(parts[:index]) + "/")
+        return [entry for entry in parents if entry in EXPECTED_TYPED_MANIFEST]
+
+    def _entries_under(self, *prefixes: str) -> list[str]:
+        normalised_prefixes = [prefix.strip("/") for prefix in prefixes]
+        entries: list[str] = []
+        for prefix in normalised_prefixes:
+            entries.extend(self._parent_entries_for(prefix))
+        for entry in EXPECTED_TYPED_MANIFEST:
+            clean_entry = entry.rstrip("/")
+            for prefix in normalised_prefixes:
+                if clean_entry == prefix or clean_entry.startswith(prefix + "/"):
+                    entries.append(entry)
+                    break
+        return sorted(set(entries))
+
+    def _entries_exact(self, *entries: str) -> list[str]:
+        expected_set = set(EXPECTED_TYPED_MANIFEST)
+        selected: list[str] = []
+        for entry in entries:
+            clean_entry = entry.strip("/")
+            selected.extend(self._parent_entries_for(clean_entry))
+            if entry in expected_set:
+                selected.append(entry)
+            elif entry + "/" in expected_set:
+                selected.append(entry + "/")
+            elif clean_entry in expected_set:
+                selected.append(clean_entry)
+            elif clean_entry + "/" in expected_set:
+                selected.append(clean_entry + "/")
+            else:
+                selected.append(entry)
+        return sorted(set(selected))
+
+    def _exclude_entries(self, entries: list[str], *prefixes: str) -> list[str]:
+        normalised_prefixes = [prefix.strip("/") for prefix in prefixes]
+        filtered: list[str] = []
+        for entry in entries:
+            clean_entry = entry.rstrip("/")
+            excluded = any(
+                clean_entry == prefix or clean_entry.startswith(prefix + "/")
+                for prefix in normalised_prefixes
+            )
+            if not excluded:
+                filtered.append(entry)
+        return sorted(set(filtered))
+
+    def _marker(self, shared_folder_path: str) -> str:
+        return f"Syncing this OneDrive Personal Shared Folder: ./{shared_folder_path.strip('/')}"
+
+    def _build_scenarios(self) -> list[SharedFolderSyncListScenario]:
+        core = "SHARED_FOLDERS/SUB_FOLDER_1/CORE"
+        core15 = "SHARED_FOLDERS/SUB_FOLDER_1/CORE_15"
+        deep = "SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE"
+        deep15 = "SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE_15"
+        tree = "SHARED_FOLDERS/SUB_FOLDER_2/TREE"
+        wide = "SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET"
+        renamed = "SHARED_FOLDERS_RENAMED/RENAMED_SHARED_FOLDER"
+        minimal = "MINIMAL"
+        annas = "Family pictures/Annas pictures"
+        bens = "Family pictures/Bens pictures"
+
+        core_without_exclude = self._exclude_entries(
+            self._entries_under(core),
+            f"{core}/nested/exclude",
+        )
+        wide_subset = self._entries_exact(
+            "SHARED_FOLDERS/SUB_FOLDER_2/",
+            f"{wide}/",
+            f"{wide}/file00.txt",
+            f"{wide}/file01.txt",
+            f"{wide}/file02.txt",
+        )
+        multi_tree = sorted(set(
+            self._entries_under(minimal)
+            + self._entries_under(renamed)
+            + self._entries_exact(f"{deep}/L1/L2/L3/deepfile.txt")
+        ))
+        wide_set_and_15_roots = sorted(set(
+            self._entries_under(wide)
+            + self._entries_exact(f"{wide}_15/")
+        ))
+        deep_and_deep15_without_deep15_file = self._exclude_entries(
+            sorted(set(self._entries_under(deep) + self._entries_under(deep15))),
+            f"{deep15}/L1/L2/L3/deepfile.txt",
+        )
+
+        return [
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0001",
+                description="rooted include of one shared folder tree with trailing slash",
+                sync_list=[f"/{core}/"],
+                expected_entries=self._entries_under(core),
+                required_present=[f"{core}/README.txt"],
+                required_absent=[f"{core15}/README.txt", f"{deep}/L1/L2/L3/deepfile.txt"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0002",
+                description="rooted include of one shared folder tree without trailing slash",
+                sync_list=[f"/{core15}"],
+                expected_entries=self._entries_under(core15),
+                required_present=[f"{core15}/README.txt"],
+                required_absent=[f"{core}/README.txt", f"{deep}/L1/L2/L3/deepfile.txt"],
+                required_stdout_markers=[self._marker(core15)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0003",
+                description="rooted include of deep shared folder path",
+                sync_list=[f"/{deep}/"],
+                expected_entries=self._entries_under(deep),
+                required_present=[f"{deep}/L1/L2/L3/deepfile.txt"],
+                required_absent=[f"{core}/README.txt", f"{tree}/A/B/C/tree.txt"],
+                required_stdout_markers=[self._marker(deep)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0004",
+                description="include shared folder tree with nested exclusion",
+                sync_list=[
+                    f"!/{core}/nested/exclude/*",
+                    f"/{core}/",
+                ],
+                expected_entries=core_without_exclude,
+                required_present=[f"{core}/nested/keep/keep.txt"],
+                required_absent=[f"{core}/nested/exclude/exclude.txt"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0005",
+                description="file-specific include inside a shared folder",
+                sync_list=[f"/{core}/files/data.txt"],
+                expected_entries=self._entries_exact(
+                    "SHARED_FOLDERS/",
+                    "SHARED_FOLDERS/SUB_FOLDER_1/",
+                    f"{core}/",
+                    f"{core}/files/",
+                    f"{core}/files/data.txt",
+                ),
+                required_present=[f"{core}/files/data.txt"],
+                required_absent=[f"{core}/files/image0.png", f"{core}/README.txt"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0006",
+                description="multiple file-specific includes within one shared folder",
+                sync_list=[
+                    f"/{wide}/file00.txt",
+                    f"/{wide}/file01.txt",
+                    f"/{wide}/file02.txt",
+                ],
+                expected_entries=wide_subset,
+                required_present=[f"{wide}/file00.txt", f"{wide}/file02.txt"],
+                required_absent=[f"{wide}/file03.txt", f"{wide}/file49.txt"],
+                required_stdout_markers=[self._marker(wide)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0007",
+                description="include nested tree shared folder and exclude sibling shared folder trees",
+                sync_list=[f"/{tree}/"],
+                expected_entries=self._entries_under(tree),
+                required_present=[f"{tree}/A/B/C/tree.txt"],
+                required_absent=[f"{wide}/file00.txt", f"{core}/README.txt"],
+                required_stdout_markers=[self._marker(tree)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0008",
+                description="mixed includes across minimal renamed and deep shared folders",
+                sync_list=[
+                    f"/{minimal}/",
+                    f"/{renamed}/",
+                    f"/{deep}/L1/L2/L3/deepfile.txt",
+                ],
+                expected_entries=multi_tree,
+                required_present=[
+                    f"{minimal}/single.txt",
+                    f"{renamed}/original.txt",
+                    f"{deep}/L1/L2/L3/deepfile.txt",
+                ],
+                required_absent=[f"{core}/README.txt", f"{wide}/file00.txt"],
+                required_stdout_markers=[self._marker(minimal), self._marker(renamed), self._marker(deep)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0009",
+                description="include shared folder path containing spaces",
+                sync_list=[f"/{annas}/"],
+                expected_entries=self._entries_under(annas),
+                required_present=[f"{annas}/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image0.png"],
+                required_absent=["Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image0.png"],
+                required_stdout_markers=[self._marker(annas)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0010",
+                description="multiple explicit shared-folder shortcut includes only",
+                sync_list=[
+                    f"/{core}/",
+                    f"/{deep}/",
+                    f"/{tree}/",
+                ],
+                expected_entries=sorted(
+                    set(
+                        self._entries_under(core)
+                        + self._entries_under(deep)
+                        + self._entries_under(tree)
+                    )
+                ),
+                required_present=[f"{core}/README.txt", f"{deep}/L1/L2/L3/deepfile.txt", f"{tree}/A/B/C/tree.txt"],
+                required_absent=[f"{core15}/README.txt", f"{wide}/file00.txt"],
+                required_stdout_markers=[self._marker(core), self._marker(deep), self._marker(tree)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0011",
+                description="safe tracked mutation inside an existing shared-folder directory",
+                sync_list=[f"/{tree}/A/B/C/"],
+                expected_entries=self._entries_under(f"{tree}/A/B/C"),
+                required_present=[f"{tree}/A/B/C/tree.txt"],
+                required_absent=[f"{core}/README.txt", f"{wide}/file00.txt"],
+                required_stdout_markers=[self._marker(tree)],
+                mutation_checks=[
+                    SharedFolderMutationCheck(
+                        parent_relative_path=f"{tree}/A/B/C",
+                        directory_name="sfptc0003-tracked-mutation",
+                        file_name="sfptc0003-upload-tree.txt",
+                        content="sfptc0003 tracked mutation validation for TREE/A/B/C\n",
+                    ),
+                ],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0012",
+                description="issue 3643 explicit Family pictures shared-folder includes only",
+                sync_list=[
+                    f"/{annas}/",
+                    f"/{bens}/",
+                ],
+                expected_entries=sorted(
+                    set(
+                        self._entries_under(annas)
+                        + self._entries_under(bens)
+                    )
+                ),
+                required_present=[
+                    f"{annas}/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image0.png",
+                    f"{bens}/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image0.png",
+                ],
+                required_absent=[
+                    "Annas pictures/",
+                    "Bens pictures/",
+                    "Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image0.png",
+                    "Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image0.png",
+                ],
+                required_stdout_markers=[self._marker(annas), self._marker(bens)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0013",
+                description="wildcard shared-folder directory include across WIDE_SET shortcuts",
+                sync_list=["/SHARED_FOLDERS/SUB_FOLDER_2/WIDE_*/"],
+                expected_entries=sorted(set(self._entries_under(wide) + self._entries_under(f"{wide}_15"))),
+                required_present=[f"{wide}/file00.txt", f"{wide}_15/file00.txt"],
+                required_absent=[f"{tree}/A/B/C/tree.txt", f"{core}/README.txt"],
+                required_stdout_markers=[self._marker(wide), self._marker(f"{wide}_15")],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0014",
+                description="globbing include for a file below a shared-folder directory tree",
+                sync_list=[f"/{tree}/**/tree.txt"],
+                expected_entries=self._entries_exact(f"{tree}/A/B/C/tree.txt"),
+                required_present=[f"{tree}/A/B/C/tree.txt"],
+                required_absent=[f"{wide}/file00.txt", f"{core}/README.txt"],
+                required_stdout_markers=[self._marker(tree)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0015",
+                description="normal shared-folder include with deeper wildcard exclusion",
+                sync_list=[
+                    f"!/{core}/nested/excl*/*",
+                    f"/{core}/",
+                ],
+                expected_entries=self._exclude_entries(self._entries_under(core), f"{core}/nested/exclude"),
+                required_present=[f"{core}/README.txt", f"{core}/nested/keep/keep.txt"],
+                required_absent=[f"{core}/nested/exclude/exclude.txt", f"{core15}/README.txt"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0016",
+                description="normal shared-folder include with deeper globbing exclusion",
+                sync_list=[
+                    f"!/{core}/**/exclude/*",
+                    f"/{core}/",
+                ],
+                expected_entries=self._exclude_entries(self._entries_under(core), f"{core}/nested/exclude"),
+                required_present=[f"{core}/README.txt", f"{core}/nested/keep/keep.txt"],
+                required_absent=[f"{core}/nested/exclude/exclude.txt", f"{core15}/README.txt"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0017",
+                description="wildcard shared-folder include with wildcard exclusion of one matched shortcut's children",
+                sync_list=[
+                    "!/SHARED_FOLDERS/SUB_FOLDER_2/WIDE_*_15/*",
+                    "/SHARED_FOLDERS/SUB_FOLDER_2/WIDE_*/",
+                ],
+                expected_entries=wide_set_and_15_roots,
+                required_present=[f"{wide}/file00.txt", f"{wide}/file49.txt"],
+                required_absent=[f"{wide}_15/file00.txt", f"{tree}/A/B/C/tree.txt"],
+                required_stdout_markers=[self._marker(wide), self._marker(f"{wide}_15")],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0018",
+                description="wildcard shared-folder include with globbing exclusion of one matched file",
+                sync_list=[
+                    f"!/{deep15}/**/deepfile.txt",
+                    "/SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE*/",
+                ],
+                expected_entries=deep_and_deep15_without_deep15_file,
+                required_present=[f"{deep}/L1/L2/L3/deepfile.txt"],
+                required_absent=[f"{deep15}/L1/L2/L3/deepfile.txt", f"{core}/README.txt"],
+                required_stdout_markers=[self._marker(deep), self._marker(deep15)],
+            ),
+
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0019",
+                description="shared-folder shortcut name collision with different per-shortcut exclusions",
+                sync_list=[
+                    f"!/{core}/files/image*",
+                    f"!/{core15}/nested/exclude/*",
+                    f"/SHARED_FOLDERS/SUB_FOLDER_1/CORE*/",
+                ],
+                expected_entries=sorted(set(
+                    self._exclude_entries(self._entries_under(core), f"{core}/files/image0.png", f"{core}/files/image1.png")
+                    + self._exclude_entries(self._entries_under(core15), f"{core15}/nested/exclude")
+                )),
+                required_present=[f"{core}/files/data.txt", f"{core15}/README.txt", f"{core15}/nested/keep/keep.txt"],
+                required_absent=[f"{core}/files/image0.png", f"{core15}/nested/exclude/exclude.txt", f"{wide}/file00.txt"],
+                required_stdout_markers=[self._marker(core), self._marker(core15)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0020",
+                description="shared-folder exact file include with sibling wildcard exclusion",
+                sync_list=[
+                    f"!/{core}/files/image*",
+                    f"/{core}/files/data.txt",
+                ],
+                expected_entries=self._entries_exact(
+                    "SHARED_FOLDERS/",
+                    "SHARED_FOLDERS/SUB_FOLDER_1/",
+                    f"{core}/",
+                    f"{core}/files/",
+                    f"{core}/files/data.txt",
+                ),
+                required_present=[f"{core}/files/data.txt"],
+                required_absent=[f"{core}/files/image0.png", f"{core}/files/image1.png", f"{core}/README.txt"],
+                required_stdout_markers=[self._marker(core)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0021",
+                description="shared-folder path with spaces using wildcard and globbing include",
+                sync_list=["/Family pictures/* pictures/**"],
+                expected_entries=sorted(set(self._entries_under(annas) + self._entries_under(bens))),
+                required_present=[
+                    f"{annas}/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image0.png",
+                    f"{bens}/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image0.png",
+                ],
+                required_absent=[f"{core}/README.txt", f"{wide}/file00.txt"],
+                required_stdout_markers=[self._marker(annas), self._marker(bens)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0022",
+                description="renamed shared folder include remains anchored without ghost sibling creation",
+                sync_list=[
+                    f"!/{renamed}_15/*",
+                    f"/{renamed}/",
+                ],
+                expected_entries=self._entries_under(renamed),
+                required_present=[f"{renamed}/original.txt", f"{renamed}/upload-target/"],
+                required_absent=[f"{core}/README.txt", f"{renamed}_15/original.txt", f"{renamed}_15/upload-target/"],
+                required_stdout_markers=[self._marker(renamed)],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0023",
+                description="shared-folder globbing include across TREE shortcut variants",
+                sync_list=["/SHARED_FOLDERS/SUB_FOLDER_2/TREE*/**/tree.txt"],
+                expected_entries=self._entries_exact(
+                    f"{tree}/A/B/C/tree.txt",
+                    f"{tree}_15/A/B/C/tree.txt",
+                ),
+                required_present=[f"{tree}/A/B/C/tree.txt", f"{tree}_15/A/B/C/tree.txt"],
+                required_absent=[f"{wide}/file00.txt", f"{core}/README.txt"],
+                required_stdout_markers=[self._marker(tree), self._marker(f"{tree}_15")],
+            ),
+            SharedFolderSyncListScenario(
+                scenario_id="SL-0024",
+                description="cleanup_local_files removes local-only stale file under included shared-folder parent",
+                sync_list=[
+                    f"!/{core}/files/sfptc0003-*",
+                    f"/{core}/",
+                ],
+                expected_entries=self._entries_under(core),
+                required_present=[f"{core}/README.txt", f"{core}/files/", f"{core}/files/data.txt"],
+                required_absent=[f"{core15}/README.txt", f"{wide}/file00.txt"],
+                required_stdout_markers=[self._marker(core)],
+                cleanup_local_stale_files=[f"{core}/files/sfptc0003-local-stale.txt"],
+            ),
+        ]
diff --git a/ci/e2e/testcases_personal_shared_folders/shared_folder_common.py b/ci/e2e/testcases_personal_shared_folders/shared_folder_common.py
new file mode 100644
index 000000000..32009688f
--- /dev/null
+++ b/ci/e2e/testcases_personal_shared_folders/shared_folder_common.py
@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+import os
+import shutil
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+from framework.context import E2EContext
+from framework.manifest import build_typed_manifest, write_manifest
+from framework.result import TestResult
+from framework.utils import command_to_string, ensure_directory, write_text_file
+
+
+EXPECTED_TYPED_MANIFEST = [
+    'Documents/',
+    'Family pictures/',
+    'Family pictures/Annas pictures/',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image0.png',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image1.png',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image2.png',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image3.png',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image4.png',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image5.png',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image6.png',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image7.png',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image8.png',
+    'Family pictures/Annas pictures/4DiNZfTkCOlazjoQlDIVDh4VglcbENhA/image9.png',
+    'Family pictures/Bens pictures/',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image0.png',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image1.png',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image2.png',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image3.png',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image4.png',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image5.png',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image6.png',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image7.png',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image8.png',
+    'Family pictures/Bens pictures/7X2tH5TX0aiCXuNs8SBOk4lZqDS2qfEA/image9.png',
+    'Getting started with OneDrive.pdf',
+    'MINIMAL/',
+    'MINIMAL/single.txt',
+    'MINIMAL_15/',
+    'MINIMAL_15/single.txt',
+    'Pictures/',
+    'SHARED_FOLDERS/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/README.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/empty-dir/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/files/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/files/data.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/files/image0.png',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/files/image1.png',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/nested/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/nested/exclude/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/nested/exclude/exclude.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/nested/keep/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/nested/keep/keep.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE/nested/upload-target/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/README.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/empty-dir/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/files/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/files/data.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/files/image0.png',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/files/image1.png',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/nested/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/nested/exclude/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/nested/exclude/exclude.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/nested/keep/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/nested/keep/keep.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_1/CORE_15/nested/upload-target/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE/L1/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE/L1/L2/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE/L1/L2/L3/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE/L1/L2/L3/deepfile.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE/L1/L2/L3/upload-target/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE_15/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE_15/L1/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE_15/L1/L2/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE_15/L1/L2/L3/',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE_15/L1/L2/L3/deepfile.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE_15/L1/L2/L3/upload-target/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/TREE/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/TREE/A/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/TREE/A/B/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/TREE/A/B/C/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/TREE/A/B/C/tree.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/TREE_15/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/TREE_15/A/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/TREE_15/A/B/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/TREE_15/A/B/C/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/TREE_15/A/B/C/tree.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file00.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file01.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file02.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file03.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file04.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file05.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file06.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file07.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file08.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file09.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file10.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file11.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file12.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file13.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file14.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file15.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file16.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file17.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file18.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file19.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file20.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file21.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file22.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file23.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file24.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file25.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file26.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file27.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file28.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file29.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file30.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file31.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file32.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file33.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file34.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file35.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file36.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file37.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file38.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file39.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file40.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file41.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file42.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file43.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file44.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file45.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file46.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file47.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file48.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET/file49.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file00.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file01.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file02.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file03.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file04.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file05.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file06.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file07.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file08.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file09.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file10.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file11.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file12.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file13.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file14.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file15.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file16.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file17.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file18.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file19.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file20.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file21.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file22.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file23.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file24.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file25.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file26.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file27.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file28.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file29.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file30.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file31.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file32.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file33.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file34.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file35.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file36.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file37.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file38.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file39.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file40.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file41.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file42.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file43.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file44.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file45.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file46.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file47.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file48.txt',
+    'SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15/file49.txt',
+    'SHARED_FOLDERS_RENAMED/',
+    'SHARED_FOLDERS_RENAMED/RENAMED_SHARED_FOLDER/',
+    'SHARED_FOLDERS_RENAMED/RENAMED_SHARED_FOLDER/original.txt',
+    'SHARED_FOLDERS_RENAMED/RENAMED_SHARED_FOLDER/upload-target/',
+    'SHARED_FOLDERS_RENAMED/RENAMED_SHARED_FOLDER_15/',
+    'SHARED_FOLDERS_RENAMED/RENAMED_SHARED_FOLDER_15/original.txt',
+    'SHARED_FOLDERS_RENAMED/RENAMED_SHARED_FOLDER_15/upload-target/',
+]
+
+REQUIRED_STDOUT_MARKERS = [
+    'Account Type:          personal',
+    'Syncing this OneDrive Personal Shared Folder: ./Family pictures/Annas pictures',
+    'Syncing this OneDrive Personal Shared Folder: ./Family pictures/Bens pictures',
+    'Syncing this OneDrive Personal Shared Folder: ./SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE',
+    'Syncing this OneDrive Personal Shared Folder: ./SHARED_FOLDERS/SUB_FOLDER_1/CORE',
+    'Syncing this OneDrive Personal Shared Folder: ./SHARED_FOLDERS/SUB_FOLDER_1/CORE_15',
+    'Syncing this OneDrive Personal Shared Folder: ./SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE_15',
+    'Syncing this OneDrive Personal Shared Folder: ./SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET',
+    'Syncing this OneDrive Personal Shared Folder: ./SHARED_FOLDERS/SUB_FOLDER_2/TREE',
+    'Syncing this OneDrive Personal Shared Folder: ./SHARED_FOLDERS/SUB_FOLDER_2/WIDE_SET_15',
+    'Syncing this OneDrive Personal Shared Folder: ./SHARED_FOLDERS/SUB_FOLDER_2/TREE_15',
+    'Syncing this OneDrive Personal Shared Folder: ./SHARED_FOLDERS_RENAMED/RENAMED_SHARED_FOLDER',
+    'Syncing this OneDrive Personal Shared Folder: ./SHARED_FOLDERS_RENAMED/RENAMED_SHARED_FOLDER_15',
+    'Syncing this OneDrive Personal Shared Folder: ./MINIMAL',
+    'Syncing this OneDrive Personal Shared Folder: ./MINIMAL_15',
+    'Generating a /delta response from the OneDrive API for this Drive ID: fe7be87d015668a8',
+    'Generating a /delta response from the OneDrive API for this Drive ID: 05c0eb4429c2aa6b',
+    'Sync with Microsoft OneDrive is complete',
+]
+
+def case_sync_root(case_id: str) -> Path:
+    home = os.environ.get("HOME", "").strip()
+    if not home:
+        raise RuntimeError("HOME is not set")
+    return Path(home) / case_id
+
+
+def reset_local_sync_root(sync_root: Path) -> None:
+    if sync_root.exists():
+        shutil.rmtree(sync_root)
+    ensure_directory(sync_root)
+
+
+def write_case_config(context: E2EContext, config_dir: Path, case_id: str) -> Path:
+    """Create a per-test config directory using a per-test sync_dir under HOME."""
+    sync_dir_config_value = f"~/{case_id}/"
+    return context.prepare_minimal_config_dir(
+        config_dir,
+        f"# {case_id} Personal Shared Folder config\n"
+        f'sync_dir = "{sync_dir_config_value}"\n'
+        'threads = "2"\n'
+    )
+
+
+def wait_for_stdout_marker(stdout_file: Path, marker: str, timeout_seconds: int = 600, poll_interval: float = 0.5) -> bool:
+    deadline = time.time() + timeout_seconds
+    while time.time() < deadline:
+        if stdout_file.exists():
+            try:
+                if marker in stdout_file.read_text(encoding="utf-8", errors="replace"):
+                    return True
+            except OSError:
+                pass
+        time.sleep(poll_interval)
+    return False
+
+
+def validate_expected_manifest(
+    *,
+    sync_root: Path,
+    stdout_text: str,
+    manifest_file: Path,
+    expected_manifest_file: Path,
+    missing_manifest_file: Path,
+    unexpected_manifest_file: Path,
+) -> dict[str, object]:
+    actual_manifest = build_typed_manifest(sync_root)
+    expected_manifest = sorted(EXPECTED_TYPED_MANIFEST)
+    write_manifest(manifest_file, actual_manifest)
+    write_manifest(expected_manifest_file, expected_manifest)
+
+    actual_set = set(actual_manifest)
+    expected_set = set(expected_manifest)
+    missing_entries = sorted(expected_set - actual_set)
+    unexpected_entries = sorted(actual_set - expected_set)
+    write_manifest(missing_manifest_file, missing_entries)
+    write_manifest(unexpected_manifest_file, unexpected_entries)
+
+    missing_stdout_markers = [
+        marker for marker in REQUIRED_STDOUT_MARKERS if marker not in stdout_text
+    ]
+
+    return {
+        "expected_entries": len(expected_manifest),
+        "actual_entries": len(actual_manifest),
+        "missing_entries": missing_entries,
+        "unexpected_entries": unexpected_entries,
+        "missing_stdout_markers": missing_stdout_markers,
+    }
+
+
+def write_common_metadata(
+    metadata_file: Path,
+    *,
+    case_id: str,
+    name: str,
+    command: list[str],
+    returncode: int | None,
+    sync_root: Path,
+    config_dir: Path,
+    validation: dict[str, object],
+    extra_lines: list[str] | None = None,
+) -> None:
+    lines = [
+        f"case_id={case_id}",
+        f"name={name}",
+        f"command={command_to_string(command)}",
+        f"returncode={returncode}",
+        f"sync_root={sync_root}",
+        f"config_dir={config_dir}",
+        f"expected_entries={validation['expected_entries']}",
+        f"actual_entries={validation['actual_entries']}",
+        f"missing_entries={len(validation['missing_entries'])}",
+        f"unexpected_entries={len(validation['unexpected_entries'])}",
+        f"missing_stdout_markers={validation['missing_stdout_markers']!r}",
+    ]
+    if extra_lines:
+        lines.extend(extra_lines)
+    write_text_file(metadata_file, "\n".join(lines) + "\n")
+
+
+def manifest_failure_reason(validation: dict[str, object]) -> str:
+    if validation["missing_stdout_markers"]:
+        return "Expected Personal Shared Folder sync markers were not present in stdout"
+    if validation["missing_entries"]:
+        return "Expected shared-folder local paths were missing after sync"
+    if validation["unexpected_entries"]:
+        return "Unexpected local paths were created after sync; possible ghost folder regression"
+    return ""
+
+
+def stop_monitor_process(process: subprocess.Popen, timeout_seconds: int = 30) -> int | None:
+    if process.poll() is None:
+        process.send_signal(signal.SIGINT)
+        try:
+            process.wait(timeout=timeout_seconds)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait(timeout=timeout_seconds)
+    return process.returncode
diff --git a/docs/end_to_end_testing.md b/docs/end_to_end_testing.md
new file mode 100644
index 000000000..c69584f5b
--- /dev/null
+++ b/docs/end_to_end_testing.md
@@ -0,0 +1,142 @@
+# End to End Testing of OneDrive Client for Linux
+
+| Test Case Results |
+|:------------------|
+|[![E2E Testing - Personal Account](https://github.com/abraunegg/onedrive/actions/workflows/e2e-personal.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)|
+|[![E2E Testing - Personal Account: 15 Character driveId Check](https://github.com/abraunegg/onedrive/actions/workflows/e2e-personal-15char-check.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)|
+|[![E2E Testing - Personal Account: Shared Folders](https://github.com/abraunegg/onedrive/actions/workflows/e2e-personal-shared-folders.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)|
+|[![E2E Testing - Business Account](https://github.com/abraunegg/onedrive/actions/workflows/e2e-business.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)|
+|[![E2E Testing - Business Account: Shared Folders](https://github.com/abraunegg/onedrive/actions/workflows/e2e-business-shared-folders.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)|
+|[![E2E Testing - SharePoint Configuration](https://github.com/abraunegg/onedrive/actions/workflows/e2e-sharepoint.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)|
+
+This document describes the **end-to-end (E2E) automated testing framework** used to validate the behaviour of the OneDrive Client for Linux.
+
+The test suite runs inside **GitHub Actions** and performs **real synchronisation operations against Microsoft OneDrive** using dedicated test accounts.
+
+The objective of the test framework is to ensure that all client functionality continues to operate correctly across future changes to the application.
+
+### Personal and Business Account Testing
+Personal and Business end-to-end testing executes the full automated test suite against the default drive associated with the authenticated account, without explicitly specifying a `drive_id` in the client configuration. In this mode, the Microsoft Graph API implicitly resolves the user’s primary drive (personal OneDrive or business OneDrive root) and all drive enumeration, metadata retrieval, path traversal, upload, download, delete, and synchronisation operations are performed within that default context. As a result, the same comprehensive set of test cases validates client behaviour, configuration handling, and synchronisation correctness using the standard account-bound drive, ensuring expected operation without any explicit drive targeting or override.
+
+Note: Personal Shared Folder testing and Business Shared Folder testing are performed separately because OneDrive shared folder shortcuts introduce different path resolution, metadata, drive discovery, shortcut anchoring, and filtering behaviour from standard account-root synchronisation.
+
+### SharePoint Account Testing
+SharePoint end-to-end testing uses the same complete automated test suite as Personal OneDrive and OneDrive for Business, but changes the target drive by supplying a `drive_id` value in the client configuration. This means the harness is not merely repeating the same account-type tests against the same default drive context; it is explicitly forcing the client to enumerate, access, and operate against a different Microsoft Graph drive object, resulting in different drive discovery, metadata enumeration, path traversal, upload, download, delete, and synchronisation API activity. By injecting `drive_id` into the test configuration, every existing test case is executed against a SharePoint document library context rather than a personal or business default OneDrive root, ensuring that the full suite validates client behaviour, configuration handling, and synchronisation correctness when operating against SharePoint-backed storage.
+
+### Test Case Details
+
+| Test Case | Description | Account Coverage | Test Details |
+|:-------|:-------------|:-------|:-------|
+| 0001 | Basic Resync           | - Personal<br>- Business<br>- SharePoint | - validate that the E2E framework can invoke the client<br> - validate that the configured environment is sufficient to run a basic sync<br> - provide a simple baseline smoke test before more advanced E2E scenarios |
+| 0002 | 'sync_list' Validation | - Personal<br>- Business<br>- SharePoint | This validates sync_list as a policy-conformance test.<br><br>The test is considered successful when all observed sync operations involving the fixture tree match the active sync_list rules.<br><br>This test covers exclusions, inclusions, wildcard and globbing for paths and files. Specific 'sync_list' test coverage is as follows:<br>- Scenario SL-0001: root directory include with trailing slash<br>- Scenario SL-0002: root include without trailing slash<br>- Scenario SL-0003: non-root include by name<br>- Scenario SL-0004: include tree with nested exclusion<br>- Scenario SL-0005: included tree with hidden directory excluded<br>- Scenario SL-0006: file-specific include inside named directory<br>- Scenario SL-0007: rooted include of Programming tree<br>- Scenario SL-0008: exclude Android recursive build output and include Programming<br>- Scenario SL-0009: exclude Android recursive .cxx content and include Programming<br>- Scenario SL-0010: exclude Web recursive build output and include Programming<br>- Scenario SL-0011: exclude .gradle anywhere and include Programming<br>- Scenario SL-0012: exclude build/kotlin anywhere and include Programming<br>- Scenario SL-0013: exclude .venv and venv anywhere and include Programming<br>- Scenario SL-0014: exclude common cache and vendor directories and include Programming<br>- Scenario SL-0015: complex style Programming ruleset<br>- Scenario SL-0016: massive mixed rule set across Programming Documents and Work<br>- Scenario SL-0017: stress test kitchen sink rule set with broad include and targeted file include<br>- Scenario SL-0018: exact trailing slash configuration with cleanup validation<br>- Scenario SL-0019: no trailing slash workaround with cleanup validation<br>- Scenario SL-0020: focused trailing slash Projects regression for sibling path survival<br>- Scenario SL-0021: focused no trailing slash Projects regression for sibling path survival<br>- Scenario SL-0022: exact root-file include<br>- Scenario SL-0023: sync_root_files = true with rooted 'Projects' include<br>- Scenario SL-0024: cleanup regression with 'sync_root_files = true'<br>- Scenario SL-0025: prefix-collision safety for 'Projects/Code'<br>- Scenario SL-0026: mixed rooted subtree include plus exact root-file include<br>- Scenario SL-0027: wildcard directory include across similarly named Project Code folders<br>- Scenario SL-0028: globbing directory include for src directories across nested project depths<br>- Scenario SL-0029: wildcard directory include with deeper wildcard exclusion<br>- Scenario SL-0030: globbing directory include with recursive globbing exclusion<br>- Scenario SL-0031: normal directory include with deeper wildcard exclusion must not exclude ancestor<br>- Scenario SL-0032: normal directory include with deeper globbing exclusion must not exclude ancestor<br>- Scenario SL-0033: generic wildcard include with per-matched-container child exclusion<br>- Scenario SL-0034: generic globbing include traverses multiple seeded trees without premature pruning<br>- Scenario SL-0035: generic exact file include with sibling wildcard exclusion<br>- Scenario SL-0036: generic path with spaces using wildcard and globbing include<br>- Scenario SL-0037: generic cleanup_local_files with included root and excluded child subtree<br>- Scenario SL-0038: generic cleanup_local_files with wildcard include and excluded sibling container children<br>- Scenario SL-0039: generic sync_root_files override retains logical root files without entering unrelated fixture subtrees<br> |
+| 0003 | Dry-run safety validation | - Personal<br>- Business<br>- SharePoint | This test validates that running the client with `--dry-run` performs a full synchronisation analysis without making any changes locally or remotely. Files and directories are created in the test environment, the client is executed with `--dry-run`, and the test verifies that no filesystem or remote changes occur.|
+| 0004 | Single-directory sync scope validation | - Personal<br>- Business<br>- SharePoint | This test validates that the `--single-directory` option restricts synchronisation to the specified directory subtree. Only the nominated directory should be synchronised, while other directories outside the scope must remain untouched. |
+| 0005 | Force-sync override validation | - Personal<br>- Business<br>- SharePoint | This test validates that the `--force-sync` option overrides blocking conditions that would normally prevent synchronisation of a single-directory scope. The test confirms that forced synchronisation proceeds even when skip rules would otherwise block the operation. |
+| 0006 | Download-only sync validation | - Personal<br>- Business<br>- SharePoint | This test validates the behaviour of the `--download-only` option. Remote content is seeded in OneDrive and the client is executed in download-only mode. The test verifies that the remote data is correctly downloaded locally without performing any upload operations. |
+| 0007 | Download-only cleanup validation | - Personal<br>- Business<br>- SharePoint | This test validates the behaviour of `--cleanup-local-files` when used with `--download-only`. Local files that no longer exist remotely should be removed during synchronisation while valid remote content is preserved. |
+| 0008 | Upload-only sync validation | - Personal<br>- Business<br>- SharePoint | This test validates that `--upload-only` mode correctly uploads local files and directories to OneDrive. The test ensures that no download operations occur and that remote content reflects the locally created files. |
+| 0009 | Upload-only remote preservation validation | - Personal<br>- Business<br>- SharePoint | This test validates the behaviour of the `--no-remote-delete` option when used with `--upload-only` mode. The test confirms that remote files are not deleted even when they do not exist locally. |
+| 0010 | Upload-only source removal validation | - Personal<br>- Business<br>- SharePoint | This test validates the `--remove-source-files` option used with `--upload-only` mode. After files are successfully uploaded to OneDrive, the local source files should be automatically removed. |
+| 0011 | Skip-file pattern validation | - Personal<br>- Business<br>- SharePoint | This test validates that `skip_file` configuration patterns correctly exclude matching files from synchronisation. Files matching the configured patterns should not be uploaded or downloaded. |
+| 0012 | Skip-directory rule validation | - Personal<br>- Business<br>- SharePoint | This test validates the behaviour of the 'skip_dir' option and the 'skip_dir_strict_match' setting. The test confirms that directories matching the configured patterns are correctly excluded from synchronisation. |
+| 0013 | Dotfile exclusion validation | - Personal<br>- Business<br>- SharePoint | This test validates the 'skip_dotfiles' option. Files and directories beginning with a dot (`.`) should be excluded from synchronisation when this option is enabled. |
+| 0014 | File size exclusion validation | - Personal<br>- Business<br>- SharePoint | This test validates the 'skip_size' option. Files exceeding the configured size threshold should be excluded from synchronisation.|
+| 0015 | Symlink exclusion validation | - Personal<br>- Business<br>- SharePoint | This test validates the 'skip_symlinks' configuration option. Symbolic links present in the local filesystem should not be synchronised when this option is enabled. |
+| 0016 | `.nosync` directory exclusion validation | - Personal<br>- Business<br>- SharePoint | This test validates the 'check_nosync' feature. Directories containing a `.nosync` marker file should be excluded from synchronisation. |
+| 0017 | `.nosync` mount protection validation | - Personal<br>- Business<br>- SharePoint | This test validates the 'check_nomount' safeguard. When a `.nosync` marker exists in the mount point of the synchronisation directory, the client should abort synchronisation to prevent unintended operations.|
+| 0018 | Recycle bin integration validation | - Personal<br>- Business<br>- SharePoint | This test validates integration with the FreeDesktop-compliant recycle bin. When files are deleted remotely, the client should move them into the configured recycle bin instead of permanently deleting them when the feature is enabled.|
+| 0019 | Logging and runtime configuration validation | - Personal<br>- Business<br>- SharePoint | This test validates that the client correctly writes logs to a configured 'log_dir' and that `--display-running-config` outputs the effective runtime configuration. |
+| 0020 | Monitor mode real-time sync validation | - Personal<br>- Business<br>- SharePoint | This test validates that when the client runs in `--monitor mode`, filesystem changes made while the process is running are automatically detected and synchronised without manually re-running the client. This validates inotify-based filesystem event handling under real-time event propagation conditions. |
+| 0021 | Resumable upload recovery validation | - Personal<br>- Business<br>- SharePoint | This test validates resumable upload and download session behaviour. Large file transfers are intentionally interrupted using controlled transfer abort behaviour and then resumed during a subsequent client execution using the same client state. The test confirms that the transfer successfully completes without requiring a full resync. |
+| 0022 | Local-first conflict resolution validation | - Personal<br>- Business<br>- SharePoint | This test validates the 'local_first' configuration option. When a file conflict occurs between local and remote versions, the client should treat the local file as the authoritative source and update the remote version accordingly. |
+| 0023 | Bypass data preservation validation | - Personal<br>- Business<br>- SharePoint | This test validates the behaviour of the 'bypass_data_preservation' option. When enabled, the client should suppress the creation of safe-backup files during conflict resolution and allow remote content to overwrite local changes. |
+| 0024 | Big delete safeguard validation | - Personal<br>- Business<br>- SharePoint | This test validates the 'classify_as_big_delete' protection mechanism. When a large number of items are deleted locally, the client should halt synchronisation and emit a warning. The deletion should only proceed after the user explicitly acknowledges the action using `--force`. This also validates consistent safeguard behaviour across account types where API timing or enumeration differences may occur. |
+| 0025 | Invalid character filename validation | - Personal<br>- Business<br>- SharePoint | This test validates that invalid filename characters are blocked while valid sibling files still synchronise |
+| 0026 | Reserved device name validation | - Personal<br>- Business<br>- SharePoint | This test validates that reserved Windows device names are blocked while valid lookalike names still synchronise |
+| 0027 | Whitespace and trailing dot validation | - Personal<br>- Business<br>- SharePoint | This test validates that trailing whitespace and trailing dot names are blocked while valid sibling files still synchronise |
+| 0028 | Control character and non-UTF8 filename validation | - Personal<br>- Business<br>- SharePoint | This test validates that control characters and non-UTF8 filenames are safely skipped without client crash while valid sibling files still synchronise |
+| 0029 | Upload-only + Local First sync validation | - Personal<br>- Business<br>- SharePoint | This test validates that `--local-first --upload-only` uploads local content without rewriting local file timestamps from Microsoft API response data |
+| 0030 | Local rename propagation validation | - Personal<br>- Business<br>- SharePoint | This test validates that renaming a local file is correctly propagated to remote state |
+| 0031 | Local directory rename propagation validation | - Personal<br>- Business<br>- SharePoint | This test validates that renaming a local directory tree is correctly propagated to remote state |
+| 0032 | Remote file rename reconciliation | - Personal<br>- Business<br>- SharePoint | This test validates that a stale local client correctly reconciles a remote-side file rename without leaving stale local leftovers |
+| 0033 | remote directory rename reconciliation | - Personal<br>- Business<br>- SharePoint | This test validates that a second client with existing local and database state correctly reconciles a remote directory rename propagated by another synchronising client |
+| 0034 | Local move between directories validation | - Personal<br>- Business<br>- SharePoint | This test validates that moving a local file from one directory to another is correctly propagated to remote state |
+| 0035 | Remote move between directories reconciliation | - Personal<br>- Business<br>- SharePoint | This test validates that a stale local client correctly reconciles a remote-side file move between directories without leaving stale local file leftovers |
+| 0036 | Overwrite / replace existing file content validation | - Personal<br>- Business<br>- SharePoint | This test validates that replacing the contents of an existing local file with the same name correctly updates remote content without leaving stale content or metadata confusion |
+| 0037 | mtime-only local change handling | - Personal<br>- Business<br>- SharePoint | This test validates that mtime-only local file changes across direct upload, automatic session upload for files larger than 4 MiB, and forced session upload behaviour without changing file content |
+| 0038 | Delete and recreate with same name validation | - Personal<br>- Business<br>- SharePoint | This test validates that deleting a file, syncing that deletion, then recreating a different file with the same name correctly results in the final remote and local state without stale item-id or state database issues |
+| 0039 | Empty directory handling | - Personal<br>- Business<br>- SharePoint | This test validates that creation, sync, verification, and cleanup behaviour for empty directories, including nested empty directories, to ensure directory-only state is created and removed correctly |
+| 0040 | Nested tree rename and delete stress validation | - Personal<br>- Business<br>- SharePoint | This test validates that a combined nested-tree mutation scenario involving multiple renames, one deletion, and one new file creation before a single sync, ensuring the final remote and fresh-download state is correct with no stale paths left behind |
+| 0041 | Monitor mode local create upload | - Personal<br>- Business<br>- SharePoint | This test validates starting --monitor, create a local file, and validate it uploads without restarting the client |
+| 0042 | Monitor mode local modify upload | - Personal<br>- Business<br>- SharePoint | This test validates modifying an existing local file under --monitor and validate the update propagates |
+| 0043 | Monitor mode local delete propagation | - Personal<br>- Business<br>- SharePoint | This test validates deleting a local file under --monitor and validate the remote delete occurs as expected |
+| 0044 | Monitor mode local rename propagation | - Personal<br>- Business<br>- SharePoint | This test validates renaming a local file while --monitor is active and validates correct behaviour |
+| 0045 | Monitor mode local directory create propagation | - Personal<br>- Business<br>- SharePoint | This test validates creating a new local directory and child file under --monitor and validate the remote state |
+| 0046 | Monitor mode local directory rename propagation | - Personal<br>- Business<br>- SharePoint | This test validates renaming a populated local directory while --monitor is active and validate the final remote state |
+| 0047 | Monitor mode local directory delete propagation | - Personal<br>- Business<br>- SharePoint | This test validates deleting a populated local directory tree under --monitor and validate the remote delete |
+| 0048 | Monitor mode burst local file creates | - Personal<br>- Business<br>- SharePoint | This test rapidly create multiple local files under --monitor and validate they all upload correctly |
+| 0049 | Monitor mode mixed burst operations | - Personal<br>- Business<br>- SharePoint | This test performs create, modify, delete, and rename operations in one burst under --monitor and validate the final state |
+| 0050 | Monitor mode nested file create inside new directory | - Personal<br>- Business<br>- SharePoint | This test creates a nested directory tree and deep file under --monitor and validate the remote state |
+| 0051 | Monitor mode mtime-only local change handling | - Personal<br>- Business<br>- SharePoint | This test touches an existing local file under --monitor without changing content and validate that no new upload occurs |
+| 0052 | Monitor mode large file create session upload | - Personal<br>- Business<br>- SharePoint | This test creates a large file under --monitor and validate session upload behaviour and remote integrity |
+| 0053 | Monitor mode rename then modify | - Personal<br>- Business<br>- SharePoint | This test renames a file and then modify the renamed file under --monitor and validate the final remote state |
+| 0054 | Monitor mode atomic-save editor replace workflow | - Personal<br>- Business<br>- SharePoint | This test replaces an existing file via temp-file save and atomic rename under --monitor and validate the final remote state |
+| 0055 | Upload-only remove-source-folders | - Personal<br>- Business<br>- SharePoint | This test validates that remove_source_folders removes empty local directory structure after upload-only succeeds |
+| 0056 | Monitor mode create then delete quickly | - Personal<br>- Business<br>- SharePoint | This test creates and delete a local file quickly under --monitor and validate stability and final remote state |
+| 0057 | Recycle bin delete behaviour validation |  - Personal<br>- Business<br>- SharePoint | This test validates `use_recycle_bin` behaviour for online-origin deletes and local-origin delete propagation. It confirms that remote-originated deletes can be moved to the local recycle bin when configured, while local-originated deletes are correctly propagated to OneDrive as delete operations. |
+
+
+
+### OneDrive Personal Shared Folder Testing
+Personal Shared Folder end-to-end testing validates client behaviour when synchronising content accessed via OneDrive shared folder shortcuts.
+
+Unlike standard directory structures, shared folders are represented through shortcut-style access to content that may be backed by different OneDrive drive items. This introduces unique behaviour in path resolution, metadata handling, shortcut anchoring, and `sync_list` evaluation.
+
+These tests ensure that:
+- shared folder shortcuts are correctly discovered and traversed
+- preserved shared folder topology is pulled down without creating ghost folders
+- linked shared folder content is synchronised without corrupting local path structure
+- `sync_list` rules correctly apply across shared folder shortcut boundaries
+- renamed, nested, and path-with-spaces shared folders remain anchored correctly
+- wildcard, globbing, inclusion, exclusion, and cleanup scenarios behave correctly for shared folder paths
+- safe test mutations do not unintentionally modify preserved shared folder fixture content
+
+### Personal Shared Folder Test Case Details
+
+| Test Case | Description | Account Coverage | Test Details |
+|:-------|:-------------|:-------|:-------|
+| 0001 | Personal shared folders clean sync pull down | - Personal | This test validates that `--sync --verbose` pulls down the preserved Personal Account shared folder topology without creating ghost folders. It confirms that shared folder shortcuts are discovered, traversed, and materialised locally using the expected path structure. |
+| 0002 | Personal shared folders clean monitor pull down | - Personal | This test validates that `--monitor --verbose` pulls down the preserved Personal Account shared folder topology without creating ghost folders. It confirms that monitor mode can initialise shared folder content correctly and remain stable while filesystem monitoring is active. |
+| 0003 | Personal shared folders `sync_list` validation | - Personal | This validates `sync_list` include and exclude behaviour across the preserved Personal Account shared folder topology without creating ghost folders.<br><br>The test is considered successful when all observed sync operations involving the shared folder fixture topology match the active `sync_list` rules, including shortcut path anchoring and resolved shared folder paths.<br><br>Specific Personal Shared Folder `sync_list` coverage is as follows:<br>- Scenario SL-0001: rooted include of one shared folder tree with trailing slash<br>- Scenario SL-0002: rooted include of one shared folder tree without trailing slash<br>- Scenario SL-0003: rooted include of deep shared folder path<br>- Scenario SL-0004: include shared folder tree with nested exclusion<br>- Scenario SL-0005: file-specific include inside a shared folder<br>- Scenario SL-0006: multiple file-specific includes within one shared folder<br>- Scenario SL-0007: include nested tree shared folder and exclude sibling shared folder trees<br>- Scenario SL-0008: mixed includes across minimal renamed and deep shared folders<br>- Scenario SL-0009: include shared folder path containing spaces<br>- Scenario SL-0010: multiple explicit shared-folder shortcut includes only<br>- Scenario SL-0011: safe tracked mutation inside an existing shared-folder directory<br>- Scenario SL-0012: issue 3643 explicit Family pictures shared-folder includes only<br>- Scenario SL-0013: wildcard shared-folder directory include across WIDE_SET shortcuts<br>- Scenario SL-0014: globbing include for a file below a shared-folder directory tree<br>- Scenario SL-0015: normal shared-folder include with deeper wildcard exclusion<br>- Scenario SL-0016: normal shared-folder include with deeper globbing exclusion<br>- Scenario SL-0017: wildcard shared-folder include with wildcard exclusion of one matched shortcut's children<br>- Scenario SL-0018: wildcard shared-folder include with globbing exclusion of one matched file<br>- Scenario SL-0019: shared-folder shortcut name collision with different per-shortcut exclusions<br>- Scenario SL-0020: shared-folder exact file include with sibling wildcard exclusion<br>- Scenario SL-0021: shared-folder path with spaces using wildcard and globbing include<br>- Scenario SL-0022: renamed shared folder include remains anchored without ghost sibling creation<br>- Scenario SL-0023: shared-folder globbing include across TREE shortcut variants<br>- Scenario SL-0024: cleanup_local_files removes local-only stale file under included shared-folder parent |
+
+
+### OneDrive Business Shared Folder Testing
+Business Shared Folder end-to-end testing validates client behaviour when synchronising content accessed via OneDrive for Business shared folder shortcuts.
+
+Unlike standard Business account-root synchronisation, shared folders are represented through shortcut-style access to content that may be backed by different OneDrive drive identifiers and remote document library contexts. This introduces unique behaviour in drive discovery, path resolution, metadata handling, shortcut anchoring, and `sync_list` evaluation.
+
+These tests ensure that:
+- Business shared folder shortcuts are correctly discovered and traversed
+- preserved Business shared folder topology is pulled down without creating ghost folders
+- linked shared folder content is synchronised without corrupting local path structure
+- `sync_list` rules correctly apply across Business shared folder shortcut boundaries
+- wildcard, globbing, inclusion, exclusion, and cleanup scenarios behave correctly for Business shared folder paths
+- deep path traversal behaves correctly across different shared folder drive contexts
+- similarly named shared folder trees remain correctly isolated during wildcard and globbing evaluation
+- safe test mutations do not unintentionally modify preserved Business shared folder fixture content
+
+### Business Shared Folder Test Case Details
+
+| Test Case | Description | Account Coverage | Test Details |
+|:-------|:-------------|:-------|:-------|
+| 0001 | Business shared folders clean sync pull down | - Business | This test validates that `--sync --verbose` pulls down the preserved Business Account shared folder topology without creating ghost folders. It confirms that Business shared folder shortcuts are discovered, traversed, and materialised locally using the expected path structure. |
+| 0002 | Business shared folders clean monitor pull down | - Business | This test validates that `--monitor --verbose` pulls down the preserved Business Account shared folder topology without creating ghost folders. It confirms that monitor mode can initialise Business shared folder content correctly and remain stable while filesystem monitoring is active. |
+| 0003 | Business shared folders `sync_list` validation | - Business | This validates `sync_list` include and exclude behaviour across the preserved Business Account shared folder topology without creating ghost folders.<br><br>The test is considered successful when all observed sync operations involving the shared folder fixture topology match the active `sync_list` rules, including shortcut path anchoring, resolved shared folder paths, and different Business shared-folder drive contexts.<br><br>Specific Business Shared Folder `sync_list` coverage is as follows:<br>- Scenario SL-0001: rooted include of one Business shared folder tree with trailing slash<br>- Scenario SL-0002: rooted include of one Business shared folder tree without trailing slash<br>- Scenario SL-0003: rooted include of deep Business shared folder path<br>- Scenario SL-0004: include Business shared folder tree with nested exclusion<br>- Scenario SL-0005: file-specific include inside a Business shared folder<br>- Scenario SL-0006: multiple file-specific includes within one Business shared folder<br>- Scenario SL-0007: include nested Business shared folder tree and exclude sibling shared folder trees<br>- Scenario SL-0008: mixed includes across minimal renamed and deep Business shared folders<br>- Scenario SL-0009: include Business shared folder path containing spaces<br>- Scenario SL-0010: multiple explicit Business shared-folder shortcut includes only<br>- Scenario SL-0011: safe tracked mutation inside an existing Business shared-folder directory<br>- Scenario SL-0012: wildcard Business shared-folder directory include across WIDE_SET trees<br>- Scenario SL-0013: globbing include for a file below a Business shared-folder directory tree<br>- Scenario SL-0014: normal Business shared-folder include with deeper wildcard exclusion<br>- Scenario SL-0015: normal Business shared-folder include with deeper globbing exclusion<br>- Scenario SL-0016: wildcard Business shared-folder include with wildcard exclusion of one matched shortcut's children<br>- Scenario SL-0017: wildcard Business shared-folder include with globbing exclusion of one matched file<br>- Scenario SL-0018: Business shared-folder exact file include with sibling wildcard exclusion<br>- Scenario SL-0019: Business shared-folder path with spaces using wildcard and globbing include<br>- Scenario SL-0020: renamed Business shared folder include remains anchored without ghost sibling creation<br>- Scenario SL-0021: Business shared-folder globbing include across TREE shortcut variants<br>- Scenario SL-0022: cleanup_local_files removes local-only stale file under included Business shared-folder parent<br>- Scenario SL-0023: deep Business shared-folder globbing include with retained sibling empty directory structure<br>- Scenario SL-0024: explicit Business shared-folder subtree include across different shared-folder drive contexts<br>- Scenario SL-0025: exact file include across multiple Business shared-folder roots<br>- Scenario SL-0026: explicit subtree include across multiple Business shared-folder roots<br>- Scenario SL-0027: mixed Business shared-folder include and exclusion behaviour across different shortcut-backed drive identifiers |
+
+### Contributing Additional Test Cases
+
+While this end-to-end test suite provides broad and comprehensive coverage of the OneDrive Client for Linux, it is not exhaustive. Real-world usage continues to surface new edge cases, behaviours, and scenarios that may not yet be represented here. 
+
+If you identify a gap in coverage, encounter a scenario that is not currently validated, or believe an existing test case could be improved, contributions are strongly encouraged. Please feel free to raise a discussion outlining the scenario, or ideally develop and submit a new test case via a pull request following the existing test framework structure. 
+
+Community contributions play a critical role in strengthening the reliability and robustness of the client, and all well-defined additions are welcomed.
diff --git a/docs/usage.md b/docs/usage.md
index 5ebd5207c..e4864e224 100644
--- a/docs/usage.md
+++ b/docs/usage.md
@@ -43,6 +43,7 @@ Before reading this document, please ensure you are running application version
 - [Frequently Asked Configuration Questions](#frequently-asked-configuration-questions)
   - [How to change the default configuration of the client?](#how-to-change-the-default-configuration-of-the-client)
   - [How to change where my data from Microsoft OneDrive is stored?](#how-to-change-where-my-data-from-microsoft-onedrive-is-stored)
+  - [How do I safely remove my local sync_dir without deleting my OneDrive data?](#how-do-i-safely-remove-my-local-sync_dir-without-deleting-my-onedrive-data)
   - [Why does the client create 'safeBackup' files?](#why-does-the-client-create-safebackup-files)
   - [How to change what file and directory permissions are assigned to data that is downloaded from Microsoft OneDrive?](#how-to-change-what-file-and-directory-permissions-are-assigned-to-data-that-is-downloaded-from-microsoft-onedrive)
   - [How are uploads and downloads managed?](#how-are-uploads-and-downloads-managed)
@@ -1065,6 +1066,47 @@ The following are supported for pattern matching and exclusion rules:
 > ```
 > This will tell the application to sync any file that it finds in your 'sync_dir' root by default, negating the need to constantly update your 'sync_list' file.
 
+#### Using 'sync_list' with OneDrive Personal Shared Folders (Shortcuts)
+
+When using `sync_list` with OneDrive Personal shared folders that have been added to your OneDrive as shortcuts, it is important to understand that these are **not standard directories within your OneDrive file hierarchy**.
+
+A shared folder is represented as a *shortcut (link)* to content stored in another location (for example, another user's OneDrive). Because of this:
+
+> [!IMPORTANT]
+> Including only the parent directory that contains shared-folder shortcuts does **not guarantee** that the client will traverse and synchronise the contents of those shared folders.
+
+For example, given the following structure:
+
+```text
+SHARED_FOLDERS/
+SHARED_FOLDERS/SUB_FOLDER_1/
+SHARED_FOLDERS/SUB_FOLDER_1/CORE/
+SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE/
+```
+
+The following `sync_list` rule:
+
+```text
+/SHARED_FOLDERS/
+```
+
+will include the shared-folder **shortcut entries only**, but will not reliably trigger traversal into the contents of those shared folders.
+
+To ensure correct behaviour, explicitly include each shared-folder shortcut path that you want to synchronise:
+
+```text
+/SHARED_FOLDERS/SUB_FOLDER_1/CORE/
+/SHARED_FOLDERS/SUB_FOLDER_1/DEEP_SOURCE/
+```
+
+> [!NOTE]
+> Using wildcard rules such as `/SHARED_FOLDERS/*` will only include the shared-folder shortcut entries and does **not guarantee** traversal into the contents of those shared folders.
+
+> [!TIP]
+> Treat each shared-folder shortcut as an independent root for the purposes of `sync_list`. Always explicitly include the exact shared-folder paths you want synchronised.
+
+
+
 ### Performing a --resync
 A `--resync` operation instructs the client to delete its local state database and fully rebuild it from the current online OneDrive contents. This is a powerful recovery and re-alignment action that should be used **sparingly** and **with care**.
 
@@ -1463,6 +1505,15 @@ The same FreeDesktop.org Trash Specification will be used with this explicit 'Re
 
 ![using_recycle_bin](./images/using_recycle_bin.png)
 
+> [!IMPORTANT]
+> The `use_recycle_bin` option only applies when a deletion originates from Microsoft OneDrive online, or from another OneDrive client, and this client then needs to remove the corresponding local file or folder.
+>
+> It does **not** protect files or folders that you delete locally from your configured `sync_dir`.
+> 
+> If you delete files locally from `sync_dir`, this client treats that as an intentional local delete and will propagate that delete to Microsoft OneDrive during synchronisation. By the time this client detects the local delete, the data has already been removed from the local filesystem, so the client cannot move it to the local Recycle Bin.
+>
+> If you want locally deleted files to go to Trash first, you must delete them using your desktop environment’s Trash mechanism, such as GNOME Files, KDE Dolphin, or another tool that implements the FreeDesktop.org Trash Specification. Do not use `rm`, `shred`, scripts, terminal cleanup commands, or manually delete the sync directory while the client or systemd service is still running unless you intend those deletes to be synchronised online.
+
 
 ### Handling a Microsoft OneDrive Account Password Change
 If you change your Microsoft OneDrive Account Password, the client will no longer be authorised to sync, and will generate the following error upon next application run:
@@ -1572,6 +1623,31 @@ To change this location, the application configuration option 'sync_dir' is used
 > [!IMPORTANT]
 > Please be aware that if you designate a network mount point (such as NFS, Windows Network Share, or Samba Network Share) as your `sync_dir`, this setup inherently lacks 'inotify' support. Support for 'inotify' is essential for real-time tracking of local file changes, which means that the client's 'Monitor Mode' cannot immediately detect changes in files located on these network shares. Instead, synchronisation between your local filesystem and Microsoft OneDrive will occur at intervals specified by the `monitor_interval` setting. This limitation regarding 'inotify' support on network mount points like NFS or Samba is beyond the control of this client.
 
+### How do I safely remove my local sync_dir without deleting my OneDrive data?
+> [!CAUTION]
+> Do **not** delete your configured `sync_dir` while the client is running.
+
+A local delete inside `sync_dir` is treated as an intentional synchronisation action. The client may detect this through inotify events in monitor mode, or during a filesystem scan, and then propagate the delete to Microsoft OneDrive.
+
+To remove the local copy without deleting online data:
+
+1. Stop all running `onedrive` processes.
+2. Stop any configured systemd service, for example:
+```
+systemctl --user stop onedrive
+```
+3. Confirm no client process is still running:
+```
+pgrep -a onedrive
+```
+4. Move the local sync directory out of the way first:
+```
+mv ~/OneDrive ~/OneDrive.local-backup
+```
+5. Only delete the backup after you are certain the client is stopped and you no longer need the local data.
+
+If you accidentally deleted local files while the client was still running, immediately stop the client and check the Microsoft OneDrive online Recycle Bin.
+
 ### Why does the client create 'safeBackup' files?
 'safeBackup' files are created to prevent local data loss whenever the client is about to replace or remove a local file and there’s any chance the current on-disk content might be different to what OneDrive expects.
 
diff --git a/readme.md b/readme.md
index 4e5a0f62d..9e107c1d4 100644
--- a/readme.md
+++ b/readme.md
@@ -1,11 +1,18 @@
 # OneDrive Client for Linux
-[![Version](https://img.shields.io/github/v/release/abraunegg/onedrive)](https://github.com/abraunegg/onedrive/releases)
-[![Release Date](https://img.shields.io/github/release-date/abraunegg/onedrive)](https://github.com/abraunegg/onedrive/releases)
+[![Version](https://img.shields.io/github/v/release/abraunegg/onedrive?logo=github)](https://github.com/abraunegg/onedrive/releases)
+[![Release Date](https://img.shields.io/github/release-date/abraunegg/onedrive?logo=github)](https://github.com/abraunegg/onedrive/releases)
 
 [![Test Build](https://github.com/abraunegg/onedrive/actions/workflows/testbuild.yaml/badge.svg)](https://github.com/abraunegg/onedrive/actions/workflows/testbuild.yaml)
 [![Smoke Test](https://github.com/abraunegg/onedrive/actions/workflows/smoke-test.yaml/badge.svg)](https://github.com/abraunegg/onedrive/actions/workflows/smoke-test.yaml)
 [![Build Docker Images](https://github.com/abraunegg/onedrive/actions/workflows/docker.yaml/badge.svg)](https://github.com/abraunegg/onedrive/actions/workflows/docker.yaml)
-[![Docker Pulls](https://img.shields.io/docker/pulls/driveone/onedrive)](https://hub.docker.com/r/driveone/onedrive)
+[![Docker Pulls](https://img.shields.io/docker/pulls/driveone/onedrive?logo=docker)](https://hub.docker.com/r/driveone/onedrive)
+
+[![E2E Testing - Personal Account](https://github.com/abraunegg/onedrive/actions/workflows/e2e-personal.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)
+[![E2E Testing - Personal Account: 15 Character driveId Check](https://github.com/abraunegg/onedrive/actions/workflows/e2e-personal-15char-check.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)
+[![E2E Testing - Personal Account: Shared Folders](https://github.com/abraunegg/onedrive/actions/workflows/e2e-personal-shared-folders.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)
+[![E2E Testing - Business Account](https://github.com/abraunegg/onedrive/actions/workflows/e2e-business.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)
+[![E2E Testing - Business Account: Shared Folders](https://github.com/abraunegg/onedrive/actions/workflows/e2e-business-shared-folders.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)
+[![E2E Testing - SharePoint documentLibrary Configuration](https://github.com/abraunegg/onedrive/actions/workflows/e2e-sharepoint.yaml/badge.svg)](https://github.com/abraunegg/onedrive/blob/master/docs/end_to_end_testing.md)
 
 A fully featured, free, and actively maintained Microsoft OneDrive client that seamlessly supports OneDrive Personal, OneDrive for Business, Microsoft 365 (formerly Office 365), and SharePoint document libraries.
 
@@ -169,7 +176,11 @@ If you encounter any issues running the application, please follow these steps *
    - See [Compatibility with curl](https://github.com/abraunegg/onedrive/blob/master/docs/usage.md#compatibility-with-curl) for details on curl bugs that impact this client.  
    - Refer to the official [cURL Releases](https://curl.se/docs/releases.html) page for version information.
 
-6. **Open a new issue**  
+6. **Perform a --resync**
+   In some cases, a `--resync` is needed to ensure your data is correctly synced. This option instructs the client to delete its local state database and fully rebuild it from the current online OneDrive contents. This is a powerful recovery and re-alignment action that should be used sparingly and with care.
+   - See [Performing a --resync](https://github.com/abraunegg/onedrive/blob/master/docs/usage.md#performing-a---resync) for further details.
+
+7. **Open a new issue**  
    If the problem persists after completing the steps above, proceed to **Reporting an Issue or Bug** below and open a new issue with the requested details and logs.