Merge pull request 'ci: route validation to available runners' (#12 ) from codex/runner-fast-path-20260903 into main

Fix ForgeFlow runner label mismatch. [skip ci]
ci: target the hardened native Windows runner
2026-09-03 18:58:57 +00:00 · 2026-09-03 18:47:56 +00:00 · 2026-09-03 00:28:43 +00:00 · 2026-09-02 21:44:29 +00:00 · 2026-09-02 23:37:30 +02:00 · 2026-08-31 20:17:56 +02:00
122 changed files with 7131 additions and 1082 deletions
@@ -0,0 +1,3 @@
+*.sh text eol=lf
+examples/server/forgeflow-deploy text eol=lf
+scripts/* text eol=lf
@@ -0,0 +1,29 @@
+name: ChatGPT validation
+
+on:
+  push:
+    branches:
+      - 'codex/**'
+  workflow_dispatch:
+
+jobs:
+  quality:
+    runs-on: windows-native
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version: 22
+          cache: npm
+      - run: npm ci
+      - run: npm run quality
+      - run: npx playwright install --with-deps chromium
+      - run: npm run test:browser:ci
+      - name: Preserve browser failure evidence
+        if: failure()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: forgeflow-browser-failure-evidence
+          path: artifacts/
+          if-no-files-found: ignore
+      - run: npm audit --omit=dev --audit-level=high
@@ -0,0 +1,147 @@
+name: Managed validation
+
+on:
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      profile:
+        description: Allowlisted validation profile
+        required: true
+        default: full
+        type: choice
+        options: [test, lint, typecheck, build, security, full]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: managed-validation-${{ gitea.repository }}-${{ gitea.ref }}
+  cancel-in-progress: true
+
+jobs:
+  full:
+    name: full
+    # Public fork code must never execute automatically on the private runner.
+    if: ${{ gitea.event_name != 'pull_request' || gitea.event.pull_request.head.repo.full_name == gitea.repository }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - name: Validate repository with a bounded profile
+        shell: bash
+        env:
+          REQUESTED_PROFILE: ${{ inputs.profile }}
+        run: |
+          set -euo pipefail
+          profile="${REQUESTED_PROFILE:-full}"
+          case "${profile}" in
+            test|lint|typecheck|build|security|full) ;;
+            *) echo "Profile is not allowlisted" >&2; exit 2 ;;
+          esac
+
+          git diff --check
+          if git grep -nE '^(<<<<<<< |=======$|>>>>>>> )' -- . ':!*.lock' ':!*.patch'; then
+            echo "Unresolved merge markers detected" >&2
+            exit 1
+          fi
+
+          # MANAGED_FAST_PATH: documentation and this baseline workflow cannot
+          # affect the shipped runtime. Keep the required status check, but do
+          # not install toolchains or execute the full product suite.
+          if [[ -n "${GITHUB_BASE_REF:-}" ]]; then
+            git fetch --no-tags --depth=1 origin "${GITHUB_BASE_REF}"
+            managed_base="origin/${GITHUB_BASE_REF}"
+            git diff --check "${managed_base}..HEAD"
+            mapfile -t managed_changed_files < <(
+              git diff --name-only --diff-filter=ACMR "${managed_base}..HEAD"
+            )
+            managed_runtime_change=0
+            for managed_path in "${managed_changed_files[@]}"; do
+              case "${managed_path}" in
+                *.md|*.mdx|docs/*|.github/ISSUE_TEMPLATE/*|.gitea/ISSUE_TEMPLATE/*|.gitea/runner-scope.sh|.gitea/workflows/managed-validation.yml)
+                  ;;
+                *)
+                  managed_runtime_change=1
+                  break
+                  ;;
+              esac
+            done
+            if [[ "${#managed_changed_files[@]}" -gt 0 && "${managed_runtime_change}" -eq 0 ]]; then
+              printf 'Managed validation fast path: %s non-runtime file(s); full product suite skipped.\n' \
+                "${#managed_changed_files[@]}"
+              exit 0
+            fi
+          fi
+          if [[ -f pyproject.toml || -f requirements.txt ]]; then
+            # Compile only tracked Python sources. Running compileall after a
+            # Node install would otherwise traverse node_modules and turn a
+            # lightweight baseline into a large runner workload.
+            git ls-files -z '*.py' | xargs -0 -r python -m py_compile
+            if [[ -f uv.lock ]]; then
+              python -m venv "${RUNNER_TEMP}/managed-uv"
+              uv_python="${RUNNER_TEMP}/managed-uv/bin/python"
+              "${uv_python}" -m pip install --disable-pip-version-check uv==0.10.0
+              managed_uv="${RUNNER_TEMP}/managed-uv/bin/uv"
+              export UV_PROJECT_ENVIRONMENT="${RUNNER_TEMP}/managed-project-venv"
+              "${managed_uv}" sync --locked
+              export PATH="${UV_PROJECT_ENVIRONMENT}/bin:${PATH}"
+              if [[ "${profile}" == test || "${profile}" == full ]]; then
+                if "${managed_uv}" run python -c 'import pytest' 2>/dev/null; then
+                  "${managed_uv}" run python -m pytest
+                fi
+              fi
+              if [[ "${profile}" == lint || "${profile}" == full ]]; then
+                if "${managed_uv}" run python -c 'import ruff' 2>/dev/null; then
+                  "${managed_uv}" run python -m ruff check .
+                fi
+              fi
+            elif [[ -f requirements.txt ]]; then
+              python -m venv "${RUNNER_TEMP}/managed-python"
+              managed_python="${RUNNER_TEMP}/managed-python/bin/python"
+              "${managed_python}" -m pip install --disable-pip-version-check -r requirements.txt
+              export PATH="${RUNNER_TEMP}/managed-python/bin:${PATH}"
+              if [[ "${profile}" == test || "${profile}" == full ]]; then
+                if "${managed_python}" -c 'import pytest' 2>/dev/null; then
+                  "${managed_python}" -m pytest
+                fi
+              fi
+            fi
+          fi
+
+          # Prepare Python before invoking Node scripts. Polyglot repositories
+          # commonly delegate their test script to Python and need the managed
+          # virtual environment to be active first.
+          if [[ -f package.json ]]; then
+            corepack enable
+            if [[ -f pnpm-lock.yaml ]]; then
+              pnpm install --frozen-lockfile
+              [[ "${profile}" == test || "${profile}" == full ]] && pnpm --if-present test
+              [[ "${profile}" == lint || "${profile}" == full ]] && pnpm --if-present lint
+              [[ "${profile}" == typecheck || "${profile}" == full ]] && pnpm --if-present typecheck
+              [[ "${profile}" == build || "${profile}" == full ]] && pnpm --if-present build
+            elif [[ -f package-lock.json ]]; then
+              npm ci
+              [[ "${profile}" == test || "${profile}" == full ]] && npm run --if-present test
+              [[ "${profile}" == lint || "${profile}" == full ]] && npm run --if-present lint
+              if [[ "${profile}" == typecheck || "${profile}" == full ]]; then
+                npm run --if-present typecheck
+              fi
+              [[ "${profile}" == build || "${profile}" == full ]] && npm run --if-present build
+            fi
+          fi
+
+          if [[ -f go.mod ]]; then
+            if [[ "${profile}" == test || "${profile}" == build || "${profile}" == full ]]; then
+              go test ./...
+            fi
+          fi
+          if [[ -f Cargo.toml ]]; then
+            if [[ "${profile}" == test || "${profile}" == build || "${profile}" == full ]]; then
+              cargo test --locked
+            fi
+          fi
+          if compgen -G '*.sln' >/dev/null; then
+            if [[ "${profile}" == test || "${profile}" == build || "${profile}" == full ]]; then
+              dotnet test --configuration Release
+            fi
+          fi
@@ -3,24 +3,42 @@ name: ForgeFlow quality gate
 on:
  push:
    branches: [main]
-  pull_request:
+  workflow_dispatch:

 jobs:
-  quality:
-    runs-on: windows-latest
+  secret-scan:
+    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: https://gitea.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - name: Secret scan
+        shell: bash
+        run: |
+          set -euo pipefail
+          scan_container="$(docker create ghcr.io/trufflesecurity/trufflehog:3.79.0 filesystem /scan --only-verified --fail --no-update)"
+          trap 'docker rm -f "${scan_container}" >/dev/null 2>&1 || true' EXIT
+          tar --exclude=.git --transform='s#^\.$#scan#;s#^\./#scan/#' -cf - . | docker cp - "${scan_container}:/"
+          docker start -a "${scan_container}"
+
+  quality:
+    # Browser quality runs against the dedicated bounded Windows 11 VM runner.
+    runs-on: windows-native
+    steps:
+      - uses: https://gitea.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: https://gitea.com/actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
        with:
          node-version: 22
          cache: npm
      - run: npm ci
+      # The native runner deliberately skips Electron's install-time binary
+      # download. Prime it once before Node's parallel test workers require
+      # Electron, otherwise they can race while creating the same directory.
+      - run: npx electron --version
      - run: npm run quality
-      - run: npx playwright install --with-deps chromium
+      - run: npx playwright install chromium
      - run: npm run test:browser:ci
      - name: Preserve browser failure evidence
        if: failure()
-        uses: actions/upload-artifact@v4
+        uses: https://gitea.com/actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
        with:
          name: forgeflow-browser-failure-evidence
          path: artifacts/
@@ -0,0 +1,108 @@
+name: ForgeFlow signed release
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - package.json
+  workflow_dispatch:
+
+permissions:
+  code: read
+  releases: write
+
+jobs:
+  release:
+    runs-on: windows-native
+    steps:
+      - uses: https://gitea.com/actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 2
+      - uses: https://gitea.com/actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+        with:
+          node-version: 22
+          cache: npm
+      - name: Validate version bump and build release artifacts
+        shell: powershell
+        env:
+          GITEA_EVENT_NAME: ${{ gitea.event_name }}
+        run: |
+          $ErrorActionPreference = "Stop"
+          Set-StrictMode -Version Latest
+
+          $manifest = Get-Content -LiteralPath "package.json" -Raw | ConvertFrom-Json
+          $version = [string]$manifest.version
+          $previousVersion = ""
+          try {
+            $previousJson = (& git show "HEAD^:package.json" 2>$null | Out-String)
+            if ($LASTEXITCODE -eq 0 -and $previousJson.Trim()) {
+              $previousVersion = [string](ConvertFrom-Json $previousJson).version
+            }
+          } catch {
+            $previousVersion = ""
+          }
+
+          if ($env:GITEA_EVENT_NAME -eq "push" -and $previousVersion -eq $version) {
+            Write-Host "package.json changed without a version bump ($version); no release will be published."
+            exit 0
+          }
+          if ($version -notmatch '^\d+\.\d+\.\d+$') {
+            throw "ForgeFlow version '$version' is not a stable semantic version."
+          }
+
+          & cmd.exe /d /s /c "npm ci --no-audit --no-fund"
+          if ($LASTEXITCODE -ne 0) { throw "npm ci failed." }
+          & cmd.exe /d /s /c "npx electron --version"
+          if ($LASTEXITCODE -ne 0) { throw "Electron preflight failed." }
+          & cmd.exe /d /s /c "npm run quality"
+          if ($LASTEXITCODE -ne 0) { throw "ForgeFlow release quality gate failed." }
+          & cmd.exe /d /s /c "npx playwright install chromium"
+          if ($LASTEXITCODE -ne 0) { throw "Playwright Chromium installation failed." }
+          & cmd.exe /d /s /c "npm run test:browser:ci"
+          if ($LASTEXITCODE -ne 0) { throw "ForgeFlow browser acceptance suite failed." }
+          & cmd.exe /d /s /c "npm audit --omit=dev --audit-level=high"
+          if ($LASTEXITCODE -ne 0) { throw "ForgeFlow production dependency audit failed." }
+          & cmd.exe /d /s /c "npx electron-builder --win nsis portable"
+          if ($LASTEXITCODE -ne 0) { throw "ForgeFlow Windows build failed." }
+          & node scripts/write-release-checksums.mjs
+          if ($LASTEXITCODE -ne 0) { throw "ForgeFlow checksum generation failed." }
+
+      - name: Sign and publish validated artifacts
+        shell: powershell
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+          FORGEFLOW_RELEASE_BASE_URL: ${{ gitea.server_url }}
+          FORGEFLOW_RELEASE_OWNER: Jens
+          FORGEFLOW_RELEASE_REPO: ForgeFlow
+          FORGEFLOW_RELEASE_BRANCH: main
+          FORGEFLOW_RELEASE_SIGNING_KEY_PEM: ${{ secrets.FORGEFLOW_RELEASE_SIGNING_KEY_PEM }}
+        run: |
+          $ErrorActionPreference = "Stop"
+          Set-StrictMode -Version Latest
+          $privateKeyPath = Join-Path $env:RUNNER_TEMP "forgeflow-release-signing-private.pem"
+          try {
+            if (-not $env:FORGEFLOW_RELEASE_SIGNING_KEY_PEM) {
+              throw "FORGEFLOW_RELEASE_SIGNING_KEY_PEM is not configured."
+            }
+            if (-not $env:GITEA_TOKEN) {
+              throw "GITEA_TOKEN is not configured."
+            }
+            $utf8NoBom = New-Object System.Text.UTF8Encoding($false)
+            [System.IO.File]::WriteAllText($privateKeyPath, $env:FORGEFLOW_RELEASE_SIGNING_KEY_PEM, $utf8NoBom)
+            $env:FORGEFLOW_UPDATE_SIGNING_PRIVATE_KEY = $privateKeyPath
+            & node scripts/sign-release-manifest.mjs
+            if ($LASTEXITCODE -ne 0) { throw "ForgeFlow manifest signing failed." }
+            & node scripts/verify-release-signatures.mjs
+            if ($LASTEXITCODE -ne 0) { throw "ForgeFlow release signature verification failed." }
+            & node scripts/prune-dist.mjs
+            if ($LASTEXITCODE -ne 0) { throw "ForgeFlow artifact pruning failed." }
+            & .\node_modules\.bin\electron.cmd scripts/publish-binary-release.cjs
+            if ($LASTEXITCODE -ne 0) { throw "ForgeFlow Gitea release publication failed." }
+          } finally {
+            $env:FORGEFLOW_UPDATE_SIGNING_PRIVATE_KEY = $null
+            if (Test-Path -LiteralPath $privateKeyPath) {
+              Remove-Item -LiteralPath $privateKeyPath -Force
+            }
+          }
+
+          Write-Host "ForgeFlow artifacts were signed and published from exact main HEAD $env:GITEA_SHA."
@@ -1,9 +1,24 @@
 node_modules/
 dist/
 .DS_Store
+Thumbs.db
 *.log
 coverage/
 artifacts/
 playwright-report/
 .forgeflow/
 .playwright-mcp/
+.env
+.env.*
+!.env.example
+*.pfx
+*.p12
+*.key
+*.pem
+!build/update-signing-public.pem
+.codex/
+.claude/
+.agents/
+.dyad/
+.idea/
+.vs/
@@ -0,0 +1,13 @@
+# Contributing
+
+ForgeFlow changes must preserve exact-commit provenance, update integrity and safe deployment boundaries.
+
+Before opening a pull request:
+
+- do not commit tokens, SSH credentials, signing private keys, deployment secrets or local repository state;
+- keep update manifests/checksums/signatures deterministic and reviewable;
+- add regression tests for repository synchronization, dirty-file handling, update and deployment changes;
+- keep real deployment targets configurable rather than embedding private infrastructure;
+- run `npm run quality` and the managed validation workflow where supported.
+
+Release metadata should distinguish an unreleased package version from the latest published Gitea Release; do not advance public release claims until the corresponding release exists.
@@ -75,7 +75,11 @@ try {
        "ForgeFlow-Setup-$version-win-x64.exe",
        "ForgeFlow-Setup-$version-win-x64.exe.sha256",
        "ForgeFlow-Portable-$version-win-x64.exe",
-        "ForgeFlow-Portable-$version-win-x64.exe.sha256"
+        "ForgeFlow-Portable-$version-win-x64.exe.sha256",
+        "ForgeFlow-$version-provenance.json",
+        "ForgeFlow-$version-sbom.cdx.json",
+        "ForgeFlow-$version-release-manifest.json",
+        "ForgeFlow-$version-release-manifest.json.sig"
      )
      foreach ($assetName in $expectedAssets) {
        if (-not (Test-Path -LiteralPath (Join-Path $clone "dist\$assetName"))) {
@@ -73,7 +73,11 @@ try {
      "ForgeFlow-Setup-$version-win-x64.exe",
      "ForgeFlow-Setup-$version-win-x64.exe.sha256",
      "ForgeFlow-Portable-$version-win-x64.exe",
-      "ForgeFlow-Portable-$version-win-x64.exe.sha256"
+      "ForgeFlow-Portable-$version-win-x64.exe.sha256",
+      "ForgeFlow-$version-provenance.json",
+      "ForgeFlow-$version-sbom.cdx.json",
+      "ForgeFlow-$version-release-manifest.json",
+      "ForgeFlow-$version-release-manifest.json.sig"
    )
    foreach ($assetName in $expectedAssets) {
      $assetPath = Join-Path $clone "dist\$assetName"
@@ -4,7 +4,7 @@

 ForgeFlow is een Windows-desktopapp voor wie Git, Gitea en eigen Docker- of Unraid-servers gebruikt. Je ziet in één werkruimte wat lokaal gewijzigd is, wat op Gitea staat en welke exacte commit op de server draait. ForgeFlow begeleidt je daarna veilig door review, commit, push, deployment en verificatie.

-> Huidige release: **0.10.3** · [download de laatste Windows-release](https://gitea.itworx.tech/Jens/ForgeFlow/releases/latest)
+> Huidige release: **0.10.15** · [download de laatste Windows-release](https://gitea.itworx.tech/Jens/ForgeFlow/releases/latest)

 ![ForgeFlow release-overzicht](docs/screenshots/overview.png)

@@ -12,10 +12,12 @@ ForgeFlow is een Windows-desktopapp voor wie Git, Gitea en eigen Docker- of Unra

 - **Eén duidelijke actielijst:** zie meteen welke repository aandacht nodig heeft en waarom.
 - **Veilige Git-flow:** review wijzigingen, stage volledige bestanden of afzonderlijke hunks, commit, push en herstel conflicten zonder contextwissel.
+- **Veilige Gitea-sync:** bekijk vooraf welke bestanden wijzigen of verdwijnen, bewaar lokale commits in een recovery branch en zet gewijzigde of untracked bestanden in een stash voordat de werkmap exact gelijk wordt gemaakt aan Gitea.
 - **Deployment op een exacte commit:** ForgeFlow gebruikt volledige commit-SHA's en toont lokaal, Gitea en server naast elkaar.
 - **Automatische serverinventaris:** ForgeFlow herkent draaiende en gestopte Docker-, Compose- en DockerMan-workloads, koppelt alleen op betrouwbaar bewijs en houdt tijdelijke of externe containers apart.
 - **Veilige server-pull:** Unraid haalt de exacte commit uit Gitea met een unieke, repository-scoped read-only deploy key en een vastgepinde SSH-hostsleutel.
 - **Ingebouwde Git Validator:** controleer repository-identiteit, branch protection, synchronisatie-instellingen, documentatie, geheimen en grote bestanden; veilige verbeteringen kunnen gericht worden toegepast.
+- **Doorzoekbaar Helpcentrum:** open **Help** voor stapsgewijze uitleg of spring vanuit workspace sync meteen naar de relevante veiligheidsinstructies.
 - **Lokale controle:** configuratie en credentials blijven op het toestel en diagnostische exports worden lokaal geredigeerd.

 ## Snel starten
@@ -28,7 +30,7 @@ ForgeFlow is een Windows-desktopapp voor wie Git, Gitea en eigen Docker- of Unra
 4. Voeg je Gitea-server, token en lokale projectmappen toe.
 5. Voeg optioneel een Docker- of Unraid-server toe. Start daarna **Scan servers** om bestaande deployments te ontdekken en veilig aan repositories te koppelen.

-Vanaf versie 0.10.2 kun je nieuwe packaged releases vanuit **Settings → Updates** ophalen. ForgeFlow accepteert uitsluitend de release die bij de exacte Gitea-commit hoort en controleert de download tegen de gepubliceerde SHA-256-checksum. Zie [UPDATING.md](docs/UPDATING.md) voor oudere of source-only installaties.
+Vanuit **Settings → Updates** kun je nieuwe packaged releases ophalen. ForgeFlow accepteert uitsluitend de release die bij de exacte Gitea-commit hoort, controleert de SHA-256-checksum én verifieert vanaf 0.10.13 een onafhankelijk Ed25519-releasemanifest met de ingebouwde publieke sleutel. Zie [UPDATING.md](docs/UPDATING.md) voor oudere of source-only installaties.

 ### Eerst vrijblijvend bekijken

@@ -39,7 +41,7 @@ npm install
 npm run demo
 ```

-Open daarna `http://127.0.0.1:4173`.
+Open daarna `http://127.0.0.1:41737`.

 ## De dagelijkse workflow

@@ -94,6 +96,7 @@ Een gelijke commit bewijst welke code draait; een geslaagde healthcheck bewijst

 - repositories ontdekken, favorieten beheren en ontbrekende lokale clones koppelen;
 - status, diff, staging, partial hunks, commit, push, fetch, pull, stash en conflict recovery;
+- read-only achtergrondfetch en een expliciete preview om een lokale projectmap veilig exact met de upstream Gitea-branch te synchroniseren;
 - branches maken, wisselen, vergelijken en opruimen;
 - branch protection controleren en pull requests openen;
 - Git Validator met assurance score, bewijs per controle en gerichte veilige fixes.
@@ -114,7 +117,7 @@ Een gelijke commit bewijst welke code draait; een geslaagde healthcheck bewijst

 - credentials versleuteld via de beveiligde opslag van het besturingssysteem;
 - origin-checks voorkomen dat een Gitea-token naar een andere host wordt gestuurd;
- updatepakketten worden alleen vanaf de geconfigureerde Gitea-origin gedownload en met checksums geverifieerd;
+- updatepakketten worden alleen vanaf de geconfigureerde Gitea-origin gedownload en met checksums plus een vastgepinde Ed25519-publisherhandtekening geverifieerd;
 - lokale redactie van tokens, wachtwoorden en gevoelige diagnostische data;
 - versleutelde configuratieback-up, herstelvoorbeeld en lokale audittrail;
 - packaged builds als Windows-installer en portable executable.
@@ -135,6 +138,7 @@ Voor serverdetectie en SSH-deployments heb je daarnaast een bereikbare Docker- o
 - [SETUP_GUIDE.md](docs/SETUP_GUIDE.md) — Gitea, projectmappen en eerste ingebruikname;
 - [DEPLOYMENT_SETUP.md](docs/DEPLOYMENT_SETUP.md) — deploymentprofielen en verificatie;
 - [SSH_UNRAID_DEPLOYMENT.md](docs/SSH_UNRAID_DEPLOYMENT.md) — SSH- en Unraid-vereisten;
+- [DEPLOYMENT_MIGRATION_EXAMPLE.md](docs/DEPLOYMENT_MIGRATION_EXAMPLE.md) — veilig een bestaande servercheckout onder beheer brengen;
 - [DIAGNOSTICS.md](docs/DIAGNOSTICS.md) — veilige controles en supportbundels.

 ## Ontwikkelen vanuit de broncode
@@ -156,7 +160,8 @@ Handige opdrachten:
 | `npm run check` | Voert bronverificatie en de volledige testset uit. |
 | `npm run doctor` | Controleert de lokale ontwikkelomgeving. |
 | `npm run acceptance` | Voert de release-acceptatiecontroles uit. |
-| `npm run dist:win` | Bouwt Windows installer + portable package, schrijft checksums en ruimt oude dist-artifacts op. |
+| `npm run signing:setup` | Maakt eenmalig de lokale Ed25519-releasesleutel en schrijft alleen de publieke sleutel naar het project. |
+| `npm run dist:win` | Bouwt Windows installer + portable package, schrijft checksums en een ondertekend releasemanifest en ruimt oude dist-artifacts op. |
 | `.\Publish-ForgeFlow-Release.ps1` | Publiceert broncode én de bijbehorende Windows-release-assets als één gecontroleerde release. |
 | `.\Publish-Missing-Binary-Release.ps1` | Herstelt een reeds gepushte versie waarvoor de Gitea binary release ontbreekt. |

@@ -0,0 +1,11 @@
+# Security Policy
+
+ForgeFlow's detailed security model is documented in [`docs/SECURITY.md`](docs/SECURITY.md).
+
+Report suspected vulnerabilities privately to `security@itworx.tech`. Do not publish Gitea tokens, SSH credentials, update-signing material, private server addresses, support bundles containing sensitive data or other operational secrets in a public issue.
+
+For a useful report, include the affected ForgeFlow version/commit, component, minimal reproduction steps, expected and observed behaviour and security impact. Use sanitized or synthetic repository/server data whenever possible.
+
+The current release model requires exact-commit verification, origin-constrained credential use, signed update manifests, redacted diagnostics and bounded deployment adapters. Changes must not silently weaken those guarantees.
+
+Never commit Gitea tokens, SSH private keys, release-signing private keys, deployment credentials or local repository state. The packaged signing public key is intentionally public; private signing material must remain outside Git.
@@ -1,14 +1,13 @@
-ForgeFlow 0.10.3 source manifest
+ForgeFlow 0.10.15 source manifest
 SHA-256                                                          BYTES  PATH
-(The manifest excludes itself, dependencies and generated release artifacts.)
-cedceb71eb846d99c7c4019031833c1c7f93b84a1c6073aec7d2435dc744ca3d           703  .gitea/workflows/quality.yml
-4a9e8a955ad8c9fa7ba3f8f89cf9920ac1d28c6e5b344782e12d02c3b0fab1ee           105  .gitignore
+(The manifest includes tracked and non-ignored source files, excluding itself.)
+ec40b1ed8e5152ca4175bbe97be43f0e2e911894112dc6a47c2c348069f79abf            87  .gitattributes
+cc690743121cd3e3a4f12499024456c0b28c4aca4af0f566e57aa9ca87124ef9           883  .gitea/workflows/chatgpt-validation.yml
+037209289e7a387d855ee061fec9b385db57c6a31ee71c770e684f70dcae28f8          5157  .gitea/workflows/managed-validation.yml
+c70a5dd662bc71e91e255b51b1a907939682259af2e27091178ef5ea231cfd77          1896  .gitea/workflows/quality.yml
+e6b76033c44516b625cd9f40e89824ebc8f74ef2a34666d6d44c042fc602c406          4905  .gitea/workflows/release.yml
+83fac3efff45f3dc926080b280ae190b6bb40eb8dae7b8cb5d27255759bc9c47           267  .gitignore
 f14b4987904bcb5814e4459a057ed4d20f58a633152288a761214dcd28780b56             3  .nvmrc
-d0b1bd421359311871224f9fa1cff5a802000933668017d9e42e5190f8d2d8e5           152  .playwright-mcp/page-2026-07-29T17-41-03-014Z.yml
-528fe408ad4b49c621dd57dd831cecf7ec00b8865069f6ed3b80fefc2e0b7823          8267  .playwright-mcp/page-2026-07-29T17-41-26-269Z.yml
-804c6dac953c5094671784919ff35ebda756306a04ef34fe01cd7cf7cd50b2dc         16909  .playwright-mcp/page-2026-07-29T17-41-46-590Z.yml
-0f17fdea98e15ebcf7f3ed356d31b0fc89be62f7bc1d25b26c8a41e4b5deca68           160  .playwright-mcp/page-2026-07-29T17-47-10-112Z.yml
-5f348bcf74baa845958884bd2258e1ce4121d386c945777b0e80912602e5b5f6         17227  .playwright-mcp/page-2026-07-29T17-47-19-366Z.yml
 89545860bd6f7566da81edc8328cd2a1ebf33e81a4b0dcf2cec74338c05e8cac          1753  build-windows.ps1
 0970821475a4452aa19e447e9397a95db836791f16890a1a83fd748ac033dc86          8830  build/icon-128.png
 09112c1425ca953d8dd8b2bcfd221e5a84b9f81752f7168f360e295030cbc8f2           521  build/icon-16.png
@@ -19,28 +18,42 @@ ca32a76e708d565c4af659f0f4d2615fc32114c3f75aec1454862a3ed1e72c41          2263
 4633990a4b055bb3d00fef915ee29e85be5ee8413f809334728ad9688973c183          3364  build/icon-64.png
 25048ed854e8ce8fece115e555c98d25507b002f8019b6ae717b54604c868c50         46223  build/icon.ico
 16efd2fca83004f781eae40ae0f706a004ce0bddf338dd087b8adf7eb10c1d84         85704  build/icon.png
+164c059453a5737110b4e5e98b6211650c757f0aff710f8f7523ffe0ff1815d7           113  build/update-signing-public.pem
 5f4aca19a35cbcaffa1a6993ce96b7d66052ec2b286022f2af74594e8a310568         15712  CHANGELOG.md
+3754dcaa776ead5dc60b4955ed4294fd8580577ecb9ce29cb0d9fbbaf9253313           811  CONTRIBUTING.md
 c612fcc44ff222db0c9a4cfd11a4076fafe080e4ada31e689a08739a4f14e74f          1650  docs/ACCEPTANCE.md
-a17f95d96d3c9fbc69d870874e6fbb7472091adefc454b24f835db1279511d72          8296  docs/ARCHITECTURE.md
+3785ad21872e3dc08fde9ef819e26f42161ba6ce6d235f87fcebd7859dfaf148          8293  docs/ARCHITECTURE.md
 e05458ee2696e3c57e2475bb42ae1f914f6a36e01768d7a26a3199f1fffed490          1157  docs/COVERAGE_POLICY.md
-b9e39748ff125031be0ee8a963ef0d457c342f7998113fc2dd042ec237ae32ad          3084  docs/CURRENT_STATE.md
+9eb9eec82518c0bfc7686f5faaf690a93ed63c71d35f1dc5a2c5ec5199da652a          3124  docs/CURRENT_STATE.md
 8ea655d1912ac2e17f8834e33a566a8b14461b396ec4268c396ca189a1749b94          2205  docs/DEPENDENCY_AUDIT.md
+3b9c301313a6406c39ec09f5ad7247dafdf47f6c21505ab8970b206cb1734f31          2788  docs/DEPLOYMENT_MIGRATION_EXAMPLE.md
 30a92bcf5daadb019efa2f82cb820ea302490dd1d68fb772674dc3faccd3e594          2045  docs/DEPLOYMENT_SETUP.md
 eb42f979666e05d51c587e4223282914926a2b9b1ade9f3fb75525019ce7f738          4616  docs/DIAGNOSTICS.md
 1d8aa3c688a9d330b9a5303b09e9e3049c50bf04f97807c7ff659607baa34c32          1464  docs/ERROR_CODES.md
-a0cd06a96f23a94e118feb012be0fa1ac51345951cb2ba8e67fb8c889c4c342a          5007  docs/LUMAOPS_SERVER_AUDIT.md
 648dd6bca6b45668fb86eb3e1f6c5898dd8da0291b990f1bb5105cfd79421343          1301  docs/MUTATION_MODEL.md
 8dc95f69e6f6c8415702c8e79fb6b466c4d60061afded9140450e7e558eaefe5          3704  docs/PRODUCTION_READINESS_1.0.md
 f79908fb3dad98c38030c6e6be7c79a1999e0478ed9c2496923891954438daa1          4581  docs/RELEASE_AUDIT_0.6.0.md
 979a0b8e129979be6b265e8571d0a3c1e9ddd4ddb6b0bf55ae748d3478e51854          2296  docs/RELEASE_NOTES_0.10.0.md
 0eb44bda2209a5979a6ac693ac4cd4d235c0015031e54b9e895990f37bf60054          1433  docs/RELEASE_NOTES_0.10.1.md
+5d3240169765e3fb1d3cd391d09547101227e76dd4670ee46be8ca3a21553a03           894  docs/RELEASE_NOTES_0.10.10.md
+36edb4f096a248fb8679bd13e5766befb478cf628c6ccfb21e3eda71bbec7633           992  docs/RELEASE_NOTES_0.10.11.md
+a355d3f577c2ec85dde5dfd7b6995f4f1615e2f6bac597529f3ff102acd93c35          1292  docs/RELEASE_NOTES_0.10.12.md
+609c55a1c0b06c307ebe16f2daaf1e48601edd57137586e4f2be1febd6a7060a          1931  docs/RELEASE_NOTES_0.10.13.md
+1d5832048dd834a773ee8f34e6599c590373358132203b022b521dd5dde2f179          1571  docs/RELEASE_NOTES_0.10.14.md
+055ad0c73f0854a708eedc3bc4e9dfb991b4e6021348c05484da9a47022e995b          1871  docs/RELEASE_NOTES_0.10.15.md
 8d713471a437a8a55b00d7e1dd95290680862107bc4e586cf27d727f6274e46c           577  docs/RELEASE_NOTES_0.10.2.md
 0942fb2c4a4f972296423b5232687f7389e2c6417a9d48a3244beef9dec907b9          1164  docs/RELEASE_NOTES_0.10.3.md
+8f4a0fe6dc250ae210cc2fc1c57c46091822ae6c2a58caa76e0091f255f9f30d           775  docs/RELEASE_NOTES_0.10.4.md
+05ed618f5a74a854363930128ca98939808517eedd28b9a508660a0c46e91d97           884  docs/RELEASE_NOTES_0.10.5.md
+94bfb2783c1befad1197e1c5e32fc002222c94a28d70d48360a8d53ecd260d5c           772  docs/RELEASE_NOTES_0.10.6.md
+226a3b2d4bc7f54841749a283fcdd71b643cd585ba74d673084bee829fef6ea2           903  docs/RELEASE_NOTES_0.10.7.md
+4be29ad0cb7ebcf5625172b8d2bd7a67cdc6d64d3a94e2c3f0656cdfd42dcb7a           642  docs/RELEASE_NOTES_0.10.8.md
+fb64517aa64d3ecfe8b51b09e198c2c9fbba96d0cd24a87301c7f6dea3076095           961  docs/RELEASE_NOTES_0.10.9.md
 a0c00ff76acd1682bb5e0e8dcf6589c9480da436c9c6d30780a1ed58b4dad94f          1770  docs/RELEASE_NOTES_0.2.0.md
 5773ead01aa4c522c556295553787482d01b1f5242f053b2c61f120c4de4fa76          5963  docs/RELEASE_NOTES_0.3.0.md
 d46de73cf6c4cd5c2ba3f455a7a2af2e0d64ee9d94a97fd1a0bfb44e35c1624a          1093  docs/RELEASE_NOTES_0.3.1.md
 0d697d241a08d2427a6e7f5c2f27bd1830a41836a01e08eeff239c7ad5d89982          2445  docs/RELEASE_NOTES_0.3.2.md
-bc6933c303d3d9b3bfdbf678cae1a717bfe5a893780a1871af8b48589f62f0e3          2160  docs/RELEASE_NOTES_0.4.0.md
+df07794fb3923f3fb6a49dacbfcc5a371227edb592b4e86ecffaae0a8799f187          2154  docs/RELEASE_NOTES_0.4.0.md
 343862445061e1a8282a7aa9b2304e7d799e58f9956d50eb5352db18d790efad          1134  docs/RELEASE_NOTES_0.4.1.md
 e2d67c816a919f00f9e26bf59cf29e5e8cf894536b743d282075c646c5accc96          1605  docs/RELEASE_NOTES_0.4.2.md
 1aef74fb109541903c4dbc4d9c48d2bd63507420eaf8cceb31890797a5e4f5fd           670  docs/RELEASE_NOTES_0.4.3.md
@@ -70,7 +83,7 @@ ed40e08bac8792f95970bc05e49bce3cc9e288a08d11565a1bd156d787360a3b           720
 25169225d73d22b9d884ab3b5c1625f03fd44e53c7a7a4c4067775e80482c9f8          2182  docs/RELEASE_NOTES_0.9.3.md
 720506842e0aeb30c9fc635f86a52a5545556f092e678cf37f08436243244c3d           933  docs/RELEASE_NOTES_0.9.4.md
 dd90c81a375f97dfb7fa8f7808db03b19d7e7dafe3818a93537397f57eaae829          2109  docs/RELEASE_NOTES_0.9.5.md
-60cb1f1ed55322b519236dde8388ecf9ee5fd67c169fd8093b5acf61387557d8          2068  docs/RELEASING.md
+1bf75f25d704dab0c6bc56c639d259f34523f0fb46718dd5a8419a59911ad2c3          2242  docs/RELEASING.md
 ac76cb50fabde6a00f28d7e9eccd3ef1129a40665eabdc90d78690a38d424652          4195  docs/ROADMAP.md
 1ccde232c060395d7aedce27e89a7647b77afe28ab71de0a5a3efeded57369d3        140415  docs/screenshots/deploy-confirmation.png
 b39506254ffa2c73c389fb4795b3a745368bbeb7d8514cc47a636316d6d9a6aa        107166  docs/screenshots/deployment-run.png
@@ -79,152 +92,167 @@ ed69b8beb948a2cf9a6deb6c82368e2bb44ffe8d8990a900dc878b0938d1084f         95937
 3868ab978de2a7945761c53a9a718aecd54dc791605d07660bcd5cad62a33ea8        103569  docs/screenshots/git-validator.png
 007681714895ac062c980db1dda806ac17d4f01019ce9c46491a108d17c2dbda         85338  docs/screenshots/overview.png
 1f78414b00ec100af2ec9bf5c9a3e400b6c9bf6dca6fcc317fd951789acc4536        112852  docs/screenshots/repository-workspace.png
-158cd3a13e9c4d081a63575fbafc77e0b23812f793a15096888b3667f41fa28c          5605  docs/SECURITY.md
+5cb9ee0e33a06db1796a740f12b0c41b917c68c1ae7cdb0070936a99c61c2c64          6036  docs/SECURITY.md
 32a34ec13a284d3f9ceebbc107b25a844e3db096f8cafa4e43951fc2050c9a03         13552  docs/SETUP_GUIDE.md
 2fd71e9bcaeb4cb10c3fa2496b7e52fedf70c5b7f871cd587e22dc060c399079          4421  docs/SSH_UNRAID_DEPLOYMENT.md
 b6a178215dab054006aae4944b8ffcbe7f6100691c30f08e221e3a2dbff4cd42          2147  docs/STATUS_ENDPOINT.md
 0adfeabb98168a7fc0b02bae8d4af436d3c59459012fb05b2216e02265190128          3139  docs/STITCH_REVIEW.md
 4983414a980075e6faae687b0d71c8e57bfe53fcb4cadb8b979b8abca636fe95          6654  docs/TEST_MATRIX.md
-dbbd9fa96988e7543e98c85da864adaadd3057815f18d20a3b3ccb5c540a169d          4558  docs/UPDATING.md
-4bffda594058697345569d937d7a524f094ac85a0f338f0ef18fcf3f94d8c299          1292  eslint.config.js
+3c34d42088b18e37d18afc848f91fbe5b74134ca74dd53df1e9eb30753fae750          4433  docs/UPDATING.md
+73f094a2f0db3de053e515feb2771cd5a4f3aa4178f2c5f37be01ca65ff1c938          2705  eslint.config.js
 c230b931abf2293d2d44b7a69b94c35f1142c093cc46b88739a0de5cbd6d1896          1532  examples/gitea-actions/deploy.yml
+5d2577d4f9f635a12dcc8795879c079b9e66630bb3d96e21510ef7ee13ebef05          3319  examples/gitea-actions/forgeflow-approved-deploy.yml
 4c792cc9fd57ed36da291300c252a6ef75b08a249cf6f2561e23c4c22522138a          1477  examples/gitea-actions/rollback.yml
-577f3fa2131a3baa84549a6523f5816ef9da94f5bac6bc274d4588b6e7ab6594          5688  examples/server/forgeflow-deploy
+4a84041fcf2d7f36d1807e2c19d6cab816f9635112756a675f32cd24d9757fbb          9661  examples/server/forgeflow-deploy
 4fe3eee5c2d8705964c24b8c4dd909883a05e7d6eb85629c84b0d64473e0a92b           258  examples/server/forgeflow-runner.sudoers
 0423fe2cc7f43fe793986a3f62a395668897cdf07348756aa7742a8cd40ac51c           569  examples/server/forgeflow-targets.conf
 106538d4a14a5a7b13419f9520c582b19809e8fafe2cb8c7dce2bc3e600dd10a           397  examples/server/nginx-forgeflow-status.conf
-2dff25fb39ce8fc7844026a50524b23f241bec5b614eb05371c7f908a080f69a           398  examples/server/status-example.json
+a0de3fe4e09b6f246e1513bccc170334e60f63f98c24377192b4335cbf16dff4           593  examples/server/status-example.json
 4a561ead5ba7cdfaf4efce91842a4308c5f2a77980205879d83835efb8a579db          1067  LICENSE
-1f0f388df4397e548887bbc7579fd3c864581b86469c01703201ece7a6cbf931         13667  main.cjs
+e2daa28bbc01c68c3702add6ea8259dff5920b22f6fdc3c9193ed78a153f2e9e         14708  main.cjs
 91a984a89dd57a084b9a2331763cacdb061582fb590f13df379d92c1a77a2ee1           352  OVERLAY-INSTRUCTIONS.md
-672410b1af3900733c067cf29ecaffb96a33500ccbd597bebe999e0c06b161e0        179806  package-lock.json
-70d4bafa0f9633bfdef297bb2599c90ff224cf10b69134ad74c77ee574ce49ce          5436  package.json
-2a597a5704c576783b8a72407fbc377fa7506b36a4596ea7f7bce126e394f837          1326  playwright.config.mjs
-69318fdf054be7aa2fe86ead9847da9da65745d8d5de548c8346f3ba0afc4892         12175  preload.cjs
+63d403ada205000a0dfb158ec57cde1a4f58572d790589428ab5b00a99b32cbe        184860  package-lock.json
+ae06416348c2039eb4cafbf287c99342e04176bbbbb718646f160ff29b6af42f          6464  package.json
+1237df9ddcbb5ac7dc4316f18c34ff4a7030e3e0d56216ade6dd07369e5e2a04          1353  playwright.config.mjs
+7b0d173d0cf5a7f8db807580492bade379dba174a271013747f9f28a3793f55e         12409  preload.cjs
 abe5dd6fd68f2970cd19ef134094907c67219061d8fe9a1a08324c78de4ad437           484  PUBLISH-AND-ENABLE-UPDATE.cmd
-f018383f755352ca448e2ebb1e19b1dba412a3eb793d61e64b02953e300754fd         10538  Publish-ForgeFlow-Release.ps1
-688fff7d2c989adb97ebb7fae38962656b70304a0aa5d27433c56adf7f136de0          4196  Publish-Missing-Binary-Release.ps1
-9e95c2fe6bca120bd2f7502afe9cf9d6a2aa0ee128261cccc955dd9b94ade833         10313  README.md
-1fa7bf646321e07e40d98f4a7529d5f748c600edd5283f62ee13574b4e97280f         14329  reports/architecture-audit.json
-c1ff18f1367691332b189bb7589843a5e0bbde4817e3dd29df4ade7ea71dbd52          1114  reports/architecture-audit.md
+6d0858d6654c3c3dc7083ebbd234c88324afcebaecd7b772719440a8afbc2e4e         10736  Publish-ForgeFlow-Release.ps1
+33f3c4795705ab77c6e6603c88a32c123b3a286bc77e8e472b76970485699338          4386  Publish-Missing-Binary-Release.ps1
+5d9f13f34c9a9cca77968e472f1829147e51d3795779fa3f766b04cdd54fc698         11437  README.md
+0f1bf0696ca6a3de7c222a935953156cdd1bb0aa27f2215b8000901c4db2be31         17255  reports/architecture-audit.json
+6c50c58f464e2f93fb7255a59d6cbb76354755f63c6f1d4ff14a9a88c8c54574          1758  reports/architecture-audit.md
 509c7bcff5280349bd9f45ed6151f70372bad7010a9ea582c13e2ccab91fe0cd          6272  scripts/acceptance.mjs
-00d57bda5af8c8eda294b72d18b318f024a307b81b0d9205a0821f5240151e31          3814  scripts/apply-binary-update.ps1
-f8359a69d20deb2dfe10042d1bec7b12a95e76e58e36bc5f265f073c3111d056         10287  scripts/apply-source-update.ps1
+5f220dc8ee24d2339aa3eb696ac7a5bd6f55c993b5fd9001ec9784788f2a6e46          6747  scripts/apply-binary-update.ps1
+358d0ecbd50d8ba1ff9460c761cc2a1990fb27104d6ad74104a8800877343e19         10954  scripts/apply-source-update.ps1
 02e924227f6cad3777fd06660230c85df590d8ce95e134194a4d18970a240b88          4145  scripts/architecture-audit.mjs
-4490bed84761f76e1fd87ee3117fe53e82e60b7760329c97d68772d6d820ebae          8521  scripts/audit-installed-deployments.cjs
+47a5b16e95934bfe510c18bf94547ae65acb980c0f0506ae156d1a486dfbdfc9          8985  scripts/audit-installed-deployments.cjs
 6d46dd6826069d842f20f9f22a99042257db936cdea0bee8d294d2d7ea290126          3893  scripts/doctor.mjs
-0244d42896b8c44f734d0bb6cdcb29b5981342be2f070ce89f8d9eaf3e4d49e6          1793  scripts/generate-source-manifest.mjs
+7b483476ddd909b085335cb78c9b0ffe71939c50011b5fbfcfdef6a340fa7ce8          2032  scripts/generate-source-manifest.mjs
 842436680521311594e798848b050ae4e488d0595f0de57315f6ec081c049fb9          1266  scripts/prune-dist.mjs
-b83d443f5724ac15393567f3a688aed8315fbe3e5966832c864a9466e0669464          8102  scripts/publish-binary-release.cjs
-444b397d515d65a7ee59d3088cba869cbb812d2b8cc18fc5d255105e3edb58c2          1468  scripts/serve-demo.mjs
+19417a26a5af967b0f057fede45d1811a6d8ad65a0ed49ad4f5865f598457168          9358  scripts/publish-binary-release.cjs
+558ff442988f1396c174c7161ff5bd3ef0b2f43cfc31459ec7c3967faa146bc3          1694  scripts/serve-demo.mjs
+288c4b93f6006c0b32cdf90555bdc0d1d3b61d24a8763fcc30f1e6425ce1684d          1713  scripts/setup-update-signing-key.mjs
+431d3d7eabf7e2ea2d5cbb96fb0ddc13f26d85afebcb9692f3e30242197cbd8d          2607  scripts/sign-release-manifest.mjs
 c76507857292c5713e1c699cf02e24b80265da39af2cecd148034bdb874adbb6          5246  scripts/test-authenticode-chain.ps1
 4393f7dc5f417e6d601a68238f4e26791799a3634acec228fe4d79deaee85eb5          3109  scripts/validate-installed-connections.cjs
 e6127e1e62f39c70ddb1abf72f4d7e7b8e3f19ff1f219e1a3660353c2e0cdfac          2411  scripts/verify-release-signatures.mjs
-c1763bad24b747051ad18d911ba9c7176882663e3b6ce9921a2f8b1aae056bd7         18156  scripts/verify.mjs
-0b9f03ba3c67ff7cdb2916a902ad8ce25e81a7c90b210e4ae52d2ad029efabf3          2353  scripts/write-release-checksums.mjs
+2187f4a6e5f162b428f123960c8121f671218e1164327c1b4f21bf45a4477d01         22686  scripts/verify.mjs
+c2c9e4ba251d93a530a52b2d0079787680261c314083bb99d2356fc177719613          2434  scripts/write-release-checksums.mjs
+c8780510ff6e77a16e9c4a88c3c981a0d9d1a4dff8eafd16afdeefbb4b03aac9          1064  SECURITY.md
 619515f524cb89960370ffcbd3fafd3c0e178b95f69c5868b1dd44777f23ec1e          2081  setup-windows.ps1
 dd613d04b366f2cd071a1685a414016a5fb008082ed1b4cb8b24b79c100f640a          2412  src/main/audit-service.cjs
-92856d698d0a5cc0a3e112e9dc05eb6de473809e9f82e7b08dd21f13f4ec1af8         32309  src/main/config-store.cjs
+e3af59fafa497d032541979bea5fe2b98187b1ced619c567d15ae79ee0904c1f         34629  src/main/config-store.cjs
 2fb04b1494b39f5d7c0720fa5fd298cd46fa85dc1b696d77657592347fcf1819          2731  src/main/configuration-backup.cjs
 86e9fc2eda66b4b563f6c4bbb87d3e8514340d484fb503b73137e63b6b05c3c9         14597  src/main/deploy-key-lifecycle-service.cjs
 7cbfe51973d6607203cb197652ed7f296a3f6b6b644df876957117866a47d802          2159  src/main/deployment-identity.cjs
-9d0af5074093108a5248d0dde0ff70a666748e61f1954b630886a81e8f34072c         24079  src/main/deployment-service.cjs
-c157640e76d558906a9aa9881eda811196623ef1c65fa3467f32f0f84b0ddd0c         15095  src/main/diagnostics-service.cjs
-a2ef47d5330095b92c2bd22fcc39962091881f9cb60d02e261eb1dd1bd693170          1974  src/main/external-tools-service.cjs
-0b7476c2cfe1872601978c20a466c20fe58be35e81b2303e38a753fea62bbc27         32548  src/main/git-service.cjs
+ce30ddac403d1adf21176e5df21b0cc3db435305d2628f51f1486eacf20df6f2         23708  src/main/deployment-service.cjs
+cc2dad2fdac386d41c37b1a8657ae2b3b4084fd8f35a97f8600c082c8d017552         16475  src/main/diagnostics-service.cjs
+7f452dc2c0e6f3a00eecf6cb1c2be75906ac40445ef3e104341c0c67208aab2e          2397  src/main/external-tools-service.cjs
+76fdc5576dcd6fdb88921009d4a923854650bd5efe5b837cd7438eba0dc733c8         48002  src/main/git-service.cjs
 e28fc1ca2fd4c0116148f5005d793feddf04c36ef711d2d348560394d209a613          7253  src/main/git-validator-policy.cjs
 3a101b63ad3761c26350c2ac0793279a0b27672b91a5b1d8dc75bc44d92f0b52         27128  src/main/git-validator-service.cjs
 3cc53e24e023aa0d8bf36c35ce9672ca98e6c74066512c8b59ab42274e838c22         21307  src/main/gitea-service.cjs
 2ad3b2e647377f687ad987fe248a142ad399ecac98e4b49965aa7efc6093e5fa          6914  src/main/inventory-classifier.cjs
 dafdb09133d2b6ec2161a3f0b09354551e54fc606c8107976fca37405643be91          3404  src/main/inventory-review-service.cjs
-00989577aed509a7ddfdf9f4df09a196a393a85b5ea59b21089002215e69f065         25949  src/main/ipc.cjs
-0eb1cfdcd3a37a0ec9502bf753966f87230c03580335798bef9265add42ee6fa         12530  src/main/ipc/deployment-handlers.cjs
+98b332589f86a4874a8adddc38e7844a4ddbe9360d38f9f77b2e95d58d748016         25720  src/main/ipc.cjs
+26efebb4c147ed560966e7e60e64a013b3476327b3bbdb4e4439949142fa7846          2250  src/main/ipc/channel.cjs
+748cddf497b4c204e5e6fa1bd049991a086fdfb38afe342e6b3617c85a111478         12467  src/main/ipc/deployment-handlers.cjs
 dc9b5971c9fefe8c374aa31916f5513601ce86003fd48b1d0e51330a909ae3a5          3442  src/main/ipc/operations-handlers.cjs
-629b0f4704cda6ed6288c5a6ec9e5d73d6ae3e2692c43581b258431b65b58e51         15887  src/main/ipc/repository-handlers.cjs
-62f2c80c8210e19370b8556b1f296cbae50dae6b758a39e209f8fb461691fd4c          4235  src/main/log-redaction.cjs
+8072252821b1245d121eac534a18eeb64f0d7d18429e272e21a6e90b010005b9         17272  src/main/ipc/repository-handlers.cjs
+fc7156aabacb3e85a4f220c490f94e9836e07fa5350a1d9e64f84f835ef51024          4961  src/main/log-redaction.cjs
 958595a99fb242c127f475f3d8622bdba4c07b2d658703f69fe3992227a9107e         12909  src/main/preflight-service.cjs
+720c4a0c554f46386d87c3ab6607d1fbcae66e50b69483c7dbba169d5128c851           680  src/main/process-error-policy.cjs
 3096b4181566cb93a27e56e248c92105d4f4df5aee39d73c6c7d8ae8c2231bc0          1570  src/main/process-runner.cjs
 e64f7257d478955c675a133b3735b6afe138a69d2ad090898061e56f557c43e5          9926  src/main/production-acceptance-harness.cjs
-fc7a5a2a42579a311f60a96bec4776942bf3f63428928820029b0dcf4874d1aa          2745  src/main/repository-monitor.cjs
-17e2a53f61cd7faba461b9f332967143087eaac95b72001462292976278ca305          7782  src/main/repository-service.cjs
+27bd6621c731545ec46d8914e9408c89928a8ce563b40eb4bcd8a516662a54d1          8716  src/main/repository-monitor.cjs
+6393583911263575c6e2a19d9baab6e638cce90252c386b0a5144f2fb6f81f15         12154  src/main/repository-service.cjs
 52b6d88ed1f5c904a13cdde92e5f96d1e2b5971ceef49862152197353cdc6490         27928  src/main/server-inventory.cjs
-afef3841a3948b2121f8fba809aae4ea3da71bd2fda86973ba50200a5b1f89b2         14894  src/main/ssh-service.cjs
-90504e27bfabcd2f927ba29930fad9bb65520fdf871a2a9e49cbcefcb837d84c         25492  src/main/unraid-access-methods.cjs
-2ede80cd1565a7f2c282cc58d35dc0889d58d7465346bc723026b9c8be4df0ac          9501  src/main/unraid-deploy-key-host.cjs
-803a079499f7b8148495209dea43b505f6eb9bb587de19e82054e47183186c6e         30461  src/main/unraid-deployment-methods.cjs
-2e63fdc0be0bf4d8e5c3d7d45ff5811d786b0821a08b82f511f1301696e12c9d         17157  src/main/unraid-deployment-service.cjs
-f0861356c1ff4ca361c7004c1f7d935858f51cc74335a7ad2136021f2e612220         36016  src/main/unraid-inventory-methods.cjs
-9e682411f73450f595b5cc4dfb28939c6c58b9547d0a91e287c3efb4955e8840         26299  src/main/unraid-preflight-methods.cjs
+793003566823e1d5c02283f583888ecc07e44477525620579b3d858f488b3c08         22347  src/main/ssh-service.cjs
+19538a3c40ea3489bbaee9a23af36a5e99962af6bb3d04259f05ece6588cbeb2         25901  src/main/unraid-access-methods.cjs
+5621e35323e4f81fb14a05670f81579ec1e66bea3a55fa6457ece0f807421424          9801  src/main/unraid-deploy-key-host.cjs
+6d9910dace52625f88e066a8485af2663c3735ff15e9ce9031441ce742710a21         30793  src/main/unraid-deployment-methods.cjs
+673b1692e7c2b5197545df98750b5d048bddf44206263e25be4f17d9bf900e2c         17208  src/main/unraid-deployment-service.cjs
+bb4a99c3526fcf4db4fbae88a058e8598fd10a87990e7d502bfdc765328bdaa1         42766  src/main/unraid-inventory-methods.cjs
+2c0cf07921ca7ee5a9085ced44498c2e6798e5cc1e8a5ecf704c3cecabe39a25         27607  src/main/unraid-preflight-methods.cjs
 d45220176aed72d692f9ae5534f9d40bcc359a2d08e025e74a3b3b505b8b9ed4         16559  src/main/unraid-runtime-methods.cjs
-d4b3a07eeca687a49544a94ea574f7c6f7e0bc3aa9311b614d5244a468ca4a1b         11307  src/main/unraid-state-methods.cjs
-b654a9e45044ad32c61fabe4a6d897288615ec83739b53e3241ff881e32f56bd         21677  src/main/update-service.cjs
+4c5cf01922e1feb36a31b50af22e973d8aee3fecccd406e449690604111898ac         11608  src/main/unraid-state-methods.cjs
+29b8c5eca83b0e89c7d0716945b5316aac43947b5387e89562d9a024ebc4663c         27204  src/main/update-service.cjs
 b5c304531bec358d059189a27cd9db8fa20cefb7f817e5eb0287001f7353f6a7           985  src/renderer/actions/command.js
 d0bf607dd1de9d55f2947d0adf0997cd3ca5c269d10a5362cc1d8bc4d1a2a8ae          6706  src/renderer/actions/deployment-operation.js
-0f2070aa3b5c404aedf643837dfd7c5d547e8f45b2e9c97e4cfcf11951555474         17705  src/renderer/actions/deployment-profile.js
+0db283b1a458ae0b31538940b1ddc931ffdb53bd04ceb7fd8903813f9200d071         17978  src/renderer/actions/deployment-profile.js
 48bed91dd2a85bb51ee7307f7acc3b79c881ce8cf63b22ba79d5d079b265eb4b          7785  src/renderer/actions/inventory.js
-4227a05a20580a31127d2c929640defc3d36e8e3e89d6be830aab1940da81082         12267  src/renderer/actions/recovery.js
-cdfaacdcd5ae04b0e5c79fefa21f5e09d5c810bcea504c5b6e1d6b744182ff84         15567  src/renderer/actions/setup-and-settings.js
-5d8110918b2957889047e38eb4ab2953b2b4476394d9328bd40ae6e4246e65ef         18584  src/renderer/actions/shell.js
-edcfa0585af4b11ec3b7458969132bdf215830505859f1519f1635dc111ce48a         24333  src/renderer/app.js
+9e8adf1ba89ffc61a7b595f813c784688bdf50daa259204d74b2cdaa81650895         15493  src/renderer/actions/recovery.js
+2414a0d29a0380d343b9b0e58ba1909e7a7eeb46357fd45ddbb3ad411d119f78         16280  src/renderer/actions/setup-and-settings.js
+058722de35ba33bfcfd29d355a75e1513a2be80c572773472cf9816dd13f894a         20148  src/renderer/actions/shell.js
+0d48993bc26ae28bdab5fbfa8d9be4ef896efdb9a5c34094087721e4274593b4         27566  src/renderer/app.js
 16efd2fca83004f781eae40ae0f706a004ce0bddf338dd087b8adf7eb10c1d84         85704  src/renderer/assets/itworx-mark.png
 813b8cdeecac43794166f3db9d3c5d2c441e0292f9ab7bd465ba136d6201e95d         82476  src/renderer/assets/itworx-wordmark-dark.png
 094c1b71cc2482a9db250ac175f45f3de68f53277dfbde371a03e61923d00988         75240  src/renderer/assets/itworx-wordmark-light.png
 813b8cdeecac43794166f3db9d3c5d2c441e0292f9ab7bd465ba136d6201e95d         82476  src/renderer/assets/itworx-wordmark.png
-1a577af2459715cf38d49d118da8c5f897a7ff1d3eb42ad41f121675eb871732         48389  src/renderer/dialogs.js
-eef2f269ba4fbb76bf66ad328d481b461255d0acb753b30878dd4d4eaac57dc6          6924  src/renderer/events.js
-a84da5aecbb16ce7983dba1f6d6aab1bf47b2e9a87c2933fa1afb8123f7ef7d6          1497  src/renderer/index.html
+f826ab1f2f35882c59995497219fcfd500e46a94dac0906ee47fb732e8023fb4         55633  src/renderer/dialogs.js
+dede1f21a06c73a2c2a462a869d27530d85f99baff202a2eb509c57436ad6aec          2732  src/renderer/diff-view.js
+b7698de13b872aa80d27b0a4d977c12ca2303b2246f05e6af4223db9b727e525          7433  src/renderer/events.js
+c4a71213d412166093f7bd8254b847de4d8beb58c1aaa356a0cdc8d728080326          1524  src/renderer/index.html
 06180d9656dd254edfb6949c397f8e313954fc560ddcb22b3a35fce3c3e35655         21350  src/renderer/mock-bridge.js
-9fa522dad0088e2981c4ca5c392e93d6c92e04ff23fd1083d9040a3aa52d2b55         28101  src/renderer/mock-deployment-bridge.js
-948369ce1bfbc31becc95996feabccd6ae90c6297217f04149b78bd323d279f7         20032  src/renderer/mock-repository-bridge.js
+870024aff376826a92c9cf7452689cc1ecc5d9034f055bea56734f3f7fcea5e5         28703  src/renderer/mock-deployment-bridge.js
+ee33d1a77ab7152cb4f3dfbb611011f755a69ba1afb1016a28c997fcfdca97d6         25810  src/renderer/mock-repository-bridge.js
 94fa265c2fe9ca8d644f0ce9b620b6f85d9b25dca5802c4e9195b66dcbe80120          6522  src/renderer/operations.js
-6776e0adb690b8f36274bfc5b31e3140054893c46ba64621c4f56a0d91b52fc2         78323  src/renderer/styles.css
-1703e64533b7e2717b27c5776296c7dd76331e6f97e8005aea9fd688f1aee3ae         94834  src/renderer/views.js
-0a1e9d9d6cd4d190eb7f85dbc6668d80600b1cf2749cc0c2c51cc428f506f20d          1121  src/shared/clone-target.cjs
+9299c83e43eef194bac2946c43b2ffda6309ccbdcc5b9ce1775e668ae7f172ef         92319  src/renderer/styles.css
+9ee96e6267d923448a45eb0a02d5352286400f2d7b4a006ba681b6806f2e1424        113808  src/renderer/views.js
+e9e72c072a5c5d04f59cd6763de0cfbf736c2a5ffa2f722143f3bad2bdbc630b          1411  src/shared/clone-target.cjs
 5d425d5c2f939d0f6beebee7ebb0c77146cb7e318535ba7286ec7081a4dc2269          2497  src/shared/deployment-policy.cjs
 029e600229714d033c28e2dcb77817aa8269847001782ae0012960e83ffd183f          3057  src/shared/git-status.cjs
 2778ebcbdf60fdc1cb0749f15565e0e1bd66f3a0d31eb70ae7942a7511a3de75          1295  src/shared/repository-match.cjs
 c7e120ea53c5ef3c01b8cce71afe913f34bb461bb73aa3ade24656e09f99f338          1152  src/shared/semver.cjs
-8791d3813e6cf285ee6aa49f76e75fc1f3af76fd98c76bcb3c92ee18e9cb699f          2889  src/shared/shell-verification.cjs
+a31b275114a2ac376f3f8c69f4328286219767d22024ddeb01070550ad62109f          3189  src/shared/shell-verification.cjs
 2daa98fd421598bfe5fc9757c9b6f4d82c31d1bfece15829928473581d5d2639          1210  src/shared/tool-invocation.cjs
-114f01be8bd54c91b90af82d8e1604e24cc0c5f8e64e63c40cf3f4042623a98e          5402  src/shared/validation.cjs
+ee73fdf9c591c029243385cb2d2085c3005c7b08c5b9e1b89102201f0ab30759          5702  src/shared/validation.cjs
 13b731c38863b1007b0312fd9d89562401b7cce875c952f52429bde74f77a8af          3096  src/shared/zip-writer.cjs
 f8853dce6fdf360d5df2fbe2b6df3e5687630c807fee5ba8436679b34ec737ea          2436  START_HERE.md
 058aeaa5d9bfe377c7e322f213c7871ecc4151b5d08ef790992f4ee28d857658           743  START-FORGEFLOW-OVERLAY.ps1
 f5b0ea887fcdeadec78c1ad49b0ec7979723562f5c0b730703acb77a37281ee0          1009  tests/acceptance.test.mjs
+2f2b21754dccd8b734d6c7bd4fdd655df79c7739a1de140e562520c8234aa7a2          2854  tests/approved-deployment-evidence.test.mjs
+720ff5b549a3dd70854eb1bac3589c77a2019a61148be8e41e112196c8821ee3          1079  tests/approved-deployment-one-shot.test.mjs
 a4e5947204ff6878e601e32477bc85b53cd0153baf95a161c8935b6e5466c257          1155  tests/audit-service.test.mjs
-2d57a66bb2a6461e4c3266f14998d505ba0582135b0bbcf8fce9f1542a70007a         10479  tests/browser/forgeflow.spec.mjs
-454edeaccb2bd41043bc918d3e3a6127db14339031d6a1c1562ac855e90455d2          4318  tests/clone-target.test.mjs
-ac17f8bbe9e388b80abef7792c8b184a1fd482c93f13d23a478e433961020f75         17214  tests/config-store.test.mjs
+6e119cda76b2ee36b93623d98f41371798227f9b3f7c20fbef035a7d7a50cc95         19402  tests/browser/forgeflow.spec.mjs
+1728c0a7abd92f4d7d9e68df32e4a6b00730555f23795e9b36416795d9d127af          5978  tests/clone-target.test.mjs
+8aa8789a984769b377f719abca42a428fffc4f89b3997d57184a8073d24121e2         18325  tests/config-store.test.mjs
 f1463326aee79842d265687ae628189ce54e92544600f2bd14073780287cfb14          2502  tests/configuration-backup.test.mjs
+144c8e217a334cd69f502938d944e0f2dac61703d5df47e287b9ed542918c779          8129  tests/dependency-wiring.test.mjs
+aad5948ea374d1e56e777005c73639654c96a90364dd398c949052cf5ae343a2         11130  tests/deploy-key-host.test.mjs
 b7e009fed4171d6dd6b4c3154ba1d3f7198e98f5b79b298687841fc8169447cd          9354  tests/deploy-key-lifecycle.test.mjs
+49bf9cf9842e7899015013675208f83a95402065a082320927a677ee4bab0766         24875  tests/deployment-operations.test.mjs
 1dc6477bd07de78be189e6e8195ec339eb9d75820c4dbd5b073b8520ee21f6b5          1938  tests/deployment-policy.test.mjs
-50e90cd41dae952a14903c40c0cb1fd191d7b875cfeb730f06a454e755fad7ce          9076  tests/deployment-status.test.mjs
-fae3634bae871abade4d487b94b4741b50e787804dbd6135249f634fdd83c6d0          3800  tests/diagnostics.test.mjs
-dd121d96ca265a027cd415a52064500a4541b2f8a662f4f4b25f2f996d52b5da           762  tests/external-tools.test.mjs
-e7aebcc0d484a6a59d463d5cb26c11b3ad56e28f6535e7c38a0fe166a41565ea         13690  tests/git-integration.test.mjs
+bf4576901e32662d832687a2761852aa1b2cffe256de5044f18c6637c189463b          9780  tests/deployment-status.test.mjs
+9a97e79618393d9f9818cb958bd038e0095489331fba0b29de313aaaaa1ce30d          4064  tests/diagnostics.test.mjs
+b63eb5bcd89c34629386c745e80c2f83f0709ebce62459b583e665d0a99654c6           938  tests/external-tools.test.mjs
+26e94450c6ab1dd0d5149d6812e66814a719f80d6f95fcb3a9dee7a3d7f46293         20559  tests/git-integration.test.mjs
 5ea94c6b241a02060d531fad94e449eecd3772eed2137581d4e2babfb09e56db          1239  tests/git-status.test.mjs
 61e0b8cad926acd22b5b17e4044f7edcbe96b6977cbbe2b6fbe123406626fc89          4283  tests/git-validator-policy.test.mjs
 2b31459f14a5e36e30cf84c1054f634f4dba8676d29adeb9c2a8e18179f56fa0          6097  tests/git-validator.test.mjs
 681ab7bcd02c4dd98d1d8d2092a3521c489d941131e7ffe5903971b940046474          2403  tests/git-workflows.test.mjs
 d633c59bd910008223c834c6d7f3e5666c685a0881944263ede2d42cc69d3151         18710  tests/gitea-actions.test.mjs
 fcc9a063882840dd89d74c2785284c8f2f6a9e5acec482b6d89ed8de62efdb85          9635  tests/inventory-classifier.test.mjs
-9643622a03ea0a88fb7d72ce43e469ff4f814902f4b3d2a672990637d66ef075          2009  tests/ipc-contract.test.mjs
-caf98cbd9de9b119dae610ee53fa333a7a11214f34762247452fbb85e8bbf725          2392  tests/log-redaction.test.mjs
+62b90c21c15b841af30d26ccb0b9e88d25674fa7dbff9dc231dd8a1dddc3d657          2025  tests/ipc-contract.test.mjs
+5c66b01ab11585aab6d923a9811ec76eef34e918f1a7f37227edd3f4337c932f          2981  tests/log-redaction.test.mjs
 96432a97d313f331694900bf0a2c21e38c20eac96d59147977aeed9055a9e3ad          2287  tests/partial-staging.test.mjs
 1b6c920e18a248f78acaed6187197c88ec8d911b62d5e2a9f8ad57b91ae80499         11827  tests/preflight.test.mjs
+7f2751ea2621f76b5427f442e931344d13e97faa7b6ef3151949bbd6a03097cf          1205  tests/process-error-policy.test.mjs
 0cb884cf62c1cb02cf59a81662be055bcb5339d176de85e2a3eeb8e8573e11b3          6435  tests/production-acceptance.test.mjs
-629ba26395c0b49cc5fdee6b0646d75369eb6338e1cc7b59509938f97eea08ec          9601  tests/renderer-workflow.test.mjs
+11fd2029593c0f4e5c36f1ce8572734f8ac9afead5abca7f5b619c5814b40a6c         12602  tests/renderer-workflow.test.mjs
 2b4956fa4df4624a04117737e57ba74020564330ff71303b5746d8ccc881e880           854  tests/repository-matching.test.mjs
-62e6d3df7051778124648c808caec634a6b2c439660dc556392ea10beec926d1          1870  tests/repository-monitor.test.mjs
-ebd3c0825bc9e2f1690cfd51e93a96bd33e939eb9c546aa373dd948b8cf71a69          7781  tests/repository-service.test.mjs
-d49c772e3c7ddaa12dc5a1d4fc4cb474a4d99ae06fa5dab5a6cf1c44acb9ed6f          3463  tests/security-validation.test.mjs
+4defa3c5f21db7fefbd79397c96b6c231a4330df60b54c0fea7e91412e336fd3          6237  tests/repository-monitor.test.mjs
+5476f3ba90bc096d4172900d9b54ada7c12da521f8627913d87794eade3cee23         13494  tests/repository-service.test.mjs
+5fea04e668344508fb4e16da9bb6fe8733e2b83d1c227acb3421e51da26b2ffa          3636  tests/security-validation.test.mjs
 bab853feb0e22aa25af17989baaa632c01efa636533ea67407fecfdd973c7024           627  tests/semver.test.mjs
-e631e9ca49a5bac7075860aac2ff4d377a32a78377b70e06ecf833f0f192fd5f         11552  tests/server-inventory-branches.test.mjs
-020eccfa9c4aef7a4ac4736d9af90518fcb6d1ad75aedcfaa1c92832a9e3d6d8          4609  tests/shell-verification.test.mjs
-0d1bc4d623ce299337736c577ec61c8ffd6974ebe20335b72838d10eae35ecb1          7993  tests/ssh-service.test.mjs
+12cb3b240bdd0922566323c0014838ca067ad10d9d4009943165ae2c4e93bc6f         11786  tests/server-inventory-branches.test.mjs
+5df7f331cc1120a0914f5ddbf39d9a6b83bd5ada70a9953b3f6bd0701ba2485e          4394  tests/shell-verification.test.mjs
+a39d30f47813dfb98c998811f3d76ebbb1544ecfd017a165d44f9afb80d7daf9          9090  tests/ssh-connection-pool.test.mjs
+7ee9166327ed227d2b7c6929692dea5c5d7a41c3e566596fa92d9ec4f42e8677          4085  tests/ssh-connection.test.mjs
+c9354e4bf3720c28cff21c15ff8b9474ba4a23b7f55389de4326f4dffde54d78          9510  tests/ssh-service.test.mjs
 8a6a8477eb94b85ccef18cddd2640afb0d1eafa679c96bc7de20428d5d69e1be          1794  tests/tool-invocation.test.mjs
-4182b61e395aff310b9a964c973a43c3566df0b44c454054c3abdd9459e86e3b         49134  tests/unraid-deployment.test.mjs
-edec1007826bff6b5457fca603d8c816a9e1eedb3ce398269f151144ae3d2197         19764  tests/update-service.test.mjs
+3e4a1a6d6a744df9badcfece2cf8d09f8c34efb3c437cb08a6f2e6c9d428c0d4         59353  tests/unraid-deployment.test.mjs
+05c0ef13fa2fa977174fdf8bdf76a7d606a049a43ad98901079cf5545d54d18d         31426  tests/update-service.test.mjs
 9cea5c1d5ba3e0972a0b5c7236cf1f7c5616373e0a39ea4a492ecebf70452e40           948  tests/validation.test.mjs
 7ef4d4b9f5f3e6979293b29d571ce0e39f83197f3cade2d999a9cea7bacdd84d          1781  tests/zip-writer.test.mjs
 8f36b542736f2933bad8b9464ad7fa37b68196009c81cf702ce3b677cd637dea           767  UPDATE_FROM_0.3.2.md
@@ -3,7 +3,7 @@
 1. Close ForgeFlow completely.
 2. Extract `ForgeFlow-0.4.0-update-from-0.3.2.zip`.
 3. Copy the contents of the included `ForgeFlow` folder into your existing
-   `C:\Users\Jens\dyad-apps\ForgeFlow` folder and replace existing files.
+   `C:\Users\your-name\Apps\ForgeFlow` folder and replace existing files.
 4. Do not create a nested `ForgeFlow\ForgeFlow` folder.
 5. Open Windows PowerShell in the existing ForgeFlow folder and run:

@@ -0,0 +1,3 @@
+-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEApGKe81NzC5mU3jfMNAQUnAOfQnCnMFry8cNpmjQsdtE=
+-----END PUBLIC KEY-----
@@ -212,8 +212,8 @@ and last exit code. See `STATUS_ENDPOINT.md`.

 ## v0.4 services

- `UpdateService` reads `package.json` at an exact Gitea branch SHA, downloads an
-  authenticated archive and launches the rollback-capable Windows source updater.
+- `UpdateService` reports `package.json` at an exact Gitea branch SHA, refuses
+  unsigned source replacement and applies only publisher-signed packaged updates.
 - `SshService` provides pinned-host SSH execution with encrypted password or
  private-key passphrase storage.
 - `UnraidDeploymentService` inspects existing application folders and performs
@@ -51,4 +51,4 @@ ForgeFlow writes its configuration atomically. Explicit server reconciliation ad
 - Read-only repository-scoped deploy keys for server pull.
 - SSH host-key changes fail closed.
 - Live commit, remote commit and runtime health remain separate evidence.
- Packaged updates must fail closed on missing or mismatched release assets and SHA-256 evidence; paid code signing is optional.
+- Packaged updates fail closed on missing or mismatched release assets, SHA-256 evidence and the pinned Ed25519 publisher signature; paid Authenticode remains optional.
@@ -0,0 +1,63 @@
+# Deployment migration example
+
+This example shows how to bring an existing Git-backed Docker or Unraid application under ForgeFlow control without exposing or overwriting runtime data.
+
+Use synthetic names and values while testing. Replace them with your own repository, server and paths only in ForgeFlow's local configuration; do not commit credentials or environment-specific diagnostics.
+
+## 1. Establish the authoritative repository
+
+Before deploying, verify that the server checkout and Gitea repository represent the same application:
+
+- compare the complete 40-character commit SHA;
+- confirm the configured remote belongs to the intended Gitea origin and repository;
+- preserve the root `.git` directory for exact-SHA verification and rollback;
+- resolve any remote URL mismatch explicitly instead of silently rewriting it.
+
+ForgeFlow blocks deployment when the existing origin conflicts with the selected repository unless the user explicitly approves alignment.
+
+## 2. Protect runtime data
+
+Typical persistent paths include:
+
+```text
+.env
+appdata/
+config/
+data/
+logs/
+compose.override.yml
+```
+
+Keep those paths outside the tracked deployment payload and add runtime-only directories to `.dockerignore` when they are not build inputs. ForgeFlow uses a controlled Git reset without `git clean`, but the repository's own Compose and ignore rules remain authoritative.
+
+## 3. Reuse the maintained Compose definition
+
+Prefer the repository's existing `compose.yml` or `docker-compose.yml` when it already defines ports, volumes, device mappings, labels and health checks. These application-specific settings should be reviewed and versioned with the application rather than regenerated during deployment.
+
+## 4. Handle nested repositories separately
+
+A historical checkout such as `source/` may contain another `.git` directory. Treat this as a migration warning:
+
+1. verify that the root Compose file builds from the intended root;
+2. back up the application folder;
+3. stop modifying the nested checkout;
+4. rename it temporarily;
+5. rebuild and verify the application from the root checkout;
+6. remove the legacy copy only after rollback has also been tested.
+
+ForgeFlow reports nested repositories but does not delete them automatically.
+
+## 5. Recommended profile
+
+```text
+Provider:       SSH / Unraid
+Server folder:  example-app
+Branch:         main
+Compose mode:   Repository/server Compose
+Compose file:   compose.yml
+Clone URL:      a Git URL reachable from the server
+Healthcheck:    the application's existing health endpoint
+Preserve paths: .env, appdata, config, data, logs, compose.override.yml
+```
+
+Complete a preflight first, deploy one exact commit, verify both the live SHA and runtime health, and test rollback before treating the migration as production-ready.
@@ -1,147 +0,0 @@
-# LumaOps server versus Gitea audit
-
-This audit compares the supplied `lumaops_server.zip` and `LumaOps_gitea.zip`.
-
-## Main result
-
-The main Unraid working tree and the supplied Gitea checkout point to exactly the same commit:
-
-```text
-d42d4a7f08240c478d07466e3fabec654dc71367
-```
-
-Latest subject:
-
-```text
-Preserve colors across Aura zone updates
-```
-
-There is therefore no source-version drift at the root of the live LumaOps folder.
-
-## Root Git repository
-
-The root `.git` directory should remain in place. It enables:
-
- exact-SHA verification;
- controlled fetch and reset;
- a reliable previous-version reference;
- rollback without copying a second complete source tree.
-
-The archived server copy showed one root status difference for `scripts/unraid-hardware-setup.sh`: file mode `100755 → 100644`. This is consistent with Unix executable bits being lost during ZIP handling. The file content did not differ. Check the executable bit directly on Unraid before deployment.
-
-
-## Origin URL mismatch to resolve
-
-The supplied server root uses:
-
-```text
-ssh://git@127.0.0.1:222/NuklearRabbit/LumaOps.git
-```
-
-The supplied Gitea checkout uses:
-
-```text
-https://gitea.itworx.tech/Jens/LumaOps.git
-```
-
-Although both archives currently point to the same commit, these are different
-repository paths. Before the first ForgeFlow deployment, choose the server-
-reachable URL for the authoritative `Jens/LumaOps` repository, for example an
-SSH URL through `127.0.0.1:222` when Gitea runs on the same Unraid host.
-
-ForgeFlow 0.4 detects this mismatch. Deployment is blocked unless the profile
-matches the existing origin or **Align an existing server origin to this URL**
-is explicitly enabled.
-
-## Runtime and persistent paths
-
-The server copy contains runtime data that must not be replaced by source updates:
-
- `appdata/`
- `data/`
- `logs/`
- `.env` and application-specific configuration
-
-The repository `.gitignore` already excludes the principal runtime paths. ForgeFlow's SSH strategy uses Git reset without `git clean`, so untracked persistent data remains in place.
-
-## Compose and Unraid integration
-
-The root `docker-compose.yml` is already suitable as the authoritative deployment definition. It includes:
-
- build context at the project root;
- container name `lumaops`;
- the Unraid `dockerman` label;
- a Web UI label;
- an Unraid icon label;
- `${WEB_PORT:-1223}:${APP_PORT:-8080}`;
- persistent relative volumes;
- USB, HID and I²C devices;
- a healthcheck.
-
-ForgeFlow should use this existing Compose file rather than generate a replacement. Ports and complex device mappings belong in the repository's maintained Compose definition.
-
-The supplied `.dockerignore` already excludes `.git`, so keeping the root Git
-working tree does **not** copy Git history into the Docker build context. It does
-not yet explicitly exclude the existing runtime/legacy folders `appdata/`,
-`data/`, `logs/` and `source/`. Before the first production rebuild, add the
-paths that are not build inputs:
-
-```text
-appdata/
-data/
-logs/
-source/
-.forgeflow/
-```
-
-ForgeFlow 0.4 detects existing preserved paths and nested Git repositories that
-are missing from `.dockerignore` and reports them as a preflight warning. The
-tool does not silently edit a source-controlled `.dockerignore`; the correction
-should be committed to Gitea so every deployment uses the same build context.
-
-## Nested `source/` repository
-
-The server archive also contains a nested Git working tree under:
-
-```text
-source/
-```
-
-Its HEAD is:
-
-```text
-b746a52af1613f4291235f5e8165b8197a269a79
-```
-
-It was ahead of its own upstream and included rebase metadata in the supplied archive. The root Compose file uses build context `.` and does not reference `source/`. This strongly indicates that `source/` is an abandoned or historical checkout rather than the active deployment source.
-
-ForgeFlow reports this as a nested-repository warning and does not remove it automatically.
-
-Recommended migration:
-
-1. Back up `/mnt/user/appdata/lumaops`.
-2. Verify on Unraid that `docker compose config` uses the root project.
-3. Stop changing files in `source/`.
-4. Rename it temporarily to `source.legacy-backup`.
-5. Rebuild and test LumaOps from the root.
-6. Remove the legacy copy only after a successful validation period.
-
-Do not delete the root `.git` directory. Also do not delete the nested `source/`
-directory as part of the first ForgeFlow test. Treat its cleanup as a separate,
-backed-up migration after the root deployment and rollback have both been
-validated.
-
-## Recommended ForgeFlow profile
-
-```text
-Provider:       SSH / Unraid
-Server folder:  lumaops
-Branch:         main
-Compose mode:   Repository/server Compose
-Compose file:   docker-compose.yml
-Clone URL:      the Git URL reachable from Unraid
-Healthcheck:    the existing LumaOps health URL, when exposed
-Preserve paths: .env, appdata, data, logs, config, compose.override.yml
-```
-
-No folder rename is required for LumaOps because `lumaops` already aligns with the repository name.
@@ -0,0 +1,10 @@
+# ForgeFlow 0.10.10
+
+## Complete server-pull deployment repair
+
+- Missing repository-scoped read-only deploy keys can be provisioned and verified from Unraid against the exact Gitea branch.
+- A repository deployment root can now remain above its Compose working directory without breaking workload recognition or being overwritten by inventory refresh.
+- Nested Compose files are preserved as repository-relative deployment paths, including Ludarium, Launchpad and ITWorx MCP Hub layouts.
+- The **Fix write access** action now receives its permission-report parser correctly instead of reporting a false write-access failure.
+- Server-pull preflight proves every required deployment file at the exact Gitea commit before any container activation starts.
+- Runtime secrets remain in server-side `.env` files and preserved appdata paths; no secret values are written to Git or diagnostic output.
@@ -0,0 +1,10 @@
+# ForgeFlow 0.10.11
+
+## Resilient repository refresh and consistent server pull
+
+- Temporary Gitea list failures now use the in-session **last-known-good** repository inventory while local and server state continue to refresh. The UI clearly reports that remote data is stale.
+- A **closed output pipe** from a detached parent process is no longer treated as a fatal desktop-app exception.
+- Server pull, deploy-key verification, deployment, rollback and metadata now consistently prefer the verified **linked checkout origin** over a stale URL detected earlier on the server.
+- Repository-scoped **read-only deploy key** checks remain fail-closed; a changed SSH host still requires explicit trust and access reconfiguration.
+- The local **browser test server** now has a dedicated port and identity endpoint, preventing another localhost application from being mistaken for ForgeFlow.
+- All 42 responsive browser flows pass across dark/light, compact/wide and reduced-motion configurations.
@@ -0,0 +1,12 @@
+# ForgeFlow 0.10.12
+
+## Faster awareness with stricter deployment truth
+
+- Repository refreshes are **coalesced** and briefly cache Gitea inventory and workspace discovery; a manual refresh remains fully forced and file changes arriving mid-refresh receive one trailing refresh.
+- Server discovery reuses its Docker and Compose evidence for existing deployment profiles instead of opening a separate SSH session for every linked workload.
+- Deployment status only claims **exact Gitea commit parity** after comparing a concrete branch SHA with the live server SHA; matching repository provenance alone is no longer sufficient.
+- Container discovery uses **batched Docker inspect** with a safe per-container fallback when a container disappears during the scan.
+- Active Gitea and SSH deployment polling uses **bounded worker pools**, improving multi-deployment latency without flooding external services.
+- A **stopped container** can no longer be marked healthy because another process answers on its previous healthcheck port.
+- Large repository and server-inventory lists use offscreen rendering containment to reduce layout and paint work.
+- Inventory diagnostics now include scan and state-refresh durations, and Gitea bulk verification fails fast after a confirmed connectivity outage.
@@ -0,0 +1,18 @@
+# ForgeFlow 0.10.13
+
+## Veilige synchronisatie en aantoonbare release-integriteit
+
+- **Gitea workspace sync** toont eerst de exacte additions, wijzigingen en deletions ten opzichte van de actuele upstream-SHA. Lokale commits worden beschermd in een recovery branch; staged, unstaged en untracked werk gaat naar een stash. Genegeerde runtimebestanden blijven onaangeroerd.
+- Read-only achtergrondfetch houdt `ahead` en `behind` actueel zonder projectbestanden automatisch te wijzigen. Interval `0` schakelt netwerkfetch volledig uit.
+- Stale deployment links blokkeren niet langer de automatische, bewijsgebaseerde koppeling van de werkelijk draaiende vervangende workload.
+- SSH-hostidentiteit wordt vóór het verzenden van credentials getoond en bij bevestiging exact vastgepind. Gitea-tokens vereisen HTTPS, behalve bij expliciete loopbackontwikkeling.
+- Packaged updates vereisen een **Ed25519-signed release manifest** dat versie, tag, broncommit, artifactnaam, bytegrootte en SHA-256 bindt aan de ingebouwde publisher key. Hiervoor is geen betaald certificaat of Azure-dienst nodig.
+- Diagnostische bundels exporteren geen ruwe remote output meer. Untracked diffs kunnen geen junction of symlink buiten de repository volgen en zijn begrensd op bestandsgrootte.
+- De Git-toolsgrid behoudt nu de volledige inhoudshoogte binnen zijn eigen scrollvlak; workspace sync en troubleshooting overlappen niet meer. De demo bridge ondersteunt dezelfde recoveryflow als de desktopapp.
+- Repositorymonitoring, deploymentpolling, Docker-inspect en SSH-verbindingen gebruiken begrensde paralleliteit en hergebruik waar dat veilig is.
+
+## Verificatie
+
+- Volledige Node-testset, coveragepoort, architectuuraudit en dependency-audit.
+- 72 browserflows over dark/light, compact/desktop/wide, 100–150% schaal en reduced motion.
+- Windows installer en portable build, SHA-256-sidecars, provenance, CycloneDX-SBOM en ondertekend releasemanifest.
@@ -0,0 +1,15 @@
+# ForgeFlow 0.10.14
+
+## Betere uitleg en een stabiele repositorywerkruimte
+
+- Een nieuw doorzoekbaar **Help center** legt de belangrijkste workflows stap voor stap uit: eerste configuratie, changes en commits, Gitea workspace sync, deploymentdetectie, exacte serverdeployments, deploykeys, Git Validator, updates en diagnose.
+- Contextuele help vanuit **Gitea workspace sync** opent onmiddellijk de relevante uitleg. De instructies maken expliciet wat ForgeFlow wijzigt, welke recovery ForgeFlow vooraf maakt en welke genegeerde runtimebestanden onaangeroerd blijven.
+- De variabele **repository context** is samengebracht in één structurele zone. Quick actions, Local → Gitea → Server-status en gekoppelde deployments kunnen daardoor niet langer over de tabnavigatie of inhoud heen schuiven.
+- Smalle werkruimtes gebruiken gecontroleerde **horizontal tab navigation**. Elke tab behoudt zijn volledige label en blijft bereikbaar zonder dat tekst door andere bedieningselementen loopt.
+- Het Help center heeft een eigen premium, responsieve presentatie met categorieën, zoekresultaten, uitklapbare stappen, veiligheidsnotities en motion-safe projectillustratie.
+
+## Verificatie
+
+- Volledige Node-testset en statische renderercontroles.
+- **84 browser flows** over dark/light, compact/desktop/wide, 100–150% schaal en reduced motion; de drie tijdens een semantische testaanpassing geraakte flows zijn daarna opnieuw groen uitgevoerd.
+- Extra layoutasserties bewijzen dat repository context, tabs en tabinhoud elkaar niet overlappen bij 1024 × 768.
@@ -0,0 +1,15 @@
+# ForgeFlow 0.10.15
+
+## Veilige exacte workspace-sync en robuustere updates
+
+- **Workspace Sync** brengt een repository gecontroleerd naar de exacte Gitea-commit zonder lokale wijzigingen stilzwijgend terug naar de server te sturen. Lokale commits krijgen een recovery branch en gewijzigde of niet-getrackte bestanden worden in een expliciete ForgeFlow-quarantaine bewaard.
+- Elke quarantaine krijgt een lokaal **Codex review manifest** met bron- en doelcommit, recovery branch, stash-identiteit en betrokken bestanden. Quarantainestashes kunnen niet via de normale ForgeFlow-herstelactie in één keer worden teruggezet; eerst moet de inhoud gericht worden nagekeken.
+- ForgeFlow behandelt `forgeflow/recovery-*` branches als **local-only** en weigert ze via de normale pushactie te publiceren, zodat herstelmateriaal niet per ongeluk opnieuw in Gitea terechtkomt.
+- De source updater voert checksum- en Git-working-tree-preflight uit **voordat** ForgeFlow de update aan de externe helper overdraagt. Een Git-checkout wordt niet meer destructief met een bronarchief overschreven.
+- De Windows binary updater controleert het nieuwe uitvoerbare bestand vóór de ownership handoff, verifieert na update dat ForgeFlow werkelijk blijft draaien en kan bij een mislukte portable update de vorige executable herstellen en opnieuw starten.
+- Een geslaagde installer-update waarbij alleen de automatische herstart mislukt, wordt correct als geïnstalleerd gerapporteerd met een duidelijke instructie om ForgeFlow handmatig te starten.
+
+## Verificatie
+
+- Managed full validation op de sync/updater-hardening is geslaagd op de exacte feature-head en opnieuw als verplichte pull-requestvalidatie vóór merge.
+- De merge naar `main` is uitgevoerd via de beschermde pull-requestflow; de releaseversie wordt afzonderlijk gevalideerd voordat 0.10.15 wordt gepubliceerd.
@@ -0,0 +1,9 @@
+# ForgeFlow 0.10.4
+
+## Permanent packaged updater handshake repair
+
+- Binary and source update helpers now use a Windows PowerShell 5.1-compatible atomic status replacement with a real temporary backup path.
+- A deterministic overwrite fallback preserves lifecycle reporting on filesystems that do not implement atomic replacement.
+- The binary helper exposes a side-effect-free handshake-only verification mode exercised by the real Windows PowerShell executable during tests.
+- existing installations with the defective helper require this one-time installer upgrade; every subsequent packaged update uses the repaired helper automatically.
+- Startup failures retain request-scoped status and helper-log evidence instead of collapsing into an unexplained exit-code message.
@@ -0,0 +1,10 @@
+# ForgeFlow 0.10.5
+
+## Consistent repository and deployment links
+
+- Every repository workspace now shows all configured deployment environments in a compact, directly actionable strip.
+- The repository deployment tab includes every detected server workload linked to that repository, including its container, Compose identity, server and runtime state.
+- A workload is only labelled linked when its repository and resolved profile both exist in the current ForgeFlow configuration.
+- Stale or incomplete metadata is shown as **Link unresolved** and routed through explicit reconciliation instead of being presented as a healthy deployment.
+- The global deployment inventory links directly to the correct repository deployment profile.
+- Responsive browser coverage now verifies valid links, unresolved links, repository navigation and scrolling across dark/light and scaled layouts.
@@ -0,0 +1,9 @@
+# ForgeFlow 0.10.6
+
+## Permanent Windows updater launch repair
+
+- ForgeFlow no longer launches hidden PowerShell update helpers with Node's defective Windows `detached` process mode.
+- Binary and source updater processes remain hidden, are explicitly unreferenced after their verified handshake, and continue independently when ForgeFlow closes.
+- A real Windows regression test now exercises the exact production Node spawn options instead of using a different process API.
+- Startup is still fail-closed: ForgeFlow remains open unless the request-scoped helper status reaches `started`.
+- Versions 0.10.4 and 0.10.5 need a one-time direct installation of 0.10.6 because their installed launcher cannot execute its own helper; updates after 0.10.6 use the repaired path.
@@ -0,0 +1,10 @@
+# ForgeFlow 0.10.7
+
+## Reliable server-to-repository recognition
+
+- Live, running workloads with one unique exact provenance or runtime-identity match are now linked automatically during normal server discovery.
+- Automatic adoption creates only ForgeFlow configuration and observed state; it performs no container changes and never automatically removes stale profiles.
+- Ambiguous, duplicate, external and monitoring-only workloads remain behind explicit **Review & link** confirmation.
+- Every linked repository now displays an `S` deployment badge with its profile count in the repository sidebar.
+- The repository release rail reports **Linked** with container and server identity even when a legacy workload has no verifiable live commit yet.
+- DevRunbook-style DockerMan deployments therefore show the same linked relationship in Deployments, the repository sidebar and the repository workspace.
@@ -0,0 +1,9 @@
+# ForgeFlow 0.10.8
+
+## Self-contained checksum verification
+
+- Binary and source update helpers no longer depend on the optional PowerShell `Get-FileHash` cmdlet.
+- Both helpers calculate checksums directly with the built-in .NET SHA-256 implementation.
+- A real Windows regression test clears `PSModulePath` and verifies the downloaded binary successfully in that minimal environment.
+- The helper still validates the exact published checksum before waiting for ForgeFlow to exit or changing installed files.
+- This release retains the reliable non-detached launcher and server-to-repository recognition improvements from 0.10.6 and 0.10.7.
@@ -0,0 +1,10 @@
+# ForgeFlow 0.10.9
+
+## Reliable deployment inventory and preflight
+
+- Unraid inventory now includes containers without healthchecks. Docker's complete JSON state is parsed safely instead of using a failing Go-template lookup.
+- ForgeFlow is single-instance: opening it again focuses the existing window, preventing concurrent inventory scans and configuration writes.
+- Server pull verifies required Compose files or the Dockerfile at the exact Gitea commit before any deployment operation starts.
+- Server-pull verification now separates deploy-ready access from optional live-SHA and runtime-health evidence. A recoverable workload is no longer shown as blocked merely because parity is not yet provable.
+- Deployment cards and audit output show concrete access blockers and non-blocking warnings instead of a generic incomplete result.
+- All discovery, verification and preflight checks remain non-destructive; no containers are changed during these checks.
@@ -17,9 +17,9 @@ for every repository. ForgeFlow now:
 Example:

 ```text
-Default project root: C:\Users\Jens\Projects
+Default project root: C:\Users\your-name\Projects
 Gitea repository:     Jens/Portfolio
-Automatic target:     C:\Users\Jens\Projects\Portfolio
+Automatic target:     C:\Users\your-name\Projects\Portfolio
 ```

 A separate **Choose another location** action remains available for exceptional
@@ -48,9 +48,9 @@ Deployment profiles support:
 - runtime-data preservation;
 - rollback to the previous SHA.

-## LumaOps audit
+## Deployment migration example

-The supplied server and Gitea roots both match commit `d42d4a7f08240c478d07466e3fabec654dc71367`. The root Git checkout and Compose file should remain. A stale nested `source/` Git checkout is documented for controlled cleanup.
+The documented migration flow keeps the root Git checkout and maintained Compose file in place, verifies the complete commit SHA and treats a stale nested `source/` checkout as separate, controlled cleanup.

 ## Validation

@@ -19,11 +19,13 @@ no certificate, Azure or other paid-service dependency:
 npm run dist:win
 ```

-This produces the installer and portable executable, SHA-256 sidecars, a
-CycloneDX SBOM and provenance evidence. The in-app updater downloads only the
-matching Gitea release asset, checks its Windows executable format and verifies
-the published SHA-256 digest before staging it. The update helper verifies the
-digest again immediately before replacing the installed executable.
+Run `npm run signing:setup` once on the release workstation. It stores the
+private Ed25519 key outside the repository and writes only its public key into
+the packaged app. `npm run dist:win` then produces the installer and portable
+executable, SHA-256 sidecars, CycloneDX SBOM, provenance and an Ed25519-signed
+manifest bound to the exact source commit. The updater verifies the pinned
+publisher key before trusting the artifact digest and verifies that digest again
+immediately before replacing the installed executable.

 Windows can display an `Unknown publisher` warning for an unsigned installer.
 That warning concerns public publisher reputation; it does not prevent ForgeFlow
@@ -34,9 +36,9 @@ correct operation.
 ## Atomic publication

 `npm run release:binary` keeps the Gitea release in draft state while uploading
-the installer, portable executable, two checksums, provenance and SBOM. It only
-publishes after all six assets are present. A failed upload leaves a draft rather
-than exposing an incomplete updater target.
+the installer, portable executable, two checksums, provenance, SBOM, signed
+manifest and signature. It only publishes after all eight assets are present. A
+failed upload leaves a draft rather than exposing an incomplete updater target.

 The optional signing acceptance fixture can still validate the complete local
 Authenticode chain without purchasing or retaining a certificate:
@@ -23,7 +23,7 @@ flexibility.
 - session-only fallback when OS encryption is unavailable;
 - token omitted from renderer-visible public state;
 - encrypted token blob excluded from diagnostic bundles;
- blank settings token field preserves the existing token;
+- a blank settings token field preserves the existing token only when the normalized Gitea origin is unchanged;
 - atomic config replacement and restrictive permissions where supported;
 - service URLs reject embedded user credentials;
 - no token is required by setup/build scripts or documentation.
@@ -124,9 +124,14 @@ included model uses:
 - SSH passwords and private-key passphrases use Electron `safeStorage`;
 - diagnostics receive those runtime secrets only for redaction and never export
  encrypted credential fields;
- SSH deployment requires a pinned host-key fingerprint;
+- SSH host identity is previewed without credentials and authenticated sessions
+  require the exact user-confirmed pinned fingerprint;
 - remote folders and Compose paths are validated against traversal;
 - tracked server-side changes block exact-SHA reset;
- updater tokens are sent only to the configured Gitea origin;
- update archives are checksummed and validated by the full local quality gate;
- source backup is restored when an update fails.
+- updater tokens are sent only to the configured Gitea origin, and changing that origin requires a newly entered token;
+- non-loopback Gitea connections require HTTPS;
+- packaged updates require a publisher-signed Ed25519 manifest that binds the
+  source commit, artifact identity, byte length and SHA-256 digest;
+- packaged update bytes are rehashed immediately before apply;
+- integrated source replacement is disabled until source archives carry the
+  same independent publisher signature.
@@ -2,42 +2,36 @@

 ForgeFlow stores credentials, repository mappings, preferences, deployment profiles, diagnostics and operation history outside the source directory.

-## Built-in source update
+## Source checkouts

-Open **Settings → ForgeFlow updates** and choose:
+Integrated source replacement is disabled until source archives are covered by the same independent publisher signature as packaged releases. A server-provided commit SHA and a checksum calculated from the downloaded archive do not independently authenticate its publisher, while dependency installation can execute package lifecycle scripts.

-1. **Check now**
-2. **Download update**
-3. **Apply & restart**
+Update a source checkout through Git instead:

-The default update source is the configured Gitea instance, repository `Jens/ForgeFlow`, branch `main`.
+1. fetch the configured upstream;
+2. review the exact commit and release notes;
+3. switch to the intended release commit or tag;
+4. run `npm ci --ignore-scripts` and review the dependency lifecycle allowlist;
+5. run `npm run check` before starting ForgeFlow.

-The updater pins the download to the exact remote commit, checks the archive SHA-256, starts an external PowerShell helper and waits for a structured `started` marker. ForgeFlow closes only after that marker exists. The helper then:
-
-1. waits for the old process to exit;
-2. backs up the current source;
-3. extracts and validates the requested semantic version;
-4. mirrors the incoming source;
-5. runs `npm ci --no-audit --no-fund` when the published release contains `package-lock.json`, otherwise a pinned direct-dependency `npm install`;
-6. runs `npm run check`;
-7. writes the successful installation result before restart;
-8. launches the installed Electron executable directly;
-9. persists `success`, `failed` or `rolled-back` state for the next launch.
-
-A failed validation restores the previous source. A successful installation is not rolled back merely because automatic restart fails; start ForgeFlow manually and the persisted result is shown.
-
-Update logs and status files are stored beneath ForgeFlow's local user-data `updates` folder and exclude the Gitea token.
+The in-app updater remains available for signed packaged Windows releases.

 ## Packaged Windows updates

-ForgeFlow 0.9.1 and newer use authenticated Gitea release assets when running from the installer or portable executable. The updater selects the installer or portable artifact that matches the current installation mode, requires its `.sha256` sidecar, validates the Windows executable header and SHA-256 digest, then verifies the digest again immediately before applying it. An external PowerShell helper waits for ForgeFlow to exit, installs or replaces the executable and restarts it.
+ForgeFlow uses authenticated Gitea release assets when running from the installer or portable executable. The updater selects the artifact that matches the current installation mode and requires its `.sha256` sidecar. From version 0.10.13 onward it also requires an Ed25519-signed release manifest. The embedded public key verifies that manifest before ForgeFlow trusts the artifact name, byte length, exact source commit or SHA-256 digest. The digest is checked again immediately before applying the update.

-`Publish-ForgeFlow-Release.ps1` now treats source and binaries as one release transaction. By default it pushes the validated source, builds the exact published commit and uploads all four required assets:
+`Publish-ForgeFlow-Release.ps1` treats source and binaries as one release transaction. It pushes the validated source, builds the exact published commit and uploads eight required assets:

 - `ForgeFlow-Setup-<version>-win-x64.exe`
 - `ForgeFlow-Setup-<version>-win-x64.exe.sha256`
 - `ForgeFlow-Portable-<version>-win-x64.exe`
 - `ForgeFlow-Portable-<version>-win-x64.exe.sha256`
+- `ForgeFlow-<version>-provenance.json`
+- `ForgeFlow-<version>-sbom.cdx.json`
+- `ForgeFlow-<version>-release-manifest.json`
+- `ForgeFlow-<version>-release-manifest.json.sig`
+
+Run `npm run signing:setup` once on the release workstation. The private Ed25519 key stays outside the repository in ForgeFlow's user-data folder. This independent publisher signature is free; optional Authenticode can still be added later for Windows reputation.

 Use `-SkipBinaryRelease` only when intentionally publishing source without enabling packaged auto-update.

@@ -59,17 +53,17 @@ The binary publisher refuses to upload when local `HEAD` differs from the config
 Extract the complete source ZIP so this file exists:

 ```text
-C:\Users\Jens\Downloads\ForgeFlow-<version>\ForgeFlow\package.json
+C:\Users\your-name\Downloads\ForgeFlow-<version>\ForgeFlow\package.json
 ```

 Run:

 ```powershell
-cd C:\Users\Jens\Downloads\ForgeFlow-<version>\ForgeFlow
+cd C:\Users\your-name\Downloads\ForgeFlow-<version>\ForgeFlow
 Set-ExecutionPolicy -Scope Process Bypass
 .\Publish-ForgeFlow-Release.ps1
 ```

-The script installs dependencies, runs the complete quality gate, clones `git@gitea.itworx.tech:Jens/ForgeFlow.git` into a temporary folder, mirrors the validated source without `.git`, `node_modules`, `dist` or release archives, commits it and pushes `main`. It then compares local `HEAD` with `git ls-remote`, builds the exact published checkout and uploads the installer, portable executable and both checksums to the matching Gitea release. Publication fails when either the source commit or any required binary asset cannot be verified.
+The script installs dependencies, runs the complete quality gate, clones `git@gitea.itworx.tech:Jens/ForgeFlow.git` into a temporary folder, mirrors the validated source without `.git`, `node_modules`, `dist` or release archives, commits it and pushes `main`. It then compares local `HEAD` with `git ls-remote`, builds the exact published checkout and uploads all binaries, checksums and signed release evidence to the matching Gitea release. Publication fails when either the source commit, publisher signature or any required asset cannot be verified.

 Keep the currently installed older ForgeFlow source folder untouched until the built-in updater test is complete.
@@ -29,6 +29,34 @@ export default [
      eqeqeq: ["error", "always", { null: "ignore" }],
    },
  },
+  {
+    // The main process and shared modules are plain CommonJS with an explicit
+    // dependency graph, so undefined identifiers there are always real bugs
+    // (missing require, missing injected dependency) rather than a global that
+    // another script tag happens to define.
+    files: ["src/main/**/*.cjs", "src/shared/**/*.cjs", "main.cjs", "preload.cjs"],
+    languageOptions: {
+      sourceType: "commonjs",
+      globals: {
+        require: "readonly", module: "writable", exports: "writable",
+        __dirname: "readonly", __filename: "readonly",
+        Buffer: "readonly", process: "readonly", console: "readonly",
+        setTimeout: "readonly", clearTimeout: "readonly",
+        setInterval: "readonly", clearInterval: "readonly", setImmediate: "readonly",
+        queueMicrotask: "readonly", structuredClone: "readonly", globalThis: "readonly",
+        URL: "readonly", URLSearchParams: "readonly", fetch: "readonly",
+        FormData: "readonly", Blob: "readonly",
+        AbortController: "readonly", AbortSignal: "readonly",
+        TextEncoder: "readonly", TextDecoder: "readonly",
+      },
+    },
+    rules: {
+      "no-undef": "error",
+      // Also catches code that a refactor left behind, such as a value computed
+      // from a dependency that is no longer injected.
+      "no-unused-vars": ["error", { args: "none", caughtErrors: "none", ignoreRestSiblings: true }],
+    },
+  },
  {
    files: ["tests/**/*.mjs"],
    rules: {
@@ -0,0 +1,90 @@
+name: ForgeFlow approved deploy
+
+on:
+  workflow_dispatch:
+    inputs:
+      repository:
+        description: Signed allowlisted deployment target (owner/repository)
+        required: true
+        type: string
+      environment:
+        description: Allowlisted ForgeFlow environment
+        required: true
+        type: string
+      commit_sha:
+        description: Exact approved commit SHA
+        required: true
+        type: string
+      request_id:
+        description: Immutable AppOps request identifier
+        required: true
+        type: string
+      approval_id:
+        description: AppOps approval identifier
+        required: true
+        type: string
+      approval_fingerprint:
+        description: Immutable AppOps approval fingerprint
+        required: true
+        type: string
+      evidence_issued_at:
+        description: Signed evidence UNIX timestamp
+        required: true
+        type: string
+      evidence_signature:
+        description: Base64 Ed25519 signature over the exact deployment evidence
+        required: true
+        type: string
+
+concurrency:
+  group: forgeflow-approved-${{ inputs.repository }}-${{ inputs.environment }}
+  cancel-in-progress: false
+
+jobs:
+  deploy:
+    runs-on: forgeflow
+    steps:
+      - name: Validate signed deployment inputs
+        shell: bash
+        env:
+          FF_REPOSITORY: ${{ inputs.repository }}
+          FF_ENVIRONMENT: ${{ inputs.environment }}
+          FF_COMMIT_SHA: ${{ inputs.commit_sha }}
+          FF_REQUEST_ID: ${{ inputs.request_id }}
+          FF_APPROVAL_ID: ${{ inputs.approval_id }}
+          FF_APPROVAL_FINGERPRINT: ${{ inputs.approval_fingerprint }}
+          FF_EVIDENCE_ISSUED_AT: ${{ inputs.evidence_issued_at }}
+          FF_EVIDENCE_SIGNATURE: ${{ inputs.evidence_signature }}
+        run: |
+          set -Eeuo pipefail
+          [[ "$FF_REPOSITORY" =~ ^[A-Za-z0-9._-]+/[A-Za-z0-9._-]+$ ]]
+          [[ "$FF_ENVIRONMENT" =~ ^[a-z0-9][a-z0-9._-]{0,63}$ ]]
+          [[ "$FF_COMMIT_SHA" =~ ^[0-9a-fA-F]{40,64}$ ]]
+          [[ "$FF_REQUEST_ID" =~ ^appr-[A-Za-z0-9._-]{1,75}$ ]]
+          [[ "$FF_APPROVAL_ID" == "$FF_REQUEST_ID" ]]
+          [[ "$FF_APPROVAL_FINGERPRINT" =~ ^[0-9a-f]{64}$ ]]
+          [[ "$FF_EVIDENCE_ISSUED_AT" =~ ^[0-9]{10,11}$ ]]
+          [[ "$FF_EVIDENCE_SIGNATURE" =~ ^[A-Za-z0-9+/]{86}==$ ]]
+
+      - name: Execute root-owned verified deployment
+        shell: bash
+        env:
+          FF_REPOSITORY: ${{ inputs.repository }}
+          FF_ENVIRONMENT: ${{ inputs.environment }}
+          FF_COMMIT_SHA: ${{ inputs.commit_sha }}
+          FF_REQUEST_ID: ${{ inputs.request_id }}
+          FF_APPROVAL_ID: ${{ inputs.approval_id }}
+          FF_APPROVAL_FINGERPRINT: ${{ inputs.approval_fingerprint }}
+          FF_EVIDENCE_ISSUED_AT: ${{ inputs.evidence_issued_at }}
+          FF_EVIDENCE_SIGNATURE: ${{ inputs.evidence_signature }}
+        run: |
+          set -Eeuo pipefail
+          sudo /usr/local/bin/forgeflow-deploy \
+            "$FF_REPOSITORY" \
+            "$FF_ENVIRONMENT" \
+            "$FF_COMMIT_SHA" \
+            "$FF_REQUEST_ID" \
+            "$FF_APPROVAL_ID" \
+            "$FF_APPROVAL_FINGERPRINT" \
+            "$FF_EVIDENCE_ISSUED_AT" \
+            "$FF_EVIDENCE_SIGNATURE"
@@ -4,18 +4,29 @@ umask 027

 # Install as /usr/local/bin/forgeflow-deploy, owned by root and not writable by
 # the Gitea runner. Targets are read from the root-owned data file below.
+# Approved machine deployments additionally verify an AppOps Ed25519 signature
+# using the root-controlled public key; the Actions runner never receives that
+# trust anchor's private key. Every verified approval id is consumed exactly
+# once in a root-owned replay journal before target lookup or mutation.

 readonly CONFIG_FILE="/etc/forgeflow/targets.conf"
+readonly EVIDENCE_PUBLIC_KEY_FILE="/etc/forgeflow/evidence.pub"
+readonly EVIDENCE_REPLAY_DIR="/var/lib/forgeflow-status/approved-requests"
 readonly REPOSITORY="${1:-}"
 readonly ENVIRONMENT="${2:-}"
 readonly SHA="${3:-}"
 readonly REQUEST_ID="${4:-manual-$(date +%s)}"
+readonly APPROVAL_ID="${5:-}"
+readonly APPROVAL_FINGERPRINT="${6:-}"
+readonly EVIDENCE_ISSUED_AT="${7:-}"
+readonly EVIDENCE_SIGNATURE="${8:-}"

 fail_usage() {
-  echo "Usage: forgeflow-deploy <owner/repository> <environment> <full-sha> [request-id]" >&2
+  echo "Usage: forgeflow-deploy <owner/repository> <environment> <full-sha> [request-id] [approval-id approval-fingerprint evidence-issued-at evidence-signature]" >&2
  exit 64
 }

+(( $# == 3 || $# == 4 || $# == 8 )) || fail_usage
 [[ "$REPOSITORY" =~ ^[A-Za-z0-9._-]+/[A-Za-z0-9._-]+$ ]] || fail_usage
 [[ "$ENVIRONMENT" =~ ^[A-Za-z0-9._-]+$ ]] || fail_usage
 [[ "$SHA" =~ ^[0-9a-fA-F]{40,64}$ ]] || fail_usage
@@ -29,6 +40,61 @@ config_mode="$(stat -c '%a' "$CONFIG_FILE")"
 # Reject group/other write bits. GNU stat returns an octal string such as 640.
 (( (8#$config_mode & 8#022) == 0 )) || { echo "Target configuration may not be group/other writable" >&2; exit 78; }

+EVIDENCE_VERIFIED=false
+if (( $# == 8 )); then
+  [[ "$REQUEST_ID" =~ ^appr-[A-Za-z0-9._-]{1,75}$ ]] || { echo "Approved deployment request ID is invalid" >&2; exit 64; }
+  [[ "$APPROVAL_ID" == "$REQUEST_ID" ]] || { echo "Approval ID must equal the immutable request ID" >&2; exit 65; }
+  [[ "$APPROVAL_FINGERPRINT" =~ ^[0-9a-f]{64}$ ]] || { echo "Approval fingerprint is invalid" >&2; exit 64; }
+  [[ "$EVIDENCE_ISSUED_AT" =~ ^[0-9]{10,11}$ ]] || { echo "Evidence timestamp is invalid" >&2; exit 64; }
+  [[ "$EVIDENCE_SIGNATURE" =~ ^[A-Za-z0-9+/]{86}==$ ]] || { echo "Evidence signature encoding is invalid" >&2; exit 64; }
+  [[ -f "$EVIDENCE_PUBLIC_KEY_FILE" ]] || { echo "Missing AppOps evidence public key: $EVIDENCE_PUBLIC_KEY_FILE" >&2; exit 78; }
+
+  evidence_owner="$(stat -c '%U' "$EVIDENCE_PUBLIC_KEY_FILE")"
+  evidence_mode="$(stat -c '%a' "$EVIDENCE_PUBLIC_KEY_FILE")"
+  [[ "$evidence_owner" == "root" ]] || { echo "Evidence public key must be owned by root" >&2; exit 78; }
+  (( (8#$evidence_mode & 8#022) == 0 )) || { echo "Evidence public key may not be group/other writable" >&2; exit 78; }
+  command -v openssl >/dev/null 2>&1 || { echo "OpenSSL is required for approved deployment evidence verification" >&2; exit 69; }
+
+  now_epoch="$(date +%s)"
+  (( EVIDENCE_ISSUED_AT <= now_epoch + 60 )) || { echo "Deployment evidence is issued too far in the future" >&2; exit 65; }
+  (( EVIDENCE_ISSUED_AT >= now_epoch - 1800 )) || { echo "Deployment evidence expired before execution" >&2; exit 65; }
+
+  evidence_tmp="$(mktemp -d /run/forgeflow-evidence.XXXXXX)"
+  cleanup_evidence() { rm -rf "$evidence_tmp"; }
+  trap cleanup_evidence EXIT
+  printf 'forgeflow-evidence-v1\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n' \
+    "$APPROVAL_ID" \
+    "$APPROVAL_FINGERPRINT" \
+    "$REPOSITORY" \
+    "$ENVIRONMENT" \
+    "${SHA,,}" \
+    "$REQUEST_ID" \
+    "$EVIDENCE_ISSUED_AT" > "$evidence_tmp/message"
+  printf '%s' "$EVIDENCE_SIGNATURE" | base64 --decode > "$evidence_tmp/signature" 2>/dev/null || {
+    echo "Deployment evidence signature could not be decoded" >&2
+    exit 65
+  }
+  openssl pkeyutl -verify \
+    -pubin \
+    -inkey "$EVIDENCE_PUBLIC_KEY_FILE" \
+    -rawin \
+    -in "$evidence_tmp/message" \
+    -sigfile "$evidence_tmp/signature" >/dev/null 2>&1 || {
+      echo "Deployment evidence signature verification failed" >&2
+      exit 65
+    }
+
+  # Consume the verified approval before any target lookup. mkdir is atomic,
+  # making this a cross-process replay fence. A failed first deployment still
+  # requires a fresh human approval, matching AppOps' terminal execution model.
+  install -d -o root -g root -m 0700 "$EVIDENCE_REPLAY_DIR"
+  if ! mkdir -m 0700 "$EVIDENCE_REPLAY_DIR/$APPROVAL_ID" 2>/dev/null; then
+    echo "Approved deployment evidence was already consumed" >&2
+    exit 65
+  fi
+  EVIDENCE_VERIFIED=true
+fi
+
 APP_DIR=""
 BRANCH=""
 COMPOSE_FILE=""
@@ -75,6 +141,9 @@ write_status() {
  temporary="${STATUS_FILE}.${$}.tmp"
  json_string "$health" >/dev/null
  json_string "$REQUEST_ID" >/dev/null
+  json_string "$APPROVAL_ID" >/dev/null
+  json_string "$APPROVAL_FINGERPRINT" >/dev/null
+  json_string "$EVIDENCE_ISSUED_AT" >/dev/null
  [[ "$live_sha" =~ ^[0-9a-fA-F]{40,64}$ ]] || { echo "Invalid live SHA for status output" >&2; return 1; }
  [[ "$previous_sha" =~ ^[0-9a-fA-F]{40,64}$ ]] || { echo "Invalid previous SHA for status output" >&2; return 1; }
  cat > "$temporary" <<JSON
@@ -85,6 +154,10 @@ write_status() {
  "commit_sha": "$live_sha",
  "previous_sha": "$previous_sha",
  "requested_sha": "$SHA",
+  "approval_id": "$APPROVAL_ID",
+  "approval_fingerprint": "$APPROVAL_FINGERPRINT",
+  "evidence_verified": $EVIDENCE_VERIFIED,
+  "evidence_issued_at": "$EVIDENCE_ISSUED_AT",
  "deployed_at": "$deployed_at",
  "health": "$health",
  "last_exit_code": $exit_code
@@ -105,6 +178,9 @@ echo "ForgeFlow request: $REQUEST_ID"
 echo "Target:            $REPOSITORY / $ENVIRONMENT"
 echo "Current SHA:       $current_sha"
 echo "Requested SHA:     $SHA"
+if [[ "$EVIDENCE_VERIFIED" == "true" ]]; then
+  echo "Approval:           $APPROVAL_ID (signed evidence verified)"
+fi

 on_error() {
  local exit_code=$?
@@ -1,11 +1,15 @@
 {
  "repository": "jens/example-app",
  "environment": "production",
-  "request_id": "3a6ed71c-d52d-4d8d-9678-96e0c9456a81",
+  "request_id": "appr-3a6ed71cd52d",
  "commit_sha": "0123456789abcdef0123456789abcdef01234567",
  "previous_sha": "89abcdef0123456789abcdef0123456789abcdef",
  "requested_sha": "0123456789abcdef0123456789abcdef01234567",
-  "deployed_at": "2026-07-24T13:00:00Z",
+  "approval_id": "appr-3a6ed71cd52d",
+  "approval_fingerprint": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+  "evidence_verified": true,
+  "evidence_issued_at": "1787778000",
+  "deployed_at": "2026-08-26T21:00:00Z",
  "health": "healthy",
  "last_exit_code": 0
 }
@@ -33,14 +33,31 @@ const {
  ExternalToolsService,
 } = require("./src/main/external-tools-service.cjs");
 const { registerIpc } = require("./src/main/ipc.cjs");
+const {
+  installOutputPipeGuards,
+  isBrokenPipeError,
+} = require("./src/main/process-error-policy.cjs");

 let mainWindow;
 let repositoryMonitor;
+let sshService;
 let operationTimer;
 let diagnostics;
 let configStore;
 let tray;
 let quitCleanupStarted = false;
+const reportBrokenOutputPipe = (error) => {
+  const report = diagnostics?.warning("process.output-pipe.closed", {
+    code: error?.code || null,
+    message: error?.message || "The parent output pipe was closed.",
+  });
+  report?.catch(() => {});
+};
+installOutputPipeGuards({ onBrokenPipe: reportBrokenOutputPipe });
+const ownsSingleInstanceLock = app.requestSingleInstanceLock();
+
+if (!ownsSingleInstanceLock) app.quit();
+else app.on("second-instance", () => showMainWindow());

 function broadcast(channel, payload) {
  for (const window of BrowserWindow.getAllWindows()) {
@@ -171,6 +188,7 @@ function createWindow() {
 app
  .whenReady()
  .then(async () => {
+    if (!ownsSingleInstanceLock) return;
    session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
      callback({
        responseHeaders: {
@@ -214,6 +232,10 @@ app
    await audit.initialize();

    process.on("uncaughtException", (error) => {
+      if (isBrokenPipeError(error)) {
+        reportBrokenOutputPipe(error);
+        return;
+      }
      diagnostics
        ?.error("process.uncaught-exception", error)
        .finally(() => app.exit(1));
@@ -231,6 +253,7 @@ app
    const repositories = new RepositoryService(store, git, gitea, diagnostics);
    const deployments = new DeploymentService(store, gitea, git, diagnostics);
    const ssh = new SshService({ store, diagnostics });
+    sshService = ssh;
    const auditedOperationStates = new Set();
    const reportOperationChange = (payload) => {
      broadcast("operations:changed", payload);
@@ -241,6 +264,11 @@ app
      ) {
        const key = `${operation.id}:${operation.status}`;
        if (!auditedOperationStates.has(key)) {
+          // One entry per completed deployment, so the set is trimmed rather
+          // than kept for the lifetime of the process.
+          if (auditedOperationStates.size >= 500) {
+            auditedOperationStates.delete(auditedOperationStates.values().next().value);
+          }
          auditedOperationStates.add(key);
          notify(
            `Deployment ${operation.status}`,
@@ -419,7 +447,6 @@ app
    });
  })
  .catch(async (error) => {
-    console.error("[startup]", error);
    await diagnostics?.error("app.startup.failed", error);
    await diagnostics?.flush();
    app.exit(1);
@@ -430,6 +457,7 @@ app.on("before-quit", (event) => {
  event.preventDefault();
  quitCleanupStarted = true;
  repositoryMonitor?.stop();
+  sshService?.closeAll();
  if (operationTimer) clearTimeout(operationTimer);
  Promise.resolve()
    .then(() => diagnostics?.info("app.quitting", {}))
@@ -1,12 +1,12 @@
 {
  "name": "forgeflow",
-  "version": "0.10.3",
+  "version": "0.10.15",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "forgeflow",
-      "version": "0.10.3",
+      "version": "0.10.15",
      "dependencies": {
        "ssh2": "1.17.0"
      },
@@ -68,9 +68,9 @@
      "license": "MIT"
    },
    "node_modules/@electron/asar/node_modules/brace-expansion": {
-      "version": "1.1.17",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.17.tgz",
-      "integrity": "sha512-w+aeW/mkgM4PyRMOJCgi3fOrTm5Q8QY1OSfn2TO2iuDj3ezIHqejmuxbjfPrqUkgqRew1iqkyAn0tr0ZwHD9+w==",
+      "version": "1.1.18",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.18.tgz",
+      "integrity": "sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -257,9 +257,9 @@
      "license": "MIT"
    },
    "node_modules/@electron/universal/node_modules/brace-expansion": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.3.tgz",
-      "integrity": "sha512-DRdx5neNsG/QXbniLFWi2YmC/68oeOOmKz6zOjVk6ZS1ZLXgLIKqVEc6hWsmkjBbgii0SwaBTcJ5XKj5gzY/4A==",
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.4.tgz",
+      "integrity": "sha512-hGfVzPxthbf3+2yjg/RBs60cB0FhqBS/zvdV/4wn4/BmN0bNMMHPc4V/BbFieqf1TKAGGAHnY4eSjajCl0f2Xg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -401,9 +401,9 @@
      "license": "MIT"
    },
    "node_modules/@eslint/config-array/node_modules/brace-expansion": {
-      "version": "1.1.17",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.17.tgz",
-      "integrity": "sha512-w+aeW/mkgM4PyRMOJCgi3fOrTm5Q8QY1OSfn2TO2iuDj3ezIHqejmuxbjfPrqUkgqRew1iqkyAn0tr0ZwHD9+w==",
+      "version": "1.1.18",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.18.tgz",
+      "integrity": "sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -482,9 +482,9 @@
      "license": "MIT"
    },
    "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
-      "version": "1.1.17",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.17.tgz",
-      "integrity": "sha512-w+aeW/mkgM4PyRMOJCgi3fOrTm5Q8QY1OSfn2TO2iuDj3ezIHqejmuxbjfPrqUkgqRew1iqkyAn0tr0ZwHD9+w==",
+      "version": "1.1.18",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.18.tgz",
+      "integrity": "sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -1357,9 +1357,9 @@
      "optional": true
    },
    "node_modules/brace-expansion": {
-      "version": "5.0.8",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.8.tgz",
-      "integrity": "sha512-JZyDyq3D4AUifKTPOB7DELf6XsB3WdPuNxCtob1vFXPsSXhdAiHBWJ/tJ8HAc9aH84BK+5JFZLNkJKx3G9kzQg==",
+      "version": "5.0.9",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
+      "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -2014,9 +2014,9 @@
      "license": "MIT"
    },
    "node_modules/dir-compare/node_modules/brace-expansion": {
-      "version": "1.1.17",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.17.tgz",
-      "integrity": "sha512-w+aeW/mkgM4PyRMOJCgi3fOrTm5Q8QY1OSfn2TO2iuDj3ezIHqejmuxbjfPrqUkgqRew1iqkyAn0tr0ZwHD9+w==",
+      "version": "1.1.18",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.18.tgz",
+      "integrity": "sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -2471,9 +2471,9 @@
      "license": "MIT"
    },
    "node_modules/eslint/node_modules/brace-expansion": {
-      "version": "1.1.17",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.17.tgz",
-      "integrity": "sha512-w+aeW/mkgM4PyRMOJCgi3fOrTm5Q8QY1OSfn2TO2iuDj3ezIHqejmuxbjfPrqUkgqRew1iqkyAn0tr0ZwHD9+w==",
+      "version": "1.1.18",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.18.tgz",
+      "integrity": "sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -2587,9 +2587,9 @@
      "license": "MIT"
    },
    "node_modules/fast-uri": {
-      "version": "3.1.4",
-      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.4.tgz",
-      "integrity": "sha512-8JnbkQ4juDyvYs4mgFGQqg4yCYtFDtUtmp2QIQq11ZZe5CFQ5wcqm1rqDgAh/QdMySuBnPzMUiJUNZG5N/AiQw==",
+      "version": "3.1.6",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.6.tgz",
+      "integrity": "sha512-7Ical1vFEMr0onbVzEDIreM22I4khW+fzyQPwvAFWBp1iwdshSZRsL4jjRvPG9JP1uiqMHRto+YU6R2/CzDz5Q==",
      "dev": true,
      "funding": [
        {
@@ -2652,9 +2652,9 @@
      "license": "MIT"
    },
    "node_modules/filelist/node_modules/brace-expansion": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.3.tgz",
-      "integrity": "sha512-DRdx5neNsG/QXbniLFWi2YmC/68oeOOmKz6zOjVk6ZS1ZLXgLIKqVEc6hWsmkjBbgii0SwaBTcJ5XKj5gzY/4A==",
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.4.tgz",
+      "integrity": "sha512-hGfVzPxthbf3+2yjg/RBs60cB0FhqBS/zvdV/4wn4/BmN0bNMMHPc4V/BbFieqf1TKAGGAHnY4eSjajCl0f2Xg==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -2927,9 +2927,9 @@
      "license": "MIT"
    },
    "node_modules/glob/node_modules/brace-expansion": {
-      "version": "1.1.17",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.17.tgz",
-      "integrity": "sha512-w+aeW/mkgM4PyRMOJCgi3fOrTm5Q8QY1OSfn2TO2iuDj3ezIHqejmuxbjfPrqUkgqRew1iqkyAn0tr0ZwHD9+w==",
+      "version": "1.1.18",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.18.tgz",
+      "integrity": "sha512-Edep/X9fGqVNmzKBVsDYIOtD+z1tuezV70LBjdCst9Tqu76lsnvRiZ6oTic1n+/BIwX6QDGAO94PN4N2SADvtw==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -3365,9 +3365,9 @@
      }
    },
    "node_modules/js-yaml": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.0.tgz",
-      "integrity": "sha512-1td788aAnnZ5qs7V2QIRl1owjtYpbKt749Y3xauqQgwIIGF/xXWz1wMTEBx5O3LK3lXLVuqXPdPxj2BoFHaW9Q==",
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.2.tgz",
+      "integrity": "sha512-SFNOvSJ+Dgf/9An904Yx+CgSlIPCkIpao4qo51lpee25TIRejdH3rhR4EZMGoNx3/TP3O+wzWuiTFl4sqbltzA==",
      "dev": true,
      "funding": [
        {
@@ -1,6 +1,6 @@
 {
  "name": "forgeflow",
-  "version": "0.10.3",
+  "version": "0.10.15",
  "private": true,
  "description": "Desktop release cockpit for local Git, Gitea Actions and controlled exact-commit deployments.",
  "main": "main.cjs",
@@ -11,9 +11,10 @@
    "demo": "node scripts/serve-demo.mjs",
    "test": "node --test tests/*.test.mjs",
    "lint": "eslint .",
-    "coverage": "c8 --check-coverage --lines 75 --functions 75 --branches 65 --statements 75 node --test tests/*.test.mjs",
+    "coverage": "c8 --check-coverage --lines 85 --functions 85 --branches 68 --statements 85 node --test tests/*.test.mjs && npm run coverage:modules",
+    "coverage:modules": "c8 report --check-coverage --per-file --include src/** --statements 60 --lines 60 --functions 50 --branches 36 --reporter=text-summary",
    "verify": "node scripts/verify.mjs",
-    "dist:win": "electron-builder --win nsis portable && node scripts/write-release-checksums.mjs && node scripts/verify-release-signatures.mjs && node scripts/prune-dist.mjs",
+    "dist:win": "electron-builder --win nsis portable && node scripts/write-release-checksums.mjs && node scripts/sign-release-manifest.mjs && node scripts/verify-release-signatures.mjs && node scripts/prune-dist.mjs",
    "dist:linux": "electron-builder --linux AppImage && node scripts/prune-dist.mjs",
    "dist:mac": "electron-builder --mac dmg && node scripts/prune-dist.mjs",
    "doctor": "node scripts/doctor.mjs",
@@ -23,6 +24,7 @@
    "test:browser": "playwright test",
    "test:browser:ci": "playwright test --reporter=line,html",
    "test:signing": "powershell.exe -NoProfile -ExecutionPolicy Bypass -File scripts/test-authenticode-chain.ps1",
+    "signing:setup": "node scripts/setup-update-signing-key.mjs",
    "connections:check": "electron scripts/validate-installed-connections.cjs",
    "deployments:audit": "electron scripts/audit-installed-deployments.cjs",
    "release:binary": "electron scripts/publish-binary-release.cjs",
@@ -49,6 +51,7 @@
      "package.json",
      "build/icon.png",
      "build/icon.ico",
+      "build/update-signing-public.pem",
      "docs/SETUP_GUIDE.md",
      "docs/DIAGNOSTICS.md",
      "docs/STATUS_ENDPOINT.md",
@@ -66,8 +69,9 @@
      "scripts/apply-source-update.ps1",
      "scripts/apply-binary-update.ps1",
      "scripts/prune-dist.mjs",
+      "scripts/sign-release-manifest.mjs",
      "docs/RELEASE_NOTES_0.4.0.md",
-      "docs/LUMAOPS_SERVER_AUDIT.md",
+      "docs/DEPLOYMENT_MIGRATION_EXAMPLE.md",
      "docs/SSH_UNRAID_DEPLOYMENT.md",
      "docs/RELEASE_NOTES_0.4.1.md",
      "docs/RELEASE_NOTES_0.4.2.md",
@@ -108,6 +112,18 @@
      "docs/RELEASE_NOTES_0.10.1.md",
      "docs/RELEASE_NOTES_0.10.2.md",
      "docs/RELEASE_NOTES_0.10.3.md",
+      "docs/RELEASE_NOTES_0.10.4.md",
+      "docs/RELEASE_NOTES_0.10.5.md",
+      "docs/RELEASE_NOTES_0.10.6.md",
+      "docs/RELEASE_NOTES_0.10.7.md",
+      "docs/RELEASE_NOTES_0.10.8.md",
+      "docs/RELEASE_NOTES_0.10.9.md",
+      "docs/RELEASE_NOTES_0.10.10.md",
+      "docs/RELEASE_NOTES_0.10.11.md",
+      "docs/RELEASE_NOTES_0.10.12.md",
+      "docs/RELEASE_NOTES_0.10.13.md",
+      "docs/RELEASE_NOTES_0.10.14.md",
+      "docs/RELEASE_NOTES_0.10.15.md",
      "docs/CURRENT_STATE.md",
      "docs/MUTATION_MODEL.md",
      "docs/RELEASING.md",
@@ -18,14 +18,14 @@ export default defineConfig({
  workers: process.env.CI ? 2 : 3,
  reporter: [["line"], ["html", { outputFolder: "artifacts/browser-report", open: "never" }]],
  use: {
-    baseURL: "http://127.0.0.1:4173",
+    baseURL: "http://127.0.0.1:41737",
    screenshot: "only-on-failure",
    trace: "retain-on-failure",
    video: "retain-on-failure",
  },
  webServer: {
    command: "node scripts/serve-demo.mjs",
-    url: "http://127.0.0.1:4173",
+    url: "http://127.0.0.1:41737/__forgeflow_test_ready__",
    reuseExistingServer: !process.env.CI,
    timeout: 30_000,
  },
@@ -46,7 +46,7 @@ contextBridge.exposeInMainWorld(
    applyUpdate: () => invoke('updates:apply'),
    saveServer: (server, password = '', passphrase = '') => invoke('server:save', { server, password, passphrase }),
    deleteServer: (serverId) => invoke('server:delete', { serverId }),
-    testServer: (serverId) => invoke('server:test', { serverId }),
+    testServer: (serverId, expectedFingerprint = '') => invoke('server:test', { serverId, expectedFingerprint }),
    inspectServerProject: (repository, profileId) => invoke('server:inspect-project', { repository, profileId }),
    discoverExistingDeployment: (repository, serverId, remoteFolder) =>
      invoke('server:discover-existing', {
@@ -54,7 +54,7 @@ contextBridge.exposeInMainWorld(
        serverId,
        remoteFolder,
      }),
-    refreshRepositories: () => invoke('repositories:refresh'),
+    refreshRepositories: (options = {}) => invoke('repositories:refresh', options),
    discoverRepositories: (roots) => invoke('repositories:discover', { roots }),
    favoriteRepository: (fullName, favorite) => invoke('repository:favorite', { fullName, favorite }),
    linkRepository: (fullName, localPath) => invoke('repository:link', { fullName, localPath }),
@@ -97,6 +97,8 @@ contextBridge.exposeInMainWorld(
    repairGitLocks: (localPath, force = false) => invoke('repository:repair-git-locks', { localPath, force }),
    reconcileRepository: (localPath) => invoke('repository:reconcile', { localPath }),
    repairRepositorySync: (localPath, strategy) => invoke('repository:repair-sync', { localPath, strategy }),
+    previewWorkspaceSync: (localPath) => invoke('repository:workspace-sync-preview', { localPath }),
+    applyWorkspaceSync: (localPath, expectedPlanId) => invoke('repository:workspace-sync-apply', { localPath, expectedPlanId }),
    setOrigin: (localPath, remoteUrl) => invoke('repository:set-origin', { localPath, remoteUrl }),
    normalizeOrigins: () => invoke('repositories:normalize-origins'),
    cloneRepository: (fullName, mode = 'default') => invoke('repository:clone', { fullName, mode }),
@@ -118,7 +120,6 @@ contextBridge.exposeInMainWorld(
        overrideReason: options.overrideReason || '',
      }),
    rollback: (repository, profileId, targetSha) => invoke('deployment:rollback', { repository, profileId, targetSha }),
-    healthcheck: (url) => invoke('deployment:health', { url }),
    refreshProfileState: (fullName, profileId) => invoke('deployment:profile-state', { fullName, profileId }),
    discoverServerDeployments: () => invoke('deployment:discover-server-workloads'),
    planServerReconciliation: (serverId) => invoke('deployment:plan-server-reconciliation', { serverId }),
@@ -1,17 +1,89 @@
 {
-  "generatedAt": "2026-07-29T22:49:48.766Z",
+  "generatedAt": "2026-08-29T22:58:20.416Z",
  "thresholds": {
    "preferredMaximumLines": 750,
    "justificationRequiredLines": 1000
  },
-  "over750": [],
+  "over750": [
+    {
+      "file": "src/main/git-service.cjs",
+      "lines": 950,
+      "branches": 139,
+      "functions": 152,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "git",
+        "renderer",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 159
+    },
+    {
+      "file": "src/renderer/views.js",
+      "lines": 876,
+      "branches": 61,
+      "functions": 161,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "inventory",
+        "deployment",
+        "git",
+        "renderer",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 101
+    },
+    {
+      "file": "src/main/update-service.cjs",
+      "lines": 854,
+      "branches": 64,
+      "functions": 65,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "git",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 74
+    },
+    {
+      "file": "src/renderer/mock-repository-bridge.js",
+      "lines": 780,
+      "branches": 19,
+      "functions": 100,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "deployment",
+        "git",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 39
+    }
+  ],
  "over1000": [],
  "cyclomaticHotspots": [
+    {
+      "file": "src/main/git-service.cjs",
+      "lines": 950,
+      "branches": 139,
+      "functions": 152,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "git",
+        "renderer",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 159
+    },
    {
      "file": "src/renderer/actions/shell.js",
-      "lines": 506,
-      "branches": 98,
-      "functions": 84,
+      "lines": 531,
+      "branches": 103,
+      "functions": 90,
      "ipcHandlers": 0,
      "responsibilities": [
        "inventory",
@@ -20,7 +92,23 @@
        "renderer",
        "updates"
      ],
-      "hotspotScore": 128
+      "hotspotScore": 133
+    },
+    {
+      "file": "src/renderer/app.js",
+      "lines": 738,
+      "branches": 80,
+      "functions": 124,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "inventory",
+        "deployment",
+        "git",
+        "renderer",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 120
    },
    {
      "file": "src/main/server-inventory.cjs",
@@ -38,23 +126,41 @@
      "hotspotScore": 119
    },
    {
-      "file": "src/main/git-service.cjs",
-      "lines": 632,
-      "branches": 98,
-      "functions": 109,
+      "file": "src/main/unraid-inventory-methods.cjs",
+      "lines": 710,
+      "branches": 76,
+      "functions": 93,
      "ipcHandlers": 0,
      "responsibilities": [
-        "git"
+        "inventory",
+        "deployment",
+        "git",
+        "security",
+        "updates"
      ],
-      "hotspotScore": 98
+      "hotspotScore": 106
    }
  ],
  "mixedResponsibilityModules": [
+    {
+      "file": "src/main/git-service.cjs",
+      "lines": 950,
+      "branches": 139,
+      "functions": 152,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "git",
+        "renderer",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 159
+    },
    {
      "file": "src/renderer/actions/shell.js",
-      "lines": 506,
-      "branches": 98,
-      "functions": 84,
+      "lines": 531,
+      "branches": 103,
+      "functions": 90,
      "ipcHandlers": 0,
      "responsibilities": [
        "inventory",
@@ -63,7 +169,23 @@
        "renderer",
        "updates"
      ],
-      "hotspotScore": 128
+      "hotspotScore": 133
+    },
+    {
+      "file": "src/renderer/app.js",
+      "lines": 738,
+      "branches": 80,
+      "functions": 124,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "inventory",
+        "deployment",
+        "git",
+        "renderer",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 120
    },
    {
      "file": "src/main/server-inventory.cjs",
@@ -81,10 +203,25 @@
      "hotspotScore": 119
    },
    {
-      "file": "src/renderer/app.js",
-      "lines": 667,
-      "branches": 74,
-      "functions": 110,
+      "file": "src/main/unraid-inventory-methods.cjs",
+      "lines": 710,
+      "branches": 76,
+      "functions": 93,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "inventory",
+        "deployment",
+        "git",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 106
+    },
+    {
+      "file": "src/renderer/views.js",
+      "lines": 876,
+      "branches": 61,
+      "functions": 161,
      "ipcHandlers": 0,
      "responsibilities": [
        "inventory",
@@ -94,28 +231,27 @@
        "security",
        "updates"
      ],
-      "hotspotScore": 114
+      "hotspotScore": 101
    },
    {
-      "file": "src/main/ipc.cjs",
-      "lines": 749,
-      "branches": 55,
-      "functions": 79,
-      "ipcHandlers": 27,
+      "file": "src/renderer/dialogs.js",
+      "lines": 435,
+      "branches": 60,
+      "functions": 83,
+      "ipcHandlers": 0,
      "responsibilities": [
        "inventory",
        "deployment",
        "git",
-        "ipc",
        "renderer",
        "security",
        "updates"
      ],
-      "hotspotScore": 105
+      "hotspotScore": 100
    },
    {
      "file": "src/main/unraid-deployment-methods.cjs",
-      "lines": 577,
+      "lines": 583,
      "branches": 69,
      "functions": 31,
      "ipcHandlers": 0,
@@ -129,41 +265,40 @@
      "hotspotScore": 99
    },
    {
-      "file": "src/renderer/views.js",
-      "lines": 693,
-      "branches": 53,
-      "functions": 138,
-      "ipcHandlers": 0,
+      "file": "src/main/ipc.cjs",
+      "lines": 706,
+      "branches": 54,
+      "functions": 72,
+      "ipcHandlers": 27,
      "responsibilities": [
        "inventory",
        "deployment",
        "git",
-        "renderer",
+        "ipc",
        "security",
        "updates"
      ],
-      "hotspotScore": 93
+      "hotspotScore": 94
    },
    {
-      "file": "src/main/unraid-inventory-methods.cjs",
-      "lines": 591,
-      "branches": 61,
-      "functions": 76,
+      "file": "src/main/ssh-service.cjs",
+      "lines": 513,
+      "branches": 70,
+      "functions": 101,
      "ipcHandlers": 0,
      "responsibilities": [
-        "inventory",
        "deployment",
        "git",
        "security",
        "updates"
      ],
-      "hotspotScore": 91
+      "hotspotScore": 90
    },
    {
      "file": "src/renderer/actions/setup-and-settings.js",
-      "lines": 427,
-      "branches": 58,
-      "functions": 58,
+      "lines": 441,
+      "branches": 60,
+      "functions": 60,
      "ipcHandlers": 0,
      "responsibilities": [
        "deployment",
@@ -172,42 +307,13 @@
        "security",
        "updates"
      ],
-      "hotspotScore": 88
-    },
-    {
-      "file": "src/main/gitea-service.cjs",
-      "lines": 618,
-      "branches": 66,
-      "functions": 57,
-      "ipcHandlers": 0,
-      "responsibilities": [
-        "deployment",
-        "git",
-        "security",
-        "updates"
-      ],
-      "hotspotScore": 86
-    },
-    {
-      "file": "src/renderer/actions/deployment-profile.js",
-      "lines": 402,
-      "branches": 56,
-      "functions": 43,
-      "ipcHandlers": 0,
-      "responsibilities": [
-        "inventory",
-        "deployment",
-        "git",
-        "renderer",
-        "security"
-      ],
-      "hotspotScore": 86
+      "hotspotScore": 90
    },
    {
      "file": "main.cjs",
-      "lines": 443,
-      "branches": 33,
-      "functions": 53,
+      "lines": 471,
+      "branches": 39,
+      "functions": 57,
      "ipcHandlers": 0,
      "responsibilities": [
        "inventory",
@@ -218,13 +324,71 @@
        "security",
        "updates"
      ],
-      "hotspotScore": 83
+      "hotspotScore": 89
+    },
+    {
+      "file": "src/main/gitea-service.cjs",
+      "lines": 624,
+      "branches": 67,
+      "functions": 57,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "deployment",
+        "git",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 87
+    },
+    {
+      "file": "src/renderer/actions/deployment-profile.js",
+      "lines": 408,
+      "branches": 57,
+      "functions": 44,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "inventory",
+        "deployment",
+        "git",
+        "renderer",
+        "security"
+      ],
+      "hotspotScore": 87
+    },
+    {
+      "file": "src/renderer/actions/recovery.js",
+      "lines": 422,
+      "branches": 64,
+      "functions": 43,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "deployment",
+        "git",
+        "renderer",
+        "updates"
+      ],
+      "hotspotScore": 84
+    },
+    {
+      "file": "src/main/config-store.cjs",
+      "lines": 668,
+      "branches": 52,
+      "functions": 89,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "inventory",
+        "deployment",
+        "git",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 82
    },
    {
      "file": "src/main/unraid-preflight-methods.cjs",
-      "lines": 594,
-      "branches": 38,
-      "functions": 42,
+      "lines": 623,
+      "branches": 40,
+      "functions": 47,
      "ipcHandlers": 0,
      "responsibilities": [
        "inventory",
@@ -234,22 +398,7 @@
        "security",
        "updates"
      ],
-      "hotspotScore": 78
-    },
-    {
-      "file": "src/main/config-store.cjs",
-      "lines": 652,
-      "branches": 47,
-      "functions": 86,
-      "ipcHandlers": 0,
-      "responsibilities": [
-        "inventory",
-        "deployment",
-        "git",
-        "security",
-        "updates"
-      ],
-      "hotspotScore": 77
+      "hotspotScore": 80
    },
    {
      "file": "src/main/unraid-runtime-methods.cjs",
@@ -267,41 +416,11 @@
      ],
      "hotspotScore": 77
    },
-    {
-      "file": "src/renderer/actions/recovery.js",
-      "lines": 356,
-      "branches": 56,
-      "functions": 38,
-      "ipcHandlers": 0,
-      "responsibilities": [
-        "deployment",
-        "git",
-        "renderer",
-        "updates"
-      ],
-      "hotspotScore": 76
-    },
-    {
-      "file": "src/renderer/dialogs.js",
-      "lines": 324,
-      "branches": 35,
-      "functions": 66,
-      "ipcHandlers": 0,
-      "responsibilities": [
-        "inventory",
-        "deployment",
-        "git",
-        "renderer",
-        "security",
-        "updates"
-      ],
-      "hotspotScore": 75
-    },
    {
      "file": "src/main/unraid-access-methods.cjs",
-      "lines": 448,
+      "lines": 462,
      "branches": 43,
-      "functions": 42,
+      "functions": 41,
      "ipcHandlers": 0,
      "responsibilities": [
        "inventory",
@@ -313,10 +432,40 @@
      "hotspotScore": 73
    },
    {
-      "file": "src/main/ssh-service.cjs",
-      "lines": 333,
-      "branches": 41,
-      "functions": 69,
+      "file": "src/main/diagnostics-service.cjs",
+      "lines": 377,
+      "branches": 39,
+      "functions": 51,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "deployment",
+        "git",
+        "ipc",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 69
+    },
+    {
+      "file": "src/renderer/events.js",
+      "lines": 189,
+      "branches": 37,
+      "functions": 28,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "inventory",
+        "deployment",
+        "git",
+        "renderer",
+        "security"
+      ],
+      "hotspotScore": 67
+    },
+    {
+      "file": "src/main/git-validator-service.cjs",
+      "lines": 600,
+      "branches": 43,
+      "functions": 77,
      "ipcHandlers": 0,
      "responsibilities": [
        "deployment",
@@ -324,7 +473,7 @@
        "security",
        "updates"
      ],
-      "hotspotScore": 61
+      "hotspotScore": 63
    },
    {
      "file": "src/main/deploy-key-lifecycle-service.cjs",
@@ -341,35 +490,6 @@
      ],
      "hotspotScore": 61
    },
-    {
-      "file": "src/renderer/events.js",
-      "lines": 172,
-      "branches": 31,
-      "functions": 26,
-      "ipcHandlers": 0,
-      "responsibilities": [
-        "inventory",
-        "deployment",
-        "git",
-        "renderer",
-        "security"
-      ],
-      "hotspotScore": 61
-    },
-    {
-      "file": "src/main/git-validator-service.cjs",
-      "lines": 588,
-      "branches": 40,
-      "functions": 74,
-      "ipcHandlers": 0,
-      "responsibilities": [
-        "deployment",
-        "git",
-        "security",
-        "updates"
-      ],
-      "hotspotScore": 60
-    },
    {
      "file": "src/main/unraid-deployment-service.cjs",
      "lines": 525,
@@ -384,20 +504,6 @@
      ],
      "hotspotScore": 55
    },
-    {
-      "file": "src/main/diagnostics-service.cjs",
-      "lines": 357,
-      "branches": 34,
-      "functions": 50,
-      "ipcHandlers": 0,
-      "responsibilities": [
-        "deployment",
-        "git",
-        "security",
-        "updates"
-      ],
-      "hotspotScore": 54
-    },
    {
      "file": "src/renderer/actions/inventory.js",
      "lines": 186,
@@ -429,7 +535,7 @@
    },
    {
      "file": "src/main/ipc/deployment-handlers.cjs",
-      "lines": 285,
+      "lines": 286,
      "branches": 13,
      "functions": 38,
      "ipcHandlers": 24,
@@ -445,9 +551,9 @@
    },
    {
      "file": "preload.cjs",
-      "lines": 162,
+      "lines": 164,
      "branches": 2,
-      "functions": 123,
+      "functions": 125,
      "ipcHandlers": 0,
      "responsibilities": [
        "inventory",
@@ -477,7 +583,7 @@
    },
    {
      "file": "src/renderer/mock-deployment-bridge.js",
-      "lines": 679,
+      "lines": 701,
      "branches": 11,
      "functions": 87,
      "ipcHandlers": 0,
@@ -523,9 +629,9 @@
    },
    {
      "file": "src/main/unraid-state-methods.cjs",
-      "lines": 283,
-      "branches": 15,
-      "functions": 20,
+      "lines": 294,
+      "branches": 16,
+      "functions": 21,
      "ipcHandlers": 0,
      "responsibilities": [
        "inventory",
@@ -534,7 +640,7 @@
        "security",
        "updates"
      ],
-      "hotspotScore": 45
+      "hotspotScore": 46
    },
    {
      "file": "src/main/preflight-service.cjs",
@@ -550,6 +656,34 @@
      ],
      "hotspotScore": 44
    },
+    {
+      "file": "src/main/repository-service.cjs",
+      "lines": 304,
+      "branches": 22,
+      "functions": 46,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "deployment",
+        "git",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 42
+    },
+    {
+      "file": "src/renderer/mock-repository-bridge.js",
+      "lines": 780,
+      "branches": 19,
+      "functions": 100,
+      "ipcHandlers": 0,
+      "responsibilities": [
+        "deployment",
+        "git",
+        "security",
+        "updates"
+      ],
+      "hotspotScore": 39
+    },
    {
      "file": "src/renderer/mock-bridge.js",
      "lines": 590,
@@ -564,34 +698,6 @@
      ],
      "hotspotScore": 37
    },
-    {
-      "file": "src/renderer/mock-repository-bridge.js",
-      "lines": 636,
-      "branches": 13,
-      "functions": 89,
-      "ipcHandlers": 0,
-      "responsibilities": [
-        "deployment",
-        "git",
-        "security",
-        "updates"
-      ],
-      "hotspotScore": 33
-    },
-    {
-      "file": "src/main/repository-service.cjs",
-      "lines": 200,
-      "branches": 12,
-      "functions": 32,
-      "ipcHandlers": 0,
-      "responsibilities": [
-        "deployment",
-        "git",
-        "security",
-        "updates"
-      ],
-      "hotspotScore": 32
-    },
    {
      "file": "src/main/deployment-identity.cjs",
      "lines": 36,
@@ -637,7 +743,7 @@
    },
    {
      "file": "src/main/unraid-deploy-key-host.cjs",
-      "lines": 77,
+      "lines": 80,
      "branches": 7,
      "functions": 22,
      "ipcHandlers": 0,
@@ -653,24 +759,23 @@
  "ipcHotspots": [
    {
      "file": "src/main/ipc.cjs",
-      "lines": 749,
-      "branches": 55,
-      "functions": 79,
+      "lines": 706,
+      "branches": 54,
+      "functions": 72,
      "ipcHandlers": 27,
      "responsibilities": [
        "inventory",
        "deployment",
        "git",
        "ipc",
-        "renderer",
        "security",
        "updates"
      ],
-      "hotspotScore": 105
+      "hotspotScore": 94
    },
    {
      "file": "src/main/ipc/deployment-handlers.cjs",
-      "lines": 285,
+      "lines": 286,
      "branches": 13,
      "functions": 38,
      "ipcHandlers": 24,
@@ -686,10 +791,10 @@
    },
    {
      "file": "src/main/ipc/repository-handlers.cjs",
-      "lines": 411,
+      "lines": 451,
      "branches": 16,
-      "functions": 79,
-      "ipcHandlers": 51,
+      "functions": 83,
+      "ipcHandlers": 53,
      "responsibilities": [
        "git",
        "ipc"
@@ -1,12 +1,15 @@
 # ForgeFlow architecture audit

-Generated 2026-07-29T22:49:48.766Z. Complexity is a deterministic decision-point count used for hotspot ranking, not a claim of exact McCabe complexity.
+Generated 2026-08-29T22:58:20.416Z. Complexity is a deterministic decision-point count used for hotspot ranking, not a claim of exact McCabe complexity.

 ## Files above 750 lines

 | File | Lines | Decisions | Functions | IPC handlers | Responsibilities |
 |---|---:|---:|---:|---:|---|
-No findings.
+| `src/main/git-service.cjs` | 950 | 139 | 152 | 0 | git, renderer, security, updates |
+| `src/renderer/views.js` | 876 | 61 | 161 | 0 | inventory, deployment, git, renderer, security, updates |
+| `src/main/update-service.cjs` | 854 | 64 | 65 | 0 | git, security, updates |
+| `src/renderer/mock-repository-bridge.js` | 780 | 19 | 100 | 0 | deployment, git, security, updates |

 ## Files above 1,000 lines

@@ -18,9 +21,11 @@ No findings.

 | File | Lines | Decisions | Functions | IPC handlers | Responsibilities |
 |---|---:|---:|---:|---:|---|
-| `src/renderer/actions/shell.js` | 506 | 98 | 84 | 0 | inventory, deployment, git, renderer, updates |
+| `src/main/git-service.cjs` | 950 | 139 | 152 | 0 | git, renderer, security, updates |
+| `src/renderer/actions/shell.js` | 531 | 103 | 90 | 0 | inventory, deployment, git, renderer, updates |
+| `src/renderer/app.js` | 738 | 80 | 124 | 0 | inventory, deployment, git, renderer, security, updates |
 | `src/main/server-inventory.cjs` | 578 | 89 | 104 | 0 | inventory, deployment, git, security, updates |
-| `src/main/git-service.cjs` | 632 | 98 | 109 | 0 | git |
+| `src/main/unraid-inventory-methods.cjs` | 710 | 76 | 93 | 0 | inventory, deployment, git, security, updates |

 ## Interpretation

@@ -7,7 +7,9 @@ param(
  [Parameter(Mandatory = $true)][int]$ParentPid,
  [Parameter(Mandatory = $true)][string]$LogPath,
  [Parameter(Mandatory = $true)][string]$StatusPath,
-  [Parameter(Mandatory = $true)][string]$UpdateId
+  [Parameter(Mandatory = $true)][string]$UpdateId,
+  [switch]$HandshakeOnly,
+  [switch]$VerifyOnly
 )

 $ErrorActionPreference = "Stop"
@@ -27,22 +29,62 @@ function Write-UpdateState {
    updatedAt = [DateTime]::UtcNow.ToString("o")
  }
  if ($State -in @("success", "failed", "rolled-back")) { $payload.completedAt = [DateTime]::UtcNow.ToString("o") }
+  $directory = Split-Path -Parent $StatusPath
+  if ($directory) { New-Item -ItemType Directory -Force -Path $directory | Out-Null }
  $temporary = "$StatusPath.$PID.tmp"
-  $payload | ConvertTo-Json -Depth 4 | Set-Content -LiteralPath $temporary -Encoding UTF8
-  if (Test-Path -LiteralPath $StatusPath) { [IO.File]::Replace($temporary, $StatusPath, $null) }
-  else { Move-Item -LiteralPath $temporary -Destination $StatusPath }
+  $backup = "$StatusPath.$PID.bak"
+  $json = $payload | ConvertTo-Json -Depth 4
+  $utf8NoBom = New-Object System.Text.UTF8Encoding($false)
+  [IO.File]::WriteAllText($temporary, $json, $utf8NoBom)
+  try {
+    if ([IO.File]::Exists($StatusPath)) {
+      [IO.File]::Replace($temporary, $StatusPath, $backup)
+      [IO.File]::Delete($backup)
+    } else {
+      [IO.File]::Move($temporary, $StatusPath)
+    }
+  } catch {
+    [IO.File]::Copy($temporary, $StatusPath, $true)
+    [IO.File]::Delete($temporary)
+    if ([IO.File]::Exists($backup)) { [IO.File]::Delete($backup) }
+  }
 }
-
 function Write-Log([string]$Message) {
  "{0} {1}" -f [DateTime]::UtcNow.ToString("o"), $Message | Add-Content -LiteralPath $LogPath -Encoding UTF8
 }
+function Get-Sha256([string]$Path) {
+  $stream = [IO.File]::OpenRead($Path)
+  $algorithm = [Security.Cryptography.SHA256]::Create()
+  try {
+    return ([BitConverter]::ToString($algorithm.ComputeHash($stream))).Replace("-", "").ToLowerInvariant()
+  } finally {
+    $algorithm.Dispose()
+    $stream.Dispose()
+  }
+}
+
+function Start-ForgeFlowAndVerify([string]$Executable) {
+  $process = Start-Process -FilePath $Executable -WorkingDirectory (Split-Path -Parent $Executable) -PassThru
+  Start-Sleep -Milliseconds 1500
+  if (-not $process -or $process.HasExited) { throw "ForgeFlow restart process exited before the application could stay running." }
+  return $process
+}

 try {
-  Write-UpdateState -State "started" -Message "Binary updater owns the update request."
  Write-Log "Validating ForgeFlow $ExpectedVersion binary update."
-  $actualSha256 = (Get-FileHash -LiteralPath $BinaryPath -Algorithm SHA256).Hash.ToLowerInvariant()
+  if ($HandshakeOnly) {
+    Write-UpdateState -State "started" -Message "Binary updater owns the update request."
+    Write-Log "Handshake-only verification completed successfully."
+    exit 0
+  }
+  $actualSha256 = Get-Sha256 -Path $BinaryPath
  if ($actualSha256 -ne $ExpectedSha256.ToLowerInvariant()) { throw "Binary update SHA-256 verification failed." }
  if (-not (Test-Path -LiteralPath $CurrentExecutable -PathType Leaf)) { throw "Current ForgeFlow executable was not found." }
+  Write-UpdateState -State "started" -Message "Binary preflight passed; updater owns the update request."
+  if ($VerifyOnly) {
+    Write-Log "Verification-only SHA-256 check completed successfully."
+    exit 0
+  }

  Write-UpdateState -State "waiting-for-exit" -Message "Waiting for ForgeFlow to close."
  try { Wait-Process -Id $ParentPid -Timeout 60 -ErrorAction Stop } catch {
@@ -56,9 +98,16 @@ try {
    try {
      Copy-Item -LiteralPath $BinaryPath -Destination $CurrentExecutable -Force
    } catch {
-      Copy-Item -LiteralPath $backupPath -Destination $CurrentExecutable -Force
-      Write-UpdateState -State "rolled-back" -Message $_.Exception.Message
-      throw
+      $copyFailure = $_.Exception.Message
+      try {
+        Copy-Item -LiteralPath $backupPath -Destination $CurrentExecutable -Force
+        $rollbackRestart = Start-ForgeFlowAndVerify -Executable $CurrentExecutable
+        Write-Log "Portable replacement failed; previous ForgeFlow restored and restarted as PID $($rollbackRestart.Id)."
+        Write-UpdateState -State "rolled-back" -Message $copyFailure -RestartLaunched $true
+      } catch {
+        Write-UpdateState -State "failed" -Message "$copyFailure Rollback also failed: $($_.Exception.Message)" -RestartLaunched $false
+      }
+      throw $copyFailure
    }
  } else {
    Write-UpdateState -State "applying" -Message "Running the verified ForgeFlow installer."
@@ -66,13 +115,31 @@ try {
    if ($installer.ExitCode -ne 0) { throw "ForgeFlow installer exited with code $($installer.ExitCode)." }
  }

-  $restart = Start-Process -FilePath $CurrentExecutable -WorkingDirectory (Split-Path -Parent $CurrentExecutable) -PassThru
-  Write-Log "ForgeFlow $ExpectedVersion installed; restart PID $($restart.Id)."
-  Write-UpdateState -State "success" -Message "ForgeFlow $ExpectedVersion installed successfully." -RestartLaunched $true
+  try {
+    $restart = Start-ForgeFlowAndVerify -Executable $CurrentExecutable
+    Write-Log "ForgeFlow $ExpectedVersion installed; verified restart PID $($restart.Id)."
+    Write-UpdateState -State "success" -Message "ForgeFlow $ExpectedVersion installed successfully." -RestartLaunched $true
+  } catch {
+    $restartFailure = $_.Exception.Message
+    if ($isPortable -and $backupPath -and (Test-Path -LiteralPath $backupPath -PathType Leaf)) {
+      Write-Log "Updated portable executable failed its restart probe; restoring the previous executable."
+      try {
+        Copy-Item -LiteralPath $backupPath -Destination $CurrentExecutable -Force
+        $rollbackRestart = Start-ForgeFlowAndVerify -Executable $CurrentExecutable
+        Write-Log "Previous ForgeFlow restored and restarted as PID $($rollbackRestart.Id)."
+        Write-UpdateState -State "rolled-back" -Message $restartFailure -RestartLaunched $true
+      } catch {
+        Write-UpdateState -State "failed" -Message "$restartFailure Rollback also failed: $($_.Exception.Message)" -RestartLaunched $false
+      }
+      exit 1
+    }
+    Write-Log "ForgeFlow $ExpectedVersion installed, but automatic restart failed: $restartFailure"
+    Write-UpdateState -State "success" -Message "ForgeFlow $ExpectedVersion installed successfully, but must be started manually." -RestartLaunched $false
+  }
 } catch {
  Write-Log $_.Exception.Message
  $current = $null
  try { $current = Get-Content -LiteralPath $StatusPath -Raw | ConvertFrom-Json } catch {}
-  if ($current.state -ne "rolled-back") { Write-UpdateState -State "failed" -Message $_.Exception.Message }
+  if ($current.state -notin @("rolled-back", "failed")) { Write-UpdateState -State "failed" -Message $_.Exception.Message }
  exit 1
 }
@@ -54,15 +54,31 @@ function Write-UpdateState {
    if ([System.IO.File]::Exists($StatusPath)) {
      # Windows PowerShell 5.1 does not reliably let Move-Item -Force replace
      # an existing file. File.Replace is atomic on the local NTFS volume.
-      [System.IO.File]::Replace($temporary, $StatusPath, $null)
+      $backup = "$StatusPath.$PID.bak"
+      [System.IO.File]::Replace($temporary, $StatusPath, $backup)
    } else {
      [System.IO.File]::Move($temporary, $StatusPath)
    }
  } catch {
    # Some filesystems do not implement File.Replace. Copy with overwrite is
    # the deterministic fallback; the temporary file is removed afterwards.
-    [System.IO.File]::Copy($temporary, $StatusPath, $true)
-    [System.IO.File]::Delete($temporary)
+    if ([System.IO.File]::Exists($temporary)) {
+      [System.IO.File]::Copy($temporary, $StatusPath, $true)
+      [System.IO.File]::Delete($temporary)
+    }
+  } finally {
+    if ([System.IO.File]::Exists($backup)) { [System.IO.File]::Delete($backup) }
+  }
+}
+
+function Get-Sha256([string]$Path) {
+  $stream = [IO.File]::OpenRead($Path)
+  $algorithm = [Security.Cryptography.SHA256]::Create()
+  try {
+    return ([BitConverter]::ToString($algorithm.ComputeHash($stream))).Replace("-", "").ToLowerInvariant()
+  } finally {
+    $algorithm.Dispose()
+    $stream.Dispose()
  }
 }

@@ -101,13 +117,20 @@ function Start-ForgeFlow {

 try {
  Write-UpdateLog "ForgeFlow source update helper started for version $ExpectedVersion."
-  Write-UpdateState -State "started" -Message "The external update helper started successfully." -Extra @{ helperPid = $PID; startedAt = (Get-Date).ToUniversalTime().ToString("o") }

  if ($HandshakeOnly) {
+    Write-UpdateState -State "started" -Message "The external update helper started successfully." -Extra @{ helperPid = $PID; startedAt = (Get-Date).ToUniversalTime().ToString("o") }
    Write-UpdateLog "Handshake-only verification completed successfully."
    exit 0
  }

+  if (Test-Path -LiteralPath (Join-Path $SourcePath ".git")) {
+    throw "Integrated source update refuses to overwrite a Git working tree. Use normal Git/ForgeFlow workspace sync so local commits and dirty files remain reviewable."
+  }
+  $actualHash = Get-Sha256 -Path $ArchivePath
+  if ($actualHash -ne $ExpectedSha256.ToLowerInvariant()) { throw "Update archive checksum mismatch." }
+  Write-UpdateState -State "started" -Message "Source update preflight passed; the external helper owns the request." -Extra @{ helperPid = $PID; startedAt = (Get-Date).ToUniversalTime().ToString("o") }
+
  Write-UpdateState -State "waiting-for-exit" -Message "Waiting for the running ForgeFlow process to exit."
  $deadline = (Get-Date).AddMinutes(2)
  while (Get-Process -Id $ParentPid -ErrorAction SilentlyContinue) {
@@ -115,9 +138,6 @@ try {
    Start-Sleep -Milliseconds 500
  }

-  $actualHash = (Get-FileHash -LiteralPath $ArchivePath -Algorithm SHA256).Hash.ToLowerInvariant()
-  if ($actualHash -ne $ExpectedSha256.ToLowerInvariant()) { throw "Update archive checksum mismatch." }
-
  $working = Join-Path ([IO.Path]::GetTempPath()) ("forgeflow-update-" + [guid]::NewGuid().ToString("N"))
  $extract = Join-Path $working "extract"
  $backup = Join-Path $working "backup"
@@ -117,7 +117,18 @@ app.whenReady().then(async () => {
      reviewBreakdown: Object.fromEntries(Object.entries(report.reviewBreakdown || {}).sort(([left], [right]) => left.localeCompare(right))),
      reviewSamples: report.reviewSamples,
      reconciliation: report.reconciliation,
-      access: report.access.map((item) => ({ repository: item.repository, profileId: item.profileId || null, ready: item.ready, readiness: item.readiness || item.action || null, remoteSha: item.remoteSha || item.branchSha || null, liveSha: item.liveSha || null, error: item.error || null })),
+      access: report.access.map((item) => ({
+        repository: item.repository,
+        profileId: item.profileId || null,
+        ready: item.ready,
+        deployReady: item.deployReady ?? item.ready,
+        readiness: item.readiness || item.action || null,
+        remoteSha: item.remoteSha || item.branchSha || null,
+        liveSha: item.liveSha || null,
+        blockers: (item.deploymentBlockers || []).map((check) => ({ id: check.id, detail: check.detail })),
+        warnings: (item.checks || []).filter((check) => check.status !== "pass" && !(item.deploymentBlockers || []).some((blocker) => blocker.id === check.id)).map((check) => ({ id: check.id, status: check.status, detail: check.detail })),
+        error: item.error || null,
+      })),
      review: report.workloads.filter((item) => !item.repository && item.running).map((item) => ({ name: item.name, confidence: item.confidence, folder: item.folder })),
    })) : reports;
    console.log(JSON.stringify(output, null, 2));
@@ -1,28 +1,44 @@
 import { createHash } from 'node:crypto';
-import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { readFile, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';

 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const excludedDirectories = new Set(['.git', '.forgeflow', 'artifacts', 'coverage', 'dist', 'node_modules', 'playwright-report', 'ForgeFlow-runtime-win-x64']);
 const excludedFiles = new Set(['SOURCE_MANIFEST.txt']);
+const execFileAsync = promisify(execFile);

-async function collect(directory, output = []) {
-  for (const entry of await readdir(directory, { withFileTypes: true })) {
-    if (excludedDirectories.has(entry.name)) continue;
-    const absolute = path.join(directory, entry.name);
-    if (entry.isDirectory()) await collect(absolute, output);
-    else if (!excludedFiles.has(entry.name)) output.push(absolute);
+async function collect() {
+  const { stdout } = await execFileAsync(
+    'git',
+    ['ls-files', '--cached', '--others', '--exclude-standard', '-z'],
+    { cwd: root, encoding: 'buffer', maxBuffer: 16 * 1024 * 1024 },
+  );
+  const relativePaths = stdout
+    .toString('utf8')
+    .split('\0')
+    .filter(Boolean)
+    .filter((relative) => !excludedFiles.has(relative));
+
+  const existing = [];
+  for (const relative of relativePaths) {
+    const absolute = path.resolve(root, relative);
+    try {
+      if ((await stat(absolute)).isFile()) existing.push(absolute);
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
  }
-  return output;
+  return existing;
 }

 const packageJson = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8'));
-const files = (await collect(root)).sort((left, right) => left.localeCompare(right, 'en'));
+const files = (await collect()).sort((left, right) => left.localeCompare(right, 'en'));
 const lines = [
  `ForgeFlow ${packageJson.version} source manifest`,
  'SHA-256                                                          BYTES  PATH',
-  '(The manifest excludes itself, dependencies and generated release artifacts.)'
+  '(The manifest includes tracked and non-ignored source files, excluding itself.)'
 ];

 for (const absolute of files) {
@@ -4,6 +4,7 @@ const fs = require("node:fs/promises");
 const path = require("node:path");
 const { execFileSync } = require("node:child_process");
 const { app, safeStorage } = require("electron");
+const { normalizeBaseUrl } = require("../src/shared/validation.cjs");

 const root = path.resolve(__dirname, "..");
 const configuredUserData =
@@ -19,6 +20,15 @@ function safeRepositoryPart(value, label) {
  return text;
 }

+async function readOptionalConfig(configPath) {
+  try {
+    return JSON.parse(await fs.readFile(configPath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
 async function api(baseUrl, token, pathname, options = {}) {
  const response = await fetch(`${baseUrl}/api/v1${pathname}`, {
    ...options,
@@ -50,19 +60,29 @@ app.whenReady().then(async () => {
      await fs.readFile(path.join(root, "package.json"), "utf8"),
    );
    const configPath = path.join(configuredUserData, "forgeflow-config.json");
-    const config = JSON.parse(await fs.readFile(configPath, "utf8"));
-    if (!config?.gitea?.encryptedToken) {
-      throw new Error(
-        `No encrypted Gitea token was found in ${configPath}. Sign in to Gitea once from ForgeFlow first.`,
+    const config = (await readOptionalConfig(configPath)) || {};
+    const actionsToken = String(
+      process.env.GITEA_TOKEN || process.env.FORGEFLOW_RELEASE_TOKEN || "",
+    ).trim();
+    let token = actionsToken;
+    if (!token) {
+      if (!config.gitea?.encryptedToken) {
+        throw new Error(
+          `No release token was supplied and no encrypted Gitea token was found in ${configPath}. Sign in to Gitea once from ForgeFlow or run from Gitea Actions with GITEA_TOKEN.`,
+        );
+      }
+      token = safeStorage.decryptString(
+        Buffer.from(config.gitea.encryptedToken, "base64"),
      );
    }
-    const token = safeStorage.decryptString(
-      Buffer.from(config.gitea.encryptedToken, "base64"),
-    );
-    const baseUrl = String(config.gitea.baseUrl || "").replace(/\/+$/, "");
-    if (!/^https?:\/\//i.test(baseUrl)) {
-      throw new Error("The configured Gitea base URL is invalid.");
+    const configuredBaseUrl =
+      process.env.FORGEFLOW_RELEASE_BASE_URL || config.gitea?.baseUrl;
+    if (!configuredBaseUrl) {
+      throw new Error(
+        "No Gitea release base URL was supplied. Set FORGEFLOW_RELEASE_BASE_URL or configure Gitea in ForgeFlow.",
+      );
    }
+    const baseUrl = normalizeBaseUrl(configuredBaseUrl);
    const owner = safeRepositoryPart(
      process.env.FORGEFLOW_RELEASE_OWNER || config.updates?.owner || "Jens",
      "Release repository owner",
@@ -124,11 +144,16 @@ app.whenReady().then(async () => {
    }

    if (release.draft !== true) {
-      release = await api(baseUrl, token, `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${release.id}`, {
-        method: "PATCH",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ draft: true }),
-      });
+      release = await api(
+        baseUrl,
+        token,
+        `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${release.id}`,
+        {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ draft: true }),
+        },
+      );
    }
    const binaries = [
      path.join(root, "dist", `ForgeFlow-Setup-${version}-win-x64.exe`),
@@ -181,27 +206,62 @@ app.whenReady().then(async () => {
    for (const [name, type] of [
      [`ForgeFlow-${version}-provenance.json`, "application/json"],
      [`ForgeFlow-${version}-sbom.cdx.json`, "application/vnd.cyclonedx+json"],
+      [`ForgeFlow-${version}-release-manifest.json`, "application/json"],
+      [`ForgeFlow-${version}-release-manifest.json.sig`, "application/octet-stream"],
    ]) {
      const bytes = await fs.readFile(path.join(root, "dist", name));
-      const existing = (release.assets || []).find((asset) => asset.name === name);
-      if (existing) await api(baseUrl, token, `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${release.id}/assets/${existing.id}`, { method: "DELETE" });
+      const existing = (release.assets || []).find(
+        (asset) => asset.name === name,
+      );
+      if (existing) {
+        await api(
+          baseUrl,
+          token,
+          `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${release.id}/assets/${existing.id}`,
+          { method: "DELETE" },
+        );
+      }
      const form = new FormData();
      form.append("attachment", new Blob([bytes], { type }), name);
-      const uploaded = await api(baseUrl, token, `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${release.id}/assets?name=${encodeURIComponent(name)}`, { method: "POST", body: form, timeout: 300_000 });
-      release.assets = [...(release.assets || []).filter((asset) => asset.name !== name), uploaded];
+      const uploaded = await api(
+        baseUrl,
+        token,
+        `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${release.id}/assets?name=${encodeURIComponent(name)}`,
+        { method: "POST", body: form, timeout: 300_000 },
+      );
+      release.assets = [
+        ...(release.assets || []).filter((asset) => asset.name !== name),
+        uploaded,
+      ];
    }
    const requiredAssets = [
-      ...binaries.flatMap((binaryPath) => [path.basename(binaryPath), `${path.basename(binaryPath)}.sha256`]),
+      ...binaries.flatMap((binaryPath) => [
+        path.basename(binaryPath),
+        `${path.basename(binaryPath)}.sha256`,
+      ]),
      `ForgeFlow-${version}-provenance.json`,
      `ForgeFlow-${version}-sbom.cdx.json`,
+      `ForgeFlow-${version}-release-manifest.json`,
+      `ForgeFlow-${version}-release-manifest.json.sig`,
    ];
-    const missingAssets = requiredAssets.filter((name) => !(release.assets || []).some((asset) => asset.name === name));
-    if (missingAssets.length) throw new Error(`Release remains draft because required assets are missing: ${missingAssets.join(", ")}`);
-    release = await api(baseUrl, token, `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${release.id}`, {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ draft: false }),
-    });
+    const missingAssets = requiredAssets.filter(
+      (name) => !(release.assets || []).some((asset) => asset.name === name),
+    );
+    if (missingAssets.length) {
+      throw new Error(
+        `Release remains draft because required assets are missing: ${missingAssets.join(", ")}`,
+      );
+    }
+    release = await api(
+      baseUrl,
+      token,
+      `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases/${release.id}`,
+      {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ draft: false }),
+      },
+    );
    console.log(
      `PASS  ForgeFlow ${version} binary release published to ${owner}/${repo} for ${commit.slice(0, 7)}`,
    );
@@ -4,12 +4,17 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';

 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'src', 'renderer');
-const port = Number(process.env.PORT || 4173);
+const port = Number(process.env.PORT || 41737);
 const mime = { '.html': 'text/html; charset=utf-8', '.css': 'text/css; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.svg': 'image/svg+xml' };

 const server = http.createServer(async (request, response) => {
  try {
    const pathname = decodeURIComponent(new URL(request.url, `http://${request.headers.host}`).pathname);
+    if (pathname === '/__forgeflow_test_ready__') {
+      response.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': 'no-store' });
+      response.end('forgeflow-demo-ready');
+      return;
+    }
    const relative = pathname === '/' ? 'index.html' : pathname.replace(/^\//, '');
    const target = path.resolve(root, relative);
    if (!target.startsWith(root)) throw Object.assign(new Error('Forbidden'), { code: 'EACCES' });
@@ -0,0 +1,34 @@
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const defaultPrivatePath = path.join(
+  process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"),
+  "forgeflow",
+  "release-signing-private.pem",
+);
+const privatePath = path.resolve(process.env.FORGEFLOW_UPDATE_SIGNING_PRIVATE_KEY || defaultPrivatePath);
+const publicPath = path.join(root, "build", "update-signing-public.pem");
+
+let privateKey;
+try {
+  privateKey = createPrivateKey(await readFile(privatePath));
+  if (privateKey.asymmetricKeyType !== "ed25519") throw new Error("The existing key is not Ed25519.");
+} catch (error) {
+  if (error.code !== "ENOENT") throw error;
+  privateKey = generateKeyPairSync("ed25519").privateKey;
+  await mkdir(path.dirname(privatePath), { recursive: true, mode: 0o700 });
+  await writeFile(privatePath, privateKey.export({ type: "pkcs8", format: "pem" }), { mode: 0o600, flag: "wx" });
+}
+
+const publicKey = createPublicKey(privateKey);
+const publicPem = publicKey.export({ type: "spki", format: "pem" });
+await mkdir(path.dirname(publicPath), { recursive: true });
+await writeFile(publicPath, publicPem, { mode: 0o644 });
+const fingerprint = createHash("sha256").update(publicKey.export({ type: "spki", format: "der" })).digest("hex");
+console.log(`ForgeFlow Ed25519 update key ready. Public key fingerprint: SHA256:${fingerprint}`);
+console.log(`Private key: ${privatePath}`);
+console.log(`Public key:  ${publicPath}`);
@@ -0,0 +1,46 @@
+import { createHash, createPrivateKey, createPublicKey, sign, verify } from "node:crypto";
+import { readFile, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const pkg = JSON.parse(await readFile(path.join(root, "package.json"), "utf8"));
+const privatePath = path.resolve(
+  process.env.FORGEFLOW_UPDATE_SIGNING_PRIVATE_KEY ||
+    path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "forgeflow", "release-signing-private.pem"),
+);
+const publicPath = path.join(root, "build", "update-signing-public.pem");
+const privateKey = createPrivateKey(await readFile(privatePath).catch((error) => {
+  if (error.code === "ENOENT") throw new Error(`ForgeFlow update signing key is missing. Run npm run signing:setup once. Expected: ${privatePath}`);
+  throw error;
+}));
+const publicKey = createPublicKey(await readFile(publicPath));
+if (!publicKey.equals(createPublicKey(privateKey))) throw new Error("The release private key does not match the public key embedded in ForgeFlow.");
+
+const provenance = JSON.parse(await readFile(path.join(root, "dist", `ForgeFlow-${pkg.version}-provenance.json`), "utf8"));
+const artifacts = [];
+for (const kind of ["Setup", "Portable"]) {
+  const name = `ForgeFlow-${kind}-${pkg.version}-win-x64.exe`;
+  const filePath = path.join(root, "dist", name);
+  const bytes = await readFile(filePath);
+  artifacts.push({ name, bytes: (await stat(filePath)).size, sha256: createHash("sha256").update(bytes).digest("hex") });
+}
+const keyId = createHash("sha256").update(publicKey.export({ type: "spki", format: "der" })).digest("hex");
+const manifest = {
+  schemaVersion: 1,
+  product: "ForgeFlow",
+  version: pkg.version,
+  tag: `v${pkg.version}`,
+  commit: provenance.commit,
+  buildId: provenance.buildId,
+  signature: { algorithm: "Ed25519", keyId: `SHA256:${keyId}` },
+  artifacts,
+};
+const manifestBytes = Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+const signature = sign(null, manifestBytes, privateKey);
+if (!verify(null, manifestBytes, publicKey, signature)) throw new Error("The generated release signature did not verify.");
+const manifestName = `ForgeFlow-${pkg.version}-release-manifest.json`;
+await writeFile(path.join(root, "dist", manifestName), manifestBytes, { mode: 0o644 });
+await writeFile(path.join(root, "dist", `${manifestName}.sig`), `${signature.toString("base64")}\n`, { mode: 0o644 });
+console.log(`${manifestName}: signed with SHA256:${keyId}`);
@@ -47,6 +47,8 @@ const required = [
  "scripts/validate-installed-connections.cjs",
  "scripts/publish-binary-release.cjs",
  "scripts/write-release-checksums.mjs",
+  "scripts/setup-update-signing-key.mjs",
+  "scripts/sign-release-manifest.mjs",
  "scripts/prune-dist.mjs",
  "scripts/generate-source-manifest.mjs",
  "setup-windows.ps1",
@@ -83,11 +85,23 @@ const required = [
  "docs/RELEASE_NOTES_0.10.1.md",
  "docs/RELEASE_NOTES_0.10.2.md",
  "docs/RELEASE_NOTES_0.10.3.md",
+  "docs/RELEASE_NOTES_0.10.4.md",
+  "docs/RELEASE_NOTES_0.10.5.md",
+  "docs/RELEASE_NOTES_0.10.6.md",
+  "docs/RELEASE_NOTES_0.10.7.md",
+  "docs/RELEASE_NOTES_0.10.8.md",
+  "docs/RELEASE_NOTES_0.10.9.md",
+  "docs/RELEASE_NOTES_0.10.10.md",
+  "docs/RELEASE_NOTES_0.10.11.md",
+  "docs/RELEASE_NOTES_0.10.12.md",
+  "docs/RELEASE_NOTES_0.10.13.md",
+  "docs/RELEASE_NOTES_0.10.14.md",
+  "docs/RELEASE_NOTES_0.10.15.md",
  "docs/UPDATING.md",
  "docs/DIAGNOSTICS.md",
  "docs/DEPLOYMENT_SETUP.md",
  "docs/SSH_UNRAID_DEPLOYMENT.md",
-  "docs/LUMAOPS_SERVER_AUDIT.md",
+  "docs/DEPLOYMENT_MIGRATION_EXAMPLE.md",
  "docs/STATUS_ENDPOINT.md",
  "docs/TEST_MATRIX.md",
  "docs/RELEASE_NOTES_0.4.0.md",
@@ -114,6 +128,7 @@ const required = [
  "examples/server/status-example.json",
  "build/icon.png",
  "build/icon.ico",
+  "build/update-signing-public.pem",
 ];

 for (const file of required) await access(path.join(root, file));
@@ -121,9 +136,9 @@ for (const file of required) await access(path.join(root, file));
 const packageJson = JSON.parse(
  await readFile(path.join(root, "package.json"), "utf8"),
 );
-if (packageJson.version !== "0.10.3")
+if (packageJson.version !== "0.10.15")
  throw new Error(
-    `Expected package version 0.10.3, got ${packageJson.version}.`,
+    `Expected package version 0.10.15, got ${packageJson.version}.`,
  );
 const sourceManifest = await readFile(
  path.join(root, "SOURCE_MANIFEST.txt"),
@@ -220,8 +235,8 @@ const sshGuide = await readFile(
  path.join(root, "docs/SSH_UNRAID_DEPLOYMENT.md"),
  "utf8",
 );
-const audit = await readFile(
-  path.join(root, "docs/LUMAOPS_SERVER_AUDIT.md"),
+const migrationExample = await readFile(
+  path.join(root, "docs/DEPLOYMENT_MIGRATION_EXAMPLE.md"),
  "utf8",
 );
 const releaseNotes = await readFile(
@@ -249,11 +264,11 @@ if (
  );
 }
 if (
-  !audit.includes("d42d4a7f08240c478d07466e3fabec654dc71367") ||
-  !audit.includes("source/")
+  !migrationExample.includes("complete 40-character commit SHA") ||
+  !migrationExample.includes("source/")
 ) {
  throw new Error(
-    "LumaOps audit is missing the exact matching SHA or nested repository finding.",
+    "Deployment migration example is missing exact-SHA or nested repository guidance.",
  );
 }
 for (const phrase of [
@@ -316,7 +331,7 @@ if (
 )
  throw new Error("PowerShell update helper must start directly with param(.");

-const renderer = (await Promise.all(["app.js", "views.js", "dialogs.js", "operations.js", "actions/shell.js", "actions/inventory.js", "actions/deployment-profile.js", "actions/deployment-operation.js", "actions/setup-and-settings.js", "actions/recovery.js", "actions/command.js", "events.js"].map((file) =>
+const renderer = (await Promise.all(["app.js", "diff-view.js", "views.js", "dialogs.js", "operations.js", "actions/shell.js", "actions/inventory.js", "actions/deployment-profile.js", "actions/deployment-operation.js", "actions/setup-and-settings.js", "actions/recovery.js", "actions/command.js", "events.js"].map((file) =>
  readFile(path.join(root, "src/renderer", file), "utf8"),
 ))).join("\n");
 const styles = await readFile(
@@ -449,6 +464,54 @@ const release0103 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.3.md
 for (const phrase of ["concurrently", "debounce", "animation frame", "Git Validator", "stale or forged"]) {
  if (!release0103.includes(phrase)) throw new Error(`0.10.3 release notes are missing: ${phrase}`);
 }
+const release0104 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.4.md"), "utf8");
+for (const phrase of ["Windows PowerShell 5.1", "atomic status", "handshake-only", "existing installations"]) {
+  if (!release0104.includes(phrase)) throw new Error(`0.10.4 release notes are missing: ${phrase}`);
+}
+const release0105 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.5.md"), "utf8");
+for (const phrase of ["repository workspace", "resolved profile", "Link unresolved", "reconciliation", "server workload"]) {
+  if (!release0105.includes(phrase)) throw new Error(`0.10.5 release notes are missing: ${phrase}`);
+}
+const release0106 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.6.md"), "utf8");
+for (const phrase of ["detached", "PowerShell", "production Node spawn", "source updater", "one-time direct installation"]) {
+  if (!release0106.includes(phrase)) throw new Error(`0.10.6 release notes are missing: ${phrase}`);
+}
+const release0107 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.7.md"), "utf8");
+for (const phrase of ["exact provenance", "automatic", "repository sidebar", "DevRunbook", "no container changes"]) {
+  if (!release0107.includes(phrase)) throw new Error(`0.10.7 release notes are missing: ${phrase}`);
+}
+const release0108 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.8.md"), "utf8");
+for (const phrase of ["Get-FileHash", ".NET SHA-256", "PSModulePath", "binary", "source update helpers"]) {
+  if (!release0108.includes(phrase)) throw new Error(`0.10.8 release notes are missing: ${phrase}`);
+}
+const release0109 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.9.md"), "utf8");
+for (const phrase of ["containers without healthchecks", "single-instance", "exact Gitea commit", "deploy-ready", "no containers are changed"]) {
+  if (!release0109.includes(phrase)) throw new Error(`0.10.9 release notes are missing: ${phrase}`);
+}
+const release01010 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.10.md"), "utf8");
+for (const phrase of ["read-only deploy keys", "repository deployment root", "Compose working directory", "Fix write access", "exact Gitea commit"]) {
+  if (!release01010.includes(phrase)) throw new Error(`0.10.10 release notes are missing: ${phrase}`);
+}
+const release01011 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.11.md"), "utf8");
+for (const phrase of ["last-known-good", "closed output pipe", "linked checkout origin", "read-only deploy key", "browser test server"]) {
+  if (!release01011.includes(phrase)) throw new Error(`0.10.11 release notes are missing: ${phrase}`);
+}
+const release01012 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.12.md"), "utf8");
+for (const phrase of ["coalesced", "exact Gitea commit parity", "batched Docker inspect", "bounded worker pools", "stopped container"]) {
+  if (!release01012.includes(phrase)) throw new Error(`0.10.12 release notes are missing: ${phrase}`);
+}
+const release01013 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.13.md"), "utf8");
+for (const phrase of ["Gitea workspace sync", "recovery branch", "Stale deployment links", "Ed25519-signed release manifest", "Git-toolsgrid"]) {
+  if (!release01013.includes(phrase)) throw new Error(`0.10.13 release notes are missing: ${phrase}`);
+}
+const release01014 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.14.md"), "utf8");
+for (const phrase of ["Help center", "Gitea workspace sync", "repository context", "horizontal tab navigation", "84 browser flows"]) {
+  if (!release01014.includes(phrase)) throw new Error(`0.10.14 release notes are missing: ${phrase}`);
+}
+const release01015 = await readFile(path.join(root, "docs/RELEASE_NOTES_0.10.15.md"), "utf8");
+for (const phrase of ["Workspace Sync", "Codex review manifest", "local-only", "source updater", "binary updater"]) {
+  if (!release01015.includes(phrase)) throw new Error(`0.10.15 release notes are missing: ${phrase}`);
+}
 const configSource = await readFile(path.join(root, "src/main/config-store.cjs"), "utf8");
 for (const mode of ["server-git", "push-bundle", "monitor-only"]) {
  if (!configSource.includes(mode)) throw new Error(`Deployment configuration is missing mode: ${mode}`);
@@ -25,7 +25,19 @@ for (const kind of ["Setup", "Portable"]) {
 }
 const commit = String(process.env.FORGEFLOW_BUILD_COMMIT || (await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: root })).stdout).trim();
 const buildId = String(process.env.FORGEFLOW_BUILD_ID || `${manifest.version}-${commit.slice(0, 12)}`);
-const provenance = { schemaVersion: 1, product: "ForgeFlow", version: manifest.version, commit, buildId, createdAt: new Date().toISOString(), signedRelease: process.env.FORGEFLOW_SIGNED_RELEASE === "1", expectedPublisher: process.env.FORGEFLOW_EXPECTED_PUBLISHER || null, artifacts };
+const provenance = {
+  schemaVersion: 1,
+  product: "ForgeFlow",
+  version: manifest.version,
+  commit,
+  buildId,
+  createdAt: new Date().toISOString(),
+  publisherManifestSignature: "Ed25519",
+  authenticodeSigned: process.env.FORGEFLOW_SIGNED_RELEASE === "1",
+  expectedAuthenticodePublisher:
+    process.env.FORGEFLOW_EXPECTED_PUBLISHER || null,
+  artifacts,
+};
 await writeFile(path.join(root, "dist", `ForgeFlow-${manifest.version}-provenance.json`), `${JSON.stringify(provenance, null, 2)}\n`, "utf8");
 const lock = JSON.parse(await readFile(path.join(root, "package-lock.json"), "utf8"));
 const components = Object.entries(lock.packages || {}).filter(([name]) => name.startsWith("node_modules/")).map(([name, value]) => ({ type: "library", name: name.slice(13), version: value.version || "unknown", licenses: value.license ? [{ license: { id: value.license } }] : undefined })).sort((a, b) => a.name.localeCompare(b.name));
@@ -3,8 +3,20 @@
 const fs = require('node:fs/promises');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { safeStorage } = require('electron');
-const { assertHttpUrl, assertWorkflowFileName, assertBranchName, assertEnvironmentName, assertCloneRemote, assertRepositoryRelativePath, assertRepositoryRelativePaths } = require('../shared/validation.cjs');
+const { normalizeBaseUrl, assertHttpUrl, assertWorkflowFileName, assertBranchName, assertEnvironmentName, assertCloneRemote, assertRepositoryRelativePath, assertRepositoryRelativePaths } = require('../shared/validation.cjs');
+
+let cachedSafeStorage;
+
+function getSafeStorage() {
+  if (cachedSafeStorage !== undefined) return cachedSafeStorage;
+  try {
+    const electron = require('electron');
+    cachedSafeStorage = electron && typeof electron === 'object' ? electron.safeStorage || null : null;
+  } catch {
+    cachedSafeStorage = null;
+  }
+  return cachedSafeStorage;
+}

 const DEFAULT_CONFIG = {
  schemaVersion: 13,
@@ -56,6 +68,8 @@ class ConfigStore {
    this.sessionToken = null;
    this.data = structuredClone(DEFAULT_CONFIG);
    this.saveQueue = Promise.resolve();
+    this.pendingSave = null;
+    this.lastWrittenSnapshot = null;
  }

  migrate(parsed) {
@@ -138,16 +152,27 @@ class ConfigStore {
  }

  async save() {
-    const snapshot = JSON.stringify(this.data, null, 2);
+    // Several callers persist in quick succession (a server scan writes deployment
+    // state per workload). Serializing the configuration once per call is the
+    // expensive part, so saves that are still queued share a single write of the
+    // latest data. That is equivalent because every caller asks for "persist the
+    // current configuration", not "persist the snapshot I saw".
+    if (this.pendingSave) return this.pendingSave;
    const operation = async () => {
+      this.pendingSave = null;
+      const snapshot = JSON.stringify(this.data, null, 2);
+      if (snapshot === this.lastWrittenSnapshot
+        && await fs.access(this.filePath).then(() => true).catch(() => false)) return;
      await fs.mkdir(path.dirname(this.filePath), { recursive: true });
      const temporary = `${this.filePath}.${process.pid}.${Date.now()}.${crypto.randomUUID()}.tmp`;
      await fs.writeFile(temporary, snapshot, { mode: 0o600 });
      await fs.rename(temporary, this.filePath);
      try { await fs.chmod(this.filePath, 0o600); } catch {}
+      this.lastWrittenSnapshot = snapshot;
    };
-    this.saveQueue = this.saveQueue.then(operation, operation);
-    return this.saveQueue;
+    this.pendingSave = this.saveQueue.then(operation, operation);
+    this.saveQueue = this.pendingSave.catch(() => {});
+    return this.pendingSave;
  }

  getGitValidatorState(fullName) {
@@ -202,6 +227,7 @@ class ConfigStore {
      return { persistent: true, preserved: false };
    }

+    const safeStorage = getSafeStorage();
    if (safeStorage?.isEncryptionAvailable?.()) {
      this.data.gitea.encryptedToken = safeStorage.encryptString(value).toString('base64');
      this.sessionToken = null;
@@ -217,6 +243,7 @@ class ConfigStore {
    if (this.sessionToken) return this.sessionToken;
    if (!this.data.gitea.encryptedToken) return '';
    try {
+      const safeStorage = getSafeStorage();
      return safeStorage?.decryptString?.(Buffer.from(this.data.gitea.encryptedToken, 'base64')) || '';
    } catch {
      return '';
@@ -227,6 +254,7 @@ class ConfigStore {
  encryptSecret(value) {
    const text = String(value || '');
    if (!text) return null;
+    const safeStorage = getSafeStorage();
    if (!safeStorage?.isEncryptionAvailable?.()) {
      const error = new Error('Secure credential storage is unavailable. ForgeFlow will not persist server passwords or key passphrases.');
      error.code = 'SECURE_STORAGE_UNAVAILABLE';
@@ -237,7 +265,10 @@ class ConfigStore {

  decryptSecret(value) {
    if (!value) return '';
-    try { return safeStorage?.decryptString?.(Buffer.from(value, 'base64')) || ''; }
+    try {
+      const safeStorage = getSafeStorage();
+      return safeStorage?.decryptString?.(Buffer.from(value, 'base64')) || '';
+    }
    catch { return ''; }
  }

@@ -253,7 +284,16 @@ class ConfigStore {
    const basePath = String(source.basePath || existing?.basePath || '/mnt/user/appdata').trim().replace(/\/+$/, '');
    if (!basePath.startsWith('/') || /[\r\n\0]/.test(basePath)) throw new Error('The server base path must be an absolute Unix path.');
    const privateKeyPath = String(source.privateKeyPath || existing?.privateKeyPath || '').trim();
-    const hostFingerprint = String(source.hostFingerprint || existing?.hostFingerprint || '').trim();
+    const credentialIdentityChanged = Boolean(existing && [
+      ['host', existing.host, host],
+      ['port', existing.port, port],
+      ['username', existing.username, username],
+      ['authType', existing.authType, authType],
+      ['privateKeyPath', existing.privateKeyPath, privateKeyPath]
+    ].some(([, previous, next]) => String(previous || '') !== String(next || '')));
+    const hostFingerprint = credentialIdentityChanged
+      ? ''
+      : String(source.hostFingerprint || existing?.hostFingerprint || '').trim();
    const scanRoots = uniqueStrings(source.scanRoots || existing?.scanRoots || [basePath]).map((value) => value.replace(/\/+$/, '')).filter((value) => value.startsWith('/') && !/[\r\n\0]/.test(value));
    const scanExcludes = uniqueStrings(source.scanExcludes || existing?.scanExcludes || ['backups', 'archives', 'releases', 'staging', 'testdata']).filter((value) => /^[a-zA-Z0-9._*-]+$/.test(value));
    return {
@@ -268,8 +308,8 @@ class ConfigStore {
      scanExcludes,
      privateKeyPath,
      hostFingerprint,
-      encryptedPassword: existing?.encryptedPassword || null,
-      encryptedPassphrase: existing?.encryptedPassphrase || null,
+      encryptedPassword: credentialIdentityChanged ? null : existing?.encryptedPassword || null,
+      encryptedPassphrase: credentialIdentityChanged ? null : existing?.encryptedPassphrase || null,
      createdAt: existing?.createdAt || new Date().toISOString(),
      updatedAt: new Date().toISOString()
    };
@@ -372,10 +412,19 @@ class ConfigStore {
  }

  async updateGitea({ baseUrl, token, user }) {
+    const nextBaseUrl = normalizeBaseUrl(baseUrl);
+    const currentBaseUrl = this.data.gitea.baseUrl
+      ? normalizeBaseUrl(this.data.gitea.baseUrl)
+      : '';
+    if (!String(token || '').trim() && nextBaseUrl !== currentBaseUrl && this.getToken()) {
+      const error = new Error('Enter a new Gitea token when changing the server address.');
+      error.code = 'GITEA_TOKEN_ORIGIN_CHANGED';
+      throw error;
+    }
    const tokenState = this.setToken(token, { preserveExisting: true });
    this.data.gitea = {
      ...this.data.gitea,
-      baseUrl,
+      baseUrl: nextBaseUrl,
      user: user || this.data.gitea.user,
      encryptedToken: this.data.gitea.encryptedToken
    };
@@ -602,7 +651,10 @@ class ConfigStore {
    const next = { ...this.data.preferences, ...(preferences || {}) };
    next.repositoryPollSeconds = Math.min(Math.max(Number(next.repositoryPollSeconds) || 4, 2), 60);
    next.operationPollSeconds = Math.min(Math.max(Number(next.operationPollSeconds) || 5, 3), 120);
-    next.fetchIntervalMinutes = Math.min(Math.max(Number(next.fetchIntervalMinutes) || 10, 0), 240);
+    const fetchIntervalMinutes = Number(next.fetchIntervalMinutes);
+    next.fetchIntervalMinutes = Number.isFinite(fetchIntervalMinutes)
+      ? Math.min(Math.max(fetchIntervalMinutes, 0), 240)
+      : 10;
    next.autoRefresh = next.autoRefresh !== false;
    next.preferredCloneProtocol = ['https', 'ssh'].includes(next.preferredCloneProtocol) ? next.preferredCloneProtocol : 'https';
    next.diagnosticsEnabled = next.diagnosticsEnabled !== false;
@@ -36,10 +36,6 @@ function isRunningStatus(value) {
  return ['running', 'in_progress', 'processing'].includes(String(value || '').toLowerCase());
 }

-function isQueuedStatus(value) {
-  return ['pending', 'queued', 'waiting', 'blocked', 'requested'].includes(String(value || '').toLowerCase());
-}
-
 class DeploymentService {
  constructor(store, giteaService, gitService, diagnostics = null) {
    this.store = store;
@@ -328,8 +324,15 @@ class DeploymentService {

  async refreshActiveOperations() {
    const active = this.store.data.operations.filter((item) => item.type === 'deployment' && !TERMINAL_STATUSES.has(item.status));
+    const queue = active.slice(0, 20);
    const results = [];
-    for (const operation of active.slice(0, 20)) results.push(await this.refreshOperation(operation.id));
+    const workers = Array.from({ length: Math.min(4, queue.length) }, async () => {
+      while (queue.length) {
+        const operation = queue.shift();
+        results.push(await this.refreshOperation(operation.id));
+      }
+    });
+    await Promise.all(workers);
    return results;
  }

@@ -5,7 +5,7 @@ const path = require('node:path');
 const os = require('node:os');
 const crypto = require('node:crypto');
 const { createZip } = require('../shared/zip-writer.cjs');
-const { sanitizeForDiagnostics, redactSecrets } = require('./log-redaction.cjs');
+const { sanitizeForDiagnostics } = require('./log-redaction.cjs');

 const LEVELS = { debug: 10, info: 20, warning: 30, error: 40 };

@@ -46,6 +46,9 @@ class DiagnosticsService {
    this.preferencesProvider = preferencesProvider;
    this.sessionId = crypto.randomUUID();
    this.writeChain = Promise.resolve();
+    this.pendingLines = [];
+    this.pendingFlush = null;
+    this.securedFiles = new Set();
    this.initialized = false;
    this.lastWriteError = null;
    this.lastBundlePath = null;
@@ -115,13 +118,25 @@ class DiagnosticsService {
      sessionId: this.sessionId,
      details
    });
-    const line = `${JSON.stringify(record)}\n`;
-    this.writeChain = this.writeChain.then(async () => {
+    this.pendingLines.push(`${JSON.stringify(record)}\n`);
+    // At the debug level every IPC call and every Gitea request writes a line.
+    // Records that queue up while a write is in flight are appended together, so
+    // a burst costs one open/write/close instead of one per record.
+    if (this.pendingFlush) return this.pendingFlush;
+    this.pendingFlush = this.writeChain.then(async () => {
+      this.pendingFlush = null;
+      const lines = this.pendingLines.splice(0).join('');
+      if (!lines) return true;
      try {
        if (!this.initialized) await fs.mkdir(this.logDirectory, { recursive: true, mode: 0o700 });
        const target = await this.rotateIfNeeded(this.filePathForToday());
-        await fs.appendFile(target, line, { encoding: 'utf8', mode: 0o600 });
-        try { await fs.chmod(target, 0o600); } catch {}
+        await fs.appendFile(target, lines, { encoding: 'utf8', mode: 0o600 });
+        // The mode above only applies when appendFile creates the file, so the
+        // explicit chmod is needed once per file rather than once per record.
+        if (!this.securedFiles.has(target)) {
+          try { await fs.chmod(target, 0o600); } catch { /* best effort */ }
+          this.securedFiles.add(target);
+        }
        this.lastWriteError = null;
        return true;
      } catch (error) {
@@ -129,7 +144,8 @@ class DiagnosticsService {
        return false;
      }
    });
-    return this.writeChain;
+    this.writeChain = this.pendingFlush.catch(() => {});
+    return this.pendingFlush;
  }

  debug(event, details) { return this.log('debug', event, details); }
@@ -186,7 +202,7 @@ class DiagnosticsService {
    return this.getStatus();
  }

-  async collectLogs(maxBytes = 20 * 1024 * 1024) {
+  async collectLogs(maxBytes = 20 * 1024 * 1024, { strictIdentifiers = false } = {}) {
    await this.flush();
    const output = [];
    let used = 0;
@@ -195,7 +211,16 @@ class DiagnosticsService {
      const remaining = maxBytes - used;
      const content = await fs.readFile(file.path);
      const slice = content.length > remaining ? content.subarray(content.length - remaining) : content;
-      output.push({ name: `logs/${file.name}`, data: Buffer.from(redactSecrets(slice.toString('utf8'), this.secretProvider?.() || []), 'utf8') });
+      output.push({
+        name: `logs/${file.name}`,
+        data: Buffer.from(
+          sanitizeForDiagnostics(slice.toString('utf8'), {
+            secrets: this.secretProvider?.() || [],
+            strictIdentifiers,
+          }),
+          'utf8',
+        ),
+      });
      used += slice.length;
    }
    return output;
@@ -275,9 +300,13 @@ class DiagnosticsService {
      dispatchedAt: operation.dispatchedAt,
      stages: operation.stages,
      jobs: operation.jobs,
-      logs: operation.logs,
-      failure: operation.failure,
-      pollError: operation.pollError,
+      remoteOutput: operation.logs || operation.failure || operation.pollError ? {
+        included: false,
+        reason: 'Remote build and command output is intentionally omitted because it may contain application secrets unknown to ForgeFlow.',
+        logCharacters: String(operation.logs || '').length,
+        failureRecorded: Boolean(operation.failure),
+        pollErrorRecorded: Boolean(operation.pollError)
+      } : null,
      applicationState: operation.applicationState,
      run: operation.run ? {
        id: operation.run.id,
@@ -325,7 +354,7 @@ class DiagnosticsService {
      { name: 'operations-sanitized.json', data: safeJson(sanitizedOperations) },
      { name: 'preflight.json', data: safeJson(sanitize(preflight || {})) },
      { name: 'context.json', data: safeJson(sanitize(extra || {})) },
-      ...(await this.collectLogs())
+      ...(await this.collectLogs(20 * 1024 * 1024, { strictIdentifiers: strict }))
    ];

    const safetyAudit = auditBundleEntries(entries, this.secretProvider?.() || []);
@@ -3,13 +3,26 @@
 const { spawn } = require('node:child_process');
 const path = require('node:path');

-function normalizeTool(tool, defaults) {
+const TOOL_PROFILES = Object.freeze({
+  editor: Object.freeze({
+    code: ['--reuse-window', '--goto', '{file}:{line}'],
+    'code.exe': ['--reuse-window', '--goto', '{file}:{line}'],
+    codium: ['--reuse-window', '--goto', '{file}:{line}'],
+    'codium.exe': ['--reuse-window', '--goto', '{file}:{line}'],
+  }),
+  terminal: Object.freeze({
+    wt: ['-d', '{path}'],
+    'wt.exe': ['-d', '{path}'],
+  }),
+});
+
+function normalizeTool(tool, defaults, kind) {
  const source = tool && typeof tool === 'object' ? tool : {};
  const executable = String(source.executable || defaults.executable).trim();
  if (!executable || /[\r\n\0]/.test(executable)) throw new Error('Tool executable is invalid.');
-  const args = (Array.isArray(source.args) ? source.args : defaults.args).map((item) => String(item)).slice(0, 20);
-  if (args.some((item) => /[\r\n\0]/.test(item))) throw new Error('Tool argument is invalid.');
-  return { executable, args };
+  const profile = TOOL_PROFILES[kind]?.[executable.toLowerCase()];
+  if (!profile) throw new Error(`Unsupported ${kind || 'external'} tool. Select a built-in trusted tool profile.`);
+  return { executable, args: [...profile] };
 }

 function expandTool(tool, context) {
@@ -27,7 +40,7 @@ class ExternalToolsService {
    const defaults = kind === 'terminal'
      ? { executable: 'wt.exe', args: ['-d', '{path}'] }
      : { executable: 'code', args: ['--reuse-window', '--goto', '{file}:{line}'] };
-    const configured = normalizeTool(this.store.data.preferences?.[kind], defaults);
+    const configured = normalizeTool(this.store.data.preferences?.[kind], defaults, kind);
    const invocation = expandTool(configured, { path: root, file: candidate, line });
    const child = spawn(invocation.executable, invocation.args, { cwd: root, detached: true, stdio: 'ignore', windowsHide: false, shell: false });
    child.unref();
@@ -35,4 +48,4 @@ class ExternalToolsService {
  }
 }

-module.exports = { ExternalToolsService, normalizeTool, expandTool };
+module.exports = { ExternalToolsService, normalizeTool, expandTool, TOOL_PROFILES };
@@ -2,11 +2,13 @@

 const path = require('node:path');
 const fs = require('node:fs/promises');
+const crypto = require('node:crypto');
 const { run } = require('./process-runner.cjs');
 const { parsePorcelainV2 } = require('../shared/git-status.cjs');
 const { normalizeRemoteUrl } = require('../shared/repository-match.cjs');

 const COMMON_GIT_LOCK_FILES = ['HEAD.lock', 'index.lock'];
+const MAX_UNTRACKED_DIFF_BYTES = 16 * 1024 * 1024;
 const {
  assertSafeRepositoryPath,
  assertRepositoryRelativePath,
@@ -28,7 +30,42 @@ function parseUnifiedDiff(diffText) {
  return { header, hunks };
 }

+function parseNameStatus(output) {
+  const entries = String(output || '').split('\0');
+  const changes = [];
+  for (let index = 0; index < entries.length;) {
+    const rawStatus = entries[index++];
+    if (!rawStatus) continue;
+    const code = rawStatus[0];
+    if (code === 'R' || code === 'C') {
+      const originalPath = entries[index++] || '';
+      const filePath = entries[index++] || '';
+      if (filePath) changes.push({ code, status: code === 'R' ? 'renamed' : 'copied', path: filePath, originalPath });
+      continue;
+    }
+    const filePath = entries[index++] || '';
+    if (!filePath) continue;
+    const labels = { A: 'added', D: 'deleted', M: 'modified', T: 'type-changed', U: 'conflict' };
+    changes.push({ code, status: labels[code] || 'changed', path: filePath, originalPath: null });
+  }
+  return changes;
+}
+
+function parseCompactLog(output) {
+  return String(output || '').split('\x1e').map((record) => record.trim()).filter(Boolean).map((record) => {
+    const [sha, shortSha, date, subject] = record.split('\x1f');
+    return { sha, shortSha, date, subject };
+  });
+}
+
 class GitService {
+  constructor() {
+    // `git remote get-url` is only re-run when the repository configuration file
+    // itself changed. Status polling asks for the remote URL of every repository
+    // every few seconds, and on Windows the child process dominates that cost.
+    this.remoteUrlCache = new Map();
+  }
+
  async isAvailable() {
    try {
      const result = await run('git', ['--version'], { timeout: 10_000 });
@@ -42,13 +79,24 @@ class GitService {
    const resolved = assertSafeRepositoryPath(repoPath);
    const stat = await fs.stat(resolved).catch(() => null);
    if (!stat?.isDirectory()) throw new Error('The linked local folder no longer exists.');
+    // A directory that carries its own `.git` entry is by definition the top level
+    // of that working tree, for plain repositories as well as for submodules and
+    // linked worktrees where `.git` is a file. Spawning `git rev-parse` to learn
+    // that again is pure overhead, and every status poll passes an already
+    // resolved repository root back in.
+    const marker = await fs.stat(path.join(resolved, '.git')).catch(() => null);
+    if (marker) return resolved;
    const result = await run('git', ['rev-parse', '--show-toplevel'], { cwd: resolved, timeout: 15_000 });
    return path.resolve(result.stdout.trim());
  }

  async status(repoPath) {
    const root = await this.ensureRepository(repoPath);
-    const result = await run('git', ['status', '--porcelain=v2', '--branch', '-z', '--untracked-files=all'], {
+    // `--no-optional-locks` keeps a status read from refreshing and rewriting the
+    // index. Without it every read writes inside .git, which both fights a
+    // concurrent Git command for the index lock and retriggers the filesystem
+    // watcher that asked for this read in the first place.
+    const result = await run('git', ['--no-optional-locks', 'status', '--porcelain=v2', '--branch', '-z', '--untracked-files=all'], {
      cwd: root,
      timeout: 30_000
    });
@@ -66,9 +114,34 @@ class GitService {
    });
  }

+  remoteUrlCacheKey(repoPath, remote) {
+    return JSON.stringify([path.resolve(repoPath), remote]);
+  }
+
  async getRemoteUrl(repoPath, remote = 'origin') {
-    const result = await run('git', ['remote', 'get-url', remote], { cwd: repoPath, timeout: 15_000 });
-    return result.stdout.trim();
+    const cacheKey = this.remoteUrlCacheKey(repoPath, remote);
+    const config = await fs.stat(path.join(repoPath, '.git', 'config')).catch(() => null);
+    const cached = this.remoteUrlCache.get(cacheKey);
+    if (config && cached && cached.mtimeMs === config.mtimeMs && cached.size === config.size) {
+      if (cached.error) throw cached.error;
+      return cached.url;
+    }
+    const remember = (entry) => {
+      if (config) this.remoteUrlCache.set(cacheKey, { ...entry, mtimeMs: config.mtimeMs, size: config.size });
+      else this.remoteUrlCache.delete(cacheKey);
+    };
+    try {
+      const result = await run('git', ['remote', 'get-url', remote], { cwd: repoPath, timeout: 15_000 });
+      const url = result.stdout.trim();
+      remember({ url, error: null });
+      return url;
+    } catch (error) {
+      // A repository that has no such remote keeps failing until its configuration
+      // changes, so the failure is remembered too. Without this, every status poll
+      // of an unmatched local repository spawns a child process that cannot succeed.
+      remember({ url: '', error });
+      throw error;
+    }
  }


@@ -94,6 +167,48 @@ class GitService {
    return { root, gitDir: path.resolve(result.stdout.trim()) };
  }

+  async writeWorkspaceReviewManifest(repoPath, plan, { backupBranch = null, stash = null } = {}) {
+    const { root, gitDir } = await this.gitDirectory(repoPath);
+    const reviewId = String(plan?.id || '').trim();
+    if (!/^[0-9a-f]{64}$/i.test(reviewId)) throw new Error('Workspace review manifest requires a valid synchronization plan.');
+    const reviewDirectory = path.join(gitDir, 'forgeflow', 'workspace-reviews');
+    await fs.mkdir(reviewDirectory, { recursive: true });
+    const manifestPath = path.join(reviewDirectory, `${reviewId}.json`);
+    const payload = {
+      schemaVersion: 1,
+      kind: 'workspace-sync-quarantine',
+      id: reviewId,
+      status: 'pending-codex-review',
+      createdAt: new Date().toISOString(),
+      repositoryRoot: root,
+      branch: plan.branch,
+      upstream: plan.upstream,
+      sourceSha: plan.currentSha,
+      targetSha: plan.targetSha,
+      recoveryBranch: backupBranch,
+      stashRef: stash?.ref || null,
+      stashSha: stash?.sha || null,
+      files: (plan.localFiles || []).map((file) => ({
+        path: file.path,
+        originalPath: file.originalPath || null,
+        status: file.status,
+        staged: Boolean(file.staged),
+        unstaged: Boolean(file.unstaged),
+        untracked: Boolean(file.untracked)
+      })),
+      instructions: [
+        'Review the recovery branch and quarantine stash with Codex before restoring anything.',
+        'ForgeFlow recovery branches are local-only and cannot be pushed to Gitea.',
+        'Restore only files that are still useful; obsolete files can be dropped after review.'
+      ],
+      manifestPath
+    };
+    const temporaryPath = `${manifestPath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    await fs.writeFile(temporaryPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
+    await fs.rename(temporaryPath, manifestPath);
+    return payload;
+  }
+
  isGitLockError(error) {
    const message = String(error?.message || error || '');
    return /(?:cannot lock ref|Unable to create .*\.lock|another git process)/i.test(message)
@@ -273,12 +388,163 @@ class GitService {
    return { strategy: requested, backupBranch: null, status, lockReport: await this.listGitLocks(root) };
  }

+  async previewWorkspaceSync(repoPath) {
+    const root = await this.ensureRepository(repoPath);
+    const { status } = await this.fetch(root);
+    const branch = status.branch?.head;
+    const upstream = status.branch?.upstream;
+    if (!status.head || !branch || branch === '(detached)') {
+      const error = new Error('Workspace synchronization requires a named branch with at least one commit.');
+      error.code = 'WORKSPACE_SYNC_BRANCH_REQUIRED';
+      throw error;
+    }
+    if (!upstream) {
+      const error = new Error('The current branch has no Gitea upstream. Publish it or switch to a tracked branch first.');
+      error.code = 'WORKSPACE_SYNC_UPSTREAM_REQUIRED';
+      throw error;
+    }
+
+    const targetSha = (await run('git', ['rev-parse', '--verify', upstream], { cwd: root, timeout: 30_000 })).stdout.trim();
+    const changes = parseNameStatus((await run('git', [
+      'diff', '--name-status', '-z', '--find-renames', 'HEAD', upstream, '--'
+    ], { cwd: root, timeout: 60_000, maxBuffer: 16 * 1024 * 1024 })).stdout);
+    const logFormat = '%H%x1f%h%x1f%aI%x1f%s%x1e';
+    const [incomingResult, localResult, interruptedOperation] = await Promise.all([
+      run('git', ['log', `--format=${logFormat}`, `HEAD..${upstream}`, '-20'], { cwd: root, timeout: 30_000 }),
+      run('git', ['log', `--format=${logFormat}`, `${upstream}..HEAD`, '-20'], { cwd: root, timeout: 30_000 }),
+      this.detectInterruptedOperation(root)
+    ]);
+    const blockers = [];
+    if (interruptedOperation) blockers.push(`Finish or abort the active Git ${interruptedOperation} before synchronizing.`);
+    if (status.counts.conflicts) blockers.push(`Resolve ${status.counts.conflicts} conflicted file${status.counts.conflicts === 1 ? '' : 's'} before synchronizing.`);
+    const summary = {
+      resultingTrackedChanges: changes.length,
+      added: changes.filter((item) => item.code === 'A').length,
+      modified: changes.filter((item) => ['M', 'T'].includes(item.code)).length,
+      deleted: changes.filter((item) => item.code === 'D').length,
+      renamed: changes.filter((item) => item.code === 'R').length,
+      localFilesToStash: status.counts.changed,
+      untrackedFilesToStash: status.counts.untracked,
+      localCommitsToProtect: status.branch.ahead,
+      incomingCommits: status.branch.behind
+    };
+    const planId = crypto.createHash('sha256').update(JSON.stringify({
+      head: status.head,
+      targetSha,
+      branch,
+      upstream,
+      fingerprint: this.statusFingerprint(status)
+    })).digest('hex');
+    return {
+      id: planId,
+      repositoryRoot: root,
+      branch,
+      upstream,
+      currentSha: status.head,
+      targetSha,
+      needsSync: status.head !== targetSha || !status.clean,
+      cleanBeforeSync: status.clean,
+      blockers,
+      summary,
+      changes: changes.slice(0, 250),
+      changesTruncated: changes.length > 250,
+      localFiles: status.files.slice(0, 250),
+      localFilesTruncated: status.files.length > 250,
+      incomingCommits: parseCompactLog(incomingResult.stdout),
+      localCommits: parseCompactLog(localResult.stdout),
+      recovery: {
+        safetyBranch: status.branch.ahead > 0,
+        stash: status.counts.changed > 0,
+        untrackedCleanup: status.counts.untracked > 0,
+        ignoredFilesPreserved: true
+      }
+    };
+  }
+
+  async synchronizeWorkspace(repoPath, expectedPlanId) {
+    const expected = String(expectedPlanId || '').trim();
+    if (!/^[0-9a-f]{64}$/i.test(expected)) {
+      const error = new Error('Apply workspace synchronization only from a reviewed preview.');
+      error.code = 'WORKSPACE_SYNC_PLAN_REQUIRED';
+      throw error;
+    }
+    const plan = await this.previewWorkspaceSync(repoPath);
+    if (plan.id !== expected) {
+      const error = new Error('The local workspace or Gitea branch changed after the preview. Review a fresh synchronization plan.');
+      error.code = 'WORKSPACE_SYNC_PLAN_STALE';
+      error.recoverable = true;
+      throw error;
+    }
+    if (plan.blockers.length) {
+      const error = new Error(plan.blockers.join(' '));
+      error.code = 'WORKSPACE_SYNC_BLOCKED';
+      error.recoverable = true;
+      throw error;
+    }
+    if (!plan.needsSync) {
+      return { applied: false, unchanged: true, plan, status: await this.status(plan.repositoryRoot), backupBranch: null, stash: null, cleaned: [] };
+    }
+
+    const root = plan.repositoryRoot;
+    const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '').replace('T', '-');
+    let backupBranch = null;
+    let stash = null;
+    let review = null;
+    if (plan.summary.localCommitsToProtect > 0) {
+      const safeBranch = plan.branch.replace(/[^A-Za-z0-9._-]/g, '-');
+      backupBranch = `forgeflow/recovery-${safeBranch}-${stamp}-${plan.currentSha.slice(0, 7)}`;
+      await run('git', ['check-ref-format', '--branch', backupBranch], { cwd: root, timeout: 30_000 });
+      await run('git', ['branch', backupBranch, 'HEAD'], { cwd: root, timeout: 30_000 });
+    }
+    if (plan.summary.localFilesToStash > 0) {
+      const label = `FORGEFLOW-QUARANTINE:${plan.id} workspace sync ${plan.branch} ${stamp}`;
+      await run('git', ['stash', 'push', '--include-untracked', '-m', label], { cwd: root, timeout: 120_000 });
+      stash = (await this.stashList(root))[0] || null;
+    }
+    if (backupBranch || stash) {
+      review = await this.writeWorkspaceReviewManifest(root, plan, { backupBranch, stash });
+    }
+
+    const protectedStatus = await this.status(root);
+    if (!protectedStatus.clean || protectedStatus.head !== plan.currentSha) {
+      const error = new Error('The workspace changed while ForgeFlow was protecting local work. Nothing was reset; review a fresh synchronization plan.');
+      error.code = 'WORKSPACE_SYNC_CONCURRENT_CHANGE';
+      error.recoverable = true;
+      error.backupBranch = backupBranch;
+      error.stash = stash;
+      throw error;
+    }
+
+    await run('git', ['reset', '--hard', plan.targetSha], { cwd: root, timeout: 2 * 60_000 });
+    const status = await this.status(root);
+    if (status.head !== plan.targetSha || !status.clean) {
+      const error = new Error('Git did not verify an exact clean match with the reviewed Gitea commit. Local recovery references were preserved.');
+      error.code = 'WORKSPACE_SYNC_VERIFICATION_FAILED';
+      error.recoverable = true;
+      error.backupBranch = backupBranch;
+      error.stash = stash;
+      throw error;
+    }
+    return {
+      applied: true,
+      unchanged: false,
+      plan,
+      status,
+      backupBranch,
+      stash,
+      review,
+      cleaned: plan.localFiles.filter((file) => file.untracked).map((file) => file.path),
+      ignoredFilesPreserved: true
+    };
+  }
+
  async setRemoteUrl(repoPath, remoteUrl, remote = 'origin') {
    const root = await this.ensureRepository(repoPath);
    const safeRemote = assertCloneRemote(remoteUrl);
    const name = String(remote || 'origin').trim();
    if (!/^[A-Za-z0-9._-]+$/.test(name)) throw new Error('Invalid Git remote name.');
    await run('git', ['remote', 'set-url', name, safeRemote], { cwd: root, timeout: 30_000 });
+    this.remoteUrlCache.delete(this.remoteUrlCacheKey(root, name));
    return this.status(root);
  }

@@ -292,7 +558,26 @@ class GitService {
    if (!result.stdout && safeFile && !staged) {
      const candidate = path.resolve(root, safeFile);
      if (candidate !== root && !candidate.startsWith(`${root}${path.sep}`)) throw new Error('File path escapes repository root.');
-      const content = await fs.readFile(candidate, 'utf8').catch(() => '');
+      const [realRoot, realCandidate, candidateStat] = await Promise.all([
+        fs.realpath(root).catch(() => root),
+        fs.realpath(candidate).catch(() => candidate),
+        fs.stat(candidate).catch(() => null)
+      ]);
+      const normalize = (value) => process.platform === 'win32' ? value.toLowerCase() : value;
+      const normalizedRoot = normalize(realRoot);
+      const normalizedCandidate = normalize(realCandidate);
+      if (normalizedCandidate !== normalizedRoot && !normalizedCandidate.startsWith(`${normalizedRoot}${path.sep}`)) {
+        const error = new Error('ForgeFlow refuses to read a diff target that resolves outside the repository.');
+        error.code = 'DIFF_TARGET_OUTSIDE_REPOSITORY';
+        throw error;
+      }
+      if (candidateStat?.size > MAX_UNTRACKED_DIFF_BYTES) {
+        const error = new Error('The untracked file is too large to render safely as a diff.');
+        error.code = 'DIFF_FILE_TOO_LARGE';
+        error.recoverable = true;
+        throw error;
+      }
+      const content = candidateStat?.isFile() ? await fs.readFile(candidate, 'utf8').catch(() => '') : '';
      if (content) return `diff --git a/${safeFile} b/${safeFile}\nnew file mode 100644\n--- /dev/null\n+++ b/${safeFile}\n${content.split('\n').map((line) => `+${line}`).join('\n')}`;
    }
    return result.stdout;
@@ -354,8 +639,7 @@ class GitService {
    return { selected, matches };
  }

-  async expandSelectedPaths(root, files, { unstagedOnly = false } = {}) {
-    const status = await this.status(root);
+  expandStatusPaths(status, files, { unstagedOnly = false } = {}) {
    const { selected, matches } = this.selectedStatusFiles(status, files);
    if (!selected.length) return [];
    const expanded = new Set();
@@ -367,12 +651,17 @@ class GitService {
    return [...expanded];
  }

-  async stage(repoPath, files) {
-    const root = await this.ensureRepository(repoPath);
+  async expandSelectedPaths(root, files, options = {}) {
+    return this.expandStatusPaths(await this.status(root), files, options);
+  }
+
+  // Callers that already read the status pass it in. Reading it again costs a
+  // child process, and a commit used to pay for four of them.
+  async applyStage(root, files, knownStatus = null) {
    const requested = assertRepositoryRelativePaths(files);
    if (!requested.length) {
      await run('git', ['add', '--all'], { cwd: root, timeout: 60_000 });
-      return this.status(root);
+      return;
    }

    // Only stage records that still have a worktree-side change. Re-running
@@ -380,10 +669,16 @@ class GitService {
    // Git fail with "pathspec did not match any files" because the file no
    // longer exists in either the worktree or HEAD. Staged-only deletions and
    // renames are already ready for commit and must therefore be left alone.
-    const selected = await this.expandSelectedPaths(root, requested, { unstagedOnly: true });
+    const status = knownStatus || await this.status(root);
+    const selected = this.expandStatusPaths(status, requested, { unstagedOnly: true });
    if (selected.length) {
      await this.runWithPathspec(root, ['add', '-A'], selected, { timeout: 120_000 });
    }
+  }
+
+  async stage(repoPath, files) {
+    const root = await this.ensureRepository(repoPath);
+    await this.applyStage(root, files);
    return this.status(root);
  }

@@ -403,8 +698,9 @@ class GitService {

  async prepareSelectedStage(root, files) {
    const selected = assertRepositoryRelativePaths(files);
+    let current = null;
    if (selected.length) {
-      const current = await this.status(root);
+      current = await this.status(root);
      const excludedStaged = current.files
        .filter((file) => file.staged)
        .filter((file) => !selected.includes(file.path) && !(file.originalPath && selected.includes(file.originalPath)))
@@ -413,7 +709,7 @@ class GitService {
        throw new Error(`Some staged files are not selected (${excludedStaged.slice(0, 3).join(', ')}${excludedStaged.length > 3 ? ', …' : ''}). Select them or unstage them first.`);
      }
    }
-    await this.stage(root, selected);
+    await this.applyStage(root, selected, current);
    const stagedCheck = await run('git', ['diff', '--cached', '--quiet'], { cwd: root, allowExitCodes: [1] });
    if (stagedCheck.exitCode === 0) throw new Error('There are no staged changes to commit.');
    return selected;
@@ -469,6 +765,12 @@ class GitService {
    const status = await this.status(root);
    const branch = status.branch.head;
    if (!branch || branch === '(detached)') throw new Error('Cannot push from a detached HEAD.');
+    if (/^forgeflow\/recovery-/.test(branch)) {
+      const error = new Error('ForgeFlow recovery branches are local quarantine references and cannot be pushed to Gitea. Review them with Codex and move only approved work onto a normal branch.');
+      error.code = 'WORKSPACE_RECOVERY_BRANCH_LOCAL_ONLY';
+      error.recoverable = true;
+      throw error;
+    }
    const args = status.branch.upstream ? ['push', '--porcelain'] : ['push', '--porcelain', '--set-upstream', 'origin', branch];
    const result = await run('git', args, { cwd: root, timeout: 180_000, maxBuffer: 16 * 1024 * 1024 });
    return { output: `${result.stdout}\n${result.stderr}`.trim(), status: await this.status(root) };
@@ -555,7 +857,16 @@ class GitService {
    const result = await run('git', ['stash', 'list', `--format=${format}`], { cwd: root });
    return result.stdout.split('\x1e').map((record) => record.trim()).filter(Boolean).map((record) => {
      const [ref, sha, date, subject] = record.split('\x1f');
-      return { ref, sha, shortSha: sha.slice(0, 7), date, subject };
+      const quarantine = String(subject || '').match(/FORGEFLOW-QUARANTINE:([0-9a-f]{64})/i);
+      return {
+        ref,
+        sha,
+        shortSha: sha.slice(0, 7),
+        date,
+        subject,
+        quarantined: Boolean(quarantine),
+        reviewId: quarantine?.[1] || null
+      };
    });
  }

@@ -563,6 +874,13 @@ class GitService {
    const root = await this.ensureRepository(repoPath);
    const value = String(ref || 'stash@{0}');
    if (!/^stash@\{\d+\}$/.test(value)) throw new Error('Invalid stash reference.');
+    const candidate = (await this.stashList(root)).find((item) => item.ref === value);
+    if (candidate?.quarantined) {
+      const error = new Error(`This stash is quarantined for Codex review (${candidate.reviewId}). ForgeFlow will not apply and drop it wholesale; restore only reviewed files manually.`);
+      error.code = 'WORKSPACE_QUARANTINE_REVIEW_REQUIRED';
+      error.recoverable = true;
+      throw error;
+    }
    const result = await run('git', ['stash', 'pop', value], { cwd: root, timeout: 120_000 });
    return { output: result.stdout.trim(), status: await this.status(root), stashes: await this.stashList(root) };
  }
@@ -1,13 +1,17 @@
 "use strict";
 const path = require("node:path");
 const fs = require("node:fs/promises");
-const { fileURLToPath } = require("node:url");
-const { ipcMain, dialog, shell, app } = require("electron");
+const { dialog, shell, app } = require("electron");
 const { matchRemoteToRepository } = require("../shared/repository-match.cjs");
 const {
  cloneDirectoryName,
  resolveCloneTarget,
 } = require("../shared/clone-target.cjs");
+const {
+  createChannelRegistrar,
+  assertTrustedSender,
+  toErrorPayload,
+} = require("./ipc/channel.cjs");
 const { registerRepositoryIpc } = require("./ipc/repository-handlers.cjs");
 const { registerDeploymentIpc } = require("./ipc/deployment-handlers.cjs");
 const { registerOperationsIpc } = require("./ipc/operations-handlers.cjs");
@@ -16,67 +20,7 @@ const {
  readEncryptedBackup,
 } = require("./configuration-backup.cjs");
 const { evaluateDeploymentPolicy } = require("../shared/deployment-policy.cjs");
-let diagnosticsService = null;
-const TRUSTED_RENDERER_PATH = path.resolve(
-  __dirname,
-  "..",
-  "renderer",
-  "index.html",
-);
-
-function toErrorPayload(error) {
-  return {
-    message: error?.message || "Unknown error",
-    code: error?.code || null,
-    status: error?.status || null,
-    recoverable: Boolean(error?.recoverable),
-    commitSha: error?.commitSha || null,
-  };
-}
-
-function assertTrustedSender(event) {
-  const url = event?.senderFrame?.url || event?.sender?.getURL?.() || "";
-  try {
-    const parsed = new URL(url);
-    if (parsed.protocol !== "file:") throw new Error("not a file URL");
-    const senderPath = path.resolve(fileURLToPath(parsed));
-    const normalize = (value) =>
-      process.platform === "win32" ? value.toLowerCase() : value;
-    if (normalize(senderPath) !== normalize(TRUSTED_RENDERER_PATH))
-      throw new Error("unexpected renderer file");
-  } catch {
-    throw new Error("Rejected IPC request from an untrusted renderer origin.");
-  }
-}
-
-function register(channel, handler) {
-  ipcMain.handle(channel, async (event, payload) => {
-    const started = Date.now();
-    try {
-      assertTrustedSender(event);
-      const data = await handler(payload || {}, event);
-      await diagnosticsService?.debug("ipc.completed", {
-        channel,
-        durationMs: Date.now() - started,
-      });
-      return { ok: true, data };
-    } catch (error) {
-      await diagnosticsService?.error("ipc.failed", {
-        channel,
-        durationMs: Date.now() - started,
-        error: {
-          name: error?.name,
-          message: error?.message,
-          code: error?.code,
-          status: error?.status,
-          stack: error?.stack,
-        },
-      });
-      console.error(`[${channel}]`, error);
-      return { ok: false, error: toErrorPayload(error) };
-    }
-  });
-}
+const { normalizeBaseUrl } = require("../shared/validation.cjs");
 function registerIpc({
  store,
  git,
@@ -96,7 +40,7 @@ function registerIpc({
  monitor,
  onPreferencesChanged,
 }) {
-  diagnosticsService = diagnostics;
+  const register = createChannelRegistrar(diagnostics);
  const repositoryMutations = new Map();
  const withRepositoryPause = async (localPath, action) => {
    monitor?.pause(localPath);
@@ -162,8 +106,11 @@ function registerIpc({
      await repositories.refresh();
      knownPaths = repositories.getWatchPaths();
    }
-    const canonicalKnown = await Promise.all(knownPaths.map(canonicalPath));
-    if (!canonicalKnown.some((known) => known === candidate))
+    // Watch paths are already canonical, so re-resolving all of them on every
+    // guarded call is only needed when the cheap comparison finds no match.
+    const matched = knownPaths.some((known) => path.resolve(known) === candidate)
+      || (await Promise.all(knownPaths.map(canonicalPath))).some((known) => known === candidate);
+    if (!matched)
      throw new Error(
        "The requested local repository is not linked or discovered by ForgeFlow.",
      );
@@ -173,9 +120,7 @@ function registerIpc({
  const resolveRepository = async (repositoryPayload) => {
    const fullName = String(repositoryPayload?.fullName || "").trim();
    if (!fullName) throw new Error("Repository identity is required.");
-    const current = (await repositories.refresh()).find(
-      (item) => item.fullName === fullName,
-    );
+    const current = await repositories.resolveByFullName(fullName);
    if (!current)
      throw new Error(
        "The repository is no longer available through the configured Gitea account.",
@@ -309,8 +254,23 @@ function registerIpc({
  });

  register("settings:update-gitea", async ({ baseUrl, token }) => {
-    const effectiveToken = String(token || "").trim() || store.getToken();
-    const validation = await gitea.validateConnection(baseUrl, effectiveToken);
+    const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+    const currentBaseUrl = store.data.gitea.baseUrl
+      ? normalizeBaseUrl(store.data.gitea.baseUrl)
+      : "";
+    const submittedToken = String(token || "").trim();
+    if (!submittedToken && normalizedBaseUrl !== currentBaseUrl) {
+      const error = new Error(
+        "Enter a new Gitea token when changing the server address. Stored tokens are bound to their original origin.",
+      );
+      error.code = "GITEA_TOKEN_ORIGIN_CHANGED";
+      throw error;
+    }
+    const effectiveToken = submittedToken || store.getToken();
+    const validation = await gitea.validateConnection(
+      normalizedBaseUrl,
+      effectiveToken,
+    );
    const tokenState = await store.updateGitea({
      baseUrl: validation.baseUrl,
      token,
@@ -471,13 +431,25 @@ function registerIpc({
    await diagnostics.info("server.deleted", { serverId });
    return store.getPublicState();
  });
-  register("server:test", async ({ serverId }) => {
+  register("server:test", async ({ serverId, expectedFingerprint = "" }) => {
    const server = store.getServer(serverId);
    if (!server) throw new Error("The configured server no longer exists.");
+    const expected = String(expectedFingerprint || "").trim();
+    if (!server.hostFingerprint && !expected) {
+      const probe = await ssh.probeHostFingerprint(serverId);
+      return { ...probe, connected: false, needsTrust: true, state: store.getPublicState() };
+    }
+    if (!server.hostFingerprint && !/^SHA256:[A-Za-z0-9+/]{40,44}$/.test(expected))
+      throw new Error("Confirm the exact SSH host fingerprint returned by ForgeFlow.");
    const result = await ssh.test(serverId, {
-      trustOnFirstUse: !server.hostFingerprint,
+      expectedFingerprint: server.hostFingerprint ? null : expected,
    });
    if (!server.hostFingerprint) {
+      if (result.fingerprint !== expected) {
+        const error = new Error("The SSH host identity changed between preview and confirmation.");
+        error.code = "SSH_HOST_KEY_MISMATCH";
+        throw error;
+      }
      await store.saveServer(
        { ...server, hostFingerprint: result.fingerprint },
        {},
@@ -733,6 +705,7 @@ function registerIpc({
  registerDeploymentIpc({
    register, store, resolveRepository, unraid, deployments, evaluateDeploymentPolicy,
    audit, deployKeys, repositories, inventoryReviews, diagnostics, git, gitea, ssh,
+    preflight,
  });
  registerOperationsIpc({
    register, store, unraid, deployments, diagnostics, shell, dialog, path, app,
@@ -0,0 +1,77 @@
+"use strict";
+
+const path = require("node:path");
+const { fileURLToPath } = require("node:url");
+const { ipcMain } = require("electron");
+
+const TRUSTED_RENDERER_PATH = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "renderer",
+  "index.html",
+);
+
+function toErrorPayload(error) {
+  return {
+    message: error?.message || "Unknown error",
+    code: error?.code || null,
+    status: error?.status || null,
+    recoverable: Boolean(error?.recoverable),
+    commitSha: error?.commitSha || null,
+  };
+}
+
+function assertTrustedSender(event) {
+  const url = event?.senderFrame?.url || event?.sender?.getURL?.() || "";
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "file:") throw new Error("not a file URL");
+    const senderPath = path.resolve(fileURLToPath(parsed));
+    const normalize = (value) =>
+      process.platform === "win32" ? value.toLowerCase() : value;
+    if (normalize(senderPath) !== normalize(TRUSTED_RENDERER_PATH))
+      throw new Error("unexpected renderer file");
+  } catch {
+    throw new Error("Rejected IPC request from an untrusted renderer origin.");
+  }
+}
+
+// Built per registerIpc() call so the diagnostics sink is an argument instead of
+// module-level mutable state that every handler silently depends on.
+function createChannelRegistrar(diagnostics) {
+  return function register(channel, handler) {
+    ipcMain.handle(channel, async (event, payload) => {
+      const started = Date.now();
+      try {
+        assertTrustedSender(event);
+        const data = await handler(payload || {}, event);
+        await diagnostics?.debug("ipc.completed", {
+          channel,
+          durationMs: Date.now() - started,
+        });
+        return { ok: true, data };
+      } catch (error) {
+        await diagnostics?.error("ipc.failed", {
+          channel,
+          durationMs: Date.now() - started,
+          error: {
+            name: error?.name,
+            message: error?.message,
+            code: error?.code,
+            status: error?.status,
+            stack: error?.stack,
+          },
+        });
+        return { ok: false, error: toErrorPayload(error) };
+      }
+    });
+  };
+}
+
+module.exports = {
+  createChannelRegistrar,
+  assertTrustedSender,
+  toErrorPayload,
+  TRUSTED_RENDERER_PATH,
+};
@@ -3,6 +3,7 @@
 function registerDeploymentIpc({
  register, store, resolveRepository, unraid, deployments, evaluateDeploymentPolicy,
  audit, deployKeys, repositories, inventoryReviews, diagnostics, git, gitea, ssh,
+  preflight,
 }) {
  register("deployment:save-profile", async ({ fullName, profile }) => {
    const saved = await store.saveDeploymentProfile(fullName, profile);
@@ -95,7 +96,6 @@ function registerDeploymentIpc({
      });
    },
  );
-  register("deployment:health", ({ url }) => deployments.checkHealth(url));
  register("deployment:link-server-workload", async ({ repository, serverId, workloadId, deploymentMode = "server-git", remoteFolder = "" }) => {
    const current = await resolveRepository(repository);
    const result = await unraid.linkServerWorkload({
@@ -6,8 +6,8 @@ function registerRepositoryIpc({
  resolveRepository, cloneRepositoryInto, cloneDirectoryName,
  matchRemoteToRepository, shell, dialog,
 }) {
-  register("repositories:refresh", async () => {
-    const result = await repositories.refresh();
+  register("repositories:refresh", async ({ force = false }) => {
+    const result = await repositories.refresh({ force: force === true });
    monitor?.setPaths(repositories.getWatchPaths());
    return result;
  });
@@ -265,6 +265,44 @@ function registerRepositoryIpc({
      git.repairSync(safePath, strategy),
    );
  });
+  register("repository:workspace-sync-preview", async ({ localPath }) => {
+    const safePath = await assertKnownRepositoryPath(localPath);
+    const plan = await withRepositoryMutation(safePath, () =>
+      git.previewWorkspaceSync(safePath),
+    );
+    await diagnostics.info("repository.workspace-sync.previewed", {
+      localPath: safePath,
+      branch: plan.branch,
+      upstream: plan.upstream,
+      currentSha: plan.currentSha,
+      targetSha: plan.targetSha,
+      planId: plan.id,
+      summary: plan.summary,
+      blockers: plan.blockers,
+    });
+    return plan;
+  });
+  register(
+    "repository:workspace-sync-apply",
+    async ({ localPath, expectedPlanId }) => {
+      const safePath = await assertKnownRepositoryPath(localPath);
+      const result = await withRepositoryMutation(safePath, () =>
+        git.synchronizeWorkspace(safePath, expectedPlanId),
+      );
+      await audit.append("repository.workspace-synchronized", {
+        localPath: safePath,
+        branch: result.plan.branch,
+        upstream: result.plan.upstream,
+        previousSha: result.plan.currentSha,
+        targetSha: result.plan.targetSha,
+        backupBranch: result.backupBranch,
+        stashSha: result.stash?.sha || null,
+        ignoredFilesPreserved: true,
+        applied: result.applied,
+      });
+      return result;
+    },
+  );
  register("repository:set-origin", async ({ localPath, remoteUrl }) => {
    const safePath = await assertKnownRepositoryPath(localPath);
    return withRepositoryMutation(safePath, () =>
@@ -49,6 +49,13 @@ function stableAlias(value, prefix = 'item') {
  return `${prefix}-${hash}`;
 }

+function redactPrivateInfrastructure(value) {
+  return String(value ?? '')
+    .replace(/\b(?:10(?:\.\d{1,3}){3}|127(?:\.\d{1,3}){3}|169\.254(?:\.\d{1,3}){2}|172\.(?:1[6-9]|2\d|3[01])(?:\.\d{1,3}){2}|192\.168(?:\.\d{1,3}){2})\b/g, '<PRIVATE_ADDRESS>')
+    .replace(/\b(?:https?|ssh):\/\/[^\s"'<>]+/gi, '<PRIVATE_URL>')
+    .replace(/\/(?:mnt|srv|opt|var\/lib)\/[^\s"'<>]*/g, '<SERVER_PATH>');
+}
+
 function sanitizeForDiagnostics(value, options = {}, seen = new WeakSet()) {
  const {
    secrets = [],
@@ -63,6 +70,7 @@ function sanitizeForDiagnostics(value, options = {}, seen = new WeakSet()) {
  if (typeof value === 'string') {
    let output = redactSecrets(value, secrets);
    if (pathMode === 'alias') output = pathAlias(output, { homeDir, cwd });
+    if (strictIdentifiers) output = redactPrivateInfrastructure(output);
    return output;
  }
  if (value instanceof Error) {
@@ -80,7 +88,7 @@ function sanitizeForDiagnostics(value, options = {}, seen = new WeakSet()) {
      output[key] = '[REDACTED]';
      continue;
    }
-    if (strictIdentifiers && ['fullName', 'repository', 'owner', 'user', 'login', 'email'].includes(key)) {
+    if (strictIdentifiers && ['full_name', 'repository', 'owner', 'user', 'login', 'email', 'host', 'hostname', 'username', 'base_path', 'private_key_path', 'local_path', 'remote_folder', 'remote_url', 'clone_url', 'status_url', 'healthcheck_url', 'web_ui_url', 'workspace_roots', 'scan_roots'].includes(normalizedKey.toLowerCase())) {
      output[key] = stableAlias(typeof item === 'object' ? JSON.stringify(item) : item, key.toLowerCase());
      continue;
    }
@@ -90,4 +98,4 @@ function sanitizeForDiagnostics(value, options = {}, seen = new WeakSet()) {
  return output;
 }

-module.exports = { redactSecrets, sanitizeForDiagnostics, pathAlias, stableAlias, SENSITIVE_KEY };
+module.exports = { redactSecrets, sanitizeForDiagnostics, pathAlias, stableAlias, redactPrivateInfrastructure, SENSITIVE_KEY };
@@ -0,0 +1,26 @@
+'use strict';
+
+function isBrokenPipeError(error) {
+  return error?.code === 'EPIPE';
+}
+
+function installOutputPipeGuards({
+  stdout = process.stdout,
+  stderr = process.stderr,
+  onBrokenPipe = () => {}
+} = {}) {
+  const guardedStreams = [stdout, stderr].filter(Boolean);
+  const handlers = guardedStreams.map((stream) => {
+    const handler = (error) => {
+      if (!isBrokenPipeError(error)) throw error;
+      onBrokenPipe(error);
+    };
+    stream.on('error', handler);
+    return { stream, handler };
+  });
+  return () => {
+    for (const { stream, handler } of handlers) stream.off('error', handler);
+  };
+}
+
+module.exports = { installOutputPipeGuards, isBrokenPipeError };
@@ -1,5 +1,16 @@
 'use strict';

+const fs = require('node:fs');
+
+// A watched repository is only re-read when the filesystem reports activity. The
+// interval below stays as a safety net for watchers that silently stop
+// delivering, which happens on network shares and removed folders.
+const SAFETY_CHECK_INTERVAL_MS = 30_000;
+const WATCH_DEBOUNCE_MS = 250;
+// Busy trees (a build, an install, a fetch) produce a continuous event stream.
+// This bounds how often that can turn into a Git read.
+const MIN_WATCH_CHECK_INTERVAL_MS = 1_000;
+
 class RepositoryMonitor {
  constructor({ store, git, onChange, diagnostics = null }) {
    this.store = store;
@@ -11,12 +22,149 @@ class RepositoryMonitor {
    this.timer = null;
    this.running = false;
    this.paused = new Set();
+    this.active = false;
+    this.watchers = new Map();
+    this.changed = new Set();
+    this.lastCheckedAt = new Map();
+    this.lastFetchedAt = new Map();
+    this.watchTimer = null;
+    this.fetchRunning = false;
  }

  setPaths(paths) {
    this.paths = [...new Set((paths || []).filter(Boolean))];
+    const watched = new Set(this.paths);
    for (const existing of [...this.fingerprints.keys()]) {
-      if (!this.paths.includes(existing)) this.fingerprints.delete(existing);
+      if (!watched.has(existing)) this.fingerprints.delete(existing);
+    }
+    // A repository that is unlinked while a mutation holds it paused would keep
+    // that pause forever, silently freezing its status once it is watched again.
+    for (const existing of [...this.paused]) {
+      if (!watched.has(existing)) this.paused.delete(existing);
+    }
+    for (const existing of [...this.changed]) {
+      if (!watched.has(existing)) this.changed.delete(existing);
+    }
+    for (const existing of [...this.lastCheckedAt.keys()]) {
+      if (!watched.has(existing)) this.lastCheckedAt.delete(existing);
+    }
+    for (const existing of [...this.lastFetchedAt.keys()]) {
+      if (!watched.has(existing)) this.lastFetchedAt.delete(existing);
+    }
+    const now = Date.now();
+    for (const localPath of this.paths) {
+      if (!this.lastFetchedAt.has(localPath)) this.lastFetchedAt.set(localPath, now);
+    }
+    this.syncWatchers();
+  }
+
+  syncWatchers() {
+    for (const [localPath, watcher] of [...this.watchers]) {
+      if (this.active && this.paths.includes(localPath)) continue;
+      this.closeWatcher(localPath, watcher);
+    }
+    if (!this.active) return;
+    for (const localPath of this.paths) {
+      if (this.watchers.has(localPath)) continue;
+      try {
+        const watcher = fs.watch(
+          localPath,
+          { recursive: true, persistent: false },
+          () => this.noteFilesystemChange(localPath)
+        );
+        watcher.on('error', () => this.dropWatcher(localPath));
+        this.watchers.set(localPath, watcher);
+      } catch {
+        // Watching is unavailable for this folder. Leaving it unwatched makes
+        // shouldCheck() fall back to the interval for that repository only.
+      }
+    }
+  }
+
+  closeWatcher(localPath, watcher = this.watchers.get(localPath)) {
+    if (!watcher) return;
+    try { watcher.close(); } catch { /* already closed */ }
+    this.watchers.delete(localPath);
+  }
+
+  dropWatcher(localPath) {
+    this.closeWatcher(localPath);
+    this.changed.add(localPath);
+  }
+
+  noteFilesystemChange(localPath) {
+    this.changed.add(localPath);
+    this.scheduleWatchTick();
+  }
+
+  scheduleWatchTick() {
+    if (this.watchTimer) return;
+    this.watchTimer = setTimeout(() => {
+      this.watchTimer = null;
+      this.tick().catch((error) => this.diagnostics?.warning('repository-monitor.tick.failed', error));
+    }, WATCH_DEBOUNCE_MS);
+    this.watchTimer.unref?.();
+  }
+
+  shouldCheck(localPath, now) {
+    if (this.paused.has(localPath)) return false;
+    if (!this.watchers.has(localPath)) return true;
+    const sinceLastCheck = now - (this.lastCheckedAt.get(localPath) || 0);
+    if (this.changed.has(localPath)) return sinceLastCheck >= MIN_WATCH_CHECK_INTERVAL_MS;
+    return sinceLastCheck >= SAFETY_CHECK_INTERVAL_MS;
+  }
+
+  fetchIntervalMs() {
+    const minutes = Number(this.store.data.preferences.fetchIntervalMinutes);
+    return Number.isFinite(minutes) && minutes > 0 ? Math.min(minutes, 240) * 60_000 : 0;
+  }
+
+  shouldFetch(localPath, now) {
+    const interval = this.fetchIntervalMs();
+    return interval > 0
+      && !this.paused.has(localPath)
+      && now - (this.lastFetchedAt.get(localPath) || now) >= interval;
+  }
+
+  async recordStatus(localPath, status, reason) {
+    const next = this.git.statusFingerprint(status);
+    const previous = this.fingerprints.get(localPath);
+    this.fingerprints.set(localPath, next);
+    if (previous && previous !== next) {
+      await this.diagnostics?.debug('repository-monitor.changed', { localPath, head: status.head, branch: status.branch?.head, counts: status.counts, reason });
+      this.onChange?.({ localPath, status, reason });
+    }
+  }
+
+  async fetchRemoteUpdates(now = Date.now()) {
+    if (this.fetchRunning) return;
+    const queue = this.paths.filter((localPath) => this.shouldFetch(localPath, now));
+    if (!queue.length) return;
+    this.fetchRunning = true;
+    try {
+      const workers = Array.from({ length: Math.min(2, queue.length) }, async () => {
+        while (queue.length) {
+          const localPath = queue.shift();
+          // Mark the attempt before awaiting the network. A failing remote should
+          // not be retried every local poll interval.
+          this.lastFetchedAt.set(localPath, Date.now());
+          try {
+            const result = await this.git.fetch(localPath);
+            await this.recordStatus(localPath, result.status, 'remote-state-changed');
+            await this.diagnostics?.debug('repository-monitor.fetch.completed', {
+              localPath,
+              branch: result.status?.branch?.head,
+              ahead: result.status?.branch?.ahead,
+              behind: result.status?.branch?.behind,
+            });
+          } catch (error) {
+            await this.diagnostics?.warning('repository-monitor.fetch.failed', { localPath, message: error.message });
+          }
+        }
+      });
+      await Promise.all(workers);
+    } finally {
+      this.fetchRunning = false;
    }
  }

@@ -26,6 +174,8 @@ class RepositoryMonitor {
  restart() {
    this.stop();
    if (!this.store.data.preferences.autoRefresh) return;
+    this.active = true;
+    this.syncWatchers();
    const seconds = Math.min(Math.max(Number(this.store.data.preferences.repositoryPollSeconds) || 4, 2), 60);
    this.timer = setInterval(() => this.tick().catch((error) => this.diagnostics?.warning('repository-monitor.tick.failed', error)), seconds * 1000);
    this.timer.unref?.();
@@ -34,26 +184,27 @@ class RepositoryMonitor {
  stop() {
    if (this.timer) clearInterval(this.timer);
    this.timer = null;
+    if (this.watchTimer) clearTimeout(this.watchTimer);
+    this.watchTimer = null;
+    this.active = false;
+    this.syncWatchers();
  }

  async tick() {
+    void this.fetchRemoteUpdates().catch((error) => this.diagnostics?.warning('repository-monitor.fetch-cycle.failed', error));
    if (this.running || !this.paths.length) return;
    this.running = true;
    try {
-      const queue = [...this.paths];
+      const now = Date.now();
+      const queue = this.paths.filter((localPath) => this.shouldCheck(localPath, now));
      const workers = Array.from({ length: Math.min(4, queue.length) }, async () => {
        while (queue.length) {
          const localPath = queue.shift();
-          if (this.paused.has(localPath)) continue;
+          this.changed.delete(localPath);
+          this.lastCheckedAt.set(localPath, Date.now());
          try {
            const status = await this.git.status(localPath);
-            const next = this.git.statusFingerprint(status);
-            const previous = this.fingerprints.get(localPath);
-            this.fingerprints.set(localPath, next);
-            if (previous && previous !== next) {
-              await this.diagnostics?.debug('repository-monitor.changed', { localPath, head: status.head, branch: status.branch?.head, counts: status.counts });
-              this.onChange?.({ localPath, status, reason: 'working-tree-changed' });
-            }
+            await this.recordStatus(localPath, status, 'working-tree-changed');
          } catch (error) {
            const next = `error:${error.message}`;
            const previous = this.fingerprints.get(localPath);
@@ -68,8 +219,11 @@ class RepositoryMonitor {
      await Promise.all(workers);
    } finally {
      this.running = false;
+      // Activity that arrived while the check was running keeps its flag set, so
+      // it must not wait for the safety interval.
+      if (this.active && this.changed.size) this.scheduleWatchTick();
    }
  }
 }

-module.exports = { RepositoryMonitor };
+module.exports = { RepositoryMonitor, SAFETY_CHECK_INTERVAL_MS, WATCH_DEBOUNCE_MS, MIN_WATCH_CHECK_INTERVAL_MS };
@@ -29,6 +29,13 @@ class RepositoryService {
    this.gitea = giteaService;
    this.diagnostics = diagnostics;
    this.lastKnownLocalPaths = [];
+    this.lastKnownRemoteRepositories = [];
+    this.lastSuccessfulRemoteRefreshAt = null;
+    this.lastRemoteRefreshAtMs = 0;
+    this.lastDiscoveredPaths = [];
+    this.lastDiscoveryAtMs = 0;
+    this.refreshPromise = null;
+    this.lastResult = null;
  }

  async discoverInRoot(root, maxDepth = 4) {
@@ -51,8 +58,13 @@ class RepositoryService {

      let entries;
      try { entries = await fs.readdir(real, { withFileTypes: true }); } catch { return; }
+      // Directory entries report as a symbolic link instead of a directory, which
+      // is how Windows junctions surface. Skipping those made a project folder
+      // that is mapped through a junction invisible; visit() resolves each entry
+      // and the `seen` set above keeps links that point back into the tree from
+      // being scanned twice.
      await mapLimit(entries
-        .filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && !SKIP_DIRECTORIES.has(entry.name)), 12,
+        .filter((entry) => (entry.isDirectory() || entry.isSymbolicLink()) && !SKIP_DIRECTORIES.has(entry.name)), 12,
      (entry) => visit(path.join(real, entry.name), depth + 1));
    };

@@ -80,13 +92,97 @@ class RepositoryService {
    return [...this.lastKnownLocalPaths];
  }

-  async refresh() {
-    const started = Date.now();
-    const remoteRepositories = this.store.data.gitea.baseUrl && this.store.getToken()
-      ? await this.gitea.listRepositories()
-      : [];
+  async getRemoteRepositories({ force = false } = {}) {
+    if (!this.store.data.gitea.baseUrl || !this.store.getToken()) {
+      this.lastKnownRemoteRepositories = [];
+      this.lastSuccessfulRemoteRefreshAt = null;
+      return { repositories: [], stale: false, error: null };
+    }

-    const discoveredPaths = await this.discoverAll(this.store.data.workspaceRoots);
+    if (!force && this.lastSuccessfulRemoteRefreshAt && Date.now() - this.lastRemoteRefreshAtMs < 15_000) {
+      return {
+        repositories: this.lastKnownRemoteRepositories.map((repository) => ({ ...repository })),
+        stale: false,
+        error: null,
+        cached: true
+      };
+    }
+
+    try {
+      const repositories = await this.gitea.listRepositories();
+      this.lastKnownRemoteRepositories = repositories.map((repository) => ({ ...repository }));
+      this.lastSuccessfulRemoteRefreshAt = new Date().toISOString();
+      this.lastRemoteRefreshAtMs = Date.now();
+      return { repositories, stale: false, error: null };
+    } catch (error) {
+      if (!this.lastSuccessfulRemoteRefreshAt) throw error;
+      await this.diagnostics?.warning('repositories.remote-refresh.degraded', {
+        message: error.message,
+        cachedCount: this.lastKnownRemoteRepositories.length,
+        lastSuccessfulAt: this.lastSuccessfulRemoteRefreshAt
+      });
+      return {
+        repositories: this.lastKnownRemoteRepositories.map((repository) => ({ ...repository })),
+        stale: true,
+        error: error.message
+      };
+    }
+  }
+
+  async getDiscoveredPaths({ force = false } = {}) {
+    if (!force && this.lastDiscoveryAtMs && Date.now() - this.lastDiscoveryAtMs < 30_000) {
+      return [...this.lastDiscoveredPaths];
+    }
+    const paths = await this.discoverAll(this.store.data.workspaceRoots);
+    this.lastDiscoveredPaths = [...paths];
+    this.lastDiscoveryAtMs = Date.now();
+    return paths;
+  }
+
+  // Resolving a single repository used to go through a full refresh, which runs
+  // `git status` for every discovered repository. Handlers that act on one
+  // repository only need that one, so its local state is read directly. Anything
+  // this cannot answer confidently still falls back to the full scan.
+  async resolveByFullName(fullName) {
+    const name = String(fullName || '').trim();
+    if (!name) return null;
+    const fromFullRefresh = async () => (await this.refresh()).find((item) => item.fullName === name) || null;
+
+    const remoteResult = await this.getRemoteRepositories({});
+    const remote = remoteResult.repositories.find((item) => item.full_name === name);
+    if (!remote) return fromFullRefresh();
+
+    const explicitPath = this.store.data.repositoryMappings[repositoryKey(remote)];
+    const knownPath = explicitPath || (this.lastResult || []).find((item) => item.fullName === name)?.localPath || null;
+    // Without a known path the link can still exist through remote-URL matching,
+    // which only the discovery pass can establish.
+    if (!knownPath && !this.lastResult) return fromFullRefresh();
+
+    const local = knownPath ? (await this.getLocalDescriptors([knownPath]))[0] : null;
+    const profiles = this.store.getDeploymentProfiles(remote.full_name).map((profile) => ({
+      ...profile,
+      state: this.store.getDeploymentState(profile.id)
+    }));
+    return {
+      ...this.decorate(remote, local, profiles),
+      remoteStale: remoteResult.stale,
+      remoteRefreshError: remoteResult.error,
+      remoteLastRefreshedAt: this.lastSuccessfulRemoteRefreshAt
+    };
+  }
+
+  async refresh(options = {}) {
+    if (this.refreshPromise) return this.refreshPromise;
+    this.refreshPromise = this.performRefresh(options).finally(() => { this.refreshPromise = null; });
+    return this.refreshPromise;
+  }
+
+  async performRefresh({ force = false } = {}) {
+    const started = Date.now();
+    const remoteResult = await this.getRemoteRepositories({ force });
+    const remoteRepositories = remoteResult.repositories;
+
+    const discoveredPaths = await this.getDiscoveredPaths({ force });
    const mappedPaths = Object.values(this.store.data.repositoryMappings || {});
    const localPaths = [...new Set([...discoveredPaths, ...mappedPaths])];
    const localDescriptors = await this.getLocalDescriptors(localPaths);
@@ -106,7 +202,12 @@ class RepositoryService {
        ...profile,
        state: this.store.getDeploymentState(profile.id)
      }));
-      repositories.push(this.decorate(remote, local, profiles));
+      repositories.push({
+        ...this.decorate(remote, local, profiles),
+        remoteStale: remoteResult.stale,
+        remoteRefreshError: remoteResult.error,
+        remoteLastRefreshedAt: this.lastSuccessfulRemoteRefreshAt
+      });
    }

    for (const local of localDescriptors.filter((item) => !usedLocalPaths.has(item.localPath))) {
@@ -145,11 +246,14 @@ class RepositoryService {
    await this.diagnostics?.debug('repositories.refresh.completed', {
      durationMs: Date.now() - started,
      remoteCount: remoteRepositories.length,
+      remoteStale: remoteResult.stale,
+      remoteCached: remoteResult.cached === true,
      discoveredCount: discoveredPaths.length,
      linkedCount: sorted.filter((item) => item.localPath).length,
      attentionCount: sorted.filter((item) => item.attention).length,
      readyToDeployCount: sorted.filter((item) => item.readyToDeploy).length
    });
+    this.lastResult = sorted;
    return sorted;
  }

@@ -1,6 +1,5 @@
 'use strict';

-const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const crypto = require('node:crypto');
 const path = require('node:path').posix;
@@ -54,9 +53,29 @@ function parseCapabilityOutput(output) {
 }

 class SshService {
-  constructor({ store, diagnostics }) {
+  constructor({ store, diagnostics, idleConnectionMs = 60_000, clientFactory = loadSshClient }) {
    this.store = store;
    this.diagnostics = diagnostics;
+    this.clientFactory = clientFactory;
+    // Every command used to pay for a TCP handshake, a key exchange and an
+    // authentication round trip. Sessions are kept per server for a short while
+    // so a sequence of commands shares one connection.
+    this.sessions = new Map();
+    this.idleConnectionMs = idleConnectionMs;
+  }
+
+  // A connection is only reusable for a server whose identity and credentials
+  // are unchanged. Anything in this key changing means a new connection.
+  sessionKey(server) {
+    return JSON.stringify([
+      server.id,
+      server.host,
+      server.port || 22,
+      server.username,
+      server.authType,
+      server.privateKeyPath || '',
+      server.hostFingerprint || '',
+    ]);
  }

  async validateServerConfiguration(server, secrets = {}) {
@@ -86,7 +105,7 @@ class SshService {
    return { valid: true, method: 'privateKey', encrypted: Boolean(passphrase), privateKeyPath };
  }

-  async connectionOptions(server, { trustOnFirstUse = false } = {}) {
+  async connectionOptions(server, { trustOnFirstUse = false, expectedFingerprint = null } = {}) {
    const credentials = this.store.getServerCredentials(server.id);
    let observedFingerprint = null;
    const options = {
@@ -98,7 +117,8 @@ class SshService {
      keepaliveCountMax: 3,
      hostVerifier: (key) => {
        observedFingerprint = fingerprintKey(key);
-        return trustOnFirstUse || Boolean(server.hostFingerprint && observedFingerprint === server.hostFingerprint);
+        const trustedFingerprint = String(server.hostFingerprint || expectedFingerprint || '').trim();
+        return trustOnFirstUse || Boolean(trustedFingerprint && observedFingerprint === trustedFingerprint);
      },
    };
    if (server.authType === 'password') options.password = credentials.password;
@@ -117,7 +137,115 @@ class SshService {
  async withClient(serverId, action, options = {}) {
    const server = this.store.getServer(serverId);
    if (!server) throw new Error('The configured SSH server no longer exists.');
-    const Client = loadSshClient();
+    // A trust-on-first-use connection is established without checking the
+    // fingerprint, so it must never serve a later verified call.
+    if (options.trustOnFirstUse || options.expectedFingerprint) return this.withDedicatedClient(server, action, options);
+    return this.withPooledClient(server, action, options);
+  }
+
+  // Retrying is only safe while the command has not reached the server. Once a
+  // stream is open the remote side may already be deploying, and repeating that
+  // is not something this layer is allowed to decide.
+  isPreCommandFailure(error) {
+    return error?.beforeCommand === true;
+  }
+
+  async withPooledClient(server, action, options) {
+    const key = this.sessionKey(server);
+    for (let attempt = 0; ; attempt += 1) {
+      const session = await this.leaseSession(server, key, options);
+      try {
+        const result = await action(session.client, server, session.fingerprint);
+        this.releaseSession(session);
+        return result;
+      } catch (error) {
+        const staleConnection = session.reused && attempt === 0 && this.isPreCommandFailure(error);
+        this.discardSession(session);
+        if (!staleConnection) throw error;
+        await this.diagnostics?.debug('ssh.session.stale-retry', { serverId: server.id, host: server.host, message: error.message });
+      }
+    }
+  }
+
+  createSession(server, key, options) {
+    const entry = { key, client: null, fingerprint: null, leases: 0, dead: false, established: false, idleTimer: null, opening: null };
+    entry.opening = this
+      .withDedicatedClient(server, async (client, _server, fingerprint) => ({ client, fingerprint }), options, { keepOpen: true })
+      .then((opened) => {
+        entry.client = opened.client;
+        entry.fingerprint = opened.fingerprint;
+        entry.established = true;
+        // Without a standing listener an error on an idle connection is
+        // unhandled, which terminates the main process.
+        opened.client.on('error', () => this.markSessionDead(entry));
+        opened.client.on('close', () => this.markSessionDead(entry));
+        opened.client.on('end', () => this.markSessionDead(entry));
+      });
+    this.sessions.set(key, entry);
+    return entry;
+  }
+
+  async leaseSession(server, key, options) {
+    const pooled = this.sessions.get(key);
+    // Only a connection that was already up before this call may be retried on
+    // failure. Callers that arrive while one is still being opened share both
+    // the connection and its outcome.
+    const reused = Boolean(pooled && !pooled.dead && pooled.established);
+    const entry = pooled && !pooled.dead ? pooled : this.createSession(server, key, options);
+    entry.leases += 1;
+    if (entry.idleTimer) { clearTimeout(entry.idleTimer); entry.idleTimer = null; }
+    try {
+      await entry.opening;
+    } catch (error) {
+      entry.leases -= 1;
+      this.markSessionDead(entry);
+      throw error;
+    }
+    return { client: entry.client, fingerprint: entry.fingerprint, reused, entry };
+  }
+
+  markSessionDead(entry) {
+    entry.dead = true;
+    if (this.sessions.get(entry.key) === entry) this.sessions.delete(entry.key);
+    if (entry.idleTimer) { clearTimeout(entry.idleTimer); entry.idleTimer = null; }
+    if (entry.leases <= 0) this.endSession(entry);
+  }
+
+  endSession(entry) {
+    if (!entry.client) return;
+    try { entry.client.end(); } catch { /* already closed */ }
+  }
+
+  releaseSession(session) {
+    const entry = session.entry;
+    entry.leases -= 1;
+    if (entry.dead) { if (entry.leases <= 0) this.endSession(entry); return; }
+    if (entry.leases > 0) return;
+    entry.idleTimer = setTimeout(() => {
+      entry.idleTimer = null;
+      this.markSessionDead(entry);
+    }, this.idleConnectionMs);
+    entry.idleTimer.unref?.();
+  }
+
+  discardSession(session) {
+    const entry = session.entry;
+    entry.leases -= 1;
+    this.markSessionDead(entry);
+  }
+
+  // Closes every pooled connection. The application calls this while quitting so
+  // no socket outlives the process.
+  closeAll() {
+    for (const entry of [...this.sessions.values()]) {
+      entry.leases = 0;
+      this.markSessionDead(entry);
+    }
+  }
+
+  async withDedicatedClient(server, action, options = {}, { keepOpen = false } = {}) {
+    const serverId = server.id;
+    const Client = this.clientFactory();
    const connection = await this.connectionOptions(server, options);
    const client = new Client();
    const started = Date.now();
@@ -126,7 +254,8 @@ class SshService {
      const finish = (callback, value) => {
        if (settled) return;
        settled = true;
-        try { client.end(); } catch {}
+        // A session that stays in the pool is closed by the pool, not here.
+        if (!(keepOpen && callback === resolve)) { try { client.end(); } catch { /* already closed */ } }
        callback(value);
      };
      client.once('ready', async () => {
@@ -136,7 +265,11 @@ class SshService {
          finish(resolve, data);
        } catch (error) { finish(reject, error); }
      });
-      client.once('error', async (error) => {
+      // Deliberately not `once`: a connection that already failed can emit a
+      // second error while it is being torn down, and an unhandled 'error' event
+      // on an EventEmitter terminates the main process.
+      client.on('error', async (error) => {
+        if (settled) return;
        const observed = connection.getObservedFingerprint();
        const mismatch = Boolean(server.hostFingerprint && observed && server.hostFingerprint !== observed);
        const wrapped = new Error(mismatch
@@ -164,6 +297,9 @@ class SshService {
        if (error) {
          clearTimeout(timer);
          completed = true;
+          // The channel never opened, so the command did not reach the server.
+          // This is the only failure the pool is allowed to retry.
+          error.beforeCommand = true;
          reject(error);
          return;
        }
@@ -280,7 +416,51 @@ class SshService {
    }));
  }

-  async test(serverId, { trustOnFirstUse = true } = {}) {
+  async probeHostFingerprint(serverId) {
+    const server = this.store.getServer(serverId);
+    if (!server) throw new Error('The configured SSH server no longer exists.');
+    const Client = this.clientFactory();
+    const client = new Client();
+    let observedFingerprint = null;
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (callback, value) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        try { client.end(); } catch { /* handshake already closed */ }
+        callback(value);
+      };
+      const completeProbe = (error = null) => {
+        if (observedFingerprint) {
+          finish(resolve, {
+            fingerprint: observedFingerprint,
+            server: { id: server.id, name: server.name, host: server.host, port: server.port || 22 },
+          });
+          return;
+        }
+        const wrapped = new Error(`Could not read the SSH host fingerprint: ${error?.message || 'the server closed the handshake'}`);
+        wrapped.code = error?.code || 'SSH_HOST_KEY_PROBE_FAILED';
+        finish(reject, wrapped);
+      };
+      const timer = setTimeout(() => completeProbe(new Error('The SSH host-key probe timed out.')), 25_000);
+      client.on('error', completeProbe);
+      client.on('close', () => completeProbe());
+      client.on('end', () => completeProbe());
+      client.connect({
+        host: server.host,
+        port: server.port || 22,
+        username: server.username,
+        readyTimeout: 20_000,
+        hostVerifier: (key) => {
+          observedFingerprint = fingerprintKey(key);
+          return false;
+        },
+      });
+    });
+  }
+
+  async test(serverId, { trustOnFirstUse = false, expectedFingerprint = null } = {}) {
    return this.withClient(serverId, async (client, server, fingerprint) => {
      const script = `
 platform=$(uname -srm 2>/dev/null || true)
@@ -315,7 +495,7 @@ printf 'baseWritable=%s\\n' "$base_writable"
        capabilities,
        output: [capabilities.platform, capabilities.composeVersion].filter(Boolean).join('\n'),
      };
-    }, { trustOnFirstUse });
+    }, { trustOnFirstUse, expectedFingerprint });
  }

  async exec(serverId, command, options = {}) {
@@ -1,9 +1,14 @@
 "use strict";

-function createUnraidAccessMethods({ shellQuote, path, bash, inventoryRemoteIdentity, checksSummary, crypto }) {
+function createUnraidAccessMethods({ shellQuote, path, bash, inventoryRemoteIdentity, checksSummary, crypto, parsePermissionInspection, safeRelativeRemoteFile }) {
  class UnraidAccessMethods {
    serverGitRemote(repository, profile) {
-      const candidates = [repository.sshUrl, profile.cloneUrl, repository.preferredCloneUrl]
+      const candidates = [
+        repository.localStatus?.remoteUrl,
+        repository.sshUrl,
+        repository.preferredCloneUrl,
+        profile.cloneUrl,
+      ]
        .map((value) => String(value || "").trim())
        .filter(Boolean);
      const value = candidates.find((candidate) => /^ssh:\/\//i.test(candidate) || /^[^@\s]+@[^:\s]+:.+/.test(candidate));
@@ -212,10 +217,19 @@ function createUnraidAccessMethods({ shellQuote, path, bash, inventoryRemoteIden
      add("commit-parity", "Gitea and server parity", branchSha && liveSha && branchSha === liveSha ? "pass" : branchSha && liveSha ? "warning" : "incomplete", branchSha && liveSha ? branchSha === liveSha ? "The exact Gitea commit is live." : `Live ${String(liveSha).slice(0, 12)} differs from Gitea ${String(branchSha).slice(0, 12)}.` : "Parity cannot be proven until both SHAs are available.", { branchSha, liveSha });
      add("runtime", "Container runtime", running === true ? "pass" : running === false ? "fail" : "incomplete", running === true ? "The linked container is running." : running === false ? "The linked container is stopped." : "Runtime state has not been verified.");
      add("health", "Runtime health", healthy === true ? "pass" : healthy === false ? "fail" : "incomplete", healthy === true ? "Runtime health passed." : healthy === false ? "Runtime health failed." : "No conclusive runtime health evidence is available.");
+      const deploymentCheckIds = new Set(["gitea-access", "remote-branch", "deploy-key-scope", "server-git-access", "server-inspection"]);
+      const deploymentBlockers = checks.filter((item) => deploymentCheckIds.has(item.id) && item.status !== "pass");
+      const deployReady = Boolean(branchSha) && deploymentBlockers.length === 0;
      const failed = checks.some((item) => item.status === "fail");
      const incomplete = checks.some((item) => ["warning", "incomplete", "unsupported"].includes(item.status));
-      const readiness = failed ? (checks.some((item) => item.id.includes("access") || item.id.includes("key")) ? "Access failed" : checks.some((item) => item.id === "runtime" || item.id === "health") ? "Runtime unhealthy" : "Configuration required") : incomplete ? (branchSha && liveSha && branchSha !== liveSha ? "Commit mismatch" : "Verification incomplete") : "Ready";
-      return { readiness, ready: readiness === "Ready" || readiness === "Commit mismatch", checkedAt: new Date().toISOString(), repository: repository.fullName, profileId, server: { id: server.id, name: server.name }, remotePath, branch: profile.branch, branchSha, liveSha, checks };
+      const readiness = deploymentBlockers.length
+        ? "Access failed"
+        : failed
+          ? "Deploy-ready; runtime unhealthy"
+          : incomplete
+            ? (branchSha && liveSha && branchSha !== liveSha ? "Deployable update available" : "Deploy-ready; runtime verification incomplete")
+            : "Ready";
+      return { readiness, ready: deployReady, deployReady, deploymentBlockers, checkedAt: new Date().toISOString(), repository: repository.fullName, profileId, server: { id: server.id, name: server.name }, remotePath, branch: profile.branch, branchSha, liveSha, checks };
    }
  
    permissionTargets(profile, server, remotePath) {
@@ -20,7 +20,7 @@ class UnraidDeployKeyHost {
    return { directory, privateKey: path.join(directory, "deploy-key"), publicKey: path.join(directory, "deploy-key.pub"), knownHosts: path.join(directory, "known_hosts"), recovery: path.join(directory, "recovery") };
  }
  remote(repository, profile) {
-    const value = [repository.sshUrl, profile.cloneUrl, repository.preferredCloneUrl].map((item) => String(item || "").trim()).find((item) => /^ssh:\/\//i.test(item) || /^[^@\s]+@[^:\s]+:.+/.test(item));
+    const value = [repository.localStatus?.remoteUrl, repository.sshUrl, repository.preferredCloneUrl, profile.cloneUrl].map((item) => String(item || "").trim()).find((item) => /^ssh:\/\//i.test(item) || /^[^@\s]+@[^:\s]+:.+/.test(item));
    if (!value) throw Object.assign(new Error("Server pull requires a Gitea SSH URL."), { code: "SERVER_GIT_SSH_URL_REQUIRED" });
    return value;
  }
@@ -50,7 +50,10 @@ class UnraidDeployKeyHost {
    const f = parseMarker((await this.execute(server, script, { timeout: 45_000, maxOutput: 256 * 1024 })).stdout, marker);
    return { ready: /^[0-9a-f]{40}$/i.test(f.remoteSha || ""), remoteSha: f.remoteSha || null, fingerprint: f.fingerprint || null, hostFingerprint: f.hostFingerprint || null };
  }
-  async preflightCandidate(context) { const proof = await this.verifyCandidate(context); if (!proof.ready) throw new Error("Candidate preflight did not prove the remote branch."); return proof; }
+  // A caller that just verified this candidate passes its proof in. Re-running
+  // `git ls-remote` would open a second SSH connection to ask the same question,
+  // with nothing in between that could change the answer.
+  async preflightCandidate(context) { const proof = context?.proof?.remoteSha ? context.proof : await this.verifyCandidate(context); if (!proof.ready) throw new Error("Candidate preflight did not prove the remote branch."); return proof; }
  async promote({ repository, server, candidate }) {
    const p = this.paths(repository, server); const c = candidate.paths;
    await this.execute(server, `test -s ${shellQuote(c.privateKey)}; test -s ${shellQuote(c.publicKey)}; test -s ${shellQuote(c.knownHosts)}; cp -p ${shellQuote(c.privateKey)} ${shellQuote(p.privateKey)}.new; cp -p ${shellQuote(c.publicKey)} ${shellQuote(p.publicKey)}.new; cp -p ${shellQuote(c.knownHosts)} ${shellQuote(p.knownHosts)}.new; mv ${shellQuote(p.privateKey)}.new ${shellQuote(p.privateKey)}; mv ${shellQuote(p.publicKey)}.new ${shellQuote(p.publicKey)}; mv ${shellQuote(p.knownHosts)}.new ${shellQuote(p.knownHosts)}`);
@@ -418,9 +418,12 @@ function createUnraidDeploymentMethods({
  
      const generated = profile.generatedCompose ? this.generatedCompose(profile, repository) : "";
      const iconReference = await this.prepareIcon(profile, repository, server);
+      const deploymentRepositoryUrl = mode === "server-git"
+        ? this.serverGitRemote(repository, profile)
+        : repository.localStatus?.remoteUrl || repository.sshUrl || repository.cloneUrl || repository.htmlUrl || repository.fullName;
      const metadata = this.metadataCompose(profile, repository, iconReference, {
        sha: targetSha,
-        repositoryUrl: profile.cloneUrl || repository.sshUrl || repository.cloneUrl || repository.htmlUrl || repository.fullName,
+        repositoryUrl: deploymentRepositoryUrl,
      });
      const previousState = this.store.getDeploymentState?.(profileId) || null;
  
@@ -518,9 +521,12 @@ function createUnraidDeploymentMethods({
      });
      const generated = profile.generatedCompose ? this.generatedCompose(profile, repository) : "";
      const iconReference = await this.prepareIcon(profile, repository, server);
+      const rollbackRepositoryUrl = rollbackMode === "server-git"
+        ? this.serverGitRemote(repository, profile)
+        : repository.localStatus?.remoteUrl || repository.sshUrl || repository.cloneUrl || repository.htmlUrl || repository.fullName;
      const metadata = this.metadataCompose(profile, repository, iconReference, {
        sha: target,
-        repositoryUrl: profile.cloneUrl || repository.sshUrl || repository.cloneUrl || repository.htmlUrl || repository.fullName,
+        repositoryUrl: rollbackRepositoryUrl,
      });
      try {
        const mode = rollbackMode;
@@ -490,7 +490,7 @@ for (const name of Object.getOwnPropertyNames(preflightMethods)) {
  if (name !== "constructor") Object.defineProperty(UnraidDeploymentService.prototype, name, Object.getOwnPropertyDescriptor(preflightMethods, name));
 }

-const accessMethods = createUnraidAccessMethods({ shellQuote, path, bash, inventoryRemoteIdentity, checksSummary, crypto });
+const accessMethods = createUnraidAccessMethods({ shellQuote, path, bash, inventoryRemoteIdentity, checksSummary, crypto, parsePermissionInspection, safeRelativeRemoteFile });
 for (const name of Object.getOwnPropertyNames(accessMethods)) {
  if (name !== "constructor") Object.defineProperty(UnraidDeploymentService.prototype, name, Object.getOwnPropertyDescriptor(accessMethods, name));
 }
@@ -34,14 +34,23 @@ function createUnraidInventoryMethods({
  fi
  if [ -n "$ids" ]; then
    disappeared=0
-    while IFS= read -r container_id; do
-      [ -n "$container_id" ] || continue
-      if inspect=$(docker inspect --format '{"id":{{json .Id}},"name":{{json .Name}},"image":{{json .Config.Image}},"imageId":{{json .Image}},"running":{{json .State.Running}},"status":{{json .State.Status}},"health":{{if .State.Health}}{{json .State.Health.Status}}{{else}}null{{end}},"labels":{{json .Config.Labels}},"ports":{{json .NetworkSettings.Ports}},"mounts":{{json .Mounts}},"networks":{{json .NetworkSettings.Networks}},"restartPolicy":{{json .HostConfig.RestartPolicy.Name}}}' "$container_id" 2>/dev/null); then
-        printf 'C\\t%s\\n' "$(printf '%s' "$inspect" | base64 | tr -d '\\r\\n')"
-      else
-        disappeared=$((disappeared + 1))
-      fi
-    done <<< "$ids"
+    mapfile -t container_ids <<< "$ids"
+    # Docker accepts multiple IDs and returns one JSON array. This avoids one
+    # daemon round-trip per container on larger Unraid installations.
+    if inspect=$(docker inspect "\${container_ids[@]}" 2>/dev/null); then
+      printf 'C\\t%s\\n' "$(printf '%s' "$inspect" | base64 | tr -d '\\r\\n')"
+    else
+      # A container can disappear between docker ps and inspect. Fall back to
+      # individual reads so the remaining inventory stays complete.
+      for container_id in "\${container_ids[@]}"; do
+        [ -n "$container_id" ] || continue
+        if inspect=$(docker inspect "$container_id" 2>/dev/null); then
+          printf 'C\\t%s\\n' "$(printf '%s' "$inspect" | base64 | tr -d '\\r\\n')"
+        else
+          disappeared=$((disappeared + 1))
+        fi
+      done
+    fi
    if [ "$disappeared" -gt 0 ]; then
      printf 'W\\t%s\\n' "$(printf '%s' "$disappeared stale container reference(s) disappeared during inventory; current containers were still processed." | base64 | tr -d '\\r\\n')"
    fi
@@ -95,26 +104,35 @@ function createUnraidInventoryMethods({
        (
          set -- -f "$primary"
          files_text=$primary
+          has_override=false
          for extra in "$dir/compose.override.yml" "$dir/compose.override.yaml" "$dir/docker-compose.override.yml" "$dir/docker-compose.override.yaml"; do
            [ -f "$extra" ] || continue
+            has_override=true
            set -- "$@" -f "$extra"
            files_text="$files_text
  $extra"
          done
          project_name=$(sed -n 's/^name:[[:space:]]*//p' "$primary" 2>/dev/null | head -n1 | cut -d'#' -f1 | tr -d '"' | tr -d "'" | xargs 2>/dev/null || true)
          [ -n "$project_name" ] || project_name=$(basename "$dir")
-          valid=false; services=''; images=''; compose_error=''
+          valid=false; services=''; compose_error=''
+          images=$(awk '
+            /^[[:space:]]*services:[[:space:]]*($|#)/ { in_services=1; next }
+            in_services && /^[^[:space:]]/ { exit }
+            in_services && /^[[:space:]]+image:[[:space:]]*/ {
+              line=$0; sub(/^[[:space:]]*image:[[:space:]]*/, "", line); sub(/[[:space:]]+#.*/, "", line); gsub(/"/, "", line); print line
+            }
+          ' "$primary" 2>/dev/null || true)
          if [ "$compose_ok" != true ]; then
            compose_error='Docker Compose is unavailable; file metadata was still detected.'
          elif [ "$compose_v2" = true ]; then
            if services=$(cd "$dir" && docker compose "$@" config --services 2>&1); then
              valid=true
-              images=$(cd "$dir" && docker compose "$@" config --images 2>/dev/null || true)
+              if [ "$has_override" = true ] || [ -z "$images" ] || printf '%s' "$images" | grep -q '\$'; then images=$(cd "$dir" && docker compose "$@" config --images 2>/dev/null || true); fi
            else compose_error=$services; services=''; fi
          else
            if services=$(cd "$dir" && docker-compose "$@" config --services 2>&1); then
              valid=true
-              images=$(cd "$dir" && docker-compose "$@" config --images 2>/dev/null || true)
+              if [ "$has_override" = true ] || [ -z "$images" ] || printf '%s' "$images" | grep -q '\$'; then images=$(cd "$dir" && docker-compose "$@" config --images 2>/dev/null || true); fi
            else compose_error=$services; services=''; fi
          fi
          if [ -z "$services" ]; then
@@ -126,15 +144,6 @@ function createUnraidInventoryMethods({
              }
            ' "$primary" 2>/dev/null || true)
          fi
-          if [ -z "$images" ]; then
-            images=$(awk '
-              /^[[:space:]]*services:[[:space:]]*($|#)/ { in_services=1; next }
-              in_services && /^[^[:space:]]/ { exit }
-              in_services && /^[[:space:]]+image:[[:space:]]*/ {
-                line=$0; sub(/^[[:space:]]*image:[[:space:]]*/, "", line); sub(/[[:space:]]+#.*/, "", line); gsub(/"/, "", line); print line
-              }
-            ' "$primary" 2>/dev/null || true)
-          fi
          printf 'Y\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n' \\
            "$(printf '%s' "$dir" | base64 | tr -d '\\r\\n')" \\
            "$(printf '%s' "$files_text" | base64 | tr -d '\\r\\n')" \\
@@ -251,19 +260,38 @@ function createUnraidInventoryMethods({
    }
  
    refreshedProfileFromWorkload(repository, server, workload, existingProfile) {
+      const configuredRoot = path.join(server.basePath, existingProfile.remoteFolder || "").replace(/\/+$/, "");
+      const composeWorkingDir = String(workload.compose?.workingDir || "").replace(/\/+$/, "");
+      const configuredRootOwnsCompose = Boolean(
+        configuredRoot
+        && composeWorkingDir
+        && (composeWorkingDir === configuredRoot || composeWorkingDir.startsWith(`${configuredRoot}/`)),
+      );
      const detected = this.profileFromWorkload(repository, server, workload, {
        linkSource: existingProfile.workloadIdentity?.linkSource || "automatic-compose",
        deploymentMode: ["push-bundle", "server-git", "monitor-only"].includes(existingProfile.deploymentMode)
          ? existingProfile.deploymentMode
          : "push-bundle",
-        remoteFolder: workload.remoteFolderCandidate || existingProfile.remoteFolder,
+        remoteFolder: configuredRootOwnsCompose
+          ? existingProfile.remoteFolder
+          : workload.remoteFolderCandidate || existingProfile.remoteFolder,
      });
+      const repositoryRelativeComposeFiles = configuredRootOwnsCompose
+        ? [...new Set((workload.compose?.configFiles || []).map((file) => {
+          const value = String(file || "").trim().replace(/\\/g, "/");
+          if (value.startsWith(`${configuredRoot}/`)) return value.slice(configuredRoot.length + 1);
+          return value.startsWith("/") ? "" : value;
+        }).filter(Boolean))]
+        : [];
+      const composeFiles = repositoryRelativeComposeFiles.length
+        ? repositoryRelativeComposeFiles
+        : detected.composeFiles;
      return {
        ...existingProfile,
        deploymentMode: detected.deploymentMode,
        remoteFolder: detected.remoteFolder,
-        composeFile: detected.composeFile,
-        composeFiles: detected.composeFiles,
+        composeFile: composeFiles[0],
+        composeFiles,
        composeProject: detected.composeProject,
        composeWorkingDir: detected.composeWorkingDir,
        composeService: detected.composeService,
@@ -287,7 +315,7 @@ function createUnraidInventoryMethods({
      };
    }
  
-    async saveWorkloadState(profile, workload, server) {
+    async saveWorkloadState(profile, workload, server, { expectedGiteaSha = null, health = null } = {}) {
      const candidateSha = String(workload.metadata?.liveRevision || "");
      const previousState = this.store.getDeploymentState?.(profile.id) || {};
      const observedLiveSha = /^[0-9a-f]{40,64}$/i.test(candidateSha) ? candidateSha.toLowerCase() : null;
@@ -295,11 +323,21 @@ function createUnraidInventoryMethods({
      const profileRemote = inventoryRemoteIdentity(profile.cloneUrl);
      const workloadRemote = inventoryRemoteIdentity(workload.metadata?.sourceRepository);
      const repositoryMatches = Boolean(observedLiveSha && profileRemote && workloadRemote && profileRemote === workloadRemote);
+      const verifiedGiteaSha = /^[0-9a-f]{40}$/i.test(String(expectedGiteaSha || ""))
+        ? String(expectedGiteaSha).toLowerCase()
+        : null;
+      const matchesGitea = Boolean(repositoryMatches && verifiedGiteaSha && observedLiveSha === verifiedGiteaSha);
      const primary = workload.containers.find((container) => container.running) || workload.containers[0] || {};
+      const dockerHealthy = workload.runtime.health === "healthy" ? true : workload.runtime.health === "unhealthy" ? false : null;
+      const effectiveHealthy = workload.runtime.running === false
+        ? false
+        : health?.configured ? health.healthy : dockerHealthy;
      return this.store.saveDeploymentState(profile.id, {
        liveSha,
-        healthy: workload.runtime.health === "healthy" ? true : workload.runtime.health === "unhealthy" ? false : null,
-        runtimeVerification: workload.runtime.health === "unverified" ? "running-unverified" : workload.runtime.health,
+        healthy: effectiveHealthy,
+        healthStatus: health?.status ?? null,
+        healthLatencyMs: health?.latencyMs ?? null,
+        runtimeVerification: workload.runtime.running === false ? "stopped" : health?.configured ? "desktop-healthcheck" : workload.runtime.health === "unverified" ? "running-unverified" : workload.runtime.health,
        containerRunning: workload.runtime.running,
        dockerHealth: primary.health || null,
        containerName: primary.name || profile.containerName,
@@ -309,8 +347,8 @@ function createUnraidInventoryMethods({
        composeProject: workload.compose?.project || null,
        observedAt: workload.observedAt,
        evidence: liveSha ? "container-provenance-label" : "runtime-only",
-        giteaSha: repositoryMatches ? observedLiveSha : previousState.giteaSha || null,
-        matchesGitea: repositoryMatches ? true : previousState.matchesGitea === true && previousState.liveSha === liveSha,
+        giteaSha: verifiedGiteaSha,
+        matchesGitea,
        previousSha: previousState.previousSha || null,
      });
    }
@@ -384,15 +422,43 @@ function createUnraidInventoryMethods({
      };
    }
  
-    async scanServerInventory(serverId, repositories) {
+    async scanServerInventory(serverId, repositories, { autoLink = false } = {}) {
+      const started = Date.now();
      const { server, inventory, workloads } = await this.collectServerInventory(serverId, repositories);
-      const response = this.inventoryResponse(server, inventory, workloads);
+      let adopted = 0;
+      const adoptedLinks = [];
+      if (autoLink) {
+        const plan = this.reconciliationPlan(server, workloads, repositories, { autoLink: true });
+        if (plan.additions.length) await this.store.createRecoverySnapshot?.(`automatic-server-links-${serverId}`);
+        const linkedRepositories = new Set(workloads
+          .filter((workload) => workload.classification?.type !== "stale-link" && workload.link?.repositoryFullName)
+          .map((workload) => String(workload.link.repositoryFullName).toLowerCase()));
+        for (const addition of plan.additions) {
+          const workload = workloads.find((item) => item.workloadId === addition.workloadId);
+          const repository = (repositories || []).find((item) => String(item.fullName).toLowerCase() === String(addition.repositoryFullName).toLowerCase());
+          const key = String(repository?.fullName || "").toLowerCase();
+          if (!workload || !repository || linkedRepositories.has(key)) continue;
+          const linkSource = addition.evidence === "exact-provenance" ? "automatic" : "automatic-runtime-identity";
+          const profile = this.profileFromWorkload(repository, server, workload, { linkSource, deploymentMode: "server-git" });
+          const saved = await this.store.saveDeploymentProfile(repository.fullName, profile);
+          await this.saveWorkloadState(saved, workload, server);
+          workload.status = "linked";
+          workload.link = { status: "linked", profileId: saved.id, repositoryFullName: repository.fullName, source: linkSource };
+          linkedRepositories.add(key);
+          adopted += 1;
+          adoptedLinks.push({ repositoryFullName: repository.fullName, profileId: saved.id, workloadId: workload.workloadId });
+        }
+      }
+      const response = this.inventoryResponse(server, inventory, workloads, { adopted });
      await this.diagnostics?.info("unraid.workloads.scanned", {
        serverId,
        detected: response.detected,
        linked: response.linked,
        needsReview: response.needsReview,
-        readOnly: true,
+        adopted,
+        adoptedLinks,
+        readOnly: !autoLink,
+        durationMs: Date.now() - started,
      });
      return response;
    }
@@ -400,7 +466,9 @@ function createUnraidInventoryMethods({
    reconciliationPlan(server, workloads, repositories, { autoLink = true } = {}) {
      const profiles = this.allSshProfiles().filter((profile) => profile.serverId === server.id);
      const activeWorkloadIds = new Set(workloads.filter((item) => item.classification?.type !== "stale-link").map((item) => item.workloadId));
-      const linkedRepositories = new Set(workloads.filter((item) => item.link?.repositoryFullName).map((item) => String(item.link.repositoryFullName).toLowerCase()));
+      const linkedRepositories = new Set(workloads
+        .filter((item) => item.classification?.type !== "stale-link" && item.link?.repositoryFullName)
+        .map((item) => String(item.link.repositoryFullName).toLowerCase()));
      const additions = [];
      const updates = [];
      const conflicts = [];
@@ -428,6 +496,7 @@ function createUnraidInventoryMethods({
            evidence: candidate.exact ? "exact-provenance" : "exact-runtime-identity",
            impact: "Create a server-pull deployment profile; no container changes",
          });
+          linkedRepositories.add(String(candidate.repositoryFullName).toLowerCase());
        } else if (["suggested", "ambiguous"].includes(workload.status) || (workload.runtime?.running && workload.candidates?.length)) {
          conflicts.push({
            workloadId: workload.workloadId,
@@ -559,7 +628,57 @@ function createUnraidInventoryMethods({
    }
  
    async discoverServerWorkloads(serverId, repositories) {
-      return this.scanServerInventory(serverId, repositories);
+      const started = Date.now();
+      const inventory = await this.scanServerInventory(serverId, repositories, { autoLink: true });
+      const server = this.store.getServer(serverId);
+      const queue = inventory.workloads.filter((workload) => workload.link?.profileId && workload.link?.repositoryFullName);
+      const refreshedProfileIds = [];
+      let giteaUnavailable = false;
+      let giteaFailureReported = false;
+      const workers = Array.from({ length: Math.min(5, queue.length) }, async () => {
+        while (queue.length) {
+          const workload = queue.shift();
+          const repository = repositories.find((item) => String(item.fullName).toLowerCase() === String(workload.link.repositoryFullName).toLowerCase());
+          const profile = this.store.getDeploymentProfile?.(workload.link.repositoryFullName, workload.link.profileId)
+            || this.store.getDeploymentProfiles?.(workload.link.repositoryFullName)?.find((item) => item.id === workload.link.profileId)
+            || this.allSshProfiles().find((item) => item.id === workload.link.profileId);
+          if (!repository || !profile) continue;
+          let expectedGiteaSha = null;
+          const status = repository.localStatus;
+          if (status?.head && status.branch?.head === profile.branch && status.branch?.upstream && status.branch.ahead === 0 && status.branch.behind === 0) {
+            expectedGiteaSha = status.head;
+          } else if (!giteaUnavailable) {
+            try {
+              const [owner, repo] = String(repository.fullName).split("/");
+              const branch = await this.gitea.getBranch(owner, repo, profile.branch);
+              expectedGiteaSha = branch?.commit?.id || branch?.commit?.sha || null;
+            } catch (error) {
+              if (!error?.status || Number(error.status) >= 500) {
+                giteaUnavailable = true;
+                if (!giteaFailureReported) {
+                  giteaFailureReported = true;
+                  await this.diagnostics?.warning("unraid.workloads.gitea-verification-degraded", {
+                    serverId,
+                    message: error.message,
+                  });
+                }
+              }
+            }
+          }
+          const health = workload.runtime.running
+            ? await this.checkHealth(profile.healthcheckUrl)
+            : { configured: false, healthy: false, skipped: "container-stopped" };
+          await this.saveWorkloadState(profile, workload, server, { expectedGiteaSha, health });
+          refreshedProfileIds.push(profile.id);
+        }
+      });
+      await Promise.all(workers);
+      await this.diagnostics?.debug("unraid.workloads.states-refreshed", {
+        serverId,
+        profiles: refreshedProfileIds.length,
+        durationMs: Date.now() - started,
+      });
+      return { ...inventory, refreshedProfiles: refreshedProfileIds.length, refreshedProfileIds };
    }
  
    async linkServerWorkload({ repository, serverId, workloadId, deploymentMode = "server-git", remoteFolder = "" }) {
@@ -283,6 +283,35 @@ function createUnraidPreflightMethods({
        }
      }

+      if (deploymentMode === "server-git") {
+        const [owner, repo] = String(repository.fullName || "").split("/");
+        const deploymentFiles = profile.generatedCompose
+          ? ["Dockerfile"]
+          : this.deploymentComposeFiles(profile);
+        try {
+          const existence = await Promise.all(deploymentFiles.map(async (filePath) => ({
+            filePath,
+            exists: await this.gitea.repositoryFileExists({ owner, repo, filePath, ref: targetSha }),
+          })));
+          const missing = existence.filter((item) => !item.exists).map((item) => item.filePath);
+          checks.push({
+            id: "gitea-deployment-files",
+            label: profile.generatedCompose ? "Dockerfile at Gitea commit" : "Compose files at Gitea commit",
+            status: missing.length ? "fail" : "pass",
+            detail: missing.length
+              ? `Missing at exact commit ${targetSha.slice(0, 12)}: ${missing.join(", ")}.`
+              : `${deploymentFiles.join(", ")} verified at exact commit ${targetSha.slice(0, 12)}.`,
+          });
+        } catch (error) {
+          checks.push({
+            id: "gitea-deployment-files",
+            label: "Deployment files at Gitea commit",
+            status: "fail",
+            detail: error.message,
+          });
+        }
+      }
+
      try {
        const connection = await this.ssh.test(server.id, { trustOnFirstUse: false });
        connectionCapabilities = connection.capabilities || {};
@@ -59,18 +59,23 @@ function createUnraidStateMethods({ path, bash, shellQuote, inventoryRemoteIdent
          return "";
        }
      };
-      const health = await this.checkHealth(profile.healthcheckUrl);
+      const containerRunning = fields.containerRunning === "true";
+      const health = containerRunning
+        ? await this.checkHealth(profile.healthcheckUrl)
+        : { configured: false, healthy: false, skipped: "container-stopped" };
      const dockerHealthy = fields.dockerHealth
        ? fields.dockerHealth === "healthy"
        : null;
-      const effectiveHealthy = health.configured ? health.healthy : dockerHealthy;
-      const runtimeVerification = health.configured
+      const effectiveHealthy = !containerRunning ? false : health.configured ? health.healthy : dockerHealthy;
+      const runtimeVerification = !containerRunning
+        ? "stopped"
+        : health.configured
        ? "desktop-healthcheck"
        : dockerHealthy === true
          ? "docker-healthcheck"
          : dockerHealthy === false
            ? "docker-unhealthy"
-            : fields.containerRunning === "true"
+            : containerRunning
              ? "running-unverified"
              : "stopped";
      return this.store.saveDeploymentState(profile.id, {
@@ -85,7 +90,7 @@ function createUnraidStateMethods({ path, bash, shellQuote, inventoryRemoteIdent
        healthStatus: health.status,
        healthLatencyMs: health.latencyMs,
        containerName,
-        containerRunning: fields.containerRunning === "true",
+        containerRunning,
        dockerHealth: fields.dockerHealth || null,
        dockerMan: {
          webUi: decode(fields.webUiLabel),
@@ -122,9 +127,6 @@ function createUnraidStateMethods({ path, bash, shellQuote, inventoryRemoteIdent
        // profile hint no longer matches the real Compose service keys.
        return this.refreshProfileState(repository.fullName, profileId);
      }
-      const composeFile = profile.generatedCompose
-        ? ".forgeflow/compose.forgeflow.yml"
-        : safeRelativeRemoteFile(profile.composeFile || "docker-compose.yml");
      const iconReference = await this.prepareIcon(profile, repository, server);
      const metadata = this.metadataCompose(profile, repository, iconReference);
      const compose = this.composeInvocation(profile, repository);
@@ -273,7 +275,16 @@ function createUnraidStateMethods({ path, bash, shellQuote, inventoryRemoteIdent
            item.status,
          ),
      );
-      return Promise.all(active.map((item) => this.refreshOperation(item.id)));
+      const queue = [...active];
+      const results = [];
+      const workers = Array.from({ length: Math.min(4, queue.length) }, async () => {
+        while (queue.length) {
+          const operation = queue.shift();
+          results.push(await this.refreshOperation(operation.id));
+        }
+      });
+      await Promise.all(workers);
+      return results;
    }
  }
  return UnraidStateMethods.prototype;
@@ -14,10 +14,95 @@ function safeRepositoryPart(value, label) {
  return text;
 }

+function verifyReleaseManifest({
+  manifestBytes,
+  signatureBytes,
+  publicKey,
+  update,
+  assetName,
+}) {
+  if (
+    !Buffer.isBuffer(manifestBytes) ||
+    manifestBytes.length < 100 ||
+    manifestBytes.length > 1_000_000
+  ) {
+    throw new Error("The signed release manifest has an invalid size.");
+  }
+  const signatureText = Buffer.from(signatureBytes || "")
+    .toString("utf8")
+    .trim();
+  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(signatureText)) {
+    throw new Error("The release manifest signature is invalid.");
+  }
+  const signature = Buffer.from(signatureText, "base64");
+  if (signature.length !== 64) {
+    throw new Error("The release manifest signature is invalid.");
+  }
+  let verified = false;
+  try {
+    verified = crypto.verify(null, manifestBytes, publicKey, signature);
+  } catch {
+    verified = false;
+  }
+  if (!verified) {
+    const error = new Error(
+      "The release manifest was not signed by the trusted ForgeFlow publisher key.",
+    );
+    error.code = "RELEASE_SIGNATURE_INVALID";
+    throw error;
+  }
+
+  let manifest;
+  try {
+    manifest = JSON.parse(manifestBytes.toString("utf8"));
+  } catch {
+    throw new Error("The signed release manifest is not valid JSON.");
+  }
+  const expectedVersion = String(update.remoteVersion || "").trim();
+  const expectedCommit = String(update.remoteSha || "").toLowerCase();
+  if (
+    manifest.schemaVersion !== 1 ||
+    manifest.product !== "ForgeFlow" ||
+    manifest.version !== expectedVersion ||
+    manifest.tag !== `v${expectedVersion}` ||
+    manifest.signature?.algorithm !== "Ed25519" ||
+    (expectedCommit &&
+      String(manifest.commit || "").toLowerCase() !== expectedCommit)
+  ) {
+    const error = new Error(
+      "The signed release manifest does not match the requested ForgeFlow update.",
+    );
+    error.code = "RELEASE_MANIFEST_MISMATCH";
+    throw error;
+  }
+  const artifact = Array.isArray(manifest.artifacts)
+    ? manifest.artifacts.find((item) => item?.name === assetName)
+    : null;
+  if (
+    !artifact ||
+    !Number.isSafeInteger(artifact.bytes) ||
+    artifact.bytes < 1_000_000 ||
+    !/^[a-f0-9]{64}$/.test(String(artifact.sha256 || ""))
+  ) {
+    const error = new Error(
+      `The signed release manifest has no valid entry for ${assetName}.`,
+    );
+    error.code = "RELEASE_MANIFEST_INCOMPLETE";
+    throw error;
+  }
+  return { manifest, artifact };
+}
+
 function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
 }

+function requireSignedSourceUpdate(message) {
+  const error = new Error(message);
+  error.code = "SIGNED_SOURCE_UPDATE_REQUIRED";
+  throw error;
+}
+
 function resolveWindowsPowerShellPath(environment = process.env) {
  const windowsRoot = environment.SystemRoot || environment.WINDIR;
  if (windowsRoot) {
@@ -33,6 +118,18 @@ function resolveWindowsPowerShellPath(environment = process.env) {
  return "powershell.exe";
 }

+function windowsUpdaterSpawnOptions(cwd) {
+  return {
+    // A detached hidden PowerShell child can exit successfully on Windows
+    // without ever executing its -File script. Normal Windows children survive
+    // their parent; unref() below releases the event-loop reference instead.
+    detached: false,
+    stdio: "ignore",
+    windowsHide: true,
+    cwd,
+  };
+}
+
 async function readJsonFile(filePath) {
  try {
    return JSON.parse(await fs.readFile(filePath, "utf8"));
@@ -144,6 +241,7 @@ class UpdateService {
    powershellPath = null,
    handshakeTimeoutMs = 12000,
    handshakePollMs = 100,
+    updatePublicKey = null,
  }) {
    this.store = store;
    this.gitea = gitea;
@@ -156,6 +254,7 @@ class UpdateService {
    this.powershellPath = powershellPath;
    this.handshakeTimeoutMs = handshakeTimeoutMs;
    this.handshakePollMs = handshakePollMs;
+    this.updatePublicKey = updatePublicKey;
    this.staged = null;
  }

@@ -232,6 +331,11 @@ class UpdateService {
      return this.downloadPackaged(update);
    }

+    requireSignedSourceUpdate(
+      "Integrated source updates are disabled because source archives do not yet carry an independently signed publisher manifest. Update a source checkout with Git after reviewing the exact commit.",
+    );
+
+    /* c8 ignore start -- retained for a future signed source-archive implementation */
    await fs.mkdir(this.updateDirectory, { recursive: true });
    const archiveUrl = `${this.store.data.gitea.baseUrl.replace(/\/+$/, "")}/${encodeURIComponent(update.owner)}/${encodeURIComponent(update.repo)}/archive/${update.remoteSha}.zip`;
    const archive = await this.gitea.downloadAuthenticated(archiveUrl);
@@ -261,6 +365,7 @@ class UpdateService {
      sha256,
    });
    return { ...metadata, downloaded: true };
+    /* c8 ignore stop */
  }

  async downloadPackaged(update) {
@@ -279,7 +384,7 @@ class UpdateService {
      ));
    if (!release || release.draft || release.prerelease) {
      const error = new Error(
-        `ForgeFlow ${update.remoteVersion} has no published binary release yet. The source branch was updated, but the matching Windows installer/portable assets were not published. Run Publish-Missing-Binary-Release.ps1 from the release source or publish the four required assets in Gitea.`,
+        `ForgeFlow ${update.remoteVersion} has no published binary release yet. The source branch was updated, but the matching signed Windows release was not published. Run Publish-Missing-Binary-Release.ps1 from the release source.`,
      );
      error.code = "BINARY_RELEASE_NOT_FOUND";
      throw error;
@@ -288,33 +393,70 @@ class UpdateService {
    const portable = Boolean(this.appInfo.portableExecutablePath);
    const assetName = `ForgeFlow-${portable ? "Portable" : "Setup"}-${update.remoteVersion}-win-x64.exe`;
    const checksumName = `${assetName}.sha256`;
+    const manifestName = `ForgeFlow-${update.remoteVersion}-release-manifest.json`;
+    const signatureName = `${manifestName}.sig`;
    const assets = Array.isArray(release.assets) ? release.assets : [];
    const asset = assets.find((item) => item.name === assetName);
    const checksumAsset = assets.find((item) => item.name === checksumName);
-    if (!asset?.id || !checksumAsset?.id) {
+    const manifestAsset = assets.find((item) => item.name === manifestName);
+    const signatureAsset = assets.find((item) => item.name === signatureName);
+    if (
+      !asset?.id ||
+      !checksumAsset?.id ||
+      !manifestAsset?.id ||
+      !signatureAsset?.id
+    ) {
      const error = new Error(
-        `Release v${update.remoteVersion} is missing ${assetName} or its SHA-256 file.`,
+        `Release v${update.remoteVersion} is incomplete: the executable, SHA-256 file, signed manifest and signature are all required.`,
      );
      error.code = "BINARY_RELEASE_INCOMPLETE";
      throw error;
    }

-    const [binary, checksumBytes] = await Promise.all([
-      this.gitea.downloadReleaseAsset(
-        update.owner,
-        update.repo,
-        release.id,
-        asset.id,
-        { downloadUrl: asset.browser_download_url },
-      ),
-      this.gitea.downloadReleaseAsset(
-        update.owner,
-        update.repo,
-        release.id,
-        checksumAsset.id,
-        { downloadUrl: checksumAsset.browser_download_url },
-      ),
-    ]);
+    const [binary, checksumBytes, manifestBytes, signatureBytes] =
+      await Promise.all([
+        this.gitea.downloadReleaseAsset(
+          update.owner,
+          update.repo,
+          release.id,
+          asset.id,
+          { downloadUrl: asset.browser_download_url },
+        ),
+        this.gitea.downloadReleaseAsset(
+          update.owner,
+          update.repo,
+          release.id,
+          checksumAsset.id,
+          { downloadUrl: checksumAsset.browser_download_url },
+        ),
+        this.gitea.downloadReleaseAsset(
+          update.owner,
+          update.repo,
+          release.id,
+          manifestAsset.id,
+          { downloadUrl: manifestAsset.browser_download_url },
+        ),
+        this.gitea.downloadReleaseAsset(
+          update.owner,
+          update.repo,
+          release.id,
+          signatureAsset.id,
+          { downloadUrl: signatureAsset.browser_download_url },
+        ),
+      ]);
+
+    const publicKey =
+      this.updatePublicKey ||
+      (await fs.readFile(
+        path.join(this.sourcePath, "build", "update-signing-public.pem"),
+      ));
+    const { manifest, artifact } = verifyReleaseManifest({
+      manifestBytes,
+      signatureBytes,
+      publicKey,
+      update,
+      assetName,
+    });
    if (binary.length < 1_000_000 || binary[0] !== 0x4d || binary[1] !== 0x5a) {
      const preview = binary.subarray(0, 200).toString("utf8").trim();
      const looksLikeMetadata =
@@ -336,6 +478,16 @@ class UpdateService {
      ?.toLowerCase();
    if (!/^[a-f0-9]{64}$/.test(expectedSha256 || ""))
      throw new Error("The release SHA-256 file is invalid.");
+    if (expectedSha256 !== artifact.sha256) {
+      throw new Error(
+        "The release checksum does not match the signed publisher manifest.",
+      );
+    }
+    if (binary.length !== artifact.bytes) {
+      throw new Error(
+        "The downloaded Windows update size does not match the signed publisher manifest.",
+      );
+    }
    const sha256 = crypto.createHash("sha256").update(binary).digest("hex");
    if (sha256 !== expectedSha256)
      throw new Error(
@@ -356,6 +508,8 @@ class UpdateService {
        ? this.appInfo.portableExecutablePath
        : this.appInfo.executablePath,
      releaseTag: release.tag_name,
+      publisherKeyId: manifest.signature.keyId,
+      releaseManifest: manifestName,
      downloadedAt: new Date().toISOString(),
      downloaded: true,
    };
@@ -371,6 +525,7 @@ class UpdateService {
      bytes: binary.length,
      sha256,
      portable,
+      publisherKeyId: manifest.signature.keyId,
    });
    return metadata;
  }
@@ -385,6 +540,10 @@ class UpdateService {
        "The integrated updater currently supports Windows only.",
      );
    if (update.kind === "binary") return this.applyPackaged(update);
+    requireSignedSourceUpdate(
+      "This source archive cannot be applied because it has no independently signed publisher manifest.",
+    );
+    /* c8 ignore start -- legacy helper retained only for migration compatibility */
    const stat = await fs.stat(update.archivePath).catch(() => null);
    if (!stat?.isFile())
      throw new Error("The staged update archive is no longer available.");
@@ -450,12 +609,11 @@ class UpdateService {
    const childState = { exited: false, code: null, error: null };
    let child;
    try {
-      child = this.spawnProcess(executable, args, {
-        detached: true,
-        stdio: "ignore",
-        windowsHide: true,
-        cwd: this.sourcePath,
-      });
+      child = this.spawnProcess(
+        executable,
+        args,
+        windowsUpdaterSpawnOptions(this.sourcePath),
+      );
    } catch (error) {
      error.code ||= "UPDATE_HELPER_SPAWN_FAILED";
      throw error;
@@ -488,7 +646,9 @@ class UpdateService {
        5000,
      );
      child.once?.("spawn", () => finish(resolve));
-      child.once?.("error", (error) => finish(reject, error));
+      // Kept attached rather than `once`: a process that fails to start can
+      // report a second error, and an unhandled 'error' event ends this process.
+      child.on?.("error", (error) => finish(reject, error));
      if (!child.once) finish(resolve);
    });

@@ -518,6 +678,7 @@ class UpdateService {
      logPath,
      statusPath,
    };
+    /* c8 ignore stop */
  }

  async applyPackaged(update) {
@@ -591,12 +752,11 @@ class UpdateService {
      "-UpdateId",
      updateId,
    ];
-    const child = this.spawnProcess(executable, args, {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true,
-      cwd: this.updateDirectory,
-    });
+    const child = this.spawnProcess(
+      executable,
+      args,
+      windowsUpdaterSpawnOptions(this.updateDirectory),
+    );
    const childState = { exited: false, code: null, error: null };
    child.once?.("error", (error) => {
      childState.error = error;
@@ -620,7 +780,9 @@ class UpdateService {
        clearTimeout(timer);
        resolve();
      });
-      child.once?.("error", (error) => {
+      // Kept attached rather than `once`: a second error would otherwise have no
+      // listener left, and an unhandled 'error' event ends this process.
+      child.on?.("error", (error) => {
        clearTimeout(timer);
        reject(error);
      });
@@ -699,8 +861,11 @@ class UpdateService {
 module.exports = {
  UpdateService,
  safeRepositoryPart,
+  verifyReleaseManifest,
  resolveWindowsPowerShellPath,
+  windowsUpdaterSpawnOptions,
  waitForUpdaterStarted,
  readJsonFile,
  readLogTail,
+  requireSignedSourceUpdate,
 };
@@ -23,6 +23,7 @@ async function handleDeploymentProfileActions(event, target, action, repository)
    };
    render();
  } else if (action === "close-modal") {
+    if (ui.modal?.type === "workspace-sync") ui.workspaceSyncPlan = null;
    ui.modal = null;
    render();
  } else if (action === "select-profile-icon") {
@@ -337,8 +338,13 @@ async function handleDeploymentProfileActions(event, target, action, repository)
      const result = await window.forgeflow.verifyServerGitProfile(repository, profileId);
      ui.serverGitVerifications[profileId] = result;
      render();
-      const failures = result.checks.filter((check) => check.status === "fail");
-      showToast(result.readiness, failures[0]?.detail || `Verified ${result.checks.length} server-pull checks without changing the server.`, result.ready ? "success" : "warning");
+      const blockers = result.deploymentBlockers || [];
+      const warnings = result.checks.filter((check) => check.status !== "pass" && !blockers.some((blocker) => blocker.id === check.id));
+      showToast(
+        result.readiness,
+        blockers[0]?.detail || warnings[0]?.detail || `Verified ${result.checks.length} server-pull checks without changing the server.`,
+        blockers.length ? "error" : warnings.length ? "warning" : "success",
+      );
    } catch (error) {
      showToast("Server-pull verification failed", error.message, "error");
    } finally {
@@ -121,6 +121,72 @@ Force repair after you have closed all Git tools for this repository?`)
    }
    setLoading(false);
    render();
+  } else if (action === "preview-workspace-sync") {
+    if (!repository?.localPath) return;
+    setLoading(true, "Fetching Gitea and building a safe synchronization plan…");
+    try {
+      ui.workspaceSyncPlan = await window.forgeflow.previewWorkspaceSync(
+        repository.localPath,
+      );
+      ui.modal = { type: "workspace-sync" };
+      showToast(
+        ui.workspaceSyncPlan.needsSync
+          ? "Workspace sync preview ready"
+          : "Workspace already synchronized",
+        ui.workspaceSyncPlan.needsSync
+          ? `${ui.workspaceSyncPlan.summary.resultingTrackedChanges} tracked change(s) and ${ui.workspaceSyncPlan.summary.localFilesToStash} local file(s) reviewed.`
+          : `Local ${ui.workspaceSyncPlan.branch} already matches ${ui.workspaceSyncPlan.upstream}.`,
+        ui.workspaceSyncPlan.blockers?.length ? "error" : "success",
+      );
+    } catch (error) {
+      showToast("Could not preview Gitea sync", error.message, "error");
+    }
+    setLoading(false);
+    render();
+  } else if (action === "confirm-workspace-sync") {
+    if (!repository?.localPath || !ui.workspaceSyncPlan) return;
+    const expectedPlanId = target.dataset.planId;
+    setLoading(true, "Protecting local work and synchronizing exact Gitea state…");
+    try {
+      const result = await window.forgeflow.applyWorkspaceSync(
+        repository.localPath,
+        expectedPlanId,
+      );
+      ui.modal = null;
+      ui.workspaceSyncPlan = null;
+      await refreshRepositories(false);
+      [ui.branches, ui.stashes] = await Promise.all([
+        window.forgeflow.branches(repository.localPath),
+        window.forgeflow.stashList(repository.localPath),
+      ]);
+      const recovery = [
+        result.backupBranch ? `recovery branch ${result.backupBranch}` : null,
+        result.stash ? `quarantine stash ${result.stash.ref}` : null,
+        result.review ? `Codex review manifest ${result.review.manifestPath}` : null,
+      ].filter(Boolean).join(" and ");
+      showToast(
+        "Workspace synchronized with Gitea",
+        recovery
+          ? `Local work is quarantined in ${recovery}. Review it before restoring anything; ignored runtime files were retained.`
+          : `Tracked files now match ${result.plan.upstream}; ignored runtime files were retained.`,
+        "success",
+      );
+    } catch (error) {
+      if (error.code === "WORKSPACE_SYNC_PLAN_STALE") {
+        try {
+          ui.workspaceSyncPlan = await window.forgeflow.previewWorkspaceSync(
+            repository.localPath,
+          );
+          ui.modal = { type: "workspace-sync" };
+        } catch {
+          ui.modal = null;
+          ui.workspaceSyncPlan = null;
+        }
+      }
+      showToast("Workspace synchronization stopped", error.message, "error");
+    }
+    setLoading(false);
+    render();
  } else if (action === "repair-repository-sync") {
    if (!repository?.localPath) return;
    const strategy = target.dataset.strategy;
@@ -242,7 +242,18 @@ async function handleSetupAndSettingsActions(event, target, action, repository)
      "Checking SSH identity, Docker, Compose and optional Git capabilities…",
    );
    try {
-      const result = await window.forgeflow.testServer(target.dataset.serverId);
+      let result = await window.forgeflow.testServer(target.dataset.serverId);
+      if (result.needsTrust) {
+        const approved = confirm(
+          `Verify this fingerprint on the SSH server before trusting it:\n\n${result.fingerprint}\n\nServer: ${result.server.host}:${result.server.port}\n\nTrust this exact host identity and continue with authentication?`,
+        );
+        if (!approved) {
+          showToast("SSH trust cancelled", "No credentials were sent and the host identity was not saved.", "info");
+          setLoading(false);
+          return true;
+        }
+        result = await window.forgeflow.testServer(target.dataset.serverId, result.fingerprint);
+      }
      ui.boot.state = result.state;
      const capabilities = result.capabilities || {};
      const deploymentReady =
@@ -329,6 +340,9 @@ async function handleSetupAndSettingsActions(event, target, action, repository)
      operationPollSeconds: Number(
        document.querySelector("#pref-operation-poll").value,
      ),
+      fetchIntervalMinutes: Number(
+        document.querySelector("#pref-fetch-interval").value,
+      ),
      preferredCloneProtocol: document.querySelector("#pref-clone-protocol")
        .value,
    };
@@ -8,7 +8,32 @@ async function handleShellActions(event, target, action, repository) {
      await refreshDeploymentTruth(true);
      setLoading(false);
    }
+  } else if (action === "open-context-help" || action === "help-topic") {
+    ui.helpTopic = target.dataset.topic || "getting-started";
+    ui.helpQuery = "";
+    ui.currentView = "help";
+    ui.modal = null;
+    render();
+    requestAnimationFrame(() =>
+      document.querySelector(`[data-help-topic="${ui.helpTopic}"]`)?.scrollIntoView({ block: "start", behavior: "smooth" }),
+    );
+  } else if (action === "clear-help-search") {
+    ui.helpQuery = "";
+    render();
+    requestAnimationFrame(() => document.querySelector("#help-search")?.focus());
  } else if (action === "select-repo") selectRepository(target.dataset.id);
+  else if (action === "open-deployment-link") {
+    if (!repository) return true;
+    selectRepository(repository.id, false);
+    ui.selectedProfileId = target.dataset.profileId || selectedProfile(repository)?.id || null;
+    ui.repositoryTab = "deployments";
+    ui.currentView = "repository";
+    render();
+  } else if (action === "select-deployment-profile") {
+    ui.selectedProfileId = target.dataset.profileId || null;
+    ui.repositoryTab = "deployments";
+    render();
+  }
  else if (action === "refresh") {
    await refreshRepositories(true);
    await refreshActiveOperations(false);
@@ -59,6 +59,8 @@ const icons = {
    '<path d="M21 12a9 9 0 0 1-15.3 6.4L3 16"/><path d="M3 21v-5h5"/><path d="M3 12A9 9 0 0 1 18.3 5.6L21 8"/><path d="M21 3v5h-5"/>',
  wrench:
    '<path d="M14.7 6.3a4 4 0 0 0-5-5l2.1 2.1-2.8 2.8-2.1-2.1a4 4 0 0 0 5 5L20 17.2 17.2 20l-8.1-8.1a4 4 0 0 0-5-5l2.1 2.1-2.8 2.8-2.1-2.1a4 4 0 0 0 5 5"/>',
+  help:
+    '<circle cx="12" cy="12" r="9"/><path d="M9.7 9a2.5 2.5 0 1 1 3.8 2.1c-.9.5-1.5 1.1-1.5 2.4M12 17.5h.01"/>',
 };

 function icon(name, className = "") {
@@ -176,13 +178,21 @@ const ui = {
  inputRenderTimer: null,
  isMock: false,
  refreshError: null,
+  refreshWarning: null,
  autoRefreshPending: false,
+  repositoryRefreshPromise: null,
+  repositoryRefreshRequest: null,
+  deploymentTruthPromise: null,
+  deploymentTruthRequest: null,
  paletteQuery: "",
+  helpQuery: "",
+  helpTopic: "getting-started",
  updateStatus: null,
  updateChecking: false,
  servers: [],
  serverInspection: null,
  gitRecovery: null,
+  workspaceSyncPlan: null,
  gitValidation: null,
  diffHunks: null,
  conflictState: null,
@@ -408,7 +418,7 @@ async function bootstrap() {
  }
 }

-function scheduleAutoRefresh() {
+function scheduleAutoRefresh(delay = 450) {
  if (
    ui.loading ||
    ui.autoRefreshPending ||
@@ -419,15 +429,43 @@ function scheduleAutoRefresh() {
  setTimeout(async () => {
    ui.autoRefreshPending = false;
    await refreshRepositories(false, true);
-  }, 450);
+  }, delay);
 }

 async function refreshRepositories(withLoader = true, silent = false) {
+  ui.repositoryRefreshRequest = {
+    withLoader: ui.repositoryRefreshRequest?.withLoader === true || withLoader,
+    silent: ui.repositoryRefreshRequest ? ui.repositoryRefreshRequest.silent && silent : silent,
+  };
+  if (ui.repositoryRefreshPromise) return ui.repositoryRefreshPromise;
+  ui.repositoryRefreshPromise = (async () => {
+    let result;
+    while (ui.repositoryRefreshRequest) {
+      const request = ui.repositoryRefreshRequest;
+      ui.repositoryRefreshRequest = null;
+      result = await performRepositoryRefresh(request.withLoader, request.silent);
+    }
+    return result;
+  })();
+  try {
+    return await ui.repositoryRefreshPromise;
+  } finally {
+    ui.repositoryRefreshPromise = null;
+  }
+}
+
+async function performRepositoryRefresh(withLoader = true, silent = false) {
  if (withLoader) setLoading(true, "Refreshing Local → Gitea → Server state…");
  try {
    const selectedId = ui.selectedRepoId;
-    ui.repositories = await window.forgeflow.refreshRepositories();
+    ui.repositories = await window.forgeflow.refreshRepositories({ force: withLoader });
    ui.refreshError = null;
+    const staleRepository = ui.repositories.find(
+      (repository) => repository.remoteStale,
+    );
+    ui.refreshWarning = staleRepository
+      ? `Gitea could not be reached. Showing repository data last refreshed ${formatDate(staleRepository.remoteLastRefreshedAt)} while local and server state continue to refresh.`
+      : null;
    if (selectedId && !selectedRepository()) ui.selectedRepoId = null;
    const repository = selectedRepository();
    if (
@@ -459,6 +497,7 @@ async function refreshRepositories(withLoader = true, silent = false) {
      selectRepository(ui.repositories[0].id, false);
  } catch (error) {
    ui.refreshError = error.message;
+    ui.refreshWarning = null;
    if (!silent) showToast("Refresh failed", error.message, "error");
  } finally {
    if (withLoader) setLoading(false);
@@ -480,6 +519,25 @@ async function refreshActiveOperations(showErrors = true) {
 }

 async function refreshDeploymentTruth(showErrors = false) {
+  ui.deploymentTruthRequest = { showErrors: ui.deploymentTruthRequest?.showErrors === true || showErrors };
+  if (ui.deploymentTruthPromise) return ui.deploymentTruthPromise;
+  ui.deploymentTruthPromise = (async () => {
+    let result;
+    while (ui.deploymentTruthRequest) {
+      const request = ui.deploymentTruthRequest;
+      ui.deploymentTruthRequest = null;
+      result = await performDeploymentTruthRefresh(request.showErrors);
+    }
+    return result;
+  })();
+  try {
+    return await ui.deploymentTruthPromise;
+  } finally {
+    ui.deploymentTruthPromise = null;
+  }
+}
+
+async function performDeploymentTruthRefresh(showErrors = false) {
  let discovery = [];
  try {
    discovery = (await window.forgeflow.discoverServerDeployments?.()) || [];
@@ -508,8 +566,11 @@ async function refreshDeploymentTruth(showErrors = false) {
  );
  if (!targets.length) return { checked: 0, failed: 0, discovery };

+  const inventoryRefreshedProfiles = new Set(discovery.flatMap((server) => server.refreshedProfileIds || []));
+  const pendingTargets = targets.filter(({ profile }) => !inventoryRefreshedProfiles.has(profile.id));
+
  const failures = [];
-  const queue = [...targets];
+  const queue = [...pendingTargets];
  const workers = Array.from(
    { length: Math.min(3, queue.length) },
    async () => {
@@ -539,7 +600,7 @@ async function refreshDeploymentTruth(showErrors = false) {
      "error",
    );
  }
-  return { checked: targets.length, failed: failures.length, discovery };
+  return { checked: targets.length, reusedInventory: targets.length - pendingTargets.length, failed: failures.length, discovery };
 }

 function selectRepository(id, shouldRender = true) {
@@ -551,6 +612,7 @@ function selectRepository(id, shouldRender = true) {
  ui.branches = [];
  ui.stashes = [];
  ui.gitRecovery = null;
+  ui.workspaceSyncPlan = null;
  ui.gitValidation = null;
  ui.branchProtection = null;
  const repository = selectedRepository();
@@ -1,3 +1,25 @@
+// These three sections used to be pushed into the DOM after render() had already
+// written the shell. Keeping them in the markup makes the rendered output the
+// single source of truth, so an unchanged render can be skipped safely.
+function renderDeploymentPolicyFields(policy) {
+  const windows = (policy.maintenanceWindows || [])
+    .map((window) => `${window.days.join(",")}:${window.start}-${window.end}`)
+    .join(" | ");
+  return `<div class="field full"><h3>Deployment policy</h3></div><label class="check-field"><input id="profile-policy-frozen" type="checkbox" ${policy.frozen ? "checked" : ""}/><span>Freeze deployments</span></label><label class="check-field"><input id="profile-policy-note" type="checkbox" ${policy.requireNote ? "checked" : ""}/><span>Require release note</span></label><div class="field full"><label>Freeze reason</label><input id="profile-policy-freeze-reason" class="input" value="${attr(policy.freezeReason || "")}"/></div><div class="field full"><label>Maintenance windows</label><input id="profile-policy-windows" class="input" value="${attr(windows)}" placeholder="1,2,3,4,5:09:00-17:00"/><small>Day 0 is Sunday. Separate windows with |.</small></div>`;
+}
+
+function renderReleaseNoteFields(profile) {
+  return `<div class="form-grid" style="margin-top:14px"><div class="field full"><label>Release note ${profile?.deploymentPolicy?.requireNote ? "(required)" : "(optional)"}</label><textarea id="deployment-note" class="textarea" placeholder="What is being released and why?"></textarea></div><label class="check-field"><input id="deployment-override" type="checkbox"/><span>Emergency policy override</span></label><div class="field"><label>Override reason</label><input id="deployment-override-reason" class="input" placeholder="Required when overriding"/></div></div>`;
+}
+
+function renderWorkloadClassificationFields(workload) {
+  const type = workload?.classification?.type || "ambiguous";
+  const recommended = type === "duplicate" ? "select-authoritative" : type === "stale-link" ? "archive-link" : type === "historical-compose" ? "mark-historical" : type === "orphan-container" ? "monitor-only" : "manual-link";
+  const actions = [["manual-link", "Confirm selected repository match"], ["select-authoritative", "Select as authoritative instance"], ["mark-historical", "Mark historical definition"], ["archive-link", "Archive stale link"], ["monitor-only", "Keep for monitoring only"], ["manual-exclude", "Exclude this workload"], ["ignore", "Ignore with reason"]];
+  const options = actions.map(([value, label]) => `<option value="${value}" ${value === recommended ? "selected" : ""}>${escapeHtml(label)}${value === recommended ? " · recommended" : ""}</option>`).join("");
+  return `<section class="settings-group" style="margin-top:14px"><h3>Classify without touching containers</h3><div class="notice" style="margin-bottom:10px">${icon("info")}<div><strong>${escapeHtml(type)}</strong><p>${escapeHtml(workload?.classification?.reason || "ForgeFlow needs an explicit decision for this workload.")}</p></div></div><div class="form-grid"><div class="field"><label for="inventory-review-action">Review decision</label><select id="inventory-review-action" class="select">${options}</select></div><div class="field"><label for="inventory-review-reason">Reason</label><input id="inventory-review-reason" class="input" placeholder="Why is this the correct classification?"/></div></div><button class="button" style="margin-top:10px" data-action="preview-inventory-review" data-server-id="${attr(ui.modal.serverId)}" data-workload-id="${attr(ui.modal.workloadId)}">${icon("shield")}Preview classification impact</button><p class="meta">The decision is tied to current evidence and becomes stale automatically when server truth changes.</p></section>`;
+}
+
 function renderModal() {
  if (!ui.modal) return "";
  const repository =
@@ -22,6 +44,20 @@ function renderModal() {
    ];
    return `<div class="modal-backdrop" role="presentation"><section class="modal wide-modal" role="dialog" aria-modal="true" aria-labelledby="reconciliation-title"><header class="modal-header"><h2 id="reconciliation-title">Review server reconciliation</h2><button class="icon-button" data-action="close-modal" aria-label="Close reconciliation preview">${icon("close")}</button></header><div class="modal-body"><div class="notice success">${icon("shield")}This reviewed plan may update ForgeFlow configuration only. It never starts, stops or recreates containers, and stale profiles are never removed automatically.</div><div class="summary-grid" style="margin-top:12px"><div class="summary-card"><span>New links</span><strong>${Number(summary.additions || 0)}</strong></div><div class="summary-card"><span>Refreshes</span><strong>${Number(summary.updates || 0)}</strong></div><div class="summary-card"><span>Stale reviews</span><strong>${Number(summary.stale || 0)}</strong></div><div class="summary-card"><span>Conflicts</span><strong>${Number(summary.conflicts || 0)}</strong></div></div><div class="tool-list" style="margin-top:14px">${rows.length ? rows.map((item) => `<div class="tool-row"><div><strong>${escapeHtml(item.title)}</strong><span>${escapeHtml(item.detail)}</span></div>${item.tone ? `<span class="status-pill ${item.tone}">${escapeHtml(item.tone === "success" ? "Planned" : item.tone === "warning" ? "Review" : "Blocked")}</span>` : ""}</div>`).join("") : '<div class="empty-state compact"><p>No configuration changes are proposed.</p></div>'}</div><div class="notice" style="margin-top:12px">${icon("archive")}A private recovery snapshot is written before the plan is applied. Plan ID: <span class="mono">${escapeHtml(String(plan.id || "").slice(0, 12))}</span></div></div><footer class="modal-footer"><button class="button" data-action="close-modal">Cancel</button><button class="button primary" data-action="apply-server-reconciliation" data-server-id="${attr(plan.serverId || "")}" data-plan-id="${attr(plan.id || "")}" ${summary.conflicts ? "disabled title=\"Resolve ambiguous workloads manually before applying reconciliation\"" : ""}>Apply reviewed plan</button></footer></section></div>`;
  }
+  if (ui.modal.type === "workspace-sync") {
+    const plan = ui.workspaceSyncPlan;
+    if (!plan) return "";
+    const summary = plan.summary || {};
+    const blocked = Boolean(plan.blockers?.length);
+    const changeRows = (plan.changes || []).map((change) => `<div class="tool-row"><div><strong>${escapeHtml(change.path)}</strong><span>${change.originalPath ? `${escapeHtml(change.originalPath)} → ` : ""}${escapeHtml(change.status)}</span></div><span class="status-pill ${change.code === "D" ? "danger" : change.code === "A" ? "success" : "warning"}">${escapeHtml(change.code)}</span></div>`).join("");
+    const recoveryRows = [
+      plan.recovery?.safetyBranch ? "Local commits → recovery branch" : "No local commits require a recovery branch",
+      plan.recovery?.stash ? "Modified and untracked files → named Git stash" : "No working-tree files require a stash",
+      plan.recovery?.untrackedCleanup ? "Untracked files are removed after they are stashed" : "No untracked cleanup required",
+      "Ignored runtime files remain in place",
+    ];
+    return `<div class="modal-backdrop" role="presentation"><section class="modal wide-modal" role="dialog" aria-modal="true" aria-labelledby="workspace-sync-title"><header class="modal-header"><h2 id="workspace-sync-title">Review Gitea workspace sync</h2><button class="icon-button" data-action="close-modal" aria-label="Close workspace sync preview">${icon("close")}</button></header><div class="modal-body"><div class="confirm-hero ${blocked ? "danger" : plan.needsSync ? "" : "success"}">${icon(blocked ? "error" : "shield")}<div><strong>${blocked ? "Synchronization is blocked" : plan.needsSync ? `${escapeHtml(plan.branch)} will match ${escapeHtml(plan.upstream)}` : "Workspace already matches Gitea"}</strong><span>${shortSha(plan.currentSha)} → ${shortSha(plan.targetSha)} · reviewed plan ${escapeHtml(plan.id.slice(0, 12))}</span></div></div>${blocked ? `<div class="notice danger" style="margin-top:12px">${icon("error")}<div><strong>Resolve before applying</strong><p>${escapeHtml(plan.blockers.join(" "))}</p></div></div>` : ""}<div class="summary-grid" style="margin-top:12px"><div class="summary-card"><span>Incoming commits</span><strong>${Number(summary.incomingCommits || 0)}</strong></div><div class="summary-card"><span>Tracked file changes</span><strong>${Number(summary.resultingTrackedChanges || 0)}</strong></div><div class="summary-card"><span>Files removed by sync</span><strong>${Number(summary.deleted || 0)}</strong></div><div class="summary-card"><span>Local files protected</span><strong>${Number(summary.localFilesToStash || 0)}</strong></div><div class="summary-card"><span>Local commits protected</span><strong>${Number(summary.localCommitsToProtect || 0)}</strong></div></div><section class="settings-group" style="margin-top:14px"><h3>Recovery contract</h3><ul>${recoveryRows.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}</ul><div class="notice success">${icon("archive")}ForgeFlow never reapplies saved local work automatically. You can review the recovery branch or stash later, file by file.</div></section><section class="settings-group"><div class="section-heading"><div><h3>Resulting tracked changes</h3><span class="meta">${summary.added || 0} added · ${summary.modified || 0} modified · ${summary.deleted || 0} deleted · ${summary.renamed || 0} renamed</span></div></div><div class="tool-list">${changeRows || '<div class="empty-state compact"><p>No tracked file changes between local HEAD and Gitea.</p></div>'}</div>${plan.changesTruncated ? '<p class="meta">Only the first 250 paths are shown. Counts include the complete plan.</p>' : ""}</section></div><footer class="modal-footer"><button class="button" data-action="close-modal">Cancel</button><button class="button primary" data-action="confirm-workspace-sync" data-plan-id="${attr(plan.id)}" ${blocked || !plan.needsSync ? "disabled" : ""}>Protect local work & synchronize</button></footer></section></div>`;
+  }
  if (ui.modal.type === "workload-link") {
    const serverResult = (ui.serverDiscovery || []).find(
      (item) => item.serverId === ui.modal.serverId,
@@ -59,7 +95,7 @@ function renderModal() {
      .map((container) => container.name)
      .filter(Boolean)
      .join(", ");
-    return `<div class="modal-backdrop" role="presentation"><section class="modal wide-modal" role="dialog" aria-modal="true"><header class="modal-header"><h2>Link existing server workload</h2><button class="icon-button" data-action="close-modal">${icon("close")}</button></header><div class="modal-body"><div class="confirm-hero">${icon("link")}<div><strong>${escapeHtml(workload.displayName)}</strong><span>${escapeHtml(serverResult?.serverName || serverResult?.server?.name || ui.modal.serverId)} · ${workload.runtime?.running ? "running" : "stopped"}</span></div></div><div class="context-summary"><div class="context-row"><span>Containers</span><strong>${escapeHtml(containerNames || "Unknown")}</strong></div><div class="context-row"><span>Compose identity</span><strong>${escapeHtml(workload.compose?.project || "DockerMan / standalone container")} ${workload.compose?.services?.length ? `· ${escapeHtml(workload.compose.services.join(", "))}` : ""}</strong></div><div class="context-row"><span>Detected folder</span><strong class="mono">${escapeHtml(workload.compose?.workingDir || workload.dockerMan?.templatePath || "No Git checkout required")}</strong></div>${candidateSummary}</div><div class="form-grid" style="margin-top:14px"><div class="field full"><label>Repository to link</label><select id="workload-repository" class="select">${availableRepositories.map((item) => `<option value="${attr(item.fullName)}" ${item.fullName === suggestedRepository ? "selected" : ""}>${escapeHtml(item.fullName)}</option>`).join("") || '<option value="">No repositories available</option>'}</select></div><div class="field"><label>Deployment source</label><select id="workload-deployment-mode" class="select"><option value="server-git" selected>Server pull from Gitea</option><option value="push-bundle">Direct copy fallback</option><option value="monitor-only">Monitor only</option></select></div><div class="field"><label>Detected deployment folder</label><input id="workload-remote-folder" class="input" value="${attr(remoteFolder)}" readonly/></div></div><div class="notice success" style="margin-top:12px">${icon("shield")}ForgeFlow preserves the detected Compose project, services and container identity. Server pull provisions a repository-scoped read-only key and activates only the selected Gitea commit.</div></div><footer class="modal-footer"><button class="button" data-action="close-modal">Cancel</button><button class="button primary" data-action="confirm-link-server-workload" data-server-id="${attr(ui.modal.serverId)}" data-workload-id="${attr(ui.modal.workloadId)}" ${availableRepositories.length ? "" : "disabled"}>Link workload</button></footer></section></div>`;
+    return `<div class="modal-backdrop" role="presentation"><section class="modal wide-modal" role="dialog" aria-modal="true"><header class="modal-header"><h2>Link existing server workload</h2><button class="icon-button" data-action="close-modal">${icon("close")}</button></header><div class="modal-body"><div class="confirm-hero">${icon("link")}<div><strong>${escapeHtml(workload.displayName)}</strong><span>${escapeHtml(serverResult?.serverName || serverResult?.server?.name || ui.modal.serverId)} · ${workload.runtime?.running ? "running" : "stopped"}</span></div></div><div class="context-summary"><div class="context-row"><span>Containers</span><strong>${escapeHtml(containerNames || "Unknown")}</strong></div><div class="context-row"><span>Compose identity</span><strong>${escapeHtml(workload.compose?.project || "DockerMan / standalone container")} ${workload.compose?.services?.length ? `· ${escapeHtml(workload.compose.services.join(", "))}` : ""}</strong></div><div class="context-row"><span>Detected folder</span><strong class="mono">${escapeHtml(workload.compose?.workingDir || workload.dockerMan?.templatePath || "No Git checkout required")}</strong></div>${candidateSummary}</div><div class="form-grid" style="margin-top:14px"><div class="field full"><label>Repository to link</label><select id="workload-repository" class="select">${availableRepositories.map((item) => `<option value="${attr(item.fullName)}" ${item.fullName === suggestedRepository ? "selected" : ""}>${escapeHtml(item.fullName)}</option>`).join("") || '<option value="">No repositories available</option>'}</select></div><div class="field"><label>Deployment source</label><select id="workload-deployment-mode" class="select"><option value="server-git" selected>Server pull from Gitea</option><option value="push-bundle">Direct copy fallback</option><option value="monitor-only">Monitor only</option></select></div><div class="field"><label>Detected deployment folder</label><input id="workload-remote-folder" class="input" value="${attr(remoteFolder)}" readonly/></div></div><div class="notice success" style="margin-top:12px">${icon("shield")}ForgeFlow preserves the detected Compose project, services and container identity. Server pull provisions a repository-scoped read-only key and activates only the selected Gitea commit.</div>${renderWorkloadClassificationFields(workload)}</div><footer class="modal-footer"><button class="button" data-action="close-modal">Cancel</button><button class="button primary" data-action="confirm-link-server-workload" data-server-id="${attr(ui.modal.serverId)}" data-workload-id="${attr(ui.modal.workloadId)}" ${availableRepositories.length ? "" : "disabled"}>Link workload</button></footer></section></div>`;
  }
  if (ui.modal.type === "deployment-config") {
    const storedProfile =
@@ -106,7 +142,7 @@ function renderModal() {
      <div class="field full"><label>Rollback workflow file (optional)</label><input id="profile-rollback-workflow" class="input" value="${attr(existing.rollbackWorkflowFile || "")}" placeholder="rollback.yml" /></div>
      <div class="field full"><label>Application status URL</label><input id="profile-status-url" class="input" value="${attr(existing.statusUrl || "")}" required placeholder="https://app.example.com/.well-known/forgeflow" /></div>
      <div class="field full"><label>Healthcheck URL (optional)</label><input id="profile-healthcheck" class="input" value="${attr(existing.healthcheckUrl || "")}" placeholder="https://app.example.com/health" /></div>`
-    }<label class="check-field full"><input id="profile-confirmation" type="checkbox" ${existing.confirmationRequired !== false ? "checked" : ""}/><span>Require an explicit confirmation before deployment</span></label></div><div class="notice" style="margin-top:13px">${icon("shield")}${ssh ? "Server pull fetches the exact selected Gitea commit with a repository-scoped read-only key, validates Compose and services, then promotes atomically with rollback protection." : "ForgeFlow sends only controlled workflow inputs: environment, exact SHA and a unique request ID."}</div></div><footer class="modal-footer">${existing.id ? `<button class="button danger" data-action="delete-deployment-profile" data-profile-id="${attr(existing.id)}">Delete</button>` : ""}<span class="modal-spacer"></span><button class="button" data-action="close-modal">Cancel</button><button class="button primary" data-action="save-deployment-profile" data-profile-id="${attr(existing.id || "")}" ${ssh && !servers.length ? "disabled" : ""}>Save environment</button></footer></section></div>`;
+    }<label class="check-field full"><input id="profile-confirmation" type="checkbox" ${existing.confirmationRequired !== false ? "checked" : ""}/><span>Require an explicit confirmation before deployment</span></label>${renderDeploymentPolicyFields(storedProfile.deploymentPolicy || {})}</div><div class="notice" style="margin-top:13px">${icon("shield")}${ssh ? "Server pull fetches the exact selected Gitea commit with a repository-scoped read-only key, validates Compose and services, then promotes atomically with rollback protection." : "ForgeFlow sends only controlled workflow inputs: environment, exact SHA and a unique request ID."}</div></div><footer class="modal-footer">${existing.id ? `<button class="button danger" data-action="delete-deployment-profile" data-profile-id="${attr(existing.id)}">Delete</button>` : ""}<span class="modal-spacer"></span><button class="button" data-action="close-modal">Cancel</button><button class="button primary" data-action="save-deployment-profile" data-profile-id="${attr(existing.id || "")}" ${ssh && !servers.length ? "disabled" : ""}>Save environment</button></footer></section></div>`;
  }
  if (ui.modal.type === "inventory-review-plan") {
    const plan = ui.inventoryReviewPlan;
@@ -133,7 +169,7 @@ function renderModal() {
        (item) => item.id === ui.modal.profileId,
      ) || selectedProfile(repository);
    const targetSha = deploymentTargetSha(repository, profile);
-    return `<div class="modal-backdrop" role="presentation"><section class="modal" role="dialog" aria-modal="true"><header class="modal-header"><h2>Confirm production action</h2><button class="icon-button" data-action="close-modal">${icon("close")}</button></header><div class="modal-body"><div class="confirm-hero">${icon("rocket")}<div><strong>Deploy ${escapeHtml(shortSha(targetSha))} → ${escapeHtml(profile.environment)}</strong><span>${escapeHtml(repository.fullName)}</span></div></div><div class="confirm-grid"><span>Exact commit</span><strong class="mono">${escapeHtml(targetSha || "Unavailable")}</strong><span>Branch</span><strong>${escapeHtml(profile.branch)}</strong><span>Provider</span><strong>${profile.provider === "ssh-unraid" ? `${deploymentMode(profile) === "server-git" ? "Gitea → Unraid" : "Desktop → Unraid"} · ${escapeHtml(profile.remoteFolder)}` : escapeHtml(profile.workflowFile)}</strong><span>Healthcheck</span><strong>${escapeHtml(profile.healthcheckUrl || "Not configured")}</strong></div>${ui.deploymentPreflight ? `<div class="notice success" style="margin-top:12px">${icon("shield")}Preflight passed with ${ui.deploymentPreflight.summary.counts.warning} warning(s). Backend safety checks run again at dispatch time.</div>` : ""}</div><footer class="modal-footer"><button class="button" data-action="close-modal">Cancel</button><button class="button success" data-action="confirm-deploy" data-profile-id="${attr(profile.id)}" ${targetSha ? "" : "disabled"}>Deploy exact commit</button></footer></section></div>`;
+    return `<div class="modal-backdrop" role="presentation"><section class="modal" role="dialog" aria-modal="true"><header class="modal-header"><h2>Confirm production action</h2><button class="icon-button" data-action="close-modal">${icon("close")}</button></header><div class="modal-body"><div class="confirm-hero">${icon("rocket")}<div><strong>Deploy ${escapeHtml(shortSha(targetSha))} → ${escapeHtml(profile.environment)}</strong><span>${escapeHtml(repository.fullName)}</span></div></div><div class="confirm-grid"><span>Exact commit</span><strong class="mono">${escapeHtml(targetSha || "Unavailable")}</strong><span>Branch</span><strong>${escapeHtml(profile.branch)}</strong><span>Provider</span><strong>${profile.provider === "ssh-unraid" ? `${deploymentMode(profile) === "server-git" ? "Gitea → Unraid" : "Desktop → Unraid"} · ${escapeHtml(profile.remoteFolder)}` : escapeHtml(profile.workflowFile)}</strong><span>Healthcheck</span><strong>${escapeHtml(profile.healthcheckUrl || "Not configured")}</strong></div>${ui.deploymentPreflight ? `<div class="notice success" style="margin-top:12px">${icon("shield")}Preflight passed with ${ui.deploymentPreflight.summary.counts.warning} warning(s). Backend safety checks run again at dispatch time.</div>` : ""}${renderReleaseNoteFields(profile)}</div><footer class="modal-footer"><button class="button" data-action="close-modal">Cancel</button><button class="button success" data-action="confirm-deploy" data-profile-id="${attr(profile.id)}" ${targetSha ? "" : "disabled"}>Deploy exact commit</button></footer></section></div>`;
  }
  if (ui.modal.type === "rollback-confirm") {
    const profile = repository?.deploymentProfiles?.find(
@@ -239,46 +275,6 @@ function renderCommandPalette() {
 }

 function enhanceRenderedUi() {
-  const repository = selectedRepository();
-  if (ui.modal?.type === "deployment-config") {
-    const profile =
-      repository?.deploymentProfiles?.find(
-        (item) => item.id === ui.modal.profileId,
-      ) || {};
-    const policy = profile.deploymentPolicy || {};
-    document
-      .querySelector(".modal-body .form-grid")
-      ?.insertAdjacentHTML(
-        "beforeend",
-        `<div class="field full"><h3>Deployment policy</h3></div><label class="check-field"><input id="profile-policy-frozen" type="checkbox" ${policy.frozen ? "checked" : ""}/><span>Freeze deployments</span></label><label class="check-field"><input id="profile-policy-note" type="checkbox" ${policy.requireNote ? "checked" : ""}/><span>Require release note</span></label><div class="field full"><label>Freeze reason</label><input id="profile-policy-freeze-reason" class="input" value="${attr(policy.freezeReason || "")}"/></div><div class="field full"><label>Maintenance windows</label><input id="profile-policy-windows" class="input" value="${attr((policy.maintenanceWindows || []).map((window) => `${window.days.join(",")}:${window.start}-${window.end}`).join(" | "))}" placeholder="1,2,3,4,5:09:00-17:00"/><small>Day 0 is Sunday. Separate windows with |.</small></div>`,
-      );
-  }
-  if (ui.modal?.type === "workload-link") {
-    const workload = (ui.serverDiscovery || []).find((server) => server.serverId === ui.modal.serverId)?.workloads?.find((item) => item.workloadId === ui.modal.workloadId);
-    const type = workload?.classification?.type || "ambiguous";
-    const recommended = type === "duplicate" ? "select-authoritative" : type === "stale-link" ? "archive-link" : type === "historical-compose" ? "mark-historical" : type === "orphan-container" ? "monitor-only" : "manual-link";
-    const actions = [["manual-link", "Confirm selected repository match"], ["select-authoritative", "Select as authoritative instance"], ["mark-historical", "Mark historical definition"], ["archive-link", "Archive stale link"], ["monitor-only", "Keep for monitoring only"], ["manual-exclude", "Exclude this workload"], ["ignore", "Ignore with reason"]];
-    const options = actions.map(([value, label]) => `<option value="${value}" ${value === recommended ? "selected" : ""}>${escapeHtml(label)}${value === recommended ? " · recommended" : ""}</option>`).join("");
-    document.querySelector(".modal-body")?.insertAdjacentHTML("beforeend", `<section class="settings-group" style="margin-top:14px"><h3>Classify without touching containers</h3><div class="notice" style="margin-bottom:10px">${icon("info")}<div><strong>${escapeHtml(type)}</strong><p>${escapeHtml(workload?.classification?.reason || "ForgeFlow needs an explicit decision for this workload.")}</p></div></div><div class="form-grid"><div class="field"><label for="inventory-review-action">Review decision</label><select id="inventory-review-action" class="select">${options}</select></div><div class="field"><label for="inventory-review-reason">Reason</label><input id="inventory-review-reason" class="input" placeholder="Why is this the correct classification?"/></div></div><button class="button" style="margin-top:10px" data-action="preview-inventory-review" data-server-id="${attr(ui.modal.serverId)}" data-workload-id="${attr(ui.modal.workloadId)}">${icon("shield")}Preview classification impact</button><p class="meta">The decision is tied to current evidence and becomes stale automatically when server truth changes.</p></section>`);
-  }
-  if (ui.modal?.type === "deploy-confirm") {
-    const profile = repository?.deploymentProfiles?.find(
-      (item) => item.id === ui.modal.profileId,
-    );
-    document
-      .querySelector(".modal-body")
-      ?.insertAdjacentHTML(
-        "beforeend",
-        `<div class="form-grid" style="margin-top:14px"><div class="field full"><label>Release note ${profile?.deploymentPolicy?.requireNote ? "(required)" : "(optional)"}</label><textarea id="deployment-note" class="textarea" placeholder="What is being released and why?"></textarea></div><label class="check-field"><input id="deployment-override" type="checkbox"/><span>Emergency policy override</span></label><div class="field"><label>Override reason</label><input id="deployment-override-reason" class="input" placeholder="Required when overriding"/></div></div>`,
-      );
-  }
-  if (ui.currentView === "diagnostics") {
-    const container = document.querySelector(".diagnostics-page");
-    container?.insertAdjacentHTML(
-      "beforeend",
-      `<section class="section-block"><div class="section-heading"><div><h2>Operational audit log</h2><span class="meta">Append-only release, pull-request and recovery events</span></div><div class="stack horizontal compact"><button class="button" data-action="load-audit-log">Refresh</button><button class="button" data-action="export-audit-json">Export JSON</button><button class="button" data-action="export-audit-csv">Export CSV</button></div></div><div class="panel">${ui.auditEvents.length ? `<table class="data-table"><thead><tr><th>Time</th><th>Event</th><th>Repository</th><th>Result</th></tr></thead><tbody>${ui.auditEvents.map((item) => `<tr><td>${formatDate(item.timestamp)}</td><td>${escapeHtml(item.event)}</td><td>${escapeHtml(item.details?.repository || "—")}</td><td>${escapeHtml(item.details?.result || item.details?.note || "—")}</td></tr>`).join("")}</tbody></table>` : '<div class="empty-state compact"><p>Load the operational audit log.</p></div>'}</div></section>`,
-    );
-  }
  document.querySelectorAll("button.icon-button:not([aria-label])").forEach((button) => {
    const action = String(button.title || button.dataset.action || "Action").replaceAll("-", " ");
    button.setAttribute("aria-label", action.charAt(0).toUpperCase() + action.slice(1));
@@ -296,6 +292,110 @@ function enhanceRenderedUi() {
  });
 }

+// A render replaces the complete application shell. Without this, a background
+// repository poll or deployment poll destroys the element the user is typing in,
+// discarding the caret position and every scroll offset on screen.
+function elementRenderPath(element) {
+  const parts = [];
+  let node = element;
+  while (node && node !== app) {
+    const parent = node.parentElement;
+    if (!parent) return null;
+    parts.push(`${node.tagName}.${Array.prototype.indexOf.call(parent.children, node)}`);
+    node = parent;
+  }
+  return node === app ? parts.reverse().join(">") : null;
+}
+
+function elementAtRenderPath(renderPath) {
+  let node = app;
+  for (const part of renderPath.split(">")) {
+    const separator = part.lastIndexOf(".");
+    node = node?.children?.[Number(part.slice(separator + 1))];
+    // The shell can be structurally different after a view change, in which case
+    // the old offset belongs to an unrelated element and must be dropped.
+    if (!node || node.tagName !== part.slice(0, separator)) return null;
+  }
+  return node;
+}
+
+// enhanceRenderedUi() re-injects these controls empty on every render, so a
+// background refresh would otherwise discard a release note or review reason
+// while the user is still writing it.
+const INJECTED_FIELD_IDS = [
+  "deployment-note",
+  "deployment-override",
+  "deployment-override-reason",
+  "inventory-review-action",
+  "inventory-review-reason",
+  "profile-policy-frozen",
+  "profile-policy-note",
+  "profile-policy-freeze-reason",
+  "profile-policy-windows",
+];
+
+function captureInjectedFieldValues() {
+  const values = [];
+  for (const id of INJECTED_FIELD_IDS) {
+    const element = document.getElementById(id);
+    if (!element) continue;
+    if (element.type === "checkbox") values.push({ id, checked: element.checked });
+    else if (element.value) values.push({ id, value: element.value });
+  }
+  return values;
+}
+
+function restoreInjectedFieldValues(values) {
+  for (const entry of values) {
+    const element = document.getElementById(entry.id);
+    if (!element) continue;
+    // Never overwrite a value the freshly rendered control already carries; only
+    // fill back in what the injection left empty.
+    if ("checked" in entry) {
+      if (!element.checked) element.checked = entry.checked;
+    } else if (!element.value) element.value = entry.value;
+  }
+}
+
+function captureInteractionState() {
+  const scroll = [];
+  for (const element of app.querySelectorAll("*")) {
+    if (!element.scrollTop && !element.scrollLeft) continue;
+    const renderPath = elementRenderPath(element);
+    if (renderPath) scroll.push({ renderPath, top: element.scrollTop, left: element.scrollLeft });
+  }
+  const injectedFields = captureInjectedFieldValues();
+  const active = document.activeElement;
+  if (!active?.id || !app.contains(active)) return { scroll, injectedFields, focus: null };
+  const focus = { id: active.id, start: null, end: null, direction: "none" };
+  try {
+    focus.start = active.selectionStart;
+    focus.end = active.selectionEnd;
+    focus.direction = active.selectionDirection || "none";
+  } catch {}
+  return { scroll, injectedFields, focus };
+}
+
+function restoreInteractionState(state) {
+  restoreInjectedFieldValues(state.injectedFields);
+  for (const entry of state.scroll) {
+    const element = elementAtRenderPath(entry.renderPath);
+    if (!element) continue;
+    element.scrollTop = entry.top;
+    element.scrollLeft = entry.left;
+  }
+  if (!state.focus) return;
+  const element = document.getElementById(state.focus.id);
+  if (!element || !app.contains(element)) return;
+  element.focus({ preventScroll: true });
+  if (state.focus.start === null) return;
+  try {
+    element.setSelectionRange(state.focus.start, state.focus.end, state.focus.direction);
+  } catch {}
+}
+
+let lastRenderedMarkup = null;
+
 function render() {
  if (!ui.boot) return;
  const repository = selectedRepository();
@@ -304,6 +404,8 @@ function render() {
      ? renderOverview()
      : ui.currentView === "deployments"
        ? renderDeployments()
+        : ui.currentView === "help"
+          ? renderHelp()
        : ui.currentView === "settings"
          ? renderSettings()
          : ui.currentView === "diagnostics"
@@ -314,8 +416,17 @@ function render() {
                ? renderRepositoryWorkspace(repository)
                : renderOverview();
  const withPanel = ui.currentView === "repository" && repository;
-  app.innerHTML = `<div class="app-shell">${renderTitlebar()}<div class="app-body">${renderSidebar()}<main class="workspace ${withPanel ? "with-panel" : ""}"><section class="main-canvas ${withPanel ? "repository-canvas" : ""}">${main}</section>${withPanel ? renderActionPanel(repository) : ""}${ui.loading ? `<div class="loading-overlay"><div class="boot-screen"><div class="spinner"></div><strong>${escapeHtml(ui.loadingMessage || "Working…")}</strong></div></div>` : ""}</main></div>${renderStatusbar()}</div>${ui.boot.state.setupComplete ? "" : renderSetup()}${renderModal()}`;
+  const markup = `<div class="app-shell">${renderTitlebar()}<div class="app-body">${renderSidebar()}<main class="workspace ${withPanel ? "with-panel" : ""}"><section class="main-canvas ${withPanel ? "repository-canvas" : ""}">${main}</section>${withPanel ? renderActionPanel(repository) : ""}${ui.loading ? `<div class="loading-overlay"><div class="boot-screen"><div class="spinner"></div><strong>${escapeHtml(ui.loadingMessage || "Working…")}</strong></div></div>` : ""}</main></div>${renderStatusbar()}</div>${ui.boot.state.setupComplete ? "" : renderSetup()}${renderModal()}`;
+  // Most renders are triggered by a poll that found nothing new. Rebuilding an
+  // identical shell would only cost layout work and interrupt the user. The
+  // markup is the complete rendered state, so comparing it is sufficient:
+  // enhanceRenderedUi() only derives labels and ids from what is already there.
+  if (markup === lastRenderedMarkup) return;
+  const interaction = captureInteractionState();
+  app.innerHTML = markup;
  enhanceRenderedUi();
+  restoreInteractionState(interaction);
+  lastRenderedMarkup = markup;
  if (ui.modal?.type === "command-palette")
    requestAnimationFrame(() =>
      document.querySelector("#palette-input")?.focus(),
@@ -0,0 +1,40 @@
+// Rendering a unified diff is a self-contained concern with its own size
+// limits, kept out of views.js so that file stays within the project's
+// architecture budget.
+// A regenerated lock file runs into tens of thousands of lines, and one element
+// per line freezes the window. Only the rendered view is capped.
+const DIFF_RENDER_LINE_LIMIT = 2000;
+
+function diffAtmosphere(diff, allLines = null) {
+  if (!ui.selectedFile) return "";
+  const lines = allLines || String(diff || "").split("\n");
+  const additions = lines.filter(
+    (line) => line.startsWith("+") && !line.startsWith("+++"),
+  ).length;
+  const removals = lines.filter(
+    (line) => line.startsWith("-") && !line.startsWith("---"),
+  ).length;
+  const extension =
+    String(ui.selectedFile).split(".").pop()?.slice(0, 8).toUpperCase() ||
+    "FILE";
+  return `<div class="diff-atmosphere ${lines.length > 34 ? "dense" : ""}" data-diff-atmosphere aria-hidden="true"><svg viewBox="0 0 360 260" role="presentation"><path class="code-route route-a" d="M38 195 C92 84 178 214 318 74"/><path class="code-route route-b" d="M52 74 C132 8 230 34 310 156"/><g class="code-card"><rect x="110" y="75" width="142" height="106" rx="18"/><path d="M136 108h90M136 128h58M136 148h76"/></g><g class="code-node node-one"><circle cx="48" cy="190" r="15"/><path d="m41 190 5 5 9-12"/></g><g class="code-node node-two"><circle cx="315" cy="76" r="13"/><path d="M308 76h14M315 69v14"/></g><circle class="code-packet packet-one" cx="0" cy="0" r="5"/><circle class="code-packet packet-two" cx="0" cy="0" r="4"/></svg><div class="diff-atmosphere-caption"><span>${escapeHtml(extension)} change map</span><strong><i>+${additions}</i><i>−${removals}</i></strong></div></div>`;
+}
+
+function diffLineType(line) {
+  if (line.startsWith("+") && !line.startsWith("+++")) return "add";
+  if (line.startsWith("-") && !line.startsWith("---")) return "remove";
+  return line.startsWith("@@") ? "hunk" : "";
+}
+
+function renderDiff(diff) {
+  if (!diff)
+    return '<div class="empty-state"><div class="empty-icon">↔</div><h3>No textual diff</h3><p>Select another file or open the project folder for binary changes.</p></div>';
+  const lines = String(diff).split("\n");
+  const rendered = lines
+    .slice(0, DIFF_RENDER_LINE_LIMIT)
+    .map((line) => `<span class="diff-line ${diffLineType(line)}">${escapeHtml(line) || " "}</span>`)
+    .join("");
+  const hidden = Math.max(0, lines.length - DIFF_RENDER_LINE_LIMIT);
+  const notice = hidden ? `<span class="diff-line hunk">… ${hidden.toLocaleString()} more line${hidden === 1 ? "" : "s"} are not shown. Copy diff and the editor still give you the complete change.</span>` : "";
+  return `${rendered}${notice}${diffAtmosphere(diff, lines)}`;
+}
@@ -51,6 +51,9 @@ app.addEventListener("input", (event) => {
  else if (event.target.id === "palette-input") {
    ui.paletteQuery = event.target.value;
    scheduleInputRender(60);
+  } else if (event.target.id === "help-search") {
+    ui.helpQuery = event.target.value;
+    scheduleInputRender(60);
  }
 });

@@ -94,6 +97,11 @@ document.addEventListener("keydown", (event) => {
    render();
    return;
  }
+  if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "f" && ui.currentView === "help") {
+    event.preventDefault();
+    document.querySelector("#help-search")?.focus();
+    return;
+  }
  if (
    (event.ctrlKey || event.metaKey) &&
    event.key === "Enter" &&
@@ -9,7 +9,7 @@
  <link rel="stylesheet" href="styles.css" />
 </head>
 <body>
-  <div id="app" aria-live="polite">
+  <div id="app">
    <div class="boot-screen">
      <img class="boot-brand-logo" src="./assets/itworx-mark.png" alt="ITWorx.tech"/>
      <strong>Starting ForgeFlow</strong>
@@ -17,10 +17,11 @@
    </div>
  </div>
  <div id="toast-root" class="toast-root" aria-live="assertive"></div>
-  <script src="mock-repository-bridge.js"></script>
-  <script src="mock-deployment-bridge.js"></script>
-  <script src="mock-bridge.js"></script>
+  <script defer src="mock-repository-bridge.js"></script>
+  <script defer src="mock-deployment-bridge.js"></script>
+  <script defer src="mock-bridge.js"></script>
  <script defer src="app.js"></script>
+  <script defer src="diff-view.js"></script>
  <script defer src="views.js"></script>
  <script defer src="dialogs.js"></script>
  <script defer src="operations.js"></script>
@@ -176,7 +176,7 @@
        username: "root",
        authType: "privateKey",
        basePath: "/mnt/user/appdata",
-        privateKeyPath: "C:\\Users\\Jens\\.ssh\\id_ed25519",
+        privateKeyPath: "C:\\Users\\your-name\\.ssh\\id_ed25519",
        hostFingerprint: "SHA256:demo",
        hasPassword: false,
        hasPassphrase: false,
@@ -238,13 +238,15 @@ function createMockDeploymentBridge(context) {
        {
          serverId: "server-unraid",
          serverName: "Unraid",
-          detected: 2,
+          detected: 3,
          adopted: 0,
          verified: 1,
-          linked: 1,
+          refreshedProfiles: 1,
+          refreshedProfileIds: ["profile-portfolio"],
+          linked: 2,
          unmatched: 0,
-          needsReview: 1,
-          running: 2,
+          needsReview: 2,
+          running: 3,
          stopped: 0,
          capabilities: {
            docker: true,
@@ -296,6 +298,19 @@ function createMockDeploymentBridge(context) {
                reasons: ["container and repository names are similar"],
              })),
            },
+            {
+              workloadId: "workload-demo-unresolved",
+              displayName: "Legacy Worker",
+              status: "linked",
+              runtime: { running: true, health: "healthy" },
+              containers: [{ name: "legacy-worker", running: true }],
+              candidates: [],
+              link: {
+                profileId: "profile-that-no-longer-exists",
+                repositoryFullName: "jens/removed-repository",
+                source: "manual",
+              },
+            },
          ],
        },
      ];
@@ -650,7 +665,7 @@ function createMockDeploymentBridge(context) {
    async exportDiagnostics(privacyMode = "standard") {
      await wait(500);
      return {
-        path: `C:\Users\Jens\Downloads\ForgeFlow-Diagnostics-demo.zip`,
+        path: `C:\Users\your-name\Downloads\ForgeFlow-Diagnostics-demo.zip`,
        bytes: 38221,
        size: "37.3 KB",
        sha256: "b".repeat(64),
@@ -5,7 +5,7 @@ function createMockRepositoryBridge(context) {
      await wait(80);
      snapshot();
      return {
-        appVersion: "0.10.3-demo",
+        appVersion: "0.10.15-demo",
        platform: "win32",
        state: clone(state),
        git: { available: true, version: "git version 2.47.3" },
@@ -29,7 +29,7 @@ function createMockRepositoryBridge(context) {
    },
    async selectKeyFile() {
      await wait();
-      return "C:\\Users\\Jens\\.ssh\\id_ed25519";
+      return "C:\\Users\\your-name\\.ssh\\id_ed25519";
    },
    async setupPreflight({ baseUrl, token, roots = [] }) {
      await wait(240);
@@ -427,6 +427,71 @@ function createMockRepositoryBridge(context) {
      emitRepositories();
      return { output: "Fast-forwarded.", status: clone(repo.localStatus) };
    },
+    async previewWorkspaceSync(localPath) {
+      await wait(260);
+      const repo = findRepo(localPath);
+      const status = repo.localStatus;
+      const targetSha = status.branch.behind ? "f".repeat(40) : status.head;
+      return {
+        id: `demo-${String(status.head).slice(0, 7)}-${status.branch.ahead}-${status.branch.behind}`.padEnd(64, "0").slice(0, 64),
+        branch: status.branch.head,
+        upstream: status.branch.upstream || `origin/${status.branch.head}`,
+        currentSha: status.head,
+        targetSha,
+        needsSync: !status.clean || status.head !== targetSha || status.branch.ahead > 0,
+        blockers: [],
+        summary: {
+          resultingTrackedChanges: status.branch.behind ? 3 : 0,
+          added: status.branch.behind ? 1 : 0,
+          modified: status.branch.behind ? 1 : 0,
+          deleted: status.branch.behind ? 1 : 0,
+          renamed: 0,
+          localFilesToStash: status.counts.changed,
+          untrackedFilesToStash: status.counts.untracked,
+          localCommitsToProtect: status.branch.ahead,
+          incomingCommits: status.branch.behind,
+        },
+        changes: status.branch.behind
+          ? [
+              { code: "A", status: "added", path: "src/remote-feature.js" },
+              { code: "M", status: "modified", path: "README.md" },
+              { code: "D", status: "deleted", path: "docs/obsolete.md" },
+            ]
+          : [],
+        localFiles: clone(status.files),
+        incomingCommits: [],
+        localCommits: [],
+        recovery: {
+          safetyBranch: status.branch.ahead > 0,
+          stash: status.counts.changed > 0,
+          untrackedCleanup: status.counts.untracked > 0,
+          ignoredFilesPreserved: true,
+        },
+      };
+    },
+    async applyWorkspaceSync(localPath, expectedPlanId) {
+      const plan = await this.previewWorkspaceSync(localPath);
+      if (plan.id !== expectedPlanId) throw new Error("The workspace sync preview is stale.");
+      const repo = findRepo(localPath);
+      const hadChanges = repo.localStatus.counts.changed > 0;
+      repo.localStatus.head = plan.targetSha;
+      repo.localStatus.shortHead = plan.targetSha.slice(0, 7);
+      repo.localStatus.files = [];
+      repo.localStatus.branch.ahead = 0;
+      repo.localStatus.branch.behind = 0;
+      recompute(repo);
+      emitRepositories();
+      return {
+        applied: plan.needsSync,
+        unchanged: !plan.needsSync,
+        plan,
+        status: clone(repo.localStatus),
+        backupBranch: plan.summary.localCommitsToProtect ? `forgeflow/recovery-${plan.branch}-demo` : null,
+        stash: hadChanges ? { ref: "stash@{0}", shortSha: "demo123", subject: "ForgeFlow workspace sync" } : null,
+        ignoredFilesPreserved: true,
+        cleaned: [],
+      };
+    },
    async history() {
      await wait(100);
      return clone(commitHistory);
@@ -556,6 +621,85 @@ function createMockRepositoryBridge(context) {
        stashes: clone(list),
      };
    },
+    async gitRecoveryStatus(localPath) {
+      const repo = findRepo(localPath);
+      const status = clone(repo.localStatus);
+      const upstream = status.branch?.upstream;
+      const recommendations = [
+        {
+          id: "fetch",
+          label: "Fetch and recalculate remote state",
+          action: "fetch",
+          safe: true,
+        },
+      ];
+      if (
+        status.clean &&
+        status.branch.behind > 0 &&
+        status.branch.ahead === 0 &&
+        upstream
+      ) {
+        recommendations.push({
+          id: "pull",
+          label: `Fast-forward from ${upstream}`,
+          action: "fast-forward",
+          safe: true,
+        });
+      }
+      if (
+        status.branch.ahead > 0 &&
+        status.branch.behind === 0 &&
+        upstream
+      ) {
+        recommendations.push({
+          id: "push",
+          label: `Push ${status.branch.ahead} local commit(s)`,
+          action: "push",
+          safe: true,
+        });
+      }
+      return {
+        status,
+        lockReport: {
+          root: localPath,
+          gitDir: `${localPath}\\.git`,
+          locks: [],
+          processes: { available: true, active: [] },
+        },
+        recommendations,
+      };
+    },
+    async reconcileRepository(localPath) {
+      await wait(160);
+      return this.gitRecoveryStatus(localPath);
+    },
+    async repairGitLocks(localPath) {
+      return {
+        ...(await this.gitRecoveryStatus(localPath)).lockReport,
+        removed: [],
+        skipped: [],
+        repaired: false,
+      };
+    },
+    async repairRepositorySync(localPath, strategy) {
+      const repo = findRepo(localPath);
+      if (strategy === "fast-forward") {
+        repo.localStatus.branch.behind = 0;
+        repo.localStatus.head = "f".repeat(40);
+      } else if (strategy === "push") {
+        repo.localStatus.branch.ahead = 0;
+      } else if (strategy !== "fetch") {
+        throw new Error("Unsupported demo synchronization strategy.");
+      }
+      recompute(repo);
+      emitRepositories();
+      return {
+        strategy,
+        backupBranch: null,
+        status: clone(repo.localStatus),
+        lockReport: (await this.gitRecoveryStatus(localPath)).lockReport,
+      };
+    },
    async indexLockInfo() {
      return { exists: false, ageMs: 0 };
    },
@@ -357,6 +357,8 @@ select:focus-visible {
  padding: 0 6px 10px;
 }
 .repo-row {
+  content-visibility: auto;
+  contain-intrinsic-size: auto 48px;
  width: 100%;
  display: grid;
  grid-template-columns: 18px minmax(0, 1fr) auto;
@@ -646,6 +648,24 @@ select:focus-visible {
  right: 14px;
  color: var(--text-faint);
 }
+.modal .summary-grid {
+  grid-template-columns: repeat(auto-fit, minmax(112px, 1fr));
+}
+.modal .summary-card {
+  min-height: 108px;
+}
+.modal .summary-card > span {
+  display: block;
+  max-width: 12ch;
+  color: var(--text-muted);
+  line-height: 1.35;
+}
+.modal .summary-card > strong {
+  display: block;
+  margin-top: 15px;
+  font: 700 27px/1 var(--font-sans);
+  color: var(--text);
+}
 .summary-card.warning .summary-value,
 .summary-card.warning .icon {
  color: var(--warning);
@@ -803,7 +823,11 @@ select:focus-visible {
  height: 100%;
  min-height: 0;
  display: grid;
-  grid-template-rows: auto auto auto 39px minmax(0, 1fr);
+  grid-template-rows: auto auto 39px minmax(0, 1fr);
+}
+.repo-context {
+  min-width: 0;
+  min-height: 0;
 }
 .repo-header {
  padding: 16px 18px 13px;
@@ -849,6 +873,64 @@ select:focus-visible {
 .release-node:last-child {
  border-right: 0;
 }
+.repository-deployment-summary {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  min-height: 48px;
+  padding: 7px 12px;
+  border-bottom: 1px solid var(--line);
+  background: linear-gradient(90deg, color-mix(in srgb, var(--accent) 7%, var(--surface-1)), var(--surface-1) 42%);
+}
+.repository-deployment-summary-label {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  flex: 0 0 auto;
+  color: var(--text-muted);
+  font-size: 10px;
+  font-weight: 760;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+.repository-deployment-summary-label svg {
+  width: 14px;
+  height: 14px;
+  color: var(--accent);
+}
+.repository-deployment-chips {
+  display: flex;
+  gap: 7px;
+  min-width: 0;
+  flex: 1;
+  overflow-x: auto;
+  scrollbar-width: thin;
+}
+.repository-deployment-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  flex: 0 0 auto;
+  max-width: 280px;
+  padding: 6px 9px;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  background: color-mix(in srgb, var(--surface-2) 88%, transparent);
+  color: var(--text);
+  cursor: pointer;
+}
+.repository-deployment-chip:hover {
+  border-color: color-mix(in srgb, var(--accent) 48%, var(--line));
+  background: color-mix(in srgb, var(--accent) 10%, var(--surface-2));
+}
+.repository-deployment-chip strong,
+.repository-deployment-chip span:last-child {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.repository-deployment-chip strong { font-size: 11px; }
+.repository-deployment-chip span:last-child { color: var(--text-muted); font-size: 10px; }
 .release-node:not(:last-child)::after {
  content: "›";
  position: absolute;
@@ -917,8 +999,14 @@ select:focus-visible {
  padding: 0 12px;
  border-bottom: 1px solid var(--line);
  background: var(--surface-1);
+  min-width: 0;
+  overflow-x: auto;
+  overflow-y: hidden;
+  scrollbar-width: thin;
 }
 .tab {
+  flex: 0 0 auto;
+  white-space: nowrap;
  height: 38px;
  padding: 0 12px;
  background: transparent;
@@ -2593,6 +2681,7 @@ kbd {
 .git-tools-grid {
  display: grid;
  grid-template-columns: repeat(2, minmax(0, 1fr));
+  grid-auto-rows: max-content;
  gap: 15px;
  align-items: start;
 }
@@ -2648,6 +2737,8 @@ kbd {
  background: linear-gradient(180deg, var(--primary), var(--success));
 }
 .server-inventory-panel .tool-row {
+  content-visibility: auto;
+  contain-intrinsic-size: auto 76px;
  transition: background 150ms ease, transform 150ms ease;
 }
 .server-inventory-panel .tool-row:hover {
@@ -3256,6 +3347,33 @@ html[data-theme="light"] .setup-brand-logo-light {
 .git-tools-grid .troubleshooting-panel {
  grid-column: 1 / -1;
 }
+.git-tools-grid .workspace-sync-panel {
+  grid-column: 1 / -1;
+  overflow: hidden;
+  background:
+    radial-gradient(circle at 88% 10%, color-mix(in srgb, var(--accent) 15%, transparent), transparent 34%),
+    var(--surface-1);
+}
+.workspace-sync-layout {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 24px;
+}
+.workspace-sync-layout h3 {
+  margin: 0 0 6px;
+}
+.workspace-sync-layout p {
+  margin: 0 0 13px;
+  color: var(--text-muted);
+  max-width: 820px;
+}
+.workspace-sync-actions {
+  display: grid;
+  justify-items: end;
+  gap: 10px;
+  min-width: 220px;
+}
 .troubleshooting-summary {
  display: flex;
  align-items: center;
@@ -3289,6 +3407,13 @@ html[data-theme="light"] .setup-brand-logo-light {
  margin-left: auto;
 }
@media (max-width: 760px) {
+  .workspace-sync-layout {
+    grid-template-columns: 1fr;
+  }
+  .workspace-sync-actions {
+    justify-items: stretch;
+    min-width: 0;
+  }
  .repo-quick-actions {
    margin-inline: 12px;
  }
@@ -3911,3 +4036,301 @@ html[data-theme="light"] .visual-page-header {
    display: none;
  }
 }
+
+/* Help center and compact repository-shell safeguards */
+.panel-header-actions {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.help-page {
+  max-width: 1500px;
+}
+.help-hero {
+  position: relative;
+  isolation: isolate;
+  display: flex;
+  justify-content: space-between;
+  gap: 32px;
+  overflow: hidden;
+  margin-bottom: 24px;
+  padding: 30px 34px;
+  border: 1px solid var(--line);
+  border-radius: 18px;
+  background:
+    radial-gradient(circle at 78% 15%, color-mix(in srgb, var(--accent) 16%, transparent), transparent 32%),
+    linear-gradient(125deg, color-mix(in srgb, var(--surface-2) 92%, transparent), var(--surface-1));
+  box-shadow: 0 22px 65px -48px color-mix(in srgb, var(--accent) 65%, transparent);
+}
+.help-hero::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  pointer-events: none;
+  background-image: radial-gradient(color-mix(in srgb, var(--text-faint) 20%, transparent) 0.8px, transparent 0.8px);
+  background-size: 18px 18px;
+  mask-image: linear-gradient(90deg, transparent, black 65%, transparent);
+  opacity: 0.42;
+}
+.help-hero > div:first-child {
+  flex: 1;
+  min-width: 0;
+  max-width: 750px;
+}
+.help-hero h1 {
+  margin: 8px 0 6px;
+  font-size: clamp(28px, 3vw, 42px);
+  line-height: 1.1;
+  letter-spacing: -0.045em;
+}
+.help-hero p {
+  max-width: 680px;
+  margin: 0;
+  color: var(--text-muted);
+  font-size: 13px;
+  line-height: 1.6;
+}
+.help-search {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 10px;
+  max-width: 680px;
+  margin-top: 22px;
+  padding: 0 12px;
+  border: 1px solid color-mix(in srgb, var(--accent) 32%, var(--line));
+  border-radius: 11px;
+  background: color-mix(in srgb, var(--surface-0) 90%, transparent);
+  box-shadow: 0 12px 36px -30px var(--accent);
+}
+.help-search:focus-within {
+  border-color: var(--primary);
+  box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary) 15%, transparent);
+}
+.help-search > .icon {
+  color: var(--primary);
+}
+.help-search input {
+  min-width: 0;
+  height: 46px;
+  border: 0;
+  outline: 0;
+  background: transparent;
+  color: var(--text);
+}
+.help-search kbd {
+  padding: 3px 6px;
+  border: 1px solid var(--line);
+  border-radius: 5px;
+  background: var(--surface-2);
+  color: var(--text-faint);
+  font: 10px var(--font-mono);
+}
+.help-layout {
+  display: grid;
+  grid-template-columns: minmax(190px, 240px) minmax(0, 1fr);
+  align-items: start;
+  gap: 20px;
+}
+.help-navigation {
+  position: sticky;
+  top: 0;
+  display: grid;
+  gap: 16px;
+  padding: 18px;
+  border: 1px solid var(--line);
+  border-radius: 14px;
+  background: color-mix(in srgb, var(--surface-1) 94%, transparent);
+}
+.help-category {
+  display: grid;
+  gap: 3px;
+}
+.help-category > strong {
+  padding: 4px 8px;
+  color: var(--text-faint);
+  font-size: 10px;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+.help-category button {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 8px;
+  border-radius: 8px;
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+  text-align: left;
+  font-size: 11px;
+  line-height: 1.3;
+}
+.help-category button:hover,
+.help-category button.active {
+  background: color-mix(in srgb, var(--accent) 10%, var(--surface-2));
+  color: var(--text);
+}
+.help-category button.active {
+  box-shadow: inset 2px 0 var(--primary);
+}
+.help-category button .icon {
+  flex: 0 0 auto;
+  width: 15px;
+  height: 15px;
+  color: var(--primary);
+}
+.help-results {
+  min-width: 0;
+}
+.help-results-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: end;
+  min-height: 48px;
+  margin-bottom: 10px;
+}
+.help-results-header h2 {
+  margin: 0 0 4px;
+  font-size: 18px;
+}
+.help-results-header span {
+  color: var(--text-faint);
+  font-size: 11px;
+}
+.help-topic {
+  overflow: hidden;
+  margin-bottom: 10px;
+  border: 1px solid var(--line);
+  border-radius: 13px;
+  background: var(--surface-1);
+  transition: border-color 150ms ease, transform 150ms ease, box-shadow 150ms ease;
+  scroll-margin-top: 14px;
+}
+.help-topic:hover {
+  border-color: color-mix(in srgb, var(--accent) 34%, var(--line));
+}
+.help-topic[open] {
+  border-color: color-mix(in srgb, var(--accent) 26%, var(--line));
+  box-shadow: 0 18px 42px -40px var(--accent);
+}
+.help-topic summary {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 14px;
+  padding: 16px 18px;
+  cursor: pointer;
+  list-style: none;
+}
+.help-topic summary::-webkit-details-marker {
+  display: none;
+}
+.help-topic summary > span:nth-child(2) {
+  display: grid;
+  gap: 3px;
+  min-width: 0;
+}
+.help-topic summary small {
+  color: var(--primary);
+  font-size: 9px;
+  font-weight: 750;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+}
+.help-topic summary strong {
+  font-size: 14px;
+}
+.help-topic summary span span {
+  overflow: hidden;
+  color: var(--text-muted);
+  font-size: 11px;
+  line-height: 1.45;
+  text-overflow: ellipsis;
+}
+.help-topic-icon {
+  display: grid;
+  place-items: center;
+  width: 38px;
+  height: 38px;
+  border: 1px solid color-mix(in srgb, var(--accent) 22%, var(--line));
+  border-radius: 11px;
+  background: color-mix(in srgb, var(--accent) 9%, var(--surface-2));
+  color: var(--primary);
+}
+.help-topic-icon .icon {
+  width: 19px;
+  height: 19px;
+}
+.help-chevron {
+  color: var(--text-faint);
+  transition: transform 150ms ease;
+}
+.help-topic[open] .help-chevron {
+  transform: rotate(90deg);
+}
+.help-topic-body {
+  padding: 0 18px 18px 70px;
+  border-top: 1px solid var(--line-soft);
+}
+.help-topic-body ol {
+  display: grid;
+  gap: 11px;
+  margin: 16px 0;
+  padding-left: 22px;
+  color: var(--text-muted);
+  font-size: 12px;
+  line-height: 1.55;
+}
+.help-topic-body li::marker {
+  color: var(--primary);
+  font-family: var(--font-mono);
+  font-weight: 700;
+}
+.help-note {
+  display: flex;
+  align-items: flex-start;
+  gap: 9px;
+  padding: 11px 12px;
+  border: 1px solid color-mix(in srgb, var(--success) 20%, var(--line));
+  border-radius: 9px;
+  background: color-mix(in srgb, var(--success) 6%, var(--surface-0));
+  color: var(--text-muted);
+  font-size: 11px;
+  line-height: 1.5;
+}
+.help-note .icon {
+  flex: 0 0 auto;
+  color: var(--success);
+}
+
+@media (max-width: 900px) {
+  .help-layout {
+    grid-template-columns: 1fr;
+  }
+  .help-navigation {
+    position: static;
+    display: none;
+  }
+  .help-hero .project-illustration {
+    display: none;
+  }
+}
+@media (max-width: 680px) {
+  .help-hero {
+    padding: 22px;
+  }
+  .help-search kbd {
+    display: none;
+  }
+  .help-search {
+    grid-template-columns: auto minmax(0, 1fr);
+  }
+  .help-topic-body {
+    padding-left: 18px;
+  }
+}
@@ -15,6 +15,7 @@ function renderTitlebar() {
          deployments: "Deployments",
          diagnostics: "Diagnostics",
          settings: "Settings",
+          help: "Help center",
          "deployment-run": "Deployment run",
        }[ui.currentView] || "Workspace";
  return `<header class="titlebar">
@@ -31,6 +32,9 @@ function renderTitlebar() {

 function renderRepositoryRow(repository) {
  const status = repository.localStatus;
+  const profiles = repository.deploymentProfiles || [];
+  const workloads = linkedWorkloadsForRepository(repository);
+  const runningWorkloads = workloads.filter((workload) => workload.runtime?.running);
  const badges = [];
  if (status?.counts.conflicts)
    badges.push('<span class="mini-badge danger" title="Conflicts">!</span>');
@@ -50,10 +54,14 @@ function renderRepositoryRow(repository) {
    badges.push(
      '<span class="mini-badge success" title="Ready to deploy">↗</span>',
    );
+  if (profiles.length)
+    badges.push(
+      `<span class="mini-badge ${runningWorkloads.length ? "success" : "warning"} deployment-badge" title="${attr(`${profiles.length} server deployment${profiles.length === 1 ? "" : "s"} linked${runningWorkloads.length ? ` · ${runningWorkloads.length} running` : ""}`)}">S${profiles.length}</span>`,
+    );
  if (!repository.localPath)
    badges.push('<span class="mini-badge" title="No local folder">—</span>');
  const branch = status?.branch.head || repository.defaultBranch || "remote";
-  return `<button class="repo-row ${String(repository.id) === String(ui.selectedRepoId) ? "active" : ""} ${repository.attention ? "attention" : ""}" data-action="select-repo" data-id="${attr(repository.id)}">
+  return `<button class="repo-row ${String(repository.id) === String(ui.selectedRepoId) ? "active" : ""} ${repository.attention ? "attention" : ""}" data-action="select-repo" data-id="${attr(repository.id)}" data-deployment-count="${profiles.length}">
    <span class="repo-icon">${repository.favorite ? icon("star") : icon(repository.localPath ? "git" : "cloud")}</span>
    <span class="repo-main"><span class="repo-name">${escapeHtml(repository.name)}</span><span class="repo-sub"><span>${escapeHtml(branch)}</span>${status?.shortHead ? `<span>• ${escapeHtml(status.shortHead)}</span>` : ""}</span></span>
    <span class="repo-badges">${badges.join("")}</span>
@@ -80,7 +88,7 @@ function renderSidebar() {
  ).length;
  const rows = (list) => list.map(renderRepositoryRow).join("");
  return `<aside class="sidebar">
-    <nav class="primary-nav">${navButton("overview", "Overview", "overview", attention || "")}${navButton("deployments", "Deployments", "deploy", operations().filter((item) => item.type === "deployment" && !isTerminalOperation(item.status)).length || "")}${navButton("diagnostics", "Diagnostics", "shield", ui.diagnosticsStatus?.lastWriteError ? "!" : "")}${navButton("settings", "Settings", "settings")}</nav>
+    <nav class="primary-nav">${navButton("overview", "Overview", "overview", attention || "")}${navButton("deployments", "Deployments", "deploy", operations().filter((item) => item.type === "deployment" && !isTerminalOperation(item.status)).length || "")}${navButton("diagnostics", "Diagnostics", "shield", ui.diagnosticsStatus?.lastWriteError ? "!" : "")}${navButton("settings", "Settings", "settings")}${navButton("help", "Help", "help")}</nav>
    <div class="sidebar-section"><span>Repositories</span><button data-action="refresh" title="Refresh">${icon("refresh")}</button></div>
    <input class="repo-filter" id="repo-filter" value="${attr(ui.repoSearch)}" placeholder="Filter projects" aria-label="Filter projects" />
    <div class="repo-list">
@@ -150,6 +158,7 @@ function renderOverview() {
  return `<div class="page">
    <div class="page-header visual-page-header"><div><div class="eyebrow">Coding flow</div><h1>Release overview</h1><p>One decision surface for local work, Gitea synchronization and the exact version running on your server.</p></div>${projectIllustration("flow")}<button class="button" data-action="refresh">${icon("refresh")}Refresh all</button></div>
    ${ui.refreshError ? `<div class="notice danger">${icon("error")} ${escapeHtml(ui.refreshError)}</div>` : ""}
+    ${ui.refreshWarning ? `<div class="notice warning">${icon("warning")} ${escapeHtml(ui.refreshWarning)}</div>` : ""}
    <div class="summary-grid">
      ${renderSummaryCard("Local work", changed, changed === 1 ? "repository has changes" : "repositories have changes", "file", changed ? "warning" : "success")}
      ${renderSummaryCard("Unpushed", unpushed, "repositories ahead of Gitea", "arrowUp", unpushed ? "warning" : "success")}
@@ -175,7 +184,7 @@ function renderOverview() {
        ${readinessRow("Git executable", ui.boot.git.available, ui.boot.git.version || ui.boot.git.error)}
        ${readinessRow("Gitea connection", ui.boot.state.gitea.hasToken, ui.boot.state.gitea.baseUrl || "Not configured")}
        ${readinessRow("Workspace folders", ui.boot.state.workspaceRoots.length > 0, `${ui.boot.state.workspaceRoots.length} configured`)}
-        ${readinessRow("Automatic awareness", ui.boot.state.preferences?.autoRefresh !== false, ui.boot.state.preferences?.autoRefresh === false ? "Manual refresh only" : `Every ${ui.boot.state.preferences?.repositoryPollSeconds || 4}s`)}
+        ${readinessRow("Automatic awareness", ui.boot.state.preferences?.autoRefresh !== false, ui.boot.state.preferences?.autoRefresh === false ? "Manual refresh only" : `Local every ${ui.boot.state.preferences?.repositoryPollSeconds || 4}s · Gitea every ${ui.boot.state.preferences?.fetchIntervalMinutes || "manual"}${ui.boot.state.preferences?.fetchIntervalMinutes ? " min" : ""}`)}
      </div></div>
    </section>
  </div>`;
@@ -188,40 +197,16 @@ function releaseNode(label, value, description, tone = "") {
  return `<div class="release-node"><div class="release-label">${label}</div><div class="release-value"><span class="state-dot ${tone}"></span><strong>${escapeHtml(value)}</strong><span>${escapeHtml(description)}</span></div></div>`;
 }

-function diffAtmosphere(diff) {
-  if (!ui.selectedFile) return "";
-  const lines = String(diff || "").split("\n");
-  const additions = lines.filter(
-    (line) => line.startsWith("+") && !line.startsWith("+++"),
-  ).length;
-  const removals = lines.filter(
-    (line) => line.startsWith("-") && !line.startsWith("---"),
-  ).length;
-  const extension =
-    String(ui.selectedFile).split(".").pop()?.slice(0, 8).toUpperCase() ||
-    "FILE";
-  return `<div class="diff-atmosphere ${lines.length > 34 ? "dense" : ""}" data-diff-atmosphere aria-hidden="true"><svg viewBox="0 0 360 260" role="presentation"><path class="code-route route-a" d="M38 195 C92 84 178 214 318 74"/><path class="code-route route-b" d="M52 74 C132 8 230 34 310 156"/><g class="code-card"><rect x="110" y="75" width="142" height="106" rx="18"/><path d="M136 108h90M136 128h58M136 148h76"/></g><g class="code-node node-one"><circle cx="48" cy="190" r="15"/><path d="m41 190 5 5 9-12"/></g><g class="code-node node-two"><circle cx="315" cy="76" r="13"/><path d="M308 76h14M315 69v14"/></g><circle class="code-packet packet-one" cx="0" cy="0" r="5"/><circle class="code-packet packet-two" cx="0" cy="0" r="4"/></svg><div class="diff-atmosphere-caption"><span>${escapeHtml(extension)} change map</span><strong><i>+${additions}</i><i>−${removals}</i></strong></div></div>`;
+function linkedWorkloadsForRepository(repository) {
+  const fullName = String(repository?.fullName || "").toLowerCase();
+  if (!fullName) return [];
+  return (ui.serverDiscovery || []).flatMap((server) =>
+    (server.workloads || [])
+      .filter((workload) => String(workload.link?.repositoryFullName || "").toLowerCase() === fullName)
+      .map((workload) => ({ ...workload, serverId: server.serverId, serverName: server.serverName || server.server?.name || "Server" })),
+  );
 }

-function renderDiff(diff) {
-  if (!diff)
-    return '<div class="empty-state"><div class="empty-icon">↔</div><h3>No textual diff</h3><p>Select another file or open the project folder for binary changes.</p></div>';
-  const rendered = escapeHtml(diff)
-    .split("\n")
-    .map((line) => {
-      const type =
-        line.startsWith("+") && !line.startsWith("+++")
-          ? "add"
-          : line.startsWith("-") && !line.startsWith("---")
-            ? "remove"
-            : line.startsWith("@@")
-              ? "hunk"
-              : "";
-      return `<span class="diff-line ${type}">${line || " "}</span>`;
-    })
-    .join("");
-  return `${rendered}${diffAtmosphere(diff)}`;
-}
 function fileStatusCode(file) {
  if (file.conflict) return "U";
  if (file.untracked) return "?";
@@ -355,12 +340,19 @@ function renderProfileCard(repository, profile, compact = false) {
  const serverAccessAction = isSsh && mode === "server-git"
    ? `<button class="button" data-action="verify-server-git-access" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("shield")}Verify server pull</button><button class="button" data-action="manage-deploy-key" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("key")}Deploy key lifecycle</button><button class="button" data-action="configure-server-git-access" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("key")}Configure Gitea access</button>`
    : "";
-  return `<article class="deploy-card accent-${identity.accent} ${compact ? "compact-card" : ""}"><div class="container-identity"><span class="container-avatar">${escapeHtml(identity.initial)}</span><div><span>Container</span><strong>${escapeHtml(identity.name)}</strong><small>${escapeHtml(repository.fullName)} · ${escapeHtml(profile.environment)}</small></div>${syncLabel}</div><div class="deploy-card-header"><div><div class="eyebrow">${escapeHtml(isSsh ? "SSH / UNRAID" : "GITEA ACTIONS")}</div><h3>${escapeHtml(profile.name)}</h3><p>${escapeHtml(providerDetail)}</p></div><span class="status-pill ${health.tone}"><span class="state-dot ${health.tone}"></span>${health.label}</span></div><div class="deploy-card-body"><div class="deploy-metadata"><span>Live commit</span><strong>${state.liveSha ? shortSha(state.liveSha) : "Unknown"}</strong><span>Deploy source</span><strong>${escapeHtml(sourceLabel)}</strong><span>Previous version</span><strong>${state.previousSha ? shortSha(state.previousSha) : "Unknown"}</strong><span>Last checked</span><strong>${state.checkedAt ? formatDate(state.checkedAt) : "Never"}</strong>${isSsh ? `<span>Deployment mode</span><strong>${escapeHtml(modeLabel)}</strong><span>Compose project</span><strong>${escapeHtml(profile.composeProject || "ForgeFlow-generated identity")}</strong><span>Runtime</span><strong>${state.containerRunning === false ? "Stopped" : state.containerRunning ? state.runtimeVerification === "running-unverified" ? "Running · unverified" : "Running" : "Unknown"}</strong><span>DockerMan</span><strong class="${managesDockerMan && !dockerManReady ? "text-warning" : "text-success"}">${escapeHtml(dockerManLabel)}</strong>` : ""}<span>Rollback</span><strong>${rollbackConfigured ? "Available after first deploy" : "Not configured"}</strong></div><div class="card-actions"><button class="button" data-action="run-deployment-preflight" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("shield")}Preflight</button>${isSsh ? `<button class="button" data-action="repair-deployment-write-access" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("wrench")}Check / fix write access</button>` : ""}${serverAccessAction}<button class="button" data-action="reconcile-deployment" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("refresh")}Refresh truth</button>${webUi ? `<button class="button" data-action="open-profile-webui" data-url="${attr(webUi)}">${icon("external")}Open Web UI</button>` : ""}${managesDockerMan ? `<button class="button ${dockerManReady ? "ghost" : ""}" data-action="apply-dockerman-metadata" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("wrench")}${dockerManReady ? "Reapply DockerMan integration" : "Repair DockerMan integration"}</button>` : ""}${ready ? `<button class="button primary" data-action="deploy-profile" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("rocket")}Deploy ${escapeHtml(shortSha(targetSha))}</button>` : ""}<button class="button ghost" data-action="edit-deployment-profile" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">Edit</button>${state.previousSha && rollbackConfigured ? `<button class="button danger" data-action="rollback-profile" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("undo")}Rollback</button>` : ""}</div></div></article>`;
+  return `<article class="deploy-card accent-${identity.accent} ${compact ? "compact-card" : ""}"><div class="container-identity"><span class="container-avatar">${escapeHtml(identity.initial)}</span><div><span>Container</span><strong>${escapeHtml(identity.name)}</strong><small>${escapeHtml(repository.fullName)} · ${escapeHtml(profile.environment)}</small></div>${syncLabel}</div><div class="deploy-card-header"><div><div class="eyebrow">${escapeHtml(isSsh ? "SSH / UNRAID" : "GITEA ACTIONS")}</div><h3>${escapeHtml(profile.name)}</h3><p>${escapeHtml(providerDetail)}</p></div><span class="status-pill ${health.tone}"><span class="state-dot ${health.tone}"></span>${health.label}</span></div><div class="deploy-card-body"><div class="deploy-metadata"><span>Live commit</span><strong>${state.liveSha ? shortSha(state.liveSha) : "Unknown"}</strong><span>Deploy source</span><strong>${escapeHtml(sourceLabel)}</strong><span>Previous version</span><strong>${state.previousSha ? shortSha(state.previousSha) : "Unknown"}</strong><span>Last checked</span><strong>${state.checkedAt ? formatDate(state.checkedAt) : "Never"}</strong>${isSsh ? `<span>Deployment mode</span><strong>${escapeHtml(modeLabel)}</strong>${mode === "server-git" ? `<span>Server pull</span><strong class="${verification ? verification.deployReady ? "text-success" : "text-warning" : ""}">${escapeHtml(verification?.readiness || "Verify before deployment")}</strong>` : ""}<span>Compose project</span><strong>${escapeHtml(profile.composeProject || "ForgeFlow-generated identity")}</strong><span>Runtime</span><strong>${state.containerRunning === false ? "Stopped" : state.containerRunning ? state.runtimeVerification === "running-unverified" ? "Running · unverified" : "Running" : "Unknown"}</strong><span>DockerMan</span><strong class="${managesDockerMan && !dockerManReady ? "text-warning" : "text-success"}">${escapeHtml(dockerManLabel)}</strong>` : ""}<span>Rollback</span><strong>${rollbackConfigured ? "Available after first deploy" : "Not configured"}</strong></div><div class="card-actions"><button class="button" data-action="run-deployment-preflight" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("shield")}Preflight</button>${isSsh ? `<button class="button" data-action="repair-deployment-write-access" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("wrench")}Check / fix write access</button>` : ""}${serverAccessAction}<button class="button" data-action="reconcile-deployment" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("refresh")}Refresh truth</button>${webUi ? `<button class="button" data-action="open-profile-webui" data-url="${attr(webUi)}">${icon("external")}Open Web UI</button>` : ""}${managesDockerMan ? `<button class="button ${dockerManReady ? "ghost" : ""}" data-action="apply-dockerman-metadata" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("wrench")}${dockerManReady ? "Reapply DockerMan integration" : "Repair DockerMan integration"}</button>` : ""}${ready ? `<button class="button primary" data-action="deploy-profile" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("rocket")}Deploy ${escapeHtml(shortSha(targetSha))}</button>` : ""}<button class="button ghost" data-action="edit-deployment-profile" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">Edit</button>${state.previousSha && rollbackConfigured ? `<button class="button danger" data-action="rollback-profile" data-repository-id="${attr(repository.id)}" data-profile-id="${attr(profile.id)}">${icon("undo")}Rollback</button>` : ""}</div></div></article>`;
 }
 function renderRepositoryDeployments(repository) {
  const profiles = repository.deploymentProfiles || [];
+  const workloads = linkedWorkloadsForRepository(repository);
+  const profileIds = new Set(profiles.map((profile) => profile.id));
+  const workloadRows = workloads.map((workload) => {
+    const containers = (workload.containers || []).map((container) => container.name).filter(Boolean);
+    const profileResolved = Boolean(workload.link?.profileId && profileIds.has(workload.link.profileId));
+    return `<div class="tool-row repository-workload-row"><div><strong>${escapeHtml(workload.displayName || containers[0] || "Server workload")}</strong><span>${escapeHtml(workload.serverName)} · ${containers.length ? escapeHtml(containers.join(", ")) : "container identity unavailable"} · ${workload.runtime?.running ? "running" : "stopped"}</span><span>${escapeHtml(workload.compose?.project ? `Compose ${workload.compose.project}` : workload.remoteFolderCandidate || "Docker workload")}</span></div><div class="stack horizontal compact"><span class="status-pill ${profileResolved ? "success" : "danger"}">${profileResolved ? "Repository linked" : "Link needs reconciliation"}</span>${profileResolved ? `<button class="button ghost" data-action="select-deployment-profile" data-profile-id="${attr(workload.link.profileId)}">Open profile</button>` : `<button class="button" data-action="navigate" data-view="deployments">Review inventory</button>`}</div></div>`;
+  }).join("");
  const repoOps = repositoryOperations(repository).slice(0, 10);
-  return `<div class="tab-page"><div class="section-heading"><div><h2>Deployment environments</h2><span class="meta">Exact-commit Gitea Actions or pinned SSH / Unraid deployments</span></div><button class="button primary" data-action="configure-deployment">${icon("plus")}Add environment</button></div>${profiles.length ? `<div class="deploy-card-grid">${profiles.map((profile) => renderProfileCard(repository, profile)).join("")}</div>` : '<div class="empty-state panel"><div class="empty-icon">↗</div><h3>No deployment profile</h3><p>Connect a Gitea Actions workflow or a trusted SSH / Unraid server.</p><button class="button primary" data-action="configure-deployment">Configure deployment</button></div>'}<section class="section-block"><div class="section-heading"><h2>Release history</h2></div><div class="panel">${repoOps.length ? `<table class="data-table"><thead><tr><th>Action</th><th>Environment</th><th>Commit</th><th>Status</th><th>Updated</th><th></th></tr></thead><tbody>${repoOps.map((operation) => `<tr><td>${escapeHtml(operation.action || "deploy")}</td><td>${escapeHtml(operation.environment)}</td><td class="mono">${escapeHtml(operation.shortSha || shortSha(operation.sha))}</td><td><span class="status-pill ${toneForStatus(operation.status)}">${escapeHtml(operation.status)}</span></td><td>${formatDate(operation.updatedAt || operation.createdAt)}</td><td><button class="button ghost" data-action="open-operation" data-operation-id="${attr(operation.id)}">Open</button></td></tr>`).join("")}</tbody></table>` : '<div class="empty-state compact"><p>No releases for this repository yet.</p></div>'}</div></section></div>`;
+  return `<div class="tab-page"><div class="section-heading"><div><h2>Deployment environments</h2><span class="meta">${profiles.length} configured profile${profiles.length === 1 ? "" : "s"} · ${workloads.length} server workload${workloads.length === 1 ? "" : "s"} linked to this repository</span></div><button class="button primary" data-action="configure-deployment">${icon("plus")}Add environment</button></div>${workloads.length ? `<section class="panel repository-workloads"><div class="panel-header"><div><h3>Detected on server</h3><span class="meta">Live Docker / Compose identities resolved back to this repository</span></div></div><div class="panel-body"><div class="tool-list">${workloadRows}</div></div></section>` : ""}${profiles.length ? `<div class="deploy-card-grid">${profiles.map((profile) => renderProfileCard(repository, profile)).join("")}</div>` : '<div class="empty-state panel"><div class="empty-icon">↗</div><h3>No deployment profile</h3><p>Connect a Gitea Actions workflow or a trusted SSH / Unraid server.</p><button class="button primary" data-action="configure-deployment">Configure deployment</button></div>'}<section class="section-block"><div class="section-heading"><h2>Release history</h2></div><div class="panel">${repoOps.length ? `<table class="data-table"><thead><tr><th>Action</th><th>Environment</th><th>Commit</th><th>Status</th><th>Updated</th><th></th></tr></thead><tbody>${repoOps.map((operation) => `<tr><td>${escapeHtml(operation.action || "deploy")}</td><td>${escapeHtml(operation.environment)}</td><td class="mono">${escapeHtml(operation.shortSha || shortSha(operation.sha))}</td><td><span class="status-pill ${toneForStatus(operation.status)}">${escapeHtml(operation.status)}</span></td><td>${formatDate(operation.updatedAt || operation.createdAt)}</td><td><button class="button ghost" data-action="open-operation" data-operation-id="${attr(operation.id)}">Open</button></td></tr>`).join("")}</tbody></table>` : '<div class="empty-state compact"><p>No releases for this repository yet.</p></div>'}</div></section></div>`;
 }

 function renderGitTools(repository) {
@@ -370,7 +362,28 @@ function renderGitTools(repository) {
  const locks = recovery?.lockReport?.locks || [];
  const activeProcesses = recovery?.lockReport?.processes?.active || [];
  const recommendations = recovery?.recommendations || [];
-  return `<div class="tab-page git-tools-grid"><section class="panel"><div class="panel-header"><h2>Branches</h2><button class="button ghost" data-action="load-git-tools">${icon("refresh")}Refresh</button></div><div class="panel-body"><div class="inline-form"><input id="new-branch-name" class="input" placeholder="feature/name"/><button class="button" data-action="create-branch">${icon("plus")}Create & switch</button></div><div class="tool-list">${ui.branches.length ? ui.branches.map((branch) => `<div class="tool-row"><div><strong>${escapeHtml(branch.name)}</strong><span>${escapeHtml(branch.shortSha)}${branch.upstream ? ` · ${escapeHtml(branch.upstream)}` : " · unpublished"}</span></div>${branch.current ? '<span class="status-pill success">Current</span>' : `<button class="button" data-action="checkout-branch" data-branch="${attr(branch.name)}">Switch</button>`}</div>`).join("") : '<div class="empty-state compact"><p>Load branch information.</p></div>'}</div></div></section><section class="panel"><div class="panel-header"><h2>Stashes</h2><button class="button" data-action="stash-changes" ${repository.localStatus?.clean ? "disabled" : ""}>${icon("archive")}Stash changes</button></div><div class="panel-body"><div class="tool-list">${ui.stashes.length ? ui.stashes.map((stash) => `<div class="tool-row"><div><strong>${escapeHtml(stash.ref)}</strong><span>${escapeHtml(stash.subject)} · ${formatDate(stash.date)}</span></div><button class="button" data-action="pop-stash" data-stash-ref="${attr(stash.ref)}">Apply & drop</button></div>`).join("") : '<div class="empty-state compact"><p>No stashes, or Git tools have not been loaded.</p></div>'}</div></div></section><section class="panel troubleshooting-panel"><div class="panel-header"><div><h2>Repository troubleshooting</h2><span class="meta">Safe, repository-specific recovery actions</span></div><button class="button primary" data-action="scan-git-recovery">${icon("pulse")}Scan</button></div><div class="panel-body">${recovery ? `<div class="troubleshooting-summary"><span class="status-pill ${locks.length ? "warning" : "success"}">${locks.length ? `${locks.length} lock${locks.length === 1 ? "" : "s"}` : "No Git locks"}</span><span>${activeProcesses.length ? `${activeProcesses.length} active Git process(es)` : "No matching active Git process detected"}</span></div>${locks.length ? `<div class="tool-list">${locks.map((lock) => `<div class="tool-row"><div><strong>${escapeHtml(lock.name)}</strong><span>${Math.round(lock.ageMs / 1000)}s old · ${escapeHtml(lock.modifiedAt)}</span></div></div>`).join("")}</div>` : ""}${recommendations.length ? `<div class="tool-list recovery-actions">${recommendations.map((item) => `<div class="tool-row"><div><strong>${escapeHtml(item.label)}</strong><span>${item.safe ? "Safe automated action" : item.action ? "Creates a safety branch before changing history" : "Review required"}</span></div>${item.action ? `<button class="button ${item.safe ? "" : "danger"}" data-action="repair-repository-sync" data-strategy="${attr(item.action)}">Run</button>` : ""}</div>`).join("")}</div>` : ""}` : '<div class="empty-state compact"><p>Scan before repairing. ForgeFlow checks every .lock file in the actual Git directory, not only index.lock.</p></div>'}<div class="card-actions"><button class="button" data-action="repair-git-locks">${icon("wrench")}Repair proven stale locks</button><button class="button" data-action="reconcile-repository">${icon("refresh")}Refresh Git state</button>${repository.sshUrl && repository.localStatus?.remoteUrl !== repository.sshUrl ? `<button class="button" data-action="repair-origin">${icon("link")}Repair origin</button>` : ""}</div><div class="notice warning">Lock repair refuses to run while a matching Git process is active. A force option is shown only when process detection itself is unavailable.</div></div></section></div>`;
+  const status = repository.localStatus || {};
+  const branchRows = ui.branches.length
+    ? ui.branches.map((branch) => `<div class="tool-row"><div><strong>${escapeHtml(branch.name)}</strong><span>${escapeHtml(branch.shortSha)}${branch.upstream ? ` · ${escapeHtml(branch.upstream)}` : " · unpublished"}</span></div>${branch.current ? '<span class="status-pill success">Current</span>' : `<button class="button" data-action="checkout-branch" data-branch="${attr(branch.name)}">Switch</button>`}</div>`).join("")
+    : '<div class="empty-state compact"><p>Load branch information.</p></div>';
+  const stashRows = ui.stashes.length
+    ? ui.stashes.map((stash) => `<div class="tool-row"><div><strong>${escapeHtml(stash.ref)}</strong><span>${escapeHtml(stash.subject)} · ${formatDate(stash.date)}</span></div>${stash.quarantined ? `<span class="status-pill warning" title="Workspace review ${attr(stash.reviewId || "")}">Codex review required</span>` : `<button class="button" data-action="pop-stash" data-stash-ref="${attr(stash.ref)}">Apply & drop</button>`}</div>`).join("")
+    : '<div class="empty-state compact"><p>No stashes, or Git tools have not been loaded.</p></div>';
+  const recoveryBody = recovery
+    ? `<div class="troubleshooting-summary"><span class="status-pill ${locks.length ? "warning" : "success"}">${locks.length ? `${locks.length} lock${locks.length === 1 ? "" : "s"}` : "No Git locks"}</span><span>${activeProcesses.length ? `${activeProcesses.length} active Git process(es)` : "No matching active Git process detected"}</span></div>${locks.length ? `<div class="tool-list">${locks.map((lock) => `<div class="tool-row"><div><strong>${escapeHtml(lock.name)}</strong><span>${Math.round(lock.ageMs / 1000)}s old · ${escapeHtml(lock.modifiedAt)}</span></div></div>`).join("")}</div>` : ""}${recommendations.length ? `<div class="tool-list recovery-actions">${recommendations.map((item) => `<div class="tool-row"><div><strong>${escapeHtml(item.label)}</strong><span>${item.safe ? "Safe automated action" : item.action ? "Creates a safety branch before changing history" : "Review required"}</span></div>${item.action ? `<button class="button ${item.safe ? "" : "danger"}" data-action="repair-repository-sync" data-strategy="${attr(item.action)}">Run</button>` : ""}</div>`).join("")}</div>` : ""}`
+    : '<div class="empty-state compact"><p>Scan before repairing. ForgeFlow checks every .lock file in the actual Git directory, not only index.lock.</p></div>';
+  const syncState = status.counts?.changed
+    ? `${status.counts.changed} local file${status.counts.changed === 1 ? "" : "s"} need protection`
+    : status.branch?.ahead || status.branch?.behind
+      ? `${status.branch.ahead || 0} ahead · ${status.branch.behind || 0} behind`
+      : "Preview against Gitea before changing files";
+
+  return `<div class="tab-page git-tools-grid">
+    <section class="panel"><div class="panel-header"><h2>Branches</h2><button class="button ghost" data-action="load-git-tools">${icon("refresh")}Refresh</button></div><div class="panel-body"><div class="inline-form"><input id="new-branch-name" class="input" placeholder="feature/name"/><button class="button" data-action="create-branch">${icon("plus")}Create & switch</button></div><div class="tool-list">${branchRows}</div></div></section>
+    <section class="panel"><div class="panel-header"><h2>Stashes</h2><button class="button" data-action="stash-changes" ${status.clean ? "disabled" : ""}>${icon("archive")}Stash changes</button></div><div class="panel-body"><div class="tool-list">${stashRows}</div></div></section>
+    <section class="panel workspace-sync-panel"><div class="panel-header"><div><h2>Gitea workspace sync</h2><span class="meta">Make tracked files match the current upstream branch exactly</span></div><div class="panel-header-actions"><button class="button ghost" data-action="open-context-help" data-topic="workspace-sync">${icon("help")}How does this work?</button><span class="status-pill ${status.branch?.behind || status.branch?.ahead || status.counts?.changed ? "warning" : "success"}">${escapeHtml(syncState)}</span></div></div><div class="panel-body"><div class="workspace-sync-layout"><div><h3>Safe mirror, never silent overwrite</h3><p>ForgeFlow fetches Gitea, previews additions, changes and deletions, then protects local Codex work before resetting. Local commits go to a recovery branch; modified and untracked files go to a stash.</p><div class="notice">${icon("shield")}Ignored runtime data such as <span class="mono">.env</span>, dependency folders and local databases is preserved. Background awareness only fetches; it never applies this sync automatically.</div></div><div class="workspace-sync-actions"><span class="meta">${escapeHtml(status.branch?.head || "No branch")} → ${escapeHtml(status.branch?.upstream || "No upstream")}</span><button class="button primary" data-action="preview-workspace-sync">${icon("refresh")}Preview Gitea sync</button></div></div></div></section>
+    <section class="panel troubleshooting-panel"><div class="panel-header"><div><h2>Repository troubleshooting</h2><span class="meta">Safe, repository-specific recovery actions</span></div><button class="button primary" data-action="scan-git-recovery">${icon("pulse")}Scan</button></div><div class="panel-body">${recoveryBody}<div class="card-actions"><button class="button" data-action="repair-git-locks">${icon("wrench")}Repair proven stale locks</button><button class="button" data-action="reconcile-repository">${icon("refresh")}Refresh Git state</button>${repository.sshUrl && status.remoteUrl !== repository.sshUrl ? `<button class="button" data-action="repair-origin">${icon("link")}Repair origin</button>` : ""}</div><div class="notice warning">Lock repair refuses to run while a matching Git process is active. A force option is shown only when process detection itself is unavailable.</div></div></section>
+  </div>`;
 }

 function renderRepositorySettings(repository) {
@@ -412,7 +425,10 @@ function renderGitValidator(repository) {

 function renderRepositoryWorkspace(repository) {
  const status = repository.localStatus;
+  const profiles = repository.deploymentProfiles || [];
+  const linkedWorkloads = linkedWorkloadsForRepository(repository);
  const profile = selectedProfile(repository);
+  const profileWorkload = linkedWorkloads.find((workload) => workload.link?.profileId === profile?.id);
  const serverState = profile?.state || {};
  const localTone = status?.counts.conflicts
    ? "danger"
@@ -433,6 +449,8 @@ function renderRepositoryWorkspace(repository) {
      ? "danger"
      : serverState.healthy === true
        ? "success"
+        : profileWorkload?.runtime?.running
+          ? "success"
        : "";
  const content = (
    {
@@ -444,9 +462,21 @@ function renderRepositoryWorkspace(repository) {
      settings: renderRepositorySettings,
    }[ui.repositoryTab] || renderChanges
  )(repository);
+  const deploymentLinks = profiles.length
+    ? `<div class="repository-deployment-summary"><span class="repository-deployment-summary-label">${icon("server")}Linked deployments</span><div class="repository-deployment-chips">${profiles.map((item) => {
+        const workload = linkedWorkloads.find((candidate) => candidate.link?.profileId === item.id);
+        const itemState = item.state || {};
+        const tone = itemState.healthy === false ? "danger" : itemState.healthy === true ? "success" : workload?.runtime?.running ? "success" : "warning";
+        const identity = workload?.displayName || item.containerName || item.remoteFolder || item.environment;
+        return `<button class="repository-deployment-chip" data-action="select-deployment-profile" data-profile-id="${attr(item.id)}"><span class="state-dot ${tone}"></span><strong>${escapeHtml(identity)}</strong><span>${escapeHtml(item.environment)}${workload?.serverName ? ` · ${escapeHtml(workload.serverName)}` : ""}</span></button>`;
+      }).join("")}</div><button class="button ghost" data-action="select-deployment-profile" data-profile-id="${attr(profile?.id || profiles[0].id)}">View all</button></div>`
+    : "";
  return `<div class="repo-workspace"><header class="repo-header illustrated-repo-header"><div class="repo-heading"><h1><button class="favorite-button ${repository.favorite ? "active" : ""}" data-action="toggle-favorite" title="Toggle favorite">${icon("star")}</button>${escapeHtml(repository.fullName)}</h1><p>${escapeHtml(repository.localPath || "No local working tree linked")}</p></div>${projectIllustration("repo")}<div class="repo-header-actions"><button class="button" data-action="fetch" ${!repository.localPath ? "disabled" : ""}>${icon("refresh")}Fetch</button><button class="button" data-action="open-path" ${!repository.localPath ? "disabled" : ""}>${icon("folder")}Folder</button><button class="button" data-action="open-gitea" ${!repository.htmlUrl ? "disabled" : ""}>${icon("external")}Gitea</button></div></header>
-    ${repository.localPath ? `<div class="repo-quick-actions"><button class="button" data-action="open-editor">${icon("external")}Open in editor</button><button class="button" data-action="open-terminal">${icon("terminal")}Open terminal</button><button class="button" data-action="check-branch-protection">${icon("shield")}Check branch protection</button><button class="button primary" data-action="open-pull-request">${icon("git")}Create pull request</button>${ui.branchProtection ? `<span class="status-pill ${ui.branchProtection.protected ? "warning" : "success"}">${ui.branchProtection.protected ? `Protected · ${ui.branchProtection.requiredApprovals || 0} approval(s)` : "Direct pushes allowed"}</span>` : ""}</div>` : ""}
-    <div class="release-rail">${releaseNode("Local", status?.shortHead || "Not linked", status ? `${status.counts.changed} changes · ${status.branch.head}` : "No working tree", localTone)}${releaseNode("Gitea", status?.shortHead || "Unknown", status?.branch.upstream ? `${status.branch.ahead} ahead · ${status.branch.behind} behind` : "Branch not published", remoteTone)}${releaseNode(`Server${profile ? ` · ${profile.environment}` : ""}`, serverState.liveSha ? shortSha(serverState.liveSha) : "Unknown", profile ? (serverState.checkedAt ? `checked ${formatDate(serverState.checkedAt)}` : "not checked") : "No deployment profile", serverTone)}</div>
+    <div class="repo-context">
+      ${repository.localPath ? `<div class="repo-quick-actions"><button class="button" data-action="open-editor">${icon("external")}Open in editor</button><button class="button" data-action="open-terminal">${icon("terminal")}Open terminal</button><button class="button" data-action="check-branch-protection">${icon("shield")}Check branch protection</button><button class="button primary" data-action="open-pull-request">${icon("git")}Create pull request</button>${ui.branchProtection ? `<span class="status-pill ${ui.branchProtection.protected ? "warning" : "success"}">${ui.branchProtection.protected ? `Protected · ${ui.branchProtection.requiredApprovals || 0} approval(s)` : "Direct pushes allowed"}</span>` : ""}</div>` : ""}
+      <div class="release-rail">${releaseNode("Local", status?.shortHead || "Not linked", status ? `${status.counts.changed} changes · ${status.branch.head}` : "No working tree", localTone)}${releaseNode("Gitea", status?.shortHead || "Unknown", status?.branch.upstream ? `${status.branch.ahead} ahead · ${status.branch.behind} behind` : "Branch not published", remoteTone)}${releaseNode(`Server${profile ? ` · ${profile.environment}` : ""}`, serverState.liveSha ? shortSha(serverState.liveSha) : profile ? "Linked" : "Unknown", profileWorkload ? `${profileWorkload.displayName || profile.containerName || "Container"} · ${profileWorkload.runtime?.running ? "running" : "stopped"} on ${profileWorkload.serverName}` : profile ? (serverState.checkedAt ? `checked ${formatDate(serverState.checkedAt)}` : "profile linked · awaiting live scan") : "No deployment profile", serverTone)}</div>
+      ${deploymentLinks}
+    </div>
    <nav class="tabs">${[
      ["changes", "Changes"],
      ["history", "History"],
@@ -531,9 +561,13 @@ function renderServerInventory() {
      ? visibleWorkloads.map((workload) => {
          const containers = (workload.containers || []).map((container) => container.name).filter(Boolean).join(", ");
          const topCandidate = workload.candidates?.[0];
-          const linked = (workload.status === "linked" || Boolean(workload.link)) && workload.classification?.type !== "stale-link";
+          const linkedRepository = ui.repositories.find((repository) => String(repository.fullName).toLowerCase() === String(workload.link?.repositoryFullName || "").toLowerCase());
+          const linkedProfile = linkedRepository?.deploymentProfiles?.find((profile) => profile.id === workload.link?.profileId);
+          const claimsLink = workload.status === "linked" || Boolean(workload.link);
+          const linked = Boolean(claimsLink && linkedRepository && linkedProfile) && workload.classification?.type !== "stale-link";
+          const inconsistentLink = claimsLink && !linked;
          const classification = workload.classification?.type || workload.status || "review";
-          const statusTone = linked && !workload.reviewDecisionStale ? "success" : ["ambiguous", "duplicate", "orphan-container"].includes(classification) || workload.reviewDecisionStale ? "danger" : "warning";
+          const statusTone = linked && !workload.reviewDecisionStale ? "success" : inconsistentLink || ["ambiguous", "duplicate", "orphan-container"].includes(classification) || workload.reviewDecisionStale ? "danger" : "warning";
          const detail = workload.compose?.project
            ? `Compose ${workload.compose.project} · ${(workload.compose.services || []).join(", ") || "services unknown"}`
            : workload.dockerMan?.templatePath
@@ -541,6 +575,8 @@ function renderServerInventory() {
              : `Container installation · ${containers || "unnamed"}`;
          const candidate = linked
            ? `Linked to ${workload.link?.repositoryFullName || "repository"}`
+            : inconsistentLink
+              ? `Stored link cannot be resolved to a loaded repository profile`
            : topCandidate
              ? `${topCandidate.repositoryFullName} suggested · ${topCandidate.confidence || topCandidate.status || "review required"}`
              : "No repository candidate; select one manually";
@@ -549,10 +585,19 @@ function renderServerInventory() {
            ? `<button class="button primary" data-action="quick-link-server-workload" data-server-id="${attr(server.serverId)}" data-workload-id="${attr(workload.workloadId)}" data-repository="${attr(topCandidate.repositoryFullName)}">${icon("link")}Link to ${escapeHtml(topCandidate.repositoryName || topCandidate.repositoryFullName)}</button>`
            : `<button class="button primary" data-action="link-server-workload" data-server-id="${attr(server.serverId)}" data-workload-id="${attr(workload.workloadId)}">${icon("link")}Review & link</button>`;
          const evidenceNote = workload.reviewDecisionStale ? "Saved decision is stale because server evidence changed" : workload.classification?.reason || "Awaiting review";
-          return `<div class="tool-row"><div><strong>${escapeHtml(workload.displayName)}</strong><span>${escapeHtml(detail)} · ${workload.runtime?.running ? "running" : "stopped"}</span><span>${escapeHtml(candidate)}</span><span class="${workload.reviewDecisionStale ? "text-warning" : "meta"}">${escapeHtml(evidenceNote)}</span>${workload.metadata?.composeDefinitionError ? `<span class="text-warning">Compose file found; validation warning: ${escapeHtml(workload.metadata.composeDefinitionError)}</span>` : ""}</div><div class="stack horizontal compact"><span class="status-pill ${statusTone}">${escapeHtml(workload.reviewDecisionStale ? "Decision stale" : linked ? "Linked" : classification)}</span>${linked ? `<button class="button ghost" data-action="edit-deployment-profile" data-profile-id="${attr(workload.link?.profileId || "")}">Open link</button>` : linkButton}</div></div>`;
+          return `<div class="tool-row"><div><strong>${escapeHtml(workload.displayName)}</strong><span>${escapeHtml(detail)} · ${workload.runtime?.running ? "running" : "stopped"}</span><span>${escapeHtml(candidate)}</span><span class="${workload.reviewDecisionStale || inconsistentLink ? "text-warning" : "meta"}">${escapeHtml(inconsistentLink ? "Reconcile this inventory link before deployment" : evidenceNote)}</span>${workload.metadata?.composeDefinitionError ? `<span class="text-warning">Compose file found; validation warning: ${escapeHtml(workload.metadata.composeDefinitionError)}</span>` : ""}</div><div class="stack horizontal compact"><span class="status-pill ${statusTone}">${escapeHtml(workload.reviewDecisionStale ? "Decision stale" : linked ? "Linked" : inconsistentLink ? "Link unresolved" : classification)}</span>${linked ? `<button class="button ghost" data-action="open-deployment-link" data-repository-id="${attr(linkedRepository.id)}" data-profile-id="${attr(linkedProfile.id)}">Open in repository</button>` : inconsistentLink ? `<button class="button" data-action="plan-server-reconciliation" data-server-id="${attr(server.serverId)}">Reconcile</button>` : linkButton}</div></div>`;
        }).join("")
      : `<div class="empty-state compact"><p>${server.error ? "No inventory could be read until the SSH connection works." : "Docker returned no containers, Compose projects or DockerMan templates."}</p></div>`;
-    return `<section class="panel server-inventory-panel"><div class="panel-header"><div><h3>${escapeHtml(server.serverName || server.server?.name || server.serverId)}</h3><span class="meta">${server.running || 0} running · ${server.linked || 0} repository links · ${visibleWorkloads.filter((workload) => !workload.link).length} to review${hiddenCount ? ` · ${hiddenCount} unrelated/system workloads hidden` : ""}</span></div><div class="stack horizontal compact"><span class="status-pill ${server.error ? "danger" : capabilities.docker && capabilities.compose ? "success" : "warning"}">${server.error ? "Scan failed" : escapeHtml(capabilityText)}</span>${server.error ? "" : `<button class="button" data-action="plan-server-reconciliation" data-server-id="${attr(server.serverId)}">${icon("shield")}Review reconciliation</button>`}</div></div><div class="panel-body">${errorBlock}${warnings}<div class="tool-list">${workloads}</div></div></section>`;
+    const resolvedLinks = visibleWorkloads.filter((workload) => {
+      const repository = ui.repositories.find((item) => String(item.fullName).toLowerCase() === String(workload.link?.repositoryFullName || "").toLowerCase());
+      return repository?.deploymentProfiles?.some((profile) => profile.id === workload.link?.profileId);
+    }).length;
+    const unresolvedLinks = visibleWorkloads.filter((workload) => {
+      if (!(workload.status === "linked" || workload.link)) return false;
+      const repository = ui.repositories.find((item) => String(item.fullName).toLowerCase() === String(workload.link?.repositoryFullName || "").toLowerCase());
+      return !repository?.deploymentProfiles?.some((profile) => profile.id === workload.link?.profileId);
+    }).length;
+    return `<section class="panel server-inventory-panel"><div class="panel-header"><div><h3>${escapeHtml(server.serverName || server.server?.name || server.serverId)}</h3><span class="meta">${server.running || 0} running · ${resolvedLinks} visible repository link${resolvedLinks === 1 ? "" : "s"}${unresolvedLinks ? ` · ${unresolvedLinks} unresolved` : ""} · ${visibleWorkloads.filter((workload) => !workload.link).length} to review${hiddenCount ? ` · ${hiddenCount} unrelated/system workloads hidden` : ""}</span></div><div class="stack horizontal compact"><span class="status-pill ${server.error ? "danger" : capabilities.docker && capabilities.compose ? "success" : "warning"}">${server.error ? "Scan failed" : escapeHtml(capabilityText)}</span>${server.error ? "" : `<button class="button" data-action="plan-server-reconciliation" data-server-id="${attr(server.serverId)}">${icon("shield")}Review reconciliation</button>`}</div></div><div class="panel-body">${errorBlock}${warnings}<div class="tool-list">${workloads}</div></div></section>`;
  }).join("");
  const empty = configuredServers.length
    ? `<div class="empty-state panel"><h3>Server inventory has not completed</h3><p>ForgeFlow will query Docker directly. A failed connection is shown explicitly instead of being reported as zero deployments.</p><button class="button primary" data-action="scan-server-inventory">Scan servers now</button></div>`
@@ -573,18 +618,155 @@ function renderDeployments() {
  );
  return `<div class="page"><div class="page-header visual-page-header"><div><div class="eyebrow">Server releases</div><h1>Deployments</h1><p>Discover live Unraid workloads, verify them against Gitea and release an exact commit through a protected server pull.</p></div>${projectIllustration("deploy")}<div class="stack horizontal compact"><button class="button" data-action="refresh-operations">${icon("refresh")}Refresh runs & servers</button>${missingDockerMan.length ? `<button class="button primary" data-action="repair-missing-dockerman">${icon("wrench")}Repair ${missingDockerMan.length} managed integration${missingDockerMan.length === 1 ? "" : "s"}</button>` : ""}</div></div>${active.length ? `<div class="notice warning">${icon("pulse")} ${active.length} deployment operation${active.length === 1 ? " is" : "s are"} still active. ForgeFlow reconciles these against the live server automatically.</div>` : ""}${renderServerInventory()}<section class="section-block"><div class="section-heading"><div><h2>Linked deployment environments</h2><span class="meta">Stable Compose identity, live container health and exact Gitea commit parity</span></div></div><div class="deploy-card-grid">${cards.length ? cards.map(({ repository, profile }) => renderProfileCard(repository, profile, true)).join("") : '<div class="empty-state panel"><h3>No deployment environments configured</h3><p>Scan a server and link an existing workload, or open a repository and add an environment.</p></div>'}</div></section><section class="section-block"><div class="section-heading"><h2>All operations</h2><span class="meta">Newest first</span></div><div class="panel">${operations().length ? `<table class="data-table"><thead><tr><th>Repository</th><th>Action</th><th>Environment</th><th>Commit</th><th>Status</th><th>Updated</th><th></th></tr></thead><tbody>${operations().map((operation) => `<tr><td>${escapeHtml(operation.repository)}</td><td>${escapeHtml(operation.action || "deploy")}</td><td>${escapeHtml(operation.environment || "—")}</td><td class="mono">${escapeHtml(operation.shortSha || shortSha(operation.sha))}</td><td><span class="status-pill ${toneForStatus(operation.status)}">${escapeHtml(operation.status)}</span></td><td>${formatDate(operation.updatedAt || operation.createdAt)}</td><td><button class="button ghost" data-action="open-operation" data-operation-id="${attr(operation.id)}">Open</button></td></tr>`).join("")}</tbody></table>` : '<div class="empty-state compact"><p>No operations recorded.</p></div>'}</div></section></div>`;
 }
+
+const HELP_TOPICS = [
+  {
+    id: "getting-started",
+    icon: "rocket",
+    category: "Basics",
+    title: "Start with a repository",
+    summary: "Connect Gitea, discover local projects and understand the Local → Gitea → Server flow.",
+    keywords: "setup connect token roots clone local remote overview",
+    steps: [
+      "Open Settings and validate the Gitea URL and token.",
+      "Add the parent folders that contain your projects, then save and rescan.",
+      "Select a repository. The release rail shows local changes, Gitea parity and the linked server release.",
+      "Use Changes to review work; use Git tools for branches, synchronization and pull requests.",
+    ],
+    note: "ForgeFlow does not modify a project merely because you opened it or refreshed the overview.",
+  },
+  {
+    id: "workspace-sync",
+    icon: "refresh",
+    category: "Git & Gitea",
+    title: "Make a local project match Gitea",
+    summary: "Clean tracked leftovers without losing local Codex work or ignored runtime data.",
+    keywords: "sync mirror pull reset deleted files cleanup stash recovery codex upstream dirty",
+    steps: [
+      "Open the repository, choose Git tools and select Preview Gitea sync.",
+      "Review every file that will be added, changed or removed.",
+      "Choose Protect local work & synchronize only when the preview matches your intention.",
+      "ForgeFlow creates a recovery branch for local commits and a stash for modified or untracked files before matching the upstream commit.",
+    ],
+    note: "Ignored files such as .env, local databases and dependency folders remain untouched. Background awareness only fetches metadata and never applies a sync.",
+  },
+  {
+    id: "changes",
+    icon: "file",
+    category: "Git & Gitea",
+    title: "Review, commit and publish changes",
+    summary: "Keep intentional local changes separate from remote updates.",
+    keywords: "changes stage hunk commit push branch pull request conflict",
+    steps: [
+      "Review selected files or individual hunks in Changes.",
+      "Enter a clear commit message and commit the reviewed selection.",
+      "Fetch before publishing; if Gitea changed, synchronize or resolve divergence first.",
+      "Push directly only when branch protection permits it, otherwise create a pull request.",
+    ],
+    note: "The action panel explains the current blocker and only enables operations that are safe for the selected state.",
+  },
+  {
+    id: "deployment-linking",
+    icon: "link",
+    category: "Deployments",
+    title: "Link server workloads to repositories",
+    summary: "Turn Docker, Compose and DockerMan evidence into one explicit repository deployment.",
+    keywords: "server inventory docker compose dockerman container detect linked review reconcile",
+    steps: [
+      "Open Deployments and scan the configured server.",
+      "Review proposed matches. ForgeFlow uses Compose paths, Git provenance, labels and container metadata; names alone are not trusted.",
+      "Confirm Review & link for a correct candidate, or choose the repository manually.",
+      "Use Review reconciliation whenever a saved link conflicts with current server evidence.",
+    ],
+    note: "External and system containers remain monitoring-only until you explicitly link them. A linked workload also appears on the matching repository.",
+  },
+  {
+    id: "deployments",
+    icon: "deploy",
+    category: "Deployments",
+    title: "Deploy an exact Gitea commit",
+    summary: "Validate, pull, build and promote a release without damaging the live service.",
+    keywords: "deploy release unraid preflight rollback health exact sha commit server pull",
+    steps: [
+      "Open the repository Deployments tab and select the intended environment.",
+      "Run preflight and repair blocking configuration before deployment.",
+      "Deploy only the shown target commit. Server pull fetches that exact commit instead of an ambiguous latest branch state.",
+      "Follow the run stages and health result. Failed promotion keeps or restores the previous release where supported.",
+    ],
+    note: "Commit parity means Local, Gitea and Server identify the same revision; a running container alone does not prove a correct release.",
+  },
+  {
+    id: "deploy-keys",
+    icon: "key",
+    category: "Deployments",
+    title: "Repair repository deploy keys",
+    summary: "Give the server read-only access to exactly the repository it must pull.",
+    keywords: "ssh key deploy key gitea permission server pull fingerprint authentication",
+    steps: [
+      "Run deployment preflight for the environment.",
+      "Use the offered deploy-key repair when repository access is missing.",
+      "ForgeFlow creates or reuses a repository-scoped key, registers the public key read-only in Gitea and verifies access from the server.",
+      "Re-run preflight and deploy only after the server can resolve and fetch the target commit.",
+    ],
+    note: "The private key remains on the configured server. ForgeFlow does not copy your personal Gitea token into deployment commands.",
+  },
+  {
+    id: "git-validator",
+    icon: "shield",
+    category: "Quality",
+    title: "Use Git Validator safely",
+    summary: "Find repository hygiene issues and apply only reviewed repairs.",
+    keywords: "validator hygiene gitignore readme license branch protection secrets large files fix repair",
+    steps: [
+      "Open a repository and choose Git Validator.",
+      "Select the policy that fits the repository and run a fresh scan.",
+      "Open each finding to understand its evidence and recommended repair.",
+      "Preview repairable findings before applying them, then rescan to verify the result.",
+    ],
+    note: "A score is guidance, not proof of correctness. Repairs that can alter repository policy or files always require an explicit action.",
+  },
+  {
+    id: "updates-diagnostics",
+    icon: "update",
+    category: "Maintenance",
+    title: "Update or troubleshoot ForgeFlow",
+    summary: "Install signed releases and collect useful diagnostics without exposing credentials.",
+    keywords: "update installer signed release diagnostics logs support error updater restart",
+    steps: [
+      "Open Settings and choose Check now under ForgeFlow updates.",
+      "Download the signed packaged release, then choose Apply & restart.",
+      "If an operation fails, open Diagnostics and run the troubleshooter.",
+      "Export a diagnostic bundle when deeper inspection is needed; tokens, passwords and private keys are redacted.",
+    ],
+    note: "Binary auto-update is available only from a packaged installation. Source checkouts continue to use the normal development workflow.",
+  },
+];
+
+function renderHelp() {
+  const query = String(ui.helpQuery || "").trim().toLowerCase();
+  const topics = HELP_TOPICS.filter((topic) =>
+    !query || `${topic.category} ${topic.title} ${topic.summary} ${topic.keywords} ${topic.steps.join(" ")} ${topic.note}`.toLowerCase().includes(query),
+  );
+  const categories = [...new Set(HELP_TOPICS.map((topic) => topic.category))];
+  const topicMarkup = topics.map((topic) => {
+    const isOpen = topic.id === ui.helpTopic || Boolean(query);
+    return `<details class="help-topic" data-help-topic="${attr(topic.id)}" ${isOpen ? "open" : ""}><summary><span class="help-topic-icon">${icon(topic.icon)}</span><span><small>${escapeHtml(topic.category)}</small><strong>${escapeHtml(topic.title)}</strong><span>${escapeHtml(topic.summary)}</span></span>${icon("chevron", "help-chevron")}</summary><div class="help-topic-body"><ol>${topic.steps.map((step) => `<li>${escapeHtml(step)}</li>`).join("")}</ol><div class="help-note">${icon("shield")}<span>${escapeHtml(topic.note)}</span></div></div></details>`;
+  }).join("");
+  return `<div class="page help-page"><header class="help-hero"><div><div class="eyebrow">ForgeFlow guide</div><h1>How can we help?</h1><p>Clear, practical instructions for repositories, Gitea synchronization, server deployments and maintenance.</p><label class="help-search">${icon("search")}<input id="help-search" value="${attr(ui.helpQuery)}" placeholder="Search sync, deploy keys, Git Validator…" aria-label="Search help"/><kbd>Ctrl F</kbd></label></div>${projectIllustration("flow")}</header><div class="help-layout"><aside class="help-navigation"><span class="eyebrow">Topics</span>${categories.map((category) => `<div class="help-category"><strong>${escapeHtml(category)}</strong>${HELP_TOPICS.filter((topic) => topic.category === category).map((topic) => `<button data-action="help-topic" data-topic="${attr(topic.id)}" class="${ui.helpTopic === topic.id ? "active" : ""}">${icon(topic.icon)}${escapeHtml(topic.title)}</button>`).join("")}</div>`).join("")}</aside><section class="help-results"><div class="help-results-header"><div><h2>${query ? `Search results` : "Everything you need to operate ForgeFlow"}</h2><span>${topics.length} topic${topics.length === 1 ? "" : "s"}${query ? ` matching “${escapeHtml(ui.helpQuery)}”` : ""}</span></div></div>${topicMarkup || `<div class="empty-state panel"><h3>No help topic found</h3><p>Try a broader term such as sync, deployment, keys, validator or update.</p><button class="button" data-action="clear-help-search">Clear search</button></div>`}</section></div></div>`;
+}
+
 function renderSettings() {
  const state = ui.boot.state;
  const prefs = state.preferences || {};
  const update = ui.updateStatus;
  const servers = state.servers || [];
  return `<div class="settings-layout"><aside class="settings-nav"><button class="nav-button active">${icon("settings")}<span>General</span></button><button class="nav-button" data-action="check-updates">${icon("update")}<span>Updates</span></button><button class="nav-button" data-action="open-add-server">${icon("server")}<span>Servers</span></button><button class="nav-button" data-action="reset-app">${icon("trash")}<span>Reset setup</span></button></aside><div class="settings-content"><div class="page-header"><div><div class="eyebrow">Application</div><h1>Settings</h1><p>Connections, project discovery, secure SSH servers and application updates.</p></div></div>
-    <section class="settings-group"><h2>Gitea connection</h2><div class="form-grid"><div class="field full"><label for="settings-gitea-url">Instance URL</label><input id="settings-gitea-url" class="input" value="${attr(state.gitea.baseUrl)}" placeholder="https://gitea.example.com" /></div><div class="field full"><label for="settings-gitea-token">New access token</label><input id="settings-gitea-token" class="input" type="password" placeholder="Leave empty to keep the existing token" /></div></div><div class="connection-card" style="margin-top:10px"><div><strong>${state.gitea.hasToken ? `Connected as ${escapeHtml(state.gitea.user?.login || "user")}` : "Not connected"}</strong><div class="queue-sub">${escapeHtml(state.gitea.baseUrl || "No Gitea instance configured")}</div></div><button class="button primary" data-action="save-gitea-settings">Validate & save</button></div></section>
-    <section class="settings-group"><div class="section-heading"><div><h2>ForgeFlow updates</h2><span class="meta">Secure source update from ${escapeHtml(state.updates?.owner || "Jens")}/${escapeHtml(state.updates?.repo || "ForgeFlow")}</span></div><button class="button" data-action="check-updates" ${ui.updateChecking ? "disabled" : ""}>${icon("update")}${ui.updateChecking ? "Checking…" : "Check now"}</button></div><div class="form-grid"><div class="field"><label>Repository owner</label><input id="update-owner" class="input" value="${attr(state.updates?.owner || "Jens")}"/></div><div class="field"><label>Repository name</label><input id="update-repo" class="input" value="${attr(state.updates?.repo || "ForgeFlow")}"/></div><div class="field"><label>Release branch</label><input id="update-branch" class="input" value="${attr(state.updates?.branch || "main")}"/></div><div class="field"><label>Automatic startup check</label><select id="update-auto-check" class="select"><option value="true" ${state.updates?.autoCheck !== false ? "selected" : ""}>Enabled</option><option value="false" ${state.updates?.autoCheck === false ? "selected" : ""}>Disabled</option></select></div></div><div class="update-card ${update?.available ? "available" : ""}"><div>${icon(update?.available ? "download" : "check")}<span><strong>${update ? (update.available ? `ForgeFlow ${escapeHtml(update.remoteVersion)} is available` : `ForgeFlow ${escapeHtml(update.currentVersion)} is up to date`) : `Current version ${escapeHtml(ui.boot.appVersion)}`}</strong><small>${update ? `Branch ${escapeHtml(update.branch)} · commit ${escapeHtml(update.shortSha)} · checked ${formatDate(update.checkedAt)}` : "No update check in this session."}</small></span></div><div class="stack horizontal compact">${update?.available && !update.downloaded ? `<button class="button primary" data-action="download-update">${icon("download")}Download update</button>` : ""}${update?.downloaded ? `<button class="button success" data-action="apply-update">${icon("update")}Apply & restart</button>` : ""}<button class="button" data-action="save-update-settings">Save update settings</button></div></div><div class="notice" style="margin-top:10px">${icon("shield")}The updater downloads an authenticated ZIP for the exact remote commit, verifies its SHA-256 checksum, runs the complete quality gate and restores the previous source version if validation fails.</div></section>
-    <section class="settings-group"><div class="section-heading"><div><h2>SSH / Unraid servers</h2><span class="meta">Credentials are entered locally and encrypted with the Windows credential protection used by Electron.</span></div><button class="button primary" data-action="open-add-server">${icon("plus")}Add server</button></div>${servers.length ? `<div class="server-list">${servers.map((server) => `<article class="server-card"><div class="server-card-main">${icon("server")}<div><strong>${escapeHtml(server.name)}</strong><span>${escapeHtml(server.username)}@${escapeHtml(server.host)}:${escapeHtml(server.port)} · ${escapeHtml(server.basePath)}</span><small>${server.hostFingerprint ? `Trusted ${escapeHtml(server.hostFingerprint)}` : "Host identity not trusted yet"}</small></div></div><div class="stack horizontal compact"><button class="button" data-action="test-server" data-server-id="${attr(server.id)}">Test & trust</button><button class="button" data-action="edit-server" data-server-id="${attr(server.id)}">Edit</button><button class="icon-button danger" data-action="delete-server" data-server-id="${attr(server.id)}" title="Delete server">${icon("trash")}</button></div></article>`).join("")}</div>` : '<div class="empty-state compact"><p>No SSH server configured. Add your Unraid server before creating an SSH deployment profile.</p></div>'}</section>
+    <section class="settings-group"><h2>Gitea connection</h2><div class="form-grid"><div class="field full"><label for="settings-gitea-url">Instance URL</label><input id="settings-gitea-url" class="input" value="${attr(state.gitea.baseUrl)}" placeholder="https://gitea.example.com" /></div><div class="field full"><label for="settings-gitea-token">New access token</label><input id="settings-gitea-token" class="input" type="password" placeholder="Leave empty only when keeping the same server" /></div></div><div class="connection-card" style="margin-top:10px"><div><strong>${state.gitea.hasToken ? `Connected as ${escapeHtml(state.gitea.user?.login || "user")}` : "Not connected"}</strong><div class="queue-sub">${escapeHtml(state.gitea.baseUrl || "No Gitea instance configured")}</div></div><button class="button primary" data-action="save-gitea-settings">Validate & save</button></div></section>
+    <section class="settings-group"><div class="section-heading"><div><h2>ForgeFlow updates</h2><span class="meta">Signed packaged updates from ${escapeHtml(state.updates?.owner || "Jens")}/${escapeHtml(state.updates?.repo || "ForgeFlow")}</span></div><button class="button" data-action="check-updates" ${ui.updateChecking ? "disabled" : ""}>${icon("update")}${ui.updateChecking ? "Checking…" : "Check now"}</button></div><div class="form-grid"><div class="field"><label>Repository owner</label><input id="update-owner" class="input" value="${attr(state.updates?.owner || "Jens")}"/></div><div class="field"><label>Repository name</label><input id="update-repo" class="input" value="${attr(state.updates?.repo || "ForgeFlow")}"/></div><div class="field"><label>Release branch</label><input id="update-branch" class="input" value="${attr(state.updates?.branch || "main")}"/></div><div class="field"><label>Automatic startup check</label><select id="update-auto-check" class="select"><option value="true" ${state.updates?.autoCheck !== false ? "selected" : ""}>Enabled</option><option value="false" ${state.updates?.autoCheck === false ? "selected" : ""}>Disabled</option></select></div></div><div class="update-card ${update?.available ? "available" : ""}"><div>${icon(update?.available ? "download" : "check")}<span><strong>${update ? (update.available ? `ForgeFlow ${escapeHtml(update.remoteVersion)} is available${update.packaged ? "" : " in the source repository"}` : `ForgeFlow ${escapeHtml(update.currentVersion)} is up to date`) : `Current version ${escapeHtml(ui.boot.appVersion)}`}</strong><small>${update ? `Branch ${escapeHtml(update.branch)} · commit ${escapeHtml(update.shortSha)} · checked ${formatDate(update.checkedAt)}` : "No update check in this session."}</small></span></div><div class="stack horizontal compact">${update?.available && update.packaged && !update.downloaded ? `<button class="button primary" data-action="download-update">${icon("download")}Download signed update</button>` : ""}${update?.downloaded ? `<button class="button success" data-action="apply-update">${icon("update")}Apply & restart</button>` : ""}<button class="button" data-action="save-update-settings">Save update settings</button></div></div><div class="notice" style="margin-top:10px">${icon("shield")}${update && !update.packaged ? "Source checkouts must be updated with Git after reviewing the exact commit. Integrated source replacement remains disabled until source archives are publisher-signed." : "Packaged updates require an Ed25519 publisher signature that binds the exact commit, artifact name, size and SHA-256 digest."}</div></section>
+    <section class="settings-group"><div class="section-heading"><div><h2>SSH / Unraid servers</h2><span class="meta">Credentials are encrypted locally; a new host fingerprint is shown before authentication.</span></div><button class="button primary" data-action="open-add-server">${icon("plus")}Add server</button></div>${servers.length ? `<div class="server-list">${servers.map((server) => `<article class="server-card"><div class="server-card-main">${icon("server")}<div><strong>${escapeHtml(server.name)}</strong><span>${escapeHtml(server.username)}@${escapeHtml(server.host)}:${escapeHtml(server.port)} · ${escapeHtml(server.basePath)}</span><small>${server.hostFingerprint ? `Trusted ${escapeHtml(server.hostFingerprint)}` : "Host identity not trusted yet"}</small></div></div><div class="stack horizontal compact"><button class="button" data-action="test-server" data-server-id="${attr(server.id)}">${server.hostFingerprint ? "Test connection" : "Preview & trust fingerprint"}</button><button class="button" data-action="edit-server" data-server-id="${attr(server.id)}">Edit</button><button class="icon-button danger" data-action="delete-server" data-server-id="${attr(server.id)}" title="Delete server">${icon("trash")}</button></div></article>`).join("")}</div>` : '<div class="empty-state compact"><p>No SSH server configured. Add your Unraid server before creating an SSH deployment profile.</p></div>'}</section>
    <section class="settings-group"><div class="section-heading"><div><h2>Git remote maintenance</h2><span class="meta">Standardize linked repositories to the current Gitea SSH URLs.</span></div><button class="button" data-action="normalize-origins">${icon("link")}Normalize all origins</button></div><p>This replaces legacy aliases and renamed owners only after an explicit click. Local commits and files are not changed.</p></section>
    <section class="settings-group"><h2>Project roots</h2><p>The first folder is the default clone destination. ForgeFlow automatically creates one subfolder per repository.</p><div class="stack">${state.workspaceRoots.map((root, index) => `<div class="root-row">${index === 0 ? '<span class="status-pill success">Default</span>' : ""}<input class="input" data-root-index="${index}" value="${attr(root)}" aria-label="Project root ${index + 1}"/><button class="icon-button" data-action="remove-root" data-index="${index}" title="Remove">${icon("trash")}</button></div>`).join("")}<button class="button" data-action="add-root">${icon("plus")}Add project root</button><button class="button primary" data-action="save-roots">Save folders & rescan</button></div></section>
-    <section class="settings-group"><h2>Background awareness</h2><div class="form-grid"><div class="field"><label>Automatic repository refresh</label><select id="pref-auto-refresh" class="select"><option value="true" ${prefs.autoRefresh !== false ? "selected" : ""}>Enabled</option><option value="false" ${prefs.autoRefresh === false ? "selected" : ""}>Disabled</option></select></div><div class="field"><label>Local poll interval</label><input id="pref-repo-poll" class="input" type="number" min="2" max="60" value="${attr(prefs.repositoryPollSeconds || 4)}"/></div><div class="field"><label>Actions poll interval</label><input id="pref-operation-poll" class="input" type="number" min="3" max="120" value="${attr(prefs.operationPollSeconds || 5)}"/></div><div class="field"><label>Preferred clone protocol</label><select id="pref-clone-protocol" class="select"><option value="https" ${prefs.preferredCloneProtocol !== "ssh" ? "selected" : ""}>HTTPS</option><option value="ssh" ${prefs.preferredCloneProtocol === "ssh" ? "selected" : ""}>SSH</option></select></div></div><button class="button primary" style="margin-top:12px" data-action="save-preferences">Save awareness settings</button></section>
+    <section class="settings-group"><h2>Background awareness</h2><div class="form-grid"><div class="field"><label>Automatic repository refresh</label><select id="pref-auto-refresh" class="select"><option value="true" ${prefs.autoRefresh !== false ? "selected" : ""}>Enabled</option><option value="false" ${prefs.autoRefresh === false ? "selected" : ""}>Disabled</option></select></div><div class="field"><label>Local poll interval</label><input id="pref-repo-poll" class="input" type="number" min="2" max="60" value="${attr(prefs.repositoryPollSeconds || 4)}"/></div><div class="field"><label>Gitea fetch interval (minutes)</label><input id="pref-fetch-interval" class="input" type="number" min="0" max="240" value="${attr(Number.isFinite(Number(prefs.fetchIntervalMinutes)) ? prefs.fetchIntervalMinutes : 10)}"/><small>Read-only remote awareness. Use 0 to disable; fetching never changes project files.</small></div><div class="field"><label>Actions poll interval</label><input id="pref-operation-poll" class="input" type="number" min="3" max="120" value="${attr(prefs.operationPollSeconds || 5)}"/></div><div class="field"><label>Preferred clone protocol</label><select id="pref-clone-protocol" class="select"><option value="https" ${prefs.preferredCloneProtocol !== "ssh" ? "selected" : ""}>HTTPS</option><option value="ssh" ${prefs.preferredCloneProtocol === "ssh" ? "selected" : ""}>SSH</option></select></div></div><div class="notice" style="margin-top:12px">${icon("shield")}Remote awareness only fetches branch metadata. ForgeFlow never resets, cleans or overwrites a workspace in the background.</div><button class="button primary" style="margin-top:12px" data-action="save-preferences">Save awareness settings</button></section>
    <section class="settings-group"><h2>Desktop integration</h2><div class="form-grid"><div class="field"><label>Editor executable</label><input id="pref-editor-executable" class="input" value="${attr(prefs.editor?.executable || "code")}"/></div><div class="field"><label>Editor arguments</label><input id="pref-editor-args" class="input" value="${attr((prefs.editor?.args || ["--reuse-window", "--goto", "{file}:{line}"]).join(" | "))}"/><small>Separate arguments with |. Placeholders: {path}, {file}, {line}</small></div><div class="field"><label>Terminal executable</label><input id="pref-terminal-executable" class="input" value="${attr(prefs.terminal?.executable || "wt.exe")}"/></div><div class="field"><label>Terminal arguments</label><input id="pref-terminal-args" class="input" value="${attr((prefs.terminal?.args || ["-d", "{path}"]).join(" | "))}"/></div><label class="check-field"><input id="pref-notifications" type="checkbox" ${prefs.notificationsEnabled !== false ? "checked" : ""}/><span>Native deployment notifications</span></label><label class="check-field"><input id="pref-tray" type="checkbox" ${prefs.trayEnabled !== false ? "checked" : ""}/><span>Show system tray icon</span></label><label class="check-field"><input id="pref-close-tray" type="checkbox" ${prefs.closeToTray === true ? "checked" : ""}/><span>Hide to tray when closing</span></label><label class="check-field"><input id="pref-login" type="checkbox" ${prefs.startAtLogin === true ? "checked" : ""}/><span>Start ForgeFlow at login</span></label></div><button class="button primary" data-action="save-desktop-preferences">Save desktop integration</button></section>
    <section class="settings-group"><h2>Encrypted configuration backup</h2><p>Repository mappings, servers, deployment profiles and preferences are encrypted. Tokens, passwords, passphrases and operation history are never exported.</p><div class="inline-form"><input id="backup-passphrase" class="input" type="password" minlength="12" placeholder="Passphrase of at least 12 characters"/><button class="button" data-action="export-config-backup">Export</button><button class="button" data-action="import-config-backup">Import</button></div></section>
    <section class="settings-group"><h2>Appearance</h2><div class="field"><label for="appearance-select">Color theme</label><select id="appearance-select" class="select"><option value="dark" ${state.appearance === "dark" ? "selected" : ""}>Dark</option><option value="light" ${state.appearance === "light" ? "selected" : ""}>Light</option><option value="system" ${state.appearance === "system" ? "selected" : ""}>Follow system</option></select></div></section>
@@ -632,6 +814,7 @@ function renderDiagnostics() {
    <section class="section-block"><div class="section-heading"><div><h2>One-click troubleshooter</h2><span class="meta">Git locks, interrupted operations, branch synchronization and deployment/server inconsistencies</span></div><div class="stack horizontal compact"><button class="button" data-action="run-troubleshooter">${icon("pulse")}Scan everything</button>${trouble?.issues?.some((item) => item.repairable && item.safe) ? `<button class="button primary" data-action="troubleshooter-auto-repair">${icon("wrench")}Repair ${trouble.issues.filter((item) => item.repairable && item.safe).length} safe issue(s)</button>` : ""}</div></div><div class="panel"><div class="preflight-summary">${trouble ? `<span class="status-pill ${trouble.summary.errors ? "danger" : trouble.summary.warnings ? "warning" : "success"}">${trouble.summary.total ? `${trouble.summary.total} issue(s)` : "Healthy"}</span><span>${trouble.summary.errors} errors · ${trouble.summary.warnings} warnings · ${trouble.summary.repairable} repairable</span>` : "<span>Run the troubleshooter to inspect all linked repositories and deployments.</span>"}</div>${troubleRows || '<div class="empty-state compact"><p>No problems detected.</p></div>'}</div></section>
    <section class="section-block"><div class="section-heading"><div><h2>System preflight</h2><span class="meta">Git, writable storage, credential protection, folders and Gitea</span></div><button class="button" data-action="run-system-preflight">${icon("shield")}Run checks</button></div><div class="panel"><div class="preflight-summary">${report ? `<span class="status-pill ${report.summary.ready ? "success" : "danger"}">${report.summary.ready ? "Ready" : `${report.summary.blocking.length} blocking`}</span><span>${report.summary.counts.pass} passed · ${report.summary.counts.warning} warnings · ${report.summary.counts.fail} failed</span>` : "<span>Not run in this session</span>"}</div>${renderPreflightChecks(report)}</div></section>
    <section class="section-block"><div class="section-heading"><div><h2>Export support bundle</h2><span class="meta">Configuration summary, repository states, operations, preflight and redacted JSONL logs</span></div></div><div class="panel panel-body"><div class="form-grid"><div class="field"><label>Privacy mode</label><select id="diagnostic-privacy" class="select"><option value="standard">Standard · preserve repository names</option><option value="strict">Strict · hash repository and user identifiers</option></select></div></div><div class="card-actions"><button class="button primary" data-action="export-diagnostics">${icon("archive")}Create diagnostic ZIP</button></div>${ui.lastDiagnosticBundle ? `<div class="notice success" style="margin-top:12px">${icon("check")}<div><strong>${escapeHtml(ui.lastDiagnosticBundle.size)} bundle created</strong><p class="mono">SHA-256 ${escapeHtml(ui.lastDiagnosticBundle.sha256)}</p><button class="button ghost" data-action="show-diagnostic-bundle">Show file</button></div></div>` : ""}</div></section>
+    <section class="section-block"><div class="section-heading"><div><h2>Operational audit log</h2><span class="meta">Append-only release, pull-request and recovery events</span></div><div class="stack horizontal compact"><button class="button" data-action="load-audit-log">Refresh</button><button class="button" data-action="export-audit-json">Export JSON</button><button class="button" data-action="export-audit-csv">Export CSV</button></div></div><div class="panel">${ui.auditEvents.length ? `<table class="data-table"><thead><tr><th>Time</th><th>Event</th><th>Repository</th><th>Result</th></tr></thead><tbody>${ui.auditEvents.map((item) => `<tr><td>${formatDate(item.timestamp)}</td><td>${escapeHtml(item.event)}</td><td>${escapeHtml(item.details?.repository || "—")}</td><td>${escapeHtml(item.details?.result || item.details?.note || "—")}</td></tr>`).join("")}</tbody></table>` : '<div class="empty-state compact"><p>Load the operational audit log.</p></div>'}</div></section>
  </div>`;
 }

@@ -5,7 +5,11 @@ const path = require('node:path');
 function cloneDirectoryName(remoteUrl) {
  const raw = String(remoteUrl || '').trim().replace(/[?#].*$/, '').replace(/[\\/]+$/, '');
  const segment = raw.split(/[\\/:]/).filter(Boolean).at(-1) || 'repository';
-  return segment.replace(/\.git$/i, '').replace(/[^a-zA-Z0-9._-]/g, '-') || 'repository';
+  const name = segment.replace(/\.git$/i, '').replace(/[^a-zA-Z0-9._-]/g, '-');
+  // A name made only of dots is not a usable directory. Windows strips trailing
+  // dots, so "..." would resolve back to the project root itself and slip past
+  // the escape check in resolveCloneTarget below.
+  return !name || /^\.+$/.test(name) ? 'repository' : name;
 }

 function resolveCloneTarget(workspaceRoot, remoteUrl) {
@@ -1,3 +1,4 @@
+const fs = require('node:fs');
 const path = require('node:path');

 function normalizeRelativePosixPath(value) {
@@ -19,11 +20,14 @@ function bashSyntaxCheckInvocation(root, scriptPath = 'examples/server/forgeflow
  if (typeof root !== 'string' || !root.trim()) {
    throw new Error('Project root is required for shell validation.');
  }
+  const relativeScriptPath = normalizeRelativePosixPath(scriptPath);
+  const scriptText = fs.readFileSync(path.join(root, ...relativeScriptPath.split('/')), 'utf8');
  return {
    command: 'bash',
-    args: ['-n', normalizeRelativePosixPath(scriptPath)],
+    args: ['-n'],
    options: {
      cwd: root,
+      input: scriptText.replace(/\r\n?/g, '\n'),
      encoding: 'utf8',
      windowsHide: true
    }
@@ -8,6 +8,10 @@ function normalizeBaseUrl(value) {
  const url = new URL(raw);
  if (!['http:', 'https:'].includes(url.protocol)) throw new Error('Only HTTP and HTTPS URLs are supported.');
  if (url.username || url.password) throw new Error('Do not include credentials in the Gitea URL.');
+  const loopback = new Set(['localhost', '127.0.0.1', '[::1]']);
+  if (url.protocol !== 'https:' && !loopback.has(url.hostname.toLowerCase())) {
+    throw new Error('Gitea must use HTTPS so access tokens are never sent over plaintext HTTP. Loopback HTTP is allowed for local development only.');
+  }
  url.hash = '';
  url.search = '';
  return url.toString().replace(/\/$/, '');
@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import test from 'node:test';
+
+const workflowUrl = new URL('../examples/gitea-actions/forgeflow-approved-deploy.yml', import.meta.url);
+const deployUrl = new URL('../examples/server/forgeflow-deploy', import.meta.url);
+
+
+test('central approved workflow transports signed target evidence only to the root-owned deploy wrapper', async () => {
+  const workflow = await readFile(workflowUrl, 'utf8');
+
+  for (const input of [
+    'repository',
+    'environment',
+    'commit_sha',
+    'request_id',
+    'approval_id',
+    'approval_fingerprint',
+    'evidence_issued_at',
+    'evidence_signature',
+  ]) {
+    assert.match(workflow, new RegExp(`\\b${input}:`));
+  }
+  assert.match(workflow, /\$\{\{ inputs\.repository \}\}/);
+  assert.doesNotMatch(workflow, /\$\{\{ gitea\.repository \}\}/);
+  assert.match(workflow, /FF_APPROVAL_ID.*FF_REQUEST_ID/s);
+  assert.match(workflow, /sudo \/usr\/local\/bin\/forgeflow-deploy/);
+  assert.doesNotMatch(workflow, /actions\/checkout/);
+  assert.doesNotMatch(workflow, /docker compose/);
+  assert.doesNotMatch(workflow, /git\s+-C/);
+});
+
+
+test('server wrapper verifies Ed25519 evidence before any live git or compose mutation', async () => {
+  const script = await readFile(deployUrl, 'utf8');
+  const verifyIndex = script.indexOf('openssl pkeyutl -verify');
+  const resetIndex = script.indexOf('git -C "$APP_DIR" reset --hard "$SHA"');
+  const composeIndex = script.indexOf('docker compose -f "$COMPOSE_FILE" up -d --build');
+
+  assert.ok(verifyIndex > 0, 'expected cryptographic verification');
+  assert.ok(resetIndex > verifyIndex, 'git reset must happen after evidence verification');
+  assert.ok(composeIndex > verifyIndex, 'compose mutation must happen after evidence verification');
+  assert.match(script, /EVIDENCE_PUBLIC_KEY_FILE="\/etc\/forgeflow\/evidence\.pub"/);
+  assert.match(script, /evidence_owner.*root/s);
+  assert.match(script, /8#022/);
+  assert.match(script, /EVIDENCE_ISSUED_AT >= now_epoch - 1800/);
+  assert.match(script, /"evidence_verified": \$EVIDENCE_VERIFIED/);
+  assert.match(script, /\(\( \$# == 3 \|\| \$# == 4 \|\| \$# == 8 \)\)/);
+});
+
+
+test('signed message fields match the AppOps evidence v1 contract and exclude runner-chosen workflow/ref', async () => {
+  const script = await readFile(deployUrl, 'utf8');
+  const marker = "printf 'forgeflow-evidence-v1\\n%s\\n%s\\n%s\\n%s\\n%s\\n%s\\n%s\\n'";
+  assert.ok(script.includes(marker));
+  assert.match(
+    script,
+    /"\$APPROVAL_ID"[\s\\]+"\$APPROVAL_FINGERPRINT"[\s\\]+"\$REPOSITORY"[\s\\]+"\$ENVIRONMENT"[\s\\]+"\$\{SHA,,\}"[\s\\]+"\$REQUEST_ID"[\s\\]+"\$EVIDENCE_ISSUED_AT"/s,
+  );
+  assert.doesNotMatch(script.slice(0, script.indexOf('APP_DIR=""')), /WORKFLOW|workflow|ref=/);
+});
@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import test from 'node:test';
+
+const deployUrl = new URL('../examples/server/forgeflow-deploy', import.meta.url);
+
+test('a signed approved request is consumed once before target selection or mutation', async () => {
+  const script = await readFile(deployUrl, 'utf8');
+  const verifyIndex = script.indexOf('openssl pkeyutl -verify');
+  const consumeIndex = script.indexOf('mkdir -m 0700 "$EVIDENCE_REPLAY_DIR/$APPROVAL_ID"');
+  const targetIndex = script.indexOf('APP_DIR=""');
+  const resetIndex = script.indexOf('git -C "$APP_DIR" reset --hard "$SHA"');
+
+  assert.ok(verifyIndex > 0);
+  assert.ok(consumeIndex > verifyIndex);
+  assert.ok(targetIndex > consumeIndex);
+  assert.ok(resetIndex > consumeIndex);
+  assert.match(script, /EVIDENCE_REPLAY_DIR="\/var\/lib\/forgeflow-status\/approved-requests"/);
+  assert.match(script, /install -d -o root -g root -m 0700 "\$EVIDENCE_REPLAY_DIR"/);
+  assert.match(script, /Approved deployment evidence was already consumed/);
+});
@@ -74,13 +74,16 @@ async function assertScrollableWhenOverflowing(page, selector) {
    return metrics.connected && metrics.clientHeight > 0;
  }).toBe(true);
  if (metrics.scrollHeight > metrics.clientHeight + 1) {
-    await target.evaluate((element) => { element.scrollTop = element.scrollHeight; });
-    await expect.poll(() => target.evaluate((element) => element.scrollTop)).toBeGreaterThan(0);
+    await expect.poll(() => target.evaluate((element) => {
+      if (element.scrollHeight <= element.clientHeight + 1) return 1;
+      element.scrollTop = element.scrollHeight;
+      return element.scrollTop;
+    })).toBeGreaterThan(0);
  }
 }
 test("shell, overview, repositories and settings remain responsive and accessible", async ({ page }, testInfo) => {
  await assertSurface(page);
-  for (const view of ["overview", "deployments", "settings"]) {
+  for (const view of ["overview", "deployments", "settings", "help"]) {
    await page.locator(`.nav-button[data-action="navigate"][data-view="${view}"]`).click();
    await expect(page.locator("main")).toBeVisible();
    await assertSurface(page);
@@ -113,10 +116,46 @@ test("repository changes, Git tools and Git Validator complete their primary flo
  await expect(page.locator(":focus")).toBeVisible();
 });

+test("repository context, tabs and content never overlap in a compact workspace", async ({ page }) => {
+  await page.setViewportSize({ width: 1024, height: 768 });
+  await page.locator('[data-action="select-repo"][data-deployment-count]:not([data-deployment-count="0"])').first().click();
+  await page.locator('[data-action="repo-tab"][data-tab="gittools"]').click();
+  const layout = await page.evaluate(() => {
+    const context = document.querySelector(".repo-context")?.getBoundingClientRect();
+    const tabs = document.querySelector(".tabs")?.getBoundingClientRect();
+    const content = document.querySelector(".repo-content")?.getBoundingClientRect();
+    return {
+      contextEndsBeforeTabs: Boolean(context && tabs && context.bottom <= tabs.top + 0.5),
+      tabsEndBeforeContent: Boolean(tabs && content && tabs.bottom <= content.top + 0.5),
+      horizontalTabFallback: Boolean(tabs && document.querySelector(".tabs").scrollWidth >= document.querySelector(".tabs").clientWidth),
+    };
+  });
+  expect(layout).toEqual({ contextEndsBeforeTabs: true, tabsEndBeforeContent: true, horizontalTabFallback: true });
+});
+
+test("Help center is searchable and contextual guidance opens the requested topic", async ({ page }) => {
+  await page.locator('.nav-button[data-view="help"]').click();
+  await expect(page.getByRole("heading", { name: "How can we help?" })).toBeVisible();
+  await expect(page.locator(".help-topic")).toHaveCount(8);
+  await page.locator("#help-search").fill("deploy key");
+  await expect(page.locator(".help-topic")).toHaveCount(1);
+  await expect(page.locator(".help-topic")).toContainText("Repair repository deploy keys");
+  await page.locator('[data-action="select-repo"]').first().click();
+  await page.locator('[data-action="repo-tab"][data-tab="gittools"]').click();
+  await page.locator('[data-action="open-context-help"][data-topic="workspace-sync"]').click();
+  await expect(page.locator('[data-help-topic="workspace-sync"]')).toHaveAttribute("open", "");
+  await expect(page.locator('[data-help-topic="workspace-sync"]')).toContainText("Make a local project match Gitea");
+  await assertSurface(page);
+});
+
 test("every long application surface retains a working vertical scroll owner", async ({ page }) => {
-  for (const view of ["overview", "deployments", "diagnostics", "settings"]) {
-    await page.locator(`.nav-button[data-view="${view}"]`).click();
-    await assertScrollableWhenOverflowing(page, ".main-canvas");
+  for (const view of ["overview", "deployments", "diagnostics", "settings", "help"]) {
+    await test.step(`${view} view scrolls`, async () => {
+      const navigation = page.locator(`.nav-button[data-view="${view}"]`);
+      await navigation.click();
+      await expect(navigation).toHaveClass(/active/);
+      await assertScrollableWhenOverflowing(page, ".main-canvas");
+    });
  }
  await page.locator('[data-action="select-repo"]').first().click();
  for (const tab of ["history", "deployments", "gittools", "validator", "settings"]) {
@@ -135,6 +174,19 @@ test("deployment inventory supports dense workloads without ambiguous blank card
  for (let index = 0; index < Math.min(count, 25); index += 1) {
    await expect(cards.nth(index)).not.toHaveText(/^\s*$/);
  }
+  const unresolved = page.locator(".tool-row", { hasText: "Legacy Worker" });
+  await expect(unresolved).toContainText("Link unresolved");
+  await expect(unresolved).not.toContainText(/^Linked$/);
+  await expect(page.locator(".server-inventory-panel").first()).toContainText("1 unresolved");
+  const repositoryLink = page.locator('[data-action="open-deployment-link"]');
+  if (await repositoryLink.count()) {
+    await repositoryLink.first().click();
+    await expect(page.locator('.repo-row.active')).toHaveAttribute("data-deployment-count", /^[1-9]/);
+    await expect(page.locator('.repo-row.active .deployment-badge')).toBeVisible();
+    await expect(page.locator('.tab[data-action="repo-tab"][data-tab="deployments"]')).toHaveClass(/active/);
+    await expect(page.locator(".repository-workloads")).toBeVisible();
+    await expect(page.locator(".repository-workload-row").first()).toContainText("Repository linked");
+  }
  await assertSurface(page);
 });

@@ -195,3 +247,116 @@ test("inventory, deployment safety and failure evidence dialogs are reviewable",
  }
  await assertSurface(page);
 });
+
+// A repository or deployment poll renders the whole shell again. Changing an
+// unrelated part of the state is what a poll effectively does, and it must not
+// take the caret or the scroll position away from the user.
+async function forceUnrelatedRerender(page) {
+  await page.evaluate(() => {
+    ui.diagnosticsStatus = { ...(ui.diagnosticsStatus || {}), enabled: !(ui.diagnosticsStatus?.enabled === false) };
+    render();
+  });
+}
+
+test("a background refresh keeps typing and caret position intact", async ({ page }) => {
+  const search = page.locator("#global-search");
+  await search.click();
+  await search.fill("Forge");
+  // Typing schedules a debounced render. Wait for it, otherwise the caret below
+  // can land on the element that render is about to replace.
+  await expect.poll(() => page.evaluate(() => ui.inputRenderTimer === null)).toBe(true);
+  await search.evaluate((element) => element.setSelectionRange(1, 3));
+
+  await forceUnrelatedRerender(page);
+
+  await expect(search).toBeFocused();
+  expect(await search.inputValue()).toBe("Forge");
+  expect(await search.evaluate((element) => [element.selectionStart, element.selectionEnd])).toEqual([1, 3]);
+});
+
+test("a background refresh keeps scroll offsets intact", async ({ page }) => {
+  await page.locator('.nav-button[data-action="navigate"][data-view="settings"]').click();
+  const canvas = page.locator(".main-canvas");
+  const scrolled = await canvas.evaluate((element) => {
+    element.scrollTop = Math.min(120, Math.max(0, element.scrollHeight - element.clientHeight));
+    return element.scrollTop;
+  });
+  expect(scrolled).toBeGreaterThan(0);
+
+  await forceUnrelatedRerender(page);
+
+  expect(await canvas.evaluate((element) => element.scrollTop)).toBe(scrolled);
+});
+
+test("sections that used to be injected after render are part of the rendered markup", async ({ page }) => {
+  await page.locator('.nav-button[data-action="navigate"][data-view="diagnostics"]').click();
+  const auditPanel = page.locator(".diagnostics-page .section-block", { hasText: "Operational audit log" });
+  await expect(auditPanel).toBeVisible();
+  await expect(auditPanel).toContainText("Load the operational audit log");
+
+  // The audit rows are state the shell renders itself now, so a plain render has
+  // to pick them up without any post-render injection step.
+  await page.evaluate(() => {
+    ui.auditEvents = [{ timestamp: new Date().toISOString(), event: "deployment.requested", details: { repository: "Jens/Probe", result: "queued" } }];
+    render();
+  });
+  await expect(auditPanel.locator("table.data-table")).toContainText("Jens/Probe");
+  await expect(auditPanel.locator("table.data-table")).toContainText("deployment.requested");
+});
+
+test("a very large diff is capped instead of freezing the window", async ({ page }) => {
+  const selected = await page.evaluate(() => {
+    const withChanges = ui.repositories.find((repository) => repository.localStatus?.counts?.changed);
+    if (!withChanges) return null;
+    selectRepository(withChanges.id);
+    return withChanges.fullName;
+  });
+  expect(selected, "the demo needs a repository with local changes").not.toBeNull();
+  await expect(page.locator(".diff-view")).toBeVisible();
+  // Selecting a repository loads its diff asynchronously; that load would
+  // otherwise overwrite the diff injected below.
+  await expect.poll(() => page.evaluate(() => Boolean(ui.diff) && !ui.diff.startsWith("Loading"))).toBe(true);
+
+  const measured = await page.evaluate(() => {
+    const newline = String.fromCharCode(10);
+    const lines = ["diff --git a/package-lock.json b/package-lock.json"];
+    for (let index = 0; index < 40_000; index += 1) lines.push(`+  "package-${index}": "^1.2.3",`);
+    ui.diff = lines.join(newline);
+    ui.repositoryTab = "changes";
+    const started = performance.now();
+    render();
+    return {
+      renderMs: performance.now() - started,
+      rendered: document.querySelectorAll(".diff-line").length,
+      storedLines: ui.diff.split(newline).length,
+    };
+  });
+
+  expect(measured.storedLines).toBe(40_001);
+  expect(measured.rendered).toBeLessThan(2100);
+  expect(measured.renderMs).toBeLessThan(3000);
+  await expect(page.locator(".diff-view")).toContainText("more lines are not shown");
+});
+
+test("an unchanged render leaves the existing DOM in place", async ({ page }) => {
+  await page.locator('[data-action="select-repo"]').first().click();
+  const marked = await page.evaluate(() => {
+    // Relative timestamps ("just now" turning into "1m ago") and pending async
+    // state legitimately change the markup between two renders that are seconds
+    // apart. Rendering twice inside one synchronous block removes that window,
+    // so the second render can only be skipped because nothing changed.
+    render();
+    document.querySelector(".repo-list").dataset.renderProbe = "kept";
+    render();
+    return document.querySelector(".repo-list")?.dataset.renderProbe || null;
+  });
+  expect(marked).toBe("kept");
+
+  const replaced = await page.evaluate(() => {
+    document.querySelector(".repo-list").dataset.renderProbe = "kept";
+    ui.repoSearch = `probe-${Date.now()}`;
+    render();
+    return document.querySelector(".repo-list")?.dataset.renderProbe || null;
+  });
+  expect(replaced).toBe(null);
+});
@@ -26,6 +26,35 @@ test('resolves the automatic clone target inside the configured project root', (
  assert.equal(plan.directoryName, 'portfolio');
 });

+test('a clone target that would leave the project root is refused', () => {
+  const root = path.join(os.tmpdir(), 'forgeflow-projects');
+  const resolved = path.resolve(root);
+
+  // The escape guard inside resolveCloneTarget stays as a backstop, but no
+  // sanitised folder name can reach it any more: the name is a single path
+  // segment and a dots-only segment falls back to "repository".
+  for (const remote of ['..', '.', '../escape', '/', '', '....git', 'https://gitea.example.test/jens/....git']) {
+    const plan = resolveCloneTarget(root, remote);
+    assert.ok(
+      plan.target.startsWith(`${resolved}${path.sep}`) && plan.target !== resolved,
+      `${remote} resolved outside the project root: ${plan.target}`,
+    );
+  }
+  for (const badRoot of ['', '   ', null, undefined]) {
+    assert.throws(() => resolveCloneTarget(badRoot, 'https://gitea.example.test/jens/app.git'), /project root is required/);
+  }
+});
+
+test('a folder name that sanitises away still produces a usable directory', () => {
+  // Windows strips trailing dots, so a dots-only name would land on the project
+  // root itself instead of a subdirectory.
+  assert.equal(cloneDirectoryName('https://gitea.example.test/jens/....git'), 'repository');
+  assert.equal(cloneDirectoryName('..'), 'repository');
+  assert.equal(cloneDirectoryName(''), 'repository');
+  assert.equal(cloneDirectoryName('https://gitea.example.test/jens/app.git#readme'), 'app');
+  assert.equal(cloneDirectoryName('https://gitea.example.test/jens/spaced name.git'), 'spaced-name');
+});
+
 test('clone target inspection accepts missing and empty destinations', async (t) => {
  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'forgeflow-clone-target-'));
  t.after(() => fs.rm(root, { recursive: true, force: true }));
@@ -110,6 +110,8 @@ test("configuration mutations persist mappings, favorites, reviews, trends, oper
  assert.equal(state.preferences.preferredCloneProtocol, "https");
  assert.equal(state.preferences.diagnosticLevel, "info");
  assert.equal(state.preferences.maxLogFileMb, 50);
+  const manualRemoteAwareness = await store.setPreferences({ fetchIntervalMinutes: 0 });
+  assert.equal(manualRemoteAwareness.preferences.fetchIntervalMinutes, 0);
  await store.removeMapping("owner/app");
  assert.equal(store.data.repositoryMappings["owner/app"], undefined);
 });
@@ -191,7 +193,11 @@ test("setup, Gitea updates and generic patches retain normalized public state",
  assert.equal(completed.state.setupComplete, true);
  assert.equal(completed.state.gitea.hasToken, true);
  assert.deepEqual(completed.state.workspaceRoots, ["C:/Projects"]);
-  const update = await store.updateGitea({ baseUrl: "https://new.test", token: "", user: null });
+  await assert.rejects(
+    store.updateGitea({ baseUrl: "https://new.test", token: "", user: null }),
+    (error) => error.code === "GITEA_TOKEN_ORIGIN_CHANGED"
+  );
+  const update = await store.updateGitea({ baseUrl: "https://gitea.test", token: "", user: null });
  assert.equal(update.preserved, true);
  assert.equal(store.data.gitea.user.login, "jens");
  const patched = await store.patch({ appearance: "light", workspaceRoots: ["D:/Code", "D:/Code"] });
@@ -213,6 +219,20 @@ test("server saves reject absent credentials before mutating configuration", asy
  assert.deepEqual(store.data.servers, []);
 });

+test("server credentials and trust are cleared when the connection identity changes", async (t) => {
+  const { store } = await storeFixture(t);
+  store.encryptSecret = (value) => `encrypted:${value}`;
+  const saved = await store.saveServer({ host: "server-one", username: "deploy", authType: "password", basePath: "/mnt/apps", hostFingerprint: "SHA256:trusted" }, { password: "test-password" });
+  await assert.rejects(
+    store.saveServer({ ...saved, host: "server-two" }, {}),
+    /password is required/i
+  );
+  assert.equal(store.data.servers[0].host, "server-one");
+  const changed = await store.saveServer({ ...saved, host: "server-two" }, { password: "replacement-password" });
+  assert.equal(changed.hostFingerprint, "");
+  assert.equal(changed.hasPassword, true);
+});
+
 test("deployment profile normalization covers safe defaults and every optional Unraid control", async (t) => {
  const { store } = await storeFixture(t);
  const actions = store.normalizeDeploymentProfile({ environment: "qa", statusUrl: "https://app.test/status" });
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jens	941f2d9aa0	Merge pull request 'ci: route validation to available runners' (#12 ) from codex/runner-fast-path-20260903 into main Fix ForgeFlow runner label mismatch. [skip ci]	2026-09-03 18:58:57 +00:00
Jens	57914f1c79	ci: target the hardened native Windows runner Managed validation / full (pull_request) Successful in 23s Details ChatGPT validation / quality (push) Successful in 5m30s Details	2026-09-03 18:47:56 +00:00
Jens	3dd301a3cb	ci: add lightweight validation fast path ChatGPT validation / quality (push) Successful in 12s Details	2026-09-03 00:28:43 +00:00
Jens	e2293f08d9	Merge pull request 'hygiene: prepare public release' (#11 ) from chore/public-release-hygiene-20260902 into main ForgeFlow quality gate / quality (push) Successful in 9m3s Details ForgeFlow quality gate / secret-scan (push) Successful in 18s Details ChatGPT validation / quality (push) Successful in 5m42s Details	2026-09-02 21:44:29 +00:00
NuklearRabbit	dec3b79793	hygiene: prepare ForgeFlow for public release Managed validation / full (pull_request) Successful in 27s Details	2026-09-02 23:37:30 +02:00
Jens	0a8a10df1b	Merge pull request 'Prepare ForgeFlow for public release' (#10 ) from codex/public-readiness-forgeflow into main ForgeFlow quality gate / secret-scan (push) Successful in 16s Details ForgeFlow quality gate / quality (push) Successful in 5m43s Details ForgeFlow signed release / release (push) Failing after 15s Details	2026-08-31 20:17:56 +02:00
NuklearRabbit	b5d615d53d	Avoid Electron initialization in plain Node tests Managed validation / full (pull_request) Successful in 27s Details ChatGPT validation / quality (push) Successful in 4m57s Details	2026-08-31 20:15:31 +02:00
NuklearRabbit	8cca1bfc01	Prepare ForgeFlow for public release Managed validation / full (pull_request) Successful in 44s Details ChatGPT validation / quality (push) Failing after 2m28s Details	2026-08-31 20:10:07 +02:00
NuklearRabbit	57929ea973	Merge remote-tracking branch 'origin/codex/portfolio-integration-fabric-20260826'	2026-08-31 07:52:36 +02:00
NuklearRabbit	5ddb6fe8f5	Merge remote-tracking branch 'origin/chatgpt/repo-hygiene-forgeflow' # Conflicts: # SECURITY.md	2026-08-31 07:52:31 +02:00
NuklearRabbit	20290e65c8	Merge remote-tracking branch 'origin/chatgpt/release-hygiene-20260830'	2026-08-31 07:52:06 +02:00
NuklearRabbit	e6e4f2ecf5	Merge branch 'codex/fix-release-0.10.15-metadata'	2026-08-31 07:52:01 +02:00
Jens	6fd69a2cd8	Add contribution and release hygiene guidance Managed validation / full (pull_request) Successful in 25s Details	2026-08-31 01:40:57 +02:00
Jens	976a1fc0df	Add top-level security entry point	2026-08-31 01:40:49 +02:00
Jens	0bbfbbad51	Harden local secret and workspace ignores	2026-08-31 01:40:41 +02:00
Jens	b486285027	docs: add top-level security entry point	2026-08-30 23:17:57 +02:00
Jens	060171d714	docs: align readme with ForgeFlow 0.10.15	2026-08-30 23:17:50 +02:00
Jens	b454bafec3	ci: avoid corrupt GitHub action cache on release runner	2026-08-30 23:17:17 +02:00
Jens	e62a1d8c1b	ci: use Gitea action mirrors on native runner	2026-08-30 23:16:59 +02:00
NuklearRabbit	0191af2ed8	fix(release): align 0.10.15 package metadata	2026-08-30 01:01:20 +02:00
Jens	b883c1ad83	Release ForgeFlow 0.10.15 (#7 ) ForgeFlow quality gate / quality (push) Failing after 5s Details ForgeFlow signed release / release (push) Failing after 6s Details ForgeFlow quality gate / secret-scan (push) Successful in 7s Details	2026-08-30 00:49:45 +02:00
Jens	a93231d69f	Harden workspace sync quarantine and updater recovery (#6 ) ForgeFlow quality gate / secret-scan (push) Successful in 8s Details ForgeFlow quality gate / quality (push) Failing after 11m39s Details	2026-08-30 00:34:02 +02:00
Jens	d926007dae	Merge pull request 'fix(ci): normalize shell validation input (fixes #3 )' (#5 ) from codex/resolve-open-issues into main ForgeFlow quality gate / quality (push) Successful in 8m40s Details ForgeFlow quality gate / secret-scan (push) Successful in 5s Details Reviewed-on: #5	2026-08-29 04:10:28 +02:00
NuklearRabbit	4b4718d231	fix(ci): preserve workflow line endings Managed validation / full (pull_request) Successful in 36s Details	2026-08-29 03:36:34 +02:00
NuklearRabbit	0b8deed1e3	fix(ci): use one required pull-request gate Managed validation / full (pull_request) Canceled after 0s Details	2026-08-29 03:35:32 +02:00
NuklearRabbit	408dea0c2d	fix(ci): normalize shell validation input (fixes #3 ) ForgeFlow quality gate / quality (pull_request) Successful in 7m26s Details Managed validation / full (pull_request) Canceled after 0s Details ForgeFlow quality gate / secret-scan (pull_request) Successful in 6s Details	2026-08-29 02:30:19 +02:00
Jens	79dc6d367b	Fix ForgeFlow Windows quality reliability (#4 ) ForgeFlow quality gate / quality (push) Successful in 6m28s Details ForgeFlow quality gate / secret-scan (push) Successful in 6s Details	2026-08-29 01:41:46 +02:00
Jens	49f43b3875	ci: run browser quality on native Windows (#2 ) ForgeFlow quality gate / quality (push) Failing after 2m35s Details ForgeFlow quality gate / secret-scan (push) Successful in 19s Details	2026-08-27 20:27:52 +02:00
Jens	736944bd91	ci: align managed validation contract [skip ci]	2026-08-27 07:40:29 +02:00
Jens	42ccfc781c	ci: add managed validation contract [skip ci]	2026-08-27 06:27:39 +02:00
Jens	2abfca7abc	[skip ci] Stop unschedulable Windows Actions jobs	2026-08-27 05:21:42 +02:00
NuklearRabbit	e882656e85	feat: add contextual help and stabilize repository layout ForgeFlow quality gate / secret-scan (push) Failing after 28s Details ForgeFlow quality gate / quality (push) Failing after 0s Details	2026-08-27 01:19:36 +02:00
NuklearRabbit	d47c7b5e41	feat: add safe Gitea sync and signed updates ForgeFlow quality gate / secret-scan (push) Failing after 32s Details ForgeFlow quality gate / quality (push) Failing after 0s Details	2026-08-27 00:38:58 +02:00
Jens	ff1fcd3303	test(deploy): lock one-shot approved request semantics ChatGPT validation / quality (push) Failing after 1s Details	2026-08-26 23:56:35 +02:00
Jens	e377889263	fix(deploy): consume signed approval evidence exactly once ChatGPT validation / quality (push) Failing after 0s Details	2026-08-26 23:55:49 +02:00
Jens	c5cf384f9a	test(deploy): prove central workflow carries signed target ChatGPT validation / quality (push) Failing after 0s Details	2026-08-26 23:47:20 +02:00
Jens	84ed89bccf	fix(deploy): centralize approved workflow dispatch ChatGPT validation / quality (push) Failing after 0s Details	2026-08-26 23:46:49 +02:00
Jens	2174b79544	ci: run managed validation on codex change branches ChatGPT validation / quality (push) Canceled after 0s Details	2026-08-26 23:26:16 +02:00
Jens	1dc3bea8dd	ci: add managed exact-head validation gate	2026-08-26 23:25:51 +02:00
Jens	858b09afeb	docs(deploy): include signed approval evidence in status example	2026-08-26 23:23:40 +02:00
Jens	b5b6660fdc	test(deploy): lock signed AppOps evidence contract	2026-08-26 23:21:44 +02:00
Jens	d1f4cb6ba8	feat(deploy): verify AppOps Ed25519 evidence before machine deploy	2026-08-26 23:20:26 +02:00
Jens	181330b78f	feat(deploy): add signed AppOps-approved workflow	2026-08-26 23:19:45 +02:00
NuklearRabbitandClaude Opus 5	cb9bdcd713	perf: reuse SSH connections per server, with a retry rule that never repeats work Every ssh.exec opened its own connection: a TCP handshake, a key exchange and an authentication round trip per command. A key rotation paid for that eight times, a deployment six, and refreshing M profile states M times. Connections are now kept per server. The three risks that made this worth doing carefully are handled explicitly: - Staleness. A pooled connection can be dead exactly when it matters. Liveness is tracked through error, close and end, and a lease that finds a dead entry opens a new one. The remaining race, where the connection dies between the check and the command, is caught by the retry rule below. - Retrying. Only a failure that proves the command never reached the server is retried, and only once, and only on a connection that was already established before this call. execClient marks exactly that case, when the channel fails to open. A command that opened a stream is never repeated, because the server may already be acting on it - repeating a deployment is not this layer's decision. Two tests hold that line: widening the rule to any failure fails both. - Lifetime. Idle connections close after a minute, the pool is reference counted so a shared connection survives until its last user is done, closeAll runs during quit, and every pooled client keeps a standing error listener so an error while idle cannot reach the uncaughtException handler. A trust-on-first-use connection is never pooled: it was established without verifying the fingerprint, so it must not serve a later verified call. A change to host, port, user, auth type, key path or trusted fingerprint invalidates the pooled connection. ssh-service coverage rises from 61% to 90% of lines and 97% of functions. Also in this commit, the smaller items from the same review: - Diagnostics batched records that queue up while a write is in flight into one append, and chmod runs once per file instead of once per record. At the debug level every IPC call writes a line, which is exactly when troubleshooting. - The set that suppresses duplicate deployment notifications is trimmed instead of growing for the lifetime of the process. - The updater kept the same once('error') pattern on its spawned helper that took the app down through the SSH client. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-23 15:06:38 +02:00
NuklearRabbitandClaude Opus 5	beeafdcba7	perf: reuse a deploy-key proof instead of asking the server twice A key rotation verified the candidate with `git ls-remote`, then immediately ran preflightCandidate, which threw that result away and ran the same command over a second SSH connection. Nothing happens between the two calls that could change the answer, and the proof was already being passed in. preflightCandidate now uses a proof that established a remote commit and falls back to verifying when it is handed nothing usable, so it still works as a standalone gate. Every ssh.exec opens its own connection, so this removes a full TCP, key exchange and authentication round trip from a rotation. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-23 14:53:53 +02:00
NuklearRabbitandClaude Opus 5	d77643c058	refactor(renderer): move diff rendering into its own module views.js sat at the project's 750-line limit, so the diff cap in the previous commit pushed it over and every further change would have meant shaving comments elsewhere. That is the file asking for decomposition, which is what the architecture audit says to do. Diff rendering is self-contained: the line cap, the line classifier and the change-map illustration depend on nothing in views.js beyond ui and escapeHtml. They now live in src/renderer/diff-view.js and are registered in index.html and in the three renderer file lists that scan the bridge surface, so anything added there is covered by the existing contract tests. views.js drops from 755 to 714 lines and no source file exceeds 750 again. The nested ternary that classified a diff line became a named function with guard clauses on the way. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-23 14:51:31 +02:00
NuklearRabbitandClaude Opus 5	5cecaa080d	fix: stop a large diff and a second SSH error from taking the app down Two failure modes that only show up under conditions the tests never reached. renderDiff built one span per diff line with no bound. A regenerated lock file is an ordinary change: 50,000 lines produce 4 MB of markup and 50,000 elements that then have to be parsed and laid out inside the full shell replacement, and 200,000 lines produce 16 MB. The rendered view now stops at 2,000 lines and says how many were left out; ui.diff keeps the whole change, so Copy diff, the editor and hunk staging are unaffected. The line scan also runs once now instead of three times. withClient registered the connection error handler with once(). A connection that fails and then emits a second error while it is being torn down - a reset during client.end() is the ordinary case - leaves that event unhandled, and an unhandled 'error' on an EventEmitter reaches the uncaughtException handler, which calls app.exit(1). The handler stays attached and ignores anything after the first failure. Both are covered by tests that were confirmed to fail without the fix, together with the SSH paths that had none: host key mismatch reporting, the trusted fingerprint requirement for exec and upload, and remote upload path validation. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-23 14:44:33 +02:00
NuklearRabbitandClaude Opus 5	a5666e95f2	test: cover the deployment and deploy-key paths, and gate coverage per module deployment-service.cjs sat at 52% and unraid-deploy-key-host.cjs at 39% of its functions, both hidden behind a healthy aggregate. They are now at 100% lines and functions, tested through real HTTP endpoints and by intercepting the shell script the key host sends, rather than by mocking the boundary away. What is pinned down: a successful workflow run still fails when the server cannot prove it runs that exact commit; a rollback ends as rolled-back rather than success; an unreachable status endpoint is never treated as healthy; a failed poll is recorded on the operation instead of losing it; deploy keys stay repository-scoped under the server base path with a pinned host key; promotion verifies the candidate before swapping atomically; and revocation moves key material to recovery instead of deleting it. Two assumptions turned out to be wrong and the tests follow the real behaviour: the previous-SHA check runs before the already-live check, and a rollback against an unreachable endpoint surfaces the underlying network error. Covering clone-target exposed a real defect: a remote ending in "....git" yielded the folder name "...". Windows strips trailing dots, so that resolves back to the project root itself, past an escape guard that only looks for "..". A dots-only name now falls back to "repository", consistent with how an empty name was already handled. As a side effect "." and ".." resolve to a usable folder instead of raising an error. Coverage gates: the aggregate moves to 85/85/68, and a new per-module gate (60 statements, 50 functions, 36 branches) stops a single module from silently collapsing behind the total. It reuses the data from the first run, so the suite is not executed twice. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-23 14:32:12 +02:00
NuklearRabbitandClaude Opus 5	9260d35957	fix: repair broken IPC wiring and cut the cost of repository polling Three handlers referenced a dependency they were never given, which made them throw a ReferenceError as soon as they ran: - deployment:preflight for Gitea Actions profiles (`preflight` was passed to registerOperationsIpc but not to registerDeploymentIpc) - Unraid write-access repair (`safeRelativeRemoteFile` was missing from createUnraidAccessMethods) - a dead reference of the same name in unraid-state-methods no-undef and no-unused-vars were disabled for every file, which is why none of these were caught. Both are now enabled for src/main and src/shared, where the dependency graph is explicit. The renderer keeps them off because its functions are deliberately cross-script globals. Performance: - git.status() spawned three processes (rev-parse, status, remote get-url) per call. A directory holding its own .git is by definition the work tree root, so rev-parse is unnecessary, and the remote URL is cached against the mtime of .git/config, including the failure for a repository without that remote. - git status runs with --no-optional-locks so a read no longer rewrites the index. That stops it fighting a concurrent Git command for the index lock, and is what makes filesystem watching viable at all. - One commit issued four `git status` reads; callers that already hold the status now pass it on, leaving two. - The repository monitor is event driven. A watched repository is read on filesystem activity, with a 30s safety net for watchers that stop delivering and a 1s floor so a busy tree cannot drive a read per event. Repositories that cannot be watched keep using the interval. Idle cost for one repository over 35s: 24 git processes before, 3 after. - Resolving one repository by name no longer refreshes the whole workspace. - Concurrent configuration saves share a single write of the latest state. - Repository discovery follows directory junctions again. The filter that skipped them made the realpath cycle guard dead code, and hid any project folder reached through a junction. Renderer: - render() replaced the whole shell on every poll, discarding focus, caret and scroll position while the user was typing. Those are preserved now, and an unchanged render leaves the DOM alone entirely. - The four sections that enhanceRenderedUi() injected after render moved into the views, so the rendered markup is the single source of truth. - The monitor no longer keeps a repository paused forever when it is unlinked mid-mutation, scheduleAutoRefresh honours its delay argument, the demo bridges no longer block startup, and #app is no longer an aria-live region announcing the entire UI on every render. IPC channel plumbing moved to src/main/ipc/channel.cjs, replacing a module-level mutable diagnostics singleton with an argument. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-23 14:31:58 +02:00
NuklearRabbit	cf1da8a2fa	fix(security): add standalone secret-scan job to CI Had a real dependency-audit gate (npm audit --audit-level=high) but no secret scan. trufflehog's Action is Docker-based and cannot run on this repo's existing windows-latest runner (needed for the Windows desktop app's own browser/quality tests), so this adds it as a separate, parallel ubuntu-latest job rather than inserting it into the Windows job where it would break CI - the last gap for this repo to count as fully-authored.	2026-08-16 14:56:13 +02:00
NuklearRabbit	32ed4fcb5e	perf: streamline repository and deployment awareness ForgeFlow quality gate / quality (push) Canceled after 0s Details	2026-08-12 15:26:53 +02:00
NuklearRabbit	38e221cbd1	fix: harden repository refresh and server pull ForgeFlow quality gate / quality (push) Canceled after 0s Details	2026-08-12 15:05:57 +02:00
NuklearRabbit	bffad670ef	fix: complete server pull deployment setup ForgeFlow quality gate / quality (push) Canceled after 0s Details	2026-08-09 00:43:08 +02:00
NuklearRabbit	4c21616e72	fix: harden deployment discovery and preflight ForgeFlow quality gate / quality (push) Canceled after 0s Details	2026-08-08 23:59:27 +02:00
NuklearRabbit	f866b12fbf	fix: make updater checksum verification self-contained ForgeFlow quality gate / quality (push) Canceled after 0s Details	2026-08-01 19:13:05 +02:00
NuklearRabbit	f7d6bc374f	fix: reconcile server deployments across repository views ForgeFlow quality gate / quality (push) Canceled after 0s Details	2026-08-01 18:57:55 +02:00
NuklearRabbit	958d5b84d3	fix: make Windows updater helper launch reliable ForgeFlow quality gate / quality (push) Canceled after 0s Details	2026-08-01 17:59:55 +02:00
NuklearRabbit	8fa4891075	chore: release ForgeFlow 0.10.5 ForgeFlow quality gate / quality (push) Canceled after 0s Details	2026-08-01 17:32:40 +02:00
NuklearRabbit	58d361bbab	fix: align deployment links across repository views ForgeFlow quality gate / quality (push) Canceled after 0s Details	2026-08-01 17:05:03 +02:00
NuklearRabbit	acad1f8932	fix: make packaged updater handshake Windows-safe ForgeFlow quality gate / quality (push) Canceled after 0s Details	2026-08-01 15:09:47 +02:00