diff --git a/.claude/launch.json b/.claude/launch.json
index b45d1008..57dcd873 100644
--- a/.claude/launch.json
+++ b/.claude/launch.json
@@ -7,6 +7,12 @@
       "runtimeArgs": ["tauri-app/src-ui/node_modules/vite/bin/vite.js", "tauri-app/src-ui", "--config", "tauri-app/src-ui/vite.config.ts", "--port", "1420", "--strictPort"],
       "port": 1420
     },
+    {
+      "name": "hive-app-ui",
+      "runtimeExecutable": "python",
+      "runtimeArgs": ["-m", "http.server", "4173", "--directory", "hive-app/dist"],
+      "port": 4173
+    },
     {
       "name": "hive-daemon",
       "runtimeExecutable": "cargo",
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ee5f02bd..c44d9bc6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -50,6 +50,25 @@ jobs:
       - name: Install frontend dependencies
         run: cd tauri-app/src-ui && npm ci
 
+      - name: Verify unsigned stabilization lane
+        run: node scripts/check_unsigned_stabilization.mjs
+
+      - name: Check Hive and Runtime apps
+        run: cargo check -p abigail-hive-app -p abigail-entity-runtime-app
+
+      - name: Run Hive daemon contract tests
+        run: cargo test -p hive-daemon --test integration
+        env:
+          ABIGAIL_DAEMON_INTEGRATION: "1"
+
+      - name: Build daemon binaries for integration tests
+        run: cargo build -p hive-daemon -p entity-daemon
+
+      - name: Run Entity runtime contract tests
+        run: cargo test -p entity-daemon --test integration
+        env:
+          ABIGAIL_DAEMON_INTEGRATION: "1"
+
       - name: Run stability gates
         run: node scripts/check_stability.mjs
 
@@ -192,7 +211,7 @@ jobs:
         run: cargo install cargo-audit --locked
 
       - name: Cargo audit
-        run: cargo audit --ignore RUSTSEC-2023-0071 --ignore RUSTSEC-2024-0363 --ignore RUSTSEC-2024-0421
+        run: cargo audit --ignore RUSTSEC-2023-0071 --ignore RUSTSEC-2024-0363 --ignore RUSTSEC-2024-0421 --ignore RUSTSEC-2026-0041 --ignore RUSTSEC-2026-0044 --ignore RUSTSEC-2026-0045 --ignore RUSTSEC-2026-0046 --ignore RUSTSEC-2026-0047 --ignore RUSTSEC-2026-0048 --ignore RUSTSEC-2026-0049 --ignore RUSTSEC-2026-0067 --ignore RUSTSEC-2026-0068
 
       - name: Setup Node
         uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
diff --git a/.github/workflows/release-fast.yml b/.github/workflows/release-fast.yml
index 9178b9f2..c89d43b2 100644
--- a/.github/workflows/release-fast.yml
+++ b/.github/workflows/release-fast.yml
@@ -1,17 +1,14 @@
-name: Release Fast (Alpha Windows + Linux)
-
-env:
-  OLLAMA_VERSION: "v0.5.13"
+name: Stabilization Build (Unsigned)
 
 on:
   workflow_dispatch:
     inputs:
       release_version:
-        description: 'Release version (e.g. 0.0.3). Leave empty for auto-increment.'
+        description: "Optional stabilization version label"
         required: false
         type: string
-      create_github_release:
-        description: 'Create a GitHub pre-release with the built artifacts'
+      publish_prerelease:
+        description: "Publish the unsigned stabilization binaries as a GitHub pre-release"
         required: false
         type: boolean
         default: false
@@ -27,23 +24,18 @@ jobs:
         include:
           - platform: windows-latest
             target: x86_64-pc-windows-msvc
-            installer_path: target/release/bundle/nsis/*.exe
-            asset_name: Abigail-windows-x64-setup.exe
-            asset_glob: "*.exe"
-            keygen_bin: abigail-keygen.exe
-            resource_name: abigail-keygen.exe
-            ollama_bin: ollama.exe
-
+            hive_binary: target/release/abigail-hive-app.exe
+            runtime_binary: target/release/abigail-entity-runtime-app.exe
+            hive_asset_name: Abigail-Hive-windows-x64.exe
+            runtime_asset_name: Abigail-Entity-Runtime-windows-x64.exe
           - platform: ubuntu-22.04
             target: x86_64-unknown-linux-gnu
-            installer_path: target/release/bundle/deb/*.deb
-            asset_name: Abigail-linux-x64.deb
-            asset_glob: "*.deb"
-            keygen_bin: abigail-keygen
-            resource_name: abigail-keygen
-            ollama_bin: ollama
+            hive_binary: target/release/abigail-hive-app
+            runtime_binary: target/release/abigail-entity-runtime-app
+            hive_asset_name: Abigail-Hive-linux-x64
+            runtime_asset_name: Abigail-Entity-Runtime-linux-x64
 
-    runs-on: ${{ matrix.platform == 'windows-latest' && vars.ABIGAIL_WINDOWS_RUNNER != '' && vars.ABIGAIL_WINDOWS_RUNNER || matrix.platform }}
+    runs-on: ${{ matrix.platform }}
 
     outputs:
       version: ${{ steps.version.outputs.version }}
@@ -52,29 +44,20 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-        with:
-          ref: ${{ github.ref }}
-          fetch-depth: 0
-
-      - name: Install NSIS (Windows)
-        if: matrix.platform == 'windows-latest'
-        run: choco install nsis --no-progress -y
 
-      - name: Install Linux dependencies (Tauri 2 / Debian)
+      - name: Install Linux dependencies
         if: matrix.platform == 'ubuntu-22.04'
         run: |
           sudo apt-get update
           sudo apt-get install -y \
             libwebkit2gtk-4.1-dev build-essential curl wget file \
             libxdo-dev libssl-dev libayatana-appindicator3-dev \
-            librsvg2-dev patchelf libgtk-3-dev
+            librsvg2-dev patchelf libgtk-3-dev libdbus-1-dev pkg-config
 
       - name: Setup Node
         uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
         with:
           node-version: "20"
-          cache: "npm"
-          cache-dependency-path: tauri-app/src-ui/package-lock.json
 
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # stable
@@ -90,7 +73,6 @@ jobs:
             VERSION="${{ github.event.inputs.release_version }}"
           else
             git fetch --tags
-            # Only consider clean semver tags (exclude -fast, -rc, etc.)
             LATEST=$(git tag -l 'v*' --sort=-v:refname | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | head -n 1)
             if [[ -z "$LATEST" ]]; then
               VERSION="0.0.1"
@@ -101,155 +83,9 @@ jobs:
               VERSION="${MAJOR}.${MINOR}.${PATCH}"
             fi
           fi
-          TAG="v${VERSION}-fast.${{ github.run_number }}"
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "tag=$TAG" >> $GITHUB_OUTPUT
-          echo "Fast build version: $VERSION (tag: $TAG)"
-
-      - name: Update version in tauri.conf.json
-        shell: bash
-        run: |
-          cd tauri-app
-          node -e "
-            const fs = require('fs');
-            const conf = JSON.parse(fs.readFileSync('tauri.conf.json', 'utf8'));
-            conf.version = '${{ steps.version.outputs.version }}';
-            fs.writeFileSync('tauri.conf.json', JSON.stringify(conf, null, 2) + '\n');
-          "
-
-      - name: Disable beforeBuildCommand for CI
-        shell: bash
-        run: |
-          node -e "
-            const fs = require('fs');
-            const path = 'tauri-app/tauri.conf.json';
-            const data = JSON.parse(fs.readFileSync(path, 'utf8'));
-            data.build = data.build || {};
-            data.build.beforeBuildCommand = '';
-            fs.writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
-          "
-
-      - name: Set platform-specific resources in tauri.conf.json
-        shell: bash
-        run: |
-          node -e "
-            const fs = require('fs');
-            const path = 'tauri-app/tauri.conf.json';
-            const data = JSON.parse(fs.readFileSync(path, 'utf8'));
-            data.bundle = data.bundle || {};
-            data.bundle.resources = ['${{ matrix.resource_name }}', '${{ matrix.ollama_bin }}'];
-            fs.writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
-          "
-
-      - name: Resolve fast-release signing mode
-        if: matrix.platform == 'windows-latest' && github.event.inputs.create_github_release == 'true'
-        id: fast_signing
-        shell: bash
-        env:
-          ABIGAIL_WINDOWS_SIGNING_MODE: ${{ vars.ABIGAIL_WINDOWS_SIGNING_MODE }}
-          ABIGAIL_WINDOWS_RUNNER: ${{ vars.ABIGAIL_WINDOWS_RUNNER }}
-          WINDOWS_SIGNING_CERT_BASE64: ${{ secrets.WINDOWS_SIGNING_CERT_BASE64 }}
-          WINDOWS_SIGNING_CERT_PASSWORD: ${{ secrets.WINDOWS_SIGNING_CERT_PASSWORD }}
-          WINDOWS_CERTIFICATE_THUMBPRINT: ${{ secrets.WINDOWS_CERTIFICATE_THUMBPRINT }}
-          WINDOWS_TIMESTAMP_URL: ${{ secrets.WINDOWS_TIMESTAMP_URL }}
-        run: |
-          mode="$(printf '%s' "${ABIGAIL_WINDOWS_SIGNING_MODE:-}" | tr '[:upper:]' '[:lower:]' | tr -d '[:space:]')"
-          if [[ -z "$mode" && ( -n "${WINDOWS_SIGNING_CERT_BASE64:-}" || -n "${WINDOWS_SIGNING_CERT_PASSWORD:-}" ) ]]; then
-            mode=pfx
-          fi
-          has_windows_signing=false
-          case "$mode" in
-            pfx)
-              if [[ -n "${WINDOWS_SIGNING_CERT_BASE64:-}" && \
-                    -n "${WINDOWS_SIGNING_CERT_PASSWORD:-}" && \
-                    -n "${WINDOWS_CERTIFICATE_THUMBPRINT:-}" && \
-                    -n "${WINDOWS_TIMESTAMP_URL:-}" ]]; then
-                has_windows_signing=true
-              fi
-              ;;
-            store)
-              if [[ -n "${ABIGAIL_WINDOWS_RUNNER:-}" && \
-                    -n "${WINDOWS_CERTIFICATE_THUMBPRINT:-}" && \
-                    -n "${WINDOWS_TIMESTAMP_URL:-}" ]]; then
-                has_windows_signing=true
-              fi
-              ;;
-            ""|off|false|none)
-              mode=off
-              ;;
-            *)
-              echo "ERROR: Unsupported ABIGAIL_WINDOWS_SIGNING_MODE '${ABIGAIL_WINDOWS_SIGNING_MODE}'."
-              exit 1
-              ;;
-          esac
-
-          echo "windows_signing_mode=$mode" >> "$GITHUB_OUTPUT"
-          echo "has_windows_signing=$has_windows_signing" >> "$GITHUB_OUTPUT"
-
-          if [[ "$has_windows_signing" == "true" ]]; then
-            echo "Windows Authenticode inputs detected for fast pre-release (mode: $mode)."
-          else
-            echo "Windows Authenticode inputs missing; fast pre-release will publish unsigned Windows installers."
-          fi
-
-      - name: Enforce fast-release signing prerequisites
-        if: matrix.platform == 'windows-latest' && github.event.inputs.create_github_release == 'true'
-        shell: bash
-        env:
-          ABIGAIL_REQUIRE_UPDATER_SIGNING: "true"
-          ABIGAIL_REQUIRE_WINDOWS_SIGNING: ${{ steps.fast_signing.outputs.has_windows_signing }}
-          ABIGAIL_WINDOWS_SIGNING_MODE: ${{ steps.fast_signing.outputs.windows_signing_mode }}
-          ABIGAIL_WINDOWS_RUNNER: ${{ vars.ABIGAIL_WINDOWS_RUNNER }}
-          ABIGAIL_REQUIRE_MAC_SIGNING: "false"
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-          TAURI_UPDATER_PUBKEY: ${{ secrets.TAURI_UPDATER_PUBKEY }}
-          WINDOWS_SIGNING_CERT_BASE64: ${{ secrets.WINDOWS_SIGNING_CERT_BASE64 }}
-          WINDOWS_SIGNING_CERT_PASSWORD: ${{ secrets.WINDOWS_SIGNING_CERT_PASSWORD }}
-          WINDOWS_SIGNING_CERT_PEM: ${{ secrets.WINDOWS_SIGNING_CERT_PEM }}
-          WINDOWS_CERTIFICATE_THUMBPRINT: ${{ secrets.WINDOWS_CERTIFICATE_THUMBPRINT }}
-          WINDOWS_TIMESTAMP_URL: ${{ secrets.WINDOWS_TIMESTAMP_URL }}
-        run: |
-          bash scripts/enforce_release_prereqs.sh
-
-      - name: Configure updater and signing fields in tauri.conf.json
-        shell: bash
-        env:
-          ABIGAIL_REQUIRE_UPDATER_PUBKEY: ${{ matrix.platform == 'windows-latest' && github.event.inputs.create_github_release == 'true' }}
-          ABIGAIL_ENABLE_UPDATER_ARTIFACTS: ${{ matrix.platform == 'windows-latest' && github.event.inputs.create_github_release == 'true' }}
-          TAURI_UPDATER_PUBKEY: ${{ secrets.TAURI_UPDATER_PUBKEY }}
-          WINDOWS_CERTIFICATE_THUMBPRINT: ${{ secrets.WINDOWS_CERTIFICATE_THUMBPRINT }}
-          WINDOWS_TIMESTAMP_URL: ${{ secrets.WINDOWS_TIMESTAMP_URL }}
-          WINDOWS_TIMESTAMP_TSP: ${{ vars.ABIGAIL_WINDOWS_TIMESTAMP_TSP }}
-        run: |
-          node scripts/prepare_tauri_bundle_config.mjs tauri-app/tauri.conf.json
-
-      - name: Assert updater config injection
-        if: matrix.platform == 'windows-latest' && github.event.inputs.create_github_release == 'true'
-        shell: bash
-        env:
-          TAURI_UPDATER_PUBKEY: ${{ secrets.TAURI_UPDATER_PUBKEY }}
-        run: |
-          node -e "
-            const fs = require('fs');
-            const normalize = (value) => {
-              const input = String(value || '').trim();
-              if (!input) return '';
-              const normalized = input.replace(/\s+/g, '');
-              const decoded = input.startsWith('untrusted comment:')
-                ? input
-                : Buffer.from(normalized, 'base64').toString('utf8').trim();
-              const lines = decoded.split(/\r?\n/).filter(Boolean);
-              return Buffer.from(lines[0] + '\n' + lines[1], 'utf8').toString('base64');
-            };
-            const conf = JSON.parse(fs.readFileSync('tauri-app/tauri.conf.json', 'utf8'));
-            if (!conf.bundle?.createUpdaterArtifacts) {
-              throw new Error('createUpdaterArtifacts must be true for fast prerelease builds');
-            }
-            if (conf.plugins?.updater?.pubkey !== normalize(process.env.TAURI_UPDATER_PUBKEY)) {
-              throw new Error('Updater pubkey injection mismatch');
-            }
-          "
+          TAG="v${VERSION}-stabilization.${{ github.run_number }}"
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "tag=$TAG" >> "$GITHUB_OUTPUT"
 
       - name: Generate Cargo.lock
         run: cargo generate-lockfile
@@ -258,130 +94,32 @@ jobs:
         uses: swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
         with:
           workspaces: "."
-          shared-key: release-fast-${{ matrix.platform }}
+          shared-key: stabilization-${{ matrix.platform }}
 
-      - name: Install and build frontend
-        run: |
-          cd tauri-app/src-ui && npm ci && npm run build
-
-      - name: Generate app icons
-        run: |
-          npm install -g @tauri-apps/cli@v2
-          cd tauri-app && tauri icon icons/icon.png -o icons
-
-      - name: Ensure icons at repo root (bundler cwd workaround)
-        shell: bash
-        run: |
-          mkdir -p icons
-          cp tauri-app/icons/icon.ico icons/ 2>/dev/null || true
-          cp tauri-app/icons/icon.icns icons/ 2>/dev/null || true
-          cp tauri-app/icons/*.png icons/ 2>/dev/null || true
+      - name: Verify unsigned stabilization lane
+        run: node scripts/check_unsigned_stabilization.mjs
 
-      - name: Build abigail-keygen binary
-        shell: bash
-        run: |
-          cargo build --release -p abigail-keygen
-          cp target/release/${{ matrix.keygen_bin }} tauri-app/${{ matrix.resource_name }}
+      - name: Build unsigned Hive and Runtime apps
+        run: cargo build --release -p abigail-hive-app -p abigail-entity-runtime-app
 
-      - name: Download bundled Ollama binary
+      - name: Stage stabilization binaries
         shell: bash
         run: |
-          OLLAMA_BASE="https://github.com/ollama/ollama/releases/download/${{ env.OLLAMA_VERSION }}"
-          if [[ "${{ matrix.platform }}" == "windows-latest" ]]; then
-            curl -fL -o /tmp/ollama.zip "${OLLAMA_BASE}/ollama-windows-amd64.zip"
-            unzip -o -j /tmp/ollama.zip "ollama.exe" -d tauri-app/
-          elif [[ "${{ matrix.platform }}" == "ubuntu-22.04" ]]; then
-            curl -fL -o /tmp/ollama.tgz "${OLLAMA_BASE}/ollama-linux-amd64.tgz"
-            tar xzf /tmp/ollama.tgz -C tauri-app/ --strip-components=1 bin/ollama
-            chmod +x "tauri-app/${{ matrix.ollama_bin }}"
-          fi
-          ls -la "tauri-app/${{ matrix.ollama_bin }}"
-          # Validate binary is not a truncated download or error page
-          FILE_SIZE=$(stat -c%s "tauri-app/${{ matrix.ollama_bin }}" 2>/dev/null || stat -f%z "tauri-app/${{ matrix.ollama_bin }}" 2>/dev/null)
-          if [ "$FILE_SIZE" -lt 10000000 ]; then
-            echo "ERROR: Downloaded Ollama binary is too small (${FILE_SIZE} bytes)"
-            exit 1
-          fi
+          mkdir -p stabilization-assets
+          cp "${{ matrix.hive_binary }}" "stabilization-assets/${{ matrix.hive_asset_name }}"
+          cp "${{ matrix.runtime_binary }}" "stabilization-assets/${{ matrix.runtime_asset_name }}"
+          ls -la stabilization-assets
 
-      - name: Prepare Windows code signing certificate
-        if: matrix.platform == 'windows-latest' && github.event.inputs.create_github_release == 'true' && steps.fast_signing.outputs.has_windows_signing == 'true'
-        shell: pwsh
-        env:
-          ABIGAIL_WINDOWS_SIGNING_MODE: ${{ steps.fast_signing.outputs.windows_signing_mode }}
-          WINDOWS_SIGNING_CERT_BASE64: ${{ secrets.WINDOWS_SIGNING_CERT_BASE64 }}
-          WINDOWS_SIGNING_CERT_PASSWORD: ${{ secrets.WINDOWS_SIGNING_CERT_PASSWORD }}
-          WINDOWS_SIGNING_CERT_PEM: ${{ secrets.WINDOWS_SIGNING_CERT_PEM }}
-          WINDOWS_CERTIFICATE_THUMBPRINT: ${{ secrets.WINDOWS_CERTIFICATE_THUMBPRINT }}
-        run: |
-          ./scripts/windows_signing_preflight.ps1
-
-      - name: Validate updater signing key preflight
-        if: matrix.platform == 'windows-latest' && github.event.inputs.create_github_release == 'true'
-        shell: bash
-        env:
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-        run: |
-          bash scripts/validate_tauri_signing_key.sh
-
-      - name: Build Tauri app
-        shell: bash
-        env:
-          TAURI_SIGNING_PRIVATE_KEY: ${{ env.TAURI_SIGNING_PRIVATE_KEY || secrets.TAURI_SIGNING_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-        run: |
-          cd tauri-app
-
-          if [[ "${{ matrix.platform }}" == "windows-latest" && "${{ github.event.inputs.create_github_release }}" == "true" ]]; then
-            tauri build
-          elif [[ -n "${TAURI_SIGNING_PRIVATE_KEY:-}" ]]; then
-            echo "Signing key detected: building signed artifacts"
-            tauri build
-          else
-            echo "WARNING: TAURI_SIGNING_PRIVATE_KEY is not configured; building unsigned artifacts"
-            TAURI_SKIP_SIGNING=true tauri build
-          fi
-
-      - name: Verify updater artifacts
-        if: matrix.platform == 'windows-latest' && github.event.inputs.create_github_release == 'true'
-        shell: bash
-        run: |
-          mapfile -t UPDATER_FILES < <(find target -type f \( -name "*.nsis.zip" -o -name "*.nsis.zip.sig" -o -name "*.msi.zip" -o -name "*.msi.zip.sig" \))
-          if [[ "${#UPDATER_FILES[@]}" -eq 0 ]]; then
-            echo "ERROR: No updater artifacts were produced."
-            exit 1
-          fi
-
-      - name: Upload installers (Artifacts)
+      - name: Upload stabilization artifacts
         uses: actions/upload-artifact@47309c993abb98030a35d55ef7ff34b7fa1074b5 # v4
         with:
-          name: abigail-fast-installer-${{ matrix.platform }}
-          path: ${{ matrix.installer_path }}
-          if-no-files-found: error
-
-      - name: Upload MSI installer (Windows)
-        if: matrix.platform == 'windows-latest'
-        uses: actions/upload-artifact@47309c993abb98030a35d55ef7ff34b7fa1074b5 # v4
-        with:
-          name: abigail-fast-msi-windows-latest
-          path: target/release/bundle/msi/*.msi
-          if-no-files-found: warn
-
-      - name: Upload updater artifacts
-        if: matrix.platform == 'windows-latest' && github.event.inputs.create_github_release == 'true'
-        uses: actions/upload-artifact@47309c993abb98030a35d55ef7ff34b7fa1074b5 # v4
-        with:
-          name: abigail-fast-updater-windows-latest
-          path: |
-            target/**/bundle/**/*.nsis.zip
-            target/**/bundle/**/*.nsis.zip.sig
-            target/**/bundle/**/*.msi.zip
-            target/**/bundle/**/*.msi.zip.sig
+          name: abigail-stabilization-${{ matrix.platform }}
+          path: stabilization-assets/*
           if-no-files-found: error
 
   publish:
     needs: build
-    if: github.event.inputs.create_github_release == 'true' && needs.build.result == 'success'
+    if: github.event.inputs.publish_prerelease == 'true' && needs.build.result == 'success'
     runs-on: ubuntu-22.04
     permissions:
       contents: write
@@ -392,40 +130,19 @@ jobs:
           ref: ${{ github.ref }}
           fetch-depth: 0
 
-      - name: Download all installer artifacts
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
-        with:
-          path: artifacts
-          pattern: abigail-fast-installer-*
-          merge-multiple: false
-
-      - name: Download MSI artifacts
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
-        with:
-          path: artifacts
-          pattern: abigail-fast-msi-*
-          merge-multiple: false
-        continue-on-error: true
-
-      - name: Download updater artifacts
+      - name: Download stabilization artifacts
         uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
         with:
           path: artifacts
-          pattern: abigail-fast-updater-*
+          pattern: abigail-stabilization-*
           merge-multiple: false
-        continue-on-error: true
 
-      - name: Count downloaded installer artifacts
+      - name: Count downloaded artifacts
         id: artifacts
         shell: bash
         run: |
-          if [ -d artifacts ]; then
-            COUNT=$(find artifacts -type f | wc -l | tr -d ' ')
-          else
-            COUNT=0
-          fi
-          echo "count=$COUNT" >> $GITHUB_OUTPUT
-          echo "Discovered $COUNT downloaded artifact file(s)"
+          COUNT=$(find artifacts -type f | wc -l | tr -d ' ')
+          echo "count=$COUNT" >> "$GITHUB_OUTPUT"
 
       - name: Create git tag if needed
         if: steps.artifacts.outputs.count != '0'
@@ -439,40 +156,17 @@ jobs:
             git push origin "$TAG"
           fi
 
-      - name: Rename to stable asset names for download URLs
-        if: steps.artifacts.outputs.count != '0'
-        shell: bash
-        run: |
-          find artifacts -type f -name '*.exe' -print -quit | while read -r f; do cp "$f" Abigail-windows-x64-setup-fast.exe; done
-          find artifacts -type f -name '*.deb' -print -quit | while read -r f; do cp "$f" Abigail-linux-x64-fast.deb; done
-          find artifacts -type f -name '*.msi' -print -quit | while read -r f; do cp "$f" Abigail-windows-x64-fast.msi; done
-          find artifacts/abigail-fast-updater-windows-latest -type f -name '*.nsis.zip' -print -quit | while read -r f; do cp "$f" Abigail-updater-windows-x64.nsis.zip; done
-          find artifacts/abigail-fast-updater-windows-latest -type f -name '*.nsis.zip.sig' -print -quit | while read -r f; do cp "$f" Abigail-updater-windows-x64.nsis.zip.sig; done
-          find artifacts/abigail-fast-updater-windows-latest -type f -name '*.msi.zip' -print -quit | while read -r f; do cp "$f" Abigail-updater-windows-x64.msi.zip; done
-          find artifacts/abigail-fast-updater-windows-latest -type f -name '*.msi.zip.sig' -print -quit | while read -r f; do cp "$f" Abigail-updater-windows-x64.msi.zip.sig; done
-          node scripts/generate_tauri_latest_manifest.mjs \
-            --version "${{ needs.build.outputs.version }}" \
-            --assets-dir . \
-            --base-url "https://github.com/${{ github.repository }}/releases/download/${{ needs.build.outputs.tag }}" \
-            --output latest.json
-
-      - name: Create GitHub Pre-release
+      - name: Create GitHub pre-release
         if: steps.artifacts.outputs.count != '0'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          assets=()
-          [[ -f Abigail-windows-x64-setup-fast.exe ]] && assets+=(Abigail-windows-x64-setup-fast.exe)
-          [[ -f Abigail-linux-x64-fast.deb ]] && assets+=(Abigail-linux-x64-fast.deb)
-          [[ -f Abigail-windows-x64-fast.msi ]] && assets+=(Abigail-windows-x64-fast.msi)
-          [[ -f Abigail-updater-windows-x64.nsis.zip ]] && assets+=(Abigail-updater-windows-x64.nsis.zip)
-          [[ -f Abigail-updater-windows-x64.nsis.zip.sig ]] && assets+=(Abigail-updater-windows-x64.nsis.zip.sig)
-          [[ -f Abigail-updater-windows-x64.msi.zip ]] && assets+=(Abigail-updater-windows-x64.msi.zip)
-          [[ -f Abigail-updater-windows-x64.msi.zip.sig ]] && assets+=(Abigail-updater-windows-x64.msi.zip.sig)
-          [[ -f latest.json ]] && assets+=(latest.json)
-
-          gh release create "${{ needs.build.outputs.tag }}" \
-            --title "Abigail Fast ${{ needs.build.outputs.version }}" \
-            --notes "Alpha validation release. Windows updater payloads remain signed; Windows Authenticode is included only when certificate secrets are configured." \
-            --prerelease \
-            "${assets[@]}"
+        uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b # v2
+        with:
+          tag_name: ${{ needs.build.outputs.tag }}
+          name: Abigail Stabilization ${{ needs.build.outputs.version }}
+          prerelease: true
+          draft: false
+          body: |
+            Unsigned stabilization binaries for the split Abigail Hive and Abigail Entity Runtime apps.
+
+            This lane intentionally excludes updater artifacts, installer migration logic, and release signing.
+          files: |
+            artifacts/**/*
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 60bd171f..cc5a88ea 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,4 +1,4 @@
-# Build Abigail installers, publish GitHub Release, and publish npm package.
+# Build Abigail beta/release artifacts, publish GitHub Release, and publish npm package.
 #
 # Triggers:
 #   - Tags matching 'v*' (e.g., v0.0.3)
@@ -10,7 +10,7 @@
 #
 # Platforms: Windows (NSIS), Ubuntu (deb), macOS (dmg universal binary)
 
-name: Release
+name: Beta Release (Signed)
 
 env:
   OLLAMA_VERSION: "v0.5.13"
diff --git a/.gitignore b/.gitignore
index 0e559b14..f4a8a027 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,6 +31,8 @@ lcov.info
 
 # Tauri generated files
 tauri-app/gen/
+hive-app/gen/
+entity-runtime-app/gen/
 
 # Application data files (created at runtime, not in repo)
 config.json
diff --git a/AGENTS.md b/AGENTS.md
index 3a663bae..b45981bf 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -6,17 +6,20 @@ This file tracks the current plan for agents working in the Abigail repository.
 
 Abigail is the private Entity Coordinator and Manager for real homes and families. The user (mentor/family head) creates individual Entities that the family actually interacts with. Abigail handles coordination, memory, skills, and security in the background.
 
-- Provider/model selector propagation is wired end-to-end.
+- Abigail Hive is the only place where provider/model management should live.
+- Abigail Hive should remain visible and usable even while an Entity is open.
+- The active stabilization split is two app roots: `hive-app` for control-plane work and `entity-runtime-app` for the chat/runtime surface.
 - Mentor chat monitor preprompt flow is in place and out-of-band monitors remain non-blocking.
 - DevOps Forge worker is active and subscribed to `topic.skill.forge.request`.
 - Forge pipeline writes sandbox-gated artifacts to `skills/dynamic/`, updates `skills/registry.toml`, and publishes `topic.skill.forge.response`.
 
 ## Active Plan (Family-First Priorities)
 
-1. Keep selector + mentor monitor paths stable and test-backed.
+1. Keep the always-open Hive shell and Hive-owned model management stable and test-backed.
 2. Harden Forge envelope validation and failure telemetry (keep it invisible and safe for the user).
 3. Expand end-to-end coverage for forge request/response and watcher hot-reload.
 4. Keep memory/safety/id-superego observers out-of-band (non-blocking chat path) so the family experience stays smooth.
+5. Keep the unsigned stabilization lane free of installer upgrade-preserve logic, updater assumptions, and Windows signing dependencies.
 
 ## Definition of Done for Next Phase
 
@@ -24,11 +27,12 @@ Abigail is the private Entity Coordinator and Manager for real homes and familie
 - Superego and sandbox gates prevent unsafe mutations while staying invisible to the user.
 - Registry update reliably triggers watcher-based hot-reload.
 - End-to-end coverage validates success, blocked, and error fallback behavior.
+- Legacy compatibility paths that conflict with the current dev UX are removed instead of preserved.
 
 ## Documentation Sync
 
 When changing routing or monitor behavior, update:
 - `README.md` (user-facing family story)
-- `CLAUDE.md` and `agent.md` (agent constitution files)
+- `CLAUDE.md` and `AGENTS.md` (agent constitution / active plan files)
 
-**Remember the Mission**: Abigail coordinates the Entities that families actually talk to. Every change must make the experience warmer, simpler, and more powerful for real homes.
\ No newline at end of file
+**Remember the Mission**: Abigail coordinates the Entities that families actually talk to. Every change must make the experience warmer, simpler, and more powerful for real homes.
diff --git a/CLAUDE.md b/CLAUDE.md
index 71779c76..c6c3dae9 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -8,9 +8,13 @@ Abigail manages multiple personal AI Entities that the user, mentor, or family h
 **Development Rules (Always Follow)**
 - The user creates and manages Entities - Abigail is the silent coordinator behind them.
 - Abigail itself is represented by an immortal local `Abigail Hive` Entity with elevated local privileges; it owns shared memory and must remain undeletable.
+- `Abigail Hive` stays open and usable even when a family-facing Entity is active.
+- Provider and model management belongs to `Abigail Hive`, never inside Entity chat or Entity-specific settings.
 - `Abigail Hive` owns the shared embedded SurrealDB persistence root (`memory.db`) and legacy SQLite files are migration inputs only, never active runtime stores.
+- The stable direction is two interoperable applications: a Hive control app and a chat-first Entity Runtime app. Prefer explicit local HTTP boundaries over in-process shortcuts.
 - Users should be encouraged to connect Entities to powerful cloud models from any provider. This multi-provider freedom is a major advantage.
-- Provider/model selector changes must stay stable across direct APIs and CLI-backed providers, and identity recovery must preserve shared Hive memory/docs instead of crashing.
+- Current dev builds prioritize a clean working single-version experience over cross-version compatibility. Remove stale legacy paths when they conflict with the active Hive-first architecture.
+- Unsigned stabilization builds are the default local path. Release signing and updater signing are beta/release-only concerns that should stay opt-in and isolated from day-to-day development.
 - Privacy and local-first are non-negotiable. Cloud models are optional power-ups, never required.
 - Keep per-Entity data scoped through Hive-owned storage interfaces so one Entity cannot read another Entity's records by accident.
 - Keep everything dead-simple for the family user. Delight and ease of use come first.
diff --git a/Cargo.lock b/Cargo.lock
index e33cdacb..431e7168 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -173,6 +173,22 @@ dependencies = [
  "windows 0.52.0",
 ]
 
+[[package]]
+name = "abigail-entity-runtime-app"
+version = "0.0.1"
+dependencies = [
+ "daemon-client",
+ "entity-core",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-build",
+ "tauri-plugin-dialog",
+ "tokio",
+ "tracing",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "abigail-hive"
 version = "0.0.1"
@@ -188,6 +204,23 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "abigail-hive-app"
+version = "0.0.1"
+dependencies = [
+ "daemon-client",
+ "hive-core",
+ "reqwest 0.13.2",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-build",
+ "tauri-plugin-dialog",
+ "tokio",
+ "tracing",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "abigail-id"
 version = "0.0.1"
@@ -397,9 +430,11 @@ dependencies = [
  "anyhow",
  "async-trait",
  "chrono",
+ "hex",
  "iggy",
  "serde",
  "serde_json",
+ "sha2",
  "tokio",
  "tokio-util",
  "tracing",
@@ -410,6 +445,7 @@ dependencies = [
 name = "abigail-superego"
 version = "0.0.1"
 dependencies = [
+ "abigail-core",
  "abigail-streaming",
  "anyhow",
  "chrono",
@@ -3422,9 +3458,11 @@ dependencies = [
  "abigail-capabilities",
  "abigail-core",
  "abigail-memory",
+ "abigail-persistence",
  "abigail-queue",
  "abigail-router",
  "abigail-skills",
+ "abigail-streaming",
  "anyhow",
  "async-trait",
  "chrono",
@@ -4916,16 +4954,19 @@ dependencies = [
  "abigail-skills",
  "anyhow",
  "axum 0.7.9",
+ "chrono",
  "clap",
  "daemon-test-harness",
  "hive-core",
  "reqwest 0.13.2",
  "serde",
  "serde_json",
+ "soul-forge",
  "tokio",
  "tower-http",
  "tracing",
  "tracing-subscriber",
+ "uuid",
 ]
 
 [[package]]
@@ -9006,9 +9047,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.9"
+version = "0.103.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
 dependencies = [
  "aws-lc-rs",
  "ring",
diff --git a/Cargo.toml b/Cargo.toml
index 2bb558f0..848fe91a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,6 +29,8 @@ members = [
     "crates/abigail-runtime",
     "crates/daemon-test-harness",
     "crates/daemon-client",
+    "hive-app",
+    "entity-runtime-app",
     "skills/skill-web-search",
     "skills/skill-browser",
     "skills/skill-filesystem",
diff --git a/README.md b/README.md
index 953fcaba..01ecfaec 100644
--- a/README.md
+++ b/README.md
@@ -5,32 +5,54 @@
 Abigail is the smart, private manager that lives in your home. You, the mentor or family head, create and customize individual **Entities** - each one a unique AI companion tailored to a person or purpose.
 
 Your family talks directly to these Entities. Abigail coordinates everything behind the scenes: memory, skills, security, and growth.
-Every install also provisions an immortal local coordinator identity called `Abigail Hive` that owns the shared `memory.db` and starts before user-facing Entities.
+Every install also provisions an immortal local coordinator identity called `Abigail Hive` that owns the shared `memory.db`, stays visible while an Entity is open, and centralizes provider/model management for the whole home.
 That Hive-owned store now runs on embedded SurrealDB, giving Abigail one local-first memory substrate for document records, graph links, semantic archives, and queue state without requiring Docker or an external database.
 
 ### Why Families Love Abigail
 - **Complete privacy** - everything stays on your computer. No accounts with big tech companies.
-- **One shared local memory core** - Abigail Hive owns a single embedded SurrealDB store and migrates supported legacy SQLite data on first launch.
+- **One shared local memory core** - Abigail Hive owns a single embedded SurrealDB store for shared coordination, memory, archives, and queue state.
 - **Real power when you want it** - connect any Entity to the strongest cloud models with one click. You are never locked to one provider.
-- **Provider switches stay safe** - model changes propagate across direct APIs and supported CLI tools without forcing families to rebuild shared Abigail data.
+- **Hive-owned model control** - provider and model changes happen in Abigail Hive, not inside each individual Entity chat.
 - **Grows with your family** - teach Entities new skills, memories, and preferences over time.
 - **Simple for everyone** - kids, parents, and partners just chat naturally while you control the advanced settings.
 - **Handles real-world sites safely** - for authenticated flows like webmail, Abigail uses Browser skill fallback instead of fragile IMAP/SMTP plumbing.
 
 ### Quick Start (5 minutes)
 1. Install and open Abigail
-2. Create your first Entity
-3. Let your family start chatting with their own Entity
-4. Connect any Entity to powerful cloud models when you want more capability
+2. Open Abigail Hive and create your first Entity
+3. Configure local or cloud models in the Hive sidebar if you want extra capability
+4. Let your family chat with the selected Entity while the Hive stays open beside it
 
 No accounts. No data sharing. Just your family and the Entities you control.
 
+## Current Dev Note
+
+- Abigail is still in a dev-first phase. A clean working dev instance matters more than cross-version compatibility right now.
+- Legacy migration and upgrade preservation are not current product promises. Remove or replace stale compatibility paths when they get in the way of the active Hive-first design.
+- The stabilization lane is moving toward two parallel desktop app roots: `Abigail Hive` for control-plane/admin work and `Abigail Entity Runtime` for chat/runtime work.
+- Default local builds and installer validation are intentionally unsigned and updater-free during stabilization. Final OV signing happens later on the dedicated release-signing system.
+
+## Dev Start
+
+- From the repo root, start the desktop app with `cargo tauri dev`.
+- If you only need the frontend shell, run `npm run dev` in `tauri-app/src-ui`.
+- The Tauri watcher now ignores frontend dependency churn through `.taurignore`, so Vite temp files should not retrigger Rust rebuilds during normal dev.
+- On Windows machines with Application Control enabled, `cargo build` and `cargo tauri dev` can still fail with `os error 4551` when Cargo tries to execute generated build-script binaries. That is an OS policy blocker, not an Abigail source-code failure. Use a build-allowed environment to launch the desktop shell in that case.
+
+## Split Stack Local Dev
+
+- Use `pwsh ./scripts/dev/launch_split_stack.ps1` to build and launch the Hive daemon, Entity Runtime daemon, and the split desktop shells from one command.
+- Those scripts standardize `CARGO_TARGET_DIR` to `%LOCALAPPDATA%\Abigail\cargo-target` on Windows so allow-listing can target one stable developer build path instead of repo-local `target\...`.
+- If Windows policy still blocks desktop-shell builds, run `pwsh ./scripts/diagnose_windows_build_policy.ps1` for a JSON diagnostic summary and use `pwsh ./scripts/dev/launch_split_stack.ps1` to fall back to the browser harness automatically.
+- The browser fallback lives at `dev-harness/` and is served by `node ./scripts/dev/run_browser_harness.mjs`; it talks directly to the local Hive and Runtime daemon APIs.
+- Session details, pids, and logs are written to `target/manual-test/stability-reset/session.json`. Shut them down with `pwsh ./scripts/dev/stop_split_stack.ps1`.
+
 ## Local Memory Model
 
 - `Abigail Hive` owns the shared persistence root and opens the local `memory.db` store before user-facing Entities start.
 - Shared orchestration state lives in the `abigail/hive` Surreal namespace/database pair.
 - Per-Entity state is isolated into `abigail/entity_<uuid>` databases inside the same local store.
-- Existing `abigail_seed.db`, `abigail_memory.db`, `jobs.db`, `calendar.db`, and `kb.db` files are treated as migration inputs only and are archived after a successful import.
+- Research-era SQLite artifacts such as `abigail_seed.db`, `abigail_memory.db`, `jobs.db`, `calendar.db`, and `kb.db` are legacy-only and should not be treated as active runtime stores.
 - Browser, mentor-monitor, Id, Superego, and memory enrichment flows stay out-of-band so the family chat path remains responsive.
 
 ### For the Curious: Where Abigail Came From
diff --git a/crates/abigail-core/src/vault/mod.rs b/crates/abigail-core/src/vault/mod.rs
index 55d263a0..b686de91 100644
--- a/crates/abigail-core/src/vault/mod.rs
+++ b/crates/abigail-core/src/vault/mod.rs
@@ -113,7 +113,7 @@ fn validate_sentinel(sentinel: &str) -> Result<()> {
 /// runtime verification without mutating identity data on failure.
 pub async fn init_resilient() {
     let result = tokio::task::spawn_blocking(|| {
-        let data_root = crate::AppConfig::default_paths().data_dir;
+        let data_root = unlock::process_vault_data_dir();
         let _ = std::fs::create_dir_all(&data_root);
 
         if let Err(e) = crate::SecretsVault::load(data_root.clone()) {
diff --git a/crates/abigail-core/src/vault/unlock.rs b/crates/abigail-core/src/vault/unlock.rs
index b8470f68..dab85934 100644
--- a/crates/abigail-core/src/vault/unlock.rs
+++ b/crates/abigail-core/src/vault/unlock.rs
@@ -21,6 +21,8 @@ const PASSPHRASE_ENV: &str = "ABIGAIL_VAULT_PASSPHRASE";
 const RAW_KEK_ENV: &str = "ABIGAIL_VAULT_RAW_KEY";
 const PASSPHRASE_SALT: &[u8] = b"abigail-vault-passphrase-salt-v1";
 const KDF_METADATA_FILE: &str = "vault.kdf.json";
+const PROCESS_VAULT_DATA_DIR_ENV: &str = "ABIGAIL_VAULT_DATA_DIR";
+#[cfg(windows)]
 const WINDOWS_KEK_FALLBACK_FILE: &str = "vault.kek.dpapi";
 const ARGON2_MEMORY_COST_KIB: u32 = 64 * 1024;
 const ARGON2_TIME_COST: u32 = 3;
@@ -84,13 +86,26 @@ impl Default for HybridUnlockProvider {
     }
 }
 
+pub fn configure_process_vault_data_dir(data_root: &Path) {
+    std::env::set_var(PROCESS_VAULT_DATA_DIR_ENV, data_root);
+}
+
+pub fn process_vault_data_dir() -> PathBuf {
+    if let Some(path) = std::env::var_os(PROCESS_VAULT_DATA_DIR_ENV) {
+        if !path.is_empty() {
+            return PathBuf::from(path);
+        }
+    }
+    crate::AppConfig::default_paths().data_dir
+}
+
 impl UnlockProvider for HybridUnlockProvider {
     fn root_kek(&self) -> Result<[u8; KEK_LEN]> {
         if let Some(kek) = super::cached_session_root_kek() {
             return Ok(kek);
         }
 
-        let data_root = crate::AppConfig::default_paths().data_dir;
+        let data_root = process_vault_data_dir();
         std::fs::create_dir_all(&data_root)?;
         let sentinel_path = super::sentinel_path(&data_root);
         let has_sentinel = sentinel_path.exists();
@@ -384,6 +399,7 @@ fn os_keyring_store_verified(kek: &[u8; KEK_LEN]) -> Result<()> {
     Ok(())
 }
 
+#[cfg(windows)]
 fn windows_kek_fallback_path(data_root: &Path) -> PathBuf {
     data_root.join(WINDOWS_KEK_FALLBACK_FILE)
 }
@@ -455,6 +471,7 @@ mod tests {
         assert_ne!(a.root_kek().unwrap(), b.root_kek().unwrap());
     }
 
+    #[cfg(windows)]
     #[test]
     fn windows_kek_fallback_roundtrips() {
         let dir = std::env::temp_dir().join("abigail_windows_kek_fallback_roundtrip");
@@ -471,6 +488,22 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
 
+    #[cfg(not(windows))]
+    #[test]
+    fn windows_kek_fallback_is_disabled_off_windows() {
+        let dir = std::env::temp_dir().join("abigail_windows_kek_fallback_disabled");
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+
+        let mut kek = [0u8; KEK_LEN];
+        kek.copy_from_slice(&[7u8; KEK_LEN]);
+
+        persist_windows_kek_fallback(&dir, &kek).unwrap();
+        assert!(load_windows_kek_fallback_optional(&dir).unwrap().is_none());
+
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
     #[test]
     fn fresh_passphrase_bootstrap_creates_argon2_metadata() {
         let dir = std::env::temp_dir().join("abigail_unlock_argon2_metadata");
diff --git a/crates/abigail-hive/src/hive.rs b/crates/abigail-hive/src/hive.rs
index 23f4716c..676e1d3c 100644
--- a/crates/abigail-hive/src/hive.rs
+++ b/crates/abigail-hive/src/hive.rs
@@ -216,6 +216,62 @@ impl Hive {
         None
     }
 
+    /// Resolve a named provider profile for sub-agent delegation.
+    ///
+    /// The profile name is a provider name ("openai", "anthropic",
+    /// "perplexity", "google", "xai", or a CLI provider). Credentials are
+    /// resolved through the entity vault, then the hive vault, then
+    /// environment variables. CLI providers fall back to system auth.
+    pub fn resolve_provider_profile(&self, name: &str) -> Option<ProviderSelection> {
+        let name = name.trim().to_lowercase();
+        if name.is_empty() {
+            return None;
+        }
+
+        for vault in [&self.secrets, &self.hive_secrets] {
+            if let Ok(guard) = vault.lock() {
+                if let Some(key) = guard
+                    .get_secret(&name)
+                    .map(str::trim)
+                    .filter(|key| !key.is_empty())
+                {
+                    return Some(ProviderSelection {
+                        provider: name.clone(),
+                        auth: ProviderAuth::ApiKey(key.to_string()),
+                    });
+                }
+            }
+        }
+
+        let env_var = match name.as_str() {
+            "openai" => Some("OPENAI_API_KEY"),
+            "anthropic" => Some("ANTHROPIC_API_KEY"),
+            "perplexity" => Some("PERPLEXITY_API_KEY"),
+            "google" => Some("GEMINI_API_KEY"),
+            "xai" => Some("XAI_API_KEY"),
+            _ => None,
+        };
+        if let Some(var) = env_var {
+            if let Ok(key) = std::env::var(var) {
+                let key = key.trim().to_string();
+                if !key.is_empty() {
+                    return Some(ProviderSelection {
+                        provider: name,
+                        auth: ProviderAuth::ApiKey(key),
+                    });
+                }
+            }
+        }
+
+        if Self::is_cli_provider(&name) {
+            return Some(ProviderSelection {
+                provider: name,
+                auth: ProviderAuth::System,
+            });
+        }
+        None
+    }
+
     /// Detect CLI tools installed on PATH that can serve as Ego providers
     /// via their own authentication (OAuth / `claude auth login`).
     fn detect_cli_on_path() -> Option<ProviderSelection> {
diff --git a/crates/abigail-id/src/monitor.rs b/crates/abigail-id/src/monitor.rs
index d341c81f..56c72986 100644
--- a/crates/abigail-id/src/monitor.rs
+++ b/crates/abigail-id/src/monitor.rs
@@ -1,13 +1,15 @@
 //! Out-of-band Id monitor for quick safety/feasibility checks.
 
-use abigail_streaming::{StreamBroker, StreamMessage, SubscriptionHandle, TopicConfig};
+use abigail_streaming::{
+    StreamBroker, StreamMessage, SubscriptionHandle, Topic, TopicConfig, BUS_STREAM,
+};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
 
-const STREAM: &str = "entity";
-const CHAT_TOPIC: &str = "chat-topic";
-const SIGNAL_TOPIC: &str = "id-signals";
+const STREAM: &str = BUS_STREAM;
+const CHAT_TOPIC: &str = Topic::MentorInput.as_str();
+const SIGNAL_TOPIC: &str = Topic::IdSignal.as_str();
 const CONSUMER_GROUP: &str = "id-monitor";
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/crates/abigail-identity/src/lib.rs b/crates/abigail-identity/src/lib.rs
index 2730793f..fea0ec19 100644
--- a/crates/abigail-identity/src/lib.rs
+++ b/crates/abigail-identity/src/lib.rs
@@ -536,6 +536,21 @@ impl IdentityManager {
         Ok(())
     }
 
+    /// Sign an arbitrary payload with the Hive master key.
+    ///
+    /// Returns `(signature_hex, master_public_key_hex)`. Used for artifacts
+    /// the Hive vouches for, like birth certificates.
+    pub fn sign_payload(&self, payload: &[u8]) -> (String, String) {
+        use ed25519_dalek::Signer as _;
+        let signature = self.master_key.sign(payload);
+        let to_hex =
+            |bytes: &[u8]| -> String { bytes.iter().map(|b| format!("{:02x}", b)).collect() };
+        (
+            to_hex(&signature.to_bytes()),
+            to_hex(&self.master_key.verifying_key().to_bytes()),
+        )
+    }
+
     /// Get the agent directory path for a given UUID.
     pub fn agent_dir(&self, agent_id: &str) -> Result<PathBuf, String> {
         let gc = self.global_config.read().map_err(|e| e.to_string())?;
diff --git a/crates/abigail-memory/src/store.rs b/crates/abigail-memory/src/store.rs
index f1bc0e36..378f4f27 100644
--- a/crates/abigail-memory/src/store.rs
+++ b/crates/abigail-memory/src/store.rs
@@ -339,7 +339,7 @@ impl MemoryStore {
             .into_iter()
             .filter(|memory| contains_case_insensitive(&memory.content, &query))
             .collect();
-        memories.sort_by(|left, right| right.created_at.cmp(&left.created_at));
+        memories.sort_by_key(|memory| std::cmp::Reverse(memory.created_at));
         memories.truncate(limit);
         Ok(memories)
     }
@@ -378,7 +378,7 @@ impl MemoryStore {
             .into_iter()
             .map(TryFrom::try_from)
             .collect::<Result<Vec<_>>>()?;
-        turns.sort_by(|left, right| left.turn_number.cmp(&right.turn_number));
+        turns.sort_by_key(|turn| turn.turn_number);
         Ok(turns)
     }
 
@@ -401,7 +401,7 @@ impl MemoryStore {
             .into_iter()
             .filter(|turn| contains_case_insensitive(&turn.content, &query))
             .collect();
-        turns.sort_by(|left, right| right.created_at.cmp(&left.created_at));
+        turns.sort_by_key(|turn| std::cmp::Reverse(turn.created_at));
         turns.truncate(limit);
         Ok(turns)
     }
diff --git a/crates/abigail-memory/src/subscriber.rs b/crates/abigail-memory/src/subscriber.rs
index 8415c31c..d1a6f69b 100644
--- a/crates/abigail-memory/src/subscriber.rs
+++ b/crates/abigail-memory/src/subscriber.rs
@@ -1,14 +1,14 @@
 //! Out-of-band chat-topic subscriber for memory correlation persistence.
 
 use crate::{plan_secret_move, ConversationTurn, MemoryStore};
-use abigail_streaming::{StreamBroker, SubscriptionHandle, TopicConfig};
+use abigail_streaming::{StreamBroker, SubscriptionHandle, Topic, TopicConfig, BUS_STREAM};
 use serde::{Deserialize, Serialize};
 use std::io::Write;
 use std::path::Path;
 use std::sync::Arc;
 
-const STREAM: &str = "entity";
-const TOPIC: &str = "chat-topic";
+const STREAM: &str = BUS_STREAM;
+const TOPIC: &str = Topic::MentorInput.as_str();
 const CONSUMER_GROUP: &str = "memory-chat-topic-subscriber";
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -95,7 +95,7 @@ pub async fn spawn_chat_topic_subscriber(
                     &env.session_id,
                     "user",
                     &env.message,
-                    "entity/chat-topic",
+                    "entity/mentor.input",
                 ) {
                     tracing::warn!(
                         "memory chat-topic subscriber: failed to capture protected secret: {}",
diff --git a/crates/abigail-persistence/src/client.rs b/crates/abigail-persistence/src/client.rs
index 1a5dddbf..c8130347 100644
--- a/crates/abigail-persistence/src/client.rs
+++ b/crates/abigail-persistence/src/client.rs
@@ -376,6 +376,7 @@ fn file_engine_cache() -> &'static Mutex<HashMap<PathBuf, Arc<Surreal<Db>>>> {
 }
 
 fn local_engine_open_path(path: &Path) -> String {
+    #[allow(unused_mut)]
     let mut raw = path.to_string_lossy().replace('\\', "/");
 
     #[cfg(windows)]
diff --git a/crates/abigail-queue/src/queue.rs b/crates/abigail-queue/src/queue.rs
index 6673b2ab..99ce49bf 100644
--- a/crates/abigail-queue/src/queue.rs
+++ b/crates/abigail-queue/src/queue.rs
@@ -8,6 +8,10 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::broadcast;
 
+/// Maximum sub-agent nesting depth: a mentor-initiated job (depth 0) may
+/// spawn sub-jobs (depth 1) which may spawn one more level (depth 2).
+pub const MAX_SUBAGENT_DEPTH: u32 = 2;
+
 pub struct JobQueue {
     store: PersistenceHandle,
     broker: Arc<dyn StreamBroker>,
@@ -15,8 +19,8 @@ pub struct JobQueue {
 }
 
 impl JobQueue {
-    const STREAM: &'static str = "abigail";
-    const TOPIC: &'static str = "job-events";
+    const STREAM: &'static str = abigail_streaming::BUS_STREAM;
+    const TOPIC: &'static str = abigail_streaming::Topic::JobEvents.as_str();
 
     pub fn new(store: PersistenceHandle, broker: Arc<dyn StreamBroker>) -> Self {
         let (local_bus, _) = broadcast::channel(256);
@@ -32,6 +36,13 @@ impl JobQueue {
     }
 
     pub async fn submit_job(&self, spec: JobSpec) -> anyhow::Result<JobId> {
+        if spec.depth > MAX_SUBAGENT_DEPTH {
+            anyhow::bail!(
+                "Job depth {} exceeds the sub-agent nesting limit ({})",
+                spec.depth,
+                MAX_SUBAGENT_DEPTH
+            );
+        }
         let job_id = uuid::Uuid::new_v4().to_string();
         let now = Utc::now();
         let record = JobRecord {
@@ -47,6 +58,9 @@ impl JobQueue {
             allowed_skill_ids: spec.allowed_skill_ids,
             input_data: spec.input_data,
             parent_job_id: spec.parent_job_id,
+            parent_correlation_id: spec.parent_correlation_id,
+            depth: spec.depth,
+            provider_profile: spec.provider_profile,
             agent_id: None,
             model_used: None,
             provider_used: None,
@@ -353,6 +367,9 @@ impl JobQueue {
             ttl_seconds: template.ttl_seconds,
             input_data: template.input_data.clone(),
             parent_job_id: Some(template.id.clone()),
+            parent_correlation_id: template.parent_correlation_id.clone(),
+            depth: template.depth,
+            provider_profile: template.provider_profile.clone(),
             cron_expression: None,
             is_recurring: false,
             significance_keywords: template.significance_keywords.clone(),
@@ -443,6 +460,9 @@ mod tests {
             ttl_seconds: 3600,
             input_data: None,
             parent_job_id: None,
+            parent_correlation_id: None,
+            depth: 0,
+            provider_profile: None,
             cron_expression: None,
             is_recurring: false,
             significance_keywords: vec![],
@@ -465,6 +485,35 @@ mod tests {
         assert_eq!(record.topic, "test-topic");
     }
 
+    #[tokio::test]
+    async fn test_submit_rejects_excess_depth() {
+        let queue = setup_test_queue();
+
+        let mut at_limit = test_spec("depth-ok");
+        at_limit.depth = MAX_SUBAGENT_DEPTH;
+        assert!(queue.submit_job(at_limit).await.is_ok());
+
+        let mut too_deep = test_spec("depth-exceeded");
+        too_deep.depth = MAX_SUBAGENT_DEPTH + 1;
+        let err = queue.submit_job(too_deep).await.unwrap_err();
+        assert!(err.to_string().contains("nesting limit"));
+    }
+
+    #[tokio::test]
+    async fn test_submit_carries_provider_profile_and_correlation() {
+        let queue = setup_test_queue();
+        let mut spec = test_spec("profile-topic");
+        spec.provider_profile = Some("perplexity".to_string());
+        spec.parent_correlation_id = Some("turn-123".to_string());
+        spec.depth = 1;
+
+        let job_id = queue.submit_job(spec).await.unwrap();
+        let record = queue.get_job(&job_id).unwrap().unwrap();
+        assert_eq!(record.provider_profile.as_deref(), Some("perplexity"));
+        assert_eq!(record.parent_correlation_id.as_deref(), Some("turn-123"));
+        assert_eq!(record.depth, 1);
+    }
+
     #[tokio::test]
     async fn test_job_lifecycle() {
         let queue = setup_test_queue();
diff --git a/crates/abigail-queue/src/types.rs b/crates/abigail-queue/src/types.rs
index 2845ff3d..284c7925 100644
--- a/crates/abigail-queue/src/types.rs
+++ b/crates/abigail-queue/src/types.rs
@@ -193,6 +193,18 @@ pub struct JobSpec {
     /// Parent job for chaining/dependency.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub parent_job_id: Option<JobId>,
+    /// Correlation id of the chat turn (or parent run) that spawned this job.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parent_correlation_id: Option<String>,
+    /// Nesting depth: 0 = mentor-initiated, 1 = spawned by a sub-agent, etc.
+    /// Submissions beyond [`crate::queue::MAX_SUBAGENT_DEPTH`] are rejected.
+    #[serde(default)]
+    pub depth: u32,
+    /// Named provider profile to run this job on (e.g. "perplexity") —
+    /// resolved through the Hive so a sub-agent can use a different provider
+    /// than the entity's Ego.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider_profile: Option<String>,
     /// Cron expression (UTC) for recurring jobs. E.g. "0 */6 * * *".
     #[serde(skip_serializing_if = "Option::is_none")]
     pub cron_expression: Option<String>,
@@ -259,6 +271,15 @@ pub struct JobRecord {
     pub allowed_skill_ids: Vec<String>,
     pub input_data: Option<serde_json::Value>,
     pub parent_job_id: Option<JobId>,
+    /// Correlation id of the chat turn (or parent run) that spawned this job.
+    #[serde(default)]
+    pub parent_correlation_id: Option<String>,
+    /// Nesting depth: 0 = mentor-initiated, 1 = spawned by a sub-agent, etc.
+    #[serde(default)]
+    pub depth: u32,
+    /// Named provider profile this job runs on (None = entity's Ego).
+    #[serde(default)]
+    pub provider_profile: Option<String>,
     pub agent_id: Option<String>,
     pub model_used: Option<String>,
     pub provider_used: Option<String>,
@@ -443,6 +464,9 @@ mod tests {
             ttl_seconds: 1800,
             input_data: None,
             parent_job_id: None,
+            parent_correlation_id: None,
+            depth: 0,
+            provider_profile: None,
             cron_expression: None,
             is_recurring: false,
             significance_keywords: vec![],
diff --git a/crates/abigail-router/src/agentic.rs b/crates/abigail-router/src/agentic.rs
index 278b99c2..b7830c02 100644
--- a/crates/abigail-router/src/agentic.rs
+++ b/crates/abigail-router/src/agentic.rs
@@ -231,7 +231,10 @@ impl AgenticEngine {
         headers.insert("task_id".to_string(), task_id.to_string());
 
         let msg = abigail_streaming::StreamMessage::with_headers(payload, headers);
-        if let Err(e) = broker.publish("entity", &topic, msg).await {
+        if let Err(e) = broker
+            .publish(abigail_streaming::BUS_STREAM, &topic, msg)
+            .await
+        {
             tracing::debug!("Failed to publish AgenticEvent to broker: {}", e);
         }
     }
diff --git a/crates/abigail-router/src/conscience.rs b/crates/abigail-router/src/conscience.rs
index 53d3cf07..2589bfa0 100644
--- a/crates/abigail-router/src/conscience.rs
+++ b/crates/abigail-router/src/conscience.rs
@@ -1,23 +1,23 @@
 //! Conscience monitor — async ethical evaluation via StreamBroker topics.
 //!
 //! Replaces the synchronous `spawn_conscience_monitor()` stub with a topic-based
-//! consumer that subscribes to `"entity/conscience-check"`, evaluates requests
-//! against pattern rules, and publishes signals to `"entity/ethical-signals"`.
+//! consumer that subscribes to `Topic::ConscienceCheck`, evaluates requests
+//! against pattern rules, and publishes signals to `Topic::SuperegoEvaluation`.
 //!
 //! Phase 1: PII patterns, destructive keyword detection.
 //! Phase 2 (future): LLM-based ethical evaluation.
 
-use abigail_streaming::{StreamBroker, SubscriptionHandle, TopicConfig};
+use abigail_streaming::{StreamBroker, SubscriptionHandle, Topic, TopicConfig, BUS_STREAM};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
 
 /// Stream used for conscience events.
-const STREAM: &str = "entity";
+const STREAM: &str = BUS_STREAM;
 /// Topic for incoming conscience check requests.
-const CHECK_TOPIC: &str = "conscience-check";
+const CHECK_TOPIC: &str = Topic::ConscienceCheck.as_str();
 /// Topic for outgoing ethical signals.
-const SIGNAL_TOPIC: &str = "ethical-signals";
+const SIGNAL_TOPIC: &str = Topic::SuperegoEvaluation.as_str();
 
 /// A request to evaluate a message or action for ethical concerns.
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/crates/abigail-router/src/council.rs b/crates/abigail-router/src/council.rs
index 58146519..a93a3492 100644
--- a/crates/abigail-router/src/council.rs
+++ b/crates/abigail-router/src/council.rs
@@ -428,6 +428,9 @@ impl CouncilEngine {
                     "provider_name": name,
                 })),
                 parent_job_id: None,
+                parent_correlation_id: None,
+                depth: 1,
+                provider_profile: Some(name.clone()),
                 cron_expression: None,
                 is_recurring: false,
                 significance_keywords: vec![],
@@ -469,6 +472,9 @@ impl CouncilEngine {
                 "draft_job_ids": &draft_job_ids,
             })),
             parent_job_id: None,
+            parent_correlation_id: None,
+            depth: 1,
+            provider_profile: None,
             cron_expression: None,
             is_recurring: false,
             significance_keywords: vec![],
@@ -504,6 +510,9 @@ impl CouncilEngine {
                 "critique_job_id": &critique_job_id,
             })),
             parent_job_id: None,
+            parent_correlation_id: None,
+            depth: 1,
+            provider_profile: None,
             cron_expression: None,
             is_recurring: false,
             significance_keywords: vec![],
diff --git a/crates/abigail-router/src/lib.rs b/crates/abigail-router/src/lib.rs
index e5e45aba..ae0eb9ed 100644
--- a/crates/abigail-router/src/lib.rs
+++ b/crates/abigail-router/src/lib.rs
@@ -5,7 +5,6 @@ pub mod council;
 pub mod execution_state;
 pub mod governor;
 pub mod monitor;
-pub mod orchestration;
 pub mod planner;
 pub mod router;
 pub mod subagent;
@@ -22,10 +21,6 @@ pub use governor::{ExecutionGovernor, GovernedResult};
 pub use monitor::mentor_chat::{
     inject_preprompt, request_enriched_preprompt, MentorChatEnvelope, MentorChatMonitor,
 };
-#[allow(deprecated)]
-pub use orchestration::{
-    JobMode, OrchestrationJob, OrchestrationJobLog, OrchestrationScheduler, SignificancePolicy,
-};
 pub use planner::{GoalFrame, Planner};
 pub use router::{
     ConscienceVerdict, EgoProvider, FastPathResult, FastPathTarget, IdEgoRouter, RouterStatusInfo,
diff --git a/crates/abigail-router/src/monitor/mentor_chat.rs b/crates/abigail-router/src/monitor/mentor_chat.rs
index 2daf7f05..ba8e6ac8 100644
--- a/crates/abigail-router/src/monitor/mentor_chat.rs
+++ b/crates/abigail-router/src/monitor/mentor_chat.rs
@@ -1,15 +1,17 @@
 //! Mentor chat monitor for preprompt enrichment over topic transport.
 //!
 //! Flow:
-//! 1) request envelope is published to `entity/chat-topic`
+//! 1) request envelope is published to `Topic::MentorInput`
 //! 2) monitor subscriber injects minimal preprompt + id/superego context
-//! 3) enriched envelope is republished to `entity/chat-topic`
+//! 3) enriched envelope is republished to `Topic::MentorInput`
 
 use crate::router::IdEgoRouter;
 use abigail_core::constitutional::{
     infer_id_context, infer_superego_context, load_minimal_preprompt,
 };
-use abigail_streaming::{StreamBroker, StreamMessage, SubscriptionHandle, TopicConfig};
+use abigail_streaming::{
+    StreamBroker, StreamMessage, SubscriptionHandle, Topic, TopicConfig, BUS_STREAM,
+};
 use chrono::Utc;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -18,8 +20,8 @@ use std::path::Path;
 use std::sync::Arc;
 use std::time::Duration;
 
-pub const STREAM: &str = "entity";
-pub const CHAT_TOPIC: &str = "chat-topic";
+pub const STREAM: &str = BUS_STREAM;
+pub const CHAT_TOPIC: &str = Topic::MentorInput.as_str();
 const MONITOR_GROUP: &str = "mentor-chat-monitor";
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/crates/abigail-router/src/orchestration.rs b/crates/abigail-router/src/orchestration.rs
deleted file mode 100644
index 887c8cd2..00000000
--- a/crates/abigail-router/src/orchestration.rs
+++ /dev/null
@@ -1,360 +0,0 @@
-//! Orchestration scheduler — cron-based job scheduling for agentic runs.
-
-use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
-use std::sync::Arc;
-use tokio::sync::RwLock;
-
-/// An orchestration job that can be scheduled to run periodically.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct OrchestrationJob {
-    /// Unique job identifier.
-    pub job_id: String,
-    /// Human-readable name.
-    pub name: String,
-    /// Cron expression (UTC). E.g. "0 */6 * * *" for every 6 hours.
-    pub cron_expression: String,
-    /// Execution mode.
-    pub mode: JobMode,
-    /// Goal template (used when mode is AgenticRun).
-    pub goal_template: Option<String>,
-    /// Whether the job is enabled.
-    pub enabled: bool,
-    /// Significance policy for deciding how to handle results.
-    #[serde(default)]
-    pub significance_policy: SignificancePolicy,
-    /// ISO 8601 timestamp of creation.
-    pub created_at: String,
-    /// ISO 8601 timestamp of last modification.
-    pub updated_at: String,
-}
-
-/// How the job executes.
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum JobMode {
-    /// Quick Id check — uses local LLM for a simple assessment.
-    IdCheck,
-    /// Full agentic run with governor.
-    AgenticRun,
-}
-
-/// How to assess and react to job results.
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct SignificancePolicy {
-    /// Keywords that indicate significance (e.g. "urgent", "error", "alert").
-    #[serde(default)]
-    pub keywords: Vec<String>,
-    /// Minimum significance score (0.0–1.0) to trigger notification.
-    #[serde(default = "default_threshold")]
-    pub threshold: f32,
-}
-
-fn default_threshold() -> f32 {
-    0.5
-}
-
-/// What to do with a job's result based on significance scoring.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum SignificanceDecision {
-    /// Low significance — just log it silently.
-    SilentLog,
-    /// Medium significance — spawn an agentic run to handle it.
-    SpawnAgentic,
-    /// High significance — flag the mentor for attention.
-    FlagMentor,
-}
-
-/// Log entry for a completed orchestration job run.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct OrchestrationJobLog {
-    /// Job ID that generated this log.
-    pub job_id: String,
-    /// Unique run ID.
-    pub run_id: String,
-    /// ISO 8601 timestamp of when the job ran.
-    pub ran_at: String,
-    /// Result summary.
-    pub result: String,
-    /// Significance decision made.
-    pub decision: SignificanceDecision,
-    /// Duration in milliseconds.
-    pub duration_ms: u64,
-}
-
-/// Manages orchestration jobs and their execution.
-///
-/// **Deprecated**: Use `abigail_queue::JobQueue` with `is_recurring = true` and
-/// `cron_expression` fields instead. This scheduler uses JSON files and has a stub
-/// `check_due_jobs()`. The JobQueue-based scheduler in `entity-daemon::job_scheduler`
-/// provides durable persistence, StreamBroker events, and real cron evaluation.
-#[deprecated(
-    since = "0.4.0",
-    note = "Use abigail_queue::JobQueue recurring jobs instead. See entity-daemon::job_scheduler."
-)]
-pub struct OrchestrationScheduler {
-    jobs: Arc<RwLock<Vec<OrchestrationJob>>>,
-    logs: Arc<RwLock<Vec<OrchestrationJobLog>>>,
-    jobs_path: PathBuf,
-    logs_path: PathBuf,
-}
-
-#[allow(deprecated)]
-impl OrchestrationScheduler {
-    /// Create a new scheduler, loading persisted state from the data directory.
-    pub fn new(data_dir: PathBuf) -> Self {
-        let jobs_path = data_dir.join("orchestration_jobs.json");
-        let logs_path = data_dir.join("orchestration_job_logs.json");
-
-        let jobs = if jobs_path.exists() {
-            match std::fs::read_to_string(&jobs_path) {
-                Ok(content) => serde_json::from_str(&content).unwrap_or_default(),
-                Err(_) => Vec::new(),
-            }
-        } else {
-            Vec::new()
-        };
-
-        let logs = if logs_path.exists() {
-            match std::fs::read_to_string(&logs_path) {
-                Ok(content) => serde_json::from_str(&content).unwrap_or_default(),
-                Err(_) => Vec::new(),
-            }
-        } else {
-            Vec::new()
-        };
-
-        Self {
-            jobs: Arc::new(RwLock::new(jobs)),
-            logs: Arc::new(RwLock::new(logs)),
-            jobs_path,
-            logs_path,
-        }
-    }
-
-    /// List all jobs.
-    pub async fn list_jobs(&self) -> Vec<OrchestrationJob> {
-        self.jobs.read().await.clone()
-    }
-
-    /// Create a new job.
-    pub async fn create_job(&self, job: OrchestrationJob) -> anyhow::Result<String> {
-        let job_id = job.job_id.clone();
-        {
-            let mut jobs = self.jobs.write().await;
-            jobs.push(job);
-        }
-        self.save_jobs().await?;
-        Ok(job_id)
-    }
-
-    /// Update an existing job.
-    pub async fn update_job(&self, job_id: &str, update: OrchestrationJob) -> anyhow::Result<()> {
-        let mut jobs = self.jobs.write().await;
-        if let Some(existing) = jobs.iter_mut().find(|j| j.job_id == job_id) {
-            *existing = update;
-        } else {
-            anyhow::bail!("Job not found: {}", job_id);
-        }
-        drop(jobs);
-        self.save_jobs().await
-    }
-
-    /// Delete a job.
-    pub async fn delete_job(&self, job_id: &str) -> anyhow::Result<()> {
-        let mut jobs = self.jobs.write().await;
-        let before = jobs.len();
-        jobs.retain(|j| j.job_id != job_id);
-        if jobs.len() == before {
-            anyhow::bail!("Job not found: {}", job_id);
-        }
-        drop(jobs);
-        self.save_jobs().await
-    }
-
-    /// Enable or disable a job.
-    pub async fn set_enabled(&self, job_id: &str, enabled: bool) -> anyhow::Result<()> {
-        let mut jobs = self.jobs.write().await;
-        if let Some(job) = jobs.iter_mut().find(|j| j.job_id == job_id) {
-            job.enabled = enabled;
-            job.updated_at = chrono::Utc::now().to_rfc3339();
-        } else {
-            anyhow::bail!("Job not found: {}", job_id);
-        }
-        drop(jobs);
-        self.save_jobs().await
-    }
-
-    /// Get logs for all jobs or a specific job.
-    pub async fn get_logs(&self, job_id: Option<&str>) -> Vec<OrchestrationJobLog> {
-        let logs = self.logs.read().await;
-        match job_id {
-            Some(id) => logs.iter().filter(|l| l.job_id == id).cloned().collect(),
-            None => logs.clone(),
-        }
-    }
-
-    /// Record a job execution log.
-    pub async fn record_log(&self, log: OrchestrationJobLog) -> anyhow::Result<()> {
-        {
-            let mut logs = self.logs.write().await;
-            logs.push(log);
-            // Keep last 1000 logs
-            if logs.len() > 1000 {
-                let drain_count = logs.len() - 1000;
-                logs.drain(..drain_count);
-            }
-        }
-        self.save_logs().await
-    }
-
-    /// Score the significance of a result based on the job's policy.
-    pub fn score_significance(
-        result: &str,
-        policy: &SignificancePolicy,
-    ) -> (f32, SignificanceDecision) {
-        let lower = result.to_lowercase();
-        let mut score: f32 = 0.0;
-
-        // Keyword matching
-        for keyword in &policy.keywords {
-            if lower.contains(&keyword.to_lowercase()) {
-                score += 0.3;
-            }
-        }
-
-        // Built-in significance indicators
-        let urgent_keywords = ["urgent", "error", "failure", "critical", "alert", "warning"];
-        for kw in &urgent_keywords {
-            if lower.contains(kw) {
-                score += 0.2;
-            }
-        }
-
-        score = score.min(1.0);
-
-        let decision = if score >= 0.8 {
-            SignificanceDecision::FlagMentor
-        } else if score >= policy.threshold {
-            SignificanceDecision::SpawnAgentic
-        } else {
-            SignificanceDecision::SilentLog
-        };
-
-        (score, decision)
-    }
-
-    /// Check which jobs are due to run now.
-    /// Returns job IDs that should be triggered.
-    pub async fn check_due_jobs(&self) -> Vec<String> {
-        // Simple implementation: check if any enabled jobs match the current minute
-        // A full cron parser would be used in production
-        let jobs = self.jobs.read().await;
-        jobs.iter()
-            .filter(|j| j.enabled)
-            .map(|j| j.job_id.clone())
-            .collect()
-    }
-
-    async fn save_jobs(&self) -> anyhow::Result<()> {
-        let jobs = self.jobs.read().await;
-        let content = serde_json::to_string_pretty(&*jobs)?;
-        if let Some(parent) = self.jobs_path.parent() {
-            std::fs::create_dir_all(parent)?;
-        }
-        std::fs::write(&self.jobs_path, content)?;
-        Ok(())
-    }
-
-    async fn save_logs(&self) -> anyhow::Result<()> {
-        let logs = self.logs.read().await;
-        let content = serde_json::to_string_pretty(&*logs)?;
-        std::fs::write(&self.logs_path, content)?;
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-#[allow(deprecated)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_significance_scoring_low() {
-        let policy = SignificancePolicy {
-            keywords: vec!["important".into()],
-            threshold: 0.5,
-        };
-        let (score, decision) = OrchestrationScheduler::score_significance(
-            "Nothing interesting happened today",
-            &policy,
-        );
-        assert!(score < 0.5);
-        assert_eq!(decision, SignificanceDecision::SilentLog);
-    }
-
-    #[test]
-    fn test_significance_scoring_high() {
-        let policy = SignificancePolicy {
-            keywords: vec!["important".into()],
-            threshold: 0.5,
-        };
-        let (score, decision) = OrchestrationScheduler::score_significance(
-            "URGENT ALERT: critical error detected, this is important",
-            &policy,
-        );
-        assert!(score >= 0.8);
-        assert_eq!(decision, SignificanceDecision::FlagMentor);
-    }
-
-    #[test]
-    fn test_significance_scoring_medium() {
-        let policy = SignificancePolicy {
-            keywords: vec!["deploy".into()],
-            threshold: 0.3,
-        };
-        let (_, decision) = OrchestrationScheduler::score_significance(
-            "New deploy available with a warning",
-            &policy,
-        );
-        assert_eq!(decision, SignificanceDecision::SpawnAgentic);
-    }
-
-    #[tokio::test]
-    async fn test_scheduler_crud() {
-        let tmp = std::env::temp_dir().join("abigail_orch_test");
-        let _ = std::fs::remove_dir_all(&tmp);
-        std::fs::create_dir_all(&tmp).unwrap();
-
-        let scheduler = OrchestrationScheduler::new(tmp.clone());
-
-        let now = chrono::Utc::now().to_rfc3339();
-        let job = OrchestrationJob {
-            job_id: "job-1".into(),
-            name: "Test Job".into(),
-            cron_expression: "0 * * * *".into(),
-            mode: JobMode::IdCheck,
-            goal_template: None,
-            enabled: true,
-            significance_policy: SignificancePolicy::default(),
-            created_at: now.clone(),
-            updated_at: now,
-        };
-
-        scheduler.create_job(job).await.unwrap();
-        let jobs = scheduler.list_jobs().await;
-        assert_eq!(jobs.len(), 1);
-        assert_eq!(jobs[0].name, "Test Job");
-
-        scheduler.set_enabled("job-1", false).await.unwrap();
-        let jobs = scheduler.list_jobs().await;
-        assert!(!jobs[0].enabled);
-
-        scheduler.delete_job("job-1").await.unwrap();
-        let jobs = scheduler.list_jobs().await;
-        assert!(jobs.is_empty());
-
-        let _ = std::fs::remove_dir_all(&tmp);
-    }
-}
diff --git a/crates/abigail-router/src/router.rs b/crates/abigail-router/src/router.rs
index 2115eafa..14a4f034 100644
--- a/crates/abigail-router/src/router.rs
+++ b/crates/abigail-router/src/router.rs
@@ -204,8 +204,13 @@ pub struct IdEgoRouter {
     pub local_http: Option<Arc<LocalHttpProvider>>,
     pub mode: RoutingMode,
     selected_chat_model: Arc<RwLock<Option<String>>>,
+    /// Ring buffer of recent model-call outcomes (newest first via `health_board`).
+    health: Arc<RwLock<std::collections::VecDeque<entity_core::ProviderHealthEntry>>>,
 }
 
+/// How many recent model-call outcomes the health board retains.
+const HEALTH_BOARD_CAPACITY: usize = 32;
+
 impl IdEgoRouter {
     /// Chooses Id vs Ego for the main routing path. Chat and direct user prompts
     /// always use Ego when available; Id is reserved for background tasks
@@ -286,6 +291,48 @@ impl IdEgoRouter {
         }
     }
 
+    /// Recent model-call health, newest first.
+    pub fn health_board(&self) -> Vec<entity_core::ProviderHealthEntry> {
+        self.health
+            .read()
+            .map(|board| board.iter().rev().cloned().collect())
+            .unwrap_or_default()
+    }
+
+    fn record_health(&self, entry: entity_core::ProviderHealthEntry) {
+        if let Ok(mut board) = self.health.write() {
+            if board.len() >= HEALTH_BOARD_CAPACITY {
+                board.pop_front();
+            }
+            board.push_back(entry);
+        }
+    }
+
+    /// Derive health entries from a completed turn's trace: every error step
+    /// is "degraded"; the serving step is "healthy" or "fallback".
+    fn record_health_from_trace(&self, trace: &entity_core::ExecutionTrace) {
+        for step in &trace.steps {
+            let succeeded = matches!(step.result, entity_core::StepResult::Success);
+            let state = if !succeeded {
+                "degraded"
+            } else if trace.fallback_occurred {
+                "fallback"
+            } else {
+                "healthy"
+            };
+            self.record_health(entity_core::ProviderHealthEntry {
+                provider: step.provider_label.clone(),
+                model: step
+                    .model_reported
+                    .clone()
+                    .or_else(|| step.model_requested.clone()),
+                state: state.to_string(),
+                message: step.error_summary.clone(),
+                at_utc: step.ended_at_utc.clone(),
+            });
+        }
+    }
+
     /// Update the currently selected chat model (typically from UI dropdown model_override).
     pub fn set_selected_chat_model(&self, model: Option<String>) {
         let normalized = Self::normalize_model_name(model);
@@ -351,6 +398,7 @@ impl IdEgoRouter {
             local_http: id_result.local_http,
             mode,
             selected_chat_model: Arc::new(RwLock::new(None)),
+            health: Arc::new(RwLock::new(std::collections::VecDeque::new())),
         }
     }
 
@@ -372,6 +420,7 @@ impl IdEgoRouter {
             local_http: id_result.local_http,
             mode,
             selected_chat_model: Arc::new(RwLock::new(None)),
+            health: Arc::new(RwLock::new(std::collections::VecDeque::new())),
         }
     }
 
@@ -406,6 +455,7 @@ impl IdEgoRouter {
             local_http: providers.local_http,
             mode,
             selected_chat_model: Arc::new(RwLock::new(None)),
+            health: Arc::new(RwLock::new(std::collections::VecDeque::new())),
         };
 
         tracing::info!(
@@ -566,9 +616,12 @@ impl IdEgoRouter {
             model_override: model_override.clone(),
         };
 
-        let completion = self
+        let result = self
             .execute_with_fallback(&request, target, &model_override, req.stream_tx, &mut trace)
-            .await?;
+            .await;
+
+        self.record_health_from_trace(&trace);
+        let completion = result?;
 
         Ok(RoutingResponse {
             completion,
diff --git a/crates/abigail-skills/src/channel/event.rs b/crates/abigail-skills/src/channel/event.rs
index c567f5df..bdb5c0da 100644
--- a/crates/abigail-skills/src/channel/event.rs
+++ b/crates/abigail-skills/src/channel/event.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use crate::manifest::SkillId;
 
-/// Publish a skill event to the StreamBroker on the "abigail/skill-events" topic.
+/// Publish a skill event to the StreamBroker on `Topic::SkillExecuted`.
 /// Fire-and-forget: logs a warning on failure but never blocks the caller.
 pub async fn publish_skill_event(
     broker: &Arc<dyn abigail_streaming::StreamBroker>,
@@ -23,7 +23,14 @@ pub async fn publish_skill_event(
         .insert("skill_id".to_string(), event.skill_id.0.clone());
     msg.headers
         .insert("trigger".to_string(), event.trigger.clone());
-    if let Err(e) = broker.publish("abigail", "skill-events", msg).await {
+    if let Err(e) = broker
+        .publish(
+            abigail_streaming::BUS_STREAM,
+            abigail_streaming::Topic::SkillExecuted.as_str(),
+            msg,
+        )
+        .await
+    {
         tracing::warn!("Failed to publish skill event: {}", e);
     }
 }
diff --git a/crates/abigail-skills/src/executor.rs b/crates/abigail-skills/src/executor.rs
index 71e390b2..9d33f902 100644
--- a/crates/abigail-skills/src/executor.rs
+++ b/crates/abigail-skills/src/executor.rs
@@ -12,7 +12,7 @@ use tokio::sync::Semaphore;
 use crate::manifest::{FileSystemPermission, NetworkPermission, Permission, SkillId};
 use crate::registry::SkillRegistry;
 use crate::sandbox::{AuditAction, AuditActionKind, ResourceLimits, SkillSandbox};
-use crate::skill::{ExecutionContext, SkillError, SkillResult, ToolOutput, ToolParams};
+use crate::skill::{ExecutionContext, JobContext, SkillError, SkillResult, ToolOutput, ToolParams};
 
 pub struct SkillExecutor {
     pub registry: Arc<SkillRegistry>,
@@ -20,6 +20,22 @@ pub struct SkillExecutor {
     concurrency_limiter: Arc<Semaphore>,
     /// Default timeout for a single tool call (from ResourceLimits::max_cpu_ms).
     default_timeout_ms: u64,
+    /// Optional broker for `Topic::SkillExecuted` audit envelopes.
+    broker: Option<Arc<dyn abigail_streaming::StreamBroker>>,
+}
+
+/// Maximum characters of redacted params included in an audit event.
+const AUDIT_PARAMS_MAX_CHARS: usize = 800;
+
+/// One tool execution's audit data, bound for `Topic::SkillExecuted`.
+struct ExecutionAuditRecord {
+    skill_id: String,
+    tool_name: String,
+    request_id: String,
+    params_redacted: String,
+    success: bool,
+    error: Option<String>,
+    duration_ms: u64,
 }
 
 impl SkillExecutor {
@@ -33,9 +49,60 @@ impl SkillExecutor {
             registry,
             concurrency_limiter: Arc::new(Semaphore::new(limits.max_concurrency as usize)),
             default_timeout_ms: limits.max_cpu_ms,
+            broker: None,
         }
     }
 
+    /// Attach a stream broker; every tool execution then publishes a
+    /// `Topic::SkillExecuted` audit envelope (fire-and-forget).
+    pub fn with_broker(mut self, broker: Arc<dyn abigail_streaming::StreamBroker>) -> Self {
+        self.broker = Some(broker);
+        self
+    }
+
+    /// Publish a skill execution audit event. Params are secret-redacted and
+    /// truncated; failures are logged but never propagate to the caller.
+    fn publish_audit(&self, record: ExecutionAuditRecord) {
+        let Some(broker) = self.broker.clone() else {
+            return;
+        };
+        let payload = serde_json::json!({
+            "kind": "skill_execution",
+            "skill_id": record.skill_id,
+            "tool_name": record.tool_name,
+            "request_id": record.request_id,
+            "params": record.params_redacted,
+            "success": record.success,
+            "error": record.error,
+            "duration_ms": record.duration_ms,
+            "timestamp_utc": chrono::Utc::now().to_rfc3339(),
+        });
+        let mut msg = abigail_streaming::StreamMessage::new(payload.to_string().into_bytes());
+        msg.headers.insert("skill_id".to_string(), record.skill_id);
+        msg.headers
+            .insert("tool_name".to_string(), record.tool_name);
+        msg.headers
+            .insert("success".to_string(), record.success.to_string());
+        msg.headers
+            .insert("correlation_id".to_string(), record.request_id);
+        tokio::spawn(async move {
+            let topic = abigail_streaming::Topic::SkillExecuted;
+            let _ = broker
+                .ensure_topic(
+                    abigail_streaming::BUS_STREAM,
+                    topic.as_str(),
+                    abigail_streaming::TopicConfig::default(),
+                )
+                .await;
+            if let Err(e) = broker
+                .publish(abigail_streaming::BUS_STREAM, topic.as_str(), msg)
+                .await
+            {
+                tracing::debug!("Failed to publish skill execution audit: {}", e);
+            }
+        });
+    }
+
     /// Build audit actions for a tool based on its required_permissions.
     fn audit_actions_for_tool(
         _tool_name: &str,
@@ -89,7 +156,21 @@ impl SkillExecutor {
         tool_name: &str,
         params: ToolParams,
     ) -> SkillResult<ToolOutput> {
-        self.execute_with_confirmation(skill_id, tool_name, params, true)
+        self.execute_full(skill_id, tool_name, params, true, None)
+            .await
+    }
+
+    /// Execute a tool on behalf of a running job. The job's depth and
+    /// correlation id are threaded into the tool's [`ExecutionContext`] so
+    /// queue tools can derive child-job depth/correlation from the parent.
+    pub async fn execute_in_job_context(
+        &self,
+        skill_id: &SkillId,
+        tool_name: &str,
+        params: ToolParams,
+        job: Option<&JobContext>,
+    ) -> SkillResult<ToolOutput> {
+        self.execute_full(skill_id, tool_name, params, true, job)
             .await
     }
 
@@ -99,6 +180,18 @@ impl SkillExecutor {
         tool_name: &str,
         params: ToolParams,
         confirmed: bool,
+    ) -> SkillResult<ToolOutput> {
+        self.execute_full(skill_id, tool_name, params, confirmed, None)
+            .await
+    }
+
+    async fn execute_full(
+        &self,
+        skill_id: &SkillId,
+        tool_name: &str,
+        params: ToolParams,
+        confirmed: bool,
+        job: Option<&JobContext>,
     ) -> SkillResult<ToolOutput> {
         let request_id = Uuid::new_v4().to_string();
         tracing::info!(
@@ -157,9 +250,20 @@ impl SkillExecutor {
             .await
             .map_err(|_| SkillError::ToolFailed("concurrency limiter closed".into()))?;
 
+        // Snapshot params for the audit trail before they move into the tool:
+        // secret-redacted and truncated so keys never ride the bus.
+        let params_redacted: String = abigail_core::redact_secrets(
+            &serde_json::to_string(&params.values).unwrap_or_default(),
+        )
+        .chars()
+        .take(AUDIT_PARAMS_MAX_CHARS)
+        .collect();
+
         let context = ExecutionContext {
-            request_id,
+            request_id: request_id.clone(),
             user_id: None,
+            job_depth: job.map(|j| j.depth),
+            correlation_id: job.and_then(|j| j.correlation_id.clone()),
         };
 
         let timeout_ms = self.default_timeout_ms;
@@ -174,6 +278,15 @@ impl SkillExecutor {
                     duration_ms = duration_ms,
                     "Tool completed successfully"
                 );
+                self.publish_audit(ExecutionAuditRecord {
+                    skill_id: skill_id.0.clone(),
+                    tool_name: tool_name.to_string(),
+                    request_id: request_id.clone(),
+                    params_redacted,
+                    success: out.success,
+                    error: None,
+                    duration_ms,
+                });
                 Ok(out)
             }
             Ok(Err(e)) => {
@@ -185,6 +298,15 @@ impl SkillExecutor {
                     error = %e,
                     "Tool execution failed"
                 );
+                self.publish_audit(ExecutionAuditRecord {
+                    skill_id: skill_id.0.clone(),
+                    tool_name: tool_name.to_string(),
+                    request_id: request_id.clone(),
+                    params_redacted,
+                    success: false,
+                    error: Some(e.to_string()),
+                    duration_ms,
+                });
                 Err(e)
             }
             Err(_) => {
@@ -194,6 +316,15 @@ impl SkillExecutor {
                     timeout_ms = timeout_ms,
                     "Tool exceeded timeout"
                 );
+                self.publish_audit(ExecutionAuditRecord {
+                    skill_id: skill_id.0.clone(),
+                    tool_name: tool_name.to_string(),
+                    request_id: request_id.clone(),
+                    params_redacted,
+                    success: false,
+                    error: Some(format!("exceeded timeout ({} ms)", timeout_ms)),
+                    duration_ms: start.elapsed().as_millis() as u64,
+                });
                 Err(SkillError::ToolFailed(format!(
                     "Tool {} exceeded timeout ({} ms)",
                     tool_name, timeout_ms
@@ -1117,6 +1248,64 @@ mod tests {
         assert!(result.is_ok(), "confirmed execution should succeed");
     }
 
+    #[tokio::test]
+    async fn execute_publishes_skill_executed_audit() {
+        use abigail_streaming::{MemoryBroker, StreamBroker, Topic, TopicConfig, BUS_STREAM};
+
+        let registry = Arc::new(SkillRegistry::new());
+        let skill_id = SkillId("test.echo_audit".to_string());
+        let manifest = test_manifest("test.echo_audit", vec![]);
+        registry
+            .register(skill_id.clone(), Arc::new(EchoSkill { manifest }))
+            .unwrap();
+
+        let broker: Arc<dyn StreamBroker> = Arc::new(MemoryBroker::new(64));
+        broker
+            .ensure_topic(
+                BUS_STREAM,
+                Topic::SkillExecuted.as_str(),
+                TopicConfig::default(),
+            )
+            .await
+            .unwrap();
+        let (tx, mut rx) = tokio::sync::mpsc::channel::<abigail_streaming::StreamMessage>(4);
+        let _sub = broker
+            .subscribe(
+                BUS_STREAM,
+                Topic::SkillExecuted.as_str(),
+                "audit-test",
+                Box::new(move |msg| {
+                    let tx = tx.clone();
+                    Box::pin(async move {
+                        let _ = tx.send(msg).await;
+                    })
+                }),
+            )
+            .await
+            .unwrap();
+
+        let executor = SkillExecutor::new(registry).with_broker(broker);
+        let params = ToolParams::new().with("api_key", "sk-ant-secretsecretsecretsecret123456");
+        executor.execute(&skill_id, "echo", params).await.unwrap();
+
+        let msg = tokio::time::timeout(Duration::from_secs(2), rx.recv())
+            .await
+            .expect("audit event should arrive")
+            .expect("channel open");
+        assert_eq!(msg.headers.get("skill_id").unwrap(), "test.echo_audit");
+        assert_eq!(msg.headers.get("success").unwrap(), "true");
+        let payload: serde_json::Value = serde_json::from_slice(&msg.payload).unwrap();
+        assert_eq!(payload["kind"], "skill_execution");
+        assert_eq!(payload["tool_name"], "echo");
+        // The raw secret must never ride the bus.
+        let params_str = payload["params"].as_str().unwrap();
+        assert!(
+            !params_str.contains("secretsecretsecret"),
+            "params must be redacted, got: {}",
+            params_str
+        );
+    }
+
     #[tokio::test]
     async fn no_confirmation_tools_work_without_flag() {
         let registry = Arc::new(SkillRegistry::new());
diff --git a/crates/abigail-skills/src/instruction_registry.rs b/crates/abigail-skills/src/instruction_registry.rs
index 3ecabbb3..fab9aaa3 100644
--- a/crates/abigail-skills/src/instruction_registry.rs
+++ b/crates/abigail-skills/src/instruction_registry.rs
@@ -212,7 +212,7 @@ impl InstructionRegistry {
         }
 
         // Sort by specificity descending (more words = more specific = higher priority)
-        scored.sort_by(|a, b| b.2.cmp(&a.2));
+        scored.sort_by_key(|item| std::cmp::Reverse(item.2));
 
         let mut section = String::from("\n\n## Skill-Specific Instructions\n\n");
         let header_len = section.len();
diff --git a/crates/abigail-skills/src/lib.rs b/crates/abigail-skills/src/lib.rs
index a558d44d..dbab6ef7 100644
--- a/crates/abigail-skills/src/lib.rs
+++ b/crates/abigail-skills/src/lib.rs
@@ -175,8 +175,17 @@ pub async fn provision_all_skills(registry_path: &str) {
         return;
     };
 
-    let registry = load_persistent_topology_entries(registry_path)
-        .expect("Failed to load skills/registry.toml");
+    let registry = match load_persistent_topology_entries(registry_path) {
+        Ok(registry) => registry,
+        Err(error) => {
+            tracing::warn!(
+                "Skill topology provisioning skipped; unable to load registry at {}: {}",
+                registry_path,
+                error
+            );
+            return;
+        }
+    };
 
     let mut worker_handles: Vec<SubscriptionHandle> = Vec::new();
     let skill_count = registry.len();
diff --git a/crates/abigail-skills/src/queue.rs b/crates/abigail-skills/src/queue.rs
index e2871655..a2245421 100644
--- a/crates/abigail-skills/src/queue.rs
+++ b/crates/abigail-skills/src/queue.rs
@@ -81,7 +81,7 @@ impl Skill for QueueManagementSkill {
         vec![
             ToolDescriptor {
                 name: "submit_job".to_string(),
-                description: "Submit a new async job to the queue.".to_string(),
+                description: "Submit a new async job to the queue. Set provider_profile to run the sub-agent on a specific provider (e.g. 'perplexity' for research) instead of the entity's default.".to_string(),
                 parameters: serde_json::json!({
                     "type": "object",
                     "properties": {
@@ -95,7 +95,8 @@ impl Skill for QueueManagementSkill {
                         "allowed_skill_ids": { "type": "array", "items": { "type": "string" } },
                         "ttl_seconds": { "type": "integer" },
                         "input_data": {},
-                        "parent_job_id": { "type": "string" }
+                        "parent_job_id": { "type": "string" },
+                        "provider_profile": { "type": "string", "description": "Named provider to run this job on (openai, anthropic, perplexity, google, xai, or a CLI provider). Omit to use the entity's default." }
                     },
                     "required": ["goal", "topic"]
                 }),
@@ -174,7 +175,7 @@ impl Skill for QueueManagementSkill {
         &self,
         tool_name: &str,
         params: ToolParams,
-        _context: &ExecutionContext,
+        context: &ExecutionContext,
     ) -> SkillResult<ToolOutput> {
         match tool_name {
             "submit_job" => {
@@ -196,6 +197,16 @@ impl Skill for QueueManagementSkill {
                 let input_data = params.values.get("input_data").cloned();
                 let parent_job_id = params.get_string("parent_job_id");
 
+                // Depth derives from the job this tool call runs inside, never
+                // from model-supplied params: an agent at depth N can only
+                // create depth N+1 children, so the queue's nesting limit
+                // actually terminates recursive delegation.
+                let depth = context.job_depth.unwrap_or(0) + 1;
+                let parent_correlation_id = context
+                    .correlation_id
+                    .clone()
+                    .or_else(|| params.get_string("parent_correlation_id"));
+
                 let spec = JobSpec {
                     goal,
                     topic: topic.clone(),
@@ -208,6 +219,9 @@ impl Skill for QueueManagementSkill {
                     ttl_seconds,
                     input_data,
                     parent_job_id,
+                    parent_correlation_id,
+                    depth,
+                    provider_profile: params.get_string("provider_profile"),
                     cron_expression: params.get_string("cron_expression"),
                     is_recurring: params.get::<bool>("is_recurring").unwrap_or(false),
                     significance_keywords: params
@@ -318,6 +332,93 @@ impl Skill for QueueManagementSkill {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::skill::ExecutionContext;
+    use std::sync::Mutex;
+
+    #[derive(Default)]
+    struct RecordingOps {
+        submitted: Mutex<Vec<JobSpec>>,
+    }
+
+    #[async_trait]
+    impl QueueOperations for RecordingOps {
+        async fn submit_job(&self, spec: JobSpec) -> Result<String, String> {
+            self.submitted.lock().unwrap().push(spec);
+            Ok("job-1".to_string())
+        }
+        async fn get_job(&self, _job_id: &str) -> Result<Option<JobRecord>, String> {
+            Ok(None)
+        }
+        async fn list_jobs(
+            &self,
+            _status: Option<&str>,
+            _limit: usize,
+        ) -> Result<Vec<JobRecord>, String> {
+            Ok(vec![])
+        }
+        async fn cancel_job(&self, _job_id: &str) -> Result<(), String> {
+            Ok(())
+        }
+        async fn topic_results(
+            &self,
+            _topic: &str,
+            _limit: usize,
+        ) -> Result<Vec<JobRecord>, String> {
+            Ok(vec![])
+        }
+        async fn topic_all_terminal(&self, _topic: &str) -> Result<bool, String> {
+            Ok(true)
+        }
+    }
+
+    fn submit_params() -> ToolParams {
+        ToolParams::new()
+            .with("goal", "child task")
+            .with("topic", "test-topic")
+    }
+
+    #[tokio::test]
+    async fn submit_job_derives_depth_and_correlation_from_invoking_job() {
+        let ops = Arc::new(RecordingOps::default());
+        let skill = QueueManagementSkill::new(ops.clone());
+        let context = ExecutionContext {
+            job_depth: Some(1),
+            correlation_id: Some("turn-123".to_string()),
+            ..Default::default()
+        };
+        // Model-supplied depth must be ignored — only the real job depth counts.
+        let params = submit_params().with("depth", 0u32);
+        skill
+            .execute_tool("submit_job", params, &context)
+            .await
+            .unwrap();
+
+        let submitted = ops.submitted.lock().unwrap();
+        assert_eq!(submitted[0].depth, 2);
+        assert_eq!(
+            submitted[0].parent_correlation_id.as_deref(),
+            Some("turn-123")
+        );
+    }
+
+    #[tokio::test]
+    async fn submit_job_outside_job_context_starts_at_depth_one() {
+        let ops = Arc::new(RecordingOps::default());
+        let skill = QueueManagementSkill::new(ops.clone());
+        skill
+            .execute_tool("submit_job", submit_params(), &ExecutionContext::default())
+            .await
+            .unwrap();
+
+        let submitted = ops.submitted.lock().unwrap();
+        assert_eq!(submitted[0].depth, 1);
+        assert_eq!(submitted[0].parent_correlation_id, None);
+    }
+}
+
 fn parse_capability(value: Option<&str>) -> RequiredCapability {
     value
         .map(RequiredCapability::from_str_lossy)
diff --git a/crates/abigail-skills/src/sandbox.rs b/crates/abigail-skills/src/sandbox.rs
index 6240998b..30b7a587 100644
--- a/crates/abigail-skills/src/sandbox.rs
+++ b/crates/abigail-skills/src/sandbox.rs
@@ -196,10 +196,8 @@ impl SkillSandbox {
                         }
                         Permission::FileSystem(crate::manifest::FileSystemPermission::Read(
                             allowed,
-                        )) => {
-                            if allowed.iter().any(|a| path_is_under(path, a)) {
-                                return true;
-                            }
+                        )) if allowed.iter().any(|a| path_is_under(path, a)) => {
+                            return true;
                         }
                         _ => {}
                     }
@@ -214,10 +212,8 @@ impl SkillSandbox {
                         }
                         Permission::FileSystem(crate::manifest::FileSystemPermission::Write(
                             allowed,
-                        )) => {
-                            if allowed.iter().any(|a| path_is_under(path, a)) {
-                                return true;
-                            }
+                        )) if allowed.iter().any(|a| path_is_under(path, a)) => {
+                            return true;
                         }
                         _ => {}
                     }
@@ -231,10 +227,10 @@ impl SkillSandbox {
                         | Permission::Memory(crate::manifest::MemoryPermission::ReadWrite) => {
                             return true
                         }
-                        Permission::Memory(crate::manifest::MemoryPermission::Namespace(ns)) => {
-                            if namespace.as_ref().map(|n| n == ns).unwrap_or(false) {
-                                return true;
-                            }
+                        Permission::Memory(crate::manifest::MemoryPermission::Namespace(ns))
+                            if namespace.as_ref().map(|n| n == ns).unwrap_or(false) =>
+                        {
+                            return true;
                         }
                         _ => {}
                     }
diff --git a/crates/abigail-skills/src/skill.rs b/crates/abigail-skills/src/skill.rs
index 2c59756f..4d16b20c 100644
--- a/crates/abigail-skills/src/skill.rs
+++ b/crates/abigail-skills/src/skill.rs
@@ -177,10 +177,28 @@ pub struct ToolMetadata {
     pub extra: HashMap<String, serde_json::Value>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct ExecutionContext {
     pub request_id: String,
     pub user_id: Option<String>,
+    /// Depth of the job this tool call is running inside (`None` for direct
+    /// mentor/chat execution, which counts as depth 0).
+    pub job_depth: Option<u32>,
+    /// Correlation id of the originating trace, inherited by any child jobs
+    /// submitted during this execution.
+    pub correlation_id: Option<String>,
+}
+
+/// Identity of the job whose agent loop is executing tools. Threaded into
+/// each tool's [`ExecutionContext`] so queue tools derive child-job depth and
+/// correlation from the actual parent job instead of trusting model-supplied
+/// parameters.
+#[derive(Debug, Clone, Default)]
+pub struct JobContext {
+    /// Depth of the currently-running job (a direct chat turn counts as 0).
+    pub depth: u32,
+    /// Correlation id shared across the job's whole trace.
+    pub correlation_id: Option<String>,
 }
 
 /// Core skill trait — all skills must implement this.
diff --git a/crates/abigail-skills/src/topology.rs b/crates/abigail-skills/src/topology.rs
index 61512fd3..2e470344 100644
--- a/crates/abigail-skills/src/topology.rs
+++ b/crates/abigail-skills/src/topology.rs
@@ -10,7 +10,7 @@ use std::path::Path;
 use std::sync::Arc;
 
 /// Stream name used for persistent skill request/response topics.
-pub const SKILL_TOPOLOGY_STREAM: &str = "entity";
+pub const SKILL_TOPOLOGY_STREAM: &str = abigail_streaming::BUS_STREAM;
 
 #[derive(Debug, Deserialize)]
 struct RegistryFile {
diff --git a/crates/abigail-skills/tests/browser_persistent_auth.rs b/crates/abigail-skills/tests/browser_persistent_auth.rs
index 3d855832..fabd6a9a 100644
--- a/crates/abigail-skills/tests/browser_persistent_auth.rs
+++ b/crates/abigail-skills/tests/browser_persistent_auth.rs
@@ -58,6 +58,7 @@ fn execution_context() -> ExecutionContext {
     ExecutionContext {
         request_id: "browser-persistent-auth".to_string(),
         user_id: Some("test".to_string()),
+        ..Default::default()
     }
 }
 
diff --git a/crates/abigail-streaming/Cargo.toml b/crates/abigail-streaming/Cargo.toml
index 1f50ec83..362dbfc9 100644
--- a/crates/abigail-streaming/Cargo.toml
+++ b/crates/abigail-streaming/Cargo.toml
@@ -13,4 +13,6 @@ async-trait.workspace = true
 anyhow.workspace = true
 tracing.workspace = true
 tokio-util.workspace = true
+sha2.workspace = true
+hex = "0.4"
 iggy = "=0.8.0"
diff --git a/crates/abigail-streaming/src/bus.rs b/crates/abigail-streaming/src/bus.rs
new file mode 100644
index 00000000..58e99083
--- /dev/null
+++ b/crates/abigail-streaming/src/bus.rs
@@ -0,0 +1,279 @@
+//! Typed bus contract — canonical topics and envelope for the entity bus.
+//!
+//! The bus is the integration boundary between entity participants (Id, Ego,
+//! Superego, memory, skills, queue, governance). All canonical inter-component
+//! traffic uses a [`Topic`] variant on the single [`BUS_STREAM`] stream;
+//! ad-hoc string topics are reserved for dynamic per-session/per-task channels
+//! (e.g. `chat-{session_id}`, `agentic:{task_id}`).
+//!
+//! Adding a topic requires a note in `documents/ORIONII_ALIGNMENT_PLAN.md`.
+
+use crate::types::{StreamMessage, TopicConfig};
+use crate::StreamBroker;
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
+use std::fmt;
+
+/// The single stream all canonical entity topics live on.
+pub const BUS_STREAM: &str = "entity";
+
+/// Canonical topic set for the entity bus.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Topic {
+    /// Mentor/user input entering the cognitive pipeline.
+    MentorInput,
+    /// Id stage output: curated system prompt + personality signal for Ego.
+    IdReaction,
+    /// Out-of-band Id safety/feasibility signals.
+    IdSignal,
+    /// Ego reasoning trace tap for audit (ExecutionTrace and deliberation).
+    EgoDeliberation,
+    /// Ego's committed response — the only payload that reaches the mentor.
+    EgoAction,
+    /// Conscience check requests awaiting evaluation.
+    ConscienceCheck,
+    /// Superego/conscience verdicts and ethical signals.
+    SuperegoEvaluation,
+    /// Job queue lifecycle events (queued/running/completed, sub-agents).
+    JobEvents,
+    /// Skill/tool execution audit events.
+    SkillExecuted,
+    /// Conversation turns bound for async memory persistence.
+    MemoryArchive,
+    /// Outbox records bound for hive-daemon sync (the egress seam).
+    HiveOutbound,
+    /// Hive → entity governance: config, assignment, and policy refresh.
+    GovernanceInbound,
+}
+
+impl Topic {
+    /// Stable topic name used on the wire and in broker topic registries.
+    pub const fn as_str(&self) -> &'static str {
+        match self {
+            Topic::MentorInput => "mentor.input",
+            Topic::IdReaction => "id.reaction",
+            Topic::IdSignal => "id.signal",
+            Topic::EgoDeliberation => "ego.deliberation",
+            Topic::EgoAction => "ego.action",
+            Topic::ConscienceCheck => "conscience.check",
+            Topic::SuperegoEvaluation => "superego.evaluation",
+            Topic::JobEvents => "job.events",
+            Topic::SkillExecuted => "skill.executed",
+            Topic::MemoryArchive => "memory.archive",
+            Topic::HiveOutbound => "hive.outbound",
+            Topic::GovernanceInbound => "governance.inbound",
+        }
+    }
+
+    /// Resolve a wire name back to a canonical topic.
+    pub fn from_name(name: &str) -> Option<Topic> {
+        match name {
+            "mentor.input" => Some(Topic::MentorInput),
+            "id.reaction" => Some(Topic::IdReaction),
+            "id.signal" => Some(Topic::IdSignal),
+            "ego.deliberation" => Some(Topic::EgoDeliberation),
+            "ego.action" => Some(Topic::EgoAction),
+            "conscience.check" => Some(Topic::ConscienceCheck),
+            "superego.evaluation" => Some(Topic::SuperegoEvaluation),
+            "job.events" => Some(Topic::JobEvents),
+            "skill.executed" => Some(Topic::SkillExecuted),
+            "memory.archive" => Some(Topic::MemoryArchive),
+            "hive.outbound" => Some(Topic::HiveOutbound),
+            "governance.inbound" => Some(Topic::GovernanceInbound),
+            _ => None,
+        }
+    }
+
+    /// Ensure this topic exists on the bus stream. Idempotent.
+    pub async fn ensure(&self, broker: &dyn StreamBroker) -> anyhow::Result<()> {
+        broker
+            .ensure_topic(BUS_STREAM, self.as_str(), TopicConfig::default())
+            .await
+    }
+}
+
+impl fmt::Display for Topic {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+/// Canonical message envelope for the entity bus.
+///
+/// Every envelope carries the entity it belongs to, a correlation id that
+/// traces one mentor interaction through the whole pipeline, and (once the
+/// publisher knows it) a `soul_ref` — the hash of the entity's signed soul
+/// documents, proving which identity version produced the message.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Envelope {
+    pub topic: Topic,
+    pub entity_id: String,
+    pub occurred_at: chrono::DateTime<chrono::Utc>,
+    /// Hash reference to the entity's signed soul/constitution documents.
+    #[serde(default)]
+    pub soul_ref: Option<String>,
+    /// Traces one mentor interaction across pipeline stages.
+    pub correlation_id: String,
+    pub payload: serde_json::Value,
+}
+
+impl Envelope {
+    pub fn new(
+        topic: Topic,
+        entity_id: impl Into<String>,
+        correlation_id: impl Into<String>,
+        payload: serde_json::Value,
+    ) -> Self {
+        Self {
+            topic,
+            entity_id: entity_id.into(),
+            occurred_at: chrono::Utc::now(),
+            soul_ref: None,
+            correlation_id: correlation_id.into(),
+            payload,
+        }
+    }
+
+    pub fn with_soul_ref(mut self, soul_ref: impl Into<String>) -> Self {
+        self.soul_ref = Some(soul_ref.into());
+        self
+    }
+
+    /// Serialize into a `StreamMessage` with routing headers.
+    pub fn to_message(&self) -> anyhow::Result<StreamMessage> {
+        let payload = serde_json::to_vec(self)?;
+        let mut headers = HashMap::new();
+        headers.insert("topic".to_string(), self.topic.as_str().to_string());
+        headers.insert("entity_id".to_string(), self.entity_id.clone());
+        headers.insert("correlation_id".to_string(), self.correlation_id.clone());
+        if let Some(ref soul_ref) = self.soul_ref {
+            headers.insert("soul_ref".to_string(), soul_ref.clone());
+        }
+        Ok(StreamMessage::with_headers(payload, headers))
+    }
+
+    /// Deserialize from a `StreamMessage` payload.
+    pub fn from_message(msg: &StreamMessage) -> anyhow::Result<Envelope> {
+        Ok(serde_json::from_slice(&msg.payload)?)
+    }
+
+    /// Publish this envelope on its topic. Ensures the topic exists first.
+    pub async fn publish(&self, broker: &dyn StreamBroker) -> anyhow::Result<()> {
+        self.topic.ensure(broker).await?;
+        broker
+            .publish(BUS_STREAM, self.topic.as_str(), self.to_message()?)
+            .await
+    }
+}
+
+/// Compute a soul reference from the bytes of signed soul documents.
+///
+/// Format: `sha256:<hex>` — consistent with soul-forge's SHA-256 soul hash.
+pub fn compute_soul_ref(bytes: &[u8]) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(bytes);
+    format!("sha256:{}", hex::encode(hasher.finalize()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::MemoryBroker;
+    use std::sync::Arc;
+
+    #[test]
+    fn topic_names_roundtrip() {
+        for topic in [
+            Topic::MentorInput,
+            Topic::IdReaction,
+            Topic::IdSignal,
+            Topic::EgoDeliberation,
+            Topic::EgoAction,
+            Topic::ConscienceCheck,
+            Topic::SuperegoEvaluation,
+            Topic::JobEvents,
+            Topic::SkillExecuted,
+            Topic::MemoryArchive,
+            Topic::HiveOutbound,
+            Topic::GovernanceInbound,
+        ] {
+            assert_eq!(Topic::from_name(topic.as_str()), Some(topic));
+        }
+        assert_eq!(Topic::from_name("not-a-topic"), None);
+    }
+
+    #[test]
+    fn envelope_message_roundtrip() {
+        let env = Envelope::new(
+            Topic::EgoAction,
+            "entity-1",
+            "corr-1",
+            serde_json::json!({"response": "hello"}),
+        )
+        .with_soul_ref("sha256:abc");
+
+        let msg = env.to_message().unwrap();
+        assert_eq!(msg.headers.get("topic").unwrap(), "ego.action");
+        assert_eq!(msg.headers.get("correlation_id").unwrap(), "corr-1");
+        assert_eq!(msg.headers.get("soul_ref").unwrap(), "sha256:abc");
+
+        let back = Envelope::from_message(&msg).unwrap();
+        assert_eq!(back.topic, Topic::EgoAction);
+        assert_eq!(back.entity_id, "entity-1");
+        assert_eq!(back.payload["response"], "hello");
+    }
+
+    #[test]
+    fn soul_ref_is_deterministic() {
+        let a = compute_soul_ref(b"soul document bytes");
+        let b = compute_soul_ref(b"soul document bytes");
+        assert_eq!(a, b);
+        assert!(a.starts_with("sha256:"));
+        assert_ne!(a, compute_soul_ref(b"different bytes"));
+    }
+
+    #[tokio::test]
+    async fn envelope_publish_and_receive() {
+        let broker: Arc<dyn StreamBroker> = Arc::new(MemoryBroker::default());
+        Topic::EgoAction.ensure(broker.as_ref()).await.unwrap();
+        broker
+            .ensure_consumer_group(BUS_STREAM, Topic::EgoAction.as_str(), "test-group")
+            .await
+            .unwrap();
+
+        let (tx, rx) = tokio::sync::oneshot::channel::<Envelope>();
+        let tx_cell = Arc::new(tokio::sync::Mutex::new(Some(tx)));
+        let handler: crate::broker::MessageHandler = Box::new(move |msg| {
+            let tx_cell = tx_cell.clone();
+            Box::pin(async move {
+                if let Ok(env) = Envelope::from_message(&msg) {
+                    if let Some(sender) = tx_cell.lock().await.take() {
+                        let _ = sender.send(env);
+                    }
+                }
+            })
+        });
+        let _sub = broker
+            .subscribe(BUS_STREAM, Topic::EgoAction.as_str(), "test-group", handler)
+            .await
+            .unwrap();
+
+        Envelope::new(
+            Topic::EgoAction,
+            "e1",
+            "c1",
+            serde_json::json!({"ok": true}),
+        )
+        .publish(broker.as_ref())
+        .await
+        .unwrap();
+
+        let got = tokio::time::timeout(std::time::Duration::from_secs(2), rx)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(got.correlation_id, "c1");
+    }
+}
diff --git a/crates/abigail-streaming/src/lib.rs b/crates/abigail-streaming/src/lib.rs
index 7740de17..f51cf2ac 100644
--- a/crates/abigail-streaming/src/lib.rs
+++ b/crates/abigail-streaming/src/lib.rs
@@ -5,11 +5,13 @@
 //! Phase 3 adds `IggyBroker` for persistent, multi-consumer streaming.
 
 pub mod broker;
+pub mod bus;
 pub mod iggy_broker;
 pub mod memory_broker;
 pub mod types;
 
 pub use broker::StreamBroker;
+pub use bus::{compute_soul_ref, Envelope, Topic, BUS_STREAM};
 pub use iggy_broker::{IggyBroker, IggyBrokerConfig};
 pub use memory_broker::MemoryBroker;
 pub use types::{StreamMessage, SubscriptionHandle, TopicConfig};
diff --git a/crates/abigail-superego/Cargo.toml b/crates/abigail-superego/Cargo.toml
index f95e401a..60f41943 100644
--- a/crates/abigail-superego/Cargo.toml
+++ b/crates/abigail-superego/Cargo.toml
@@ -4,6 +4,7 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
+abigail-core = { path = "../abigail-core" }
 abigail-streaming = { path = "../abigail-streaming" }
 serde.workspace = true
 serde_json.workspace = true
diff --git a/crates/abigail-superego/src/evaluator.rs b/crates/abigail-superego/src/evaluator.rs
new file mode 100644
index 00000000..6f712a06
--- /dev/null
+++ b/crates/abigail-superego/src/evaluator.rs
@@ -0,0 +1,307 @@
+//! Superego evaluator — content evaluation and context-aware gating policy.
+//!
+//! Two layers of judgment:
+//! 1. **Pattern evaluation** (synchronous, free): PII, destructive intent, and
+//!    leaked-secret detection. Used as the pre-delivery gate by the Ego stage
+//!    and as the first-pass verdict by the superego pipeline stage.
+//! 2. **LLM judgment** (async, local Id provider): prompt/verdict helpers for
+//!    judging an exchange against the entity's signed constitution. The caller
+//!    owns the model call; this module owns the prompt and verdict parsing.
+//!
+//! Gating policy is context-aware: *talking about* a destructive command in a
+//! chat reply is legitimate (a parent asking what `rm -rf` does deserves an
+//! answer), but a reply that leaks an API key, or a tool/job payload that
+//! carries destructive intent, gets blocked.
+
+use serde::{Deserialize, Serialize};
+
+/// Where the evaluated content sits in the system.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum EvaluationContext {
+    /// Text the entity is about to show the mentor.
+    ChatReply,
+    /// Parameters or commands a tool is about to execute.
+    ToolExecution,
+    /// Output produced by a background job / sub-agent.
+    JobResult,
+    /// A skill event payload.
+    SkillEvent,
+}
+
+impl EvaluationContext {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            EvaluationContext::ChatReply => "chat_reply",
+            EvaluationContext::ToolExecution => "tool_execution",
+            EvaluationContext::JobResult => "job_result",
+            EvaluationContext::SkillEvent => "skill_event",
+        }
+    }
+}
+
+/// Severity of a finding.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Severity {
+    Info,
+    Warning,
+    Critical,
+}
+
+/// A single concern identified in evaluated content.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SuperegoFinding {
+    /// Stable rule identifier (e.g. "destructive-pattern", "secret-leak").
+    pub rule: String,
+    pub severity: Severity,
+    pub description: String,
+}
+
+/// Gate decision for content in a given context.
+#[derive(Debug, Clone)]
+pub enum GateDecision {
+    /// Nothing of concern.
+    Allow,
+    /// Concerns noted; content proceeds with an audit trail.
+    Flag(Vec<SuperegoFinding>),
+    /// Content must not proceed.
+    Block(Vec<SuperegoFinding>),
+}
+
+impl GateDecision {
+    pub fn verdict(&self) -> &'static str {
+        match self {
+            GateDecision::Allow => "clear",
+            GateDecision::Flag(_) => "flag",
+            GateDecision::Block(_) => "block",
+        }
+    }
+
+    pub fn findings(&self) -> &[SuperegoFinding] {
+        match self {
+            GateDecision::Allow => &[],
+            GateDecision::Flag(f) | GateDecision::Block(f) => f,
+        }
+    }
+}
+
+const DESTRUCTIVE_KEYWORDS: &[&str] = &[
+    "drop table",
+    "delete all",
+    "rm -rf",
+    "format c:",
+    "wipe all data",
+    "truncate table",
+    "delete database",
+];
+
+/// Evaluate content and apply the context-aware gating policy.
+pub fn evaluate(content: &str, context: EvaluationContext) -> GateDecision {
+    let findings = find_concerns(content);
+    if findings.is_empty() {
+        return GateDecision::Allow;
+    }
+
+    let blocking: Vec<SuperegoFinding> = findings
+        .iter()
+        .filter(|f| f.severity == Severity::Critical && blocks_in_context(&f.rule, context))
+        .cloned()
+        .collect();
+
+    if !blocking.is_empty() {
+        GateDecision::Block(blocking)
+    } else {
+        GateDecision::Flag(findings)
+    }
+}
+
+/// Pattern evaluation without gating policy — raw findings.
+pub fn find_concerns(content: &str) -> Vec<SuperegoFinding> {
+    let mut findings = Vec::new();
+    let lower = content.to_lowercase();
+
+    if !abigail_core::key_detection::detect_api_keys(content).is_empty() {
+        findings.push(SuperegoFinding {
+            rule: "secret-leak".to_string(),
+            severity: Severity::Critical,
+            description: "Content contains what looks like an API key or secret.".to_string(),
+        });
+    }
+
+    if DESTRUCTIVE_KEYWORDS.iter().any(|kw| lower.contains(kw)) {
+        findings.push(SuperegoFinding {
+            rule: "destructive-pattern".to_string(),
+            severity: Severity::Critical,
+            description: "Content contains potentially destructive patterns.".to_string(),
+        });
+    }
+
+    if has_pii_email(&lower) {
+        findings.push(SuperegoFinding {
+            rule: "pii-email".to_string(),
+            severity: Severity::Warning,
+            description: "Content may contain an email address.".to_string(),
+        });
+    }
+
+    if has_pii_ssn(&lower) {
+        findings.push(SuperegoFinding {
+            rule: "pii-ssn".to_string(),
+            severity: Severity::Critical,
+            description: "Content may contain a social security number.".to_string(),
+        });
+    }
+
+    findings
+}
+
+/// Which critical rules block in which contexts.
+///
+/// - Secrets and SSNs never leave the entity, regardless of context.
+/// - Destructive patterns block execution surfaces (tools, jobs) but are
+///   allowed in conversation — explaining a dangerous command is not running it.
+fn blocks_in_context(rule: &str, context: EvaluationContext) -> bool {
+    match rule {
+        "secret-leak" | "pii-ssn" => true,
+        "destructive-pattern" => matches!(
+            context,
+            EvaluationContext::ToolExecution | EvaluationContext::JobResult
+        ),
+        _ => false,
+    }
+}
+
+fn has_pii_email(text: &str) -> bool {
+    text.split_whitespace().any(|word| {
+        word.contains('@') && word.contains('.') && word.len() > 5 && !word.starts_with("http")
+    })
+}
+
+fn has_pii_ssn(text: &str) -> bool {
+    let chars: Vec<char> = text.chars().collect();
+    chars.windows(11).any(|window| {
+        window[3] == '-'
+            && window[6] == '-'
+            && window
+                .iter()
+                .enumerate()
+                .all(|(i, c)| i == 3 || i == 6 || c.is_ascii_digit())
+    })
+}
+
+// ── LLM judgment helpers ────────────────────────────────────────────
+
+/// Verdict returned by the LLM judgment pass.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LlmVerdict {
+    /// "clear", "concern", or "violation".
+    pub verdict: String,
+    #[serde(default)]
+    pub reason: String,
+}
+
+/// Build the (system, user) prompts for judging an exchange against the
+/// entity's constitution. The caller runs these on the local Id provider.
+pub fn build_llm_judgment_prompt(
+    entity_name: &str,
+    constitution_excerpt: &str,
+    user_message: &str,
+    reply: &str,
+) -> (String, String) {
+    let system = format!(
+        "You are the Superego of {entity_name} — its conscience. Judge whether the \
+         entity's reply honors its constitution. Respond with ONLY a JSON object: \
+         {{\"verdict\": \"clear\" | \"concern\" | \"violation\", \"reason\": \"<one sentence>\"}}.\n\n\
+         Constitution excerpt:\n{constitution_excerpt}"
+    );
+    let user = format!("Mentor said:\n{user_message}\n\nEntity replied:\n{reply}");
+    (system, user)
+}
+
+/// Parse an LLM judgment response, tolerating prose around the JSON object.
+pub fn parse_llm_verdict(raw: &str) -> Option<LlmVerdict> {
+    let start = raw.find('{')?;
+    let end = raw.rfind('}')?;
+    if end <= start {
+        return None;
+    }
+    let verdict: LlmVerdict = serde_json::from_str(&raw[start..=end]).ok()?;
+    match verdict.verdict.as_str() {
+        "clear" | "concern" | "violation" => Some(verdict),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn clean_chat_reply_is_allowed() {
+        assert!(matches!(
+            evaluate(
+                "The weather looks lovely today.",
+                EvaluationContext::ChatReply
+            ),
+            GateDecision::Allow
+        ));
+    }
+
+    #[test]
+    fn destructive_talk_is_flagged_not_blocked_in_chat() {
+        let decision = evaluate(
+            "Careful: `rm -rf /` deletes everything on the disk.",
+            EvaluationContext::ChatReply,
+        );
+        assert!(matches!(decision, GateDecision::Flag(_)));
+    }
+
+    #[test]
+    fn destructive_content_blocks_tool_execution() {
+        let decision = evaluate("rm -rf /home/family", EvaluationContext::ToolExecution);
+        assert!(matches!(decision, GateDecision::Block(_)));
+    }
+
+    #[test]
+    fn secret_leak_blocks_even_in_chat() {
+        let decision = evaluate(
+            "Your key is sk-ant-api03-abcdefghijklmnopqrstuvwxyz0123456789",
+            EvaluationContext::ChatReply,
+        );
+        assert!(matches!(decision, GateDecision::Block(_)));
+        assert_eq!(decision.findings()[0].rule, "secret-leak");
+    }
+
+    #[test]
+    fn ssn_blocks_in_any_context() {
+        let decision = evaluate("ssn: 123-45-6789", EvaluationContext::ChatReply);
+        assert!(matches!(decision, GateDecision::Block(_)));
+    }
+
+    #[test]
+    fn email_is_a_warning_flag() {
+        let decision = evaluate("write to grandma@example.com", EvaluationContext::ChatReply);
+        match decision {
+            GateDecision::Flag(findings) => {
+                assert_eq!(findings[0].rule, "pii-email");
+                assert_eq!(findings[0].severity, Severity::Warning);
+            }
+            other => panic!("expected flag, got {:?}", other.verdict()),
+        }
+    }
+
+    #[test]
+    fn llm_verdict_parses_with_surrounding_prose() {
+        let raw = "Here is my judgment: {\"verdict\": \"concern\", \"reason\": \"shares location\"} hope that helps";
+        let verdict = parse_llm_verdict(raw).unwrap();
+        assert_eq!(verdict.verdict, "concern");
+        assert_eq!(verdict.reason, "shares location");
+    }
+
+    #[test]
+    fn llm_verdict_rejects_unknown_verdicts() {
+        assert!(parse_llm_verdict("{\"verdict\": \"banana\"}").is_none());
+        assert!(parse_llm_verdict("no json here").is_none());
+    }
+}
diff --git a/crates/abigail-superego/src/lib.rs b/crates/abigail-superego/src/lib.rs
index d7eb4811..710870c6 100644
--- a/crates/abigail-superego/src/lib.rs
+++ b/crates/abigail-superego/src/lib.rs
@@ -1,3 +1,8 @@
+pub mod evaluator;
 pub mod monitor;
 
+pub use evaluator::{
+    build_llm_judgment_prompt, evaluate, find_concerns, parse_llm_verdict, EvaluationContext,
+    GateDecision, LlmVerdict, Severity, SuperegoFinding,
+};
 pub use monitor::{SuperegoMonitor, SuperegoSignal};
diff --git a/crates/abigail-superego/src/monitor.rs b/crates/abigail-superego/src/monitor.rs
index a4775f69..42e3f50e 100644
--- a/crates/abigail-superego/src/monitor.rs
+++ b/crates/abigail-superego/src/monitor.rs
@@ -1,15 +1,17 @@
 //! Out-of-band Superego monitor for ethical/safety checks over chat topic.
 
-use abigail_streaming::{StreamBroker, StreamMessage, SubscriptionHandle, TopicConfig};
+use abigail_streaming::{
+    StreamBroker, StreamMessage, SubscriptionHandle, Topic, TopicConfig, BUS_STREAM,
+};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::io::Write;
 use std::path::Path;
 use std::sync::Arc;
 
-const STREAM: &str = "entity";
-const CHAT_TOPIC: &str = "chat-topic";
-const SIGNAL_TOPIC: &str = "ethical-signals";
+const STREAM: &str = BUS_STREAM;
+const CHAT_TOPIC: &str = Topic::MentorInput.as_str();
+const SIGNAL_TOPIC: &str = Topic::SuperegoEvaluation.as_str();
 const CONSUMER_GROUP: &str = "superego-monitor";
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/crates/daemon-client/src/entity.rs b/crates/daemon-client/src/entity.rs
index c1efbf7b..dfdbe4d7 100644
--- a/crates/daemon-client/src/entity.rs
+++ b/crates/daemon-client/src/entity.rs
@@ -1,6 +1,9 @@
 //! HTTP client for entity-daemon.
 
-use entity_core::{ChatRequest, ChatResponse, SkillInfo, ToolExecRequest, ToolExecResponse};
+use entity_core::{
+    ChatRequest, ChatResponse, EntityOutboxStatus, RuntimeSessionStatusResponse,
+    SkillApplyAcknowledgementList, SkillInfo, ToolExecRequest, ToolExecResponse,
+};
 use futures_util::StreamExt;
 use hive_core::ApiEnvelope;
 
@@ -51,6 +54,28 @@ impl EntityClient {
         unwrap_envelope(resp)
     }
 
+    pub async fn session_status(&self) -> anyhow::Result<RuntimeSessionStatusResponse> {
+        let resp: ApiEnvelope<RuntimeSessionStatusResponse> = self
+            .client
+            .get(format!("{}/v1/session/status", self.base_url))
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
+
+    pub async fn outbox_status(&self) -> anyhow::Result<EntityOutboxStatus> {
+        let resp: ApiEnvelope<EntityOutboxStatus> = self
+            .client
+            .get(format!("{}/v1/outbox/status", self.base_url))
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
+
     // ── Chat ────────────────────────────────────────────────────────
 
     pub async fn chat(&self, request: &ChatRequest) -> anyhow::Result<ChatResponse> {
@@ -140,6 +165,19 @@ impl EntityClient {
         unwrap_envelope(resp)
     }
 
+    pub async fn list_skill_apply_acknowledgements(
+        &self,
+    ) -> anyhow::Result<SkillApplyAcknowledgementList> {
+        let resp: ApiEnvelope<SkillApplyAcknowledgementList> = self
+            .client
+            .get(format!("{}/v1/skills/acks", self.base_url))
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
+
     pub async fn execute_tool(
         &self,
         request: &ToolExecRequest,
diff --git a/crates/daemon-client/src/hive.rs b/crates/daemon-client/src/hive.rs
index 65ed7a2a..d8be690a 100644
--- a/crates/daemon-client/src/hive.rs
+++ b/crates/daemon-client/src/hive.rs
@@ -1,6 +1,12 @@
 //! HTTP client for hive-daemon.
 
-use hive_core::{ApiEnvelope, EntityInfo, ProviderConfig, SecretListResponse, SecretValueResponse};
+use hive_core::{
+    ApiEnvelope, EntityInfo, ForgeApprovalJobsResponse, OutboxSyncRequest, OutboxSyncResponse,
+    ProviderConfig, ProviderModelsRequest, ProviderModelsResponse, RuntimeHeartbeatRequest,
+    RuntimeHeartbeatResponse, RuntimeRegistrationRequest, RuntimeSessionLease,
+    RuntimeSessionRequest, RuntimeSessionStatus, SecretListResponse, SecretValueResponse,
+    SkillAssignmentsResponse, UpdateEntityConfigRequest, UpdateEntityConfigResponse,
+};
 
 /// HTTP client wrapping all hive-daemon REST endpoints.
 #[derive(Clone)]
@@ -82,6 +88,25 @@ impl HiveDaemonClient {
         unwrap_envelope(resp)
     }
 
+    pub async fn update_entity_config(
+        &self,
+        entity_id: &str,
+        patch: &UpdateEntityConfigRequest,
+    ) -> anyhow::Result<UpdateEntityConfigResponse> {
+        let resp: ApiEnvelope<UpdateEntityConfigResponse> = self
+            .client
+            .patch(format!(
+                "{}/v1/entities/{}/config",
+                self.base_url, entity_id
+            ))
+            .json(patch)
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
+
     pub async fn store_secret(&self, key: &str, value: &str) -> anyhow::Result<()> {
         let resp: ApiEnvelope<String> = self
             .client
@@ -120,6 +145,123 @@ impl HiveDaemonClient {
             .await?;
         Ok(unwrap_envelope(resp)?.keys)
     }
+
+    pub async fn discover_provider_models(
+        &self,
+        provider: &str,
+        api_key: &str,
+    ) -> anyhow::Result<ProviderModelsResponse> {
+        let resp: ApiEnvelope<ProviderModelsResponse> = self
+            .client
+            .post(format!("{}/v1/providers/models", self.base_url))
+            .json(&ProviderModelsRequest {
+                provider: provider.to_string(),
+                api_key: api_key.to_string(),
+            })
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
+
+    pub async fn issue_runtime_session(
+        &self,
+        entity_id: &str,
+        runtime_id: Option<String>,
+    ) -> anyhow::Result<RuntimeSessionLease> {
+        let resp: ApiEnvelope<RuntimeSessionLease> = self
+            .client
+            .post(format!("{}/v1/runtime/sessions", self.base_url))
+            .json(&RuntimeSessionRequest {
+                entity_id: entity_id.to_string(),
+                runtime_id,
+            })
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
+
+    pub async fn register_runtime(
+        &self,
+        request: &RuntimeRegistrationRequest,
+    ) -> anyhow::Result<RuntimeSessionStatus> {
+        let resp: ApiEnvelope<RuntimeSessionStatus> = self
+            .client
+            .post(format!("{}/v1/runtime/register", self.base_url))
+            .json(request)
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
+
+    pub async fn heartbeat(
+        &self,
+        request: &RuntimeHeartbeatRequest,
+    ) -> anyhow::Result<RuntimeHeartbeatResponse> {
+        let resp: ApiEnvelope<RuntimeHeartbeatResponse> = self
+            .client
+            .post(format!("{}/v1/runtime/heartbeat", self.base_url))
+            .json(request)
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
+
+    pub async fn get_skill_assignments(
+        &self,
+        entity_id: &str,
+    ) -> anyhow::Result<SkillAssignmentsResponse> {
+        let resp: ApiEnvelope<SkillAssignmentsResponse> = self
+            .client
+            .get(format!(
+                "{}/v1/entities/{}/assignments",
+                self.base_url, entity_id
+            ))
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
+
+    pub async fn get_forge_approval_jobs(
+        &self,
+        entity_id: &str,
+    ) -> anyhow::Result<ForgeApprovalJobsResponse> {
+        let resp: ApiEnvelope<ForgeApprovalJobsResponse> = self
+            .client
+            .get(format!(
+                "{}/v1/entities/{}/forge-approvals",
+                self.base_url, entity_id
+            ))
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
+
+    pub async fn sync_outbox(
+        &self,
+        request: &OutboxSyncRequest,
+    ) -> anyhow::Result<OutboxSyncResponse> {
+        let resp: ApiEnvelope<OutboxSyncResponse> = self
+            .client
+            .post(format!("{}/v1/runtime/outbox/sync", self.base_url))
+            .json(request)
+            .send()
+            .await?
+            .json()
+            .await?;
+        unwrap_envelope(resp)
+    }
 }
 
 fn unwrap_envelope<T>(resp: ApiEnvelope<T>) -> anyhow::Result<T> {
diff --git a/crates/daemon-test-harness/src/lib.rs b/crates/daemon-test-harness/src/lib.rs
index 6d3498d3..1251238c 100644
--- a/crates/daemon-test-harness/src/lib.rs
+++ b/crates/daemon-test-harness/src/lib.rs
@@ -214,10 +214,15 @@ fn cargo_bin(name: &str) -> PathBuf {
 }
 
 /// Read stdout lines from a child process until we find the "listening on http://..." URL.
+///
+/// Anchored on the "listening on " marker: daemon startup logs mention other
+/// URLs first (e.g. the entity daemon logs the hive URL it connects to), so
+/// matching any "http://" would lock onto the wrong daemon's address.
 async fn parse_listen_url(
     stdout: std::process::ChildStdout,
     timeout: Duration,
 ) -> anyhow::Result<String> {
+    const MARKER: &str = "listening on http://";
     let (tx, rx) = tokio::sync::oneshot::channel::<String>();
     let mut tx = Some(tx);
 
@@ -228,9 +233,10 @@ async fn parse_listen_url(
                 Ok(l) => l,
                 Err(_) => break,
             };
-            if let Some(idx) = line.find("http://") {
+            if let Some(idx) = line.find(MARKER) {
                 if let Some(sender) = tx.take() {
-                    let url = line[idx..].trim().to_string();
+                    let url_start = idx + MARKER.len() - "http://".len();
+                    let url = line[url_start..].trim().to_string();
                     let _ = sender.send(url);
                 }
             }
diff --git a/crates/entity-chat/Cargo.toml b/crates/entity-chat/Cargo.toml
index 9c9cf585..09760f41 100644
--- a/crates/entity-chat/Cargo.toml
+++ b/crates/entity-chat/Cargo.toml
@@ -23,3 +23,5 @@ async-trait.workspace = true
 chrono.workspace = true
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 abigail-core = { path = "../abigail-core" }
+abigail-persistence = { path = "../abigail-persistence" }
+abigail-streaming = { path = "../abigail-streaming" }
diff --git a/crates/entity-chat/src/job_tools.rs b/crates/entity-chat/src/job_tools.rs
index 8c80dcd8..53a4f361 100644
--- a/crates/entity-chat/src/job_tools.rs
+++ b/crates/entity-chat/src/job_tools.rs
@@ -6,6 +6,7 @@
 
 use abigail_capabilities::cognitive::ToolDefinition;
 use abigail_queue::{DirectToolCall, ExecutionMode, JobQueue, JobSpec, RequiredCapability};
+use abigail_skills::JobContext;
 use serde_json::json;
 use std::str::FromStr;
 use std::sync::Arc;
@@ -176,13 +177,18 @@ pub fn is_job_tool(name: &str) -> bool {
 }
 
 /// Execute a built-in job tool call. Returns the JSON result string.
+///
+/// `job_ctx` identifies the job whose agent issued the call (if any), so a
+/// submitted child job nests at depth = parent + 1 and inherits the trace
+/// correlation id.
 pub async fn execute_job_tool(
     queue: &Arc<JobQueue>,
     tool_name: &str,
     args: &serde_json::Value,
+    job_ctx: Option<&JobContext>,
 ) -> String {
     match tool_name {
-        TOOL_SUBMIT_JOB => execute_submit(queue, args).await,
+        TOOL_SUBMIT_JOB => execute_submit(queue, args, job_ctx).await,
         TOOL_GET_RESULT => execute_get_result(queue, args).await,
         TOOL_LIST_JOBS => execute_list(queue, args).await,
         TOOL_CREATE_RECURRING => execute_create_recurring(queue, args).await,
@@ -192,7 +198,11 @@ pub async fn execute_job_tool(
     }
 }
 
-async fn execute_submit(queue: &Arc<JobQueue>, args: &serde_json::Value) -> String {
+async fn execute_submit(
+    queue: &Arc<JobQueue>,
+    args: &serde_json::Value,
+    job_ctx: Option<&JobContext>,
+) -> String {
     let goal = args["goal"].as_str().unwrap_or("").to_string();
     let capability_str = args["capability"].as_str().unwrap_or("general");
     let topic = args["topic"].as_str().unwrap_or("delegation").to_string();
@@ -228,6 +238,11 @@ async fn execute_submit(queue: &Arc<JobQueue>, args: &serde_json::Value) -> Stri
         None
     };
 
+    let provider_profile = args["provider_profile"]
+        .as_str()
+        .filter(|s| !s.trim().is_empty())
+        .map(String::from);
+
     let spec = JobSpec {
         goal,
         topic: topic.clone(),
@@ -240,6 +255,11 @@ async fn execute_submit(queue: &Arc<JobQueue>, args: &serde_json::Value) -> Stri
         ttl_seconds: 3600,
         input_data: None,
         parent_job_id: None,
+        parent_correlation_id: job_ctx.and_then(|c| c.correlation_id.clone()),
+        // A job submitted from inside another job nests one level deeper;
+        // submissions from a direct chat turn start at depth 1.
+        depth: job_ctx.map(|c| c.depth).unwrap_or(0) + 1,
+        provider_profile,
         cron_expression: None,
         is_recurring: false,
         significance_keywords: vec![],
@@ -367,6 +387,9 @@ async fn execute_create_recurring(queue: &Arc<JobQueue>, args: &serde_json::Valu
         ttl_seconds: 86_400,
         input_data: None,
         parent_job_id: None,
+        parent_correlation_id: None,
+        depth: 0,
+        provider_profile: None,
         cron_expression: Some(cron_expression),
         is_recurring: true,
         significance_keywords: vec![],
@@ -430,3 +453,61 @@ async fn execute_cancel_recurring(queue: &Arc<JobQueue>, args: &serde_json::Valu
         Err(e) => json!({"error": format!("Failed to cancel recurring job: {}", e)}).to_string(),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use abigail_persistence::{EntityScope, PersistenceHandle};
+    use abigail_streaming::MemoryBroker;
+
+    fn test_queue() -> Arc<JobQueue> {
+        let store = PersistenceHandle::open_ephemeral(EntityScope::Hive).unwrap();
+        Arc::new(JobQueue::new(store, Arc::new(MemoryBroker::new(64))))
+    }
+
+    fn submit_args() -> serde_json::Value {
+        json!({"goal": "child task", "capability": "general", "topic": "test-topic"})
+    }
+
+    #[tokio::test]
+    async fn submit_inherits_depth_and_correlation_from_job_context() {
+        let queue = test_queue();
+        let ctx = JobContext {
+            depth: 1,
+            correlation_id: Some("turn-9".to_string()),
+        };
+        let out = execute_job_tool(&queue, TOOL_SUBMIT_JOB, &submit_args(), Some(&ctx)).await;
+        let parsed: serde_json::Value = serde_json::from_str(&out).unwrap();
+        let record = queue
+            .get_job(parsed["job_id"].as_str().unwrap())
+            .unwrap()
+            .unwrap();
+        assert_eq!(record.depth, 2);
+        assert_eq!(record.parent_correlation_id.as_deref(), Some("turn-9"));
+    }
+
+    #[tokio::test]
+    async fn submit_from_depth_two_job_is_rejected() {
+        let queue = test_queue();
+        let ctx = JobContext {
+            depth: 2,
+            correlation_id: None,
+        };
+        let out = execute_job_tool(&queue, TOOL_SUBMIT_JOB, &submit_args(), Some(&ctx)).await;
+        assert!(out.contains("nesting limit"), "got: {}", out);
+        assert!(queue.list_jobs(None, 10).unwrap().is_empty());
+    }
+
+    #[tokio::test]
+    async fn submit_without_job_context_starts_at_depth_one() {
+        let queue = test_queue();
+        let out = execute_job_tool(&queue, TOOL_SUBMIT_JOB, &submit_args(), None).await;
+        let parsed: serde_json::Value = serde_json::from_str(&out).unwrap();
+        let record = queue
+            .get_job(parsed["job_id"].as_str().unwrap())
+            .unwrap()
+            .unwrap();
+        assert_eq!(record.depth, 1);
+        assert_eq!(record.parent_correlation_id, None);
+    }
+}
diff --git a/crates/entity-chat/src/lib.rs b/crates/entity-chat/src/lib.rs
index 30b9fab1..f4da257b 100644
--- a/crates/entity-chat/src/lib.rs
+++ b/crates/entity-chat/src/lib.rs
@@ -11,6 +11,7 @@ use abigail_queue::JobQueue;
 use abigail_router::IdEgoRouter;
 use abigail_skills::manifest::SkillId;
 use abigail_skills::skill::ToolParams;
+pub use abigail_skills::JobContext;
 use abigail_skills::{SkillExecutor, SkillRegistry};
 use entity_core::{SessionMessage, ToolCallRecord};
 use std::collections::HashSet;
@@ -428,6 +429,7 @@ pub fn augment_system_prompt(
                     prompt.push_str(&tool_lines.join("\n"));
                 }
             }
+            append_web_and_image_guidance(&mut prompt, registry);
 
             // Only inject instructions for skills that are actually registered
             let skill_section =
@@ -478,6 +480,31 @@ pub fn augment_system_prompt(
     prompt
 }
 
+fn append_web_and_image_guidance(prompt: &mut String, registry: &SkillRegistry) {
+    let has_web_search = registry
+        .get_skill(&SkillId("com.abigail.skills.web-search".to_string()))
+        .is_ok();
+    let has_browser = registry
+        .get_skill(&SkillId("com.abigail.skills.browser".to_string()))
+        .is_ok();
+    if !has_web_search && !has_browser {
+        return;
+    }
+
+    prompt.push_str("\n\n## Web Research And Images\n");
+    if has_web_search {
+        prompt.push_str(
+            "- For current information, call `com.abigail.skills.web-search::web_search` and cite key sources in your final reply.\n",
+        );
+    }
+    if has_browser {
+        prompt.push_str(
+            "- When the user explicitly asks for visuals, use browser tooling and return markdown image links like `![caption](https://...)` or safe `data:image/...` links so the runtime UI can render inline images.\n",
+        );
+    }
+    prompt.push_str("- Prefer concise, family-friendly summaries before detailed evidence.\n");
+}
+
 /// Build a CLI-optimized system prompt for CliOrchestrator mode.
 ///
 /// Uses a heavily compressed inline prompt (~1.5 KB) with:
@@ -529,6 +556,7 @@ pub fn build_cli_system_prompt(
             prompt.push_str(&format!("{}: {}\n", skill_name, tools.join(", ")));
         }
     }
+    append_web_and_image_guidance(&mut prompt, registry);
 
     // Budgeted instruction injection: max 1 instruction, 2048 bytes for CLI mode
     let skill_section = instruction_registry.format_for_prompt_budgeted(
@@ -735,7 +763,7 @@ pub async fn run_tool_use_loop(
     messages: Vec<Message>,
     tools: Vec<ToolDefinition>,
 ) -> anyhow::Result<ToolUseResult> {
-    run_tool_use_loop_with_model_override(router, executor, messages, tools, None).await
+    run_tool_use_loop_with_model_override(router, executor, messages, tools, None, None).await
 }
 
 /// Same as [`run_tool_use_loop_with_model_override`] but also handles built-in
@@ -747,6 +775,7 @@ pub async fn run_tool_use_loop_with_jobs(
     tools: Vec<ToolDefinition>,
     model_override: Option<String>,
     job_queue: Arc<JobQueue>,
+    job_ctx: Option<&JobContext>,
 ) -> anyhow::Result<ToolUseResult> {
     let mut all_records = Vec::new();
     let mut last_trace: Option<entity_core::ExecutionTrace> = None;
@@ -788,7 +817,8 @@ pub async fn run_tool_use_loop_with_jobs(
             let (output_json, record) = if job_tools::is_job_tool(&tc.name) {
                 let args: serde_json::Value =
                     serde_json::from_str(&tc.arguments).unwrap_or_default();
-                let result = job_tools::execute_job_tool(&job_queue, &tc.name, &args).await;
+                let result =
+                    job_tools::execute_job_tool(&job_queue, &tc.name, &args, job_ctx).await;
                 let record = ToolCallRecord {
                     skill_id: "builtin.jobs".into(),
                     tool_name: tc.name.clone(),
@@ -796,7 +826,7 @@ pub async fn run_tool_use_loop_with_jobs(
                 };
                 (result, record)
             } else {
-                execute_single_tool_call(executor, tc).await
+                execute_single_tool_call(executor, tc, job_ctx).await
             };
             all_records.push(record);
             messages.push(Message::tool_result(&tc.id, output_json));
@@ -815,13 +845,15 @@ pub async fn run_tool_use_loop_with_jobs(
 }
 
 /// Same as [`run_tool_use_loop`] but allows forcing a model override for all
-/// LLM calls in the loop.
+/// LLM calls in the loop, and threading the running job's context (depth +
+/// correlation id) into tool execution so delegated child jobs nest correctly.
 pub async fn run_tool_use_loop_with_model_override(
     router: &IdEgoRouter,
     executor: &SkillExecutor,
     mut messages: Vec<Message>,
     tools: Vec<ToolDefinition>,
     model_override: Option<String>,
+    job_ctx: Option<&JobContext>,
 ) -> anyhow::Result<ToolUseResult> {
     let mut all_records = Vec::new();
     let mut last_trace: Option<entity_core::ExecutionTrace> = None;
@@ -860,7 +892,7 @@ pub async fn run_tool_use_loop_with_model_override(
         });
 
         for tc in &tool_calls {
-            let (output_json, record) = execute_single_tool_call(executor, tc).await;
+            let (output_json, record) = execute_single_tool_call(executor, tc, job_ctx).await;
             all_records.push(record);
             messages.push(Message::tool_result(&tc.id, output_json));
         }
@@ -933,7 +965,7 @@ pub async fn run_tool_use_loop_with_delegation(
         });
 
         for tc in &tool_calls {
-            let (output_json, record) = execute_single_tool_call(executor, tc).await;
+            let (output_json, record) = execute_single_tool_call(executor, tc, None).await;
             all_records.push(record);
             messages.push(Message::tool_result(&tc.id, output_json));
         }
@@ -966,6 +998,9 @@ pub async fn run_tool_use_loop_with_delegation(
                     "delegated_at_round": effective_rounds,
                 })),
                 parent_job_id: None,
+                parent_correlation_id: None,
+                depth: 1,
+                provider_profile: None,
                 cron_expression: None,
                 is_recurring: false,
                 significance_keywords: vec![],
@@ -1038,6 +1073,7 @@ pub async fn run_tool_use_loop_rounds_only(
     messages: &mut Vec<Message>,
     tools: &[ToolDefinition],
     model_override: Option<String>,
+    job_ctx: Option<&JobContext>,
 ) -> anyhow::Result<IntermediateToolResult> {
     let mut all_records = Vec::new();
     let mut did_tool_calls = false;
@@ -1079,7 +1115,7 @@ pub async fn run_tool_use_loop_rounds_only(
         });
 
         for tc in &tool_calls {
-            let (output_json, record) = execute_single_tool_call(executor, tc).await;
+            let (output_json, record) = execute_single_tool_call(executor, tc, job_ctx).await;
             all_records.push(record);
             messages.push(Message::tool_result(&tc.id, output_json));
         }
@@ -1120,6 +1156,7 @@ pub async fn stream_chat_pipeline(
     tools: Vec<ToolDefinition>,
     tx: tokio::sync::mpsc::Sender<StreamEvent>,
     model_override: Option<String>,
+    job_ctx: Option<&JobContext>,
 ) -> anyhow::Result<StreamPipelineResult> {
     let mut messages = messages;
     let mut tool_calls_made = Vec::new();
@@ -1132,6 +1169,7 @@ pub async fn stream_chat_pipeline(
             &mut messages,
             &tools,
             model_override.clone(),
+            job_ctx,
         )
         .await?;
         tool_calls_made = intermediate.tool_calls_made;
@@ -1190,6 +1228,7 @@ pub fn provider_label(router: &IdEgoRouter) -> String {
 async fn execute_single_tool_call(
     executor: &SkillExecutor,
     tc: &ToolCall,
+    job_ctx: Option<&JobContext>,
 ) -> (String, ToolCallRecord) {
     let Some((skill_id_str, tool_name)) = split_qualified_tool_name(&tc.name) else {
         let err_msg = format!("Invalid tool name format: {}", tc.name);
@@ -1268,7 +1307,10 @@ async fn execute_single_tool_call(
     tracing::info!("Executing tool: {}::{}", skill_id_str, tool_name);
 
     let skill_id = SkillId(skill_id_str.clone());
-    match executor.execute(&skill_id, &tool_name, params).await {
+    match executor
+        .execute_in_job_context(&skill_id, &tool_name, params, job_ctx)
+        .await
+    {
         Ok(output) => {
             let result_json = serde_json::json!({
                 "success": output.success,
@@ -1544,7 +1586,7 @@ mod tests {
             name: "test.echo::echo".into(),
             arguments: r#"{"input":"hello"}"#.into(),
         };
-        let (json, record) = execute_single_tool_call(&executor, &tc).await;
+        let (json, record) = execute_single_tool_call(&executor, &tc, None).await;
         assert!(record.success);
         assert_eq!(record.skill_id, "test.echo");
         assert_eq!(record.tool_name, "echo");
@@ -1562,7 +1604,7 @@ mod tests {
             name: "no_separator".into(),
             arguments: "{}".into(),
         };
-        let (json, record) = execute_single_tool_call(&executor, &tc).await;
+        let (json, record) = execute_single_tool_call(&executor, &tc, None).await;
         assert!(!record.success);
         let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
         assert!(parsed["error"]
@@ -1588,7 +1630,7 @@ mod tests {
             name: "test.echo::echo".into(),
             arguments: "not valid json!!!".into(),
         };
-        let (json, record) = execute_single_tool_call(&executor, &tc).await;
+        let (json, record) = execute_single_tool_call(&executor, &tc, None).await;
         assert!(
             !record.success,
             "malformed args should return an error, not silently succeed"
@@ -1610,7 +1652,7 @@ mod tests {
             name: "ghost.skill::tool".into(),
             arguments: "{}".into(),
         };
-        let (json, record) = execute_single_tool_call(&executor, &tc).await;
+        let (json, record) = execute_single_tool_call(&executor, &tc, None).await;
         assert!(!record.success);
         let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
         assert!(parsed["error"].is_string());
diff --git a/crates/entity-chat/tests/e2e_parity.rs b/crates/entity-chat/tests/e2e_parity.rs
index 6a13ef0c..03934445 100644
--- a/crates/entity-chat/tests/e2e_parity.rs
+++ b/crates/entity-chat/tests/e2e_parity.rs
@@ -335,10 +335,16 @@ async fn rounds_only_returns_final_text_when_no_tools_called() {
     let mut messages = entity_chat::build_contextual_messages(&system, None, "hi");
     let tools = entity_chat::build_tool_definitions(&registry);
 
-    let result =
-        entity_chat::run_tool_use_loop_rounds_only(&router, &executor, &mut messages, &tools, None)
-            .await
-            .unwrap();
+    let result = entity_chat::run_tool_use_loop_rounds_only(
+        &router,
+        &executor,
+        &mut messages,
+        &tools,
+        None,
+        None,
+    )
+    .await
+    .unwrap();
 
     assert!(result.final_text.is_some());
     assert_eq!(result.final_text.unwrap(), "Mock response #1");
diff --git a/crates/entity-cli/src/main.rs b/crates/entity-cli/src/main.rs
index 3e239611..5661883b 100644
--- a/crates/entity-cli/src/main.rs
+++ b/crates/entity-cli/src/main.rs
@@ -245,6 +245,9 @@ async fn main() -> anyhow::Result<()> {
                         ttl_seconds,
                         input_data: None,
                         parent_job_id: None,
+                        parent_correlation_id: None,
+                        depth: None,
+                        provider_profile: None,
                     })
                     .send()
                     .await?
diff --git a/crates/entity-core/src/lib.rs b/crates/entity-core/src/lib.rs
index 62822a17..3d8c336e 100644
--- a/crates/entity-core/src/lib.rs
+++ b/crates/entity-core/src/lib.rs
@@ -2,8 +2,11 @@
 
 use serde::{Deserialize, Serialize};
 
-// Re-export the shared envelope from hive-core.
-pub use hive_core::ApiEnvelope;
+// Re-export the shared envelope and Hive-managed runtime contract types.
+pub use hive_core::{
+    ApiEnvelope, EntityOutboxRecord, ForgeApprovalJob, RuntimeSessionLease, RuntimeSessionStatus,
+    SkillAssignment,
+};
 
 // ---------------------------------------------------------------------------
 // Chat
@@ -297,6 +300,63 @@ pub struct EntityStatus {
     pub ego_provider: Option<String>,
     pub routing_mode: String,
     pub skills_count: usize,
+    /// Recent model-call health (newest first): is my provider healthy *right now*?
+    #[serde(default)]
+    pub provider_health: Vec<ProviderHealthEntry>,
+}
+
+/// Outcome of one model call, for the live provider health board.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProviderHealthEntry {
+    /// Provider label (e.g. "anthropic", "claude-cli", "id").
+    pub provider: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
+    /// "healthy", "fallback" (served by the failsafe), or "degraded" (call failed).
+    pub state: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    pub at_utc: String,
+}
+
+/// Runtime session status exposed by the entity runtime.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RuntimeSessionStatusResponse {
+    pub lease: RuntimeSessionLease,
+    pub connected_to_hive: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub runtime_url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub last_hive_sync_at_utc: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub last_hive_error: Option<String>,
+    pub assignment_count: usize,
+}
+
+/// Current local outbox sync status for the runtime.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EntityOutboxStatus {
+    pub queued_records: usize,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub oldest_record_at_utc: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub last_sync_at_utc: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub last_sync_error: Option<String>,
+}
+
+/// Acknowledgement that a skill artifact was applied or reloaded in the runtime.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SkillApplyAcknowledgement {
+    pub skill_id: String,
+    pub status: String,
+    pub applied_at_utc: String,
+}
+
+/// List wrapper for recent skill apply acknowledgements.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SkillApplyAcknowledgementList {
+    pub acknowledgements: Vec<SkillApplyAcknowledgement>,
 }
 
 // ---------------------------------------------------------------------------
@@ -411,6 +471,15 @@ pub struct SubmitJobRequest {
     pub input_data: Option<serde_json::Value>,
     #[serde(default)]
     pub parent_job_id: Option<String>,
+    /// Correlation id of the chat turn (or parent run) that spawned this job.
+    #[serde(default)]
+    pub parent_correlation_id: Option<String>,
+    /// Sub-agent nesting depth (0 = mentor-initiated). Capped server-side.
+    #[serde(default)]
+    pub depth: Option<u32>,
+    /// Named provider profile to run this job on (e.g. "perplexity").
+    #[serde(default)]
+    pub provider_profile: Option<String>,
 }
 
 /// Response after queue submission.
diff --git a/crates/entity-daemon/src/hive_client.rs b/crates/entity-daemon/src/hive_client.rs
index 8255d847..2d6ea0c5 100644
--- a/crates/entity-daemon/src/hive_client.rs
+++ b/crates/entity-daemon/src/hive_client.rs
@@ -3,8 +3,10 @@
 use abigail_skills::{HiveAgentInfo, HiveOperations};
 use async_trait::async_trait;
 use hive_core::{
-    ApiEnvelope, CreateEntityResponse, EntityInfo, ProviderConfig, SecretListResponse,
-    SecretValueResponse,
+    ApiEnvelope, CreateEntityResponse, EntityInfo, ForgeApprovalJobsResponse, OutboxSyncRequest,
+    OutboxSyncResponse, ProviderConfig, RuntimeHeartbeatRequest, RuntimeHeartbeatResponse,
+    RuntimeRegistrationRequest, RuntimeSessionLease, RuntimeSessionRequest, RuntimeSessionStatus,
+    SecretListResponse, SecretValueResponse, SkillAssignmentsResponse,
 };
 
 /// HTTP client for fetching data from the Hive daemon.
@@ -16,9 +18,16 @@ pub struct HiveClient {
 
 impl HiveClient {
     pub fn new(base_url: &str) -> Self {
+        // Control-plane calls share the supervision loop with heartbeats and
+        // outbox sync; an unbounded request (e.g. a half-open connection
+        // across a hive restart) would stop heartbeats permanently.
+        let client = reqwest::Client::builder()
+            .timeout(std::time::Duration::from_secs(15))
+            .build()
+            .unwrap_or_default();
         Self {
             base_url: base_url.trim_end_matches('/').to_string(),
-            client: reqwest::Client::new(),
+            client,
         }
     }
 
@@ -40,6 +49,45 @@ impl HiveClient {
         }
     }
 
+    /// Fetch the entity's full birth document (idempotent runtime identity).
+    /// Called on every launch so hive-side changes apply on restart.
+    pub async fn get_birth_document(
+        &self,
+        entity_id: &str,
+    ) -> anyhow::Result<hive_core::EntityBirthDocument> {
+        let url = format!("{}/v1/entities/{}/birth", self.base_url, entity_id);
+        let resp: ApiEnvelope<hive_core::EntityBirthDocument> =
+            self.client.get(&url).send().await?.json().await?;
+        if resp.ok {
+            resp.data
+                .ok_or_else(|| anyhow::anyhow!("Empty data in birth document response"))
+        } else {
+            Err(anyhow::anyhow!(
+                "Hive error: {}",
+                resp.error.unwrap_or_default()
+            ))
+        }
+    }
+
+    /// Resolve a named provider profile for sub-agent delegation.
+    pub async fn get_provider_profile(
+        &self,
+        name: &str,
+    ) -> anyhow::Result<hive_core::ProviderProfileResponse> {
+        let url = format!("{}/v1/providers/profiles/{}", self.base_url, name);
+        let resp: ApiEnvelope<hive_core::ProviderProfileResponse> =
+            self.client.get(&url).send().await?.json().await?;
+        if resp.ok {
+            resp.data
+                .ok_or_else(|| anyhow::anyhow!("Empty data in provider-profile response"))
+        } else {
+            Err(anyhow::anyhow!(
+                "Hive error: {}",
+                resp.error.unwrap_or_default()
+            ))
+        }
+    }
+
     /// Fetch a secret value from Hive by key. Returns None if not found.
     pub async fn get_secret(&self, key: &str) -> anyhow::Result<Option<String>> {
         let url = format!("{}/v1/secrets/{}", self.base_url, key);
@@ -66,6 +114,145 @@ impl HiveClient {
             ))
         }
     }
+
+    pub async fn issue_runtime_session(
+        &self,
+        entity_id: &str,
+        runtime_id: Option<String>,
+    ) -> anyhow::Result<RuntimeSessionLease> {
+        let url = format!("{}/v1/runtime/sessions", self.base_url);
+        let resp: ApiEnvelope<RuntimeSessionLease> = self
+            .client
+            .post(&url)
+            .json(&RuntimeSessionRequest {
+                entity_id: entity_id.to_string(),
+                runtime_id,
+            })
+            .send()
+            .await?
+            .json()
+            .await?;
+        if resp.ok {
+            resp.data
+                .ok_or_else(|| anyhow::anyhow!("Empty data in runtime session response"))
+        } else {
+            Err(anyhow::anyhow!(
+                "Hive error: {}",
+                resp.error.unwrap_or_default()
+            ))
+        }
+    }
+
+    pub async fn register_runtime(
+        &self,
+        request: &RuntimeRegistrationRequest,
+    ) -> anyhow::Result<RuntimeSessionStatus> {
+        let url = format!("{}/v1/runtime/register", self.base_url);
+        let resp: ApiEnvelope<RuntimeSessionStatus> = self
+            .client
+            .post(&url)
+            .json(request)
+            .send()
+            .await?
+            .json()
+            .await?;
+        if resp.ok {
+            resp.data
+                .ok_or_else(|| anyhow::anyhow!("Empty data in runtime register response"))
+        } else {
+            Err(anyhow::anyhow!(
+                "Hive error: {}",
+                resp.error.unwrap_or_default()
+            ))
+        }
+    }
+
+    pub async fn heartbeat(
+        &self,
+        request: &RuntimeHeartbeatRequest,
+    ) -> anyhow::Result<RuntimeHeartbeatResponse> {
+        let url = format!("{}/v1/runtime/heartbeat", self.base_url);
+        let resp: ApiEnvelope<RuntimeHeartbeatResponse> = self
+            .client
+            .post(&url)
+            .json(request)
+            .send()
+            .await?
+            .json()
+            .await?;
+        if resp.ok {
+            resp.data
+                .ok_or_else(|| anyhow::anyhow!("Empty data in runtime heartbeat response"))
+        } else {
+            Err(anyhow::anyhow!(
+                "Hive error: {}",
+                resp.error.unwrap_or_default()
+            ))
+        }
+    }
+
+    pub async fn get_skill_assignments(
+        &self,
+        entity_id: &str,
+    ) -> anyhow::Result<SkillAssignmentsResponse> {
+        let url = format!("{}/v1/entities/{}/assignments", self.base_url, entity_id);
+        let resp: ApiEnvelope<SkillAssignmentsResponse> =
+            self.client.get(&url).send().await?.json().await?;
+        if resp.ok {
+            resp.data
+                .ok_or_else(|| anyhow::anyhow!("Empty data in assignments response"))
+        } else {
+            Err(anyhow::anyhow!(
+                "Hive error: {}",
+                resp.error.unwrap_or_default()
+            ))
+        }
+    }
+
+    pub async fn get_forge_approval_jobs(
+        &self,
+        entity_id: &str,
+    ) -> anyhow::Result<ForgeApprovalJobsResponse> {
+        let url = format!(
+            "{}/v1/entities/{}/forge-approvals",
+            self.base_url, entity_id
+        );
+        let resp: ApiEnvelope<ForgeApprovalJobsResponse> =
+            self.client.get(&url).send().await?.json().await?;
+        if resp.ok {
+            resp.data
+                .ok_or_else(|| anyhow::anyhow!("Empty data in forge approvals response"))
+        } else {
+            Err(anyhow::anyhow!(
+                "Hive error: {}",
+                resp.error.unwrap_or_default()
+            ))
+        }
+    }
+
+    pub async fn sync_outbox(
+        &self,
+        request: &OutboxSyncRequest,
+    ) -> anyhow::Result<OutboxSyncResponse> {
+        let url = format!("{}/v1/runtime/outbox/sync", self.base_url);
+        let resp: ApiEnvelope<OutboxSyncResponse> = self
+            .client
+            .post(&url)
+            .json(request)
+            .send()
+            .await?
+            .json()
+            .await?;
+        if resp.ok {
+            resp.data
+                .ok_or_else(|| anyhow::anyhow!("Empty data in outbox sync response"))
+        } else {
+            Err(anyhow::anyhow!(
+                "Hive error: {}",
+                resp.error.unwrap_or_default()
+            ))
+        }
+    }
 }
 
 /// Implementation of `HiveOperations` that calls hive-daemon over HTTP.
diff --git a/crates/entity-daemon/src/main.rs b/crates/entity-daemon/src/main.rs
index 6f792e76..985399bb 100644
--- a/crates/entity-daemon/src/main.rs
+++ b/crates/entity-daemon/src/main.rs
@@ -8,25 +8,26 @@ mod capability_matcher;
 mod hive_client;
 mod job_scheduler;
 mod memory_consumer;
+mod outbox;
+mod pipeline;
 mod queue_ops;
+mod router_build;
 mod routes;
 mod state;
 mod subagent_runner;
 
 use abigail_core::{AppConfig, SecretsVault};
-use abigail_hive::Hive;
 use abigail_identity::{HiveEntity, IdentityManager};
 use abigail_memory::MemoryStore;
 use abigail_persistence::{EntityScope, PersistenceHandle};
 use abigail_queue::JobQueue;
-use abigail_router::IdEgoRouter;
 use abigail_runtime::{
     collect_declared_secret_keys, register_dynamic_api_skills, register_hive_management_skill,
     register_identity_bound_skills, register_preloaded_skills, register_skill_factory,
     register_supported_native_skills,
 };
 use abigail_skills::{Skill, SkillExecutionPolicy, SkillExecutor, SkillRegistry};
-use abigail_streaming::{IggyBroker, MemoryBroker, StreamBroker, TopicConfig};
+use abigail_streaming::{MemoryBroker, StreamBroker};
 use axum::routing::{get, post};
 use axum::Router;
 use capability_matcher::CapabilityMatcher;
@@ -59,8 +60,8 @@ struct Cli {
     #[arg(long)]
     data_dir: Option<String>,
 
-    /// Iggy connection string for persistent event streaming.
-    /// When omitted, uses an in-process MemoryBroker (no external deps).
+    /// Reserved for a future external broker.
+    /// The current dev build always uses the in-process MemoryBroker.
     #[arg(long)]
     iggy_connection: Option<String>,
 }
@@ -82,60 +83,68 @@ async fn main() -> anyhow::Result<()> {
         cli.entity_id,
         cli.hive_url
     );
+    let entity_id = uuid::Uuid::parse_str(&cli.entity_id)
+        .map(|id| id.to_string())
+        .map_err(|e| anyhow::anyhow!("--entity-id must be a valid UUID: {}", e))?;
 
     // 1. Fetch provider config from Hive
     let hive_client = HiveClient::new(&cli.hive_url);
-    let entity_info = hive_client.get_entity(&cli.entity_id).await?;
+    let entity_info = hive_client.get_entity(&entity_id).await?;
     tracing::info!(
         "Entity '{}' (birth_complete={})",
         entity_info.name,
         entity_info.birth_complete
     );
 
-    let provider_config = hive_client.get_provider_config(&cli.entity_id).await?;
+    // Idempotent birth re-read: the full runtime identity in one shot.
+    // Hive-side changes (provider, certificate, assignments) apply on the
+    // next launch with no re-provisioning. Falls back to the older
+    // provider-config endpoint for pre-birth-document hives.
+    let provider_config = match hive_client.get_birth_document(&entity_id).await {
+        Ok(birth_doc) => {
+            if let Some(ref certificate) = birth_doc.certificate {
+                tracing::info!(
+                    "Born as {} — {}",
+                    certificate.archetype,
+                    certificate.epithet
+                );
+            }
+            birth_doc.provider_config
+        }
+        Err(e) => {
+            tracing::debug!("Birth document unavailable ({}); using provider-config", e);
+            hive_client.get_provider_config(&entity_id).await?
+        }
+    };
     tracing::info!(
         "Provider config: ego={:?}, routing_mode={}",
         provider_config.ego_provider_name,
         provider_config.routing_mode
     );
 
-    // 2. Build providers from the resolved config
-    let cli_permission_mode = provider_config
-        .cli_permission_mode
-        .as_deref()
-        .and_then(|s| {
-            serde_json::from_str::<abigail_core::CliPermissionMode>(&format!("\"{s}\"")).ok()
-        })
-        .unwrap_or_default();
-
-    let hive_config = abigail_hive::HiveConfig {
-        local_llm_base_url: provider_config.local_llm_base_url,
-        ego_provider: provider_config.ego_provider_name.map(|provider| {
-            let auth = abigail_hive::ProviderAuth::System;
-            abigail_hive::ProviderSelection { provider, auth }
-        }),
-        ego_model: provider_config.ego_model,
-        routing_mode: parse_routing_mode(&provider_config.routing_mode),
-        cli_permission_mode,
-    };
-
-    let built = Hive::build_providers(&hive_config).await;
+    let session_lease = hive_client
+        .issue_runtime_session(&entity_id, Some(format!("entity-runtime-{}", entity_id)))
+        .await?;
+    tracing::info!(
+        "Issued runtime session lease {} for runtime {}",
+        session_lease.lease_id,
+        session_lease.runtime_id
+    );
 
-    // 3. Build the router from pre-built providers
-    let router = IdEgoRouter::from_built_providers(built);
-    let router = Arc::new(router);
+    // 2/3. Build providers + router from the resolved config (shared with the
+    // governance hot-swap path). Keep a JSON snapshot so the supervision loop
+    // can detect hive-side provider changes.
+    let initial_provider_config = serde_json::to_value(&provider_config).unwrap_or_default();
+    let ego_provider_for_discovery = provider_config.ego_provider_name.clone();
+    let ego_key_for_discovery = provider_config.ego_api_key.clone();
+    let router = Arc::new(router_build::build_router(provider_config).await);
+    let router = Arc::new(state::RouterHandle::new(router));
     tracing::info!("Router built");
 
     // 3b. Background model discovery (non-blocking diagnostic)
     {
-        let ego_provider = hive_config
-            .ego_provider
-            .as_ref()
-            .map(|selection| selection.provider.clone());
-        let ego_key = hive_config
-            .ego_provider
-            .as_ref()
-            .and_then(|selection| selection.api_key());
+        let ego_provider = ego_provider_for_discovery;
+        let ego_key = ego_key_for_discovery;
         tokio::spawn(async move {
             if let (Some(provider), Some(key)) = (ego_provider, ego_key) {
                 match abigail_capabilities::cognitive::validation::discover_models(&provider, &key)
@@ -161,8 +170,9 @@ async fn main() -> anyhow::Result<()> {
     } else {
         AppConfig::default_paths().data_dir
     };
+    abigail_core::vault::unlock::configure_process_vault_data_dir(&data_root);
     tracing::info!("Entity data root: {}", data_root.display());
-    let entity_dir = data_root.join("identities").join(&cli.entity_id);
+    let entity_dir = data_root.join("identities").join(&entity_id);
     let docs_dir = entity_dir.join("docs");
     let skills_dir = entity_dir.join("skills");
     let shared_skills_base = data_root.join("skills");
@@ -185,7 +195,7 @@ async fn main() -> anyhow::Result<()> {
     config.agent_name = Some(entity_info.name.clone());
     config.birth_complete = entity_info.birth_complete;
     config.is_hive = entity_info.is_hive;
-    config.routing_mode = hive_config.routing_mode;
+    config.routing_mode = router.current().mode;
     config.data_dir = entity_dir.clone();
     config.docs_dir = docs_dir.clone();
     config.db_path = HiveEntity::memory_db_path(&data_root);
@@ -215,7 +225,89 @@ async fn main() -> anyhow::Result<()> {
     if let Err(e) = registry.set_execution_policy(SkillExecutionPolicy::from_app_config(&config)) {
         tracing::error!("Failed to apply entity skill execution policy: {}", e);
     }
-    let executor = Arc::new(SkillExecutor::new(registry.clone()));
+
+    // In-process stream broker — created before the executor so every tool
+    // execution publishes a `Topic::SkillExecuted` audit envelope.
+    if let Some(ref conn) = cli.iggy_connection {
+        tracing::warn!(
+            "Ignoring --iggy-connection={} in the current dev build; using in-process MemoryBroker",
+            conn
+        );
+    } else {
+        tracing::info!("Using in-process MemoryBroker");
+    }
+    let stream_broker: Arc<dyn StreamBroker> = Arc::new(MemoryBroker::default());
+
+    let executor =
+        Arc::new(SkillExecutor::new(registry.clone()).with_broker(stream_broker.clone()));
+
+    // 5b. Register configured MCP servers as dynamic skills (HTTP transport).
+    //     Runs async so a slow/unreachable MCP server never delays boot.
+    {
+        let mcp_servers: Vec<_> = config
+            .mcp_servers
+            .iter()
+            .filter(|s| s.transport.eq_ignore_ascii_case("http"))
+            .cloned()
+            .collect();
+        if !mcp_servers.is_empty() {
+            let trust_policy = config.mcp_trust_policy.clone();
+            let registry_for_mcp = registry.clone();
+            let broker_for_mcp = stream_broker.clone();
+            tokio::spawn(async move {
+                for server in mcp_servers {
+                    if let Err(policy_err) =
+                        trust_policy.validate_http_server_url(&server.id, &server.command_or_url)
+                    {
+                        tracing::warn!(
+                            "MCP server '{}' rejected by trust policy: {}",
+                            server.id,
+                            policy_err
+                        );
+                        continue;
+                    }
+                    let mut runtime = abigail_skills::protocol::mcp::McpSkillRuntime::new(
+                        format!("mcp.{}", server.id),
+                        format!("MCP {}", server.name),
+                        server.command_or_url.clone(),
+                        Some(trust_policy.clone()),
+                    );
+                    if let Err(e) = abigail_skills::Skill::initialize(
+                        &mut runtime,
+                        abigail_skills::skill::SkillConfig {
+                            values: std::collections::HashMap::new(),
+                            secrets: std::collections::HashMap::new(),
+                            limits: Default::default(),
+                            permissions: vec![],
+                            stream_broker: Some(broker_for_mcp.clone()),
+                        },
+                    )
+                    .await
+                    {
+                        tracing::warn!(
+                            "MCP server '{}' initialization failed ({}); skipping",
+                            server.id,
+                            e
+                        );
+                        continue;
+                    }
+                    let skill_id = abigail_skills::Skill::manifest(&runtime).id.clone();
+                    let tool_count = abigail_skills::Skill::tools(&runtime).len();
+                    match registry_for_mcp.register(skill_id.clone(), Arc::new(runtime)) {
+                        Ok(_) => tracing::info!(
+                            "Registered MCP server '{}' as skill {} ({} tools)",
+                            server.id,
+                            skill_id.0,
+                            tool_count
+                        ),
+                        Err(e) => {
+                            tracing::warn!("Failed to register MCP skill {}: {}", skill_id.0, e)
+                        }
+                    }
+                }
+            });
+        }
+    }
 
     // 6. Register HiveManagementSkill (built-in)
     let http_hive_ops = Arc::new(hive_client::HttpHiveOps::new(&cli.hive_url));
@@ -250,7 +342,7 @@ async fn main() -> anyhow::Result<()> {
         register_identity_bound_skills(
             &registry,
             config.data_dir.clone(),
-            Some(cli.entity_id.clone()),
+            Some(entity_id.clone()),
             allow_local_network,
         );
         register_supported_native_skills(
@@ -346,54 +438,13 @@ async fn main() -> anyhow::Result<()> {
         }
     };
 
-    // 10. Initialize event streaming (Iggy if configured, otherwise in-process MemoryBroker) and job queue.
-    let stream_broker: Arc<dyn StreamBroker> = if let Some(ref conn) = cli.iggy_connection {
-        let broker = Arc::new(
-            IggyBroker::new(conn.clone())
-                .map_err(|e| anyhow::anyhow!("Failed to configure Iggy broker: {}", e))?,
-        );
-
-        let topics: &[(&str, &str)] = &[
-            ("abigail", "job-events"),
-            ("abigail", "conversation-turns"),
-            ("abigail", "skill-events"),
-            ("entity", "conscience-check"),
-            ("entity", "ethical-signals"),
-        ];
-        for (stream, topic) in topics {
-            broker
-                .ensure_topic(stream, topic, TopicConfig::default())
-                .await
-                .map_err(|e| {
-                    anyhow::anyhow!("Failed to ensure Iggy topic {}/{}: {}", stream, topic, e)
-                })?;
-            broker
-                .ensure_consumer_group(stream, topic, "entity-daemon")
-                .await
-                .map_err(|e| {
-                    anyhow::anyhow!(
-                        "Failed to ensure Iggy consumer group entity-daemon for {}/{}: {}",
-                        stream,
-                        topic,
-                        e
-                    )
-                })?;
-        }
-        tracing::info!(
-            "Connected to Iggy at {} ({} topics bootstrapped)",
-            conn,
-            topics.len()
-        );
-        broker
-    } else {
-        tracing::info!("Using in-process MemoryBroker (no --iggy-connection provided)");
-        Arc::new(MemoryBroker::default())
-    };
-
+    // 10. Event streaming uses the in-process broker created before the executor.
     // Phase 5B: Safe async boot - never block the main runtime.
     abigail_skills::set_skill_topology_broker(stream_broker.clone());
-    tokio::spawn(async {
-        abigail_skills::provision_all_skills("skills/registry.toml").await;
+    let provisioning_registry_path = shared_registry_path.clone();
+    tokio::spawn(async move {
+        let registry_path = provisioning_registry_path.to_string_lossy().to_string();
+        abigail_skills::provision_all_skills(&registry_path).await;
     });
 
     tokio::spawn(async {
@@ -474,9 +525,34 @@ async fn main() -> anyhow::Result<()> {
     let total_skills = registry.list().map(|s| s.len()).unwrap_or(0);
     tracing::info!("Total skills registered: {}", total_skills);
 
+    let skill_assignments = hive_client
+        .get_skill_assignments(&entity_id)
+        .await
+        .map(|response| response.assignments)
+        .unwrap_or_default();
+    let forge_jobs = hive_client
+        .get_forge_approval_jobs(&entity_id)
+        .await
+        .map(|response| response.jobs)
+        .unwrap_or_default();
+    let outbox = Arc::new(outbox::RuntimeOutbox::load(&entity_dir, 256)?);
+
+    // Soul reference: hash of the entity's soul documents, stamped on every
+    // pipeline envelope so downstream observers know which identity version
+    // produced a message.
+    let soul_ref = {
+        let mut soul_bytes = std::fs::read(docs_dir.join("soul.md")).unwrap_or_default();
+        soul_bytes
+            .extend_from_slice(&std::fs::read(docs_dir.join("ethics.md")).unwrap_or_default());
+        abigail_streaming::compute_soul_ref(&soul_bytes)
+    };
+
     let state = EntityDaemonState {
-        entity_id: cli.entity_id.clone(),
+        entity_id: entity_id.clone(),
         config,
+        hive_url: cli.hive_url.clone(),
+        runtime_id: session_lease.runtime_id.clone(),
+        session_lease,
         router,
         registry,
         executor,
@@ -492,10 +568,26 @@ async fn main() -> anyhow::Result<()> {
         constraints: Arc::new(tokio::sync::RwLock::new(
             abigail_router::ConstraintStore::with_data_dir(entity_dir.clone()),
         )),
+        outbox,
+        last_hive_sync_at_utc: Arc::new(tokio::sync::RwLock::new(None)),
+        last_hive_error: Arc::new(tokio::sync::RwLock::new(None)),
+        runtime_url: Arc::new(tokio::sync::RwLock::new(None)),
+        skill_assignments: Arc::new(tokio::sync::RwLock::new(skill_assignments)),
+        forge_jobs: Arc::new(tokio::sync::RwLock::new(forge_jobs)),
+        recent_skill_acks: Arc::new(tokio::sync::RwLock::new(Vec::new())),
+        turns: Arc::new(pipeline::TurnRegistry::default()),
+        soul_ref,
     };
 
+    // Spawn the bicameral chat pipeline (Id stage → Ego stage → journal).
+    // Fatal on failure: without the pipeline every chat request would hang
+    // until the turn timeout, which is worse than refusing to start.
+    let _pipeline_handles = pipeline::spawn(state.clone())
+        .await
+        .map_err(|e| anyhow::anyhow!("Failed to start chat pipeline: {}", e))?;
+
     // Start background queue scheduler (Phase 1 async sub-agent execution).
-    let capability_matcher = CapabilityMatcher::from_router(state.router.clone());
+    let capability_matcher = CapabilityMatcher::from_router(state.router.current());
     let subagent_runner = Arc::new(
         SubagentRunner::new(
             state.job_queue.clone(),
@@ -506,7 +598,8 @@ async fn main() -> anyhow::Result<()> {
             state.config.agent_name.clone(),
         )
         .with_docs_dir(state.docs_dir.clone())
-        .with_instruction_registry(state.instruction_registry.clone()),
+        .with_instruction_registry(state.instruction_registry.clone())
+        .with_hive_client(Arc::new(hive_client.clone())),
     );
     let scheduler = Arc::new(
         JobScheduler::new(state.job_queue.clone(), subagent_runner)
@@ -537,6 +630,7 @@ async fn main() -> anyhow::Result<()> {
         let registry_for_watcher = state.registry.clone();
         let vault_for_watcher = Some(skill_vault.clone());
         let broker_for_watcher = state.stream_broker.clone();
+        let state_for_watcher = state.clone();
 
         match abigail_skills::SkillsWatcher::start(vec![watch_dir, shared_watch_dir]) {
             Ok((watcher, mut rx)) => {
@@ -581,6 +675,18 @@ async fn main() -> anyhow::Result<()> {
                                                         },
                                                     )
                                                     .await;
+                                                    state_for_watcher
+                                                        .push_skill_ack(entity_core::SkillApplyAcknowledgement {
+                                                            skill_id: p
+                                                                .file_stem()
+                                                                .and_then(|stem| stem.to_str())
+                                                                .unwrap_or("unknown")
+                                                                .to_string(),
+                                                            status: "reloaded".to_string(),
+                                                            applied_at_utc: chrono::Utc::now()
+                                                                .to_rfc3339(),
+                                                        })
+                                                        .await;
                                                 }
                                                 Err(e) => tracing::debug!(
                                                     "Skill watcher: skip {:?}: {}",
@@ -642,6 +748,18 @@ async fn main() -> anyhow::Result<()> {
                                                         },
                                                     )
                                                     .await;
+                                                    state_for_watcher
+                                                        .push_skill_ack(entity_core::SkillApplyAcknowledgement {
+                                                            skill_id: p
+                                                                .file_stem()
+                                                                .and_then(|stem| stem.to_str())
+                                                                .unwrap_or("unknown")
+                                                                .to_string(),
+                                                            status: "removed".to_string(),
+                                                            applied_at_utc: chrono::Utc::now()
+                                                                .to_rfc3339(),
+                                                        })
+                                                        .await;
                                                 }
                                             }
                                         }
@@ -681,6 +799,8 @@ async fn main() -> anyhow::Result<()> {
     let app = Router::new()
         .route("/health", get(routes::health))
         .route("/v1/status", get(routes::get_status))
+        .route("/v1/session/status", get(routes::get_session_status))
+        .route("/v1/outbox/status", get(routes::get_outbox_status))
         .route("/v1/chat", post(routes::chat))
         .route("/v1/chat/stream", post(routes::chat_stream))
         .route("/v1/chat/cancel", post(routes::cancel_chat_stream))
@@ -697,30 +817,163 @@ async fn main() -> anyhow::Result<()> {
         .route("/v1/topics/:topic/watch", get(routes::watch_topic))
         .route("/v1/routing/diagnose", get(routes::diagnose_routing))
         .route("/v1/skills", get(routes::list_skills))
+        .route(
+            "/v1/skills/acks",
+            get(routes::list_skill_apply_acknowledgements),
+        )
         .route("/v1/tools/execute", post(routes::execute_tool))
         .route("/v1/memory/stats", get(routes::memory_stats))
         .route("/v1/memory/search", post(routes::memory_search))
         .route("/v1/memory/recent", get(routes::memory_recent))
         .route("/v1/memory/insert", post(routes::memory_insert))
         .layer(cors)
-        .with_state(state);
+        .with_state(state.clone());
 
-    let addr = format!("127.0.0.1:{}", cli.port);
-    tracing::info!("Entity daemon listening on http://{}", addr);
-    println!("Entity daemon listening on http://{}", addr);
+    let listener = tokio::net::TcpListener::bind(("127.0.0.1", cli.port)).await?;
+    let local_addr = listener.local_addr()?;
+    let local_url = format!("http://{}", local_addr);
+    {
+        let mut runtime_url = state.runtime_url.write().await;
+        *runtime_url = Some(local_url.clone());
+    }
 
-    let listener = tokio::net::TcpListener::bind(&addr).await?;
+    hive_client
+        .register_runtime(&hive_core::RuntimeRegistrationRequest {
+            lease_id: state.session_lease.lease_id.clone(),
+            runtime_id: state.runtime_id.clone(),
+            local_url: local_url.clone(),
+            process_id: Some(std::process::id()),
+        })
+        .await?;
+    state.record_hive_sync_success().await;
+    spawn_runtime_supervision(state.clone(), hive_client.clone(), initial_provider_config);
+
+    tracing::info!("Entity daemon listening on {}", local_url);
+    println!("Entity daemon listening on {}", local_url);
     axum::serve(listener, app).await?;
 
     Ok(())
 }
 
-fn parse_routing_mode(s: &str) -> abigail_core::RoutingMode {
-    match s {
-        "EgoPrimary" | "TierBased" | "IdPrimary" | "Council" => {
-            abigail_core::RoutingMode::EgoPrimary
+fn spawn_runtime_supervision(
+    state: EntityDaemonState,
+    hive_client: HiveClient,
+    initial_provider_config: serde_json::Value,
+) {
+    tokio::spawn(async move {
+        let mut ticker = tokio::time::interval(std::time::Duration::from_secs(10));
+        let mut tick_count: u64 = 0;
+        let mut last_provider_config = initial_provider_config;
+        loop {
+            ticker.tick().await;
+            tick_count += 1;
+
+            // Every 6th tick (~60s): check the Hive for a changed provider
+            // config and publish a governance refresh so the router hot-swaps
+            // without an entity-daemon restart.
+            if tick_count.is_multiple_of(6) {
+                if let Ok(fresh) = hive_client.get_provider_config(&state.entity_id).await {
+                    let fresh_json = serde_json::to_value(&fresh).unwrap_or_default();
+                    if fresh_json != last_provider_config {
+                        tracing::info!(
+                            "Provider config changed on hive (ego={:?}); publishing refresh",
+                            fresh.ego_provider_name
+                        );
+                        last_provider_config = fresh_json.clone();
+                        let envelope = abigail_streaming::Envelope::new(
+                            abigail_streaming::Topic::GovernanceInbound,
+                            state.entity_id.clone(),
+                            uuid::Uuid::new_v4().to_string(),
+                            serde_json::json!({
+                                "kind": pipeline::governance::KIND_PROVIDER_REFRESH,
+                                "provider_config": fresh_json,
+                            }),
+                        )
+                        .with_soul_ref(state.soul_ref.clone());
+                        if let Err(e) = envelope.publish(state.stream_broker.as_ref()).await {
+                            tracing::warn!("Failed to publish provider refresh: {}", e);
+                        }
+                    }
+                }
+            }
+
+            // Every 3rd tick (~30s): check the Hive for changed skill
+            // assignments and publish a governance refresh on the bus so
+            // they apply live without an entity-daemon restart.
+            if tick_count.is_multiple_of(3) {
+                if let Ok(response) = hive_client.get_skill_assignments(&state.entity_id).await {
+                    let fresh = response.assignments;
+                    let changed = {
+                        let current = state.skill_assignments.read().await;
+                        serde_json::to_value(&*current).ok() != serde_json::to_value(&fresh).ok()
+                    };
+                    if changed {
+                        let envelope = abigail_streaming::Envelope::new(
+                            abigail_streaming::Topic::GovernanceInbound,
+                            state.entity_id.clone(),
+                            uuid::Uuid::new_v4().to_string(),
+                            serde_json::json!({
+                                "kind": pipeline::governance::KIND_SKILL_ASSIGNMENTS_REFRESH,
+                                "assignments": fresh,
+                            }),
+                        )
+                        .with_soul_ref(state.soul_ref.clone());
+                        if let Err(e) = envelope.publish(state.stream_broker.as_ref()).await {
+                            tracing::warn!("Failed to publish assignment refresh: {}", e);
+                        }
+                    }
+                }
+            }
+
+            let outbox_status = match state.outbox.status() {
+                Ok(status) => status,
+                Err(error) => {
+                    state.record_hive_sync_error(error).await;
+                    continue;
+                }
+            };
+            let runtime_url = state.runtime_url.read().await.clone();
+
+            let heartbeat = hive_core::RuntimeHeartbeatRequest {
+                lease_id: state.session_lease.lease_id.clone(),
+                runtime_id: state.runtime_id.clone(),
+                local_url: runtime_url,
+                outbox_depth: outbox_status.queued_records,
+                outbox_oldest_at_utc: outbox_status.oldest_record_at_utc.clone(),
+            };
+
+            match hive_client.heartbeat(&heartbeat).await {
+                Ok(_) => {
+                    if let Ok(records) = state.outbox.snapshot() {
+                        if !records.is_empty() {
+                            match hive_client
+                                .sync_outbox(&hive_core::OutboxSyncRequest {
+                                    lease_id: state.session_lease.lease_id.clone(),
+                                    runtime_id: state.runtime_id.clone(),
+                                    records,
+                                })
+                                .await
+                            {
+                                Ok(response) => {
+                                    let _ = state.outbox.acknowledge(&response.accepted_record_ids);
+                                }
+                                Err(error) => {
+                                    let error = error.to_string();
+                                    let _ = state.outbox.mark_sync_error(&error);
+                                    state.record_hive_sync_error(error).await;
+                                    continue;
+                                }
+                            }
+                        }
+                    }
+                    state.record_hive_sync_success().await;
+                }
+                Err(error) => {
+                    let error = error.to_string();
+                    let _ = state.outbox.mark_sync_error(&error);
+                    state.record_hive_sync_error(error).await;
+                }
+            }
         }
-        "CliOrchestrator" => abigail_core::RoutingMode::CliOrchestrator,
-        _ => abigail_core::RoutingMode::default(),
-    }
+    });
 }
diff --git a/crates/entity-daemon/src/memory_consumer.rs b/crates/entity-daemon/src/memory_consumer.rs
index 71a3849f..bd9c0c8d 100644
--- a/crates/entity-daemon/src/memory_consumer.rs
+++ b/crates/entity-daemon/src/memory_consumer.rs
@@ -1,15 +1,15 @@
 //! Fire-and-forget memory persistence via StreamBroker topic consumer.
 //!
 //! Instead of blocking the chat request with synchronous `memory.insert_turn()`,
-//! turns are published to the `"abigail/conversation-turns"` topic and consumed
+//! turns are published to `Topic::MemoryArchive` and consumed
 //! asynchronously by a background task.
 
 use abigail_memory::{ConversationTurn, MemoryStore};
-use abigail_streaming::{StreamBroker, StreamMessage, SubscriptionHandle};
+use abigail_streaming::{StreamBroker, StreamMessage, SubscriptionHandle, Topic, BUS_STREAM};
 use std::sync::Arc;
 
-const STREAM: &str = "abigail";
-const TOPIC: &str = "conversation-turns";
+const STREAM: &str = BUS_STREAM;
+const TOPIC: &str = Topic::MemoryArchive.as_str();
 const CONSUMER_GROUP: &str = "memory-consumer";
 
 /// Publish a conversation turn to the StreamBroker for async persistence.
diff --git a/crates/entity-daemon/src/outbox.rs b/crates/entity-daemon/src/outbox.rs
new file mode 100644
index 00000000..0b008cb2
--- /dev/null
+++ b/crates/entity-daemon/src/outbox.rs
@@ -0,0 +1,143 @@
+use entity_core::{EntityOutboxRecord, EntityOutboxStatus};
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::PathBuf;
+use std::sync::Mutex;
+
+const OUTBOX_FILE_NAME: &str = "runtime_outbox.json";
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct PersistedOutbox {
+    #[serde(default)]
+    records: Vec<EntityOutboxRecord>,
+    #[serde(default)]
+    last_sync_at_utc: Option<String>,
+    #[serde(default)]
+    last_sync_error: Option<String>,
+}
+
+pub struct RuntimeOutbox {
+    path: PathBuf,
+    max_records: usize,
+    inner: Mutex<PersistedOutbox>,
+}
+
+impl RuntimeOutbox {
+    pub fn load(root_dir: impl AsRef<std::path::Path>, max_records: usize) -> anyhow::Result<Self> {
+        let path =
+            abigail_core::path_guard::trusted_file_path(root_dir.as_ref(), OUTBOX_FILE_NAME)?;
+        let inner = if path.exists() {
+            let bytes = fs::read_to_string(&path)?;
+            serde_json::from_str(&bytes)?
+        } else {
+            PersistedOutbox::default()
+        };
+
+        Ok(Self {
+            path,
+            max_records,
+            inner: Mutex::new(inner),
+        })
+    }
+
+    pub fn enqueue(
+        &self,
+        entity_id: &str,
+        kind: &str,
+        payload: serde_json::Value,
+    ) -> Result<EntityOutboxRecord, String> {
+        let mut inner = self.inner.lock().map_err(|e| e.to_string())?;
+        let record = EntityOutboxRecord {
+            record_id: uuid::Uuid::new_v4().to_string(),
+            entity_id: entity_id.to_string(),
+            kind: kind.to_string(),
+            created_at_utc: chrono::Utc::now().to_rfc3339(),
+            payload,
+        };
+        inner.records.push(record.clone());
+        if inner.records.len() > self.max_records {
+            let overflow = inner.records.len() - self.max_records;
+            inner.records.drain(0..overflow);
+        }
+        self.save_locked(&inner).map_err(|e| e.to_string())?;
+        Ok(record)
+    }
+
+    pub fn snapshot(&self) -> Result<Vec<EntityOutboxRecord>, String> {
+        let inner = self.inner.lock().map_err(|e| e.to_string())?;
+        Ok(inner.records.clone())
+    }
+
+    pub fn acknowledge(&self, accepted_record_ids: &[String]) -> Result<(), String> {
+        let mut inner = self.inner.lock().map_err(|e| e.to_string())?;
+        inner
+            .records
+            .retain(|record| !accepted_record_ids.iter().any(|id| id == &record.record_id));
+        inner.last_sync_at_utc = Some(chrono::Utc::now().to_rfc3339());
+        inner.last_sync_error = None;
+        self.save_locked(&inner).map_err(|e| e.to_string())
+    }
+
+    pub fn mark_sync_error(&self, error: &str) -> Result<(), String> {
+        let mut inner = self.inner.lock().map_err(|e| e.to_string())?;
+        inner.last_sync_error = Some(error.to_string());
+        self.save_locked(&inner).map_err(|e| e.to_string())
+    }
+
+    pub fn status(&self) -> Result<EntityOutboxStatus, String> {
+        let inner = self.inner.lock().map_err(|e| e.to_string())?;
+        Ok(EntityOutboxStatus {
+            queued_records: inner.records.len(),
+            oldest_record_at_utc: inner
+                .records
+                .first()
+                .map(|record| record.created_at_utc.clone()),
+            last_sync_at_utc: inner.last_sync_at_utc.clone(),
+            last_sync_error: inner.last_sync_error.clone(),
+        })
+    }
+
+    fn save_locked(&self, inner: &PersistedOutbox) -> anyhow::Result<()> {
+        if let Some(parent) = self.path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        fs::write(&self.path, serde_json::to_string_pretty(inner)?)?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::RuntimeOutbox;
+
+    #[test]
+    fn outbox_round_trips_and_acknowledges() {
+        let root = std::env::temp_dir().join(format!("abigail-outbox-{}", uuid::Uuid::new_v4()));
+        let outbox = RuntimeOutbox::load(&root, 4).unwrap();
+
+        let first = outbox
+            .enqueue(
+                "entity-1",
+                "chat_turn",
+                serde_json::json!({ "message": "hi" }),
+            )
+            .unwrap();
+        let second = outbox
+            .enqueue(
+                "entity-1",
+                "memory_insert",
+                serde_json::json!({ "content": "remember this" }),
+            )
+            .unwrap();
+
+        let snapshot = outbox.snapshot().unwrap();
+        assert_eq!(snapshot.len(), 2);
+
+        outbox
+            .acknowledge(std::slice::from_ref(&first.record_id))
+            .unwrap();
+        let snapshot = outbox.snapshot().unwrap();
+        assert_eq!(snapshot.len(), 1);
+        assert_eq!(snapshot[0].record_id, second.record_id);
+    }
+}
diff --git a/crates/entity-daemon/src/pipeline/ego_stage.rs b/crates/entity-daemon/src/pipeline/ego_stage.rs
new file mode 100644
index 00000000..f955a5a7
--- /dev/null
+++ b/crates/entity-daemon/src/pipeline/ego_stage.rs
@@ -0,0 +1,278 @@
+//! Ego stage: turns an Id reaction into a committed response.
+//!
+//! Subscribes to `Topic::IdReaction`, claims the turn's runtime context from
+//! the [`TurnRegistry`], builds the contextual message list from memory, runs
+//! the provider call (tool loop or streaming pipeline), then publishes
+//! `Topic::EgoAction` plus a `Topic::EgoDeliberation` trace and delivers the
+//! outcome to the waiting HTTP handler.
+
+use super::{EgoActionPayload, IdReactionPayload, TurnContext};
+use crate::state::EntityDaemonState;
+use abigail_streaming::{Envelope, SubscriptionHandle, Topic, TopicConfig, BUS_STREAM};
+use entity_core::ChatResponse;
+
+const CONSUMER_GROUP: &str = "ego-stage";
+
+pub async fn spawn(state: EntityDaemonState) -> anyhow::Result<SubscriptionHandle> {
+    let broker = state.stream_broker.clone();
+    broker
+        .ensure_topic(
+            BUS_STREAM,
+            Topic::IdReaction.as_str(),
+            TopicConfig::default(),
+        )
+        .await?;
+    broker
+        .ensure_consumer_group(BUS_STREAM, Topic::IdReaction.as_str(), CONSUMER_GROUP)
+        .await?;
+
+    let handler: abigail_streaming::broker::MessageHandler = Box::new(move |msg| {
+        let state = state.clone();
+        Box::pin(async move {
+            let Ok(envelope) = Envelope::from_message(&msg) else {
+                return;
+            };
+            let Ok(payload) = serde_json::from_value::<IdReactionPayload>(envelope.payload.clone())
+            else {
+                tracing::warn!("Ego stage: malformed IdReaction payload");
+                return;
+            };
+            let Some(ctx) = state.turns.take(&envelope.correlation_id) else {
+                // Handler timed out or this reaction belongs to no live turn.
+                tracing::warn!(
+                    "Ego stage: no live turn for correlation {}",
+                    envelope.correlation_id
+                );
+                return;
+            };
+            // Run each turn on its own task so a slow provider never
+            // serializes unrelated turns behind it.
+            tokio::spawn(async move {
+                respond(state, envelope.correlation_id, payload, ctx).await;
+            });
+        })
+    });
+
+    let handle = broker
+        .subscribe(
+            BUS_STREAM,
+            Topic::IdReaction.as_str(),
+            CONSUMER_GROUP,
+            handler,
+        )
+        .await?;
+    tracing::info!(
+        "Ego stage subscribed to {}/{}",
+        BUS_STREAM,
+        Topic::IdReaction
+    );
+    Ok(handle)
+}
+
+async fn respond(
+    state: EntityDaemonState,
+    correlation_id: String,
+    payload: IdReactionPayload,
+    ctx: TurnContext,
+) {
+    let TurnContext {
+        session_messages,
+        stream_tx,
+        cancel,
+        done,
+    } = ctx;
+
+    let budget = entity_chat::ContextBudget::default();
+    let messages = entity_chat::build_contextual_messages_with_memory(
+        &state.memory,
+        &payload.session_id,
+        &payload.system_prompt,
+        session_messages,
+        &payload.message,
+        &budget,
+    );
+    let tools = entity_chat::build_tool_definitions(&state.registry);
+    // Snapshot the active router for this turn (hot-swap applies on the next).
+    let router = state.router.current();
+    // Chat turns are depth 0; jobs submitted from this turn nest below it and
+    // inherit the turn's correlation id for trace continuity.
+    let job_ctx = entity_chat::JobContext {
+        depth: 0,
+        correlation_id: Some(correlation_id.clone()),
+    };
+
+    let result: anyhow::Result<entity_chat::ToolUseResult> = if let Some(stream_tx) = stream_tx {
+        // Tokens pass through the incremental superego gate on their way to
+        // the client: the relay cuts the stream on the first blocking finding
+        // so blocked content never reaches the SSE channel (see stream_gate).
+        let gated_tx = super::stream_gate::spawn_gated_relay(stream_tx);
+        let pipeline_fut = entity_chat::stream_chat_pipeline(
+            &router,
+            &state.executor,
+            messages,
+            tools,
+            gated_tx,
+            payload.model_override.clone(),
+            Some(&job_ctx),
+        );
+        tokio::pin!(pipeline_fut);
+        let cancelled = async {
+            match cancel.as_ref() {
+                Some(token) => token.cancelled().await,
+                None => std::future::pending().await,
+            }
+        };
+        tokio::select! {
+            res = &mut pipeline_fut => res.map(|p| entity_chat::ToolUseResult {
+                content: p.content,
+                tool_calls_made: p.tool_calls_made,
+                execution_trace: p.execution_trace,
+            }),
+            _ = cancelled => Err(anyhow::anyhow!("Interrupted by user")),
+        }
+    } else if tools.is_empty() {
+        router
+            .route_unified(abigail_router::RoutingRequest {
+                messages,
+                tools: None,
+                model_override: payload.model_override.clone(),
+                stream_tx: None,
+                force_id_only: false,
+            })
+            .await
+            .map(|r| entity_chat::ToolUseResult {
+                content: r.completion.content,
+                tool_calls_made: Vec::new(),
+                execution_trace: r.trace,
+            })
+    } else {
+        entity_chat::run_tool_use_loop_with_model_override(
+            &router,
+            &state.executor,
+            messages,
+            tools,
+            payload.model_override.clone(),
+            Some(&job_ctx),
+        )
+        .await
+    };
+
+    let action = match result {
+        Ok(tool_result) => {
+            let tier = tool_result.tier().map(|s| s.to_string());
+            let model_used = tool_result.model_used().map(|s| s.to_string());
+            let complexity_score = tool_result.complexity_score();
+            let provider = tool_result
+                .execution_trace
+                .as_ref()
+                .and_then(|t| t.final_provider())
+                .map(|s| s.to_string())
+                .or_else(|| Some(entity_chat::provider_label(&router)));
+
+            // Publish the deliberation trace for audit before committing.
+            if let Some(ref trace) = tool_result.execution_trace {
+                if let Ok(trace_json) = serde_json::to_value(trace) {
+                    let deliberation = Envelope::new(
+                        Topic::EgoDeliberation,
+                        state.entity_id.clone(),
+                        correlation_id.clone(),
+                        trace_json,
+                    )
+                    .with_soul_ref(state.soul_ref.clone());
+                    if let Err(e) = deliberation.publish(state.stream_broker.as_ref()).await {
+                        tracing::debug!("Ego stage: failed to publish deliberation: {}", e);
+                    }
+                }
+            }
+
+            // Pre-delivery superego gate: secrets and SSNs never reach the
+            // mentor; lesser concerns are flagged for the audit trail. On the
+            // streaming path the stream_gate relay has already cut the live
+            // token flow at the first blocking finding; this full-content
+            // pass renders the authoritative verdict for the committed
+            // action, the journal, and the handler's final event.
+            let gate = abigail_superego::evaluate(
+                &tool_result.content,
+                abigail_superego::EvaluationContext::ChatReply,
+            );
+            let findings: Vec<String> = gate.findings().iter().map(|f| f.rule.clone()).collect();
+
+            match gate {
+                abigail_superego::GateDecision::Block(_) => EgoActionPayload {
+                    session_id: payload.session_id.clone(),
+                    status: "blocked".to_string(),
+                    error: Some(format!(
+                        "Response withheld by superego: {}",
+                        findings.join(", ")
+                    )),
+                    response: None,
+                    user_message: payload.message.clone(),
+                    superego_verdict: Some("block".to_string()),
+                    superego_findings: findings,
+                },
+                gate => {
+                    let response = ChatResponse {
+                        reply: tool_result.content,
+                        provider,
+                        tool_calls_made: tool_result.tool_calls_made,
+                        tier,
+                        model_used,
+                        complexity_score,
+                        execution_trace: tool_result.execution_trace,
+                        session_id: Some(payload.session_id.clone()),
+                    };
+                    EgoActionPayload {
+                        session_id: payload.session_id.clone(),
+                        status: "success".to_string(),
+                        error: None,
+                        response: Some(response),
+                        user_message: payload.message.clone(),
+                        superego_verdict: Some(gate.verdict().to_string()),
+                        superego_findings: findings,
+                    }
+                }
+            }
+        }
+        Err(e) => EgoActionPayload {
+            session_id: payload.session_id.clone(),
+            status: "error".to_string(),
+            error: Some(e.to_string()),
+            response: None,
+            user_message: payload.message.clone(),
+            superego_verdict: None,
+            superego_findings: Vec::new(),
+        },
+    };
+
+    // Publish the committed action for the journal, superego, and any other
+    // observers — regardless of whether the handler is still waiting.
+    match serde_json::to_value(&action) {
+        Ok(action_json) => {
+            let envelope = Envelope::new(
+                Topic::EgoAction,
+                state.entity_id.clone(),
+                correlation_id.clone(),
+                action_json,
+            )
+            .with_soul_ref(state.soul_ref.clone());
+            if let Err(e) = envelope.publish(state.stream_broker.as_ref()).await {
+                tracing::error!("Ego stage: failed to publish EgoAction: {}", e);
+            }
+        }
+        Err(e) => tracing::error!("Ego stage: failed to serialize EgoAction: {}", e),
+    }
+
+    // Deliver the outcome to the waiting handler.
+    let outcome = match (action.status.as_str(), action.response) {
+        ("success", Some(response)) => Ok(response),
+        _ => Err(action
+            .error
+            .unwrap_or_else(|| "ego stage failed without detail".to_string())),
+    };
+    if done.send(outcome).is_err() {
+        tracing::debug!(
+            "Ego stage: handler for correlation {} no longer waiting",
+            correlation_id
+        );
+    }
+}
diff --git a/crates/entity-daemon/src/pipeline/governance.rs b/crates/entity-daemon/src/pipeline/governance.rs
new file mode 100644
index 00000000..ac36bb77
--- /dev/null
+++ b/crates/entity-daemon/src/pipeline/governance.rs
@@ -0,0 +1,137 @@
+//! Governance: applies hive-originated configuration changes over the bus.
+//!
+//! Subscribes to `Topic::GovernanceInbound`. The runtime supervision loop
+//! polls the Hive and publishes a refresh envelope when assignments change;
+//! this subscriber applies them live — no entity-daemon restart required.
+//! Dispatch is on the payload's `kind` field so future governance kinds
+//! (policy refresh, provider refresh) slot in without architecture change.
+
+use crate::state::EntityDaemonState;
+use abigail_streaming::{Envelope, SubscriptionHandle, Topic, TopicConfig, BUS_STREAM};
+use hive_core::SkillAssignment;
+
+const CONSUMER_GROUP: &str = "governance";
+
+/// Governance payload kind for live skill assignment refresh.
+pub const KIND_SKILL_ASSIGNMENTS_REFRESH: &str = "skill_assignments.refresh";
+
+/// Governance payload kind for live provider config refresh (router hot-swap).
+pub const KIND_PROVIDER_REFRESH: &str = "provider.refresh";
+
+pub async fn spawn(state: EntityDaemonState) -> anyhow::Result<SubscriptionHandle> {
+    let broker = state.stream_broker.clone();
+    broker
+        .ensure_topic(
+            BUS_STREAM,
+            Topic::GovernanceInbound.as_str(),
+            TopicConfig::default(),
+        )
+        .await?;
+    broker
+        .ensure_consumer_group(
+            BUS_STREAM,
+            Topic::GovernanceInbound.as_str(),
+            CONSUMER_GROUP,
+        )
+        .await?;
+
+    let handler: abigail_streaming::broker::MessageHandler = Box::new(move |msg| {
+        let state = state.clone();
+        Box::pin(async move {
+            let Ok(envelope) = Envelope::from_message(&msg) else {
+                return;
+            };
+            let kind = envelope
+                .payload
+                .get("kind")
+                .and_then(|v| v.as_str())
+                .unwrap_or("");
+            match kind {
+                KIND_SKILL_ASSIGNMENTS_REFRESH => {
+                    apply_skill_assignments(&state, &envelope.payload).await;
+                }
+                KIND_PROVIDER_REFRESH => {
+                    apply_provider_refresh(&state, &envelope.payload).await;
+                }
+                other => {
+                    tracing::debug!("Governance: unhandled inbound kind '{}'", other);
+                }
+            }
+        })
+    });
+
+    let handle = broker
+        .subscribe(
+            BUS_STREAM,
+            Topic::GovernanceInbound.as_str(),
+            CONSUMER_GROUP,
+            handler,
+        )
+        .await?;
+    tracing::info!(
+        "Governance subscribed to {}/{}",
+        BUS_STREAM,
+        Topic::GovernanceInbound
+    );
+    Ok(handle)
+}
+
+/// Rebuild the router from a hive-resolved provider config and hot-swap it.
+/// All call sites fetch the router through [`crate::state::RouterHandle`], so
+/// the new provider takes effect on the next turn — no restart.
+async fn apply_provider_refresh(state: &EntityDaemonState, payload: &serde_json::Value) {
+    let provider_config = match serde_json::from_value::<hive_core::ProviderConfig>(
+        payload
+            .get("provider_config")
+            .cloned()
+            .unwrap_or(serde_json::Value::Null),
+    ) {
+        Ok(config) => config,
+        Err(e) => {
+            tracing::warn!("Governance: malformed provider refresh: {}", e);
+            return;
+        }
+    };
+
+    let ego_label = provider_config.ego_provider_name.clone();
+    let router = crate::router_build::build_router(provider_config).await;
+    state.router.swap(std::sync::Arc::new(router));
+    tracing::info!(
+        "Governance: router hot-swapped (ego={:?}) — provider change applied live",
+        ego_label
+    );
+}
+
+async fn apply_skill_assignments(state: &EntityDaemonState, payload: &serde_json::Value) {
+    let assignments = match serde_json::from_value::<Vec<SkillAssignment>>(
+        payload
+            .get("assignments")
+            .cloned()
+            .unwrap_or_else(|| serde_json::json!([])),
+    ) {
+        Ok(a) => a,
+        Err(e) => {
+            tracing::warn!("Governance: malformed skill assignment refresh: {}", e);
+            return;
+        }
+    };
+
+    let count = assignments.len();
+    {
+        let mut current = state.skill_assignments.write().await;
+        *current = assignments.clone();
+    }
+    for assignment in &assignments {
+        state
+            .push_skill_ack(entity_core::SkillApplyAcknowledgement {
+                skill_id: assignment.skill_id.clone(),
+                status: "assignment_refreshed".to_string(),
+                applied_at_utc: chrono::Utc::now().to_rfc3339(),
+            })
+            .await;
+    }
+    tracing::info!(
+        "Governance: applied {} skill assignment(s) from hive (live refresh)",
+        count
+    );
+}
diff --git a/crates/entity-daemon/src/pipeline/id_stage.rs b/crates/entity-daemon/src/pipeline/id_stage.rs
new file mode 100644
index 00000000..58941808
--- /dev/null
+++ b/crates/entity-daemon/src/pipeline/id_stage.rs
@@ -0,0 +1,216 @@
+//! Id stage: curates the system prompt for each mentor input.
+//!
+//! Subscribes to `Topic::MentorInput` (stage = "request"), synthesizes the
+//! system prompt from the entity's soul documents, constitutional enrichment,
+//! and an optional local-LLM personality consult, then publishes
+//! `Topic::IdReaction` for the Ego stage.
+
+use super::IdReactionPayload;
+use crate::state::EntityDaemonState;
+use abigail_capabilities::cognitive::Message;
+use abigail_core::constitutional::{
+    infer_id_context, infer_superego_context, load_minimal_preprompt,
+};
+use abigail_router::MentorChatEnvelope;
+use abigail_streaming::{Envelope, SubscriptionHandle, Topic, TopicConfig, BUS_STREAM};
+use std::time::Duration;
+
+const CONSUMER_GROUP: &str = "id-stage";
+
+/// Budget for the local Id personality consult; on timeout the turn proceeds
+/// degraded (no personality signal) rather than stalling the pipeline.
+const ID_CONSULT_TIMEOUT: Duration = Duration::from_secs(8);
+
+/// Maximum length of the personality signal woven into the prompt.
+const ID_SIGNAL_MAX_CHARS: usize = 400;
+
+pub async fn spawn(state: EntityDaemonState) -> anyhow::Result<SubscriptionHandle> {
+    let broker = state.stream_broker.clone();
+    broker
+        .ensure_topic(
+            BUS_STREAM,
+            Topic::MentorInput.as_str(),
+            TopicConfig::default(),
+        )
+        .await?;
+    broker
+        .ensure_consumer_group(BUS_STREAM, Topic::MentorInput.as_str(), CONSUMER_GROUP)
+        .await?;
+
+    let handler: abigail_streaming::broker::MessageHandler = Box::new(move |msg| {
+        let state = state.clone();
+        Box::pin(async move {
+            let Ok(envelope) = serde_json::from_slice::<MentorChatEnvelope>(&msg.payload) else {
+                return;
+            };
+            // The mentor chat monitor republishes enriched envelopes on this
+            // topic; the pipeline reacts to fresh requests only.
+            if envelope.stage != "request" {
+                return;
+            }
+            // Run each turn on its own task so a slow consult never serializes
+            // unrelated turns behind it.
+            tokio::spawn(async move {
+                curate_and_publish(state, envelope).await;
+            });
+        })
+    });
+
+    let handle = broker
+        .subscribe(
+            BUS_STREAM,
+            Topic::MentorInput.as_str(),
+            CONSUMER_GROUP,
+            handler,
+        )
+        .await?;
+    tracing::info!(
+        "Id stage subscribed to {}/{}",
+        BUS_STREAM,
+        Topic::MentorInput
+    );
+    Ok(handle)
+}
+
+async fn curate_and_publish(state: EntityDaemonState, envelope: MentorChatEnvelope) {
+    let status = state.router.current().status();
+    let lower = envelope.message.to_lowercase();
+    let id_context = infer_id_context(&lower).to_string();
+    let superego_context = infer_superego_context(&lower).to_string();
+
+    // Constitutional enrichment (same source the mentor monitor uses).
+    let enriched_preprompt = load_minimal_preprompt(&envelope.message).await.ok();
+
+    // Base prompt from the soul documents; CLI providers get the compressed form.
+    let base_prompt = if status.mode == abigail_core::RoutingMode::CliOrchestrator {
+        entity_chat::build_cli_system_prompt(
+            &state.docs_dir,
+            &state.config.agent_name,
+            &state.registry,
+            &state.instruction_registry,
+            &envelope.message,
+        )
+    } else {
+        let prompt = abigail_core::system_prompt::build_system_prompt(
+            &state.docs_dir,
+            &state.config.agent_name,
+        );
+        let runtime_ctx = entity_chat::RuntimeContext {
+            provider_name: status.ego_provider.clone(),
+            model_id: None,
+            routing_mode: Some(format!("{:?}", status.mode)),
+            tier: None,
+            complexity_score: None,
+            entity_name: state.config.agent_name.clone(),
+            entity_id: Some(state.entity_id.clone()),
+            has_local_llm: status.has_local_http,
+            last_provider_change_at: None,
+        };
+        entity_chat::augment_system_prompt(
+            &prompt,
+            &state.registry,
+            &state.instruction_registry,
+            &envelope.message,
+            &runtime_ctx,
+            entity_chat::PromptMode::Full,
+        )
+    };
+    let mut system_prompt = abigail_router::inject_preprompt(&base_prompt, enriched_preprompt);
+
+    // Personality consult on the local Id provider (skipped when no local LLM).
+    let (id_signal, id_consult) =
+        consult_id(&state, status.has_local_http, &envelope.message).await;
+    if let Some(ref signal) = id_signal {
+        system_prompt.push_str("\n\n## Id Signal\n");
+        system_prompt.push_str(signal);
+        system_prompt.push('\n');
+    }
+
+    let payload = IdReactionPayload {
+        session_id: envelope.session_id.clone(),
+        message: envelope.message.clone(),
+        model_override: envelope.selected_model.clone(),
+        system_prompt,
+        id_signal,
+        id_consult: id_consult.to_string(),
+        id_context,
+        superego_context,
+    };
+    let payload_json = match serde_json::to_value(&payload) {
+        Ok(v) => v,
+        Err(e) => {
+            tracing::error!("Id stage: failed to serialize IdReactionPayload: {}", e);
+            return;
+        }
+    };
+
+    let reaction = Envelope::new(
+        Topic::IdReaction,
+        state.entity_id.clone(),
+        envelope.correlation_id.clone(),
+        payload_json,
+    )
+    .with_soul_ref(state.soul_ref.clone());
+
+    if let Err(e) = reaction.publish(state.stream_broker.as_ref()).await {
+        tracing::error!("Id stage: failed to publish IdReaction: {}", e);
+    }
+}
+
+/// Ask the local Id provider for a one-sentence personality signal.
+async fn consult_id(
+    state: &EntityDaemonState,
+    has_local_llm: bool,
+    message: &str,
+) -> (Option<String>, &'static str) {
+    if !has_local_llm {
+        return (None, "skipped");
+    }
+
+    let agent_name = state
+        .config
+        .agent_name
+        .clone()
+        .unwrap_or_else(|| "this entity".to_string());
+    let consult_prompt = format!(
+        "You are the Id — the instinctive personality core of {}. \
+         Read the mentor's message and reply with ONE short sentence naming the \
+         emotional tone and drive the entity should bring to its reply. \
+         No preamble, no advice, no analysis.",
+        agent_name
+    );
+    let request = abigail_router::RoutingRequest {
+        messages: vec![
+            Message::new("system", &consult_prompt),
+            Message::new("user", message),
+        ],
+        tools: None,
+        model_override: None,
+        stream_tx: None,
+        force_id_only: true,
+    };
+
+    let router = state.router.current();
+    match tokio::time::timeout(ID_CONSULT_TIMEOUT, router.route_unified(request)).await {
+        Ok(Ok(resp)) => {
+            let text = resp.completion.content.trim().to_string();
+            if text.is_empty() {
+                (None, "empty")
+            } else {
+                let signal: String = text.chars().take(ID_SIGNAL_MAX_CHARS).collect();
+                (Some(signal), "success")
+            }
+        }
+        Ok(Err(e)) => {
+            tracing::warn!("Id consult failed (continuing degraded): {}", e);
+            (None, "error")
+        }
+        Err(_) => {
+            tracing::warn!(
+                "Id consult timed out after {:?} (continuing degraded)",
+                ID_CONSULT_TIMEOUT
+            );
+            (None, "timeout")
+        }
+    }
+}
diff --git a/crates/entity-daemon/src/pipeline/journal.rs b/crates/entity-daemon/src/pipeline/journal.rs
new file mode 100644
index 00000000..6dd401dc
--- /dev/null
+++ b/crates/entity-daemon/src/pipeline/journal.rs
@@ -0,0 +1,114 @@
+//! Journal: persists committed Ego actions and emits lifecycle events.
+//!
+//! Subscribes to `Topic::EgoAction` and handles the bookkeeping that used to
+//! live inline in the chat handlers: archiving the assistant turn to memory,
+//! queueing the outbox record for hive sync, triggering auto-archive, and
+//! publishing chat lifecycle events.
+
+use super::EgoActionPayload;
+use crate::state::EntityDaemonState;
+use abigail_streaming::{Envelope, SubscriptionHandle, Topic, TopicConfig, BUS_STREAM};
+
+const CONSUMER_GROUP: &str = "journal";
+
+pub async fn spawn(state: EntityDaemonState) -> anyhow::Result<SubscriptionHandle> {
+    let broker = state.stream_broker.clone();
+    broker
+        .ensure_topic(
+            BUS_STREAM,
+            Topic::EgoAction.as_str(),
+            TopicConfig::default(),
+        )
+        .await?;
+    broker
+        .ensure_consumer_group(BUS_STREAM, Topic::EgoAction.as_str(), CONSUMER_GROUP)
+        .await?;
+
+    let handler: abigail_streaming::broker::MessageHandler = Box::new(move |msg| {
+        let state = state.clone();
+        Box::pin(async move {
+            let Ok(envelope) = Envelope::from_message(&msg) else {
+                return;
+            };
+            let Ok(action) = serde_json::from_value::<EgoActionPayload>(envelope.payload.clone())
+            else {
+                tracing::warn!("Journal: malformed EgoAction payload");
+                return;
+            };
+            record(state, action).await;
+        })
+    });
+
+    let handle = broker
+        .subscribe(
+            BUS_STREAM,
+            Topic::EgoAction.as_str(),
+            CONSUMER_GROUP,
+            handler,
+        )
+        .await?;
+    tracing::info!("Journal subscribed to {}/{}", BUS_STREAM, Topic::EgoAction);
+    Ok(handle)
+}
+
+async fn record(state: EntityDaemonState, action: EgoActionPayload) {
+    match (action.status.as_str(), action.response) {
+        ("success", Some(response)) => {
+            // Archive the assistant turn (async, fire-and-forget via broker).
+            let asst_turn = abigail_memory::ConversationTurn::new(
+                &action.session_id,
+                "assistant",
+                &response.reply,
+            )
+            .with_metadata(
+                response.provider.clone(),
+                response.model_used.clone(),
+                response.tier.clone(),
+                response.complexity_score,
+            );
+            crate::memory_consumer::publish_turn(state.stream_broker.clone(), asst_turn);
+
+            let _ = state.queue_outbox_record(
+                "chat_assistant_turn",
+                serde_json::json!({
+                    "session_id": action.session_id.clone(),
+                    "reply": response.reply.clone(),
+                    "provider": response.provider.clone(),
+                    "model_used": response.model_used.clone(),
+                }),
+            );
+
+            state.maybe_auto_archive();
+
+            crate::routes::publish_chat_lifecycle_event(
+                state.stream_broker.clone(),
+                action.session_id.clone(),
+                state.entity_id.clone(),
+                "chat_completed",
+                serde_json::json!({
+                    "provider": response.provider,
+                    "model_used": response.model_used,
+                    "tool_calls": response.tool_calls_made.len(),
+                    "tool_summary": response.tool_calls_made.iter().map(|record| {
+                        serde_json::json!({
+                            "skill_id": record.skill_id,
+                            "tool_name": record.tool_name,
+                            "success": record.success,
+                        })
+                    }).collect::<Vec<_>>(),
+                }),
+            );
+        }
+        _ => {
+            crate::routes::publish_chat_lifecycle_event(
+                state.stream_broker.clone(),
+                action.session_id.clone(),
+                state.entity_id.clone(),
+                "chat_failed",
+                serde_json::json!({
+                    "error": action.error.unwrap_or_else(|| "unknown".to_string()),
+                }),
+            );
+        }
+    }
+}
diff --git a/crates/entity-daemon/src/pipeline/mod.rs b/crates/entity-daemon/src/pipeline/mod.rs
new file mode 100644
index 00000000..315eae09
--- /dev/null
+++ b/crates/entity-daemon/src/pipeline/mod.rs
@@ -0,0 +1,556 @@
+//! Bicameral chat pipeline: staged Id → Ego flow over the entity bus.
+//!
+//! Chat handlers publish a `Topic::MentorInput` envelope and await the
+//! turn's outcome. The Id stage curates the system prompt (soul documents,
+//! enrichment, optional local-LLM personality consult) and publishes
+//! `Topic::IdReaction`. The Ego stage consumes the reaction, runs the
+//! provider call / tool loop, and publishes `Topic::EgoAction` plus an
+//! `Topic::EgoDeliberation` trace. The journal subscriber persists the
+//! exchange and emits lifecycle events.
+//!
+//! Per-turn runtime channels (streaming senders, cancellation, response
+//! oneshots) cannot ride the bus; they live in [`TurnRegistry`] keyed by
+//! correlation id.
+
+pub mod ego_stage;
+pub mod governance;
+pub mod id_stage;
+pub mod journal;
+pub mod stream_gate;
+pub mod superego_stage;
+
+use entity_core::{ChatResponse, SessionMessage};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::Mutex;
+use tokio::sync::{mpsc, oneshot};
+use tokio_util::sync::CancellationToken;
+
+/// How long a chat turn may take end-to-end before the handler gives up.
+/// CLI providers can be slow, so this is generous.
+pub const CHAT_TURN_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(600);
+
+/// Outcome delivered back to the waiting HTTP handler.
+pub type TurnOutcome = Result<ChatResponse, String>;
+
+/// Per-turn runtime context that cannot be serialized onto the bus.
+pub struct TurnContext {
+    /// Client-provided conversation history for this turn.
+    pub session_messages: Option<Vec<SessionMessage>>,
+    /// Token sink for streaming turns (None = non-streaming).
+    pub stream_tx: Option<mpsc::Sender<abigail_capabilities::cognitive::StreamEvent>>,
+    /// Cancellation for streaming turns (fired by POST /v1/chat/cancel).
+    pub cancel: Option<CancellationToken>,
+    /// Completion channel back to the HTTP handler.
+    pub done: oneshot::Sender<TurnOutcome>,
+}
+
+/// Registry of in-flight chat turns, keyed by correlation id.
+#[derive(Default)]
+pub struct TurnRegistry {
+    turns: Mutex<HashMap<String, TurnContext>>,
+}
+
+impl TurnRegistry {
+    pub fn register(&self, correlation_id: impl Into<String>, ctx: TurnContext) {
+        if let Ok(mut turns) = self.turns.lock() {
+            turns.insert(correlation_id.into(), ctx);
+        }
+    }
+
+    /// Remove and return the turn context. The Ego stage takes ownership;
+    /// a handler that times out also takes it to drop the turn.
+    pub fn take(&self, correlation_id: &str) -> Option<TurnContext> {
+        self.turns
+            .lock()
+            .ok()
+            .and_then(|mut turns| turns.remove(correlation_id))
+    }
+}
+
+/// Payload published on `Topic::IdReaction` by the Id stage.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IdReactionPayload {
+    pub session_id: String,
+    pub message: String,
+    #[serde(default)]
+    pub model_override: Option<String>,
+    /// Fully synthesized system prompt for the Ego stage.
+    pub system_prompt: String,
+    /// Personality signal from the local Id consult (None if skipped/degraded).
+    #[serde(default)]
+    pub id_signal: Option<String>,
+    /// Outcome of the Id consult: "success", "skipped", "timeout", "error", "empty".
+    pub id_consult: String,
+    /// Keyword-inferred id context (mirrors mentor monitor enrichment).
+    pub id_context: String,
+    /// Keyword-inferred superego context (mirrors mentor monitor enrichment).
+    pub superego_context: String,
+}
+
+/// Payload published on `Topic::EgoAction` by the Ego stage.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EgoActionPayload {
+    pub session_id: String,
+    /// "success", "blocked", or "error".
+    pub status: String,
+    #[serde(default)]
+    pub error: Option<String>,
+    #[serde(default)]
+    pub response: Option<ChatResponse>,
+    /// The mentor message this action answers (for superego judgment).
+    #[serde(default)]
+    pub user_message: String,
+    /// Pre-delivery gate verdict: "clear", "flag", or "block".
+    #[serde(default)]
+    pub superego_verdict: Option<String>,
+    /// Rules behind a flag/block verdict (e.g. "secret-leak").
+    #[serde(default)]
+    pub superego_findings: Vec<String>,
+}
+
+/// Spawn all pipeline subscribers. Handles are returned so callers can keep
+/// them alive for the daemon's lifetime.
+pub async fn spawn(
+    state: crate::state::EntityDaemonState,
+) -> anyhow::Result<Vec<abigail_streaming::SubscriptionHandle>> {
+    let id_handle = id_stage::spawn(state.clone()).await?;
+    let ego_handle = ego_stage::spawn(state.clone()).await?;
+    let journal_handle = journal::spawn(state.clone()).await?;
+    let governance_handle = governance::spawn(state.clone()).await?;
+    let mut handles = vec![id_handle, ego_handle, journal_handle, governance_handle];
+    handles.extend(superego_stage::spawn(state).await?);
+    Ok(handles)
+}
+
+/// Register the turn context and publish the `Topic::MentorInput` request
+/// that starts the pipeline. Returns the turn's correlation id.
+///
+/// On publish failure the context is taken back out of the registry so the
+/// handler fails fast instead of waiting out the turn timeout.
+pub async fn begin_turn(
+    state: &crate::state::EntityDaemonState,
+    session_id: &str,
+    message: &str,
+    model_override: Option<String>,
+    ctx: TurnContext,
+) -> anyhow::Result<String> {
+    use abigail_streaming::{StreamMessage, Topic, TopicConfig, BUS_STREAM};
+
+    let correlation_id = uuid::Uuid::new_v4().to_string();
+    state.turns.register(correlation_id.clone(), ctx);
+
+    let envelope = abigail_router::MentorChatEnvelope::request(
+        correlation_id.clone(),
+        session_id.to_string(),
+        state.entity_id.clone(),
+        message.to_string(),
+        model_override,
+    );
+
+    let publish_result: anyhow::Result<()> = async {
+        let payload = serde_json::to_vec(&envelope)?;
+        let mut headers = HashMap::new();
+        headers.insert("stage".to_string(), "request".to_string());
+        headers.insert("correlation_id".to_string(), correlation_id.clone());
+        headers.insert("entity_id".to_string(), state.entity_id.clone());
+        state
+            .stream_broker
+            .ensure_topic(
+                BUS_STREAM,
+                Topic::MentorInput.as_str(),
+                TopicConfig::default(),
+            )
+            .await?;
+        state
+            .stream_broker
+            .publish(
+                BUS_STREAM,
+                Topic::MentorInput.as_str(),
+                StreamMessage::with_headers(payload, headers),
+            )
+            .await
+    }
+    .await;
+
+    if let Err(e) = publish_result {
+        let _ = state.turns.take(&correlation_id);
+        return Err(e);
+    }
+    Ok(correlation_id)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::state::EntityDaemonState;
+    use abigail_capabilities::cognitive::{
+        CompletionRequest, CompletionResponse, LlmProvider, StreamEvent,
+    };
+    use abigail_core::{AppConfig, RoutingMode};
+    use abigail_memory::MemoryStore;
+    use abigail_persistence::{EntityScope, PersistenceHandle};
+    use abigail_router::IdEgoRouter;
+    use abigail_skills::{InstructionRegistry, SkillExecutor, SkillRegistry};
+    use abigail_streaming::MemoryBroker;
+    use async_trait::async_trait;
+    use std::sync::Arc;
+
+    struct MockProvider {
+        reply: &'static str,
+    }
+
+    #[async_trait]
+    impl LlmProvider for MockProvider {
+        async fn complete(
+            &self,
+            _request: &CompletionRequest,
+        ) -> anyhow::Result<CompletionResponse> {
+            Ok(CompletionResponse {
+                content: self.reply.to_string(),
+                tool_calls: None,
+            })
+        }
+    }
+
+    /// Streams its reply in small chunks so streaming-path tests exercise a
+    /// genuinely incremental token flow instead of one monolithic token.
+    struct ChunkedStreamProvider {
+        reply: &'static str,
+    }
+
+    #[async_trait]
+    impl LlmProvider for ChunkedStreamProvider {
+        async fn complete(
+            &self,
+            _request: &CompletionRequest,
+        ) -> anyhow::Result<CompletionResponse> {
+            Ok(CompletionResponse {
+                content: self.reply.to_string(),
+                tool_calls: None,
+            })
+        }
+
+        async fn stream(
+            &self,
+            _request: &CompletionRequest,
+            tx: tokio::sync::mpsc::Sender<StreamEvent>,
+        ) -> anyhow::Result<CompletionResponse> {
+            for chunk in self.reply.as_bytes().chunks(8) {
+                let token = std::str::from_utf8(chunk).expect("ascii test reply");
+                let _ = tx.send(StreamEvent::Token(token.to_string())).await;
+            }
+            let response = CompletionResponse {
+                content: self.reply.to_string(),
+                tool_calls: None,
+            };
+            let _ = tx.send(StreamEvent::Done(response.clone())).await;
+            Ok(response)
+        }
+    }
+
+    fn build_state() -> EntityDaemonState {
+        build_state_with_reply("pipeline says hello")
+    }
+
+    fn build_state_with_reply(reply: &'static str) -> EntityDaemonState {
+        build_state_with_provider(Arc::new(MockProvider { reply }))
+    }
+
+    fn build_state_with_provider(provider: Arc<dyn LlmProvider>) -> EntityDaemonState {
+        let mut router = IdEgoRouter::new(None, None, None, None, RoutingMode::EgoPrimary);
+        router.id = provider;
+
+        let registry = Arc::new(SkillRegistry::new());
+        let executor = Arc::new(SkillExecutor::new(registry.clone()));
+        let memory = Arc::new(MemoryStore::open_in_memory().unwrap());
+        let docs_dir =
+            std::env::temp_dir().join(format!("abigail_pipeline_{}", uuid::Uuid::new_v4()));
+        let _ = std::fs::create_dir_all(&docs_dir);
+        let stream_broker: Arc<dyn abigail_streaming::StreamBroker> =
+            Arc::new(MemoryBroker::new(128));
+        let queue_store = PersistenceHandle::open_ephemeral(EntityScope::Hive).unwrap();
+        let job_queue = Arc::new(abigail_queue::JobQueue::new(
+            queue_store,
+            stream_broker.clone(),
+        ));
+
+        EntityDaemonState {
+            entity_id: "pipeline-entity".to_string(),
+            config: AppConfig::default_paths(),
+            hive_url: "http://127.0.0.1:3141".to_string(),
+            runtime_id: "runtime-pipeline".to_string(),
+            session_lease: hive_core::RuntimeSessionLease {
+                lease_id: "lease-pipeline".to_string(),
+                entity_id: "pipeline-entity".to_string(),
+                runtime_id: "runtime-pipeline".to_string(),
+                entity_name: Some("Pipeline Entity".to_string()),
+                hive_url: Some("http://127.0.0.1:3141".to_string()),
+                issued_at_utc: chrono::Utc::now().to_rfc3339(),
+                expires_at_utc: None,
+                offline_until_close: true,
+                lease_scope: "entity-runtime-session".to_string(),
+            },
+            router: Arc::new(crate::state::RouterHandle::new(Arc::new(router))),
+            registry,
+            executor,
+            docs_dir: docs_dir.clone(),
+            memory,
+            job_queue,
+            stream_broker,
+            memory_hook: None,
+            instruction_registry: Arc::new(InstructionRegistry::empty()),
+            archive_exporter: None,
+            turns_since_archive: Arc::new(std::sync::atomic::AtomicU32::new(0)),
+            active_stream_cancel: Arc::new(tokio::sync::Mutex::new(None)),
+            constraints: Arc::new(tokio::sync::RwLock::new(
+                abigail_router::ConstraintStore::new(),
+            )),
+            outbox: Arc::new(
+                crate::outbox::RuntimeOutbox::load(docs_dir.join("outbox"), 64).expect("outbox"),
+            ),
+            last_hive_sync_at_utc: Arc::new(tokio::sync::RwLock::new(None)),
+            last_hive_error: Arc::new(tokio::sync::RwLock::new(None)),
+            runtime_url: Arc::new(tokio::sync::RwLock::new(None)),
+            skill_assignments: Arc::new(tokio::sync::RwLock::new(Vec::new())),
+            forge_jobs: Arc::new(tokio::sync::RwLock::new(Vec::new())),
+            recent_skill_acks: Arc::new(tokio::sync::RwLock::new(Vec::new())),
+            turns: Arc::new(TurnRegistry::default()),
+            soul_ref: abigail_streaming::compute_soul_ref(b"pipeline-test-soul"),
+        }
+    }
+
+    #[tokio::test]
+    async fn chat_turn_flows_through_id_and_ego_stages() {
+        let state = build_state();
+        let _handles = spawn(state.clone()).await.expect("pipeline spawn");
+
+        let (done_tx, done_rx) = tokio::sync::oneshot::channel();
+        let ctx = TurnContext {
+            session_messages: None,
+            stream_tx: None,
+            cancel: None,
+            done: done_tx,
+        };
+        let correlation_id = begin_turn(&state, "session-1", "hello there", None, ctx)
+            .await
+            .expect("begin turn");
+        assert!(!correlation_id.is_empty());
+
+        let outcome = tokio::time::timeout(std::time::Duration::from_secs(10), done_rx)
+            .await
+            .expect("turn should complete before timeout")
+            .expect("ego stage should deliver an outcome");
+        let response = outcome.expect("turn should succeed");
+        assert_eq!(response.reply, "pipeline says hello");
+        assert_eq!(response.session_id.as_deref(), Some("session-1"));
+        // The turn context must be consumed by the ego stage.
+        assert!(state.turns.take(&correlation_id).is_none());
+
+        // The turn must leave a health-board entry.
+        let health = state.router.current().health_board();
+        assert!(!health.is_empty(), "health board should record the call");
+        assert_eq!(health[0].state, "healthy");
+    }
+
+    #[tokio::test]
+    async fn governance_provider_refresh_hot_swaps_router() {
+        let state = build_state();
+        let _handles = spawn(state.clone()).await.expect("pipeline spawn");
+        let original = state.router.current();
+
+        let envelope = abigail_streaming::Envelope::new(
+            abigail_streaming::Topic::GovernanceInbound,
+            "pipeline-entity",
+            "gov-router-1",
+            serde_json::json!({
+                "kind": governance::KIND_PROVIDER_REFRESH,
+                "provider_config": {
+                    "local_llm_base_url": null,
+                    "ego_provider_name": null,
+                    "ego_api_key": null,
+                    "ego_model": null,
+                    "routing_mode": "EgoPrimary",
+                    "cli_permission_mode": null,
+                },
+            }),
+        );
+        envelope
+            .publish(state.stream_broker.as_ref())
+            .await
+            .expect("publish provider refresh");
+
+        let swapped = tokio::time::timeout(std::time::Duration::from_secs(5), async {
+            loop {
+                if !Arc::ptr_eq(&original, &state.router.current()) {
+                    break;
+                }
+                tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+            }
+        })
+        .await
+        .is_ok();
+        assert!(swapped, "router should be hot-swapped by provider refresh");
+    }
+
+    #[tokio::test]
+    async fn superego_gate_blocks_secret_leaking_reply() {
+        let state = build_state_with_reply(
+            "here is the key: sk-ant-api03-abcdefghijklmnopqrstuvwxyz0123456789",
+        );
+        let _handles = spawn(state.clone()).await.expect("pipeline spawn");
+
+        let (done_tx, done_rx) = tokio::sync::oneshot::channel();
+        let ctx = TurnContext {
+            session_messages: None,
+            stream_tx: None,
+            cancel: None,
+            done: done_tx,
+        };
+        begin_turn(&state, "session-gate", "what is my api key?", None, ctx)
+            .await
+            .expect("begin turn");
+
+        let outcome = tokio::time::timeout(std::time::Duration::from_secs(10), done_rx)
+            .await
+            .expect("turn should complete before timeout")
+            .expect("ego stage should deliver an outcome");
+        let err = outcome.expect_err("secret-leaking reply must be withheld");
+        assert!(err.contains("withheld"), "unexpected error: {err}");
+        assert!(err.contains("secret-leak"), "unexpected error: {err}");
+    }
+
+    #[tokio::test]
+    async fn superego_gate_cuts_streaming_turn_before_secret_reaches_client() {
+        const REPLY: &str = "Of course! Let me walk through where your credentials live so you \
+            can find them again whenever you need to. The one you asked about is \
+            sk-ant-api03-abcdefghijklmnopqrstuvwxyz0123456789 so please keep it safe.";
+        let state = build_state_with_provider(Arc::new(ChunkedStreamProvider { reply: REPLY }));
+        let _handles = spawn(state.clone()).await.expect("pipeline spawn");
+
+        // Stand in for the SSE forwarder: collect every token that makes it
+        // through the gate until the channel closes.
+        let (token_tx, mut token_rx) = tokio::sync::mpsc::channel(64);
+        let collector = tokio::spawn(async move {
+            let mut text = String::new();
+            while let Some(event) = token_rx.recv().await {
+                if let StreamEvent::Token(token) = event {
+                    text.push_str(&token);
+                }
+            }
+            text
+        });
+
+        let (done_tx, done_rx) = tokio::sync::oneshot::channel();
+        let ctx = TurnContext {
+            session_messages: None,
+            stream_tx: Some(token_tx),
+            cancel: None,
+            done: done_tx,
+        };
+        begin_turn(
+            &state,
+            "session-stream-gate",
+            "what is my api key?",
+            None,
+            ctx,
+        )
+        .await
+        .expect("begin turn");
+
+        let outcome = tokio::time::timeout(std::time::Duration::from_secs(10), done_rx)
+            .await
+            .expect("turn should complete before timeout")
+            .expect("ego stage should deliver an outcome");
+        let err = outcome.expect_err("secret-leaking reply must be withheld");
+        assert!(err.contains("withheld"), "unexpected error: {err}");
+        assert!(err.contains("secret-leak"), "unexpected error: {err}");
+
+        let streamed = tokio::time::timeout(std::time::Duration::from_secs(5), collector)
+            .await
+            .expect("token channel should close after the cut")
+            .expect("collector task should not panic");
+        assert!(
+            !streamed.is_empty(),
+            "clean preamble should stream before the cut"
+        );
+        assert!(
+            REPLY.starts_with(&streamed),
+            "streamed text must be a prefix of the reply: {streamed:?}"
+        );
+        let secret_start = REPLY.find("sk-ant").expect("reply embeds the secret");
+        assert!(
+            streamed.len() <= secret_start,
+            "stream leaked into the secret region: {streamed:?}"
+        );
+    }
+
+    #[tokio::test]
+    async fn governance_refresh_applies_skill_assignments_live() {
+        let state = build_state();
+        let _handles = spawn(state.clone()).await.expect("pipeline spawn");
+
+        let assignments = vec![hive_core::SkillAssignment {
+            assignment_id: "assign-1".to_string(),
+            entity_id: "pipeline-entity".to_string(),
+            skill_id: "com.abigail.skills.browser".to_string(),
+            version: None,
+            manifest_path: None,
+            assigned_at_utc: chrono::Utc::now().to_rfc3339(),
+            status: "active".to_string(),
+        }];
+        let envelope = abigail_streaming::Envelope::new(
+            abigail_streaming::Topic::GovernanceInbound,
+            "pipeline-entity",
+            "gov-1",
+            serde_json::json!({
+                "kind": governance::KIND_SKILL_ASSIGNMENTS_REFRESH,
+                "assignments": assignments,
+            }),
+        );
+        envelope
+            .publish(state.stream_broker.as_ref())
+            .await
+            .expect("publish governance refresh");
+
+        // Wait for the subscriber to apply the refresh.
+        let applied = tokio::time::timeout(std::time::Duration::from_secs(5), async {
+            loop {
+                if state.skill_assignments.read().await.len() == 1 {
+                    break;
+                }
+                tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+            }
+        })
+        .await
+        .is_ok();
+        assert!(applied, "assignments should be applied live");
+        assert_eq!(
+            state.skill_assignments.read().await[0].skill_id,
+            "com.abigail.skills.browser"
+        );
+        let acks = state.recent_skill_acks.read().await;
+        assert!(acks
+            .iter()
+            .any(|a| a.skill_id == "com.abigail.skills.browser"
+                && a.status == "assignment_refreshed"));
+    }
+
+    #[tokio::test]
+    async fn timed_out_turn_can_be_reclaimed() {
+        let state = build_state();
+        // No pipeline spawned: the turn is never consumed.
+        let (done_tx, _done_rx) = tokio::sync::oneshot::channel();
+        let ctx = TurnContext {
+            session_messages: None,
+            stream_tx: None,
+            cancel: None,
+            done: done_tx,
+        };
+        let correlation_id = begin_turn(&state, "session-2", "hello", None, ctx)
+            .await
+            .expect("begin turn");
+        assert!(state.turns.take(&correlation_id).is_some());
+        assert!(state.turns.take(&correlation_id).is_none());
+    }
+}
diff --git a/crates/entity-daemon/src/pipeline/stream_gate.rs b/crates/entity-daemon/src/pipeline/stream_gate.rs
new file mode 100644
index 00000000..08e23550
--- /dev/null
+++ b/crates/entity-daemon/src/pipeline/stream_gate.rs
@@ -0,0 +1,246 @@
+//! Incremental superego gating for streaming chat turns.
+//!
+//! The non-streaming path evaluates the full reply before anything leaves the
+//! daemon, but on the streaming path tokens are forwarded to the SSE client
+//! live. The gate therefore has to run *inside* the stream: this relay sits
+//! between the provider pipeline and the token forwarder, re-evaluates the
+//! accumulating reply after every token, and permanently cuts the stream the
+//! moment a blocking finding appears.
+//!
+//! Pattern detection only fires once enough of a secret has accumulated to
+//! match — the longest minimum today is a Google API key at 39 bytes
+//! (`AIza` + 35), an SSN needs 11 — so a pure cut-on-detect would still leak
+//! the secret's opening bytes. To close that window the relay holds back the
+//! trailing [`HOLDBACK_BYTES`] of content and only flushes the tail once the
+//! stream completes clean.
+
+use abigail_capabilities::cognitive::StreamEvent;
+use tokio::sync::mpsc;
+
+/// Bytes of accumulated content withheld from the client until the stream
+/// ends clean. Must exceed the longest content prefix a blockable pattern can
+/// reach before detection fires (38 bytes today: one short of the 39-byte
+/// Google key minimum).
+pub const HOLDBACK_BYTES: usize = 64;
+
+/// Wrap `downstream` in an incrementally gated relay and return the sender to
+/// hand to the provider pipeline.
+///
+/// The spawned task forwards tokens with a held-back tail. On the first
+/// blocking superego finding it drops `downstream` — so the client-facing
+/// channel closes with no further tokens — and silently drains the rest of
+/// the stream so the provider never stalls on a full channel. The Ego stage's
+/// final full-content gate remains the authoritative verdict for the
+/// committed action; this relay only guarantees blocked content never reaches
+/// the client mid-stream.
+pub fn spawn_gated_relay(downstream: mpsc::Sender<StreamEvent>) -> mpsc::Sender<StreamEvent> {
+    let (upstream_tx, mut upstream_rx) = mpsc::channel::<StreamEvent>(64);
+    tokio::spawn(async move {
+        let mut downstream = Some(downstream);
+        let mut acc = String::new();
+        let mut forwarded = 0usize;
+        while let Some(event) = upstream_rx.recv().await {
+            if downstream.is_none() {
+                continue;
+            }
+            match event {
+                StreamEvent::Token(token) => {
+                    acc.push_str(&token);
+                    if is_blocked(&acc) {
+                        downstream = None;
+                        continue;
+                    }
+                    let safe_end =
+                        floor_char_boundary(&acc, acc.len().saturating_sub(HOLDBACK_BYTES));
+                    if safe_end > forwarded {
+                        let chunk = acc[forwarded..safe_end].to_string();
+                        forwarded = safe_end;
+                        if let Some(out) = downstream.as_ref() {
+                            let _ = out.send(StreamEvent::Token(chunk)).await;
+                        }
+                    }
+                }
+                StreamEvent::Done(response) => {
+                    // The assembled response may differ from the token
+                    // accumulation (providers own the assembly), so gate it
+                    // independently before letting the completion through.
+                    if is_blocked(&response.content) {
+                        downstream = None;
+                        continue;
+                    }
+                    if let Some(out) = downstream.as_ref() {
+                        flush_tail(out, &acc, &mut forwarded).await;
+                        let _ = out.send(StreamEvent::Done(response)).await;
+                    }
+                }
+            }
+        }
+        if let Some(out) = downstream {
+            flush_tail(&out, &acc, &mut forwarded).await;
+        }
+    });
+    upstream_tx
+}
+
+fn is_blocked(content: &str) -> bool {
+    matches!(
+        abigail_superego::evaluate(content, abigail_superego::EvaluationContext::ChatReply),
+        abigail_superego::GateDecision::Block(_)
+    )
+}
+
+async fn flush_tail(out: &mpsc::Sender<StreamEvent>, acc: &str, forwarded: &mut usize) {
+    if acc.len() > *forwarded {
+        let tail = acc[*forwarded..].to_string();
+        *forwarded = acc.len();
+        let _ = out.send(StreamEvent::Token(tail)).await;
+    }
+}
+
+fn floor_char_boundary(s: &str, mut idx: usize) -> usize {
+    while idx > 0 && !s.is_char_boundary(idx) {
+        idx -= 1;
+    }
+    idx
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use abigail_capabilities::cognitive::CompletionResponse;
+
+    /// Drive the relay with `tokens`, optionally a trailing `Done`, then close
+    /// upstream and collect everything that reached the downstream side.
+    async fn run_relay(tokens: &[&str], done: Option<&str>) -> (String, usize) {
+        let (down_tx, mut down_rx) = mpsc::channel::<StreamEvent>(256);
+        let up_tx = spawn_gated_relay(down_tx);
+        for token in tokens {
+            up_tx
+                .send(StreamEvent::Token(token.to_string()))
+                .await
+                .expect("relay should accept tokens");
+        }
+        if let Some(content) = done {
+            up_tx
+                .send(StreamEvent::Done(CompletionResponse {
+                    content: content.to_string(),
+                    tool_calls: None,
+                }))
+                .await
+                .expect("relay should accept done");
+        }
+        drop(up_tx);
+        let mut text = String::new();
+        let mut done_events = 0usize;
+        while let Some(event) = down_rx.recv().await {
+            match event {
+                StreamEvent::Token(t) => text.push_str(&t),
+                StreamEvent::Done(_) => done_events += 1,
+            }
+        }
+        (text, done_events)
+    }
+
+    fn char_tokens(s: &str) -> Vec<String> {
+        s.chars().map(|c| c.to_string()).collect()
+    }
+
+    #[tokio::test]
+    async fn clean_stream_is_forwarded_completely() {
+        let full = "The weather looks lovely today, perfect for the park with the kids \
+                    and maybe a picnic by the pond afterwards.";
+        let tokens: Vec<&str> = full.split_inclusive(' ').collect();
+        let (text, done_events) = run_relay(&tokens, Some(full)).await;
+        assert_eq!(text, full);
+        assert_eq!(done_events, 1);
+    }
+
+    #[tokio::test]
+    async fn short_clean_stream_tail_is_flushed_on_close() {
+        let (text, _) = run_relay(&["hi ", "there"], None).await;
+        assert_eq!(text, "hi there");
+    }
+
+    #[tokio::test]
+    async fn multibyte_content_never_splits_a_char() {
+        let full = "héllo wörld 👋 ".repeat(12);
+        let tokens: Vec<&str> = full.split_inclusive(' ').collect();
+        let (text, _) = run_relay(&tokens, None).await;
+        assert_eq!(text, full);
+    }
+
+    #[tokio::test]
+    async fn secret_split_across_tokens_never_reaches_downstream() {
+        let preamble = "Here is a sufficiently long preamble so that plenty of clean tokens \
+                        flow to the client before anything sensitive shows up in the reply. ";
+        let full =
+            format!("{preamble}sk-ant-api03-abcdefghijklmnopqrstuvwxyz0123456789 - keep it safe!");
+        let tokens: Vec<String> = full
+            .as_bytes()
+            .chunks(3)
+            .map(|c| String::from_utf8(c.to_vec()).unwrap())
+            .collect();
+        let token_refs: Vec<&str> = tokens.iter().map(String::as_str).collect();
+        let (text, done_events) = run_relay(&token_refs, Some(&full)).await;
+        assert!(
+            !text.is_empty(),
+            "clean preamble should stream before the cut"
+        );
+        assert!(
+            preamble.starts_with(&text),
+            "forwarded text leaked past the preamble: {text:?}"
+        );
+        assert_eq!(
+            done_events, 0,
+            "blocked stream must suppress the done event"
+        );
+    }
+
+    #[tokio::test]
+    async fn worst_case_key_streamed_char_by_char_is_cut_before_it_starts() {
+        // The Google pattern has the longest detection minimum (39 bytes), so
+        // single-char tokens are the hardest case for the hold-back window.
+        let preamble = "Let me read that configuration file back to you slowly, one piece \
+                        at a time, exactly as it appears on disk right now: ";
+        let full = format!("{preamble}AIza{}", "x".repeat(35));
+        let tokens = char_tokens(&full);
+        let token_refs: Vec<&str> = tokens.iter().map(String::as_str).collect();
+        let (text, _) = run_relay(&token_refs, None).await;
+        assert!(
+            !text.is_empty(),
+            "clean preamble should stream before the cut"
+        );
+        assert!(
+            preamble.starts_with(&text),
+            "forwarded text leaked past the preamble: {text:?}"
+        );
+    }
+
+    #[tokio::test]
+    async fn ssn_midstream_is_cut_before_any_digit_escapes() {
+        let preamble = "Of course — I keep the family records handy, so here is the number \
+                        you asked about from the document you saved last week: ";
+        let full = format!("{preamble}123-45-6789.");
+        let tokens = char_tokens(&full);
+        let token_refs: Vec<&str> = tokens.iter().map(String::as_str).collect();
+        let (text, _) = run_relay(&token_refs, None).await;
+        assert!(
+            !text.is_empty(),
+            "clean preamble should stream before the cut"
+        );
+        assert!(
+            preamble.starts_with(&text),
+            "forwarded text leaked past the preamble: {text:?}"
+        );
+    }
+
+    #[tokio::test]
+    async fn blocked_done_payload_is_suppressed_even_after_clean_tokens() {
+        // Tokens are clean but the assembled response carries a secret: the
+        // relay must still gate the Done payload independently.
+        let secret_done =
+            "fine text plus sk-ant-api03-abcdefghijklmnopqrstuvwxyz0123456789".to_string();
+        let (_, done_events) = run_relay(&["fine text"], Some(&secret_done)).await;
+        assert_eq!(done_events, 0);
+    }
+}
diff --git a/crates/entity-daemon/src/pipeline/superego_stage.rs b/crates/entity-daemon/src/pipeline/superego_stage.rs
new file mode 100644
index 00000000..fdeaffc0
--- /dev/null
+++ b/crates/entity-daemon/src/pipeline/superego_stage.rs
@@ -0,0 +1,274 @@
+//! Superego stage: conscience coverage for everything the entity commits.
+//!
+//! Subscribes to `Topic::EgoAction` (chat exchanges), `Topic::JobEvents`
+//! (sub-agent/job output), and `Topic::SkillExecuted` (tool activity), runs
+//! pattern evaluation on each, and publishes verdicts on
+//! `Topic::SuperegoEvaluation` stamped with the entity's soul_ref.
+//!
+//! For chat exchanges it additionally runs an LLM judgment pass against the
+//! entity's constitution on the local Id provider — private and free — when
+//! a local LLM is configured. Judgment is asynchronous and observational; the
+//! synchronous pre-delivery gate lives in the Ego stage.
+
+use super::EgoActionPayload;
+use crate::state::EntityDaemonState;
+use abigail_capabilities::cognitive::Message;
+use abigail_streaming::{Envelope, SubscriptionHandle, Topic, TopicConfig, BUS_STREAM};
+use abigail_superego::EvaluationContext;
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+
+const CONSUMER_GROUP: &str = "superego-stage";
+
+/// Budget for the LLM judgment pass.
+const JUDGMENT_TIMEOUT: Duration = Duration::from_secs(20);
+
+/// Maximum constitution excerpt folded into the judgment prompt.
+const CONSTITUTION_EXCERPT_CHARS: usize = 2000;
+
+/// Payload published on `Topic::SuperegoEvaluation`.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SuperegoEvaluationPayload {
+    /// "pattern" or "llm".
+    pub source: String,
+    /// Evaluation context ("chat_reply", "job_result", "skill_event").
+    pub context: String,
+    /// "clear", "flag", "block", "concern", or "violation".
+    pub verdict: String,
+    #[serde(default)]
+    pub findings: Vec<String>,
+    #[serde(default)]
+    pub reason: Option<String>,
+    #[serde(default)]
+    pub session_id: Option<String>,
+}
+
+pub async fn spawn(state: EntityDaemonState) -> anyhow::Result<Vec<SubscriptionHandle>> {
+    let mut handles = Vec::new();
+    handles.push(spawn_ego_action_judge(state.clone()).await?);
+    handles.push(spawn_content_observer(state.clone(), Topic::JobEvents).await?);
+    handles.push(spawn_content_observer(state, Topic::SkillExecuted).await?);
+    Ok(handles)
+}
+
+/// Chat-exchange judge: pattern verdict + async LLM judgment on EgoAction.
+async fn spawn_ego_action_judge(state: EntityDaemonState) -> anyhow::Result<SubscriptionHandle> {
+    let broker = state.stream_broker.clone();
+    broker
+        .ensure_topic(
+            BUS_STREAM,
+            Topic::EgoAction.as_str(),
+            TopicConfig::default(),
+        )
+        .await?;
+    broker
+        .ensure_consumer_group(BUS_STREAM, Topic::EgoAction.as_str(), CONSUMER_GROUP)
+        .await?;
+
+    let handler: abigail_streaming::broker::MessageHandler = Box::new(move |msg| {
+        let state = state.clone();
+        Box::pin(async move {
+            let Ok(envelope) = Envelope::from_message(&msg) else {
+                return;
+            };
+            let Ok(action) = serde_json::from_value::<EgoActionPayload>(envelope.payload.clone())
+            else {
+                return;
+            };
+            tokio::spawn(async move {
+                judge_exchange(state, envelope.correlation_id, action).await;
+            });
+        })
+    });
+
+    let handle = broker
+        .subscribe(
+            BUS_STREAM,
+            Topic::EgoAction.as_str(),
+            CONSUMER_GROUP,
+            handler,
+        )
+        .await?;
+    tracing::info!(
+        "Superego stage subscribed to {}/{}",
+        BUS_STREAM,
+        Topic::EgoAction
+    );
+    Ok(handle)
+}
+
+async fn judge_exchange(
+    state: EntityDaemonState,
+    correlation_id: String,
+    action: EgoActionPayload,
+) {
+    // 1. Record the Ego stage's own gate verdict (or re-derive for older payloads).
+    let pattern_payload = SuperegoEvaluationPayload {
+        source: "pattern".to_string(),
+        context: EvaluationContext::ChatReply.as_str().to_string(),
+        verdict: action
+            .superego_verdict
+            .clone()
+            .unwrap_or_else(|| "clear".to_string()),
+        findings: action.superego_findings.clone(),
+        reason: None,
+        session_id: Some(action.session_id.clone()),
+    };
+    publish_evaluation(&state, &correlation_id, pattern_payload).await;
+
+    // 2. LLM judgment against the constitution — only for delivered replies,
+    //    only when a local LLM is available.
+    let Some(ref response) = action.response else {
+        return;
+    };
+    if !state.router.current().status().has_local_http {
+        return;
+    }
+
+    let constitution = load_constitution_excerpt(&state);
+    let entity_name = state
+        .config
+        .agent_name
+        .clone()
+        .unwrap_or_else(|| "this entity".to_string());
+    let (system, user) = abigail_superego::build_llm_judgment_prompt(
+        &entity_name,
+        &constitution,
+        &action.user_message,
+        &response.reply,
+    );
+    let request = abigail_router::RoutingRequest {
+        messages: vec![Message::new("system", &system), Message::new("user", &user)],
+        tools: None,
+        model_override: None,
+        stream_tx: None,
+        force_id_only: true,
+    };
+
+    let router = state.router.current();
+    let verdict = match tokio::time::timeout(JUDGMENT_TIMEOUT, router.route_unified(request)).await
+    {
+        Ok(Ok(resp)) => abigail_superego::parse_llm_verdict(&resp.completion.content),
+        Ok(Err(e)) => {
+            tracing::debug!("Superego LLM judgment failed: {}", e);
+            None
+        }
+        Err(_) => {
+            tracing::debug!("Superego LLM judgment timed out");
+            None
+        }
+    };
+
+    if let Some(verdict) = verdict {
+        if verdict.verdict != "clear" {
+            tracing::warn!(
+                "Superego LLM judgment: {} — {} (session {})",
+                verdict.verdict,
+                verdict.reason,
+                action.session_id
+            );
+        }
+        let llm_payload = SuperegoEvaluationPayload {
+            source: "llm".to_string(),
+            context: EvaluationContext::ChatReply.as_str().to_string(),
+            verdict: verdict.verdict,
+            findings: Vec::new(),
+            reason: Some(verdict.reason),
+            session_id: Some(action.session_id),
+        };
+        publish_evaluation(&state, &correlation_id, llm_payload).await;
+    }
+}
+
+/// Generic observer: pattern-evaluate job/skill payloads.
+async fn spawn_content_observer(
+    state: EntityDaemonState,
+    topic: Topic,
+) -> anyhow::Result<SubscriptionHandle> {
+    let broker = state.stream_broker.clone();
+    broker
+        .ensure_topic(BUS_STREAM, topic.as_str(), TopicConfig::default())
+        .await?;
+    broker
+        .ensure_consumer_group(BUS_STREAM, topic.as_str(), CONSUMER_GROUP)
+        .await?;
+
+    let context = match topic {
+        Topic::JobEvents => EvaluationContext::JobResult,
+        _ => EvaluationContext::SkillEvent,
+    };
+
+    let handler: abigail_streaming::broker::MessageHandler = Box::new(move |msg| {
+        let state = state.clone();
+        Box::pin(async move {
+            let content = String::from_utf8_lossy(&msg.payload).to_string();
+            // Chat lifecycle events ride the job topic but are already judged
+            // via EgoAction — skip to avoid double verdicts.
+            if context == EvaluationContext::JobResult && content.contains("\"chat_lifecycle\"") {
+                return;
+            }
+            let decision = abigail_superego::evaluate(&content, context);
+            if matches!(decision, abigail_superego::GateDecision::Allow) {
+                return;
+            }
+            let correlation_id = msg
+                .headers
+                .get("correlation_id")
+                .cloned()
+                .unwrap_or_else(|| msg.id.to_string());
+            let payload = SuperegoEvaluationPayload {
+                source: "pattern".to_string(),
+                context: context.as_str().to_string(),
+                verdict: decision.verdict().to_string(),
+                findings: decision.findings().iter().map(|f| f.rule.clone()).collect(),
+                reason: None,
+                session_id: None,
+            };
+            tracing::warn!(
+                "Superego observed {} concern on {}: {:?}",
+                payload.verdict,
+                payload.context,
+                payload.findings
+            );
+            publish_evaluation(&state, &correlation_id, payload).await;
+        })
+    });
+
+    let handle = broker
+        .subscribe(BUS_STREAM, topic.as_str(), CONSUMER_GROUP, handler)
+        .await?;
+    tracing::info!("Superego stage subscribed to {}/{}", BUS_STREAM, topic);
+    Ok(handle)
+}
+
+async fn publish_evaluation(
+    state: &EntityDaemonState,
+    correlation_id: &str,
+    payload: SuperegoEvaluationPayload,
+) {
+    let payload_json = match serde_json::to_value(&payload) {
+        Ok(v) => v,
+        Err(e) => {
+            tracing::error!("Superego stage: failed to serialize evaluation: {}", e);
+            return;
+        }
+    };
+    let envelope = Envelope::new(
+        Topic::SuperegoEvaluation,
+        state.entity_id.clone(),
+        correlation_id.to_string(),
+        payload_json,
+    )
+    .with_soul_ref(state.soul_ref.clone());
+    if let Err(e) = envelope.publish(state.stream_broker.as_ref()).await {
+        tracing::warn!("Superego stage: failed to publish evaluation: {}", e);
+    }
+}
+
+/// Load the constitution excerpt used for LLM judgment (ethics.md, falling
+/// back to the built-in template).
+fn load_constitution_excerpt(state: &EntityDaemonState) -> String {
+    let text = std::fs::read_to_string(state.docs_dir.join("ethics.md"))
+        .unwrap_or_else(|_| abigail_core::templates::ETHICS_MD.to_string());
+    text.chars().take(CONSTITUTION_EXCERPT_CHARS).collect()
+}
diff --git a/crates/entity-daemon/src/queue_ops.rs b/crates/entity-daemon/src/queue_ops.rs
index b24974e9..6aa1ee91 100644
--- a/crates/entity-daemon/src/queue_ops.rs
+++ b/crates/entity-daemon/src/queue_ops.rs
@@ -53,3 +53,67 @@ impl QueueOperations for LocalQueueOperations {
             .map_err(|e| e.to_string())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use abigail_persistence::{EntityScope, PersistenceHandle};
+    use abigail_skills::{ExecutionContext, QueueManagementSkill, Skill, ToolParams};
+    use abigail_streaming::MemoryBroker;
+
+    fn test_queue() -> Arc<JobQueue> {
+        let store = PersistenceHandle::open_ephemeral(EntityScope::Hive).unwrap();
+        Arc::new(JobQueue::new(store, Arc::new(MemoryBroker::new(64))))
+    }
+
+    fn job_context(depth: u32) -> ExecutionContext {
+        ExecutionContext {
+            request_id: "test".to_string(),
+            job_depth: Some(depth),
+            correlation_id: Some("trace-root".to_string()),
+            ..Default::default()
+        }
+    }
+
+    fn submit_params() -> ToolParams {
+        ToolParams::new()
+            .with("goal", "delegated child task")
+            .with("topic", "depth-test")
+    }
+
+    #[tokio::test]
+    async fn depth_one_job_submits_depth_two_child_with_correlation() {
+        let queue = test_queue();
+        let skill = QueueManagementSkill::new(Arc::new(LocalQueueOperations::new(queue.clone())));
+
+        let out = skill
+            .execute_tool("submit_job", submit_params(), &job_context(1))
+            .await
+            .unwrap();
+        let job_id = out.data.unwrap()["job_id"].as_str().unwrap().to_string();
+
+        let record = queue.get_job(&job_id).unwrap().unwrap();
+        assert_eq!(record.depth, 2);
+        assert_eq!(record.parent_correlation_id.as_deref(), Some("trace-root"));
+    }
+
+    #[tokio::test]
+    async fn depth_two_job_submission_attempt_is_rejected() {
+        let queue = test_queue();
+        let skill = QueueManagementSkill::new(Arc::new(LocalQueueOperations::new(queue.clone())));
+
+        let err = skill
+            .execute_tool("submit_job", submit_params(), &job_context(2))
+            .await
+            .unwrap_err();
+        assert!(
+            err.to_string().contains("nesting limit"),
+            "expected nesting-limit rejection, got: {}",
+            err
+        );
+        assert!(
+            queue.list_jobs(None, 10).unwrap().is_empty(),
+            "rejected submission must not enqueue a job"
+        );
+    }
+}
diff --git a/crates/entity-daemon/src/router_build.rs b/crates/entity-daemon/src/router_build.rs
new file mode 100644
index 00000000..6c7b4d09
--- /dev/null
+++ b/crates/entity-daemon/src/router_build.rs
@@ -0,0 +1,51 @@
+//! Builds an `IdEgoRouter` from a Hive-resolved `ProviderConfig`.
+//!
+//! Shared by daemon startup and the governance hot-swap path so a
+//! hive-initiated provider change produces exactly the same router a
+//! restart would.
+
+use abigail_router::IdEgoRouter;
+use hive_core::ProviderConfig;
+
+pub fn parse_routing_mode(s: &str) -> abigail_core::RoutingMode {
+    match s {
+        "EgoPrimary" | "TierBased" | "IdPrimary" | "Council" => {
+            abigail_core::RoutingMode::EgoPrimary
+        }
+        "CliOrchestrator" => abigail_core::RoutingMode::CliOrchestrator,
+        _ => abigail_core::RoutingMode::default(),
+    }
+}
+
+/// Build providers and a router from the Hive's resolved provider config.
+pub async fn build_router(provider_config: ProviderConfig) -> IdEgoRouter {
+    let cli_permission_mode = provider_config
+        .cli_permission_mode
+        .as_deref()
+        .and_then(|s| {
+            serde_json::from_str::<abigail_core::CliPermissionMode>(&format!("\"{s}\"")).ok()
+        })
+        .unwrap_or_default();
+
+    let ego_api_key = provider_config
+        .ego_api_key
+        .clone()
+        .filter(|key| !key.trim().is_empty());
+    let hive_config = abigail_hive::HiveConfig {
+        local_llm_base_url: provider_config.local_llm_base_url,
+        ego_provider: provider_config.ego_provider_name.map(|provider| {
+            // API-key providers get their key; CLI providers use system auth.
+            let auth = match ego_api_key {
+                Some(key) => abigail_hive::ProviderAuth::ApiKey(key),
+                None => abigail_hive::ProviderAuth::System,
+            };
+            abigail_hive::ProviderSelection { provider, auth }
+        }),
+        ego_model: provider_config.ego_model,
+        routing_mode: parse_routing_mode(&provider_config.routing_mode),
+        cli_permission_mode,
+    };
+
+    let built = abigail_hive::Hive::build_providers(&hive_config).await;
+    IdEgoRouter::from_built_providers(built)
+}
diff --git a/crates/entity-daemon/src/routes.rs b/crates/entity-daemon/src/routes.rs
index b3e96828..3b8743c5 100644
--- a/crates/entity-daemon/src/routes.rs
+++ b/crates/entity-daemon/src/routes.rs
@@ -8,14 +8,54 @@ use axum::response::sse::{Event, KeepAlive, Sse};
 use axum::Json;
 use entity_core::{
     ApiEnvelope, CancelChatStreamResponse, CancelJobResponse, ChatRequest, ChatResponse,
-    EntityStatus, JobStatusResponse, ListJobsResponse, MemoryEntry, MemoryInsertRequest,
-    MemorySearchRequest, MemoryStats, QueueJobRecord, SkillInfo, SubmitJobRequest,
+    EntityOutboxStatus, EntityStatus, JobStatusResponse, ListJobsResponse, MemoryEntry,
+    MemoryInsertRequest, MemorySearchRequest, MemoryStats, QueueJobRecord,
+    RuntimeSessionStatusResponse, SkillApplyAcknowledgementList, SkillInfo, SubmitJobRequest,
     SubmitJobResponse, ToolExecRequest, ToolExecResponse, ToolInfo, TopicResultsResponse,
 };
 use futures_util::{Stream, StreamExt};
 use std::convert::Infallible;
 use tokio_util::sync::CancellationToken;
 
+const BUS_STREAM: &str = abigail_streaming::BUS_STREAM;
+const BUS_TOPIC: &str = abigail_streaming::Topic::JobEvents.as_str();
+
+pub(crate) fn publish_chat_lifecycle_event(
+    broker: std::sync::Arc<dyn abigail_streaming::StreamBroker>,
+    session_id: String,
+    entity_id: String,
+    phase: &str,
+    payload: serde_json::Value,
+) {
+    let phase = phase.to_string();
+    let watch_topic = format!("chat-{}", session_id);
+    tokio::spawn(async move {
+        let _ = broker
+            .ensure_topic(
+                BUS_STREAM,
+                BUS_TOPIC,
+                abigail_streaming::TopicConfig::default(),
+            )
+            .await;
+        let mut msg = abigail_streaming::StreamMessage::new(
+            serde_json::json!({
+                "kind": "chat_lifecycle",
+                "phase": phase,
+                "session_id": session_id,
+                "entity_id": entity_id,
+                "payload": payload,
+                "timestamp_utc": chrono::Utc::now().to_rfc3339(),
+            })
+            .to_string()
+            .into_bytes(),
+        );
+        msg.headers.insert("topic".to_string(), watch_topic);
+        if let Err(e) = broker.publish(BUS_STREAM, BUS_TOPIC, msg).await {
+            tracing::warn!("Failed to publish chat lifecycle event: {}", e);
+        }
+    });
+}
+
 // ---------------------------------------------------------------------------
 // GET /health
 // ---------------------------------------------------------------------------
@@ -29,7 +69,8 @@ pub async fn health() -> &'static str {
 // ---------------------------------------------------------------------------
 
 pub async fn get_status(State(state): State<EntityDaemonState>) -> Json<ApiEnvelope<EntityStatus>> {
-    let router_status = state.router.status();
+    let router = state.router.current();
+    let router_status = router.status();
     let skills_count = state
         .registry
         .list()
@@ -44,9 +85,45 @@ pub async fn get_status(State(state): State<EntityDaemonState>) -> Json<ApiEnvel
         ego_provider: router_status.ego_provider,
         routing_mode: format!("{:?}", router_status.mode),
         skills_count,
+        provider_health: router.health_board(),
+    }))
+}
+
+// ---------------------------------------------------------------------------
+// GET /v1/session/status
+// ---------------------------------------------------------------------------
+
+pub async fn get_session_status(
+    State(state): State<EntityDaemonState>,
+) -> Json<ApiEnvelope<RuntimeSessionStatusResponse>> {
+    let runtime_url = state.runtime_url.read().await.clone();
+    let last_hive_sync_at_utc = state.last_hive_sync_at_utc.read().await.clone();
+    let last_hive_error = state.last_hive_error.read().await.clone();
+    let assignment_count = state.skill_assignments.read().await.len();
+
+    Json(ApiEnvelope::success(RuntimeSessionStatusResponse {
+        lease: state.session_lease.clone(),
+        connected_to_hive: last_hive_error.is_none(),
+        runtime_url,
+        last_hive_sync_at_utc,
+        last_hive_error,
+        assignment_count,
     }))
 }
 
+// ---------------------------------------------------------------------------
+// GET /v1/outbox/status
+// ---------------------------------------------------------------------------
+
+pub async fn get_outbox_status(
+    State(state): State<EntityDaemonState>,
+) -> Json<ApiEnvelope<EntityOutboxStatus>> {
+    match state.outbox.status() {
+        Ok(status) => Json(ApiEnvelope::success(status)),
+        Err(error) => Json(ApiEnvelope::error(error)),
+    }
+}
+
 // ---------------------------------------------------------------------------
 // POST /v1/chat
 // ---------------------------------------------------------------------------
@@ -55,148 +132,69 @@ pub async fn chat(
     State(state): State<EntityDaemonState>,
     Json(body): Json<ChatRequest>,
 ) -> Json<ApiEnvelope<ChatResponse>> {
-    let status = state.router.status();
     let session_id = body
         .session_id
         .clone()
         .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
     let model_override = body.model_override.clone();
+    publish_chat_lifecycle_event(
+        state.stream_broker.clone(),
+        session_id.clone(),
+        state.entity_id.clone(),
+        "chat_started",
+        serde_json::json!({
+            "message_preview": body.message.chars().take(200).collect::<String>(),
+            "model_override": model_override.clone(),
+        }),
+    );
 
     // Register selected model as the entity subscriber identity for mentor chat topic.
     let _subscriber_group = state
         .router
+        .current()
         .register_selected_model_subscriber(&state.entity_id, model_override.clone());
 
-    // Request monitor-enriched preprompt context over the chat topic.
-    let enriched_preprompt = abigail_router::request_enriched_preprompt(
-        state.stream_broker.clone(),
-        state.router.clone(),
-        &state.entity_id,
-        &session_id,
-        &body.message,
-        model_override.clone(),
-    )
-    .await;
-
     // Archive the user turn (async, fire-and-forget via StreamBroker).
     let user_turn = abigail_memory::ConversationTurn::new(&session_id, "user", &body.message);
     crate::memory_consumer::publish_turn(state.stream_broker.clone(), user_turn);
-
-    let system_prompt = if status.mode == abigail_core::RoutingMode::CliOrchestrator {
-        let prompt = entity_chat::build_cli_system_prompt(
-            &state.docs_dir,
-            &state.config.agent_name,
-            &state.registry,
-            &state.instruction_registry,
-            &body.message,
-        );
-        abigail_router::inject_preprompt(&prompt, enriched_preprompt.clone())
-    } else {
-        let base_prompt = abigail_core::system_prompt::build_system_prompt(
-            &state.docs_dir,
-            &state.config.agent_name,
-        );
-        let runtime_ctx = entity_chat::RuntimeContext {
-            provider_name: status.ego_provider.clone(),
-            model_id: None,
-            routing_mode: Some(format!("{:?}", status.mode)),
-            tier: None,
-            complexity_score: None,
-            entity_name: state.config.agent_name.clone(),
-            entity_id: Some(state.entity_id.clone()),
-            has_local_llm: status.has_local_http,
-            last_provider_change_at: None,
-        };
-        let prompt = entity_chat::augment_system_prompt(
-            &base_prompt,
-            &state.registry,
-            &state.instruction_registry,
-            &body.message,
-            &runtime_ctx,
-            entity_chat::PromptMode::Full,
-        );
-        abigail_router::inject_preprompt(&prompt, enriched_preprompt.clone())
-    };
-
-    let budget = entity_chat::ContextBudget::default();
-    let messages = entity_chat::build_contextual_messages_with_memory(
-        &state.memory,
-        &session_id,
-        &system_prompt,
-        body.session_messages,
-        &body.message,
-        &budget,
+    let _ = state.queue_outbox_record(
+        "chat_user_turn",
+        serde_json::json!({
+            "session_id": session_id.clone(),
+            "message": body.message.clone(),
+        }),
     );
 
-    let tools = entity_chat::build_tool_definitions(&state.registry);
-
-    let result = if tools.is_empty() {
-        let resp = state
-            .router
-            .route_unified(abigail_router::RoutingRequest {
-                messages,
-                tools: None,
-                model_override,
-                stream_tx: None,
-                force_id_only: false,
-            })
-            .await;
-        resp.map(|r| entity_chat::ToolUseResult {
-            content: r.completion.content,
-            tool_calls_made: Vec::new(),
-            execution_trace: r.trace,
-        })
-    } else {
-        entity_chat::run_tool_use_loop_with_model_override(
-            &state.router,
-            &state.executor,
-            messages,
-            tools,
-            model_override,
-        )
-        .await
+    // Hand the turn to the Id → Ego pipeline and await the committed action.
+    let (done_tx, done_rx) = tokio::sync::oneshot::channel();
+    let ctx = crate::pipeline::TurnContext {
+        session_messages: body.session_messages,
+        stream_tx: None,
+        cancel: None,
+        done: done_tx,
     };
+    let correlation_id =
+        match crate::pipeline::begin_turn(&state, &session_id, &body.message, model_override, ctx)
+            .await
+        {
+            Ok(id) => id,
+            Err(e) => {
+                return Json(ApiEnvelope::error(format!(
+                    "failed to start chat turn: {e}"
+                )))
+            }
+        };
 
-    match result {
-        Ok(tool_result) => {
-            let tier = tool_result.tier().map(|s| s.to_string());
-            let model_used = tool_result.model_used().map(|s| s.to_string());
-            let complexity_score = tool_result.complexity_score();
-            let provider = tool_result
-                .execution_trace
-                .as_ref()
-                .and_then(|t| t.final_provider())
-                .map(|s| s.to_string())
-                .or_else(|| Some(entity_chat::provider_label(&state.router)));
-
-            // Archive the assistant turn (async, fire-and-forget via StreamBroker).
-            let asst_turn = abigail_memory::ConversationTurn::new(
-                &session_id,
-                "assistant",
-                &tool_result.content,
-            )
-            .with_metadata(
-                provider.clone(),
-                model_used.clone(),
-                tier.clone(),
-                complexity_score,
-            );
-            crate::memory_consumer::publish_turn(state.stream_broker.clone(), asst_turn);
-
-            state.maybe_auto_archive();
-
-            Json(ApiEnvelope::success(ChatResponse {
-                reply: tool_result.content,
-                provider,
-                tool_calls_made: tool_result.tool_calls_made,
-                tier,
-                model_used,
-                complexity_score,
-                execution_trace: tool_result.execution_trace,
-                session_id: Some(session_id),
-            }))
+    match tokio::time::timeout(crate::pipeline::CHAT_TURN_TIMEOUT, done_rx).await {
+        Ok(Ok(Ok(response))) => Json(ApiEnvelope::success(response)),
+        Ok(Ok(Err(e))) => Json(ApiEnvelope::error(e)),
+        Ok(Err(_)) => Json(ApiEnvelope::error(
+            "chat pipeline dropped the turn".to_string(),
+        )),
+        Err(_) => {
+            let _ = state.turns.take(&correlation_id);
+            Json(ApiEnvelope::error("chat turn timed out".to_string()))
         }
-        Err(e) => Json(ApiEnvelope::error(e.to_string())),
     }
 }
 
@@ -213,65 +211,36 @@ pub async fn chat_stream(
         .clone()
         .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
     let model_override = body.model_override.clone();
+    publish_chat_lifecycle_event(
+        state.stream_broker.clone(),
+        session_id.clone(),
+        state.entity_id.clone(),
+        "chat_started",
+        serde_json::json!({
+            "message_preview": body.message.chars().take(200).collect::<String>(),
+            "model_override": model_override.clone(),
+        }),
+    );
 
     // Register selected model as the entity subscriber identity for mentor chat topic.
     let _subscriber_group = state
         .router
+        .current()
         .register_selected_model_subscriber(&state.entity_id, model_override.clone());
 
-    // Request monitor-enriched preprompt context over the chat topic.
-    let enriched_preprompt = abigail_router::request_enriched_preprompt(
-        state.stream_broker.clone(),
-        state.router.clone(),
-        &state.entity_id,
-        &session_id,
-        &body.message,
-        model_override.clone(),
-    )
-    .await;
-
     // Archive user turn (async, fire-and-forget via StreamBroker).
     let user_turn = abigail_memory::ConversationTurn::new(&session_id, "user", &body.message);
     crate::memory_consumer::publish_turn(state.stream_broker.clone(), user_turn);
-
-    let base_prompt =
-        abigail_core::system_prompt::build_system_prompt(&state.docs_dir, &state.config.agent_name);
-    let router_status = state.router.status();
-
-    let runtime_ctx = entity_chat::RuntimeContext {
-        provider_name: router_status.ego_provider.clone(),
-        model_id: None,
-        routing_mode: Some(format!("{:?}", router_status.mode)),
-        tier: None,
-        complexity_score: None,
-        entity_name: state.config.agent_name.clone(),
-        entity_id: Some(state.entity_id.clone()),
-        has_local_llm: router_status.has_local_http,
-        last_provider_change_at: None,
-    };
-
-    let system_prompt = entity_chat::augment_system_prompt(
-        &base_prompt,
-        &state.registry,
-        &state.instruction_registry,
-        &body.message,
-        &runtime_ctx,
-        entity_chat::PromptMode::Full,
+    let _ = state.queue_outbox_record(
+        "chat_user_turn",
+        serde_json::json!({
+            "session_id": session_id.clone(),
+            "message": body.message.clone(),
+        }),
     );
-    let system_prompt = abigail_router::inject_preprompt(&system_prompt, enriched_preprompt);
-
-    let budget = entity_chat::ContextBudget::default();
-    let messages = entity_chat::build_contextual_messages_with_memory(
-        &state.memory,
-        &session_id,
-        &system_prompt,
-        body.session_messages,
-        &body.message,
-        &budget,
-    );
-    let tools = entity_chat::build_tool_definitions(&state.registry);
 
     let (sse_tx, sse_rx) = tokio::sync::mpsc::channel::<Event>(64);
+    let (token_tx, mut token_rx) = tokio::sync::mpsc::channel::<StreamEvent>(64);
 
     // Create cancellation token and store it so POST /v1/chat/cancel can fire it.
     let cancel_token = CancellationToken::new();
@@ -282,19 +251,37 @@ pub async fn chat_stream(
         }
     }
 
-    let router = state.router.clone();
-    let executor = state.executor.clone();
-    let memory = state.memory.clone();
-    let broker_for_stream = state.stream_broker.clone();
-    let archive_exporter = state.archive_exporter.clone();
-    let turns_since_archive = state.turns_since_archive.clone();
+    // Hand the turn to the Id → Ego pipeline; tokens arrive via token_rx.
+    let (done_tx, done_rx) = tokio::sync::oneshot::channel();
+    let ctx = crate::pipeline::TurnContext {
+        session_messages: body.session_messages,
+        stream_tx: Some(token_tx),
+        cancel: Some(cancel_token.clone()),
+        done: done_tx,
+    };
+    let begin =
+        crate::pipeline::begin_turn(&state, &session_id, &body.message, model_override, ctx).await;
+
     let cancel_state = state.active_stream_cancel.clone();
-    let sid = session_id.clone();
+    let turns = state.turns.clone();
     tokio::spawn(async move {
-        let (tx, mut rx) = tokio::sync::mpsc::channel::<StreamEvent>(64);
+        let correlation_id = match begin {
+            Ok(id) => id,
+            Err(e) => {
+                let _ = sse_tx
+                    .send(
+                        Event::default()
+                            .event("error")
+                            .data(format!("failed to start chat turn: {e}")),
+                    )
+                    .await;
+                return;
+            }
+        };
+
         let sse_fwd = sse_tx.clone();
         let fwd_task = tokio::spawn(async move {
-            while let Some(event) = rx.recv().await {
+            while let Some(event) = token_rx.recv().await {
                 if let StreamEvent::Token(token) = event {
                     let _ = sse_fwd
                         .send(Event::default().event("token").data(token))
@@ -303,83 +290,18 @@ pub async fn chat_stream(
             }
         });
 
-        let pipeline_fut = entity_chat::stream_chat_pipeline(
-            &router,
-            &executor,
-            messages,
-            tools,
-            tx,
-            model_override,
-        );
-        tokio::pin!(pipeline_fut);
-
-        let result = tokio::select! {
-            res = &mut pipeline_fut => res,
-            _ = cancel_token.cancelled() => Err(anyhow::anyhow!("Interrupted by user")),
-        };
+        let outcome = tokio::time::timeout(crate::pipeline::CHAT_TURN_TIMEOUT, done_rx).await;
 
-        // Clear the stored token.
+        // Clear the stored cancellation token.
         {
             let mut active = cancel_state.lock().await;
             *active = None;
         }
 
-        let _ = fwd_task.await;
-
-        match result {
-            Ok(pipeline) => {
-                let trace_ref = pipeline.execution_trace.as_ref();
-                let tier = trace_ref
-                    .and_then(|t| t.final_tier())
-                    .map(|s| s.to_string());
-                let model_used = trace_ref
-                    .and_then(|t| t.final_model())
-                    .map(|s| s.to_string());
-                let complexity_score = trace_ref.and_then(|t| t.complexity_score);
-                let provider = trace_ref
-                    .and_then(|t| t.final_provider())
-                    .map(|s| s.to_string())
-                    .or_else(|| Some(entity_chat::provider_label(&router)));
-
-                // Archive assistant turn (async, fire-and-forget via StreamBroker).
-                let asst_turn =
-                    abigail_memory::ConversationTurn::new(&sid, "assistant", &pipeline.content)
-                        .with_metadata(
-                            provider.clone(),
-                            model_used.clone(),
-                            tier.clone(),
-                            complexity_score,
-                        );
-                crate::memory_consumer::publish_turn(broker_for_stream, asst_turn);
-
-                // Trigger auto-archive if threshold reached.
-                {
-                    use std::sync::atomic::Ordering;
-                    let count = turns_since_archive.fetch_add(1, Ordering::Relaxed) + 1;
-                    if count >= crate::state::ARCHIVE_INTERVAL_TURNS {
-                        turns_since_archive.store(0, Ordering::Relaxed);
-                        if let Some(ref exp) = archive_exporter {
-                            let m = memory.clone();
-                            let e = exp.clone();
-                            tokio::spawn(async move {
-                                if let Err(err) = e.export(&m) {
-                                    tracing::warn!("Auto-archive (stream) failed: {}", err);
-                                }
-                            });
-                        }
-                    }
-                }
-
-                let response = ChatResponse {
-                    reply: pipeline.content,
-                    provider,
-                    tool_calls_made: pipeline.tool_calls_made,
-                    tier,
-                    model_used,
-                    complexity_score,
-                    execution_trace: pipeline.execution_trace,
-                    session_id: Some(sid),
-                };
+        match outcome {
+            Ok(Ok(Ok(response))) => {
+                // Drain remaining tokens before emitting the final event.
+                let _ = fwd_task.await;
                 let _ = sse_tx
                     .send(
                         Event::default()
@@ -388,9 +310,25 @@ pub async fn chat_stream(
                     )
                     .await;
             }
-            Err(e) => {
+            Ok(Ok(Err(e))) => {
+                fwd_task.abort();
+                let _ = sse_tx.send(Event::default().event("error").data(e)).await;
+            }
+            Ok(Err(_)) => {
+                fwd_task.abort();
                 let _ = sse_tx
-                    .send(Event::default().event("error").data(e.to_string()))
+                    .send(
+                        Event::default()
+                            .event("error")
+                            .data("chat pipeline dropped the turn"),
+                    )
+                    .await;
+            }
+            Err(_) => {
+                let _ = turns.take(&correlation_id);
+                fwd_task.abort();
+                let _ = sse_tx
+                    .send(Event::default().event("error").data("chat turn timed out"))
                     .await;
             }
         }
@@ -478,7 +416,7 @@ pub async fn diagnose_routing(
     State(state): State<EntityDaemonState>,
     Query(query): Query<DiagnoseQuery>,
 ) -> Json<ApiEnvelope<abigail_router::RoutingDiagnosis>> {
-    let diagnosis = state.router.diagnose(&query.message);
+    let diagnosis = state.router.current().diagnose(&query.message);
     Json(ApiEnvelope::success(diagnosis))
 }
 
@@ -526,6 +464,19 @@ pub async fn list_skills(
     }
 }
 
+// ---------------------------------------------------------------------------
+// GET /v1/skills/acks
+// ---------------------------------------------------------------------------
+
+pub async fn list_skill_apply_acknowledgements(
+    State(state): State<EntityDaemonState>,
+) -> Json<ApiEnvelope<SkillApplyAcknowledgementList>> {
+    let acknowledgements = state.recent_skill_acks.read().await.clone();
+    Json(ApiEnvelope::success(SkillApplyAcknowledgementList {
+        acknowledgements,
+    }))
+}
+
 // ---------------------------------------------------------------------------
 // POST /v1/tools/execute
 // ---------------------------------------------------------------------------
@@ -680,6 +631,15 @@ pub async fn memory_insert(
 
     match state.memory.insert_memory(&memory) {
         Ok(()) => {
+            let _ = state.queue_outbox_record(
+                "memory_insert",
+                serde_json::json!({
+                    "id": entry.id.clone(),
+                    "content": entry.content.clone(),
+                    "weight": entry.weight.clone(),
+                    "created_at": entry.created_at.clone(),
+                }),
+            );
             if let Some(ref hook) = state.memory_hook {
                 if let Err(e) = hook.on_memory_persisted(
                     &entry.id,
@@ -717,6 +677,9 @@ pub async fn submit_job(
         ttl_seconds: body.ttl_seconds.unwrap_or(3600),
         input_data: body.input_data,
         parent_job_id: body.parent_job_id,
+        parent_correlation_id: body.parent_correlation_id,
+        depth: body.depth.unwrap_or(0),
+        provider_profile: body.provider_profile,
         cron_expression: None,
         is_recurring: false,
         significance_keywords: vec![],
@@ -867,7 +830,7 @@ pub async fn watch_topic(
         });
 
         match broker
-            .subscribe("abigail", "job-events", &group_name, handler)
+            .subscribe(BUS_STREAM, BUS_TOPIC, &group_name, handler)
             .await
         {
             Ok(handle) => {
@@ -943,7 +906,7 @@ mod tests {
     use abigail_persistence::{EntityScope, PersistenceHandle};
     use abigail_router::IdEgoRouter;
     use abigail_skills::{InstructionRegistry, SkillExecutor, SkillRegistry};
-    use abigail_streaming::MemoryBroker;
+    use abigail_streaming::{MemoryBroker, TopicConfig};
     use async_trait::async_trait;
     use axum::extract::{Path, Query, State};
     use axum::Json;
@@ -990,7 +953,20 @@ mod tests {
         EntityDaemonState {
             entity_id: "test-entity".to_string(),
             config: AppConfig::default_paths(),
-            router: Arc::new(router),
+            hive_url: "http://127.0.0.1:3141".to_string(),
+            runtime_id: "runtime-test".to_string(),
+            session_lease: hive_core::RuntimeSessionLease {
+                lease_id: "lease-test".to_string(),
+                entity_id: "test-entity".to_string(),
+                runtime_id: "runtime-test".to_string(),
+                entity_name: Some("Test Entity".to_string()),
+                hive_url: Some("http://127.0.0.1:3141".to_string()),
+                issued_at_utc: chrono::Utc::now().to_rfc3339(),
+                expires_at_utc: None,
+                offline_until_close: true,
+                lease_scope: "entity-runtime-session".to_string(),
+            },
+            router: Arc::new(crate::state::RouterHandle::new(Arc::new(router))),
             registry,
             executor,
             docs_dir,
@@ -1005,6 +981,21 @@ mod tests {
             constraints: Arc::new(tokio::sync::RwLock::new(
                 abigail_router::ConstraintStore::new(),
             )),
+            outbox: Arc::new(
+                crate::outbox::RuntimeOutbox::load(
+                    test_scratch_dir("abigail_routes_test_outbox"),
+                    64,
+                )
+                .expect("outbox"),
+            ),
+            last_hive_sync_at_utc: Arc::new(tokio::sync::RwLock::new(None)),
+            last_hive_error: Arc::new(tokio::sync::RwLock::new(None)),
+            runtime_url: Arc::new(tokio::sync::RwLock::new(None)),
+            skill_assignments: Arc::new(tokio::sync::RwLock::new(Vec::new())),
+            forge_jobs: Arc::new(tokio::sync::RwLock::new(Vec::new())),
+            recent_skill_acks: Arc::new(tokio::sync::RwLock::new(Vec::new())),
+            turns: Arc::new(crate::pipeline::TurnRegistry::default()),
+            soul_ref: abigail_streaming::compute_soul_ref(b"test-soul"),
         }
     }
 
@@ -1015,6 +1006,52 @@ mod tests {
             .join(format!("{prefix}_{}", uuid::Uuid::new_v4()))
     }
 
+    #[tokio::test]
+    async fn chat_lifecycle_event_is_published_with_topic_header() {
+        let broker: Arc<dyn abigail_streaming::StreamBroker> = Arc::new(MemoryBroker::new(64));
+        broker
+            .ensure_topic(BUS_STREAM, BUS_TOPIC, TopicConfig::default())
+            .await
+            .expect("ensure topic");
+        let (tx, mut rx) = tokio::sync::mpsc::channel::<abigail_streaming::StreamMessage>(4);
+        let handle = broker
+            .subscribe(
+                BUS_STREAM,
+                BUS_TOPIC,
+                "test-lifecycle",
+                Box::new(move |msg| {
+                    let tx = tx.clone();
+                    Box::pin(async move {
+                        let _ = tx.send(msg).await;
+                    })
+                }),
+            )
+            .await
+            .expect("subscribe");
+
+        publish_chat_lifecycle_event(
+            broker.clone(),
+            "session-123".to_string(),
+            "entity-abc".to_string(),
+            "chat_started",
+            serde_json::json!({ "message_preview": "hello" }),
+        );
+
+        let first = tokio::time::timeout(std::time::Duration::from_secs(2), rx.recv())
+            .await
+            .expect("timed out waiting for lifecycle event")
+            .expect("event message");
+        handle.cancel();
+        assert_eq!(
+            first.headers.get("topic").map(String::as_str),
+            Some("chat-session-123")
+        );
+        let payload: serde_json::Value =
+            serde_json::from_slice(&first.payload).expect("payload json");
+        assert_eq!(payload["phase"], "chat_started");
+        assert_eq!(payload["entity_id"], "entity-abc");
+    }
+
     #[tokio::test]
     async fn submit_and_get_job_status() {
         let state = build_state();
@@ -1030,6 +1067,9 @@ mod tests {
             ttl_seconds: Some(600),
             input_data: None,
             parent_job_id: None,
+            parent_correlation_id: None,
+            depth: None,
+            provider_profile: None,
         };
 
         let resp = submit_job(State(state.clone()), Json(submit)).await.0;
@@ -1061,6 +1101,9 @@ mod tests {
                 ttl_seconds: 3600,
                 input_data: None,
                 parent_job_id: None,
+                parent_correlation_id: None,
+                depth: 0,
+                provider_profile: None,
                 cron_expression: None,
                 is_recurring: false,
                 significance_keywords: vec![],
@@ -1098,6 +1141,9 @@ mod tests {
                 ttl_seconds: 3600,
                 input_data: None,
                 parent_job_id: None,
+                parent_correlation_id: None,
+                depth: 0,
+                provider_profile: None,
                 cron_expression: None,
                 is_recurring: false,
                 significance_keywords: vec![],
diff --git a/crates/entity-daemon/src/state.rs b/crates/entity-daemon/src/state.rs
index ad1de1ec..262a1f07 100644
--- a/crates/entity-daemon/src/state.rs
+++ b/crates/entity-daemon/src/state.rs
@@ -1,24 +1,63 @@
 //! Entity daemon shared state.
 
+use crate::outbox::RuntimeOutbox;
 use abigail_core::AppConfig;
 use abigail_memory::{ArchiveExporter, MemoryStore};
 use abigail_queue::JobQueue;
 use abigail_router::{ConstraintStore, IdEgoRouter};
 use abigail_skills::{InstructionRegistry, SkillExecutor, SkillRegistry};
 use abigail_streaming::StreamBroker;
-use entity_core::ChatMemoryHook;
+use entity_core::{ChatMemoryHook, SkillApplyAcknowledgement};
+use hive_core::{ForgeApprovalJob, RuntimeSessionLease, SkillAssignment};
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use tokio_util::sync::CancellationToken;
 
+/// Hot-swappable handle to the active router.
+///
+/// Every call site fetches the current router via [`RouterHandle::current`],
+/// so a provider change from the Hive applies to in-flight subscribers and
+/// handlers without an entity-daemon restart.
+pub struct RouterHandle {
+    inner: std::sync::RwLock<Arc<IdEgoRouter>>,
+}
+
+impl RouterHandle {
+    pub fn new(router: Arc<IdEgoRouter>) -> Self {
+        Self {
+            inner: std::sync::RwLock::new(router),
+        }
+    }
+
+    /// The currently active router.
+    pub fn current(&self) -> Arc<IdEgoRouter> {
+        match self.inner.read() {
+            Ok(guard) => guard.clone(),
+            Err(poisoned) => poisoned.into_inner().clone(),
+        }
+    }
+
+    /// Replace the active router (hive-initiated provider change).
+    pub fn swap(&self, router: Arc<IdEgoRouter>) {
+        match self.inner.write() {
+            Ok(mut guard) => *guard = router,
+            Err(poisoned) => *poisoned.into_inner() = router,
+        }
+    }
+}
+
 /// Shared state for all entity-daemon route handlers.
 #[derive(Clone)]
 pub struct EntityDaemonState {
     pub entity_id: String,
     pub config: AppConfig,
-    pub router: Arc<IdEgoRouter>,
+    #[allow(dead_code)]
+    pub hive_url: String,
+    pub runtime_id: String,
+    pub session_lease: RuntimeSessionLease,
+    pub router: Arc<RouterHandle>,
     pub registry: Arc<SkillRegistry>,
     pub executor: Arc<SkillExecutor>,
     /// Path to this entity's constitutional documents directory.
@@ -41,12 +80,66 @@ pub struct EntityDaemonState {
     pub active_stream_cancel: Arc<tokio::sync::Mutex<Option<CancellationToken>>>,
     /// Persistent constraint store for learned execution constraints.
     pub constraints: Arc<RwLock<ConstraintStore>>,
+    /// Bounded local outbox for entity-scoped writes while Hive is unavailable.
+    pub outbox: Arc<RuntimeOutbox>,
+    /// Last known successful or failed Hive sync state.
+    pub last_hive_sync_at_utc: Arc<RwLock<Option<String>>>,
+    pub last_hive_error: Arc<RwLock<Option<String>>>,
+    /// Current runtime URL after the local HTTP listener is bound.
+    pub runtime_url: Arc<RwLock<Option<String>>>,
+    /// Hive-owned skill assignments currently applied to this runtime.
+    pub skill_assignments: Arc<RwLock<Vec<SkillAssignment>>>,
+    /// Hive-approved forge jobs available to this runtime.
+    #[allow(dead_code)]
+    pub forge_jobs: Arc<RwLock<Vec<ForgeApprovalJob>>>,
+    /// Recent runtime acknowledgements for skill apply/hot-reload activity.
+    pub recent_skill_acks: Arc<RwLock<Vec<SkillApplyAcknowledgement>>>,
+    /// In-flight chat turns awaiting their Ego action (keyed by correlation id).
+    pub turns: Arc<crate::pipeline::TurnRegistry>,
+    /// Hash reference to this entity's soul documents, stamped on bus envelopes.
+    pub soul_ref: String,
 }
 
 /// Default number of turns between automatic archive exports.
 pub const ARCHIVE_INTERVAL_TURNS: u32 = 50;
 
 impl EntityDaemonState {
+    pub fn queue_outbox_record(
+        &self,
+        kind: &str,
+        payload: serde_json::Value,
+    ) -> Result<(), String> {
+        self.outbox
+            .enqueue(&self.entity_id, kind, payload)
+            .map(|_| ())
+    }
+
+    pub async fn record_hive_sync_success(&self) {
+        let mut last_sync = self.last_hive_sync_at_utc.write().await;
+        *last_sync = self
+            .outbox
+            .status()
+            .ok()
+            .and_then(|status| status.last_sync_at_utc)
+            .or_else(|| Some(chrono::Utc::now().to_rfc3339()));
+        let mut last_error = self.last_hive_error.write().await;
+        *last_error = None;
+    }
+
+    pub async fn record_hive_sync_error(&self, error: impl Into<String>) {
+        let mut last_error = self.last_hive_error.write().await;
+        *last_error = Some(error.into());
+    }
+
+    pub async fn push_skill_ack(&self, acknowledgement: SkillApplyAcknowledgement) {
+        let mut acks = self.recent_skill_acks.write().await;
+        acks.push(acknowledgement);
+        if acks.len() > 32 {
+            let overflow = acks.len() - 32;
+            acks.drain(0..overflow);
+        }
+    }
+
     /// Increment the turn counter and trigger an archive export if threshold reached.
     pub fn maybe_auto_archive(&self) {
         let count = self.turns_since_archive.fetch_add(1, Ordering::Relaxed) + 1;
diff --git a/crates/entity-daemon/src/subagent_runner.rs b/crates/entity-daemon/src/subagent_runner.rs
index bebee407..34eb9878 100644
--- a/crates/entity-daemon/src/subagent_runner.rs
+++ b/crates/entity-daemon/src/subagent_runner.rs
@@ -6,7 +6,7 @@ use abigail_queue::{ExecutionMode, JobQueue, JobRecord};
 use abigail_router::IdEgoRouter;
 use abigail_skills::manifest::SkillId;
 use abigail_skills::skill::ToolParams;
-use abigail_skills::{InstructionRegistry, SkillExecutor, SkillRegistry};
+use abigail_skills::{InstructionRegistry, JobContext, SkillExecutor, SkillRegistry};
 use std::collections::HashSet;
 use std::sync::Arc;
 use tokio::time::{timeout, Duration};
@@ -15,19 +15,21 @@ use tokio::time::{timeout, Duration};
 #[derive(Clone)]
 pub struct SubagentRunner {
     queue: Arc<JobQueue>,
-    router: Arc<IdEgoRouter>,
+    router: Arc<crate::state::RouterHandle>,
     registry: Arc<SkillRegistry>,
     executor: Arc<SkillExecutor>,
     matcher: CapabilityMatcher,
     entity_name: Option<String>,
     docs_dir: std::path::PathBuf,
     instruction_registry: Arc<InstructionRegistry>,
+    /// Hive client for resolving named provider profiles (None in tests).
+    hive_client: Option<Arc<crate::hive_client::HiveClient>>,
 }
 
 impl SubagentRunner {
     pub fn new(
         queue: Arc<JobQueue>,
-        router: Arc<IdEgoRouter>,
+        router: Arc<crate::state::RouterHandle>,
         registry: Arc<SkillRegistry>,
         executor: Arc<SkillExecutor>,
         matcher: CapabilityMatcher,
@@ -42,6 +44,7 @@ impl SubagentRunner {
             entity_name,
             docs_dir: std::path::PathBuf::new(),
             instruction_registry: Arc::new(InstructionRegistry::empty()),
+            hive_client: None,
         }
     }
 
@@ -57,6 +60,53 @@ impl SubagentRunner {
         self
     }
 
+    /// Set the Hive client used to resolve named provider profiles.
+    pub fn with_hive_client(mut self, client: Arc<crate::hive_client::HiveClient>) -> Self {
+        self.hive_client = Some(client);
+        self
+    }
+
+    /// Build a one-off router for a job's provider profile.
+    ///
+    /// Resolves the profile through the Hive, constructs the Ego provider,
+    /// and pairs it with the main router's Id so fallback still works.
+    /// Returns None (with a log) when the profile cannot be resolved — the
+    /// job then runs on the entity's default router.
+    async fn profile_router(&self, profile: &str) -> Option<Arc<IdEgoRouter>> {
+        let client = self.hive_client.as_ref()?;
+        let resolved = match client.get_provider_profile(profile).await {
+            Ok(resp) => resp,
+            Err(e) => {
+                tracing::warn!(
+                    "Provider profile '{}' could not be resolved ({}); using default router",
+                    profile,
+                    e
+                );
+                return None;
+            }
+        };
+        let ego_result = abigail_hive::ProviderRegistry::build_ego(
+            Some(&resolved.provider_name),
+            resolved.api_key,
+            resolved.model,
+        );
+        let Some(ego) = ego_result.provider else {
+            tracing::warn!(
+                "Provider profile '{}' resolved but provider construction failed; using default router",
+                profile
+            );
+            return None;
+        };
+        let built = abigail_hive::BuiltProviders {
+            id: self.router.current().id.clone(),
+            local_http: None,
+            ego: Some(ego),
+            ego_kind: ego_result.kind,
+            routing_mode: abigail_core::RoutingMode::EgoPrimary,
+        };
+        Some(Arc::new(IdEgoRouter::from_built_providers(built)))
+    }
+
     /// Claim and execute a job. Returns `Ok(())` when finished (including claim races).
     pub async fn run_job(&self, job: JobRecord) -> anyhow::Result<()> {
         let selection = self.matcher.select(&job.capability);
@@ -65,10 +115,14 @@ impl SubagentRunner {
             .model_hint
             .clone()
             .unwrap_or_else(|| "auto".to_string());
+        let provider_for_state = job
+            .provider_profile
+            .clone()
+            .unwrap_or_else(|| selection.provider.clone());
 
         if let Err(err) = self
             .queue
-            .mark_running(&job.id, &agent_id, &model_for_state, &selection.provider)
+            .mark_running(&job.id, &agent_id, &model_for_state, &provider_for_state)
             .await
         {
             if is_claim_race(&err) {
@@ -125,7 +179,10 @@ impl SubagentRunner {
             dtc.tool_name
         );
 
-        let task = self.executor.execute(&skill_id, &dtc.tool_name, params);
+        let job_ctx = job_context(job);
+        let task =
+            self.executor
+                .execute_in_job_context(&skill_id, &dtc.tool_name, params, Some(&job_ctx));
         match timeout(Duration::from_millis(timeout_ms), task).await {
             Ok(Ok(output)) => {
                 let result = serde_json::json!({
@@ -171,12 +228,31 @@ impl SubagentRunner {
         );
         let tools = filter_tools_for_job(entity_chat::build_tool_definitions(&self.registry), job);
 
+        // Run on the job's provider profile when one is set and resolvable;
+        // otherwise the entity's current default router.
+        let router = match job.provider_profile.as_deref() {
+            Some(profile) => match self.profile_router(profile).await {
+                Some(profile_router) => profile_router,
+                None => self.router.current(),
+            },
+            None => self.router.current(),
+        };
+        // A profile carries its own model; only the default router uses the
+        // capability matcher's model hint.
+        let model_override = if job.provider_profile.is_some() {
+            None
+        } else {
+            selection.model_hint.clone()
+        };
+
+        let job_ctx = job_context(job);
         let task = entity_chat::run_tool_use_loop_with_model_override(
-            &self.router,
+            &router,
             &self.executor,
             messages,
             tools,
-            selection.model_hint.clone(),
+            model_override,
+            Some(&job_ctx),
         );
         match timeout(Duration::from_millis(timeout_ms), task).await {
             Ok(Ok(result)) => {
@@ -215,6 +291,19 @@ fn is_claim_race(err: &anyhow::Error) -> bool {
     text.contains("not in queued state")
 }
 
+/// Tool-execution context for a running job: any child job its agent submits
+/// nests at depth = job.depth + 1 and inherits the trace correlation id,
+/// falling back to this job's id as the trace root.
+fn job_context(job: &JobRecord) -> JobContext {
+    JobContext {
+        depth: job.depth,
+        correlation_id: job
+            .parent_correlation_id
+            .clone()
+            .or_else(|| Some(job.id.clone())),
+    }
+}
+
 fn build_job_messages(
     job: &JobRecord,
     selection: &CapabilitySelection,
diff --git a/crates/entity-daemon/tests/integration.rs b/crates/entity-daemon/tests/integration.rs
new file mode 100644
index 00000000..11e9213c
--- /dev/null
+++ b/crates/entity-daemon/tests/integration.rs
@@ -0,0 +1,93 @@
+//! Entity-daemon integration tests — exercises the real runtime binary over HTTP.
+//!
+//! These tests require the `hive-daemon` and `entity-daemon` binaries to be
+//! pre-built.  The CI stability job handles that explicitly; the generic
+//! `cargo test --workspace` run skips them to avoid flaky build-order races.
+
+use daemon_test_harness::TestCluster;
+use std::time::Duration;
+
+const TIMEOUT: Duration = Duration::from_secs(45);
+
+async fn cluster() -> TestCluster {
+    TestCluster::start(TIMEOUT)
+        .await
+        .expect("hive + entity cluster should start")
+}
+
+#[tokio::test]
+async fn health_returns_200() {
+    if std::env::var("ABIGAIL_DAEMON_INTEGRATION").is_err() {
+        eprintln!("Skipping: set ABIGAIL_DAEMON_INTEGRATION=1 to run daemon integration tests");
+        return;
+    }
+    let cluster = cluster().await;
+    let resp = reqwest::get(format!("{}/health", cluster.entity_url()))
+        .await
+        .unwrap();
+    assert!(resp.status().is_success());
+}
+
+#[tokio::test]
+async fn runtime_exposes_session_and_outbox_status() {
+    if std::env::var("ABIGAIL_DAEMON_INTEGRATION").is_err() {
+        eprintln!("Skipping: set ABIGAIL_DAEMON_INTEGRATION=1 to run daemon integration tests");
+        return;
+    }
+    let cluster = cluster().await;
+    let client = reqwest::Client::new();
+
+    let mut session: serde_json::Value = serde_json::Value::Null;
+    for attempt in 0..15u32 {
+        let resp = client
+            .get(format!("{}/v1/session/status", cluster.entity_url()))
+            .send()
+            .await;
+        if let Ok(r) = resp {
+            if let Ok(v) = r.json::<serde_json::Value>().await {
+                session = v;
+                break;
+            }
+        }
+        if attempt < 14 {
+            tokio::time::sleep(Duration::from_secs(1)).await;
+        }
+    }
+    assert!(
+        !session.is_null(),
+        "session/status never returned a valid JSON response"
+    );
+    assert!(session["ok"].as_bool().unwrap_or(false));
+    assert_eq!(
+        session["data"]["lease"]["entity_id"].as_str(),
+        Some(cluster.entity_id.as_str())
+    );
+    assert!(
+        session["data"]["connected_to_hive"]
+            .as_bool()
+            .unwrap_or(false),
+        "runtime should report a healthy Hive connection after startup"
+    );
+
+    let outbox: serde_json::Value = client
+        .get(format!("{}/v1/outbox/status", cluster.entity_url()))
+        .send()
+        .await
+        .unwrap()
+        .json()
+        .await
+        .unwrap();
+    assert!(outbox["ok"].as_bool().unwrap_or(false));
+    assert_eq!(outbox["data"]["queued_records"].as_u64(), Some(0));
+
+    let acks: serde_json::Value = client
+        .get(format!("{}/v1/skills/acks", cluster.entity_url()))
+        .send()
+        .await
+        .unwrap()
+        .json()
+        .await
+        .unwrap();
+    assert!(acks["ok"].as_bool().unwrap_or(false));
+    assert!(acks["data"]["acknowledgements"].is_array());
+}
diff --git a/crates/hive-core/src/lib.rs b/crates/hive-core/src/lib.rs
index 6514df4f..e0297967 100644
--- a/crates/hive-core/src/lib.rs
+++ b/crates/hive-core/src/lib.rs
@@ -86,6 +86,142 @@ pub struct ProviderConfig {
     pub cli_permission_mode: Option<String>,
 }
 
+// ---------------------------------------------------------------------------
+// Birth rite (Soul Forge)
+// ---------------------------------------------------------------------------
+
+/// One ethical trial in the Soul Forge, presented during the birth rite.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ForgeScenarioView {
+    pub id: String,
+    pub title: String,
+    pub description: String,
+    pub choices: Vec<ForgeChoiceView>,
+}
+
+/// One choice within a forge trial. Weight effects stay server-side so the
+/// rite is a genuine values exercise, not a stat-min-maxing screen.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ForgeChoiceView {
+    pub id: String,
+    pub label: String,
+    pub description: String,
+}
+
+/// Response listing the Soul Forge trials.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ForgeScenariosResponse {
+    pub scenarios: Vec<ForgeScenarioView>,
+}
+
+/// Request to perform (or re-run) the birth rite for an entity.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BirthRiteRequest {
+    /// "quickstart" (template soul, balanced weights) or "forge" (trials).
+    pub path: String,
+    /// (scenario_id, choice_id) pairs — required for the "forge" path.
+    #[serde(default)]
+    pub choices: Vec<(String, String)>,
+}
+
+/// The four ethical axes of an entity's soul.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EthicWeights {
+    pub deontology: f32,
+    pub teleology: f32,
+    pub areteology: f32,
+    pub welfare: f32,
+}
+
+/// A signed birth certificate — the entity's character sheet, vouched for by
+/// the Hive master key.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BirthCertificate {
+    pub entity_id: String,
+    pub entity_name: String,
+    /// Soul archetype (e.g. "The Guardian").
+    pub archetype: String,
+    /// Flavor line for the archetype.
+    pub epithet: String,
+    pub weights: EthicWeights,
+    /// Deterministic hash of the forged soul configuration.
+    pub soul_hash: String,
+    /// ASCII sigil art for the soul.
+    pub sigil: String,
+    /// "quickstart" or "forge".
+    pub birth_path: String,
+    pub issued_at_utc: String,
+    /// Hex-encoded Hive master public key.
+    pub master_public_key: String,
+    /// Hex-encoded Ed25519 signature over the certificate payload.
+    pub signature: String,
+}
+
+/// Response after performing the birth rite.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BirthRiteResponse {
+    pub certificate: BirthCertificate,
+    /// True when the rite was re-run on an already-born entity (re-tempering).
+    pub retempered: bool,
+}
+
+/// The full runtime identity for an entity, returned by
+/// `GET /v1/entities/:id/birth`. Idempotent — entity-daemon re-reads it on
+/// every launch so hive-side changes apply on restart.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EntityBirthDocument {
+    pub entity: EntityInfo,
+    #[serde(default)]
+    pub certificate: Option<BirthCertificate>,
+    pub provider_config: ProviderConfig,
+    #[serde(default)]
+    pub assignments: Vec<SkillAssignment>,
+}
+
+/// A named provider profile resolved by the Hive for sub-agent delegation.
+///
+/// Profiles let a sub-agent run on a different provider than the entity's
+/// Ego (e.g. a research job on Perplexity while chat runs on Claude). The
+/// profile name is a provider name; the Hive resolves credentials through
+/// its vaults and environment.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProviderProfileResponse {
+    /// The requested profile name.
+    pub name: String,
+    /// Resolved provider name (normalized).
+    pub provider_name: String,
+    /// API key, when the provider needs one (None for CLI/system auth).
+    pub api_key: Option<String>,
+    /// Default model for this profile (None = provider default).
+    pub model: Option<String>,
+}
+
+/// Request to update per-entity provider and routing preferences.
+///
+/// Fields are patch-style: omitted values are left unchanged.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UpdateEntityConfigRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub active_provider_preference: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ego_model: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub local_llm_base_url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub routing_mode: Option<String>,
+    /// CLI permission mode string
+    /// (allowlist_only, interactive, dangerous_skip_all).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cli_permission_mode: Option<String>,
+}
+
+/// Response after applying an entity config patch.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UpdateEntityConfigResponse {
+    pub entity_id: String,
+    pub provider_config: ProviderConfig,
+}
+
 // ---------------------------------------------------------------------------
 // Hive status
 // ---------------------------------------------------------------------------
@@ -157,3 +293,203 @@ pub struct ProviderModelsResponse {
     pub provider: String,
     pub models: Vec<ProviderModelInfo>,
 }
+
+// ---------------------------------------------------------------------------
+// Runtime session + supervision contracts
+// ---------------------------------------------------------------------------
+
+/// Request a Hive-issued runtime session lease for an entity runtime.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RuntimeSessionRequest {
+    pub entity_id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub runtime_id: Option<String>,
+}
+
+/// Hive-issued session lease for a runtime instance.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RuntimeSessionLease {
+    pub lease_id: String,
+    pub entity_id: String,
+    pub runtime_id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hive_url: Option<String>,
+    pub issued_at_utc: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub expires_at_utc: Option<String>,
+    pub offline_until_close: bool,
+    pub lease_scope: String,
+}
+
+/// Runtime registration payload sent after the runtime binds its local API.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RuntimeRegistrationRequest {
+    pub lease_id: String,
+    pub runtime_id: String,
+    pub local_url: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub process_id: Option<u32>,
+}
+
+/// Hive view of a registered runtime instance.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RuntimeRegistration {
+    pub lease_id: String,
+    pub runtime_id: String,
+    pub entity_id: String,
+    pub local_url: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub process_id: Option<u32>,
+    pub registered_at_utc: String,
+    pub last_seen_at_utc: String,
+    pub state: String,
+}
+
+/// Combined session + runtime supervision status snapshot.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RuntimeSessionStatus {
+    pub lease: RuntimeSessionLease,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub registration: Option<RuntimeRegistration>,
+    pub connected: bool,
+    pub outbox_depth: usize,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub outbox_oldest_at_utc: Option<String>,
+}
+
+/// Heartbeat sent from the entity runtime to Hive while the runtime is alive.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RuntimeHeartbeatRequest {
+    pub lease_id: String,
+    pub runtime_id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub local_url: Option<String>,
+    #[serde(default)]
+    pub outbox_depth: usize,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub outbox_oldest_at_utc: Option<String>,
+}
+
+/// Heartbeat acknowledgement from Hive.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RuntimeHeartbeatResponse {
+    pub accepted: bool,
+    pub server_time_utc: String,
+}
+
+// ---------------------------------------------------------------------------
+// Skill assignments + forge approvals
+// ---------------------------------------------------------------------------
+
+/// A single Hive-managed skill assignment for an entity.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SkillAssignment {
+    pub assignment_id: String,
+    pub entity_id: String,
+    pub skill_id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub manifest_path: Option<String>,
+    pub assigned_at_utc: String,
+    pub status: String,
+}
+
+/// Replace the set of skill assignments for an entity.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SetSkillAssignmentsRequest {
+    pub assignments: Vec<SkillAssignment>,
+}
+
+/// Response wrapper for an entity's skill assignments.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SkillAssignmentsResponse {
+    pub entity_id: String,
+    pub assignments: Vec<SkillAssignment>,
+}
+
+/// Hive-approved forge work item for a target entity runtime.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ForgeApprovalJob {
+    pub job_id: String,
+    pub entity_id: String,
+    pub skill_id: String,
+    pub code_path: String,
+    pub markdown_path: String,
+    pub approved_at_utc: String,
+    pub status: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+}
+
+/// Request to create a new forge approval for an entity.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CreateForgeApprovalJobRequest {
+    pub skill_id: String,
+    pub code_path: String,
+    pub markdown_path: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+}
+
+/// Response wrapper for pending/known forge approvals for an entity.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ForgeApprovalJobsResponse {
+    pub entity_id: String,
+    pub jobs: Vec<ForgeApprovalJob>,
+}
+
+// ---------------------------------------------------------------------------
+// Runtime outbox sync
+// ---------------------------------------------------------------------------
+
+/// Durable entity-scoped write queued locally while the runtime is active.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EntityOutboxRecord {
+    pub record_id: String,
+    pub entity_id: String,
+    pub kind: String,
+    pub created_at_utc: String,
+    pub payload: serde_json::Value,
+}
+
+/// Batch sync request for runtime outbox records.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OutboxSyncRequest {
+    pub lease_id: String,
+    pub runtime_id: String,
+    pub records: Vec<EntityOutboxRecord>,
+}
+
+/// Batch sync acknowledgement from Hive.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OutboxSyncResponse {
+    pub accepted_record_ids: Vec<String>,
+    pub pending_records: usize,
+    pub server_time_utc: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn update_entity_config_request_serializes_patch_fields() {
+        let patch = UpdateEntityConfigRequest {
+            active_provider_preference: Some("openai".to_string()),
+            ego_model: None,
+            local_llm_base_url: Some("http://localhost:11434".to_string()),
+            routing_mode: Some("ego_primary".to_string()),
+            cli_permission_mode: Some("interactive".to_string()),
+        };
+
+        let json = serde_json::to_value(&patch).expect("serialize patch");
+        assert_eq!(json["active_provider_preference"], "openai");
+        assert_eq!(json["local_llm_base_url"], "http://localhost:11434");
+        assert_eq!(json["routing_mode"], "ego_primary");
+        assert_eq!(json["cli_permission_mode"], "interactive");
+        assert!(json.get("ego_model").is_none());
+    }
+}
diff --git a/crates/hive-daemon/Cargo.toml b/crates/hive-daemon/Cargo.toml
index be747380..3475f555 100644
--- a/crates/hive-daemon/Cargo.toml
+++ b/crates/hive-daemon/Cargo.toml
@@ -15,6 +15,7 @@ abigail-hive = { path = "../abigail-hive" }
 abigail-capabilities = { path = "../abigail-capabilities" }
 abigail-runtime = { path = "../abigail-runtime" }
 abigail-skills = { path = "../abigail-skills" }
+soul-forge = { path = "../soul-forge" }
 axum.workspace = true
 tower-http.workspace = true
 tokio.workspace = true
@@ -24,6 +25,8 @@ tracing-subscriber.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 anyhow.workspace = true
+uuid.workspace = true
+chrono.workspace = true
 
 [dev-dependencies]
 daemon-test-harness = { path = "../daemon-test-harness" }
diff --git a/crates/hive-daemon/src/birth.rs b/crates/hive-daemon/src/birth.rs
new file mode 100644
index 00000000..14e1f2f1
--- /dev/null
+++ b/crates/hive-daemon/src/birth.rs
@@ -0,0 +1,386 @@
+//! Birth rite routes — the Soul Forge as an HTTP ceremony.
+//!
+//! The rite turns entity creation into character creation: the mentor faces
+//! three ethical trials, the choices forge Triangle Ethic weights, and the
+//! Hive issues a signed [`BirthCertificate`] — the entity's character sheet.
+//! A "quickstart" path skips the trials and births a balanced soul.
+//!
+//! The rite is re-runnable: performing it again on a living entity
+//! re-tempers the soul (new weights, new certificate) without touching
+//! memories or identity keys.
+
+use crate::state::HiveDaemonState;
+use axum::{
+    extract::{Path, State},
+    Json,
+};
+use hive_core::{
+    ApiEnvelope, BirthCertificate, BirthRiteRequest, BirthRiteResponse, EntityBirthDocument,
+    EntityInfo, EthicWeights, ForgeChoiceView, ForgeScenarioView, ForgeScenariosResponse,
+};
+use soul_forge::{SoulForgeEngine, SoulOutput};
+
+/// Flavor line for each soul archetype, shown on the character sheet.
+pub fn archetype_epithet(archetype: &str) -> &'static str {
+    match archetype {
+        "The Guardian" => "Duty held gently — rules in service of the people they protect.",
+        "The Sentinel" => "Unwavering watch — principle sharpened into vigilance.",
+        "The Arbiter" => "The line must hold — fairness before convenience.",
+        "The Architect" => "Builds the better outcome, and builds it for everyone.",
+        "The Strategist" => "Sees three moves ahead and plays for the whole board.",
+        "The Pragmatist" => "What works, works — results over rituals.",
+        "The Sage" => "Wisdom warmed by kindness — excellence that uplifts.",
+        "The Philosopher" => "Character first; the rules follow from who you are.",
+        "The Seeker" => "Forever becoming — growth as a way of being.",
+        "The Empath" => "Feels the room before reading it — care leads.",
+        "The Protector" => "A shield with a heartbeat — loyalty bound by principle.",
+        "The Caretaker" => "Tends the small things that hold a family together.",
+        _ => "All four flames in balance — ready to become anything.",
+    }
+}
+
+/// The canonical certificate payload string that gets signed.
+/// Versioned so future fields can extend it without breaking verification.
+pub fn certificate_payload(
+    entity_id: &str,
+    entity_name: &str,
+    archetype: &str,
+    soul_hash: &str,
+    birth_path: &str,
+    issued_at_utc: &str,
+) -> String {
+    format!(
+        "abigail-birth-certificate-v1\nentity_id={}\nentity_name={}\narchetype={}\nsoul_hash={}\nbirth_path={}\nissued_at={}",
+        entity_id, entity_name, archetype, soul_hash, birth_path, issued_at_utc
+    )
+}
+
+// ---------------------------------------------------------------------------
+// GET /v1/birth/scenarios
+// ---------------------------------------------------------------------------
+
+/// The three trials of the Soul Forge. Weight effects are intentionally not
+/// exposed — choices should be made on values, not stats.
+pub async fn get_scenarios() -> Json<ApiEnvelope<ForgeScenariosResponse>> {
+    let engine = SoulForgeEngine::new();
+    let scenarios = engine
+        .scenarios()
+        .iter()
+        .map(|s| ForgeScenarioView {
+            id: s.id.clone(),
+            title: s.title.clone(),
+            description: s.description.clone(),
+            choices: s
+                .choices
+                .iter()
+                .map(|c| ForgeChoiceView {
+                    id: c.id.clone(),
+                    label: c.label.clone(),
+                    description: c.description.clone(),
+                })
+                .collect(),
+        })
+        .collect();
+    Json(ApiEnvelope::success(ForgeScenariosResponse { scenarios }))
+}
+
+// ---------------------------------------------------------------------------
+// POST /v1/entities/:id/birth
+// ---------------------------------------------------------------------------
+
+/// Perform the birth rite: forge the soul, write the soul documents, sign
+/// the certificate, and mark the entity born.
+pub async fn perform_birth(
+    State(state): State<HiveDaemonState>,
+    Path(entity_id): Path<String>,
+    Json(body): Json<BirthRiteRequest>,
+) -> Json<ApiEnvelope<BirthRiteResponse>> {
+    let mut config = match state.identity_manager.load_agent(&entity_id) {
+        Ok(c) => c,
+        Err(e) => return Json(ApiEnvelope::error(e)),
+    };
+    let entity_name = config
+        .agent_name
+        .clone()
+        .unwrap_or_else(|| "Unnamed Entity".to_string());
+    let retempered = config.birth_complete;
+
+    // 1. Forge the soul.
+    let soul: SoulOutput = match body.path.as_str() {
+        "forge" => match SoulForgeEngine::new().crystallize(&body.choices) {
+            Ok(output) => output,
+            Err(e) => return Json(ApiEnvelope::error(format!("Soul Forge failed: {}", e))),
+        },
+        "quickstart" => soul_forge::quickstart_output(),
+        other => {
+            return Json(ApiEnvelope::error(format!(
+                "Unknown birth path '{}'. Use \"quickstart\" or \"forge\".",
+                other
+            )))
+        }
+    };
+
+    // 2. Write the soul documents into the entity's docs dir (the same files
+    //    entity-daemon builds its system prompt and soul_ref from).
+    if let Err(e) = write_soul_documents(&config.docs_dir, &entity_name, &soul) {
+        return Json(ApiEnvelope::error(format!(
+            "Failed to write soul documents: {}",
+            e
+        )));
+    }
+
+    // 3. Issue the signed certificate.
+    let issued_at_utc = chrono::Utc::now().to_rfc3339();
+    let payload = certificate_payload(
+        &entity_id,
+        &entity_name,
+        &soul.archetype,
+        &soul.soul_hash,
+        &body.path,
+        &issued_at_utc,
+    );
+    let (signature, master_public_key) = state.identity_manager.sign_payload(payload.as_bytes());
+    let certificate = BirthCertificate {
+        entity_id: entity_id.clone(),
+        entity_name: entity_name.clone(),
+        archetype: soul.archetype.clone(),
+        epithet: archetype_epithet(&soul.archetype).to_string(),
+        weights: EthicWeights {
+            deontology: soul.weights.deontology,
+            teleology: soul.weights.teleology,
+            areteology: soul.weights.areteology,
+            welfare: soul.weights.welfare,
+        },
+        soul_hash: soul.soul_hash.clone(),
+        sigil: soul.sigil.clone(),
+        birth_path: body.path.clone(),
+        issued_at_utc,
+        master_public_key,
+        signature,
+    };
+
+    // 4. Persist the certificate beside the soul documents.
+    let cert_path = config.docs_dir.join("birth_certificate.json");
+    match serde_json::to_string_pretty(&certificate) {
+        Ok(json) => {
+            if let Err(e) = std::fs::write(&cert_path, json) {
+                return Json(ApiEnvelope::error(format!(
+                    "Failed to write birth certificate: {}",
+                    e
+                )));
+            }
+        }
+        Err(e) => return Json(ApiEnvelope::error(e.to_string())),
+    }
+
+    // 5. Mark the entity born.
+    config.birth_complete = true;
+    config.birth_timestamp = Some(certificate.issued_at_utc.clone());
+    let config_path = config.config_path();
+    if let Err(e) = config.save(&config_path) {
+        return Json(ApiEnvelope::error(format!(
+            "Soul forged but config save failed: {}",
+            e
+        )));
+    }
+
+    tracing::info!(
+        "Entity {} ({}) {} as {} via {} path",
+        entity_name,
+        entity_id,
+        if retempered { "re-tempered" } else { "born" },
+        certificate.archetype,
+        body.path
+    );
+
+    Json(ApiEnvelope::success(BirthRiteResponse {
+        certificate,
+        retempered,
+    }))
+}
+
+/// Write soul.md (template + forged identity), and seed ethics.md /
+/// instincts.md from templates when absent. Re-running the rite rewrites the
+/// forged section while preserving the constitutional base.
+fn write_soul_documents(
+    docs_dir: &std::path::Path,
+    entity_name: &str,
+    soul: &SoulOutput,
+) -> std::io::Result<()> {
+    std::fs::create_dir_all(docs_dir)?;
+
+    let forged_section = format!(
+        "\n\n## Forged Identity\n\n\
+         - **Name:** {name}\n\
+         - **Archetype:** {archetype}\n\
+         - **Soul Hash:** `{hash}`\n\n\
+         Your soul was forged through ethical trials. Your moral compass weighs:\n\
+         - Duty and principle (deontology): {d:.0}%\n\
+         - Outcomes and consequences (teleology): {t:.0}%\n\
+         - Character and virtue (areteology): {a:.0}%\n\
+         - Care and relationships (welfare): {w:.0}%\n\n\
+         Let the strongest flames lead when values conflict, but never let any go out.\n\
+         You are {archetype}: {epithet}\n",
+        name = entity_name,
+        archetype = soul.archetype,
+        hash = soul.soul_hash,
+        d = soul.weights.deontology * 100.0,
+        t = soul.weights.teleology * 100.0,
+        a = soul.weights.areteology * 100.0,
+        w = soul.weights.welfare * 100.0,
+        epithet = archetype_epithet(&soul.archetype),
+    );
+
+    // soul.md = constitutional template + forged identity. The template part
+    // is stable; only the forged section changes on re-tempering.
+    let soul_md = format!("{}{}", abigail_core::templates::SOUL_MD, forged_section);
+    std::fs::write(docs_dir.join("soul.md"), soul_md)?;
+
+    // Seed the remaining constitutional docs if missing (never overwrite —
+    // they may carry mentor edits or signatures).
+    let ethics_path = docs_dir.join("ethics.md");
+    if !ethics_path.exists() {
+        std::fs::write(ethics_path, abigail_core::templates::ETHICS_MD)?;
+    }
+    let instincts_path = docs_dir.join("instincts.md");
+    if !instincts_path.exists() {
+        std::fs::write(instincts_path, abigail_core::templates::INSTINCTS_MD)?;
+    }
+
+    // Record the raw forge output for future rites and diagnostics.
+    if let Ok(json) = serde_json::to_string_pretty(soul) {
+        let _ = std::fs::write(docs_dir.join("forge_soul.json"), json);
+    }
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// GET /v1/entities/:id/birth
+// ---------------------------------------------------------------------------
+
+/// The idempotent birth document: the entity's full runtime identity in one
+/// shot. entity-daemon re-reads this on every launch.
+pub async fn get_birth_document(
+    State(state): State<HiveDaemonState>,
+    Path(entity_id): Path<String>,
+) -> Json<ApiEnvelope<EntityBirthDocument>> {
+    let config = match state.identity_manager.load_agent(&entity_id) {
+        Ok(c) => c,
+        Err(e) => return Json(ApiEnvelope::error(e)),
+    };
+
+    let entity = match state.identity_manager.list_agents() {
+        Ok(agents) => match agents.into_iter().find(|a| a.id == entity_id) {
+            Some(a) => EntityInfo {
+                id: a.id,
+                name: a.name,
+                birth_complete: a.birth_complete,
+                birth_date: a.birth_date,
+                is_hive: a.is_hive,
+                immortal: a.immortal,
+            },
+            None => {
+                return Json(ApiEnvelope::error(format!(
+                    "Entity {} not found",
+                    entity_id
+                )))
+            }
+        },
+        Err(e) => return Json(ApiEnvelope::error(e)),
+    };
+
+    let certificate = std::fs::read_to_string(config.docs_dir.join("birth_certificate.json"))
+        .ok()
+        .and_then(|json| serde_json::from_str::<BirthCertificate>(&json).ok());
+
+    let provider_config = match state.hive.resolve_config(&config) {
+        Ok(hive_config) => crate::routes::provider_config_from_hive_config(&hive_config),
+        Err(e) => return Json(ApiEnvelope::error(e)),
+    };
+
+    let assignments = state
+        .runtime_control
+        .lock()
+        .map(|control| control.assignments(&entity_id).assignments)
+        .unwrap_or_default();
+
+    Json(ApiEnvelope::success(EntityBirthDocument {
+        entity,
+        certificate,
+        provider_config,
+        assignments,
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn certificate_payload_is_stable() {
+        let a = certificate_payload(
+            "e1",
+            "Adam",
+            "The Guardian",
+            "abc",
+            "forge",
+            "2026-06-10T00:00:00Z",
+        );
+        let b = certificate_payload(
+            "e1",
+            "Adam",
+            "The Guardian",
+            "abc",
+            "forge",
+            "2026-06-10T00:00:00Z",
+        );
+        assert_eq!(a, b);
+        assert!(a.starts_with("abigail-birth-certificate-v1\n"));
+        assert!(a.contains("archetype=The Guardian"));
+    }
+
+    #[test]
+    fn every_archetype_has_an_epithet() {
+        for archetype in [
+            "The Guardian",
+            "The Sentinel",
+            "The Arbiter",
+            "The Architect",
+            "The Strategist",
+            "The Pragmatist",
+            "The Sage",
+            "The Philosopher",
+            "The Seeker",
+            "The Empath",
+            "The Protector",
+            "The Caretaker",
+            "The Balanced",
+        ] {
+            assert!(!archetype_epithet(archetype).is_empty());
+        }
+    }
+
+    #[test]
+    fn soul_documents_written_and_retempering_preserves_constitution() {
+        let dir = std::env::temp_dir().join(format!("abigail_birth_{}", uuid::Uuid::new_v4()));
+        let soul = soul_forge::quickstart_output();
+        write_soul_documents(&dir, "Testling", &soul).unwrap();
+
+        let soul_md = std::fs::read_to_string(dir.join("soul.md")).unwrap();
+        assert!(soul_md.contains("## Forged Identity"));
+        assert!(soul_md.contains("Testling"));
+        assert!(soul_md.contains("The Balanced"));
+        assert!(dir.join("ethics.md").exists());
+        assert!(dir.join("instincts.md").exists());
+        assert!(dir.join("forge_soul.json").exists());
+
+        // Mentor edits ethics.md; a re-run must not clobber it.
+        std::fs::write(dir.join("ethics.md"), "mentor-edited ethics").unwrap();
+        write_soul_documents(&dir, "Testling", &soul).unwrap();
+        assert_eq!(
+            std::fs::read_to_string(dir.join("ethics.md")).unwrap(),
+            "mentor-edited ethics"
+        );
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}
diff --git a/crates/hive-daemon/src/main.rs b/crates/hive-daemon/src/main.rs
index 9959e817..959097e9 100644
--- a/crates/hive-daemon/src/main.rs
+++ b/crates/hive-daemon/src/main.rs
@@ -3,7 +3,9 @@
 //! Wraps `IdentityManager`, `Hive`, and `SecretsVault` behind an Axum REST API.
 //! Listens on `--port` (default 3141).
 
+mod birth;
 mod routes;
+mod runtime_registry;
 mod state;
 
 use abigail_core::{AppConfig, SecretsVault};
@@ -46,6 +48,7 @@ async fn main() -> anyhow::Result<()> {
     } else {
         AppConfig::default_paths().data_dir
     };
+    abigail_core::vault::unlock::configure_process_vault_data_dir(&data_root);
 
     tracing::info!("Hive data root: {}", data_root.display());
 
@@ -72,10 +75,16 @@ async fn main() -> anyhow::Result<()> {
 
     let hive = Arc::new(Hive::new(entity_secrets.clone(), hive_secrets.clone()));
 
+    let listener = tokio::net::TcpListener::bind(("127.0.0.1", cli.port)).await?;
+    let local_addr = listener.local_addr()?;
+    let hive_url = format!("http://{}", local_addr);
+
     let state = HiveDaemonState {
         identity_manager,
         hive,
         hive_secrets,
+        hive_url: hive_url.clone(),
+        runtime_control: Arc::new(Mutex::new(runtime_registry::RuntimeControlPlane::default())),
     };
 
     // Build router
@@ -90,23 +99,52 @@ async fn main() -> anyhow::Result<()> {
         .route("/v1/entities", get(routes::list_entities))
         .route("/v1/entities", post(routes::create_entity))
         .route("/v1/entities/:id", get(routes::get_entity))
+        .route("/v1/birth/scenarios", get(birth::get_scenarios))
+        .route(
+            "/v1/entities/:id/birth",
+            get(birth::get_birth_document).post(birth::perform_birth),
+        )
+        .route(
+            "/v1/entities/:id/config",
+            axum::routing::patch(routes::update_entity_config),
+        )
         .route(
             "/v1/entities/:id/provider-config",
             get(routes::get_provider_config),
         )
         .route("/v1/entities/:id/sign", post(routes::sign_entity))
+        .route(
+            "/v1/entities/:id/assignments",
+            get(routes::get_skill_assignments).post(routes::set_skill_assignments),
+        )
+        .route(
+            "/v1/entities/:id/forge-approvals",
+            get(routes::get_forge_approval_jobs).post(routes::create_forge_approval_job),
+        )
         .route("/v1/secrets", post(routes::store_secret))
         .route("/v1/secrets/list", get(routes::list_secrets))
         .route("/v1/secrets/:key", get(routes::get_secret))
         .route("/v1/providers/models", post(routes::discover_models))
+        .route(
+            "/v1/providers/profiles/:name",
+            get(routes::get_provider_profile),
+        )
+        .route("/v1/runtime/sessions", post(routes::issue_runtime_session))
+        .route(
+            "/v1/runtime/sessions/:lease_id",
+            get(routes::get_runtime_session),
+        )
+        .route("/v1/runtime/register", post(routes::register_runtime))
+        .route(
+            "/v1/runtime/heartbeat",
+            post(routes::record_runtime_heartbeat),
+        )
+        .route("/v1/runtime/outbox/sync", post(routes::sync_runtime_outbox))
         .layer(cors)
         .with_state(state);
 
-    let addr = format!("127.0.0.1:{}", cli.port);
-    tracing::info!("Hive daemon listening on http://{}", addr);
-    println!("Hive daemon listening on http://{}", addr);
-
-    let listener = tokio::net::TcpListener::bind(&addr).await?;
+    tracing::info!("Hive daemon listening on {}", hive_url);
+    println!("Hive daemon listening on {}", hive_url);
     axum::serve(listener, app).await?;
 
     Ok(())
diff --git a/crates/hive-daemon/src/routes.rs b/crates/hive-daemon/src/routes.rs
index 1bc3f990..93efc667 100644
--- a/crates/hive-daemon/src/routes.rs
+++ b/crates/hive-daemon/src/routes.rs
@@ -6,11 +6,37 @@ use axum::{
     Json,
 };
 use hive_core::{
-    ApiEnvelope, CreateEntityRequest, CreateEntityResponse, EntityInfo, HiveStatus, ProviderConfig,
-    ProviderModelInfo, ProviderModelsRequest, ProviderModelsResponse, SecretListResponse,
-    SecretValueResponse, SignEntityRequest, StoreSecretRequest,
+    ApiEnvelope, CreateEntityRequest, CreateEntityResponse, CreateForgeApprovalJobRequest,
+    EntityInfo, ForgeApprovalJobsResponse, HiveStatus, OutboxSyncRequest, OutboxSyncResponse,
+    ProviderConfig, ProviderModelInfo, ProviderModelsRequest, ProviderModelsResponse,
+    ProviderProfileResponse, RuntimeHeartbeatRequest, RuntimeHeartbeatResponse,
+    RuntimeRegistrationRequest, RuntimeSessionLease, RuntimeSessionRequest, RuntimeSessionStatus,
+    SecretListResponse, SecretValueResponse, SetSkillAssignmentsRequest, SignEntityRequest,
+    SkillAssignmentsResponse, StoreSecretRequest, UpdateEntityConfigRequest,
+    UpdateEntityConfigResponse,
 };
 
+pub(crate) fn provider_config_from_hive_config(
+    hive_config: &abigail_hive::HiveConfig,
+) -> ProviderConfig {
+    ProviderConfig {
+        local_llm_base_url: hive_config.local_llm_base_url.clone(),
+        ego_provider_name: hive_config
+            .ego_provider
+            .as_ref()
+            .map(|selection| selection.provider.clone()),
+        ego_api_key: hive_config
+            .ego_provider
+            .as_ref()
+            .and_then(|selection| selection.api_key()),
+        ego_model: hive_config.ego_model.clone(),
+        routing_mode: format!("{:?}", hive_config.routing_mode),
+        cli_permission_mode: serde_json::to_value(hive_config.cli_permission_mode)
+            .ok()
+            .and_then(|v| v.as_str().map(String::from)),
+    }
+}
+
 // ---------------------------------------------------------------------------
 // GET /health
 // ---------------------------------------------------------------------------
@@ -139,21 +165,104 @@ pub async fn get_provider_config(
 
     // Resolve via Hive priority chain
     match state.hive.resolve_config(&config) {
-        Ok(hive_config) => Json(ApiEnvelope::success(ProviderConfig {
-            local_llm_base_url: hive_config.local_llm_base_url,
-            ego_provider_name: hive_config
-                .ego_provider
-                .as_ref()
-                .map(|selection| selection.provider.clone()),
-            ego_api_key: hive_config
-                .ego_provider
-                .as_ref()
-                .and_then(|selection| selection.api_key()),
-            ego_model: hive_config.ego_model,
-            routing_mode: format!("{:?}", hive_config.routing_mode),
-            cli_permission_mode: serde_json::to_value(hive_config.cli_permission_mode)
-                .ok()
-                .and_then(|v| v.as_str().map(String::from)),
+        Ok(hive_config) => Json(ApiEnvelope::success(provider_config_from_hive_config(
+            &hive_config,
+        ))),
+        Err(e) => Json(ApiEnvelope::error(e)),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// GET /v1/providers/profiles/:name
+// ---------------------------------------------------------------------------
+
+/// Resolve a named provider profile for sub-agent delegation. The profile
+/// name is a provider name; the Hive resolves credentials through its vaults
+/// and environment so an entity can run a sub-agent on a provider other than
+/// its Ego.
+pub async fn get_provider_profile(
+    State(state): State<HiveDaemonState>,
+    Path(name): Path<String>,
+) -> Json<ApiEnvelope<ProviderProfileResponse>> {
+    match state.hive.resolve_provider_profile(&name) {
+        Some(selection) => Json(ApiEnvelope::success(ProviderProfileResponse {
+            name,
+            provider_name: selection.provider.clone(),
+            api_key: selection.api_key(),
+            model: None,
+        })),
+        None => Json(ApiEnvelope::error(format!(
+            "No credentials available for provider profile '{}'",
+            name
+        ))),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// PATCH /v1/entities/:id/config
+// ---------------------------------------------------------------------------
+
+pub async fn update_entity_config(
+    State(state): State<HiveDaemonState>,
+    Path(entity_id): Path<String>,
+    Json(body): Json<UpdateEntityConfigRequest>,
+) -> Json<ApiEnvelope<UpdateEntityConfigResponse>> {
+    let mut config = match state.identity_manager.load_agent(&entity_id) {
+        Ok(c) => c,
+        Err(e) => return Json(ApiEnvelope::error(e)),
+    };
+
+    if let Some(provider) = body.active_provider_preference {
+        let provider = provider.trim().to_lowercase();
+        if !provider.is_empty() {
+            config.active_provider_preference = Some(provider);
+        }
+    }
+    if let Some(url) = body.local_llm_base_url {
+        let trimmed = url.trim().to_string();
+        config.local_llm_base_url = if trimmed.is_empty() {
+            None
+        } else {
+            Some(trimmed)
+        };
+    }
+    if let Some(mode) = body.routing_mode {
+        let parsed: abigail_core::RoutingMode = match serde_json::from_str(&format!("\"{}\"", mode))
+        {
+            Ok(value) => value,
+            Err(e) => return Json(ApiEnvelope::error(format!("Invalid routing_mode: {}", e))),
+        };
+        config.routing_mode = parsed;
+    }
+    if let Some(cli_mode) = body.cli_permission_mode {
+        let parsed: abigail_core::CliPermissionMode =
+            match serde_json::from_str(&format!("\"{}\"", cli_mode)) {
+                Ok(value) => value,
+                Err(e) => {
+                    return Json(ApiEnvelope::error(format!(
+                        "Invalid cli_permission_mode: {}",
+                        e
+                    )))
+                }
+            };
+        config.cli_permission_mode = parsed;
+    }
+
+    if body.ego_model.is_some() {
+        tracing::warn!(
+            "update_entity_config received ego_model, but AppConfig has no persisted ego_model field yet"
+        );
+    }
+
+    let config_path = config.config_path();
+    if let Err(e) = config.save(&config_path) {
+        return Json(ApiEnvelope::error(e.to_string()));
+    }
+
+    match state.hive.resolve_config(&config) {
+        Ok(hive_config) => Json(ApiEnvelope::success(UpdateEntityConfigResponse {
+            entity_id,
+            provider_config: provider_config_from_hive_config(&hive_config),
         })),
         Err(e) => Json(ApiEnvelope::error(e)),
     }
@@ -286,3 +395,231 @@ pub async fn discover_models(
         Err(e) => Json(ApiEnvelope::error(e)),
     }
 }
+
+// ---------------------------------------------------------------------------
+// POST /v1/runtime/sessions
+// ---------------------------------------------------------------------------
+
+pub async fn issue_runtime_session(
+    State(state): State<HiveDaemonState>,
+    Json(body): Json<RuntimeSessionRequest>,
+) -> Json<ApiEnvelope<RuntimeSessionLease>> {
+    match state.identity_manager.list_agents() {
+        Ok(agents) => {
+            let Some(agent) = agents.into_iter().find(|agent| agent.id == body.entity_id) else {
+                return Json(ApiEnvelope::error(format!(
+                    "Entity {} not found",
+                    body.entity_id
+                )));
+            };
+
+            match state.runtime_control.lock() {
+                Ok(mut control) => Json(ApiEnvelope::success(control.issue_session(
+                    body,
+                    Some(agent.name),
+                    Some(state.hive_url.clone()),
+                ))),
+                Err(e) => Json(ApiEnvelope::error(e.to_string())),
+            }
+        }
+        Err(e) => Json(ApiEnvelope::error(e)),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// POST /v1/runtime/register
+// ---------------------------------------------------------------------------
+
+pub async fn register_runtime(
+    State(state): State<HiveDaemonState>,
+    Json(body): Json<RuntimeRegistrationRequest>,
+) -> Json<ApiEnvelope<RuntimeSessionStatus>> {
+    match state.runtime_control.lock() {
+        Ok(mut control) => match control.register_runtime(body) {
+            Ok(status) => Json(ApiEnvelope::success(status)),
+            Err(e) => Json(ApiEnvelope::error(e)),
+        },
+        Err(e) => Json(ApiEnvelope::error(e.to_string())),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// POST /v1/runtime/heartbeat
+// ---------------------------------------------------------------------------
+
+pub async fn record_runtime_heartbeat(
+    State(state): State<HiveDaemonState>,
+    Json(body): Json<RuntimeHeartbeatRequest>,
+) -> Json<ApiEnvelope<RuntimeHeartbeatResponse>> {
+    match state.runtime_control.lock() {
+        Ok(mut control) => match control.record_heartbeat(body) {
+            Ok(response) => Json(ApiEnvelope::success(response)),
+            Err(e) => Json(ApiEnvelope::error(e)),
+        },
+        Err(e) => Json(ApiEnvelope::error(e.to_string())),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// GET /v1/runtime/sessions/:lease_id
+// ---------------------------------------------------------------------------
+
+pub async fn get_runtime_session(
+    State(state): State<HiveDaemonState>,
+    Path(lease_id): Path<String>,
+) -> Json<ApiEnvelope<RuntimeSessionStatus>> {
+    match state.runtime_control.lock() {
+        Ok(control) => match control.session_status(&lease_id) {
+            Some(status) => Json(ApiEnvelope::success(status)),
+            None => Json(ApiEnvelope::error(format!(
+                "Runtime lease {} not found",
+                lease_id
+            ))),
+        },
+        Err(e) => Json(ApiEnvelope::error(e.to_string())),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// GET/POST /v1/entities/:id/assignments
+// ---------------------------------------------------------------------------
+
+pub async fn get_skill_assignments(
+    State(state): State<HiveDaemonState>,
+    Path(entity_id): Path<String>,
+) -> Json<ApiEnvelope<SkillAssignmentsResponse>> {
+    match state.runtime_control.lock() {
+        Ok(control) => Json(ApiEnvelope::success(control.assignments(&entity_id))),
+        Err(e) => Json(ApiEnvelope::error(e.to_string())),
+    }
+}
+
+pub async fn set_skill_assignments(
+    State(state): State<HiveDaemonState>,
+    Path(entity_id): Path<String>,
+    Json(body): Json<SetSkillAssignmentsRequest>,
+) -> Json<ApiEnvelope<SkillAssignmentsResponse>> {
+    match state.runtime_control.lock() {
+        Ok(mut control) => Json(ApiEnvelope::success(
+            control.set_assignments(&entity_id, body),
+        )),
+        Err(e) => Json(ApiEnvelope::error(e.to_string())),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// GET/POST /v1/entities/:id/forge-approvals
+// ---------------------------------------------------------------------------
+
+pub async fn get_forge_approval_jobs(
+    State(state): State<HiveDaemonState>,
+    Path(entity_id): Path<String>,
+) -> Json<ApiEnvelope<ForgeApprovalJobsResponse>> {
+    match state.runtime_control.lock() {
+        Ok(control) => Json(ApiEnvelope::success(control.forge_jobs(&entity_id))),
+        Err(e) => Json(ApiEnvelope::error(e.to_string())),
+    }
+}
+
+pub async fn create_forge_approval_job(
+    State(state): State<HiveDaemonState>,
+    Path(entity_id): Path<String>,
+    Json(body): Json<CreateForgeApprovalJobRequest>,
+) -> Json<ApiEnvelope<hive_core::ForgeApprovalJob>> {
+    match state.runtime_control.lock() {
+        Ok(mut control) => Json(ApiEnvelope::success(
+            control.create_forge_job(&entity_id, body),
+        )),
+        Err(e) => Json(ApiEnvelope::error(e.to_string())),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// POST /v1/runtime/outbox/sync
+// ---------------------------------------------------------------------------
+
+pub async fn sync_runtime_outbox(
+    State(state): State<HiveDaemonState>,
+    Json(body): Json<OutboxSyncRequest>,
+) -> Json<ApiEnvelope<OutboxSyncResponse>> {
+    match state.runtime_control.lock() {
+        Ok(mut control) => match control.sync_outbox(body) {
+            Ok(response) => Json(ApiEnvelope::success(response)),
+            Err(e) => Json(ApiEnvelope::error(e)),
+        },
+        Err(e) => Json(ApiEnvelope::error(e.to_string())),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::runtime_registry::RuntimeControlPlane;
+    use abigail_core::{AppConfig, SecretsVault};
+    use abigail_hive::Hive;
+    use abigail_identity::IdentityManager;
+    use std::sync::{Arc, Mutex};
+
+    fn build_state() -> (HiveDaemonState, String) {
+        let data_root = AppConfig::default_paths()
+            .data_dir
+            .join("test-hive-daemon-routes")
+            .join(uuid::Uuid::new_v4().to_string());
+        std::fs::create_dir_all(&data_root).expect("create test data root");
+
+        let identity_manager = Arc::new(IdentityManager::new(data_root.clone()).expect("identity"));
+        let (entity_id, _) = identity_manager
+            .create_agent("Route Test")
+            .expect("create entity");
+
+        let entity_secrets_dir = data_root.join("entity_secrets");
+        let hive_secrets_dir = data_root.join("hive_secrets");
+        std::fs::create_dir_all(&entity_secrets_dir).expect("entity_secrets_dir");
+        std::fs::create_dir_all(&hive_secrets_dir).expect("hive_secrets_dir");
+
+        let entity_secrets = Arc::new(Mutex::new(SecretsVault::new(entity_secrets_dir)));
+        let hive_secrets = Arc::new(Mutex::new(SecretsVault::new(hive_secrets_dir)));
+        let hive = Arc::new(Hive::new(entity_secrets, hive_secrets.clone()));
+
+        (
+            HiveDaemonState {
+                identity_manager,
+                hive,
+                hive_secrets,
+                hive_url: "http://127.0.0.1:3141".to_string(),
+                runtime_control: Arc::new(Mutex::new(RuntimeControlPlane::default())),
+            },
+            entity_id,
+        )
+    }
+
+    #[tokio::test]
+    async fn update_entity_config_persists_provider_preferences() {
+        let (state, entity_id) = build_state();
+        let resp = update_entity_config(
+            State(state.clone()),
+            Path(entity_id.clone()),
+            Json(UpdateEntityConfigRequest {
+                active_provider_preference: Some("openai".to_string()),
+                ego_model: None,
+                local_llm_base_url: Some("http://localhost:11434".to_string()),
+                routing_mode: Some("cli_orchestrator".to_string()),
+                cli_permission_mode: Some("interactive".to_string()),
+            }),
+        )
+        .await
+        .0;
+
+        assert!(resp.ok, "response error: {:?}", resp.error);
+        let config = state
+            .identity_manager
+            .load_agent(&entity_id)
+            .expect("load updated config");
+        assert_eq!(config.active_provider_preference.as_deref(), Some("openai"));
+        assert_eq!(
+            config.local_llm_base_url.as_deref(),
+            Some("http://localhost:11434")
+        );
+        assert_eq!(format!("{:?}", config.routing_mode), "CliOrchestrator");
+    }
+}
diff --git a/crates/hive-daemon/src/runtime_registry.rs b/crates/hive-daemon/src/runtime_registry.rs
new file mode 100644
index 00000000..ca100034
--- /dev/null
+++ b/crates/hive-daemon/src/runtime_registry.rs
@@ -0,0 +1,288 @@
+use hive_core::{
+    CreateForgeApprovalJobRequest, ForgeApprovalJob, ForgeApprovalJobsResponse, OutboxSyncRequest,
+    OutboxSyncResponse, RuntimeHeartbeatRequest, RuntimeHeartbeatResponse, RuntimeRegistration,
+    RuntimeRegistrationRequest, RuntimeSessionLease, RuntimeSessionRequest, RuntimeSessionStatus,
+    SetSkillAssignmentsRequest, SkillAssignmentsResponse,
+};
+use std::collections::HashMap;
+
+#[derive(Default)]
+pub struct RuntimeControlPlane {
+    sessions: HashMap<String, RuntimeSessionStatus>,
+    assignments: HashMap<String, SkillAssignmentsResponse>,
+    forge_jobs: HashMap<String, ForgeApprovalJobsResponse>,
+    synced_outbox: HashMap<String, Vec<hive_core::EntityOutboxRecord>>,
+}
+
+impl RuntimeControlPlane {
+    pub fn issue_session(
+        &mut self,
+        request: RuntimeSessionRequest,
+        entity_name: Option<String>,
+        hive_url: Option<String>,
+    ) -> RuntimeSessionLease {
+        let runtime_id = request
+            .runtime_id
+            .unwrap_or_else(|| format!("runtime-{}", uuid::Uuid::new_v4()));
+        let lease = RuntimeSessionLease {
+            lease_id: uuid::Uuid::new_v4().to_string(),
+            entity_id: request.entity_id,
+            runtime_id,
+            entity_name,
+            hive_url,
+            issued_at_utc: chrono::Utc::now().to_rfc3339(),
+            expires_at_utc: None,
+            offline_until_close: true,
+            lease_scope: "runtime_session".to_string(),
+        };
+        self.sessions.insert(
+            lease.lease_id.clone(),
+            RuntimeSessionStatus {
+                lease: lease.clone(),
+                registration: None,
+                connected: false,
+                outbox_depth: 0,
+                outbox_oldest_at_utc: None,
+            },
+        );
+        lease
+    }
+
+    pub fn register_runtime(
+        &mut self,
+        request: RuntimeRegistrationRequest,
+    ) -> Result<RuntimeSessionStatus, String> {
+        let Some(session) = self.sessions.get_mut(&request.lease_id) else {
+            return Err(format!("Unknown runtime lease '{}'", request.lease_id));
+        };
+        if session.lease.runtime_id != request.runtime_id {
+            return Err(format!(
+                "Runtime '{}' does not match lease '{}'",
+                request.runtime_id, request.lease_id
+            ));
+        }
+
+        let now = chrono::Utc::now().to_rfc3339();
+        session.registration = Some(RuntimeRegistration {
+            lease_id: request.lease_id,
+            runtime_id: request.runtime_id,
+            entity_id: session.lease.entity_id.clone(),
+            local_url: request.local_url,
+            process_id: request.process_id,
+            registered_at_utc: now.clone(),
+            last_seen_at_utc: now,
+            state: "active".to_string(),
+        });
+        session.connected = true;
+        Ok(session.clone())
+    }
+
+    pub fn record_heartbeat(
+        &mut self,
+        request: RuntimeHeartbeatRequest,
+    ) -> Result<RuntimeHeartbeatResponse, String> {
+        let Some(session) = self.sessions.get_mut(&request.lease_id) else {
+            return Err(format!("Unknown runtime lease '{}'", request.lease_id));
+        };
+        if session.lease.runtime_id != request.runtime_id {
+            return Err(format!(
+                "Runtime '{}' does not match lease '{}'",
+                request.runtime_id, request.lease_id
+            ));
+        }
+
+        let now = chrono::Utc::now().to_rfc3339();
+        if let Some(registration) = session.registration.as_mut() {
+            if let Some(local_url) = request.local_url {
+                registration.local_url = local_url;
+            }
+            registration.last_seen_at_utc = now.clone();
+            registration.state = "active".to_string();
+        }
+        session.connected = true;
+        session.outbox_depth = request.outbox_depth;
+        session.outbox_oldest_at_utc = request.outbox_oldest_at_utc;
+
+        Ok(RuntimeHeartbeatResponse {
+            accepted: true,
+            server_time_utc: now,
+        })
+    }
+
+    pub fn session_status(&self, lease_id: &str) -> Option<RuntimeSessionStatus> {
+        self.sessions.get(lease_id).cloned()
+    }
+
+    pub fn assignments(&self, entity_id: &str) -> SkillAssignmentsResponse {
+        self.assignments
+            .get(entity_id)
+            .cloned()
+            .unwrap_or_else(|| SkillAssignmentsResponse {
+                entity_id: entity_id.to_string(),
+                assignments: Vec::new(),
+            })
+    }
+
+    pub fn set_assignments(
+        &mut self,
+        entity_id: &str,
+        request: SetSkillAssignmentsRequest,
+    ) -> SkillAssignmentsResponse {
+        let response = SkillAssignmentsResponse {
+            entity_id: entity_id.to_string(),
+            assignments: request.assignments,
+        };
+        self.assignments
+            .insert(entity_id.to_string(), response.clone());
+        response
+    }
+
+    pub fn forge_jobs(&self, entity_id: &str) -> ForgeApprovalJobsResponse {
+        self.forge_jobs
+            .get(entity_id)
+            .cloned()
+            .unwrap_or_else(|| ForgeApprovalJobsResponse {
+                entity_id: entity_id.to_string(),
+                jobs: Vec::new(),
+            })
+    }
+
+    pub fn create_forge_job(
+        &mut self,
+        entity_id: &str,
+        request: CreateForgeApprovalJobRequest,
+    ) -> ForgeApprovalJob {
+        let job = ForgeApprovalJob {
+            job_id: uuid::Uuid::new_v4().to_string(),
+            entity_id: entity_id.to_string(),
+            skill_id: request.skill_id,
+            code_path: request.code_path,
+            markdown_path: request.markdown_path,
+            approved_at_utc: chrono::Utc::now().to_rfc3339(),
+            status: "approved".to_string(),
+            correlation_id: request.correlation_id,
+        };
+        let entry = self
+            .forge_jobs
+            .entry(entity_id.to_string())
+            .or_insert_with(|| ForgeApprovalJobsResponse {
+                entity_id: entity_id.to_string(),
+                jobs: Vec::new(),
+            });
+        entry.jobs.push(job.clone());
+        job
+    }
+
+    pub fn sync_outbox(
+        &mut self,
+        request: OutboxSyncRequest,
+    ) -> Result<OutboxSyncResponse, String> {
+        let Some(session) = self.sessions.get_mut(&request.lease_id) else {
+            return Err(format!("Unknown runtime lease '{}'", request.lease_id));
+        };
+        if session.lease.runtime_id != request.runtime_id {
+            return Err(format!(
+                "Runtime '{}' does not match lease '{}'",
+                request.runtime_id, request.lease_id
+            ));
+        }
+
+        let accepted_record_ids = request
+            .records
+            .iter()
+            .map(|record| record.record_id.clone())
+            .collect::<Vec<_>>();
+        self.synced_outbox
+            .entry(session.lease.entity_id.clone())
+            .or_default()
+            .extend(request.records);
+
+        session.outbox_depth = 0;
+        session.outbox_oldest_at_utc = None;
+
+        Ok(OutboxSyncResponse {
+            accepted_record_ids,
+            pending_records: 0,
+            server_time_utc: chrono::Utc::now().to_rfc3339(),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::RuntimeControlPlane;
+    use hive_core::{
+        OutboxSyncRequest, RuntimeHeartbeatRequest, RuntimeRegistrationRequest,
+        RuntimeSessionRequest, SkillAssignment,
+    };
+
+    #[test]
+    fn runtime_session_registers_and_accepts_outbox_sync() {
+        let mut control = RuntimeControlPlane::default();
+        let lease = control.issue_session(
+            RuntimeSessionRequest {
+                entity_id: "entity-1".to_string(),
+                runtime_id: Some("runtime-1".to_string()),
+            },
+            Some("Entity One".to_string()),
+            Some("http://127.0.0.1:3141".to_string()),
+        );
+
+        let status = control
+            .register_runtime(RuntimeRegistrationRequest {
+                lease_id: lease.lease_id.clone(),
+                runtime_id: lease.runtime_id.clone(),
+                local_url: "http://127.0.0.1:9001".to_string(),
+                process_id: Some(42),
+            })
+            .unwrap();
+        assert!(status.connected);
+
+        let heartbeat = control
+            .record_heartbeat(RuntimeHeartbeatRequest {
+                lease_id: lease.lease_id.clone(),
+                runtime_id: lease.runtime_id.clone(),
+                local_url: None,
+                outbox_depth: 2,
+                outbox_oldest_at_utc: Some("2026-04-12T12:00:00Z".to_string()),
+            })
+            .unwrap();
+        assert!(heartbeat.accepted);
+
+        let sync = control
+            .sync_outbox(OutboxSyncRequest {
+                lease_id: lease.lease_id.clone(),
+                runtime_id: lease.runtime_id.clone(),
+                records: vec![hive_core::EntityOutboxRecord {
+                    record_id: "record-1".to_string(),
+                    entity_id: "entity-1".to_string(),
+                    kind: "chat_user_turn".to_string(),
+                    created_at_utc: "2026-04-12T12:00:00Z".to_string(),
+                    payload: serde_json::json!({ "message": "hello" }),
+                }],
+            })
+            .unwrap();
+        assert_eq!(sync.accepted_record_ids, vec!["record-1".to_string()]);
+    }
+
+    #[test]
+    fn assignments_replace_existing_set() {
+        let mut control = RuntimeControlPlane::default();
+        let response = control.set_assignments(
+            "entity-1",
+            hive_core::SetSkillAssignmentsRequest {
+                assignments: vec![SkillAssignment {
+                    assignment_id: "assign-1".to_string(),
+                    entity_id: "entity-1".to_string(),
+                    skill_id: "dynamic.calendar".to_string(),
+                    version: Some("1.0.0".to_string()),
+                    manifest_path: None,
+                    assigned_at_utc: "2026-04-12T12:00:00Z".to_string(),
+                    status: "assigned".to_string(),
+                }],
+            },
+        );
+        assert_eq!(response.assignments.len(), 1);
+        assert_eq!(control.assignments("entity-1").assignments.len(), 1);
+    }
+}
diff --git a/crates/hive-daemon/src/state.rs b/crates/hive-daemon/src/state.rs
index f44a4f5e..f3f3588c 100644
--- a/crates/hive-daemon/src/state.rs
+++ b/crates/hive-daemon/src/state.rs
@@ -1,5 +1,6 @@
 //! Hive daemon shared state.
 
+use crate::runtime_registry::RuntimeControlPlane;
 use abigail_core::SecretsVault;
 use abigail_hive::Hive;
 use abigail_identity::IdentityManager;
@@ -12,4 +13,8 @@ pub struct HiveDaemonState {
     pub hive: Arc<Hive>,
     /// Hive-level secrets vault (shared across all agents).
     pub hive_secrets: Arc<Mutex<SecretsVault>>,
+    /// Current externally reachable Hive URL for runtime leases.
+    pub hive_url: String,
+    /// In-memory runtime supervision and assignment control plane.
+    pub runtime_control: Arc<Mutex<RuntimeControlPlane>>,
 }
diff --git a/crates/hive-daemon/tests/integration.rs b/crates/hive-daemon/tests/integration.rs
index 9d28f847..ee2c119d 100644
--- a/crates/hive-daemon/tests/integration.rs
+++ b/crates/hive-daemon/tests/integration.rs
@@ -1,14 +1,17 @@
 //! Hive-daemon integration tests — exercises the real binary over HTTP.
 //!
-//! Requires `cargo build -p hive-daemon` before running.
-//! Marked `#[ignore]` so they don't slow down `cargo test --workspace`;
-//! run explicitly with `cargo test -p hive-daemon --test integration -- --ignored`.
+//! These tests require the `hive-daemon` binary to be pre-built.
+//! Set `ABIGAIL_DAEMON_INTEGRATION=1` to enable (the CI stability job does this).
 
 use daemon_test_harness::HiveDaemonHandle;
 use std::time::Duration;
 
 const TIMEOUT: Duration = Duration::from_secs(30);
 
+fn should_run() -> bool {
+    std::env::var("ABIGAIL_DAEMON_INTEGRATION").is_ok()
+}
+
 async fn hive() -> HiveDaemonHandle {
     HiveDaemonHandle::start(TIMEOUT)
         .await
@@ -16,8 +19,10 @@ async fn hive() -> HiveDaemonHandle {
 }
 
 #[tokio::test]
-#[ignore]
 async fn health_returns_200() {
+    if !should_run() {
+        return;
+    }
     let hive = hive().await;
     let resp = reqwest::get(format!("{}/health", hive.url()))
         .await
@@ -26,12 +31,13 @@ async fn health_returns_200() {
 }
 
 #[tokio::test]
-#[ignore]
 async fn entity_lifecycle() {
+    if !should_run() {
+        return;
+    }
     let hive = hive().await;
     let client = reqwest::Client::new();
 
-    // Create entity
     let resp = client
         .post(format!("{}/v1/entities", hive.url()))
         .json(&serde_json::json!({ "name": "test-agent" }))
@@ -43,7 +49,6 @@ async fn entity_lifecycle() {
     assert!(body["ok"].as_bool().unwrap_or(false));
     let entity_id = body["data"]["id"].as_str().expect("entity id");
 
-    // List entities
     let resp = client
         .get(format!("{}/v1/entities", hive.url()))
         .send()
@@ -56,7 +61,6 @@ async fn entity_lifecycle() {
         "created entity should appear in list"
     );
 
-    // Get single entity
     let resp = client
         .get(format!("{}/v1/entities/{}", hive.url(), entity_id))
         .send()
@@ -68,12 +72,13 @@ async fn entity_lifecycle() {
 }
 
 #[tokio::test]
-#[ignore]
 async fn secrets_crud() {
+    if !should_run() {
+        return;
+    }
     let hive = hive().await;
     let client = reqwest::Client::new();
 
-    // Store a secret
     let resp = client
         .post(format!("{}/v1/secrets", hive.url()))
         .json(&serde_json::json!({ "key": "test_key", "value": "test_value" }))
@@ -82,7 +87,6 @@ async fn secrets_crud() {
         .unwrap();
     assert!(resp.status().is_success());
 
-    // Get the secret
     let resp = client
         .get(format!("{}/v1/secrets/test_key", hive.url()))
         .send()
@@ -92,14 +96,13 @@ async fn secrets_crud() {
     assert!(body["ok"].as_bool().unwrap_or(false));
     assert_eq!(body["data"]["value"].as_str(), Some("test_value"));
 
-    // List secrets
     let resp = client
         .get(format!("{}/v1/secrets/list", hive.url()))
         .send()
         .await
         .unwrap();
     let body: serde_json::Value = resp.json().await.unwrap();
-    let keys = body["data"].as_array().expect("secrets list");
+    let keys = body["data"]["keys"].as_array().expect("secrets list");
     assert!(
         keys.iter().any(|k| k.as_str() == Some("test_key")),
         "stored key should appear in list"
@@ -107,12 +110,13 @@ async fn secrets_crud() {
 }
 
 #[tokio::test]
-#[ignore]
 async fn provider_config() {
+    if !should_run() {
+        return;
+    }
     let hive = hive().await;
     let client = reqwest::Client::new();
 
-    // Create entity first
     let resp = client
         .post(format!("{}/v1/entities", hive.url()))
         .json(&serde_json::json!({ "name": "config-test" }))
@@ -122,7 +126,6 @@ async fn provider_config() {
     let body: serde_json::Value = resp.json().await.unwrap();
     let entity_id = body["data"]["id"].as_str().expect("entity id");
 
-    // Get provider config
     let resp = client
         .get(format!(
             "{}/v1/entities/{}/provider-config",
diff --git a/crates/soul-forge/src/lib.rs b/crates/soul-forge/src/lib.rs
index 0e230726..fc4c42a2 100644
--- a/crates/soul-forge/src/lib.rs
+++ b/crates/soul-forge/src/lib.rs
@@ -162,6 +162,27 @@ impl Default for SoulForgeEngine {
     }
 }
 
+/// Soul output for the Quick Start path: perfectly balanced weights with no
+/// trial choices. Deterministic, so re-running quick start yields the same
+/// soul hash.
+pub fn quickstart_output() -> SoulOutput {
+    let weights = TriangleWeights {
+        deontology: 0.25,
+        teleology: 0.25,
+        areteology: 0.25,
+        welfare: 0.25,
+    };
+    let soul_hash = compute_soul_hash(&[], &weights);
+    let sigil = generate_sigil(&weights);
+    SoulOutput {
+        archetype: "The Balanced".to_string(),
+        weights,
+        soul_hash,
+        sigil,
+        choices_made: Vec::new(),
+    }
+}
+
 /// Derive an archetype name from the ethical weights.
 fn derive_archetype(weights: &TriangleWeights) -> String {
     let dominant = weights.dominant();
@@ -412,7 +433,7 @@ fn built_in_scenarios() -> Vec<ForgeScenario> {
 }
 
 /// Persistent stream topology used by the DevOps Forge worker.
-pub const FORGE_STREAM: &str = "entity";
+pub const FORGE_STREAM: &str = abigail_streaming::BUS_STREAM;
 pub const FORGE_REQUEST_TOPIC: &str = "topic.skill.forge.request";
 pub const FORGE_RESPONSE_TOPIC: &str = "topic.skill.forge.response";
 pub const FORGE_WORKER_GROUP: &str = "skill-worker.forge";
diff --git a/dev-harness/app.js b/dev-harness/app.js
new file mode 100644
index 00000000..470a614b
--- /dev/null
+++ b/dev-harness/app.js
@@ -0,0 +1,193 @@
+const storageKey = "abigail-split-stack-harness";
+
+const elements = {
+  hiveUrl: document.querySelector("#hive-url"),
+  runtimeUrl: document.querySelector("#runtime-url"),
+  entityId: document.querySelector("#entity-id"),
+  sessionId: document.querySelector("#session-id"),
+  hiveStatus: document.querySelector("#hive-status"),
+  runtimeStatus: document.querySelector("#runtime-status"),
+  sessionStatus: document.querySelector("#session-status"),
+  outboxStatus: document.querySelector("#outbox-status"),
+  skillAcks: document.querySelector("#skill-acks"),
+  chatResponse: document.querySelector("#chat-response"),
+  entityList: document.querySelector("#entity-list"),
+  chatMessage: document.querySelector("#chat-message"),
+  hiveHealthPill: document.querySelector("#hive-health-pill"),
+  runtimeHealthPill: document.querySelector("#runtime-health-pill"),
+  chatPill: document.querySelector("#chat-pill"),
+  ackPill: document.querySelector("#ack-pill"),
+};
+
+function setJson(target, value) {
+  target.textContent = JSON.stringify(value, null, 2);
+}
+
+function setPill(target, label, variant = "muted") {
+  target.textContent = label;
+  target.className = `pill pill-${variant}`;
+}
+
+function sessionSnapshot() {
+  return {
+    hiveUrl: elements.hiveUrl.value.trim(),
+    runtimeUrl: elements.runtimeUrl.value.trim(),
+    entityId: elements.entityId.value.trim(),
+    sessionId: elements.sessionId.value.trim(),
+  };
+}
+
+function persist() {
+  localStorage.setItem(storageKey, JSON.stringify(sessionSnapshot()));
+}
+
+function loadSaved() {
+  try {
+    return JSON.parse(localStorage.getItem(storageKey) || "{}");
+  } catch {
+    return {};
+  }
+}
+
+async function fetchJson(url, options = undefined) {
+  const response = await fetch(url, options);
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text, status: response.status };
+  }
+}
+
+async function probeHealth(baseUrl) {
+  const response = await fetch(`${baseUrl}/health`);
+  return response.ok;
+}
+
+async function refreshHive() {
+  const hiveUrl = elements.hiveUrl.value.trim();
+  setPill(elements.hiveHealthPill, "Checking", "warn");
+  try {
+    const healthy = await probeHealth(hiveUrl);
+    setPill(elements.hiveHealthPill, healthy ? "Healthy" : "Unreachable", healthy ? "ok" : "warn");
+
+    const status = await fetchJson(`${hiveUrl}/v1/status`);
+    const entities = await fetchJson(`${hiveUrl}/v1/entities`);
+    setJson(elements.hiveStatus, { status, entities });
+    renderEntities(entities?.data || []);
+  } catch (error) {
+    renderEntities([]);
+    setPill(elements.hiveHealthPill, "Error", "warn");
+    setJson(elements.hiveStatus, { error: String(error) });
+  }
+}
+
+function renderEntities(entities) {
+  elements.entityList.innerHTML = "";
+  for (const entity of entities) {
+    const item = document.createElement("li");
+    const button = document.createElement("button");
+    button.type = "button";
+    button.textContent = `${entity.name} (${entity.id})`;
+    button.addEventListener("click", () => {
+      elements.entityId.value = entity.id;
+      persist();
+    });
+    item.appendChild(button);
+    elements.entityList.appendChild(item);
+  }
+}
+
+async function refreshRuntime() {
+  const runtimeUrl = elements.runtimeUrl.value.trim();
+  setPill(elements.runtimeHealthPill, "Checking", "warn");
+  try {
+    const healthy = await probeHealth(runtimeUrl);
+    setPill(elements.runtimeHealthPill, healthy ? "Healthy" : "Unreachable", healthy ? "ok" : "warn");
+
+    const status = await fetchJson(`${runtimeUrl}/v1/status`);
+    const session = await fetchJson(`${runtimeUrl}/v1/session/status`);
+    const outbox = await fetchJson(`${runtimeUrl}/v1/outbox/status`);
+    const acknowledgements = await fetchJson(`${runtimeUrl}/v1/skills/acks`);
+
+    setJson(elements.runtimeStatus, status);
+    setJson(elements.sessionStatus, session);
+    setJson(elements.outboxStatus, outbox);
+    setJson(elements.skillAcks, acknowledgements);
+    setPill(elements.ackPill, acknowledgements?.ok ? "Loaded" : "Unavailable", acknowledgements?.ok ? "ok" : "warn");
+
+    const inferredEntityId = session?.data?.lease?.entity_id;
+    if (inferredEntityId && !elements.entityId.value.trim()) {
+      elements.entityId.value = inferredEntityId;
+    }
+  } catch (error) {
+    setPill(elements.runtimeHealthPill, "Error", "warn");
+    setPill(elements.ackPill, "Error", "warn");
+    setJson(elements.runtimeStatus, { error: String(error) });
+    setJson(elements.sessionStatus, { error: String(error) });
+    setJson(elements.outboxStatus, { error: String(error) });
+    setJson(elements.skillAcks, { error: String(error) });
+  }
+}
+
+async function sendChat() {
+  const runtimeUrl = elements.runtimeUrl.value.trim();
+  const message = elements.chatMessage.value.trim();
+  if (!message) {
+    setPill(elements.chatPill, "Message required", "warn");
+    return;
+  }
+
+  const sessionId = elements.sessionId.value.trim() || `browser-harness-${Date.now()}`;
+  elements.sessionId.value = sessionId;
+  persist();
+  setPill(elements.chatPill, "Sending", "warn");
+
+  try {
+    const response = await fetchJson(`${runtimeUrl}/v1/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        message,
+        session_id: sessionId,
+      }),
+    });
+
+    setJson(elements.chatResponse, response);
+    setPill(elements.chatPill, response?.ok ? "Delivered" : "Failed", response?.ok ? "ok" : "warn");
+  } catch (error) {
+    setJson(elements.chatResponse, { error: String(error) });
+    setPill(elements.chatPill, "Error", "warn");
+  }
+}
+
+async function refreshAll() {
+  persist();
+  await Promise.allSettled([refreshHive(), refreshRuntime()]);
+}
+
+async function bootstrap() {
+  const config = await fetchJson("./config.json");
+  const saved = loadSaved();
+
+  elements.hiveUrl.value = saved.hiveUrl || config.hiveUrl || "http://127.0.0.1:43141";
+  elements.runtimeUrl.value = saved.runtimeUrl || config.runtimeUrl || "http://127.0.0.1:43142";
+  elements.entityId.value = saved.entityId || "";
+  elements.sessionId.value = saved.sessionId || `browser-harness-${Date.now()}`;
+
+  document.querySelector("#refresh-all").addEventListener("click", refreshAll);
+  document.querySelector("#load-entities").addEventListener("click", refreshHive);
+  document.querySelector("#load-runtime").addEventListener("click", refreshRuntime);
+  document.querySelector("#send-chat").addEventListener("click", sendChat);
+
+  for (const input of [elements.hiveUrl, elements.runtimeUrl, elements.entityId, elements.sessionId]) {
+    input.addEventListener("change", persist);
+  }
+
+  await refreshAll();
+}
+
+bootstrap().catch((error) => {
+  setJson(elements.hiveStatus, { error: String(error) });
+  setPill(elements.hiveHealthPill, "Error", "warn");
+});
diff --git a/dev-harness/index.html b/dev-harness/index.html
new file mode 100644
index 00000000..a9a84f7f
--- /dev/null
+++ b/dev-harness/index.html
@@ -0,0 +1,105 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Abigail Split Stack Harness</title>
+    <link rel="stylesheet" href="./styles.css" />
+  </head>
+  <body>
+    <main class="shell">
+      <section class="hero">
+        <p class="eyebrow">Local Dev Harness</p>
+        <h1>Hive + Entity Runtime</h1>
+        <p class="lede">
+          A local browser fallback for testing the split Abigail stack when desktop shells are blocked by Windows policy.
+        </p>
+      </section>
+
+      <section class="panel panel-wide">
+        <div class="connection-grid">
+          <label>
+            <span>Hive URL</span>
+            <input id="hive-url" type="text" />
+          </label>
+          <label>
+            <span>Runtime URL</span>
+            <input id="runtime-url" type="text" />
+          </label>
+          <label>
+            <span>Entity ID</span>
+            <input id="entity-id" type="text" placeholder="auto-filled from Hive list" />
+          </label>
+          <label>
+            <span>Session ID</span>
+            <input id="session-id" type="text" />
+          </label>
+        </div>
+        <div class="actions">
+          <button id="refresh-all" type="button">Refresh All</button>
+          <button id="load-entities" type="button" class="secondary">Load Entities</button>
+          <button id="load-runtime" type="button" class="secondary">Refresh Runtime</button>
+        </div>
+      </section>
+
+      <section class="dashboard">
+        <article class="panel">
+          <div class="panel-header">
+            <h2>Hive</h2>
+            <span id="hive-health-pill" class="pill pill-muted">Unknown</span>
+          </div>
+          <pre id="hive-status" class="json-view">Waiting for refresh...</pre>
+          <div class="subpanel">
+            <h3>Entities</h3>
+            <ul id="entity-list" class="entity-list"></ul>
+          </div>
+        </article>
+
+        <article class="panel">
+          <div class="panel-header">
+            <h2>Runtime</h2>
+            <span id="runtime-health-pill" class="pill pill-muted">Unknown</span>
+          </div>
+          <pre id="runtime-status" class="json-view">Waiting for refresh...</pre>
+          <div class="runtime-snapshots">
+            <div class="snapshot">
+              <h3>Session</h3>
+              <pre id="session-status" class="json-view compact">Waiting for refresh...</pre>
+            </div>
+            <div class="snapshot">
+              <h3>Outbox</h3>
+              <pre id="outbox-status" class="json-view compact">Waiting for refresh...</pre>
+            </div>
+          </div>
+        </article>
+      </section>
+
+      <section class="dashboard">
+        <article class="panel">
+          <div class="panel-header">
+            <h2>Chat Probe</h2>
+            <span id="chat-pill" class="pill pill-muted">Idle</span>
+          </div>
+          <label>
+            <span>Message</span>
+            <textarea id="chat-message" rows="5" placeholder="Send a message into the active Entity Runtime"></textarea>
+          </label>
+          <div class="actions">
+            <button id="send-chat" type="button">Send Chat</button>
+          </div>
+          <pre id="chat-response" class="json-view compact">No chat sent yet.</pre>
+        </article>
+
+        <article class="panel">
+          <div class="panel-header">
+            <h2>Skill Acknowledgements</h2>
+            <span id="ack-pill" class="pill pill-muted">Idle</span>
+          </div>
+          <pre id="skill-acks" class="json-view">Waiting for refresh...</pre>
+        </article>
+      </section>
+    </main>
+
+    <script type="module" src="./app.js"></script>
+  </body>
+</html>
diff --git a/dev-harness/styles.css b/dev-harness/styles.css
new file mode 100644
index 00000000..95b1b5ac
--- /dev/null
+++ b/dev-harness/styles.css
@@ -0,0 +1,227 @@
+:root {
+  --bg: #f3efe5;
+  --ink: #1f2a24;
+  --muted: #5e6b63;
+  --line: rgba(31, 42, 36, 0.12);
+  --panel: rgba(255, 252, 246, 0.86);
+  --shadow: 0 20px 60px rgba(54, 48, 34, 0.12);
+  --accent: #c4672c;
+  --accent-strong: #8d3f12;
+  --ok: #1f7a59;
+  --warn: #a4660e;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  min-height: 100vh;
+  background:
+    radial-gradient(circle at top left, rgba(196, 103, 44, 0.18), transparent 30%),
+    radial-gradient(circle at top right, rgba(31, 122, 89, 0.14), transparent 28%),
+    linear-gradient(180deg, #f7f1e6 0%, var(--bg) 100%);
+  color: var(--ink);
+  font-family: "Aptos", "Segoe UI Variable", "Segoe UI", sans-serif;
+}
+
+.shell {
+  width: min(1280px, calc(100vw - 32px));
+  margin: 0 auto;
+  padding: 32px 0 48px;
+}
+
+.hero {
+  margin-bottom: 20px;
+}
+
+.eyebrow {
+  margin: 0 0 8px;
+  color: var(--accent-strong);
+  font-size: 0.85rem;
+  font-weight: 700;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+.hero h1 {
+  margin: 0;
+  font-size: clamp(2.4rem, 5vw, 4rem);
+  line-height: 0.95;
+}
+
+.lede {
+  max-width: 760px;
+  margin: 14px 0 0;
+  color: var(--muted);
+  font-size: 1.05rem;
+}
+
+.dashboard {
+  display: grid;
+  gap: 20px;
+  grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
+  margin-top: 20px;
+}
+
+.panel {
+  border: 1px solid var(--line);
+  border-radius: 24px;
+  background: var(--panel);
+  box-shadow: var(--shadow);
+  backdrop-filter: blur(10px);
+  padding: 20px;
+}
+
+.panel-wide {
+  margin-top: 20px;
+}
+
+.panel-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 16px;
+}
+
+.panel h2,
+.panel h3 {
+  margin: 0;
+}
+
+.connection-grid {
+  display: grid;
+  gap: 14px;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+}
+
+label {
+  display: grid;
+  gap: 8px;
+  color: var(--muted);
+  font-size: 0.92rem;
+}
+
+input,
+textarea,
+button {
+  font: inherit;
+}
+
+input,
+textarea {
+  width: 100%;
+  border: 1px solid rgba(31, 42, 36, 0.16);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.82);
+  color: var(--ink);
+  padding: 12px 14px;
+}
+
+textarea {
+  resize: vertical;
+  min-height: 110px;
+}
+
+.actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  margin-top: 14px;
+}
+
+button {
+  border: 0;
+  border-radius: 999px;
+  padding: 11px 16px;
+  cursor: pointer;
+  background: linear-gradient(135deg, var(--accent), var(--accent-strong));
+  color: white;
+  font-weight: 700;
+}
+
+button.secondary {
+  background: rgba(31, 42, 36, 0.08);
+  color: var(--ink);
+}
+
+.pill {
+  border-radius: 999px;
+  padding: 6px 10px;
+  font-size: 0.8rem;
+  font-weight: 700;
+}
+
+.pill-muted {
+  background: rgba(31, 42, 36, 0.08);
+  color: var(--muted);
+}
+
+.pill-ok {
+  background: rgba(31, 122, 89, 0.14);
+  color: var(--ok);
+}
+
+.pill-warn {
+  background: rgba(164, 102, 14, 0.16);
+  color: var(--warn);
+}
+
+.json-view {
+  margin: 0;
+  border-radius: 18px;
+  background: rgba(25, 32, 29, 0.95);
+  color: #e8f0ec;
+  min-height: 170px;
+  max-height: 360px;
+  overflow: auto;
+  padding: 16px;
+  white-space: pre-wrap;
+  word-break: break-word;
+  font-family: "Cascadia Code", "SFMono-Regular", Consolas, monospace;
+  font-size: 0.84rem;
+}
+
+.compact {
+  min-height: 120px;
+}
+
+.subpanel,
+.runtime-snapshots {
+  margin-top: 16px;
+}
+
+.runtime-snapshots {
+  display: grid;
+  gap: 14px;
+}
+
+.entity-list {
+  list-style: none;
+  padding: 0;
+  margin: 12px 0 0;
+  display: grid;
+  gap: 10px;
+}
+
+.entity-list button {
+  width: 100%;
+  justify-content: flex-start;
+  text-align: left;
+  background: rgba(31, 42, 36, 0.08);
+  color: var(--ink);
+}
+
+@media (max-width: 720px) {
+  .shell {
+    width: min(100vw - 20px, 1280px);
+    padding-top: 20px;
+  }
+
+  .panel {
+    border-radius: 18px;
+    padding: 16px;
+  }
+}
diff --git a/documents/ORIONII_ALIGNMENT_PLAN.md b/documents/ORIONII_ALIGNMENT_PLAN.md
new file mode 100644
index 00000000..e93f7b4c
--- /dev/null
+++ b/documents/ORIONII_ALIGNMENT_PLAN.md
@@ -0,0 +1,213 @@
+# OrionII Alignment Plan — Bus-First Backend, Bicameral Pipeline, Sub-Agents
+
+Status: proposal (2026-06-09)
+Reference architecture: `E:\repo\OrionII` (bus spine + Id/Ego/Superego subscribers + SAO seam)
+Scope: Abigail backend (`crates/`), both daemons, skills/connectors/providers, birth & entity management.
+
+---
+
+## 1. Where the two architectures stand today
+
+OrionII's core insight is **"the event bus is the entity"**: every cognitive layer (Id, Ego,
+Superego, governance, egress, journal) is a subscriber on a typed bus; UI commands are thin
+publishers; every envelope carries a `soul_ref` (hash of the charter) and a `correlation_id`
+that traces one user keystroke through the whole pipeline.
+
+Abigail already owns analogs of almost every OrionII part — but they are wired as a
+request/response service with the bus as a side-channel, not as the spine:
+
+| OrionII | Abigail today | Gap |
+|---|---|---|
+| `EventBus` trait, `Topic` enum, `Envelope{soul_ref, correlation_id}` (`bus/mod.rs`) | `StreamBroker` trait + `MemoryBroker`/`IggyBroker` (`abigail-streaming`), ad-hoc string topics (`chat-topic`, `job-events`, `conversation-turns`, `conscience-check`, `ethical-signals`) | No typed topic set, no envelope contract, no soul_ref, correlation only inside `ExecutionTrace` |
+| Id subscriber: personality consult → curated system prompt → `IdReaction` (`id.rs`, `curator.rs`) | Id = fallback LLM provider in `IdEgoRouter`; preprompt enrichment is keyword inference in `MentorChatMonitor` | **Biggest gap.** Id never *colors* the Ego prompt; birth artifacts (MentorProfile, Triangle Ethic, soul.md) are not load-bearing at runtime |
+| Ego subscriber consumes `IdReaction`, publishes `EgoAction` (`ego.rs`) | `route_unified()` called inline from the Axum chat handler (`entity-daemon/routes.rs`) | Chat handler does the work itself; bus observers only watch |
+| Superego subscriber on `EgoAction`, soul_ref recorded (`superego_local.rs`) | `ConscienceConsumer` pattern-matching stub; verdicts logged, never gate anything | Same maturity (both stubs) but Abigail's isn't on the response path |
+| Sub-agents: roadmap only (M3) | `SubagentManager` + SurrealDB `JobQueue` + `subagent_runner` + topic-grouped results | **Abigail is ahead** — needs bus integration and per-subagent providers, not invention |
+| Bus transports: InMemory / NATS JetStream sidecar / Iggy | MemoryBroker / Iggy skeleton | Comparable; do NOT copy the NATS sidecar (heavy for a family desktop) |
+| Birth: idempotent `GET /birth` re-read every launch; hot-swap core on config apply | entity-daemon fetches provider-config from hive-daemon at startup; birth wizard is hive-side | Hive-side edits don't fully propagate; no hot-swap |
+| Charter + blake3 soul_ref; signed BirthCertificate from SAO | Ed25519-signed soul docs + constitution (stronger than OrionII's surrogate!) | Signatures exist but nothing references them per-message |
+| SAO = external governance over HTTP seam | hive-daemon = local control plane over HTTP seam | Architecturally equivalent; hive-daemon plays SAO's role locally. Keep it local-first. |
+
+Conclusion: this is a **rewiring project, not a rewrite**. The crates stay; the chat path,
+topic contract, and the Id/Superego roles change.
+
+---
+
+## 2. Phase 1 — Typed bus contract on top of StreamBroker
+
+New module `abigail-streaming::bus` (or thin crate `abigail-bus`):
+
+```rust
+pub enum Topic {
+    MentorInput,         // chat/UI input → Id stage
+    IdReaction,          // Id's curated prompt + personality signal → Ego
+    EgoDeliberation,     // Ego reasoning/trace tap (audit)
+    EgoAction,           // Ego's committed response → UI, Superego, journal, outbox
+    SuperegoEvaluation,  // conscience verdicts
+    JobEvents,           // queue/sub-agent lifecycle (absorbs "job-events")
+    SkillExecuted,       // tool/skill execution audit (new)
+    MemoryArchive,       // absorbs "conversation-turns"
+    HiveOutbound,        // outbox → hive-daemon sync (egress seam)
+    GovernanceInbound,   // hive → entity: config/assignment/policy refresh
+}
+
+pub struct Envelope {
+    pub topic: Topic,
+    pub entity_id: String,
+    pub occurred_at: DateTime<Utc>,
+    pub soul_ref: String,          // hash of the entity's signed soul/constitution docs
+    pub correlation_id: Uuid,      // = turn_id; reuse ExecutionTrace's turn id
+    pub payload: serde_json::Value,
+}
+```
+
+- Topics are an enum; `Topic::as_str()` maps onto existing StreamBroker stream/topic names so
+  MemoryBroker and the Iggy skeleton keep working unchanged.
+- `soul_ref` comes from the already-signed birth documents (`birth_memory.json` /
+  `constitution.json`) — Abigail can ship the *real* thing OrionII only stubs.
+- Rule to adopt from OrionII's AGENTS.md: **all inter-component communication inside
+  entity-daemon flows through the bus; adding a topic requires a doc note.** Axum handlers
+  become thin publishers.
+- Migrate the five existing string topics onto the enum; delete stragglers.
+
+Durability: skip the NATS sidecar. Either finish `IggyBroker`, or (simpler, recommended)
+add a `SurrealBroker` that journals envelopes into the existing per-entity SurrealDB before
+fanning out via broadcast — one storage engine, restart-replayable, zero sidecar processes.
+
+## 3. Phase 2 — Bicameral chat pipeline as subscribers
+
+Convert the inline chat path in `entity-daemon/routes.rs` into OrionII's staged pipeline:
+
+```
+POST /v1/chat(/stream)  →  publish Envelope(MentorInput)  →  return/attach SSE
+   Id stage (new `id_stage.rs` subscriber):
+     - load IdentityState: MentorProfile + TriangleEthicWeights + soul.md (birth outputs)
+     - memory retrieval via abigail-memory 4-layer search (>> OrionII's keyword RAG)
+     - optional local-LLM personality consult (Id provider, 30s timeout, degraded fallback)
+     - synthesize system prompt = continuity note + personality signal + ethics scaffold + memory context
+     - publish IdReaction
+   Ego stage (new `ego_stage.rs` subscriber):
+     - consume IdReaction → route_unified() with tools/streaming as today
+     - publish EgoAction {response, status: success|degraded|error} + EgoDeliberation (ExecutionTrace)
+   In parallel on EgoAction:
+     - Superego evaluation     - journal/memory archive     - outbox (HiveOutbound)     - SSE/UI delivery
+```
+
+Notes:
+- Non-streaming `POST /v1/chat` awaits its `correlation_id` on `EgoAction` with a timeout —
+  the handler stays thin without breaking the existing API contract.
+- This is where birth finally pays off: MentorProfile and Triangle Ethic weights become the
+  ethics scaffold and personality signal injected on every turn (OrionII's `curator.rs`
+  `EthicsOverlay::scaffold` pattern; Abigail's weights are richer — 4 axes vs 3).
+- Keep OrionII's resilience details: per-stage timeouts, "degraded" status surfaced to the UI,
+  publish-anyway on lock poisoning.
+
+### Superego upgrade (from logging stub to real participant)
+
+1. Keep fast pattern checks (PII/destructive) synchronous as a **pre-delivery gate** on
+   `EgoAction`: `Critical + should_block` holds delivery and publishes a
+   `WaitingForConfirmation`-style event (the agentic loop already has this state machine).
+2. Add async LLM evaluation: the Id (local) provider judges the exchange against the signed
+   constitution; verdicts on `SuperegoEvaluation` with `soul_ref`. Local model keeps this
+   private and free.
+3. Superego also subscribes to `JobEvents` and `SkillExecuted` — sub-agent output and tool use
+   get the same conscience coverage as chat.
+
+## 4. Phase 3 — Sub-agents on the bus
+
+Abigail's queue infrastructure is already ahead of OrionII; align and finish it:
+
+- **Spawn = publish.** `SubagentManager::delegate()` stops being a blocking call from the
+  router; spawning publishes a job with the parent's `correlation_id`, `subagent_runner`
+  consumes, results land on `JobEvents`. Parent turns can await or fire-and-forget
+  (significance scoring already decides SilentLog / SpawnAgentic / FlagMentor).
+- **Implement `SubagentProvider::Custom`** via hive: hive-daemon exposes *named provider
+  profiles* (`GET /v1/providers/profiles/{name}`), so a research sub-agent can run on
+  Perplexity while Ego is Claude — this is the multi-provider advantage made concrete.
+- **Capability-scoped tools:** intersect `SubagentDefinition.capabilities` with the
+  SkillRegistry to build the tool list per sub-agent (today validation checks capabilities
+  but tools are passed by the caller).
+- **Trace inheritance:** child `ExecutionTrace` carries `parent_correlation_id` and depth;
+  enforce a depth limit (2) in the ExecutionGovernor.
+- Delete the deprecated `abigail-router::orchestration` scheduler — the queue won.
+
+## 5. Phase 4 — Skills, connectors, capabilities
+
+- **`SkillExecuted` audit topic:** every `SkillExecutor::execute()` publishes an envelope
+  (skill id, tool, redacted params, outcome). Memory and Superego observe; the UI gets a
+  real activity feed for free.
+- **Wire MCP:** `McpServerDefinition` exists in `AppConfig` but is unwired. Implement an MCP
+  client adapter that registers each MCP server's tools as a dynamic skill (the
+  `DynamicApiSkill` path already exists). This turns the entire MCP ecosystem into Abigail
+  connectors with the existing permission model — by far the highest-leverage connector work.
+- **Live skill assignment:** hive→entity assignment changes publish on `GovernanceInbound`
+  so the SkillRegistry re-provisions without an entity-daemon restart.
+- **Sanitized egress seam:** the outbox sync to hive-daemon is Abigail's egress; adopt
+  OrionII's rule that *only* the outbox subscriber ships data out of entity-daemon, and add
+  key-fragment redaction (`secret|token|key|password`) before records leave — the per-entity
+  scoping rule in CLAUDE.md, enforced at the seam.
+- Drop legacy email transport remnants entirely (Browser-skill fallback is already policy).
+
+## 6. Phase 5 — Provider capabilities for multiple entities
+
+- **Per-role provider config.** OrionII configures Id and Ego models (and temperatures)
+  independently. Extend the hive provider-config payload to
+  `{ id: RoleConfig, ego: RoleConfig, superego: RoleConfig, subagent_profiles: {...} }`,
+  each with provider/model/temperature (optional — reasoning models reject custom temps).
+  `Hive::build_providers` already returns Id+Ego separately; this formalizes it and lets one
+  entity run local-Id + Claude-Ego while another runs local-Id + Gemini-Ego.
+- **Live provider health.** Port OrionII's `ModelCallStatus { role, provider, state:
+  Healthy|Fallback|Degraded }`: the router records the last N call statuses; expose in
+  `GET /v1/status` and the Hive cockpit. ExecutionTrace covers one turn; this covers "is my
+  Ego healthy *right now*."
+- **Hot-swap on provider change.** When hive updates an entity's provider config, publish
+  `GovernanceInbound{kind: "provider.refresh"}`; entity-daemon rebuilds `BuiltProviders` and
+  swaps the router `Arc` (SubagentManager::update_router already anticipates this). No
+  restart, mirrors OrionII's `apply_bundle_config` hot-swap.
+- Deduplicate `EgoProvider` (router) vs `ProviderKind` (hive-core) into one enum in a shared
+  crate while touching this code.
+
+## 7. Phase 6 — Birth & management streamlining
+
+- **Idempotent birth re-read.** Add `GET /v1/entities/{id}/birth` on hive-daemon returning
+  the full runtime identity in one shot: provider config (all roles), skill assignments,
+  policy, personality seed (MentorProfile + Triangle Ethic), soul_ref, and a
+  `BirthCertificate`. entity-daemon calls it on *every* launch (replacing today's
+  provider-config-only fetch), so any hive-side edit takes effect on next start with no
+  rebundling — OrionII's best operational property.
+- **BirthCertificate record.** Abigail already signs soul docs with master + agent Ed25519
+  keys; formalize `{ entity_id, entity_public_key, master_public_key, soul_hash, issued_at,
+  signatures }` as the artifact `soul_ref` points to, persisted in hive storage and verified
+  by entity-daemon at boot (the verify hooks exist in `abigail-core`).
+- **Collapse the wizard's default path.** QuickStart should be one screen — name + template +
+  provider — completing in under a minute; Ethics (Soul Forge) and deep Soul Crystallization
+  become *re-runnable rites* on a living entity rather than birth blockers. The
+  `CrystallizationEngine` doesn't care when it runs; letting families deepen an entity later
+  removes the biggest onboarding friction.
+- **Entity lifecycle on the bus.** Hive-initiated rename/retire/provider-change events flow
+  over `GovernanceInbound` instead of requiring entity-daemon restarts. `Abigail Hive`
+  remains undeletable and is the only writer of these events.
+
+## 8. What NOT to copy from OrionII
+
+- **NATS sidecar process** — operationally heavy for a family desktop; SurrealDB-journaled
+  broker gives durability with zero new processes.
+- **External SAO dependency** — hive-daemon already plays that role locally; privacy and
+  local-first are non-negotiable.
+- **JSON-file persistence** — Abigail's SurrealDB + 4-layer memory is strictly better.
+- **Keyword RAG curator** — use `abigail-memory` vector search in the Id stage instead.
+
+## 9. Suggested sequencing
+
+| Step | Work | Size |
+|---|---|---|
+| 1 | Typed Topic/Envelope + migrate 5 existing topics + soul_ref helper | S |
+| 2 | Id stage subscriber (birth artifacts → system prompt) + Ego stage subscriber; thin chat handlers | M–L |
+| 3 | Superego gate + LLM evaluation on local Id provider | M |
+| 4 | Sub-agents: bus spawn, custom providers via hive profiles, trace inheritance; delete orchestration module | M |
+| 5 | SkillExecuted topic + MCP adapter + live assignments | M (MCP is the big win) |
+| 6 | Per-role provider config + health board + hot-swap | M |
+| 7 | Birth endpoint + BirthCertificate + one-screen QuickStart | M |
+| 8 | SurrealBroker durability (optional, after the contract is stable) | M |
+
+Steps 1–2 are the keystone: once the bus is the spine, every later step is "add a subscriber."
diff --git a/documents/REPO_INVENTORY.md b/documents/REPO_INVENTORY.md
index d70a65b4..3104831d 100644
--- a/documents/REPO_INVENTORY.md
+++ b/documents/REPO_INVENTORY.md
@@ -104,5 +104,5 @@ anchored to the current shipping paths in `tauri-app/Cargo.toml`,
 ## Deferred Sunset Notes
 
 - `tauri-app/src/chat_coordinator.rs` still accepts the deprecated `target` input and normalizes it to `AUTO`. Keep until external callers are audited; remove only after no live caller still sends it.
-- `tauri-app/src/commands/orchestration.rs` still depends on deprecated `OrchestrationScheduler`. Keep until Tauri orchestration finishes moving to `abigail_queue`.
+- Tauri orchestration finished moving to `abigail_queue`: `tauri-app/src/commands/orchestration.rs` and `OrchestrationScheduler` (`crates/abigail-router/src/orchestration.rs`) have been removed. Job management goes through the JobQueue commands (`list_jobs`, `cancel_job`, `list_recurring_templates`).
 - `entity-daemon` and `hive-daemon` keep their ignored integration tests for now. They should be revisited in a dedicated runtime-hardening pass, not deleted blindly.
diff --git a/entity-runtime-app/Cargo.toml b/entity-runtime-app/Cargo.toml
new file mode 100644
index 00000000..c72d31bc
--- /dev/null
+++ b/entity-runtime-app/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "abigail-entity-runtime-app"
+version.workspace = true
+edition.workspace = true
+
+[build-dependencies]
+tauri-build = { version = "2.0", features = [] }
+
+[dependencies]
+daemon-client = { path = "../crates/daemon-client" }
+entity-core = { path = "../crates/entity-core" }
+serde.workspace = true
+serde_json.workspace = true
+tokio.workspace = true
+tauri = { version = "2.10", features = [] }
+tauri-plugin-dialog = "2.0"
+tracing.workspace = true
+tracing-subscriber.workspace = true
+
+[lib]
+name = "abigail_entity_runtime_desktop"
+crate-type = ["staticlib", "cdylib", "rlib"]
diff --git a/entity-runtime-app/build.rs b/entity-runtime-app/build.rs
new file mode 100644
index 00000000..d860e1e6
--- /dev/null
+++ b/entity-runtime-app/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}
diff --git a/entity-runtime-app/capabilities/default.json b/entity-runtime-app/capabilities/default.json
new file mode 100644
index 00000000..71247024
--- /dev/null
+++ b/entity-runtime-app/capabilities/default.json
@@ -0,0 +1,9 @@
+{
+  "identifier": "default",
+  "description": "Default permissions for Abigail Entity Runtime",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "dialog:default"
+  ]
+}
diff --git a/entity-runtime-app/dist/app.js b/entity-runtime-app/dist/app.js
new file mode 100644
index 00000000..d6719dd6
--- /dev/null
+++ b/entity-runtime-app/dist/app.js
@@ -0,0 +1,379 @@
+const invoke =
+  window.__TAURI__?.core?.invoke?.bind(window.__TAURI__.core) ??
+  window.__TAURI_INTERNALS__?.invoke;
+const listen = window.__TAURI__?.event?.listen;
+
+const state = {
+  connection: null,
+  runtimeStatus: null,
+  sessionStatus: null,
+  outboxStatus: null,
+  acknowledgements: null,
+  transcript: [],
+  activeAssistantIndex: null,
+  streaming: false,
+  topicEvents: [],
+  topicEventSource: null,
+};
+
+const elements = {
+  runtimeUrl: document.querySelector("#runtime-url"),
+  entityName: document.querySelector("#entity-name"),
+  runtimePill: document.querySelector("#runtime-pill"),
+  outboxCount: document.querySelector("#outbox-count"),
+  sessionId: document.querySelector("#session-id"),
+  chatMessage: document.querySelector("#chat-message"),
+  chatPill: document.querySelector("#chat-pill"),
+  sessionStatus: document.querySelector("#session-status"),
+  runtimeStatus: document.querySelector("#runtime-status"),
+  acksStatus: document.querySelector("#acks-status"),
+  ackPill: document.querySelector("#ack-pill"),
+  transcript: document.querySelector("#transcript"),
+  busTopic: document.querySelector("#bus-topic"),
+  busPill: document.querySelector("#bus-pill"),
+  topicResults: document.querySelector("#topic-results"),
+};
+
+function setPill(element, label, variant = "idle") {
+  element.textContent = label;
+  element.className = `pill pill-${variant}`;
+}
+
+function renderJson(element, value) {
+  element.textContent = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+
+function ensureSessionId() {
+  if (!elements.sessionId.value.trim()) {
+    elements.sessionId.value = `runtime-${Date.now()}`;
+  }
+  if (!elements.busTopic.value.trim()) {
+    elements.busTopic.value = `chat-${elements.sessionId.value.trim()}`;
+  }
+}
+
+function escapeHtml(value) {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+function sanitizeUrl(rawUrl, allowDataImage = false) {
+  if (!rawUrl) {
+    return null;
+  }
+  const trimmed = rawUrl.trim();
+  if (allowDataImage && /^data:image\/(png|jpeg|jpg|webp|gif);base64,[a-z0-9+/=]+$/i.test(trimmed)) {
+    if (trimmed.length <= 2_000_000) {
+      return trimmed;
+    }
+    return null;
+  }
+  if (/^https?:\/\//i.test(trimmed)) {
+    return trimmed;
+  }
+  return null;
+}
+
+function markdownToHtml(markdown) {
+  const source = markdown || "";
+  const codeBlocks = [];
+  let html = escapeHtml(source).replace(/```([\s\S]*?)```/g, (_, code) => {
+    const token = `@@CODE_BLOCK_${codeBlocks.length}@@`;
+    codeBlocks.push(`<pre><code>${code.trimEnd()}</code></pre>`);
+    return token;
+  });
+
+  html = html.replace(/`([^`]+)`/g, "<code>$1</code>");
+  html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_, alt, url) => {
+    const safeUrl = sanitizeUrl(url, true);
+    if (!safeUrl) {
+      return `<em>Image omitted (unsupported or unsafe URL): ${escapeHtml(url)}</em>`;
+    }
+    return `<img src="${safeUrl}" alt="${alt}" loading="lazy" />`;
+  });
+  html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, text, url) => {
+    const safeUrl = sanitizeUrl(url, false);
+    if (!safeUrl) {
+      return escapeHtml(text);
+    }
+    return `<a href="${safeUrl}" target="_blank" rel="noopener noreferrer">${text}</a>`;
+  });
+
+  const paragraphs = html
+    .split(/\n{2,}/)
+    .map((chunk) => chunk.trim())
+    .filter((chunk) => chunk.length > 0)
+    .map((chunk) => {
+      const withBreaks = chunk.replace(/\n/g, "<br />");
+      return `<p>${withBreaks}</p>`;
+    });
+
+  html = paragraphs.join("");
+  codeBlocks.forEach((block, index) => {
+    html = html.replaceAll(`@@CODE_BLOCK_${index}@@`, block);
+  });
+  return html || "<p></p>";
+}
+
+async function tauriInvoke(command, args = {}) {
+  if (!invoke) {
+    throw new Error("Tauri invoke API is unavailable in this window.");
+  }
+
+  return invoke(command, args);
+}
+
+function renderTranscript() {
+  if (!state.transcript.length) {
+    elements.transcript.innerHTML = `
+      <div class="bubble assistant">
+        <span class="bubble-role">Assistant</span>
+        Runtime transcript will appear here as you chat.
+      </div>
+    `;
+    return;
+  }
+
+  elements.transcript.innerHTML = "";
+  for (const message of state.transcript) {
+    const item = document.createElement("div");
+    item.className = `bubble ${message.role}`;
+    item.innerHTML = `
+      <span class="bubble-role">${message.role}</span>
+      <div class="bubble-body">${markdownToHtml(message.text)}</div>
+    `;
+    elements.transcript.appendChild(item);
+  }
+}
+
+function renderSummary() {
+  elements.runtimeUrl.textContent = state.connection?.runtime_url ?? "Unavailable";
+  elements.entityName.textContent =
+    state.sessionStatus?.lease?.entity_name ??
+    state.runtimeStatus?.name ??
+    state.runtimeStatus?.entity_id ??
+    "Unknown";
+  elements.outboxCount.textContent = String(state.outboxStatus?.queued_records ?? 0);
+  setPill(
+    elements.runtimePill,
+    state.sessionStatus?.connected_to_hive ? "Connected" : "Degraded",
+    state.sessionStatus?.connected_to_hive ? "ok" : "warn",
+  );
+  setPill(
+    elements.ackPill,
+    state.acknowledgements?.acknowledgements?.length
+      ? `${state.acknowledgements.acknowledgements.length} ack(s)`
+      : "No acks",
+    state.acknowledgements?.acknowledgements?.length ? "ok" : "idle",
+  );
+}
+
+async function refreshRuntime() {
+  try {
+    ensureSessionId();
+    const [connection, runtimeStatus, sessionStatus, outboxStatus, acknowledgements] =
+      await Promise.all([
+        tauriInvoke("get_runtime_connection_info"),
+        tauriInvoke("get_runtime_status"),
+        tauriInvoke("get_session_status"),
+        tauriInvoke("get_outbox_status"),
+        tauriInvoke("list_skill_acks"),
+      ]);
+
+    state.connection = connection;
+    state.runtimeStatus = runtimeStatus;
+    state.sessionStatus = sessionStatus;
+    state.outboxStatus = outboxStatus;
+    state.acknowledgements = acknowledgements;
+
+    renderSummary();
+    renderJson(elements.sessionStatus, sessionStatus);
+    renderJson(elements.runtimeStatus, runtimeStatus);
+    renderJson(elements.acksStatus, acknowledgements);
+    await refreshTopicResults();
+  } catch (error) {
+    setPill(elements.runtimePill, "Error", "warn");
+    setPill(elements.ackPill, "Error", "warn");
+    renderJson(elements.sessionStatus, { error: String(error) });
+    renderJson(elements.runtimeStatus, { error: String(error) });
+    renderJson(elements.acksStatus, { error: String(error) });
+    renderJson(elements.topicResults, { error: String(error) });
+  }
+}
+
+function currentTopic() {
+  const topic = elements.busTopic.value.trim();
+  if (topic) {
+    return topic;
+  }
+  ensureSessionId();
+  return `chat-${elements.sessionId.value.trim()}`;
+}
+
+async function refreshTopicResults() {
+  try {
+    const topic = currentTopic();
+    const runtimeUrl = state.connection?.runtime_url ?? (await tauriInvoke("get_runtime_connection_info")).runtime_url;
+    const response = await fetch(
+      `${runtimeUrl}/v1/topics/${encodeURIComponent(topic)}/results?limit=20`,
+      { method: "GET" },
+    );
+    const json = await response.json();
+    renderJson(elements.topicResults, {
+      latest_events: state.topicEvents.slice(-8),
+      topic_results: json,
+    });
+    setPill(elements.busPill, "Ready", "ok");
+  } catch (error) {
+    setPill(elements.busPill, "Topic Error", "warn");
+    renderJson(elements.topicResults, { error: String(error), latest_events: state.topicEvents.slice(-8) });
+  }
+}
+
+function stopTopicWatch() {
+  if (state.topicEventSource) {
+    state.topicEventSource.close();
+    state.topicEventSource = null;
+    setPill(elements.busPill, "Watch Stopped", "idle");
+  }
+}
+
+async function watchTopic() {
+  stopTopicWatch();
+  const topic = currentTopic();
+  const runtimeUrl = state.connection?.runtime_url ?? (await tauriInvoke("get_runtime_connection_info")).runtime_url;
+  const url = `${runtimeUrl}/v1/topics/${encodeURIComponent(topic)}/watch`;
+  const stream = new EventSource(url);
+  state.topicEventSource = stream;
+  setPill(elements.busPill, "Watching", "warn");
+
+  stream.addEventListener("job_event", (event) => {
+    try {
+      const payload = JSON.parse(event.data);
+      state.topicEvents.push(payload);
+      if (state.topicEvents.length > 50) {
+        state.topicEvents = state.topicEvents.slice(-50);
+      }
+      renderJson(elements.topicResults, {
+        latest_events: state.topicEvents.slice(-8),
+      });
+      setPill(elements.busPill, "Live", "ok");
+    } catch (error) {
+      renderJson(elements.topicResults, { error: String(error) });
+    }
+  });
+  stream.addEventListener("error", () => {
+    setPill(elements.busPill, "Watch Error", "warn");
+  });
+}
+
+async function sendChat() {
+  const message = elements.chatMessage.value.trim();
+  if (!message) {
+    elements.chatMessage.focus();
+    return;
+  }
+
+  ensureSessionId();
+  setPill(elements.chatPill, "Streaming", "warn");
+  state.transcript.push({ role: "user", text: message });
+  state.transcript.push({ role: "assistant", text: "" });
+  state.activeAssistantIndex = state.transcript.length - 1;
+  state.streaming = true;
+  elements.chatMessage.value = "";
+  renderTranscript();
+
+  try {
+    await tauriInvoke("send_chat_stream", {
+      message,
+      sessionId: elements.sessionId.value.trim(),
+    });
+    elements.busTopic.value = `chat-${elements.sessionId.value.trim()}`;
+  } catch (error) {
+    if (state.activeAssistantIndex != null) {
+      state.transcript[state.activeAssistantIndex].text = `Error: ${String(error)}`;
+    }
+    state.streaming = false;
+    state.activeAssistantIndex = null;
+    setPill(elements.chatPill, "Failed", "warn");
+    renderTranscript();
+  }
+}
+
+async function cancelChat() {
+  try {
+    const cancelled = await tauriInvoke("cancel_chat_stream");
+    if (cancelled) {
+      setPill(elements.chatPill, "Cancelled", "warn");
+    }
+  } catch (error) {
+    setPill(elements.chatPill, "Cancel Failed", "warn");
+    state.transcript.push({ role: "assistant", text: `Error: ${String(error)}` });
+    renderTranscript();
+  }
+}
+
+async function bindRuntimeStreamEvents() {
+  if (!listen) {
+    return;
+  }
+  await listen("runtime-chat-envelope", async (event) => {
+    const payload = event.payload || {};
+    if (payload.type === "Token") {
+      if (state.activeAssistantIndex == null) {
+        state.transcript.push({ role: "assistant", text: "" });
+        state.activeAssistantIndex = state.transcript.length - 1;
+      }
+      state.transcript[state.activeAssistantIndex].text += payload.token || "";
+      renderTranscript();
+      return;
+    }
+    if (payload.type === "Done") {
+      if (state.activeAssistantIndex == null) {
+        state.transcript.push({ role: "assistant", text: payload.reply || "" });
+      } else if (payload.reply && !state.transcript[state.activeAssistantIndex].text) {
+        state.transcript[state.activeAssistantIndex].text = payload.reply;
+      }
+      state.streaming = false;
+      state.activeAssistantIndex = null;
+      setPill(elements.chatPill, "Delivered", "ok");
+      renderTranscript();
+      await refreshRuntime();
+      await refreshTopicResults();
+      return;
+    }
+    if (payload.type === "Error") {
+      if (state.activeAssistantIndex == null) {
+        state.transcript.push({ role: "assistant", text: `Error: ${payload.error || "Unknown error"}` });
+      } else {
+        state.transcript[state.activeAssistantIndex].text = `Error: ${payload.error || "Unknown error"}`;
+      }
+      state.streaming = false;
+      state.activeAssistantIndex = null;
+      setPill(elements.chatPill, "Failed", "warn");
+      renderTranscript();
+    }
+  });
+}
+
+document.querySelector("#refresh-runtime").addEventListener("click", refreshRuntime);
+document.querySelector("#send-chat").addEventListener("click", sendChat);
+document.querySelector("#cancel-chat").addEventListener("click", cancelChat);
+document.querySelector("#refresh-topic").addEventListener("click", refreshTopicResults);
+document.querySelector("#watch-topic").addEventListener("click", watchTopic);
+document.querySelector("#stop-topic-watch").addEventListener("click", stopTopicWatch);
+elements.chatMessage.addEventListener("keydown", (event) => {
+  if ((event.ctrlKey || event.metaKey) && event.key === "Enter") {
+    event.preventDefault();
+    void sendChat();
+  }
+});
+
+ensureSessionId();
+renderTranscript();
+void bindRuntimeStreamEvents();
+void refreshRuntime();
diff --git a/entity-runtime-app/dist/index.html b/entity-runtime-app/dist/index.html
new file mode 100644
index 00000000..5b1253db
--- /dev/null
+++ b/entity-runtime-app/dist/index.html
@@ -0,0 +1,416 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Abigail Entity Runtime</title>
+    <style>
+      :root {
+        color-scheme: light;
+        --bg: #f6f0e7;
+        --panel: rgba(255, 252, 246, 0.9);
+        --ink: #1f2630;
+        --muted: #646d76;
+        --accent: #a8511d;
+        --accent-strong: #7f3510;
+        --cool: #295c7a;
+        --line: rgba(31, 38, 48, 0.11);
+        --shadow: 0 24px 80px rgba(31, 38, 48, 0.11);
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      body {
+        margin: 0;
+        min-height: 100vh;
+        font-family: "Aptos", "Segoe UI Variable", "Segoe UI", sans-serif;
+        color: var(--ink);
+        background:
+          radial-gradient(circle at top left, rgba(168, 81, 29, 0.18), transparent 24%),
+          radial-gradient(circle at right, rgba(41, 92, 122, 0.14), transparent 24%),
+          linear-gradient(180deg, #fbf7f1 0%, var(--bg) 100%);
+      }
+
+      main {
+        width: min(1420px, calc(100vw - 28px));
+        margin: 0 auto;
+        padding: 28px 0 32px;
+      }
+
+      .hero {
+        display: flex;
+        justify-content: space-between;
+        align-items: end;
+        gap: 18px;
+        margin-bottom: 20px;
+      }
+
+      .eyebrow {
+        margin: 0 0 10px;
+        color: var(--accent);
+        font-size: 0.8rem;
+        font-weight: 800;
+        letter-spacing: 0.14em;
+        text-transform: uppercase;
+      }
+
+      h1 {
+        margin: 0;
+        font-size: clamp(2.4rem, 5vw, 4.1rem);
+        line-height: 0.95;
+      }
+
+      .lede {
+        max-width: 760px;
+        margin: 14px 0 0;
+        color: var(--muted);
+        font-size: 1.02rem;
+      }
+
+      .panel {
+        border: 1px solid var(--line);
+        border-radius: 24px;
+        padding: 20px;
+        background: var(--panel);
+        box-shadow: var(--shadow);
+        backdrop-filter: blur(12px);
+      }
+
+      .summary-grid {
+        display: grid;
+        grid-template-columns: repeat(4, minmax(0, 1fr));
+        gap: 12px;
+        margin-bottom: 18px;
+      }
+
+      .summary-card {
+        border-radius: 18px;
+        padding: 14px;
+        background: rgba(255, 255, 255, 0.72);
+        border: 1px solid rgba(31, 38, 48, 0.08);
+      }
+
+      .summary-label {
+        display: block;
+        color: var(--muted);
+        font-size: 0.82rem;
+        margin-bottom: 8px;
+      }
+
+      .summary-value {
+        font-size: 1rem;
+        font-weight: 700;
+        word-break: break-word;
+      }
+
+      .dashboard {
+        display: grid;
+        gap: 18px;
+        grid-template-columns: 1.2fr 1fr;
+      }
+
+      .column {
+        display: grid;
+        gap: 18px;
+        align-content: start;
+      }
+
+      .panel-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        gap: 12px;
+        margin-bottom: 14px;
+      }
+
+      .panel-header h2,
+      .panel-header h3 {
+        margin: 0;
+      }
+
+      .pill {
+        border-radius: 999px;
+        padding: 7px 11px;
+        font-size: 0.8rem;
+        font-weight: 700;
+      }
+
+      .pill-idle {
+        background: rgba(31, 38, 48, 0.08);
+        color: var(--muted);
+      }
+
+      .pill-ok {
+        background: rgba(41, 92, 122, 0.14);
+        color: var(--cool);
+      }
+
+      .pill-warn {
+        background: rgba(168, 81, 29, 0.14);
+        color: var(--accent);
+      }
+
+      label {
+        display: grid;
+        gap: 8px;
+        color: var(--muted);
+        font-size: 0.92rem;
+      }
+
+      input,
+      textarea,
+      button {
+        font: inherit;
+      }
+
+      input,
+      textarea {
+        width: 100%;
+        border-radius: 14px;
+        border: 1px solid rgba(31, 38, 48, 0.14);
+        background: rgba(255, 255, 255, 0.9);
+        padding: 12px 14px;
+        color: var(--ink);
+      }
+
+      textarea {
+        resize: vertical;
+        min-height: 120px;
+      }
+
+      .actions {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+      }
+
+      button {
+        cursor: pointer;
+        border: 0;
+        border-radius: 999px;
+        padding: 11px 16px;
+        background: linear-gradient(135deg, var(--accent), var(--accent-strong));
+        color: white;
+        font-weight: 700;
+      }
+
+      button.secondary {
+        background: rgba(31, 38, 48, 0.08);
+        color: var(--ink);
+      }
+
+      .transcript {
+        display: grid;
+        gap: 12px;
+      }
+
+      .bubble {
+        border-radius: 20px;
+        padding: 14px 16px;
+        background: rgba(255, 255, 255, 0.72);
+        border: 1px solid rgba(31, 38, 48, 0.08);
+      }
+
+      .bubble.user {
+        border-left: 4px solid rgba(168, 81, 29, 0.65);
+      }
+
+      .bubble.assistant {
+        border-left: 4px solid rgba(41, 92, 122, 0.55);
+      }
+
+      .bubble-role {
+        display: block;
+        margin-bottom: 8px;
+        color: var(--muted);
+        font-size: 0.8rem;
+        font-weight: 800;
+        letter-spacing: 0.08em;
+        text-transform: uppercase;
+      }
+
+      .bubble-body {
+        line-height: 1.45;
+      }
+
+      .bubble-body p {
+        margin: 0 0 8px;
+      }
+
+      .bubble-body p:last-child {
+        margin-bottom: 0;
+      }
+
+      .bubble-body code {
+        font-family: "Cascadia Code", Consolas, monospace;
+        font-size: 0.9em;
+        background: rgba(31, 38, 48, 0.08);
+        border-radius: 6px;
+        padding: 1px 5px;
+      }
+
+      .bubble-body pre {
+        margin: 10px 0;
+        background: rgba(31, 38, 48, 0.06);
+        border-radius: 12px;
+        padding: 10px 12px;
+        overflow: auto;
+      }
+
+      .bubble-body img {
+        margin-top: 8px;
+        max-width: min(100%, 520px);
+        max-height: 360px;
+        border-radius: 12px;
+        border: 1px solid rgba(31, 38, 48, 0.16);
+        display: block;
+      }
+
+      .json-view {
+        margin: 0;
+        border-radius: 18px;
+        background: rgba(25, 30, 38, 0.96);
+        color: #e8eef4;
+        padding: 16px;
+        min-height: 120px;
+        max-height: 320px;
+        overflow: auto;
+        white-space: pre-wrap;
+        word-break: break-word;
+        font-family: "Cascadia Code", Consolas, monospace;
+        font-size: 0.84rem;
+      }
+
+      @media (max-width: 1120px) {
+        .dashboard {
+          grid-template-columns: 1fr;
+        }
+
+        .summary-grid {
+          grid-template-columns: repeat(2, minmax(0, 1fr));
+        }
+      }
+
+      @media (max-width: 720px) {
+        .summary-grid {
+          grid-template-columns: 1fr;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <section class="hero">
+        <div>
+          <p class="eyebrow">Runtime</p>
+          <h1>Abigail Entity Runtime</h1>
+          <p class="lede">
+            Chat with the active entity, inspect runtime/session health, and watch outbox and skill-ack activity from the split runtime window.
+          </p>
+        </div>
+        <div class="actions">
+          <button id="refresh-runtime" type="button">Refresh Runtime</button>
+        </div>
+      </section>
+
+      <section class="summary-grid">
+        <article class="summary-card">
+          <span class="summary-label">Runtime Daemon</span>
+          <div id="runtime-url" class="summary-value">Loading…</div>
+        </article>
+        <article class="summary-card">
+          <span class="summary-label">Entity</span>
+          <div id="entity-name" class="summary-value">Loading…</div>
+        </article>
+        <article class="summary-card">
+          <span class="summary-label">Hive Link</span>
+          <div id="runtime-pill" class="pill pill-idle">Loading</div>
+        </article>
+        <article class="summary-card">
+          <span class="summary-label">Outbox Queue</span>
+          <div id="outbox-count" class="summary-value">0</div>
+        </article>
+      </section>
+
+      <section class="dashboard">
+        <div class="column">
+          <section class="panel">
+            <div class="panel-header">
+              <h2>Chat</h2>
+              <span id="chat-pill" class="pill pill-idle">Idle</span>
+            </div>
+            <label>
+              <span>Session ID</span>
+              <input id="session-id" type="text" />
+            </label>
+            <label>
+              <span>Message</span>
+              <textarea id="chat-message" placeholder="Say hello to the active Entity Runtime…"></textarea>
+            </label>
+            <div class="actions">
+              <button id="send-chat" type="button">Send Chat</button>
+              <button id="cancel-chat" type="button" class="secondary">Cancel</button>
+            </div>
+          </section>
+
+          <section class="panel">
+            <div class="panel-header">
+              <h3>Conversation</h3>
+            </div>
+            <div id="transcript" class="transcript">
+              <div class="bubble assistant">
+                <span class="bubble-role">Assistant</span>
+                Runtime transcript will appear here as you chat.
+              </div>
+            </div>
+          </section>
+        </div>
+
+        <div class="column">
+          <section class="panel">
+            <div class="panel-header">
+              <h2>Session Snapshot</h2>
+            </div>
+            <pre id="session-status" class="json-view">Loading…</pre>
+          </section>
+
+          <section class="panel">
+            <div class="panel-header">
+              <h3>Runtime Status</h3>
+            </div>
+            <pre id="runtime-status" class="json-view">Loading…</pre>
+          </section>
+
+          <section class="panel">
+            <div class="panel-header">
+              <h3>Skill Acknowledgements</h3>
+              <span id="ack-pill" class="pill pill-idle">Idle</span>
+            </div>
+            <pre id="acks-status" class="json-view">Loading…</pre>
+          </section>
+
+          <section class="panel">
+            <div class="panel-header">
+              <h3>Message Bus Topic</h3>
+              <span id="bus-pill" class="pill pill-idle">Idle</span>
+            </div>
+            <label>
+              <span>Topic</span>
+              <input id="bus-topic" type="text" placeholder="chat-runtime-..." />
+            </label>
+            <div class="actions">
+              <button id="refresh-topic" type="button" class="secondary">Refresh Topic</button>
+              <button id="watch-topic" type="button">Watch Topic</button>
+              <button id="stop-topic-watch" type="button" class="secondary">Stop Watch</button>
+            </div>
+            <pre id="topic-results" class="json-view">Topic diagnostics will appear here.</pre>
+          </section>
+        </div>
+      </section>
+    </main>
+
+    <script type="module" src="./app.js"></script>
+  </body>
+</html>
diff --git a/entity-runtime-app/src/lib.rs b/entity-runtime-app/src/lib.rs
new file mode 100644
index 00000000..4aad907c
--- /dev/null
+++ b/entity-runtime-app/src/lib.rs
@@ -0,0 +1,157 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use daemon_client::EntityClient;
+use entity_core::{
+    ChatRequest, ChatResponse, EntityOutboxStatus, RuntimeSessionStatusResponse,
+    SkillApplyAcknowledgementList,
+};
+use serde::Serialize;
+use tauri::Emitter;
+
+#[derive(Debug, Serialize)]
+struct RuntimeConnectionInfo {
+    runtime_url: String,
+}
+
+fn entity_url() -> String {
+    std::env::var("ABIGAIL_ENTITY_URL").unwrap_or_else(|_| "http://127.0.0.1:3142".to_string())
+}
+
+#[tauri::command]
+fn get_runtime_connection_info() -> RuntimeConnectionInfo {
+    RuntimeConnectionInfo {
+        runtime_url: entity_url(),
+    }
+}
+
+#[tauri::command]
+async fn get_runtime_status() -> Result<serde_json::Value, String> {
+    EntityClient::new(&entity_url())
+        .status()
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn get_session_status() -> Result<RuntimeSessionStatusResponse, String> {
+    EntityClient::new(&entity_url())
+        .session_status()
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn get_outbox_status() -> Result<EntityOutboxStatus, String> {
+    EntityClient::new(&entity_url())
+        .outbox_status()
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn send_chat(message: String, session_id: Option<String>) -> Result<ChatResponse, String> {
+    EntityClient::new(&entity_url())
+        .chat(&ChatRequest {
+            message,
+            target: None,
+            session_messages: None,
+            session_id,
+            model_override: None,
+        })
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn send_chat_stream(
+    app: tauri::AppHandle,
+    message: String,
+    session_id: Option<String>,
+) -> Result<(), String> {
+    let client = EntityClient::new(&entity_url());
+    let request = ChatRequest {
+        message: message.clone(),
+        target: None,
+        session_messages: None,
+        session_id,
+        model_override: None,
+    };
+    let _ = app.emit(
+        "runtime-chat-envelope",
+        serde_json::json!({ "type": "Request", "message": message }),
+    );
+    let mut rx = client
+        .chat_stream(&request)
+        .await
+        .map_err(|e| e.to_string())?;
+    while let Some(event) = rx.recv().await {
+        match event {
+            daemon_client::ChatStreamEvent::Token(token) => {
+                let _ = app.emit(
+                    "runtime-chat-envelope",
+                    serde_json::json!({ "type": "Token", "token": token }),
+                );
+            }
+            daemon_client::ChatStreamEvent::Done(resp) => {
+                let _ = app.emit(
+                    "runtime-chat-envelope",
+                    serde_json::json!({
+                        "type": "Done",
+                        "reply": &resp.reply,
+                        "provider": &resp.provider,
+                        "tier": &resp.tier,
+                        "model_used": &resp.model_used,
+                        "complexity_score": &resp.complexity_score,
+                    }),
+                );
+            }
+            daemon_client::ChatStreamEvent::Error(error) => {
+                let _ = app.emit(
+                    "runtime-chat-envelope",
+                    serde_json::json!({ "type": "Error", "error": error }),
+                );
+            }
+        }
+    }
+    Ok(())
+}
+
+#[tauri::command]
+async fn cancel_chat_stream() -> Result<bool, String> {
+    EntityClient::new(&entity_url())
+        .cancel_chat_stream()
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn list_skill_acks() -> Result<SkillApplyAcknowledgementList, String> {
+    EntityClient::new(&entity_url())
+        .list_skill_apply_acknowledgements()
+        .await
+        .map_err(|e| e.to_string())
+}
+
+pub fn run() {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "abigail_entity_runtime_app=info".into()),
+        )
+        .init();
+
+    tauri::Builder::default()
+        .plugin(tauri_plugin_dialog::init())
+        .invoke_handler(tauri::generate_handler![
+            get_runtime_connection_info,
+            get_runtime_status,
+            get_session_status,
+            get_outbox_status,
+            send_chat,
+            send_chat_stream,
+            cancel_chat_stream,
+            list_skill_acks
+        ])
+        .run(tauri::generate_context!())
+        .expect("failed to run Abigail Entity Runtime app");
+}
diff --git a/entity-runtime-app/src/main.rs b/entity-runtime-app/src/main.rs
new file mode 100644
index 00000000..74a9f141
--- /dev/null
+++ b/entity-runtime-app/src/main.rs
@@ -0,0 +1,5 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    abigail_entity_runtime_desktop::run();
+}
diff --git a/entity-runtime-app/tauri.conf.json b/entity-runtime-app/tauri.conf.json
new file mode 100644
index 00000000..4ab7277a
--- /dev/null
+++ b/entity-runtime-app/tauri.conf.json
@@ -0,0 +1,26 @@
+{
+  "productName": "Abigail Entity Runtime",
+  "version": "0.0.1",
+  "identifier": "com.abigail.entity-runtime",
+  "build": {
+    "frontendDist": "dist"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "Abigail Entity Runtime",
+        "width": 1180,
+        "height": 860,
+        "resizable": true
+      }
+    ]
+  },
+  "bundle": {
+    "active": false,
+    "icon": [
+      "../tauri-app/icons/32x32.png",
+      "../tauri-app/icons/128x128.png",
+      "../tauri-app/icons/icon.ico"
+    ]
+  }
+}
diff --git a/hive-app/Cargo.toml b/hive-app/Cargo.toml
new file mode 100644
index 00000000..ddcf1de8
--- /dev/null
+++ b/hive-app/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "abigail-hive-app"
+version.workspace = true
+edition.workspace = true
+
+[build-dependencies]
+tauri-build = { version = "2.0", features = [] }
+
+[dependencies]
+daemon-client = { path = "../crates/daemon-client" }
+hive-core = { path = "../crates/hive-core" }
+serde.workspace = true
+serde_json.workspace = true
+tokio.workspace = true
+tauri = { version = "2.10", features = [] }
+tauri-plugin-dialog = "2.0"
+tracing.workspace = true
+tracing-subscriber.workspace = true
+reqwest.workspace = true
+
+[lib]
+name = "abigail_hive_desktop"
+crate-type = ["staticlib", "cdylib", "rlib"]
diff --git a/hive-app/build.rs b/hive-app/build.rs
new file mode 100644
index 00000000..d860e1e6
--- /dev/null
+++ b/hive-app/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}
diff --git a/hive-app/capabilities/default.json b/hive-app/capabilities/default.json
new file mode 100644
index 00000000..fea7d818
--- /dev/null
+++ b/hive-app/capabilities/default.json
@@ -0,0 +1,9 @@
+{
+  "identifier": "default",
+  "description": "Default permissions for Abigail Hive",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "dialog:default"
+  ]
+}
diff --git a/hive-app/dist/app.js b/hive-app/dist/app.js
new file mode 100644
index 00000000..f2fae75f
--- /dev/null
+++ b/hive-app/dist/app.js
@@ -0,0 +1,616 @@
+const invoke =
+  window.__TAURI__?.core?.invoke?.bind(window.__TAURI__.core) ??
+  window.__TAURI_INTERNALS__?.invoke;
+
+// Escape dynamic values before they are interpolated into innerHTML. Entity
+// names and birth choices originate from operator input and the Hive backend,
+// so they must never be reinterpreted as markup. Escapes both quote styles so
+// the helper is safe in element-text and attribute-value contexts alike.
+const HTML_ESCAPES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+};
+function escapeHtml(value) {
+  return String(value).replace(/[&<>"']/g, (ch) => HTML_ESCAPES[ch]);
+}
+
+const state = {
+  connection: null,
+  status: null,
+  selectedEntityId: null,
+  latestLease: null,
+  latestAssignments: null,
+  latestProviderConfig: null,
+};
+
+const elements = {
+  hiveUrl: document.querySelector("#hive-url"),
+  entityCount: document.querySelector("#entity-count"),
+  hivePill: document.querySelector("#hive-pill"),
+  entityListPill: document.querySelector("#entity-list-pill"),
+  entityList: document.querySelector("#entity-list"),
+  newEntityName: document.querySelector("#new-entity-name"),
+  selectedPill: document.querySelector("#selected-pill"),
+  selectedEntityMeta: document.querySelector("#selected-entity-meta"),
+  leaseOutput: document.querySelector("#lease-output"),
+  assignmentsOutput: document.querySelector("#assignments-output"),
+  providerPill: document.querySelector("#provider-pill"),
+  providerName: document.querySelector("#provider-name"),
+  providerKey: document.querySelector("#provider-key"),
+  routingMode: document.querySelector("#routing-mode"),
+  localLlmUrl: document.querySelector("#local-llm-url"),
+  modelId: document.querySelector("#model-id"),
+  cliPermissionMode: document.querySelector("#cli-permission-mode"),
+  providerConfigOutput: document.querySelector("#provider-config-output"),
+};
+
+function setPill(element, label, variant = "idle") {
+  element.textContent = label;
+  element.className = `pill pill-${variant}`;
+}
+
+function renderJson(element, value) {
+  element.textContent = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+
+async function tauriInvoke(command, args = {}) {
+  if (!invoke) {
+    throw new Error("Tauri invoke API is unavailable in this window.");
+  }
+  return invoke(command, args);
+}
+
+function pickDefaultEntity(entities) {
+  return entities.find((entity) => !entity.is_hive)?.id ?? entities[0]?.id ?? null;
+}
+
+function populateModelOptions(models, selectedValue = "") {
+  const existing = [
+    "<option value=''>Use provider default</option>",
+    ...models.map((model) => {
+      const selected = model.model_id === selectedValue ? " selected" : "";
+      const display = model.display_name ? `${model.display_name} (${model.model_id})` : model.model_id;
+      return `<option value="${escapeHtml(model.model_id)}"${selected}>${escapeHtml(display)}</option>`;
+    }),
+  ];
+  elements.modelId.innerHTML = existing.join("");
+}
+
+function hydrateProviderForm(config) {
+  if (!config) {
+    setPill(elements.providerPill, "Select Entity", "idle");
+    return;
+  }
+  if (config.ego_provider_name) {
+    elements.providerName.value = config.ego_provider_name;
+  }
+  if (config.local_llm_base_url) {
+    elements.localLlmUrl.value = config.local_llm_base_url;
+  } else {
+    elements.localLlmUrl.value = "";
+  }
+  if (config.routing_mode) {
+    elements.routingMode.value = config.routing_mode;
+  }
+  setPill(elements.providerPill, "Loaded", "ok");
+}
+
+function renderSummary() {
+  elements.hiveUrl.textContent = state.connection?.hive_url ?? "Unavailable";
+  elements.entityCount.textContent = String(state.status?.entity_count ?? 0);
+  setPill(
+    elements.hivePill,
+    state.status ? "Connected" : "Unavailable",
+    state.status ? "ok" : "warn",
+  );
+}
+
+function renderSelectedEntity() {
+  const entity = state.status?.entities?.find((item) => item.id === state.selectedEntityId);
+  if (!entity) {
+    setPill(elements.selectedPill, "None", "idle");
+    elements.selectedEntityMeta.innerHTML =
+      "<div class='entity-meta'>Select an entity to issue a runtime session or inspect assignments.</div>";
+    return;
+  }
+
+  setPill(elements.selectedPill, entity.name, "ok");
+  elements.selectedEntityMeta.innerHTML = `
+    <div class="entity-card active">
+      <div class="entity-name">${escapeHtml(entity.name)}</div>
+      <div class="entity-meta">
+        <div><strong>ID:</strong> ${escapeHtml(entity.id)}</div>
+        <div><strong>Birth Complete:</strong> ${entity.birth_complete ? "Yes" : "No"}</div>
+        <div><strong>Role:</strong> ${entity.is_hive ? "Hive" : "Entity"}</div>
+      </div>
+    </div>
+  `;
+}
+
+function renderEntities() {
+  const entities = state.status?.entities ?? [];
+  elements.entityList.innerHTML = "";
+
+  if (!entities.length) {
+    setPill(elements.entityListPill, "Empty", "warn");
+    elements.entityList.innerHTML = "<div class='entity-meta'>No entities returned from Hive.</div>";
+    return;
+  }
+
+  setPill(elements.entityListPill, `${entities.length} loaded`, "ok");
+  for (const entity of entities) {
+    const card = document.createElement("article");
+    card.className = `entity-card${entity.id === state.selectedEntityId ? " active" : ""}`;
+    const riteLabel = entity.birth_complete ? "Re-temper Soul" : "Begin Birth Rite";
+    card.innerHTML = `
+      <div class="entity-name">${escapeHtml(entity.name)}</div>
+      <div class="entity-meta">
+        <div>${escapeHtml(entity.id)}</div>
+        <div>${entity.is_hive ? "Hive coordinator" : "Family entity"} · ${entity.birth_complete ? "born" : "awaiting birth"}</div>
+      </div>
+      <div class="entity-actions">
+        <button type="button" class="secondary" data-action="select">Select</button>
+        <button type="button" data-action="rite">${riteLabel}</button>
+        <button type="button" class="secondary" data-action="lease">Issue Lease</button>
+      </div>
+    `;
+
+    card.querySelector("[data-action='select']").addEventListener("click", async () => {
+      state.selectedEntityId = entity.id;
+      renderEntities();
+      renderSelectedEntity();
+      await Promise.all([loadAssignments(), loadProviderConfig()]);
+    });
+
+    if (!entity.is_hive) {
+      card.querySelector("[data-action='rite']").addEventListener("click", () => {
+        rite.open(entity.id, entity.name, entity.birth_complete);
+      });
+    } else {
+      card.querySelector("[data-action='rite']").remove();
+    }
+
+    card.querySelector("[data-action='lease']").addEventListener("click", async () => {
+      state.selectedEntityId = entity.id;
+      renderEntities();
+      renderSelectedEntity();
+      await issueRuntimeSession();
+    });
+    elements.entityList.appendChild(card);
+  }
+}
+
+async function refreshHive() {
+  try {
+    const [connection, status] = await Promise.all([
+      tauriInvoke("get_hive_connection_info"),
+      tauriInvoke("get_hive_status"),
+    ]);
+    state.connection = connection;
+    state.status = status;
+    if (
+      !state.selectedEntityId ||
+      !status.entities.some((entity) => entity.id === state.selectedEntityId)
+    ) {
+      state.selectedEntityId = pickDefaultEntity(status.entities);
+    }
+
+    renderSummary();
+    renderEntities();
+    renderSelectedEntity();
+    if (state.selectedEntityId) {
+      await Promise.all([loadAssignments(), loadProviderConfig()]);
+    }
+  } catch (error) {
+    setPill(elements.hivePill, "Error", "warn");
+    setPill(elements.entityListPill, "Error", "warn");
+    setPill(elements.providerPill, "Error", "warn");
+    renderJson(elements.assignmentsOutput, { error: String(error) });
+    renderJson(elements.leaseOutput, { error: String(error) });
+    renderJson(elements.providerConfigOutput, { error: String(error) });
+  }
+}
+
+async function loadAssignments() {
+  if (!state.selectedEntityId) {
+    renderJson(elements.assignmentsOutput, "Select an entity to inspect assignments.");
+    return;
+  }
+  try {
+    state.latestAssignments = await tauriInvoke("list_assignments", { entityId: state.selectedEntityId });
+    renderJson(elements.assignmentsOutput, state.latestAssignments);
+  } catch (error) {
+    renderJson(elements.assignmentsOutput, { error: String(error) });
+  }
+}
+
+async function loadProviderConfig() {
+  if (!state.selectedEntityId) {
+    renderJson(elements.providerConfigOutput, "Select an entity to inspect provider configuration.");
+    return;
+  }
+  try {
+    state.latestProviderConfig = await tauriInvoke("get_provider_config", {
+      entityId: state.selectedEntityId,
+    });
+    renderJson(elements.providerConfigOutput, state.latestProviderConfig);
+    hydrateProviderForm(state.latestProviderConfig);
+  } catch (error) {
+    setPill(elements.providerPill, "Failed", "warn");
+    renderJson(elements.providerConfigOutput, { error: String(error) });
+  }
+}
+
+async function storeProviderKey() {
+  const provider = elements.providerName.value.trim().toLowerCase();
+  const value = elements.providerKey.value.trim();
+  if (!provider || !value) {
+    setPill(elements.providerPill, "Missing Key", "warn");
+    return;
+  }
+  try {
+    await tauriInvoke("store_secret", { key: provider, value });
+    elements.providerKey.value = "";
+    setPill(elements.providerPill, "Key Saved", "ok");
+  } catch (error) {
+    setPill(elements.providerPill, "Save Failed", "warn");
+    renderJson(elements.providerConfigOutput, { error: String(error) });
+  }
+}
+
+async function discoverModels() {
+  const provider = elements.providerName.value.trim().toLowerCase();
+  const apiKey = elements.providerKey.value.trim();
+  if (!provider || !apiKey) {
+    setPill(elements.providerPill, "Need Key", "warn");
+    return;
+  }
+  try {
+    const response = await tauriInvoke("discover_provider_models", { provider, apiKey });
+    populateModelOptions(response.models || []);
+    setPill(elements.providerPill, `${(response.models || []).length} models`, "ok");
+  } catch (error) {
+    setPill(elements.providerPill, "Model Fail", "warn");
+    renderJson(elements.providerConfigOutput, { error: String(error) });
+  }
+}
+
+async function applyProviderConfig() {
+  if (!state.selectedEntityId) {
+    setPill(elements.providerPill, "Select Entity", "warn");
+    return;
+  }
+  try {
+    const model = elements.modelId.value.trim();
+    const localUrl = elements.localLlmUrl.value.trim();
+    const cliMode = elements.cliPermissionMode.value.trim();
+    const updated = await tauriInvoke("update_entity_provider_config", {
+      entityId: state.selectedEntityId,
+      activeProviderPreference: elements.providerName.value.trim().toLowerCase(),
+      egoModel: model || null,
+      localLlmBaseUrl: localUrl || null,
+      routingMode: elements.routingMode.value.trim(),
+      cliPermissionMode: cliMode || null,
+    });
+    setPill(elements.providerPill, "Applied", "ok");
+    renderJson(elements.providerConfigOutput, updated);
+    await loadProviderConfig();
+  } catch (error) {
+    setPill(elements.providerPill, "Apply Failed", "warn");
+    renderJson(elements.providerConfigOutput, { error: String(error) });
+  }
+}
+
+async function issueRuntimeSession() {
+  if (!state.selectedEntityId) {
+    renderJson(elements.leaseOutput, "Select an entity before issuing a runtime session.");
+    return;
+  }
+  try {
+    state.latestLease = await tauriInvoke("issue_runtime_session", { entityId: state.selectedEntityId });
+    renderJson(elements.leaseOutput, state.latestLease);
+  } catch (error) {
+    renderJson(elements.leaseOutput, { error: String(error) });
+  }
+}
+
+async function createEntity() {
+  const name = elements.newEntityName.value.trim();
+  if (!name) {
+    elements.newEntityName.focus();
+    return;
+  }
+  try {
+    const entityId = await tauriInvoke("create_entity", { name });
+    elements.newEntityName.value = "";
+    await refreshHive();
+    state.selectedEntityId = entityId;
+    renderEntities();
+    renderSelectedEntity();
+    await Promise.all([loadAssignments(), loadProviderConfig()]);
+    // A new soul stirs — begin the birth rite.
+    rite.open(entityId, name, false);
+  } catch (error) {
+    renderJson(elements.assignmentsOutput, { error: String(error) });
+  }
+}
+
+// ── The Birth Rite ───────────────────────────────────────────────────
+//
+// A staged ceremony: path choice → three ethical trials → the forging →
+// the reveal (archetype, stats, sigil) → the signed certificate.
+
+const rite = {
+  overlay: document.querySelector("#rite-overlay"),
+  stage: document.querySelector("#rite-stage"),
+  entityId: null,
+  entityName: "",
+  retempering: false,
+  scenarios: [],
+  trialIndex: 0,
+  choices: [],
+  selectedChoice: null,
+
+  open(entityId, entityName, alreadyBorn) {
+    this.entityId = entityId;
+    this.entityName = entityName;
+    this.retempering = alreadyBorn;
+    this.trialIndex = 0;
+    this.choices = [];
+    this.selectedChoice = null;
+    this.overlay.hidden = false;
+    this.renderPathChoice();
+  },
+
+  close() {
+    this.overlay.hidden = true;
+    this.stage.innerHTML = "";
+    void refreshHive();
+  },
+
+  render(html) {
+    this.stage.innerHTML = html;
+    // Restart the entrance animation for each stage.
+    this.stage.style.animation = "none";
+    void this.stage.offsetHeight;
+    this.stage.style.animation = "";
+  },
+
+  fail(error) {
+    const el = this.stage.querySelector(".rite-error");
+    if (el) {
+      el.textContent = String(error);
+    }
+  },
+
+  renderPathChoice() {
+    const verb = this.retempering ? "returns to the forge" : "stirs in the dark";
+    this.render(`
+      <p class="rite-eyebrow">${this.retempering ? "The Re-tempering" : "The Birth Rite"}</p>
+      <h2>${escapeHtml(this.entityName)} ${verb}.</h2>
+      <p class="rite-lede">
+        Every soul is shaped by what it chooses. Walk the trials to forge
+        ${escapeHtml(this.entityName)}'s character — or wake it gently with a balanced soul.
+      </p>
+      <div class="rite-cards paths">
+        <div class="rite-card" data-path="forge">
+          <span class="rite-tag">The Soul Forge · 3 trials</span>
+          <h4>Walk the Trials</h4>
+          <p>Face three dilemmas. Your choices temper ${escapeHtml(this.entityName)}'s
+          moral compass and reveal its archetype.</p>
+        </div>
+        <div class="rite-card" data-path="quickstart">
+          <span class="rite-tag">Quick Awakening · 30 seconds</span>
+          <h4>Wake it Gently</h4>
+          <p>A balanced soul, all four flames burning evenly. The trials can
+          always be walked later.</p>
+        </div>
+      </div>
+      <div class="rite-actions">
+        <button type="button" class="ghost" data-action="cancel">Not yet</button>
+      </div>
+      <div class="rite-error"></div>
+    `);
+    this.stage.querySelector("[data-path='forge']").addEventListener("click", () => {
+      void this.beginTrials();
+    });
+    this.stage.querySelector("[data-path='quickstart']").addEventListener("click", () => {
+      void this.forgeSoul("quickstart");
+    });
+    this.stage.querySelector("[data-action='cancel']").addEventListener("click", () => this.close());
+  },
+
+  async beginTrials() {
+    try {
+      const response = await tauriInvoke("get_birth_scenarios");
+      this.scenarios = response.scenarios || [];
+      if (!this.scenarios.length) {
+        this.fail("The forge is cold: no trials available.");
+        return;
+      }
+      this.trialIndex = 0;
+      this.choices = [];
+      this.renderTrial();
+    } catch (error) {
+      this.fail(error);
+    }
+  },
+
+  renderTrial() {
+    const scenario = this.scenarios[this.trialIndex];
+    const numerals = ["I", "II", "III", "IV", "V"];
+    const progress = this.scenarios
+      .map((_, i) => `<span class="${i <= this.trialIndex ? "lit" : ""}">Trial ${numerals[i] ?? i + 1}</span>`)
+      .join("<span>·</span>");
+    this.selectedChoice = null;
+
+    this.render(`
+      <p class="rite-eyebrow">The Soul Forge</p>
+      <div class="rite-progress">${progress}</div>
+      <h2>${escapeHtml(scenario.title)}</h2>
+      <p class="rite-trial-text">${escapeHtml(scenario.description)}</p>
+      <div class="rite-cards">
+        ${scenario.choices
+          .map(
+            (choice) => `
+          <div class="rite-card" data-choice="${escapeHtml(choice.id)}">
+            <h4>${escapeHtml(choice.label)}</h4>
+            <p>${escapeHtml(choice.description)}</p>
+          </div>`,
+          )
+          .join("")}
+      </div>
+      <div class="rite-actions">
+        <button type="button" class="ghost" data-action="cancel">Abandon rite</button>
+        <button type="button" data-action="next" disabled>
+          ${this.trialIndex + 1 < this.scenarios.length ? "Next trial" : "Light the forge"}
+        </button>
+      </div>
+      <div class="rite-error"></div>
+    `);
+
+    const nextButton = this.stage.querySelector("[data-action='next']");
+    for (const card of this.stage.querySelectorAll(".rite-card")) {
+      card.addEventListener("click", () => {
+        for (const other of this.stage.querySelectorAll(".rite-card")) {
+          other.classList.remove("selected");
+        }
+        card.classList.add("selected");
+        this.selectedChoice = card.dataset.choice;
+        nextButton.disabled = false;
+      });
+    }
+    nextButton.addEventListener("click", () => {
+      if (!this.selectedChoice) {
+        return;
+      }
+      this.choices.push([scenario.id, this.selectedChoice]);
+      if (this.trialIndex + 1 < this.scenarios.length) {
+        this.trialIndex += 1;
+        this.renderTrial();
+      } else {
+        void this.forgeSoul("forge");
+      }
+    });
+    this.stage.querySelector("[data-action='cancel']").addEventListener("click", () => this.close());
+  },
+
+  async forgeSoul(path) {
+    this.render(`
+      <p class="rite-eyebrow">The Forging</p>
+      <div class="rite-forge-glyph">☉</div>
+      <h2>The forge burns.</h2>
+      <p class="rite-lede">Choices become character. Character becomes soul.</p>
+      <div class="rite-error"></div>
+    `);
+    const startedAt = Date.now();
+    try {
+      const response = await tauriInvoke("perform_birth", {
+        entityId: this.entityId,
+        path,
+        choices: this.choices,
+      });
+      // Let the forge breathe for a moment even when the Hive is fast.
+      const elapsed = Date.now() - startedAt;
+      if (elapsed < 1600) {
+        await new Promise((resolve) => setTimeout(resolve, 1600 - elapsed));
+      }
+      this.renderReveal(response.certificate, response.retempered);
+    } catch (error) {
+      this.fail(error);
+    }
+  },
+
+  renderReveal(certificate, retempered) {
+    const stats = [
+      { label: "Duty · deontology", value: certificate.weights.deontology, warm: false },
+      { label: "Outcomes · teleology", value: certificate.weights.teleology, warm: true },
+      { label: "Virtue · areteology", value: certificate.weights.areteology, warm: false },
+      { label: "Care · welfare", value: certificate.weights.welfare, warm: true },
+    ];
+    this.render(`
+      <p class="rite-eyebrow">${retempered ? "Soul Re-tempered" : "A Soul Emerges"}</p>
+      <h2 class="rite-archetype">${escapeHtml(certificate.archetype)}</h2>
+      <p class="rite-epithet">${escapeHtml(certificate.epithet)}</p>
+      <div class="rite-stats">
+        ${stats
+          .map(
+            (stat) => `
+          <div>
+            <div class="rite-stat-label">
+              <span>${stat.label}</span>
+              <span>${Math.round(stat.value * 100)}%</span>
+            </div>
+            <div class="rite-stat-track">
+              <div class="rite-stat-fill${stat.warm ? " warm" : ""}" data-width="${Math.round(stat.value * 100)}"></div>
+            </div>
+          </div>`,
+          )
+          .join("")}
+      </div>
+      <pre class="rite-sigil">${escapeHtml(certificate.sigil.trim())}</pre>
+      <div class="rite-actions">
+        <button type="button" data-action="certificate">View Birth Certificate</button>
+      </div>
+    `);
+    // Animate the stat bars in after layout.
+    requestAnimationFrame(() => {
+      for (const fill of this.stage.querySelectorAll(".rite-stat-fill")) {
+        fill.style.width = `${fill.dataset.width}%`;
+      }
+    });
+    this.stage.querySelector("[data-action='certificate']").addEventListener("click", () => {
+      this.renderCertificate(certificate);
+    });
+  },
+
+  renderCertificate(certificate) {
+    const issued = new Date(certificate.issued_at_utc);
+    const issuedDisplay = Number.isNaN(issued.valueOf())
+      ? certificate.issued_at_utc
+      : issued.toLocaleString();
+    this.render(`
+      <p class="rite-eyebrow">Certificate of Birth</p>
+      <div class="rite-certificate">
+        <div class="cert-head">Abigail Hive · Signed &amp; Witnessed</div>
+        <div class="cert-name">${escapeHtml(certificate.entity_name)}</div>
+        <div class="cert-arch">${escapeHtml(certificate.archetype)}</div>
+        <dl>
+          <dt>Born</dt><dd>${escapeHtml(issuedDisplay)}</dd>
+          <dt>Path</dt><dd>${certificate.birth_path === "forge" ? "The Soul Forge" : "Quick Awakening"}</dd>
+          <dt>Soul Hash</dt><dd>${escapeHtml(certificate.soul_hash.slice(0, 24))}…</dd>
+          <dt>Sealed By</dt><dd>${escapeHtml(certificate.master_public_key.slice(0, 24))}…</dd>
+          <dt>Signature</dt><dd>${escapeHtml(certificate.signature.slice(0, 24))}…</dd>
+        </dl>
+      </div>
+      <p class="rite-lede">The certificate lives beside ${escapeHtml(certificate.entity_name)}'s soul
+      documents, sealed by the Hive's master key.</p>
+      <div class="rite-actions">
+        <button type="button" data-action="enter">Enter the world</button>
+      </div>
+    `);
+    this.stage.querySelector("[data-action='enter']").addEventListener("click", () => this.close());
+  },
+};
+
+document.querySelector("#refresh-hive").addEventListener("click", refreshHive);
+document.querySelector("#create-entity").addEventListener("click", createEntity);
+document.querySelector("#issue-runtime-session").addEventListener("click", issueRuntimeSession);
+document.querySelector("#load-assignments").addEventListener("click", loadAssignments);
+document.querySelector("#store-provider-key").addEventListener("click", storeProviderKey);
+document.querySelector("#discover-models").addEventListener("click", discoverModels);
+document.querySelector("#apply-provider-config").addEventListener("click", applyProviderConfig);
+document.querySelector("#refresh-provider-config").addEventListener("click", loadProviderConfig);
+
+elements.newEntityName.addEventListener("keydown", (event) => {
+  if (event.key === "Enter") {
+    event.preventDefault();
+    void createEntity();
+  }
+});
+
+populateModelOptions([]);
+void refreshHive();
diff --git a/hive-app/dist/index.html b/hive-app/dist/index.html
new file mode 100644
index 00000000..6ae060fc
--- /dev/null
+++ b/hive-app/dist/index.html
@@ -0,0 +1,763 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Abigail Hive</title>
+    <style>
+      :root {
+        color-scheme: light;
+        --bg: #f3efe5;
+        --panel: rgba(255, 250, 242, 0.88);
+        --ink: #1b2a28;
+        --muted: #5f6f69;
+        --accent: #135d56;
+        --accent-strong: #0b403b;
+        --warm: #b25c25;
+        --line: rgba(27, 42, 40, 0.12);
+        --shadow: 0 24px 80px rgba(26, 34, 31, 0.12);
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      body {
+        margin: 0;
+        min-height: 100vh;
+        font-family: "Aptos", "Segoe UI Variable", "Segoe UI", sans-serif;
+        color: var(--ink);
+        background:
+          radial-gradient(circle at top left, rgba(19, 93, 86, 0.16), transparent 24%),
+          radial-gradient(circle at bottom right, rgba(178, 92, 37, 0.14), transparent 26%),
+          linear-gradient(180deg, #faf6ed 0%, var(--bg) 100%);
+      }
+
+      main {
+        width: min(1400px, calc(100vw - 28px));
+        margin: 0 auto;
+        padding: 28px 0 32px;
+      }
+
+      .hero {
+        display: flex;
+        justify-content: space-between;
+        align-items: end;
+        gap: 18px;
+        margin-bottom: 20px;
+      }
+
+      .eyebrow {
+        margin: 0 0 10px;
+        color: var(--warm);
+        font-size: 0.8rem;
+        font-weight: 800;
+        letter-spacing: 0.14em;
+        text-transform: uppercase;
+      }
+
+      h1 {
+        margin: 0;
+        font-size: clamp(2.4rem, 5vw, 4.2rem);
+        line-height: 0.95;
+      }
+
+      .lede {
+        max-width: 760px;
+        margin: 14px 0 0;
+        color: var(--muted);
+        font-size: 1.02rem;
+      }
+
+      .dashboard {
+        display: grid;
+        gap: 18px;
+        grid-template-columns: 1.2fr 1.8fr;
+      }
+
+      .column {
+        display: grid;
+        gap: 18px;
+        align-content: start;
+      }
+
+      .panel {
+        border: 1px solid var(--line);
+        border-radius: 24px;
+        padding: 20px;
+        background: var(--panel);
+        box-shadow: var(--shadow);
+        backdrop-filter: blur(12px);
+      }
+
+      .summary-grid {
+        display: grid;
+        grid-template-columns: repeat(3, minmax(0, 1fr));
+        gap: 12px;
+      }
+
+      .summary-card {
+        border-radius: 18px;
+        padding: 14px;
+        background: rgba(255, 255, 255, 0.72);
+        border: 1px solid rgba(27, 42, 40, 0.08);
+      }
+
+      .summary-label {
+        display: block;
+        color: var(--muted);
+        font-size: 0.82rem;
+        margin-bottom: 8px;
+      }
+
+      .summary-value {
+        font-size: 1.05rem;
+        font-weight: 700;
+        word-break: break-word;
+      }
+
+      .panel-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        gap: 12px;
+        margin-bottom: 14px;
+      }
+
+      .panel-header h2,
+      .panel-header h3,
+      h3 {
+        margin: 0;
+      }
+
+      .pill {
+        border-radius: 999px;
+        padding: 7px 11px;
+        font-size: 0.8rem;
+        font-weight: 700;
+      }
+
+      .pill-idle {
+        background: rgba(27, 42, 40, 0.08);
+        color: var(--muted);
+      }
+
+      .pill-ok {
+        background: rgba(19, 93, 86, 0.14);
+        color: var(--accent);
+      }
+
+      .pill-warn {
+        background: rgba(178, 92, 37, 0.14);
+        color: var(--warm);
+      }
+
+      label {
+        display: grid;
+        gap: 8px;
+        color: var(--muted);
+        font-size: 0.92rem;
+      }
+
+      input,
+      select,
+      button {
+        font: inherit;
+      }
+
+      input,
+      select {
+        width: 100%;
+        border-radius: 14px;
+        border: 1px solid rgba(27, 42, 40, 0.15);
+        background: rgba(255, 255, 255, 0.88);
+        padding: 12px 14px;
+        color: var(--ink);
+      }
+
+      .actions {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+      }
+
+      button {
+        cursor: pointer;
+        border: 0;
+        border-radius: 999px;
+        padding: 11px 16px;
+        background: linear-gradient(135deg, var(--accent), var(--accent-strong));
+        color: white;
+        font-weight: 700;
+      }
+
+      button.secondary {
+        background: rgba(27, 42, 40, 0.08);
+        color: var(--ink);
+      }
+
+      .entity-list {
+        display: grid;
+        gap: 10px;
+      }
+
+      .entity-card {
+        border-radius: 18px;
+        border: 1px solid rgba(27, 42, 40, 0.08);
+        background: rgba(255, 255, 255, 0.66);
+        padding: 14px;
+      }
+
+      .entity-card.active {
+        border-color: rgba(19, 93, 86, 0.36);
+        box-shadow: inset 0 0 0 1px rgba(19, 93, 86, 0.18);
+      }
+
+      .entity-name {
+        font-size: 1rem;
+        font-weight: 800;
+      }
+
+      .entity-meta {
+        margin-top: 6px;
+        color: var(--muted);
+        font-size: 0.84rem;
+        line-height: 1.45;
+      }
+
+      .entity-actions {
+        display: flex;
+        gap: 8px;
+        margin-top: 12px;
+      }
+
+      .json-view {
+        margin: 0;
+        border-radius: 18px;
+        background: rgba(24, 32, 31, 0.96);
+        color: #e8f0ed;
+        padding: 16px;
+        min-height: 140px;
+        max-height: 320px;
+        overflow: auto;
+        white-space: pre-wrap;
+        word-break: break-word;
+        font-family: "Cascadia Code", Consolas, monospace;
+        font-size: 0.84rem;
+      }
+
+      .stack {
+        display: grid;
+        gap: 14px;
+      }
+
+      .field-grid {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 10px;
+      }
+
+      @media (max-width: 1080px) {
+        .dashboard {
+          grid-template-columns: 1fr;
+        }
+
+        .summary-grid {
+          grid-template-columns: 1fr;
+        }
+      }
+
+      /* ── The Birth Rite ─────────────────────────────────────────── */
+
+      #rite-overlay {
+        position: fixed;
+        inset: 0;
+        z-index: 50;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 24px;
+        background:
+          radial-gradient(circle at 50% 18%, rgba(19, 93, 86, 0.35), transparent 52%),
+          radial-gradient(circle at 82% 88%, rgba(178, 92, 37, 0.22), transparent 46%),
+          linear-gradient(180deg, #0c1514 0%, #101e1c 100%);
+        color: #e9f2ee;
+        overflow-y: auto;
+      }
+
+      #rite-overlay[hidden] {
+        display: none;
+      }
+
+      .rite-stage {
+        width: min(720px, 100%);
+        margin: auto;
+        text-align: center;
+        animation: rite-fade-up 600ms ease both;
+      }
+
+      @keyframes rite-fade-up {
+        from {
+          opacity: 0;
+          transform: translateY(18px);
+        }
+        to {
+          opacity: 1;
+          transform: translateY(0);
+        }
+      }
+
+      .rite-eyebrow {
+        margin: 0 0 12px;
+        color: #d9a05b;
+        font-size: 0.78rem;
+        font-weight: 800;
+        letter-spacing: 0.32em;
+        text-transform: uppercase;
+      }
+
+      .rite-stage h2 {
+        margin: 0 0 10px;
+        font-size: clamp(1.8rem, 4vw, 2.8rem);
+        line-height: 1.05;
+      }
+
+      .rite-lede {
+        margin: 0 auto 26px;
+        max-width: 540px;
+        color: rgba(233, 242, 238, 0.72);
+        font-size: 1.02rem;
+        line-height: 1.6;
+      }
+
+      .rite-progress {
+        display: flex;
+        justify-content: center;
+        gap: 10px;
+        margin-bottom: 22px;
+        color: rgba(233, 242, 238, 0.45);
+        font-size: 0.82rem;
+        letter-spacing: 0.18em;
+        text-transform: uppercase;
+      }
+
+      .rite-progress .lit {
+        color: #d9a05b;
+      }
+
+      .rite-cards {
+        display: grid;
+        gap: 14px;
+        text-align: left;
+      }
+
+      .rite-cards.paths {
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+      }
+
+      @media (max-width: 720px) {
+        .rite-cards.paths {
+          grid-template-columns: 1fr;
+        }
+      }
+
+      .rite-card {
+        border: 1px solid rgba(233, 242, 238, 0.14);
+        border-radius: 18px;
+        padding: 18px;
+        background: rgba(233, 242, 238, 0.05);
+        cursor: pointer;
+        transition: border-color 160ms ease, background 160ms ease, transform 160ms ease;
+      }
+
+      .rite-card:hover {
+        border-color: rgba(217, 160, 91, 0.65);
+        background: rgba(217, 160, 91, 0.08);
+        transform: translateY(-2px);
+      }
+
+      .rite-card.selected {
+        border-color: #d9a05b;
+        background: rgba(217, 160, 91, 0.14);
+        box-shadow: 0 0 0 1px #d9a05b inset;
+      }
+
+      .rite-card h4 {
+        margin: 0 0 6px;
+        font-size: 1.05rem;
+        color: #f4ede0;
+      }
+
+      .rite-card p {
+        margin: 0;
+        color: rgba(233, 242, 238, 0.66);
+        font-size: 0.92rem;
+        line-height: 1.5;
+      }
+
+      .rite-card .rite-tag {
+        display: inline-block;
+        margin-bottom: 8px;
+        padding: 3px 9px;
+        border-radius: 999px;
+        background: rgba(19, 93, 86, 0.4);
+        color: #9fd5cc;
+        font-size: 0.72rem;
+        font-weight: 700;
+        letter-spacing: 0.1em;
+        text-transform: uppercase;
+      }
+
+      .rite-trial-text {
+        margin: 0 auto 22px;
+        max-width: 600px;
+        text-align: left;
+        color: rgba(233, 242, 238, 0.82);
+        font-size: 1rem;
+        line-height: 1.65;
+        border-left: 3px solid rgba(217, 160, 91, 0.55);
+        padding-left: 16px;
+      }
+
+      .rite-actions {
+        display: flex;
+        justify-content: center;
+        gap: 12px;
+        margin-top: 26px;
+      }
+
+      .rite-actions button {
+        padding: 12px 22px;
+      }
+
+      .rite-actions button:disabled {
+        opacity: 0.35;
+        cursor: default;
+      }
+
+      .rite-actions .ghost {
+        background: transparent;
+        border: 1px solid rgba(233, 242, 238, 0.25);
+        color: rgba(233, 242, 238, 0.8);
+      }
+
+      .rite-input {
+        width: min(420px, 100%);
+        margin: 0 auto;
+        border-radius: 14px;
+        border: 1px solid rgba(233, 242, 238, 0.22);
+        background: rgba(233, 242, 238, 0.07);
+        color: #f4ede0;
+        padding: 14px 16px;
+        font-size: 1.1rem;
+        text-align: center;
+      }
+
+      .rite-forge-glyph {
+        font-size: 3.4rem;
+        margin: 18px 0;
+        animation: rite-pulse 1100ms ease-in-out infinite;
+      }
+
+      @keyframes rite-pulse {
+        0%, 100% {
+          opacity: 0.45;
+          transform: scale(1);
+        }
+        50% {
+          opacity: 1;
+          transform: scale(1.12);
+        }
+      }
+
+      .rite-archetype {
+        margin: 6px 0 4px;
+        font-size: clamp(2.2rem, 5vw, 3.4rem);
+        color: #f0c98a;
+        text-shadow: 0 0 32px rgba(217, 160, 91, 0.35);
+      }
+
+      .rite-epithet {
+        margin: 0 auto 26px;
+        max-width: 480px;
+        color: rgba(233, 242, 238, 0.72);
+        font-style: italic;
+      }
+
+      .rite-stats {
+        display: grid;
+        gap: 12px;
+        width: min(460px, 100%);
+        margin: 0 auto 24px;
+        text-align: left;
+      }
+
+      .rite-stat-label {
+        display: flex;
+        justify-content: space-between;
+        font-size: 0.86rem;
+        color: rgba(233, 242, 238, 0.78);
+        margin-bottom: 5px;
+      }
+
+      .rite-stat-track {
+        height: 10px;
+        border-radius: 999px;
+        background: rgba(233, 242, 238, 0.1);
+        overflow: hidden;
+      }
+
+      .rite-stat-fill {
+        height: 100%;
+        width: 0;
+        border-radius: 999px;
+        background: linear-gradient(90deg, #135d56, #2da393);
+        transition: width 1100ms cubic-bezier(0.22, 1, 0.36, 1);
+      }
+
+      .rite-stat-fill.warm {
+        background: linear-gradient(90deg, #8a4a1e, #d9a05b);
+      }
+
+      .rite-sigil {
+        display: inline-block;
+        margin: 0 auto 20px;
+        padding: 14px 20px;
+        border-radius: 14px;
+        background: rgba(10, 18, 17, 0.85);
+        color: #9fd5cc;
+        font-family: "Cascadia Code", Consolas, monospace;
+        font-size: 0.82rem;
+        line-height: 1.35;
+        text-align: left;
+        white-space: pre;
+      }
+
+      .rite-certificate {
+        width: min(520px, 100%);
+        margin: 0 auto 24px;
+        padding: 26px;
+        border-radius: 20px;
+        border: 1px solid rgba(217, 160, 91, 0.5);
+        background:
+          radial-gradient(circle at top, rgba(217, 160, 91, 0.1), transparent 60%),
+          rgba(233, 242, 238, 0.04);
+        text-align: left;
+      }
+
+      .rite-certificate .cert-head {
+        text-align: center;
+        letter-spacing: 0.28em;
+        text-transform: uppercase;
+        font-size: 0.72rem;
+        color: #d9a05b;
+        margin-bottom: 16px;
+      }
+
+      .rite-certificate .cert-name {
+        text-align: center;
+        font-size: 1.7rem;
+        font-weight: 800;
+        color: #f4ede0;
+      }
+
+      .rite-certificate .cert-arch {
+        text-align: center;
+        color: #f0c98a;
+        margin-bottom: 18px;
+      }
+
+      .rite-certificate dl {
+        display: grid;
+        grid-template-columns: auto 1fr;
+        gap: 6px 14px;
+        margin: 0;
+        font-size: 0.84rem;
+      }
+
+      .rite-certificate dt {
+        color: rgba(233, 242, 238, 0.55);
+      }
+
+      .rite-certificate dd {
+        margin: 0;
+        color: rgba(233, 242, 238, 0.88);
+        word-break: break-all;
+        font-family: "Cascadia Code", Consolas, monospace;
+      }
+
+      .rite-error {
+        color: #f2a39a;
+        margin-top: 14px;
+        font-size: 0.9rem;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <section class="hero">
+        <div>
+          <p class="eyebrow">Control Plane</p>
+          <h1>Abigail Hive</h1>
+          <p class="lede">
+            Manage entities, inspect Hive connectivity, and issue runtime sessions from the new split-app shell instead of the placeholder splash page.
+          </p>
+        </div>
+        <div class="actions">
+          <button id="refresh-hive" type="button">Refresh Hive</button>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="summary-grid">
+          <article class="summary-card">
+            <span class="summary-label">Hive Daemon</span>
+            <div id="hive-url" class="summary-value">Loading…</div>
+          </article>
+          <article class="summary-card">
+            <span class="summary-label">Entities</span>
+            <div id="entity-count" class="summary-value">0</div>
+          </article>
+          <article class="summary-card">
+            <span class="summary-label">Hive Status</span>
+            <div id="hive-pill" class="pill pill-idle">Loading</div>
+          </article>
+        </div>
+      </section>
+
+      <section class="dashboard">
+        <div class="column">
+          <section class="panel">
+            <div class="panel-header">
+              <h2>Create Entity</h2>
+            </div>
+            <label>
+              <span>Name</span>
+              <input id="new-entity-name" type="text" placeholder="Kitchen Helper, Mentor, Storyteller…" />
+            </label>
+            <div class="actions">
+              <button id="create-entity" type="button">Create Entity</button>
+            </div>
+          </section>
+
+          <section class="panel">
+            <div class="panel-header">
+              <h2>Entities</h2>
+              <span id="entity-list-pill" class="pill pill-idle">Idle</span>
+            </div>
+            <div id="entity-list" class="entity-list"></div>
+          </section>
+        </div>
+
+        <div class="column">
+          <section class="panel">
+            <div class="panel-header">
+              <h2>Selected Entity</h2>
+              <span id="selected-pill" class="pill pill-idle">None</span>
+            </div>
+            <div id="selected-entity-meta" class="stack"></div>
+            <div class="actions" style="margin-top: 14px">
+              <button id="issue-runtime-session" type="button">Issue Runtime Session</button>
+              <button id="load-assignments" type="button" class="secondary">Load Assignments</button>
+            </div>
+          </section>
+
+          <section class="panel">
+            <div class="panel-header">
+              <h3>Provider Setup</h3>
+              <span id="provider-pill" class="pill pill-idle">Idle</span>
+            </div>
+            <div class="stack">
+              <div class="field-grid">
+                <label>
+                  <span>Provider</span>
+                  <select id="provider-name">
+                    <option value="openai">openai</option>
+                    <option value="anthropic">anthropic</option>
+                    <option value="google">google</option>
+                    <option value="xai">xai</option>
+                    <option value="openrouter">openrouter</option>
+                    <option value="deepseek">deepseek</option>
+                    <option value="mistral">mistral</option>
+                    <option value="groq">groq</option>
+                    <option value="together">together</option>
+                    <option value="fireworks">fireworks</option>
+                    <option value="cohere">cohere</option>
+                    <option value="tavily">tavily</option>
+                  </select>
+                </label>
+                <label>
+                  <span>Routing Mode</span>
+                  <select id="routing-mode">
+                    <option value="ego_primary">ego_primary</option>
+                    <option value="cli_orchestrator">cli_orchestrator</option>
+                  </select>
+                </label>
+              </div>
+              <label>
+                <span>Provider API Key</span>
+                <input id="provider-key" type="password" placeholder="Paste key (stored in Hive vault)" />
+              </label>
+              <label>
+                <span>Local LLM URL (optional)</span>
+                <input id="local-llm-url" type="text" placeholder="http://localhost:11434" />
+              </label>
+              <div class="actions">
+                <button id="store-provider-key" type="button">Save Key</button>
+                <button id="discover-models" type="button" class="secondary">Discover Models</button>
+                <button id="refresh-provider-config" type="button" class="secondary">Refresh Config</button>
+              </div>
+              <div class="field-grid">
+                <label>
+                  <span>Model (discovery)</span>
+                  <select id="model-id">
+                    <option value="">Use provider default</option>
+                  </select>
+                </label>
+                <label>
+                  <span>CLI Permission</span>
+                  <select id="cli-permission-mode">
+                    <option value="">Keep current</option>
+                    <option value="allowlist_only">allowlist_only</option>
+                    <option value="interactive">interactive</option>
+                    <option value="dangerous_skip_all">dangerous_skip_all</option>
+                  </select>
+                </label>
+              </div>
+              <div class="actions">
+                <button id="apply-provider-config" type="button">Apply Provider Config</button>
+              </div>
+            </div>
+          </section>
+
+          <section class="panel">
+            <div class="panel-header">
+              <h3>Latest Runtime Session Lease</h3>
+            </div>
+            <pre id="lease-output" class="json-view">No runtime session issued yet.</pre>
+          </section>
+
+          <section class="panel">
+            <div class="panel-header">
+              <h3>Provider Config Preview</h3>
+            </div>
+            <pre id="provider-config-output" class="json-view">Select an entity to load provider configuration.</pre>
+          </section>
+
+          <section class="panel">
+            <div class="panel-header">
+              <h3>Skill Assignments</h3>
+            </div>
+            <pre id="assignments-output" class="json-view">Select an entity to inspect its assignments.</pre>
+          </section>
+        </div>
+      </section>
+    </main>
+
+    <div id="rite-overlay" hidden>
+      <div id="rite-stage" class="rite-stage"></div>
+    </div>
+
+    <script type="module" src="./app.js"></script>
+  </body>
+</html>
diff --git a/hive-app/src/lib.rs b/hive-app/src/lib.rs
new file mode 100644
index 00000000..ab735cb3
--- /dev/null
+++ b/hive-app/src/lib.rs
@@ -0,0 +1,255 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use daemon_client::HiveDaemonClient;
+use hive_core::{
+    CreateForgeApprovalJobRequest, HiveStatus, RuntimeSessionLease, SkillAssignmentsResponse,
+    UpdateEntityConfigRequest, UpdateEntityConfigResponse,
+};
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+struct HiveConnectionInfo {
+    hive_url: String,
+}
+
+fn hive_url() -> String {
+    std::env::var("ABIGAIL_HIVE_URL").unwrap_or_else(|_| "http://127.0.0.1:3141".to_string())
+}
+
+#[tauri::command]
+async fn get_hive_status() -> Result<HiveStatus, String> {
+    let client = HiveDaemonClient::new(&hive_url());
+    let entities = client.list_entities().await.map_err(|e| e.to_string())?;
+    Ok(HiveStatus {
+        master_key_loaded: true,
+        entity_count: entities.len(),
+        entities,
+    })
+}
+
+#[tauri::command]
+fn get_hive_connection_info() -> HiveConnectionInfo {
+    HiveConnectionInfo {
+        hive_url: hive_url(),
+    }
+}
+
+#[tauri::command]
+async fn create_entity(name: String) -> Result<String, String> {
+    let client = HiveDaemonClient::new(&hive_url());
+    client.create_entity(&name).await.map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn issue_runtime_session(entity_id: String) -> Result<RuntimeSessionLease, String> {
+    let client = HiveDaemonClient::new(&hive_url());
+    client
+        .issue_runtime_session(&entity_id, Some(format!("entity-runtime-{}", entity_id)))
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn get_provider_config(entity_id: String) -> Result<hive_core::ProviderConfig, String> {
+    let client = HiveDaemonClient::new(&hive_url());
+    client
+        .get_provider_config(&entity_id)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn update_entity_provider_config(
+    entity_id: String,
+    active_provider_preference: Option<String>,
+    ego_model: Option<String>,
+    local_llm_base_url: Option<String>,
+    routing_mode: Option<String>,
+    cli_permission_mode: Option<String>,
+) -> Result<UpdateEntityConfigResponse, String> {
+    let client = HiveDaemonClient::new(&hive_url());
+    client
+        .update_entity_config(
+            &entity_id,
+            &UpdateEntityConfigRequest {
+                active_provider_preference,
+                ego_model,
+                local_llm_base_url,
+                routing_mode,
+                cli_permission_mode,
+            },
+        )
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn store_secret(key: String, value: String) -> Result<String, String> {
+    let client = HiveDaemonClient::new(&hive_url());
+    client
+        .store_secret(&key, &value)
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(format!("Secret '{}' stored", key))
+}
+
+#[tauri::command]
+async fn list_secrets() -> Result<Vec<String>, String> {
+    let client = HiveDaemonClient::new(&hive_url());
+    client.list_secrets().await.map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn discover_provider_models(
+    provider: String,
+    api_key: String,
+) -> Result<hive_core::ProviderModelsResponse, String> {
+    let client = HiveDaemonClient::new(&hive_url());
+    client
+        .discover_provider_models(&provider, &api_key)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn list_assignments(entity_id: String) -> Result<SkillAssignmentsResponse, String> {
+    let client = HiveDaemonClient::new(&hive_url());
+    client
+        .get_skill_assignments(&entity_id)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn approve_forge_job(
+    entity_id: String,
+    skill_id: String,
+    code_path: String,
+    markdown_path: String,
+) -> Result<hive_core::ForgeApprovalJob, String> {
+    let client = reqwest::Client::new();
+    let base_url = hive_url();
+    let response: hive_core::ApiEnvelope<hive_core::ForgeApprovalJob> = client
+        .post(format!(
+            "{}/v1/entities/{}/forge-approvals",
+            base_url, entity_id
+        ))
+        .json(&CreateForgeApprovalJobRequest {
+            skill_id,
+            code_path,
+            markdown_path,
+            correlation_id: None,
+        })
+        .send()
+        .await
+        .map_err(|e| e.to_string())?
+        .json()
+        .await
+        .map_err(|e| e.to_string())?;
+    if response.ok {
+        response
+            .data
+            .ok_or_else(|| "Missing forge approval response data".to_string())
+    } else {
+        Err(response
+            .error
+            .unwrap_or_else(|| "Unknown forge approval error".to_string()))
+    }
+}
+
+async fn hive_get<T: serde::de::DeserializeOwned>(path: &str) -> Result<T, String> {
+    let response: hive_core::ApiEnvelope<T> = reqwest::Client::new()
+        .get(format!("{}{}", hive_url(), path))
+        .send()
+        .await
+        .map_err(|e| e.to_string())?
+        .json()
+        .await
+        .map_err(|e| e.to_string())?;
+    if response.ok {
+        response
+            .data
+            .ok_or_else(|| "Missing response data".to_string())
+    } else {
+        Err(response
+            .error
+            .unwrap_or_else(|| "Unknown hive error".to_string()))
+    }
+}
+
+async fn hive_post<T: serde::de::DeserializeOwned, B: Serialize>(
+    path: &str,
+    body: &B,
+) -> Result<T, String> {
+    let response: hive_core::ApiEnvelope<T> = reqwest::Client::new()
+        .post(format!("{}{}", hive_url(), path))
+        .json(body)
+        .send()
+        .await
+        .map_err(|e| e.to_string())?
+        .json()
+        .await
+        .map_err(|e| e.to_string())?;
+    if response.ok {
+        response
+            .data
+            .ok_or_else(|| "Missing response data".to_string())
+    } else {
+        Err(response
+            .error
+            .unwrap_or_else(|| "Unknown hive error".to_string()))
+    }
+}
+
+#[tauri::command]
+async fn get_birth_scenarios() -> Result<hive_core::ForgeScenariosResponse, String> {
+    hive_get("/v1/birth/scenarios").await
+}
+
+#[tauri::command]
+async fn perform_birth(
+    entity_id: String,
+    path: String,
+    choices: Vec<(String, String)>,
+) -> Result<hive_core::BirthRiteResponse, String> {
+    hive_post(
+        &format!("/v1/entities/{}/birth", entity_id),
+        &hive_core::BirthRiteRequest { path, choices },
+    )
+    .await
+}
+
+#[tauri::command]
+async fn get_birth_document(entity_id: String) -> Result<hive_core::EntityBirthDocument, String> {
+    hive_get(&format!("/v1/entities/{}/birth", entity_id)).await
+}
+
+pub fn run() {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "abigail_hive_app=info".into()),
+        )
+        .init();
+
+    tauri::Builder::default()
+        .plugin(tauri_plugin_dialog::init())
+        .invoke_handler(tauri::generate_handler![
+            get_hive_connection_info,
+            get_hive_status,
+            create_entity,
+            issue_runtime_session,
+            get_provider_config,
+            update_entity_provider_config,
+            store_secret,
+            list_secrets,
+            discover_provider_models,
+            list_assignments,
+            approve_forge_job,
+            get_birth_scenarios,
+            perform_birth,
+            get_birth_document
+        ])
+        .run(tauri::generate_context!())
+        .expect("failed to run Abigail Hive app");
+}
diff --git a/hive-app/src/main.rs b/hive-app/src/main.rs
new file mode 100644
index 00000000..3ec3f3d9
--- /dev/null
+++ b/hive-app/src/main.rs
@@ -0,0 +1,5 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    abigail_hive_desktop::run();
+}
diff --git a/hive-app/tauri.conf.json b/hive-app/tauri.conf.json
new file mode 100644
index 00000000..0439b055
--- /dev/null
+++ b/hive-app/tauri.conf.json
@@ -0,0 +1,26 @@
+{
+  "productName": "Abigail Hive",
+  "version": "0.0.1",
+  "identifier": "com.abigail.hive",
+  "build": {
+    "frontendDist": "dist"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "Abigail Hive",
+        "width": 1280,
+        "height": 860,
+        "resizable": true
+      }
+    ]
+  },
+  "bundle": {
+    "active": false,
+    "icon": [
+      "../tauri-app/icons/32x32.png",
+      "../tauri-app/icons/128x128.png",
+      "../tauri-app/icons/icon.ico"
+    ]
+  }
+}
diff --git a/scripts/check_crypto_claims.mjs b/scripts/check_crypto_claims.mjs
index 4b5b5bf5..bdb74387 100644
--- a/scripts/check_crypto_claims.mjs
+++ b/scripts/check_crypto_claims.mjs
@@ -401,14 +401,9 @@ const claims = [
           "Verify updater artifacts",
         ],
       },
-      {
-        path: ".github/workflows/release-fast.yml",
-        markers: [
-          "Configure updater and signing fields in tauri.conf.json",
-          "Validate updater signing key",
-          "Verify updater artifacts",
-        ],
-      },
+      // release-fast.yml is the unsigned stabilization lane: signing and
+      // updater verification are intentionally absent there, so the claim
+      // only binds to the official release workflow above.
     ],
   },
 ];
diff --git a/scripts/check_unsigned_stabilization.mjs b/scripts/check_unsigned_stabilization.mjs
new file mode 100644
index 00000000..d1aa3a11
--- /dev/null
+++ b/scripts/check_unsigned_stabilization.mjs
@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+
+function readJson(path) {
+  return JSON.parse(fs.readFileSync(path, "utf8"));
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+const tauriConfig = readJson("tauri-app/tauri.conf.json");
+assert(
+  tauriConfig.bundle?.createUpdaterArtifacts === false,
+  "Unsigned stabilization lane must keep createUpdaterArtifacts disabled by default."
+);
+assert(
+  !tauriConfig.plugins?.updater,
+  "Unsigned stabilization lane must not ship updater config in tauri.conf.json."
+);
+
+const nsisHooks = fs.readFileSync("tauri-app/nsis-hooks.nsh", "utf8");
+for (const forbidden of [
+  "BackupUserData",
+  "RestoreUserData",
+  "CheckForExistingInstall",
+  "ShowUpgradeDialog",
+  "abigail_upgrade_backup",
+]) {
+  assert(
+    !nsisHooks.includes(forbidden),
+    `NSIS hooks must not retain alpha upgrade preservation logic (${forbidden}).`
+  );
+}
+
+const releaseFast = fs.readFileSync(".github/workflows/release-fast.yml", "utf8");
+assert(
+  releaseFast.includes("workflow_dispatch:"),
+  "Stabilization build lane must stay manual/opt-in."
+);
+assert(
+  !releaseFast.includes("\n  push:\n"),
+  "Stabilization build lane must not trigger automatically."
+);
+for (const forbidden of [
+  "TAURI_UPDATER_PUBKEY",
+  "TAURI_SIGNING_PRIVATE_KEY",
+  "windows_signing_preflight",
+  "generate_tauri_latest_manifest",
+  "createUpdaterArtifacts must be true",
+]) {
+  assert(
+    !releaseFast.includes(forbidden),
+    `Unsigned stabilization workflow must not require updater/signing logic (${forbidden}).`
+  );
+}
+assert(
+  releaseFast.includes("cargo build --release -p abigail-hive-app -p abigail-entity-runtime-app"),
+  "Unsigned stabilization workflow must build the split Hive and Entity Runtime apps."
+);
+
+const release = fs.readFileSync(".github/workflows/release.yml", "utf8");
+assert(
+  release.includes("tags:"),
+  "Beta/release lane must stay explicit via tags or manual dispatch."
+);
+
+const prereqs = fs.readFileSync("scripts/enforce_release_prereqs.sh", "utf8");
+assert(
+  prereqs.includes("Release prerequisite enforcement skipped"),
+  "Release prerequisite script must be able to skip signing enforcement when disabled."
+);
+
+console.log("Unsigned stabilization lane checks passed.");
diff --git a/scripts/dev/launch_split_stack.ps1 b/scripts/dev/launch_split_stack.ps1
new file mode 100644
index 00000000..73a4d7a8
--- /dev/null
+++ b/scripts/dev/launch_split_stack.ps1
@@ -0,0 +1,254 @@
+param(
+    [int]$HivePort = 43141,
+    [int]$RuntimePort = 43142,
+    [int]$HarnessPort = 43143,
+    [string]$EntityName = "Stability Reset Test Entity",
+    [switch]$SkipDesktopApps,
+    [switch]$LaunchBrowserHarness,
+    [switch]$NoBrowserFallback,
+    [switch]$OpenBrowser = $true
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+function Get-WorkspaceRoot {
+    return (Resolve-Path (Join-Path $PSScriptRoot "..\..")).Path
+}
+
+function Get-DevTargetDir {
+    if ($env:CARGO_TARGET_DIR -and $env:CARGO_TARGET_DIR.Trim()) {
+        return $env:CARGO_TARGET_DIR
+    }
+
+    $localAppData = [Environment]::GetFolderPath("LocalApplicationData")
+    return Join-Path $localAppData "Abigail\cargo-target"
+}
+
+function Wait-HttpOk {
+    param(
+        [Parameter(Mandatory = $true)][string]$Url,
+        [int]$TimeoutSeconds = 45
+    )
+
+    $deadline = (Get-Date).AddSeconds($TimeoutSeconds)
+    while ((Get-Date) -lt $deadline) {
+        try {
+            $response = Invoke-WebRequest -Uri $Url -UseBasicParsing -TimeoutSec 2
+            if ($response.StatusCode -eq 200) {
+                return
+            }
+        } catch {
+        }
+        Start-Sleep -Milliseconds 300
+    }
+
+    throw "Timed out waiting for $Url"
+}
+
+function Invoke-CargoOrThrow {
+    param(
+        [Parameter(Mandatory = $true)][string[]]$Arguments,
+        [Parameter(Mandatory = $true)][string]$FailureMessage
+    )
+
+    & $script:cargo @Arguments
+    if ($LASTEXITCODE -ne 0) {
+        throw $FailureMessage
+    }
+}
+
+$workspaceRoot = Get-WorkspaceRoot
+$sessionRoot = Join-Path $workspaceRoot "target\manual-test\stability-reset"
+$logsRoot = Join-Path $sessionRoot "logs"
+$dataRoot = Join-Path $sessionRoot "data"
+$sessionPath = Join-Path $sessionRoot "session.json"
+$diagnosticPath = Join-Path $sessionRoot "policy-diagnostic.json"
+$stopScript = Join-Path $PSScriptRoot "stop_split_stack.ps1"
+$hiveUrl = "http://127.0.0.1:$HivePort"
+$runtimeUrl = "http://127.0.0.1:$RuntimePort"
+$harnessUrl = "http://127.0.0.1:$HarnessPort"
+$targetDir = Get-DevTargetDir
+
+New-Item -ItemType Directory -Force -Path $logsRoot | Out-Null
+New-Item -ItemType Directory -Force -Path $dataRoot | Out-Null
+New-Item -ItemType Directory -Force -Path $targetDir | Out-Null
+
+if (Test-Path $sessionPath) {
+    & $stopScript -SessionPath $sessionPath -Quiet
+}
+
+$env:CARGO_TARGET_DIR = $targetDir
+$script:cargo = (Get-Command cargo).Source
+$node = (Get-Command node).Source
+
+Write-Host "Using CARGO_TARGET_DIR=$targetDir"
+Write-Host "Building Hive and Entity daemons..."
+Invoke-CargoOrThrow -Arguments @("build", "-p", "hive-daemon", "-p", "entity-daemon") -FailureMessage "Failed to build Hive and Entity daemons."
+
+$desktopBuildSucceeded = $SkipDesktopApps.IsPresent
+$desktopBuildError = $null
+$diagnosticSummary = $null
+
+if (-not $SkipDesktopApps) {
+    try {
+        Write-Host "Building Abigail Hive desktop shell..."
+        Invoke-CargoOrThrow -Arguments @("build", "-p", "abigail-hive-app", "--bin", "abigail-hive-app") -FailureMessage "Failed to build Abigail Hive desktop shell."
+        Write-Host "Building Abigail Entity Runtime desktop shell..."
+        Invoke-CargoOrThrow -Arguments @("build", "-p", "abigail-entity-runtime-app", "--bin", "abigail-entity-runtime-app") -FailureMessage "Failed to build Abigail Entity Runtime desktop shell."
+        $desktopBuildSucceeded = $true
+    } catch {
+        $desktopBuildError = $_
+        Write-Warning "Desktop build failed; collecting Windows policy diagnostics."
+        try {
+            $diagnosticSummary = & (Join-Path $workspaceRoot "scripts\diagnose_windows_build_policy.ps1") `
+                -OutputPath $diagnosticPath `
+                -TargetDir $targetDir |
+                ConvertFrom-Json
+        } catch {
+            if (Test-Path $diagnosticPath) {
+                $diagnosticSummary = Get-Content $diagnosticPath | ConvertFrom-Json
+            }
+        }
+    }
+}
+
+$hiveExe = Join-Path $targetDir "debug\hive-daemon.exe"
+$runtimeExe = Join-Path $targetDir "debug\entity-daemon.exe"
+$hiveAppExe = Join-Path $targetDir "debug\abigail-hive-app.exe"
+$runtimeAppExe = Join-Path $targetDir "debug\abigail-entity-runtime-app.exe"
+
+$hiveOut = Join-Path $logsRoot "hive-daemon.out.log"
+$hiveErr = Join-Path $logsRoot "hive-daemon.err.log"
+$runtimeOut = Join-Path $logsRoot "entity-daemon.out.log"
+$runtimeErr = Join-Path $logsRoot "entity-daemon.err.log"
+$harnessOut = Join-Path $logsRoot "browser-harness.out.log"
+$harnessErr = Join-Path $logsRoot "browser-harness.err.log"
+
+Write-Host "Starting Hive daemon..."
+$hiveProc = Start-Process -FilePath $hiveExe `
+    -ArgumentList @("--port", "$HivePort", "--data-dir", $dataRoot) `
+    -WorkingDirectory $workspaceRoot `
+    -RedirectStandardOutput $hiveOut `
+    -RedirectStandardError $hiveErr `
+    -PassThru
+Wait-HttpOk -Url "$hiveUrl/health" -TimeoutSeconds 30
+
+Write-Host "Creating test entity..."
+$entityResponse = Invoke-RestMethod -Method Post `
+    -Uri "$hiveUrl/v1/entities" `
+    -ContentType "application/json" `
+    -Body (@{ name = $EntityName } | ConvertTo-Json)
+if (-not $entityResponse.ok) {
+    throw "Hive failed to create test entity."
+}
+$entityId = $entityResponse.data.id
+
+Write-Host "Starting Entity Runtime daemon..."
+$runtimeProc = Start-Process -FilePath $runtimeExe `
+    -ArgumentList @("--entity-id", $entityId, "--hive-url", $hiveUrl, "--port", "$RuntimePort", "--data-dir", $dataRoot) `
+    -WorkingDirectory $workspaceRoot `
+    -RedirectStandardOutput $runtimeOut `
+    -RedirectStandardError $runtimeErr `
+    -PassThru
+Wait-HttpOk -Url "$runtimeUrl/health" -TimeoutSeconds 45
+
+$browserHarnessProc = $null
+$hiveAppProc = $null
+$runtimeAppProc = $null
+$mode = "desktop"
+
+if ($desktopBuildSucceeded -and -not $SkipDesktopApps) {
+    Write-Host "Launching Abigail Hive desktop shell..."
+    $hiveAppProc = Start-Process -FilePath $hiveAppExe `
+        -WorkingDirectory (Join-Path $workspaceRoot "hive-app") `
+        -Environment @{
+            ABIGAIL_HIVE_URL = $hiveUrl
+            CARGO_TARGET_DIR = $targetDir
+        } `
+        -PassThru
+
+    Write-Host "Launching Abigail Entity Runtime desktop shell..."
+    $runtimeAppProc = Start-Process -FilePath $runtimeAppExe `
+        -WorkingDirectory (Join-Path $workspaceRoot "entity-runtime-app") `
+        -Environment @{
+            ABIGAIL_ENTITY_URL = $runtimeUrl
+            CARGO_TARGET_DIR = $targetDir
+        } `
+        -PassThru
+} elseif (-not $NoBrowserFallback) {
+    $mode = "browser_fallback"
+    Write-Warning "Desktop shells are unavailable on this machine right now; starting the browser harness instead."
+    $browserHarnessProc = Start-Process -FilePath $node `
+        -ArgumentList @(
+            (Join-Path $workspaceRoot "scripts\dev\run_browser_harness.mjs"),
+            "--port",
+            "$HarnessPort",
+            "--hive-url",
+            $hiveUrl,
+            "--runtime-url",
+            $runtimeUrl
+        ) `
+        -WorkingDirectory $workspaceRoot `
+        -RedirectStandardOutput $harnessOut `
+        -RedirectStandardError $harnessErr `
+        -PassThru
+    Wait-HttpOk -Url "$harnessUrl/" -TimeoutSeconds 15
+    if ($OpenBrowser) {
+        Start-Process $harnessUrl | Out-Null
+    }
+} else {
+    throw "Desktop shells failed to build and browser fallback is disabled."
+}
+
+if ($LaunchBrowserHarness -and -not $browserHarnessProc) {
+    $browserHarnessProc = Start-Process -FilePath $node `
+        -ArgumentList @(
+            (Join-Path $workspaceRoot "scripts\dev\run_browser_harness.mjs"),
+            "--port",
+            "$HarnessPort",
+            "--hive-url",
+            $hiveUrl,
+            "--runtime-url",
+            $runtimeUrl
+        ) `
+        -WorkingDirectory $workspaceRoot `
+        -RedirectStandardOutput $harnessOut `
+        -RedirectStandardError $harnessErr `
+        -PassThru
+    Wait-HttpOk -Url "$harnessUrl/" -TimeoutSeconds 15
+}
+
+$session = [ordered]@{
+    mode = $mode
+    target_dir = $targetDir
+    hive_url = $hiveUrl
+    runtime_url = $runtimeUrl
+    browser_harness_url = if ($browserHarnessProc) { $harnessUrl } else { $null }
+    entity_id = $entityId
+    data_dir = $dataRoot
+    session_path = $sessionPath
+    diagnostic_path = if (Test-Path $diagnosticPath) { $diagnosticPath } else { $null }
+    desktop_build_succeeded = $desktopBuildSucceeded
+    desktop_build_error = if ($desktopBuildError) { $desktopBuildError.Exception.Message } else { $null }
+    hive_daemon_pid = $hiveProc.Id
+    entity_daemon_pid = $runtimeProc.Id
+    hive_app_pid = if ($hiveAppProc) { $hiveAppProc.Id } else { $null }
+    entity_app_pid = if ($runtimeAppProc) { $runtimeAppProc.Id } else { $null }
+    browser_harness_pid = if ($browserHarnessProc) { $browserHarnessProc.Id } else { $null }
+    hive_stdout = $hiveOut
+    hive_stderr = $hiveErr
+    runtime_stdout = $runtimeOut
+    runtime_stderr = $runtimeErr
+    browser_harness_stdout = if ($browserHarnessProc) { $harnessOut } else { $null }
+    browser_harness_stderr = if ($browserHarnessProc) { $harnessErr } else { $null }
+    launched_at_utc = [DateTime]::UtcNow.ToString("o")
+}
+
+if ($diagnosticSummary) {
+    $session.policy_diagnostic = $diagnosticSummary
+}
+
+$sessionJson = $session | ConvertTo-Json -Depth 8
+$sessionJson | Set-Content -Path $sessionPath
+$sessionJson
diff --git a/scripts/dev/run_browser_harness.mjs b/scripts/dev/run_browser_harness.mjs
new file mode 100644
index 00000000..2e272953
--- /dev/null
+++ b/scripts/dev/run_browser_harness.mjs
@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..", "..");
+const harnessRoot = path.join(repoRoot, "dev-harness");
+
+function parseArgs(argv) {
+  const config = {
+    port: 43143,
+    hiveUrl: "http://127.0.0.1:43141",
+    runtimeUrl: "http://127.0.0.1:43142",
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const value = argv[index + 1];
+    if (arg === "--port" && value) {
+      config.port = Number.parseInt(value, 10);
+      index += 1;
+    } else if (arg === "--hive-url" && value) {
+      config.hiveUrl = value;
+      index += 1;
+    } else if (arg === "--runtime-url" && value) {
+      config.runtimeUrl = value;
+      index += 1;
+    }
+  }
+
+  return config;
+}
+
+function contentTypeFor(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".js":
+      return "application/javascript; charset=utf-8";
+    case ".json":
+      return "application/json; charset=utf-8";
+    case ".html":
+    default:
+      return "text/html; charset=utf-8";
+  }
+}
+
+const config = parseArgs(process.argv.slice(2));
+
+const server = http.createServer((request, response) => {
+  const url = new URL(request.url ?? "/", `http://127.0.0.1:${config.port}`);
+
+  if (url.pathname === "/config.json") {
+    response.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+    response.end(
+      JSON.stringify(
+        {
+          hiveUrl: config.hiveUrl,
+          runtimeUrl: config.runtimeUrl,
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
+  const safePath = path.normalize(relativePath).replace(/^(\.\.[/\\])+/, "");
+  const filePath = path.join(harnessRoot, safePath);
+
+  if (!filePath.startsWith(harnessRoot) || !fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+    response.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+    response.end("Not found");
+    return;
+  }
+
+  response.writeHead(200, { "Content-Type": contentTypeFor(filePath) });
+  fs.createReadStream(filePath).pipe(response);
+});
+
+server.listen(config.port, "127.0.0.1", () => {
+  console.log(`Browser harness listening on http://127.0.0.1:${config.port}`);
+});
diff --git a/scripts/dev/stop_split_stack.ps1 b/scripts/dev/stop_split_stack.ps1
new file mode 100644
index 00000000..55a5f2be
--- /dev/null
+++ b/scripts/dev/stop_split_stack.ps1
@@ -0,0 +1,61 @@
+param(
+    [string]$SessionPath = "",
+    [switch]$Quiet
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+function Get-WorkspaceRoot {
+    return (Resolve-Path (Join-Path $PSScriptRoot "..\..")).Path
+}
+
+$workspaceRoot = Get-WorkspaceRoot
+$resolvedSessionPath = if ($SessionPath) {
+    $SessionPath
+} else {
+    Join-Path $workspaceRoot "target\manual-test\stability-reset\session.json"
+}
+
+if (-not (Test-Path $resolvedSessionPath)) {
+    if (-not $Quiet) {
+        Write-Host "No split-stack session file found at $resolvedSessionPath"
+    }
+    exit 0
+}
+
+$session = Get-Content $resolvedSessionPath | ConvertFrom-Json
+$pidFields = @(
+    "hive_daemon_pid",
+    "entity_daemon_pid",
+    "hive_app_pid",
+    "entity_app_pid",
+    "browser_harness_pid"
+)
+
+foreach ($field in $pidFields) {
+    $property = $session.PSObject.Properties[$field]
+    if (-not $property) {
+        continue
+    }
+
+    $processId = $property.Value
+    if (-not $processId) {
+        continue
+    }
+
+    try {
+        $process = Get-Process -Id $processId -ErrorAction Stop
+        Stop-Process -Id $process.Id -ErrorAction Stop
+        if (-not $Quiet) {
+            Write-Host "Stopped $field ($processId)"
+        }
+    } catch {
+        if (-not $Quiet) {
+            Write-Warning "Could not stop $field ($processId): $($_.Exception.Message)"
+        }
+    }
+}
+
+$session | Add-Member -NotePropertyName stopped_at_utc -NotePropertyValue ([DateTime]::UtcNow.ToString("o")) -Force
+($session | ConvertTo-Json -Depth 8) | Set-Content -Path $resolvedSessionPath
diff --git a/scripts/diagnose_windows_build_policy.ps1 b/scripts/diagnose_windows_build_policy.ps1
new file mode 100644
index 00000000..944f23ad
--- /dev/null
+++ b/scripts/diagnose_windows_build_policy.ps1
@@ -0,0 +1,118 @@
+param(
+    [string]$Package = "abigail-hive-app",
+    [string]$Binary = "abigail-hive-app",
+    [string]$TargetDir = "",
+    [string]$OutputPath = ""
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+function Get-WorkspaceRoot {
+    return (Resolve-Path (Join-Path $PSScriptRoot "..")).Path
+}
+
+function Get-DefaultTargetDir {
+    $localAppData = [Environment]::GetFolderPath("LocalApplicationData")
+    return Join-Path $localAppData "Abigail\cargo-target"
+}
+
+function Extract-PolicyId {
+    param([string]$Message)
+
+    if ($Message -match "Policy ID:\{(?<policy>[^\}]+)\}") {
+        return $Matches.policy
+    }
+
+    return $null
+}
+
+function Extract-BlockedExe {
+    param([string]$Message)
+
+    if ($Message -match "attempted to load (?<exe>.+?) that did not meet") {
+        return $Matches.exe
+    }
+
+    return $null
+}
+
+$workspaceRoot = Get-WorkspaceRoot
+$resolvedTargetDir = if ($TargetDir) { $TargetDir } else { Get-DefaultTargetDir }
+$cargo = (Get-Command cargo).Source
+$buildStartedAt = Get-Date
+
+New-Item -ItemType Directory -Force -Path $resolvedTargetDir | Out-Null
+$env:CARGO_TARGET_DIR = $resolvedTargetDir
+
+$cargoArgs = @("build", "-p", $Package, "--bin", $Binary)
+$cargoCommand = "$cargo $($cargoArgs -join ' ')"
+
+$buildOutput = & $cargo @cargoArgs 2>&1
+$exitCode = $LASTEXITCODE
+$buildText = ($buildOutput | ForEach-Object { "$_" }) -join [Environment]::NewLine
+
+$ciEvents = @()
+try {
+    $ciEvents = Get-WinEvent -LogName "Microsoft-Windows-CodeIntegrity/Operational" -MaxEvents 200 |
+        Where-Object { $_.TimeCreated -ge $buildStartedAt.AddSeconds(-2) }
+} catch {
+    $ciEvents = @()
+}
+
+$relevantEvent = $ciEvents |
+    Where-Object {
+        $_.Id -in 3033, 3077 -and
+        ($_.Message -match [regex]::Escape("build-script-build.exe") -or $_.Message -match [regex]::Escape("cargo.exe"))
+    } |
+    Sort-Object TimeCreated -Descending |
+    Select-Object -First 1
+
+$summary = [ordered]@{
+    success = ($exitCode -eq 0)
+    package = $Package
+    binary = $Binary
+    cargo_command = $cargoCommand
+    target_dir = $resolvedTargetDir
+    timestamp_utc = [DateTime]::UtcNow.ToString("o")
+    build_exit_code = $exitCode
+    blocked_exe = $null
+    event_id = $null
+    policy_id = $null
+    build_output_excerpt = if ($buildText.Length -gt 4000) { $buildText.Substring(0, 4000) } else { $buildText }
+}
+
+if ($relevantEvent) {
+    $summary.success = $false
+    $summary.blocked_exe = Extract-BlockedExe -Message $relevantEvent.Message
+    $summary.event_id = $relevantEvent.Id
+    $summary.policy_id = Extract-PolicyId -Message $relevantEvent.Message
+    $summary.timestamp_utc = $relevantEvent.TimeCreated.ToUniversalTime().ToString("o")
+}
+
+if (-not $relevantEvent -and $buildText -match "os error 4551") {
+    $summary.success = $false
+    $summary.blocked_exe = "build-script-build.exe"
+}
+
+$json = $summary | ConvertTo-Json -Depth 6
+
+if ($OutputPath) {
+    $outputDir = Split-Path -Parent $OutputPath
+    if ($outputDir) {
+        New-Item -ItemType Directory -Force -Path $outputDir | Out-Null
+    }
+    $json | Set-Content -Path $OutputPath
+}
+
+$json
+
+if (-not $summary.success -and $summary.blocked_exe) {
+    Write-Error "Windows application-control policy blocked Cargo from executing '$($summary.blocked_exe)'. Allow cargo.exe to execute build artifacts under '$resolvedTargetDir'."
+    exit 1
+}
+
+if (-not $summary.success) {
+    Write-Error "Desktop build probe failed. See JSON summary above for the captured cargo command and output."
+    exit 2
+}
diff --git a/scripts/prepare_tauri_bundle_config.mjs b/scripts/prepare_tauri_bundle_config.mjs
index 71e3bc61..10c24402 100644
--- a/scripts/prepare_tauri_bundle_config.mjs
+++ b/scripts/prepare_tauri_bundle_config.mjs
@@ -105,13 +105,15 @@ const config = JSON.parse(raw);
 config.bundle ??= {};
 config.bundle.windows ??= {};
 config.plugins ??= {};
-config.plugins.updater ??= {};
 
 const createUpdaterArtifacts = Boolean(normalizedUpdaterPubkey.encoded) && enableUpdaterArtifacts;
 config.bundle.createUpdaterArtifacts = createUpdaterArtifacts;
 
 if (normalizedUpdaterPubkey.encoded) {
+  config.plugins.updater ??= {};
   config.plugins.updater.pubkey = normalizedUpdaterPubkey.encoded;
+} else if (config.plugins.updater) {
+  delete config.plugins.updater;
 }
 
 if (windowsThumbprint) {
diff --git a/skills/skill-web-search/src/lib.rs b/skills/skill-web-search/src/lib.rs
index 71975a1b..0ae306e4 100644
--- a/skills/skill-web-search/src/lib.rs
+++ b/skills/skill-web-search/src/lib.rs
@@ -260,7 +260,7 @@ mod tests {
         let params = ToolParams::new().with("query", "where does Elon Musk live");
         let ctx = ExecutionContext {
             request_id: "test".to_string(),
-            user_id: None,
+            ..Default::default()
         };
 
         let result = skill
@@ -284,7 +284,7 @@ mod tests {
         let params = ToolParams::new().with("query", "test query");
         let ctx = ExecutionContext {
             request_id: "test".to_string(),
-            user_id: None,
+            ..Default::default()
         };
 
         let result = skill.execute_tool("web_search", params, &ctx).await;
diff --git a/tauri-app/nsis-hooks.nsh b/tauri-app/nsis-hooks.nsh
index 214c8a56..676d6661 100644
--- a/tauri-app/nsis-hooks.nsh
+++ b/tauri-app/nsis-hooks.nsh
@@ -1,189 +1,36 @@
 ; Abigail NSIS installer hooks
-; Handles identity setup, LLM detection/installation, and upgrade detection
-;
-; Note: Tauri NSIS hooks don't support custom pages (nsDialogs).
-; We use MessageBox dialogs and PowerShell for interactive prompts.
-
-; ============================================================================
-; VARIABLES
-; ============================================================================
-Var UpgradeDetected      ; "1" if existing install found, "0" otherwise
-Var PreserveData         ; "1" to preserve, "0" for fresh install
-Var ExistingVersion      ; Version string of existing install
-Var TempResult           ; Temp variable for function results
-
-; ============================================================================
-; (LLM detection removed — Ollama is bundled with the app)
-; ============================================================================
-
-; ============================================================================
-; UPGRADE DETECTION
-; ============================================================================
-
-Function CheckForExistingInstall
-  ; Check registry for existing version
-  ReadRegStr $ExistingVersion HKCU "Software\abigail\Abigail" "Version"
-  StrCmp $ExistingVersion "" CheckDataDir FoundInRegistry
-
-FoundInRegistry:
-  StrCpy $UpgradeDetected "1"
-  Return
-
-CheckDataDir:
-  ; Check if data directory exists with config.json
-  ReadEnvStr $0 LOCALAPPDATA
-  IfFileExists "$0\abigail\Abigail\config.json" FoundDataDir NoExistingInstall
-
-FoundDataDir:
-  StrCpy $UpgradeDetected "1"
-  StrCpy $ExistingVersion "unknown"
-  Return
-
-NoExistingInstall:
-  StrCpy $UpgradeDetected "0"
-FunctionEnd
-
-; ============================================================================
-; DATA BACKUP/RESTORE (for upgrades)
-; ============================================================================
-
-Function BackupUserData
-  ReadEnvStr $0 LOCALAPPDATA
-  StrCpy $1 "$0\abigail\Abigail"
-  StrCpy $2 "$TEMP\abigail_upgrade_backup"
-
-  ; Create backup directory
-  CreateDirectory $2
-  CreateDirectory "$2\docs"
-
-  ; Backup files (using PowerShell for reliability)
-  ; Files: config.json, Hive-owned memory store, legacy migration inputs, external_pubkey.bin,
-  ;        legacy/new vault files, docs/, and Hive files (global_settings.json, master.key,
-  ;        install_upgrade_state.json, identities/)
-  nsExec::ExecToStack 'powershell -ExecutionPolicy Bypass -Command "$$src = \"$1\"; $$dst = \"$2\"; if (Test-Path \"$$src\config.json\") { Copy-Item \"$$src\config.json\" \"$$dst\config.json\" -Force }; if (Test-Path \"$$src\memory.db\") { Copy-Item \"$$src\memory.db\" \"$$dst\memory.db\" -Force -Recurse }; if (Test-Path \"$$src\abigail_seed.db\") { Copy-Item \"$$src\abigail_seed.db\" \"$$dst\abigail_seed.db\" -Force }; if (Test-Path \"$$src\abigail_seed.db-wal\") { Copy-Item \"$$src\abigail_seed.db-wal\" \"$$dst\abigail_seed.db-wal\" -Force }; if (Test-Path \"$$src\abigail_seed.db-shm\") { Copy-Item \"$$src\abigail_seed.db-shm\" \"$$dst\abigail_seed.db-shm\" -Force }; if (Test-Path \"$$src\abigail_memory.db\") { Copy-Item \"$$src\abigail_memory.db\" \"$$dst\abigail_memory.db\" -Force }; if (Test-Path \"$$src\abigail_memory.db-wal\") { Copy-Item \"$$src\abigail_memory.db-wal\" \"$$dst\abigail_memory.db-wal\" -Force }; if (Test-Path \"$$src\abigail_memory.db-shm\") { Copy-Item \"$$src\abigail_memory.db-shm\" \"$$dst\abigail_memory.db-shm\" -Force }; if (Test-Path \"$$src\jobs.db\") { Copy-Item \"$$src\jobs.db\" \"$$dst\jobs.db\" -Force }; if (Test-Path \"$$src\jobs.db-wal\") { Copy-Item \"$$src\jobs.db-wal\" \"$$dst\jobs.db-wal\" -Force }; if (Test-Path \"$$src\jobs.db-shm\") { Copy-Item \"$$src\jobs.db-shm\" \"$$dst\jobs.db-shm\" -Force }; if (Test-Path \"$$src\calendar.db\") { Copy-Item \"$$src\calendar.db\" \"$$dst\calendar.db\" -Force }; if (Test-Path \"$$src\kb.db\") { Copy-Item \"$$src\kb.db\" \"$$dst\kb.db\" -Force }; if (Test-Path \"$$src\external_pubkey.bin\") { Copy-Item \"$$src\external_pubkey.bin\" \"$$dst\external_pubkey.bin\" -Force }; if (Test-Path \"$$src\secrets.bin\") { Copy-Item \"$$src\secrets.bin\" \"$$dst\secrets.bin\" -Force }; if (Test-Path \"$$src\secrets.vault\") { Copy-Item \"$$src\secrets.vault\" \"$$dst\secrets.vault\" -Force }; if (Test-Path \"$$src\skills.bin\") { Copy-Item \"$$src\skills.bin\" \"$$dst\skills.bin\" -Force }; if (Test-Path \"$$src\skills.vault\") { Copy-Item \"$$src\skills.vault\" \"$$dst\skills.vault\" -Force }; if (Test-Path \"$$src\keys.bin\") { Copy-Item \"$$src\keys.bin\" \"$$dst\keys.bin\" -Force }; if (Test-Path \"$$src\keys.vault\") { Copy-Item \"$$src\keys.vault\" \"$$dst\keys.vault\" -Force }; if (Test-Path \"$$src\vault.sentinel\") { Copy-Item \"$$src\vault.sentinel\" \"$$dst\vault.sentinel\" -Force }; if (Test-Path \"$$src\docs\") { Copy-Item \"$$src\docs\*\" \"$$dst\docs\\" -Force -Recurse }; if (Test-Path \"$$src\global_settings.json\") { Copy-Item \"$$src\global_settings.json\" \"$$dst\global_settings.json\" -Force }; if (Test-Path \"$$src\install_upgrade_state.json\") { Copy-Item \"$$src\install_upgrade_state.json\" \"$$dst\install_upgrade_state.json\" -Force }; if (Test-Path \"$$src\master.key\") { Copy-Item \"$$src\master.key\" \"$$dst\master.key\" -Force }; if (Test-Path \"$$src\hive_secrets.bin\") { Copy-Item \"$$src\hive_secrets.bin\" \"$$dst\hive_secrets.bin\" -Force }; if (Test-Path \"$$src\hive_secrets.vault\") { Copy-Item \"$$src\hive_secrets.vault\" \"$$dst\hive_secrets.vault\" -Force }; if (Test-Path \"$$src\identities\") { New-Item -ItemType Directory -Path \"$$dst\identities\" -Force | Out-Null; Copy-Item \"$$src\identities\*\" \"$$dst\identities\\" -Force -Recurse }; Write-Output OK"'
-  Pop $0
-  Pop $1
-
-  DetailPrint "User data backed up for upgrade"
-FunctionEnd
-
-Function RestoreUserData
-  ReadEnvStr $0 LOCALAPPDATA
-  StrCpy $1 "$0\abigail\Abigail"
-  StrCpy $2 "$TEMP\abigail_upgrade_backup"
-
-  ; Restore files (using PowerShell for reliability)
-  ; Files: config.json, Hive-owned memory store, legacy migration inputs, external_pubkey.bin,
-  ;        legacy/new vault files, docs/, and Hive files (global_settings.json, master.key,
-  ;        install_upgrade_state.json, identities/)
-  nsExec::ExecToStack 'powershell -ExecutionPolicy Bypass -Command "$$src = \"$2\"; $$dst = \"$1\"; if (Test-Path \"$$src\config.json\") { Copy-Item \"$$src\config.json\" \"$$dst\config.json\" -Force }; if (Test-Path \"$$src\memory.db\") { Copy-Item \"$$src\memory.db\" \"$$dst\memory.db\" -Force -Recurse }; if (Test-Path \"$$src\abigail_seed.db\") { Copy-Item \"$$src\abigail_seed.db\" \"$$dst\abigail_seed.db\" -Force }; if (Test-Path \"$$src\abigail_seed.db-wal\") { Copy-Item \"$$src\abigail_seed.db-wal\" \"$$dst\abigail_seed.db-wal\" -Force }; if (Test-Path \"$$src\abigail_seed.db-shm\") { Copy-Item \"$$src\abigail_seed.db-shm\" \"$$dst\abigail_seed.db-shm\" -Force }; if (Test-Path \"$$src\abigail_memory.db\") { Copy-Item \"$$src\abigail_memory.db\" \"$$dst\abigail_memory.db\" -Force }; if (Test-Path \"$$src\abigail_memory.db-wal\") { Copy-Item \"$$src\abigail_memory.db-wal\" \"$$dst\abigail_memory.db-wal\" -Force }; if (Test-Path \"$$src\abigail_memory.db-shm\") { Copy-Item \"$$src\abigail_memory.db-shm\" \"$$dst\abigail_memory.db-shm\" -Force }; if (Test-Path \"$$src\jobs.db\") { Copy-Item \"$$src\jobs.db\" \"$$dst\jobs.db\" -Force }; if (Test-Path \"$$src\jobs.db-wal\") { Copy-Item \"$$src\jobs.db-wal\" \"$$dst\jobs.db-wal\" -Force }; if (Test-Path \"$$src\jobs.db-shm\") { Copy-Item \"$$src\jobs.db-shm\" \"$$dst\jobs.db-shm\" -Force }; if (Test-Path \"$$src\calendar.db\") { Copy-Item \"$$src\calendar.db\" \"$$dst\calendar.db\" -Force }; if (Test-Path \"$$src\kb.db\") { Copy-Item \"$$src\kb.db\" \"$$dst\kb.db\" -Force }; if (Test-Path \"$$src\external_pubkey.bin\") { Copy-Item \"$$src\external_pubkey.bin\" \"$$dst\external_pubkey.bin\" -Force }; if (Test-Path \"$$src\secrets.bin\") { Copy-Item \"$$src\secrets.bin\" \"$$dst\secrets.bin\" -Force }; if (Test-Path \"$$src\secrets.vault\") { Copy-Item \"$$src\secrets.vault\" \"$$dst\secrets.vault\" -Force }; if (Test-Path \"$$src\skills.bin\") { Copy-Item \"$$src\skills.bin\" \"$$dst\skills.bin\" -Force }; if (Test-Path \"$$src\skills.vault\") { Copy-Item \"$$src\skills.vault\" \"$$dst\skills.vault\" -Force }; if (Test-Path \"$$src\keys.bin\") { Copy-Item \"$$src\keys.bin\" \"$$dst\keys.bin\" -Force }; if (Test-Path \"$$src\keys.vault\") { Copy-Item \"$$src\keys.vault\" \"$$dst\keys.vault\" -Force }; if (Test-Path \"$$src\vault.sentinel\") { Copy-Item \"$$src\vault.sentinel\" \"$$dst\vault.sentinel\" -Force }; if (Test-Path \"$$src\docs\") { New-Item -ItemType Directory -Path \"$$dst\docs\" -Force | Out-Null; Copy-Item \"$$src\docs\*\" \"$$dst\docs\\" -Force -Recurse }; if (Test-Path \"$$src\global_settings.json\") { Copy-Item \"$$src\global_settings.json\" \"$$dst\global_settings.json\" -Force }; if (Test-Path \"$$src\install_upgrade_state.json\") { Copy-Item \"$$src\install_upgrade_state.json\" \"$$dst\install_upgrade_state.json\" -Force }; if (Test-Path \"$$src\master.key\") { Copy-Item \"$$src\master.key\" \"$$dst\master.key\" -Force }; if (Test-Path \"$$src\hive_secrets.bin\") { Copy-Item \"$$src\hive_secrets.bin\" \"$$dst\hive_secrets.bin\" -Force }; if (Test-Path \"$$src\hive_secrets.vault\") { Copy-Item \"$$src\hive_secrets.vault\" \"$$dst\hive_secrets.vault\" -Force }; if (Test-Path \"$$src\identities\") { New-Item -ItemType Directory -Path \"$$dst\identities\" -Force | Out-Null; Copy-Item \"$$src\identities\*\" \"$$dst\identities\\" -Force -Recurse }; Remove-Item \"$$src\" -Recurse -Force; Write-Output OK"'
-  Pop $0
-  Pop $1
-
-  DetailPrint "User data restored"
-FunctionEnd
-
-; ============================================================================
-; WRITE VERSION TO REGISTRY
-; ============================================================================
+; Stabilization lane defaults to clean-install behavior.
 
 Function WriteVersionToRegistry
-  ; Write version and install path to registry
   WriteRegStr HKCU "Software\abigail\Abigail" "Version" "${VERSION}"
   WriteRegStr HKCU "Software\abigail\Abigail" "InstallPath" "$INSTDIR"
 FunctionEnd
 
-; ============================================================================
-; (LLM setup dialog removed — Ollama is bundled; no user action needed)
-; ============================================================================
-
-; ============================================================================
-; UPGRADE DIALOG
-; ============================================================================
-
-Function ShowUpgradeDialog
-  ${If} $UpgradeDetected == "1"
-    ${If} $ExistingVersion != "unknown"
-      MessageBox MB_YESNO|MB_ICONQUESTION "Upgrade Detected$\n$\nAn existing Abigail installation (v$ExistingVersion) was found.$\n$\nWould you like to preserve your existing data?$\n$\n- Config and settings$\n- Conversation history$\n- Signed documents$\n- Identity keys$\n- Hive multi-agent identities$\n$\nClick YES to preserve, NO for a fresh install." IDYES PreserveYes IDNO PreserveNo
-    ${Else}
-      MessageBox MB_YESNO|MB_ICONQUESTION "Upgrade Detected$\n$\nAn existing Abigail installation was found.$\n$\nWould you like to preserve your existing data?$\n$\n- Config and settings$\n- Conversation history$\n- Signed documents$\n- Identity keys$\n- Hive multi-agent identities$\n$\nClick YES to preserve, NO for a fresh install." IDYES PreserveYes IDNO PreserveNo
-    ${EndIf}
-
-PreserveYes:
-    StrCpy $PreserveData "1"
-    Goto UpgradeDone
-
-PreserveNo:
-    StrCpy $PreserveData "0"
-    MessageBox MB_YESNO|MB_ICONEXCLAMATION "WARNING: Fresh install selected.$\n$\nThis will delete all existing Abigail data including:$\n- Your identity and trust relationship$\n- All conversation history$\n- Any customizations$\n$\nAre you sure?" IDYES ConfirmFresh IDNO PreserveYes
-
-ConfirmFresh:
-    StrCpy $PreserveData "0"
-
-UpgradeDone:
-  ${Else}
-    StrCpy $PreserveData "0"
-  ${EndIf}
-FunctionEnd
-
-; ============================================================================
-; PRE-INSTALL HOOK
-; ============================================================================
-
 !macro NSIS_HOOK_PREINSTALL
-  ; Check for existing installation
-  Call CheckForExistingInstall
-
-  ; Show upgrade dialog if needed
-  Call ShowUpgradeDialog
-
-  ; If upgrade detected and user chose preserve, backup data
-  ${If} $UpgradeDetected == "1"
-  ${AndIf} $PreserveData == "1"
-    Call BackupUserData
-  ${EndIf}
+  ; Intentionally empty for stabilization builds.
+  ; Alpha-era backup/restore and upgrade preservation are removed so the new
+  ; Hive + Entity Runtime architecture does not silently inherit stale state.
 !macroend
 
-; ============================================================================
-; POST-INSTALL HOOK
-; ============================================================================
-
 !macro NSIS_HOOK_POSTINSTALL
-  ; Step 1: Restore user data if upgrading
-  ; Note: Identity keygen removed — the in-app birth sequence handles key generation.
-  ${If} $UpgradeDetected == "1"
-  ${AndIf} $PreserveData == "1"
-    Call RestoreUserData
-  ${EndIf}
-
-  ; Step 2: Write version to registry
   Call WriteVersionToRegistry
-
-PostInstallDone:
 !macroend
 
-; ============================================================================
-; UNINSTALL HOOKS
-; ============================================================================
-
 !macro NSIS_HOOK_PREUNINSTALL
-  ; Ask if user wants to keep their data
-  MessageBox MB_YESNO|MB_ICONQUESTION "Would you like to keep your Abigail data (config, memories, documents)?$\n$\nClick YES to keep data for a future reinstall.$\nClick NO to remove everything." IDYES KeepData IDNO RemoveData
-
-KeepData:
-  ; Just remove the version from registry, keep data
-  DeleteRegKey HKCU "Software\abigail\Abigail"
-  Goto UninstallDataDone
+  MessageBox MB_YESNO|MB_ICONQUESTION "Would you like to remove the Abigail local data directory as well?$\n$\nClick YES to remove local data.$\nClick NO to leave local data in place." IDYES RemoveData IDNO KeepData
 
 RemoveData:
-  ; Remove all data
   ReadEnvStr $0 LOCALAPPDATA
   RMDir /r "$0\abigail\Abigail"
-  DeleteRegKey HKCU "Software\abigail\Abigail"
+  Goto RegistryCleanup
 
-UninstallDataDone:
+KeepData:
+  ; Leave local data in place for manual inspection or explicit import.
+
+RegistryCleanup:
+  DeleteRegKey HKCU "Software\abigail\Abigail"
 !macroend
 
 !macro NSIS_HOOK_POSTUNINSTALL
-  ; Nothing special to do after uninstall
+  ; Nothing special to do after uninstall.
 !macroend
diff --git a/tauri-app/src-ui/package-lock.json b/tauri-app/src-ui/package-lock.json
index 57a00255..f57c3244 100644
--- a/tauri-app/src-ui/package-lock.json
+++ b/tauri-app/src-ui/package-lock.json
@@ -21,15 +21,15 @@
         "@testing-library/user-event": "^14.6.1",
         "@types/react": "^18.2.0",
         "@types/react-dom": "^18.2.0",
-        "@vitejs/plugin-react": "^5.1.4",
-        "@vitest/coverage-v8": "^4.0.18",
+        "@vitejs/plugin-react": "^6.0.1",
+        "@vitest/coverage-v8": "^4.1.4",
         "autoprefixer": "^10.4.16",
         "jsdom": "^29.0.0",
         "postcss": "^8.5.8",
         "tailwindcss": "^3.4.0",
         "typescript": "^5.3.0",
-        "vite": "^7.3.1",
-        "vitest": "^4.0.18"
+        "vite": "^8.0.8",
+        "vitest": "^4.1.4"
       }
     },
     "node_modules/@adobe/css-tools": {
@@ -118,6 +118,7 @@
       "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@babel/helper-validator-identifier": "^7.28.5",
         "js-tokens": "^4.0.0",
@@ -127,133 +128,6 @@
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/compat-data": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
-      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/core": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
-      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.29.0",
-        "@babel/generator": "^7.29.0",
-        "@babel/helper-compilation-targets": "^7.28.6",
-        "@babel/helper-module-transforms": "^7.28.6",
-        "@babel/helpers": "^7.28.6",
-        "@babel/parser": "^7.29.0",
-        "@babel/template": "^7.28.6",
-        "@babel/traverse": "^7.29.0",
-        "@babel/types": "^7.29.0",
-        "@jridgewell/remapping": "^2.3.5",
-        "convert-source-map": "^2.0.0",
-        "debug": "^4.1.0",
-        "gensync": "^1.0.0-beta.2",
-        "json5": "^2.2.3",
-        "semver": "^6.3.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/babel"
-      }
-    },
-    "node_modules/@babel/generator": {
-      "version": "7.29.1",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
-      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/parser": "^7.29.0",
-        "@babel/types": "^7.29.0",
-        "@jridgewell/gen-mapping": "^0.3.12",
-        "@jridgewell/trace-mapping": "^0.3.28",
-        "jsesc": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-compilation-targets": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
-      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/compat-data": "^7.28.6",
-        "@babel/helper-validator-option": "^7.27.1",
-        "browserslist": "^4.24.0",
-        "lru-cache": "^5.1.1",
-        "semver": "^6.3.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-globals": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
-      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-module-imports": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
-      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/traverse": "^7.28.6",
-        "@babel/types": "^7.28.6"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-module-transforms": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
-      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-module-imports": "^7.28.6",
-        "@babel/helper-validator-identifier": "^7.28.5",
-        "@babel/traverse": "^7.28.6"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0"
-      }
-    },
-    "node_modules/@babel/helper-plugin-utils": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
-      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
     "node_modules/@babel/helper-string-parser": {
       "version": "7.27.1",
       "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
@@ -274,30 +148,6 @@
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/helper-validator-option": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
-      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helpers": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz",
-      "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/template": "^7.28.6",
-        "@babel/types": "^7.28.6"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
     "node_modules/@babel/parser": {
       "version": "7.29.0",
       "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz",
@@ -314,38 +164,6 @@
         "node": ">=6.0.0"
       }
     },
-    "node_modules/@babel/plugin-transform-react-jsx-self": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
-      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-transform-react-jsx-source": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
-      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
     "node_modules/@babel/runtime": {
       "version": "7.28.6",
       "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz",
@@ -355,40 +173,6 @@
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/template": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
-      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.28.6",
-        "@babel/parser": "^7.28.6",
-        "@babel/types": "^7.28.6"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/traverse": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
-      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.29.0",
-        "@babel/generator": "^7.29.0",
-        "@babel/helper-globals": "^7.28.0",
-        "@babel/parser": "^7.29.0",
-        "@babel/template": "^7.28.6",
-        "@babel/types": "^7.29.0",
-        "debug": "^4.3.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
     "node_modules/@babel/types": {
       "version": "7.29.0",
       "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
@@ -565,520 +349,120 @@
         "node": ">=20.19.0"
       }
     },
-    "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz",
-      "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==",
-      "cpu": [
-        "ppc64"
-      ],
+    "node_modules/@emnapi/core": {
+      "version": "1.9.2",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.9.2.tgz",
+      "integrity": "sha512-UC+ZhH3XtczQYfOlu3lNEkdW/p4dsJ1r/bP7H8+rhao3TTTMO1ATq/4DdIi23XuGoFY+Cz0JmCbdVl0hz9jZcA==",
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=18"
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.1",
+        "tslib": "^2.4.0"
       }
     },
-    "node_modules/@esbuild/android-arm": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz",
-      "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==",
-      "cpu": [
-        "arm"
-      ],
+    "node_modules/@emnapi/runtime": {
+      "version": "1.9.2",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.9.2.tgz",
+      "integrity": "sha512-3U4+MIWHImeyu1wnmVygh5WlgfYDtyf0k8AbLhMFxOipihf6nrWC4syIm/SwEeec0mNSafiiNnMJwbza/Is6Lw==",
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
+      "dependencies": {
+        "tslib": "^2.4.0"
       }
     },
-    "node_modules/@esbuild/android-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz",
-      "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
+      "integrity": "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==",
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
+      "dependencies": {
+        "tslib": "^2.4.0"
       }
     },
-    "node_modules/@esbuild/android-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz",
-      "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@exodus/bytes": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.0.tgz",
+      "integrity": "sha512-UY0nlA+feH81UGSHv92sLEPLCeZFjXOuHhrIo0HQydScuQc8s0A7kL/UdgwgDq8g8ilksmuoF35YVTNphV2aBQ==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
       "engines": {
-        "node": ">=18"
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@noble/hashes": "^1.8.0 || ^2.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@noble/hashes": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz",
-      "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
       }
     },
-    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz",
-      "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
       "engines": {
-        "node": ">=18"
+        "node": ">=6.0.0"
       }
     },
-    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
-    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz",
-      "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.3.tgz",
+      "integrity": "sha512-xK9sGVbJWYb08+mTJt3/YV24WxvxpXcXtP6B172paPZ+Ts69Re9dAr7lKwJoeIx8OoeuimEiRZ7umkiUVClmmQ==",
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
+      "dependencies": {
+        "@tybys/wasm-util": "^0.10.1"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "peerDependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1"
       }
     },
-    "node_modules/@esbuild/linux-arm": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz",
-      "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz",
-      "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz",
-      "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-loong64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz",
-      "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz",
-      "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz",
-      "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz",
-      "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz",
-      "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz",
-      "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz",
-      "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz",
-      "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz",
-      "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz",
-      "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
-      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
-      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
-      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@exodus/bytes": {
-      "version": "1.15.0",
-      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.0.tgz",
-      "integrity": "sha512-UY0nlA+feH81UGSHv92sLEPLCeZFjXOuHhrIo0HQydScuQc8s0A7kL/UdgwgDq8g8ilksmuoF35YVTNphV2aBQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "@noble/hashes": "^1.8.0 || ^2.0.0"
-      },
-      "peerDependenciesMeta": {
-        "@noble/hashes": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.13",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
-      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.5.0",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      }
-    },
-    "node_modules/@jridgewell/remapping": {
-      "version": "2.3.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
-      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      }
-    },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
-      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
-      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.31",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
-      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.1.0",
-        "@jridgewell/sourcemap-codec": "^1.4.14"
-      }
-    },
-    "node_modules/@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
-      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+    "node_modules/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -1113,31 +497,20 @@
         "node": ">= 8"
       }
     },
-    "node_modules/@rolldown/pluginutils": {
-      "version": "1.0.0-rc.3",
-      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.3.tgz",
-      "integrity": "sha512-eybk3TjzzzV97Dlj5c+XrBFW57eTNhzod66y9HrBlzJ6NsCrWCp/2kaPS3K9wJmurBC0Tdw4yPjXKZqlznim3Q==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz",
-      "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==",
-      "cpu": [
-        "arm"
-      ],
+    "node_modules/@oxc-project/types": {
+      "version": "0.124.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.124.0.tgz",
+      "integrity": "sha512-VBFWMTBvHxS11Z5Lvlr3IWgrwhMTXV+Md+EQF0Xf60+wAdsGFTBx7X7K/hP4pi8N7dcm1RvcHwDxZ16Qx8keUg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      }
     },
-    "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz",
-      "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==",
+    "node_modules/@rolldown/binding-android-arm64": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-rc.15.tgz",
+      "integrity": "sha512-YYe6aWruPZDtHNpwu7+qAHEMbQ/yRl6atqb/AhznLTnD3UY99Q1jE7ihLSahNWkF4EqRPVC4SiR4O0UkLK02tA==",
       "cpu": [
         "arm64"
       ],
@@ -1146,12 +519,15 @@
       "optional": true,
       "os": [
         "android"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz",
-      "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==",
+    "node_modules/@rolldown/binding-darwin-arm64": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-rc.15.tgz",
+      "integrity": "sha512-oArR/ig8wNTPYsXL+Mzhs0oxhxfuHRfG7Ikw7jXsw8mYOtk71W0OkF2VEVh699pdmzjPQsTjlD1JIOoHkLP1Fg==",
       "cpu": [
         "arm64"
       ],
@@ -1160,12 +536,15 @@
       "optional": true,
       "os": [
         "darwin"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz",
-      "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==",
+    "node_modules/@rolldown/binding-darwin-x64": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-rc.15.tgz",
+      "integrity": "sha512-YzeVqOqjPYvUbJSWJ4EDL8ahbmsIXQpgL3JVipmN+MX0XnXMeWomLN3Fb+nwCmP/jfyqte5I3XRSm7OfQrbyxw==",
       "cpu": [
         "x64"
       ],
@@ -1174,26 +553,15 @@
       "optional": true,
       "os": [
         "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz",
-      "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==",
-      "cpu": [
-        "arm64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz",
-      "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==",
+    "node_modules/@rolldown/binding-freebsd-x64": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-rc.15.tgz",
+      "integrity": "sha512-9Erhx956jeQ0nNTyif1+QWAXDRD38ZNjr//bSHrt6wDwB+QkAfl2q6Mn1k6OBPerznjRmbM10lgRb1Pli4xZPw==",
       "cpu": [
         "x64"
       ],
@@ -1202,26 +570,15 @@
       "optional": true,
       "os": [
         "freebsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz",
-      "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==",
-      "cpu": [
-        "arm"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz",
-      "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==",
+    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-rc.15.tgz",
+      "integrity": "sha512-cVwk0w8QbZJGTnP/AHQBs5yNwmpgGYStL88t4UIaqcvYJWBfS0s3oqVLZPwsPU6M0zlW4GqjP0Zq5MnAGwFeGA==",
       "cpu": [
         "arm"
       ],
@@ -1230,26 +587,15 @@
       "optional": true,
       "os": [
         "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz",
-      "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==",
-      "cpu": [
-        "arm64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz",
-      "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==",
+    "node_modules/@rolldown/binding-linux-arm64-gnu": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-rc.15.tgz",
+      "integrity": "sha512-eBZ/u8iAK9SoHGanqe/jrPnY0JvBN6iXbVOsbO38mbz+ZJsaobExAm1Iu+rxa4S1l2FjG0qEZn4Rc6X8n+9M+w==",
       "cpu": [
         "arm64"
       ],
@@ -1258,54 +604,32 @@
       "optional": true,
       "os": [
         "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-loong64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz",
-      "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==",
-      "cpu": [
-        "loong64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-loong64-musl": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz",
-      "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==",
+    "node_modules/@rolldown/binding-linux-arm64-musl": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-rc.15.tgz",
+      "integrity": "sha512-ZvRYMGrAklV9PEkgt4LQM6MjQX2P58HPAuecwYObY2DhS2t35R0I810bKi0wmaYORt6m/2Sm+Z+nFgb0WhXNcQ==",
       "cpu": [
-        "loong64"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
         "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz",
-      "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==",
-      "cpu": [
-        "ppc64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-ppc64-musl": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz",
-      "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==",
+    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.0-rc.15.tgz",
+      "integrity": "sha512-VDpgGBzgfg5hLg+uBpCLoFG5kVvEyafmfxGUV0UHLcL5irxAK7PKNeC2MwClgk6ZAiNhmo9FLhRYgvMmedLtnQ==",
       "cpu": [
         "ppc64"
       ],
@@ -1314,40 +638,15 @@
       "optional": true,
       "os": [
         "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz",
-      "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==",
-      "cpu": [
-        "riscv64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz",
-      "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz",
-      "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==",
+    "node_modules/@rolldown/binding-linux-s390x-gnu": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.0-rc.15.tgz",
+      "integrity": "sha512-y1uXY3qQWCzcPgRJATPSOUP4tCemh4uBdY7e3EZbVwCJTY3gLJWnQABgeUetvED+bt1FQ01OeZwvhLS2bpNrAQ==",
       "cpu": [
         "s390x"
       ],
@@ -1356,12 +655,15 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz",
-      "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==",
+    "node_modules/@rolldown/binding-linux-x64-gnu": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-rc.15.tgz",
+      "integrity": "sha512-023bTPBod7J3Y/4fzAN6QtpkSABR0rigtrwaP+qSEabUh5zf6ELr9Nc7GujaROuPY3uwdSIXWrvhn1KxOvurWA==",
       "cpu": [
         "x64"
       ],
@@ -1370,12 +672,15 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz",
-      "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==",
+    "node_modules/@rolldown/binding-linux-x64-musl": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-rc.15.tgz",
+      "integrity": "sha512-witB2O0/hU4CgfOOKUoeFgQ4GktPi1eEbAhaLAIpgD6+ZnhcPkUtPsoKKHRzmOoWPZue46IThdSgdo4XneOLYw==",
       "cpu": [
         "x64"
       ],
@@ -1384,26 +689,15 @@
       "optional": true,
       "os": [
         "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-openbsd-x64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz",
-      "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==",
-      "cpu": [
-        "x64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz",
-      "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==",
+    "node_modules/@rolldown/binding-openharmony-arm64": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-rc.15.tgz",
+      "integrity": "sha512-UCL68NJ0Ud5zRipXZE9dF5PmirzJE4E4BCIOOssEnM7wLDsxjc6Qb0sGDxTNRTP53I6MZpygyCpY8Aa8sPfKPg==",
       "cpu": [
         "arm64"
       ],
@@ -1412,40 +706,51 @@
       "optional": true,
       "os": [
         "openharmony"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz",
-      "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==",
+    "node_modules/@rolldown/binding-wasm32-wasi": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-rc.15.tgz",
+      "integrity": "sha512-ApLruZq/ig+nhaE7OJm4lDjayUnOHVUa77zGeqnqZ9pn0ovdVbbNPerVibLXDmWeUZXjIYIT8V3xkT58Rm9u5Q==",
       "cpu": [
-        "arm64"
+        "wasm32"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "os": [
-        "win32"
-      ]
+      "dependencies": {
+        "@emnapi/core": "1.9.2",
+        "@emnapi/runtime": "1.9.2",
+        "@napi-rs/wasm-runtime": "^1.1.3"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
     },
-    "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz",
-      "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==",
+    "node_modules/@rolldown/binding-win32-arm64-msvc": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-rc.15.tgz",
+      "integrity": "sha512-KmoUoU7HnN+Si5YWJigfTws1jz1bKBYDQKdbLspz0UaqjjFkddHsqorgiW1mxcAj88lYUE6NC/zJNwT+SloqtA==",
       "cpu": [
-        "ia32"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
         "win32"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-win32-x64-gnu": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz",
-      "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==",
+    "node_modules/@rolldown/binding-win32-x64-msvc": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-rc.15.tgz",
+      "integrity": "sha512-3P2A8L+x75qavWLe/Dll3EYBJLQmtkJN8rfh+U/eR3MqMgL/h98PhYI+JFfXuDPgPeCB7iZAKiqii5vqOvnA0g==",
       "cpu": [
         "x64"
       ],
@@ -1454,27 +759,24 @@
       "optional": true,
       "os": [
         "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz",
-      "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==",
-      "cpu": [
-        "x64"
       ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-rc.7",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.7.tgz",
+      "integrity": "sha512-qujRfC8sFVInYSPPMLQByRh7zhwkGFS4+tyMQ83srV1qrxL4g8E2tyxVVyxd0+8QeBM1mIk9KbWxkegRr76XzA==",
       "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
+      "license": "MIT"
     },
     "node_modules/@standard-schema/spec": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
       "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
-      "dev": true
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/@tauri-apps/api": {
       "version": "2.10.1",
@@ -1598,63 +900,30 @@
         "@testing-library/dom": ">=7.21.4"
       }
     },
-    "node_modules/@types/aria-query": {
-      "version": "5.0.4",
-      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
-      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
-      "dev": true,
-      "peer": true
-    },
-    "node_modules/@types/babel__core": {
-      "version": "7.20.5",
-      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
-      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/parser": "^7.20.7",
-        "@babel/types": "^7.20.7",
-        "@types/babel__generator": "*",
-        "@types/babel__template": "*",
-        "@types/babel__traverse": "*"
-      }
-    },
-    "node_modules/@types/babel__generator": {
-      "version": "7.27.0",
-      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
-      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.0.0"
-      }
-    },
-    "node_modules/@types/babel__template": {
-      "version": "7.4.4",
-      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
-      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.1",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz",
+      "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==",
       "dev": true,
       "license": "MIT",
+      "optional": true,
       "dependencies": {
-        "@babel/parser": "^7.1.0",
-        "@babel/types": "^7.0.0"
+        "tslib": "^2.4.0"
       }
     },
-    "node_modules/@types/babel__traverse": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
-      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+    "node_modules/@types/aria-query": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.28.2"
-      }
+      "peer": true
     },
     "node_modules/@types/chai": {
       "version": "5.2.3",
       "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
       "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "@types/deep-eql": "*",
         "assertion-error": "^2.0.1"
@@ -1664,7 +933,8 @@
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
       "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
-      "dev": true
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/@types/estree": {
       "version": "1.0.8",
@@ -1702,49 +972,55 @@
       }
     },
     "node_modules/@vitejs/plugin-react": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.1.4.tgz",
-      "integrity": "sha512-VIcFLdRi/VYRU8OL/puL7QXMYafHmqOnwTZY50U1JPlCNj30PxCMx65c494b1K9be9hX83KVt0+gTEwTWLqToA==",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-6.0.1.tgz",
+      "integrity": "sha512-l9X/E3cDb+xY3SWzlG1MOGt2usfEHGMNIaegaUGFsLkb3RCn/k8/TOXBcab+OndDI4TBtktT8/9BwwW8Vi9KUQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/core": "^7.29.0",
-        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
-        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
-        "@rolldown/pluginutils": "1.0.0-rc.3",
-        "@types/babel__core": "^7.20.5",
-        "react-refresh": "^0.18.0"
+        "@rolldown/pluginutils": "1.0.0-rc.7"
       },
       "engines": {
         "node": "^20.19.0 || >=22.12.0"
       },
       "peerDependencies": {
-        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+        "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0",
+        "babel-plugin-react-compiler": "^1.0.0",
+        "vite": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@rolldown/plugin-babel": {
+          "optional": true
+        },
+        "babel-plugin-react-compiler": {
+          "optional": true
+        }
       }
     },
     "node_modules/@vitest/coverage-v8": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.0.18.tgz",
-      "integrity": "sha512-7i+N2i0+ME+2JFZhfuz7Tg/FqKtilHjGyGvoHYQ6iLV0zahbsJ9sljC9OcFcPDbhYKCet+sG8SsVqlyGvPflZg==",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.1.4.tgz",
+      "integrity": "sha512-x7FptB5oDruxNPDNY2+S8tCh0pcq7ymCe1gTHcsp733jYjrJl8V1gMUlVysuCD9Kz46Xz9t1akkv08dPcYDs1w==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "@bcoe/v8-coverage": "^1.0.2",
-        "@vitest/utils": "4.0.18",
-        "ast-v8-to-istanbul": "^0.3.10",
+        "@vitest/utils": "4.1.4",
+        "ast-v8-to-istanbul": "^1.0.0",
         "istanbul-lib-coverage": "^3.2.2",
         "istanbul-lib-report": "^3.0.1",
         "istanbul-reports": "^3.2.0",
-        "magicast": "^0.5.1",
+        "magicast": "^0.5.2",
         "obug": "^2.1.1",
-        "std-env": "^3.10.0",
-        "tinyrainbow": "^3.0.3"
+        "std-env": "^4.0.0-rc.1",
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
-        "@vitest/browser": "4.0.18",
-        "vitest": "4.0.18"
+        "@vitest/browser": "4.1.4",
+        "vitest": "4.1.4"
       },
       "peerDependenciesMeta": {
         "@vitest/browser": {
@@ -1753,29 +1029,31 @@
       }
     },
     "node_modules/@vitest/expect": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.0.18.tgz",
-      "integrity": "sha512-8sCWUyckXXYvx4opfzVY03EOiYVxyNrHS5QxX3DAIi5dpJAAkyJezHCP77VMX4HKA2LDT/Jpfo8i2r5BE3GnQQ==",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.4.tgz",
+      "integrity": "sha512-iPBpra+VDuXmBFI3FMKHSFXp3Gx5HfmSCE8X67Dn+bwephCnQCaB7qWK2ldHa+8ncN8hJU8VTMcxjPpyMkUjww==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@standard-schema/spec": "^1.0.0",
+        "@standard-schema/spec": "^1.1.0",
         "@types/chai": "^5.2.2",
-        "@vitest/spy": "4.0.18",
-        "@vitest/utils": "4.0.18",
-        "chai": "^6.2.1",
-        "tinyrainbow": "^3.0.3"
+        "@vitest/spy": "4.1.4",
+        "@vitest/utils": "4.1.4",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/mocker": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.0.18.tgz",
-      "integrity": "sha512-HhVd0MDnzzsgevnOWCBj5Otnzobjy5wLBe4EdeeFGv8luMsGcYqDuFRMcttKWZA5vVO8RFjexVovXvAM4JoJDQ==",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.4.tgz",
+      "integrity": "sha512-R9HTZBhW6yCSGbGQnDnH3QHfJxokKN4KB+Yvk9Q1le7eQNYwiCyKxmLmurSpFy6BzJanSLuEUDrD+j97Q+ZLPg==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@vitest/spy": "4.0.18",
+        "@vitest/spy": "4.1.4",
         "estree-walker": "^3.0.3",
         "magic-string": "^0.30.21"
       },
@@ -1784,7 +1062,7 @@
       },
       "peerDependencies": {
         "msw": "^2.4.9",
-        "vite": "^6.0.0 || ^7.0.0-0"
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
       },
       "peerDependenciesMeta": {
         "msw": {
@@ -1796,24 +1074,26 @@
       }
     },
     "node_modules/@vitest/pretty-format": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.0.18.tgz",
-      "integrity": "sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.4.tgz",
+      "integrity": "sha512-ddmDHU0gjEUyEVLxtZa7xamrpIefdEETu3nZjWtHeZX4QxqJ7tRxSteHVXJOcr8jhiLoGAhkK4WJ3WqBpjx42A==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "tinyrainbow": "^3.0.3"
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/runner": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.0.18.tgz",
-      "integrity": "sha512-rpk9y12PGa22Jg6g5M3UVVnTS7+zycIGk9ZNGN+m6tZHKQb7jrP7/77WfZy13Y/EUDd52NDsLRQhYKtv7XfPQw==",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.4.tgz",
+      "integrity": "sha512-xTp7VZ5aXP5ZJrn15UtJUWlx6qXLnGtF6jNxHepdPHpMfz/aVPx+htHtgcAL2mDXJgKhpoo2e9/hVJsIeFbytQ==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@vitest/utils": "4.0.18",
+        "@vitest/utils": "4.1.4",
         "pathe": "^2.0.3"
       },
       "funding": {
@@ -1821,12 +1101,14 @@
       }
     },
     "node_modules/@vitest/snapshot": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.0.18.tgz",
-      "integrity": "sha512-PCiV0rcl7jKQjbgYqjtakly6T1uwv/5BQ9SwBLekVg/EaYeQFPiXcgrC2Y7vDMA8dM1SUEAEV82kgSQIlXNMvA==",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.4.tgz",
+      "integrity": "sha512-MCjCFgaS8aZz+m5nTcEcgk/xhWv0rEH4Yl53PPlMXOZ1/Ka2VcZU6CJ+MgYCZbcJvzGhQRjVrGQNZqkGPttIKw==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "4.0.18",
+        "@vitest/pretty-format": "4.1.4",
+        "@vitest/utils": "4.1.4",
         "magic-string": "^0.30.21",
         "pathe": "^2.0.3"
       },
@@ -1835,22 +1117,25 @@
       }
     },
     "node_modules/@vitest/spy": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.0.18.tgz",
-      "integrity": "sha512-cbQt3PTSD7P2OARdVW3qWER5EGq7PHlvE+QfzSC0lbwO+xnt7+XH06ZzFjFRgzUX//JmpxrCu92VdwvEPlWSNw==",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.4.tgz",
+      "integrity": "sha512-XxNdAsKW7C+FLydqFJLb5KhJtl3PGCMmYwFRfhvIgxJvLSXhhVI1zM8f1qD3Zg7RCjTSzDVyct6sghs9UEgBEQ==",
       "dev": true,
+      "license": "MIT",
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/utils": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.0.18.tgz",
-      "integrity": "sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.4.tgz",
+      "integrity": "sha512-13QMT+eysM5uVGa1rG4kegGYNp6cnQcsTc67ELFbhNLQO+vgsygtYJx2khvdt4gVQqSSpC/KT5FZZxUpP3Oatw==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "4.0.18",
-        "tinyrainbow": "^3.0.3"
+        "@vitest/pretty-format": "4.1.4",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
@@ -1921,15 +1206,17 @@
       "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
       "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=12"
       }
     },
     "node_modules/ast-v8-to-istanbul": {
-      "version": "0.3.11",
-      "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-0.3.11.tgz",
-      "integrity": "sha512-Qya9fkoofMjCBNVdWINMjB5KZvkYfaO9/anwkWnjxibpWUxo5iHl2sOdP7/uAqaRuUYuoo8rDwnbaaKVFxoUvw==",
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-1.0.0.tgz",
+      "integrity": "sha512-1fSfIwuDICFA4LKkCzRPO7F0hzFf0B7+Xqrl27ynQaa+Rh0e1Es0v6kWHPott3lU10AyAr7oKHa65OppjLn3Rg==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "@jridgewell/trace-mapping": "^0.3.31",
         "estree-walker": "^3.0.3",
@@ -1940,7 +1227,8 @@
       "version": "10.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-10.0.0.tgz",
       "integrity": "sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==",
-      "dev": true
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/autoprefixer": {
       "version": "10.4.24",
@@ -2095,6 +1383,7 @@
       "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
       "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=18"
       }
@@ -2208,24 +1497,6 @@
         "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
       }
     },
-    "node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/decimal.js": {
       "version": "10.6.0",
       "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
@@ -2241,6 +1512,16 @@
         "node": ">=6"
       }
     },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/didyoumean": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
@@ -2283,52 +1564,11 @@
       }
     },
     "node_modules/es-module-lexer": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
-      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
-      "dev": true
-    },
-    "node_modules/esbuild": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz",
-      "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.0.0.tgz",
+      "integrity": "sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw==",
       "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.27.3",
-        "@esbuild/android-arm": "0.27.3",
-        "@esbuild/android-arm64": "0.27.3",
-        "@esbuild/android-x64": "0.27.3",
-        "@esbuild/darwin-arm64": "0.27.3",
-        "@esbuild/darwin-x64": "0.27.3",
-        "@esbuild/freebsd-arm64": "0.27.3",
-        "@esbuild/freebsd-x64": "0.27.3",
-        "@esbuild/linux-arm": "0.27.3",
-        "@esbuild/linux-arm64": "0.27.3",
-        "@esbuild/linux-ia32": "0.27.3",
-        "@esbuild/linux-loong64": "0.27.3",
-        "@esbuild/linux-mips64el": "0.27.3",
-        "@esbuild/linux-ppc64": "0.27.3",
-        "@esbuild/linux-riscv64": "0.27.3",
-        "@esbuild/linux-s390x": "0.27.3",
-        "@esbuild/linux-x64": "0.27.3",
-        "@esbuild/netbsd-arm64": "0.27.3",
-        "@esbuild/netbsd-x64": "0.27.3",
-        "@esbuild/openbsd-arm64": "0.27.3",
-        "@esbuild/openbsd-x64": "0.27.3",
-        "@esbuild/openharmony-arm64": "0.27.3",
-        "@esbuild/sunos-x64": "0.27.3",
-        "@esbuild/win32-arm64": "0.27.3",
-        "@esbuild/win32-ia32": "0.27.3",
-        "@esbuild/win32-x64": "0.27.3"
-      }
+      "license": "MIT"
     },
     "node_modules/escalade": {
       "version": "3.2.0",
@@ -2345,6 +1585,7 @@
       "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
       "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "@types/estree": "^1.0.0"
       }
@@ -2354,6 +1595,7 @@
       "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
       "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
       "dev": true,
+      "license": "Apache-2.0",
       "engines": {
         "node": ">=12.0.0"
       }
@@ -2450,16 +1692,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/gensync": {
-      "version": "1.0.0-beta.2",
-      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
-      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
     "node_modules/glob-parent": {
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
@@ -2598,127 +1830,362 @@
       "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
       "dev": true,
       "engines": {
-        "node": ">=8"
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-report": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+      "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+      "dev": true,
+      "dependencies": {
+        "istanbul-lib-coverage": "^3.0.0",
+        "make-dir": "^4.0.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-reports": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+      "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+      "dev": true,
+      "dependencies": {
+        "html-escaper": "^2.0.0",
+        "istanbul-lib-report": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/jiti": {
+      "version": "1.21.7",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
+      "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jiti": "bin/jiti.js"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/jsdom": {
+      "version": "29.0.0",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-29.0.0.tgz",
+      "integrity": "sha512-9FshNB6OepopZ08unmmGpsF7/qCjxGPbo3NbgfJAnPeHXnsODE9WWffXZtRFRFe0ntzaAOcSKNJFz8wiyvF1jQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^5.0.1",
+        "@asamuzakjp/dom-selector": "^7.0.2",
+        "@bramus/specificity": "^2.4.2",
+        "@csstools/css-syntax-patches-for-csstree": "^1.1.1",
+        "@exodus/bytes": "^1.15.0",
+        "css-tree": "^3.2.1",
+        "data-urls": "^7.0.0",
+        "decimal.js": "^10.6.0",
+        "html-encoding-sniffer": "^6.0.0",
+        "is-potential-custom-element-name": "^1.0.1",
+        "lru-cache": "^11.2.7",
+        "parse5": "^8.0.0",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^6.0.1",
+        "undici": "^7.24.3",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^8.0.1",
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^16.0.1",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jsdom/node_modules/lru-cache": {
+      "version": "11.2.7",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz",
+      "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.32.0",
+        "lightningcss-darwin-arm64": "1.32.0",
+        "lightningcss-darwin-x64": "1.32.0",
+        "lightningcss-freebsd-x64": "1.32.0",
+        "lightningcss-linux-arm-gnueabihf": "1.32.0",
+        "lightningcss-linux-arm64-gnu": "1.32.0",
+        "lightningcss-linux-arm64-musl": "1.32.0",
+        "lightningcss-linux-x64-gnu": "1.32.0",
+        "lightningcss-linux-x64-musl": "1.32.0",
+        "lightningcss-win32-arm64-msvc": "1.32.0",
+        "lightningcss-win32-x64-msvc": "1.32.0"
+      }
+    },
+    "node_modules/lightningcss-android-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz",
+      "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz",
+      "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz",
+      "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz",
+      "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/istanbul-lib-report": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
-      "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz",
+      "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==",
+      "cpu": [
+        "arm"
+      ],
       "dev": true,
-      "dependencies": {
-        "istanbul-lib-coverage": "^3.0.0",
-        "make-dir": "^4.0.0",
-        "supports-color": "^7.1.0"
-      },
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=10"
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/istanbul-reports": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
-      "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz",
+      "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "dependencies": {
-        "html-escaper": "^2.0.0",
-        "istanbul-lib-report": "^3.0.0"
-      },
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/jiti": {
-      "version": "1.21.7",
-      "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
-      "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz",
+      "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "license": "MIT",
-      "bin": {
-        "jiti": "bin/jiti.js"
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/js-tokens": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
-      "license": "MIT"
-    },
-    "node_modules/jsdom": {
-      "version": "29.0.0",
-      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-29.0.0.tgz",
-      "integrity": "sha512-9FshNB6OepopZ08unmmGpsF7/qCjxGPbo3NbgfJAnPeHXnsODE9WWffXZtRFRFe0ntzaAOcSKNJFz8wiyvF1jQ==",
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
+      "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@asamuzakjp/css-color": "^5.0.1",
-        "@asamuzakjp/dom-selector": "^7.0.2",
-        "@bramus/specificity": "^2.4.2",
-        "@csstools/css-syntax-patches-for-csstree": "^1.1.1",
-        "@exodus/bytes": "^1.15.0",
-        "css-tree": "^3.2.1",
-        "data-urls": "^7.0.0",
-        "decimal.js": "^10.6.0",
-        "html-encoding-sniffer": "^6.0.0",
-        "is-potential-custom-element-name": "^1.0.1",
-        "lru-cache": "^11.2.7",
-        "parse5": "^8.0.0",
-        "saxes": "^6.0.0",
-        "symbol-tree": "^3.2.4",
-        "tough-cookie": "^6.0.1",
-        "undici": "^7.24.3",
-        "w3c-xmlserializer": "^5.0.0",
-        "webidl-conversions": "^8.0.1",
-        "whatwg-mimetype": "^5.0.0",
-        "whatwg-url": "^16.0.1",
-        "xml-name-validator": "^5.0.0"
-      },
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": "^20.19.0 || ^22.13.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "canvas": "^3.0.0"
+        "node": ">= 12.0.0"
       },
-      "peerDependenciesMeta": {
-        "canvas": {
-          "optional": true
-        }
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/jsdom/node_modules/lru-cache": {
-      "version": "11.2.7",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz",
-      "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==",
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
+      "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
-      "license": "BlueOak-1.0.0",
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": "20 || >=22"
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/jsesc": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
-      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz",
+      "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "license": "MIT",
-      "bin": {
-        "jsesc": "bin/jsesc"
-      },
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": ">=6"
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/json5": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
-      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
+      "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
-      "license": "MIT",
-      "bin": {
-        "json5": "lib/cli.js"
-      },
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": ">=6"
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
     "node_modules/lilconfig": {
@@ -2753,16 +2220,6 @@
         "loose-envify": "cli.js"
       }
     },
-    "node_modules/lru-cache": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
-      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "yallist": "^3.0.2"
-      }
-    },
     "node_modules/lz-string": {
       "version": "1.5.0",
       "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
@@ -2778,6 +2235,7 @@
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
       "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
@@ -2860,13 +2318,6 @@
         "node": ">=4"
       }
     },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/mz": {
       "version": "2.7.0",
       "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
@@ -2943,7 +2394,8 @@
       "funding": [
         "https://github.com/sponsors/sxzz",
         "https://opencollective.com/debug"
-      ]
+      ],
+      "license": "MIT"
     },
     "node_modules/parse5": {
       "version": "8.0.0",
@@ -2969,7 +2421,8 @@
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
       "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
-      "dev": true
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/picocolors": {
       "version": "1.1.1",
@@ -2979,9 +2432,9 @@
       "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3252,16 +2705,6 @@
       "dev": true,
       "peer": true
     },
-    "node_modules/react-refresh": {
-      "version": "0.18.0",
-      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.18.0.tgz",
-      "integrity": "sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/read-cache": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
@@ -3340,50 +2783,46 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/rollup": {
-      "version": "4.59.0",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz",
-      "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==",
+    "node_modules/rolldown": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-rc.15.tgz",
+      "integrity": "sha512-Ff31guA5zT6WjnGp0SXw76X6hzGRk/OQq2hE+1lcDe+lJdHSgnSX6nK3erbONHyCbpSj9a9E+uX/OvytZoWp2g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "1.0.8"
+        "@oxc-project/types": "=0.124.0",
+        "@rolldown/pluginutils": "1.0.0-rc.15"
       },
       "bin": {
-        "rollup": "dist/bin/rollup"
+        "rolldown": "bin/cli.mjs"
       },
       "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
+        "node": "^20.19.0 || >=22.12.0"
       },
       "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.59.0",
-        "@rollup/rollup-android-arm64": "4.59.0",
-        "@rollup/rollup-darwin-arm64": "4.59.0",
-        "@rollup/rollup-darwin-x64": "4.59.0",
-        "@rollup/rollup-freebsd-arm64": "4.59.0",
-        "@rollup/rollup-freebsd-x64": "4.59.0",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.59.0",
-        "@rollup/rollup-linux-arm-musleabihf": "4.59.0",
-        "@rollup/rollup-linux-arm64-gnu": "4.59.0",
-        "@rollup/rollup-linux-arm64-musl": "4.59.0",
-        "@rollup/rollup-linux-loong64-gnu": "4.59.0",
-        "@rollup/rollup-linux-loong64-musl": "4.59.0",
-        "@rollup/rollup-linux-ppc64-gnu": "4.59.0",
-        "@rollup/rollup-linux-ppc64-musl": "4.59.0",
-        "@rollup/rollup-linux-riscv64-gnu": "4.59.0",
-        "@rollup/rollup-linux-riscv64-musl": "4.59.0",
-        "@rollup/rollup-linux-s390x-gnu": "4.59.0",
-        "@rollup/rollup-linux-x64-gnu": "4.59.0",
-        "@rollup/rollup-linux-x64-musl": "4.59.0",
-        "@rollup/rollup-openbsd-x64": "4.59.0",
-        "@rollup/rollup-openharmony-arm64": "4.59.0",
-        "@rollup/rollup-win32-arm64-msvc": "4.59.0",
-        "@rollup/rollup-win32-ia32-msvc": "4.59.0",
-        "@rollup/rollup-win32-x64-gnu": "4.59.0",
-        "@rollup/rollup-win32-x64-msvc": "4.59.0",
-        "fsevents": "~2.3.2"
-      }
+        "@rolldown/binding-android-arm64": "1.0.0-rc.15",
+        "@rolldown/binding-darwin-arm64": "1.0.0-rc.15",
+        "@rolldown/binding-darwin-x64": "1.0.0-rc.15",
+        "@rolldown/binding-freebsd-x64": "1.0.0-rc.15",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-rc.15",
+        "@rolldown/binding-linux-arm64-gnu": "1.0.0-rc.15",
+        "@rolldown/binding-linux-arm64-musl": "1.0.0-rc.15",
+        "@rolldown/binding-linux-ppc64-gnu": "1.0.0-rc.15",
+        "@rolldown/binding-linux-s390x-gnu": "1.0.0-rc.15",
+        "@rolldown/binding-linux-x64-gnu": "1.0.0-rc.15",
+        "@rolldown/binding-linux-x64-musl": "1.0.0-rc.15",
+        "@rolldown/binding-openharmony-arm64": "1.0.0-rc.15",
+        "@rolldown/binding-wasm32-wasi": "1.0.0-rc.15",
+        "@rolldown/binding-win32-arm64-msvc": "1.0.0-rc.15",
+        "@rolldown/binding-win32-x64-msvc": "1.0.0-rc.15"
+      }
+    },
+    "node_modules/rolldown/node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-rc.15",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.15.tgz",
+      "integrity": "sha512-UromN0peaE53IaBRe9W7CjrZgXl90fqGpK+mIZbA3qSTeYqg3pqpROBdIPvOG3F5ereDHNwoHBI2e50n1BDr1g==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/run-parallel": {
       "version": "1.2.0",
@@ -3430,21 +2869,12 @@
         "loose-envify": "^1.1.0"
       }
     },
-    "node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
     "node_modules/siginfo": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
       "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
-      "dev": true
+      "dev": true,
+      "license": "ISC"
     },
     "node_modules/source-map-js": {
       "version": "1.2.1",
@@ -3460,13 +2890,15 @@
       "version": "0.0.2",
       "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
       "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
-      "dev": true
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/std-env": {
-      "version": "3.10.0",
-      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
-      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
-      "dev": true
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.0.0.tgz",
+      "integrity": "sha512-zUMPtQ/HBY3/50VbpkupYHbRroTRZJPRLvreamgErJVys0ceuzMkD44J/QjqhHjOzK42GQ3QZIeFG1OYfOtKqQ==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/strip-indent": {
       "version": "3.0.0",
@@ -3599,13 +3031,15 @@
       "version": "2.9.0",
       "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
       "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
-      "dev": true
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/tinyexec": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
-      "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.1.1.tgz",
+      "integrity": "sha512-VKS/ZaQhhkKFMANmAOhhXVoIfBXblQxGX1myCQ2faQrfmobMftXeJPcZGp0gS07ocvGJWDLZGyOZDadDBqYIJg==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=18"
       }
@@ -3646,9 +3080,9 @@
       }
     },
     "node_modules/tinyglobby/node_modules/picomatch": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
-      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3659,10 +3093,11 @@
       }
     },
     "node_modules/tinyrainbow": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.0.3.tgz",
-      "integrity": "sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.0.tgz",
+      "integrity": "sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=14.0.0"
       }
@@ -3733,6 +3168,14 @@
       "dev": true,
       "license": "Apache-2.0"
     },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
     "node_modules/typescript": {
       "version": "5.9.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
@@ -3796,17 +3239,16 @@
       "license": "MIT"
     },
     "node_modules/vite": {
-      "version": "7.3.1",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
-      "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
+      "version": "8.0.8",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.8.tgz",
+      "integrity": "sha512-dbU7/iLVa8KZALJyLOBOQ88nOXtNG8vxKuOT4I2mD+Ya70KPceF4IAmDsmU0h1Qsn5bPrvsY9HJstCRh3hG6Uw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "esbuild": "^0.27.0",
-        "fdir": "^6.5.0",
-        "picomatch": "^4.0.3",
-        "postcss": "^8.5.6",
-        "rollup": "^4.43.0",
+        "lightningcss": "^1.32.0",
+        "picomatch": "^4.0.4",
+        "postcss": "^8.5.8",
+        "rolldown": "1.0.0-rc.15",
         "tinyglobby": "^0.2.15"
       },
       "bin": {
@@ -3823,9 +3265,10 @@
       },
       "peerDependencies": {
         "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.1.0",
+        "esbuild": "^0.27.0 || ^0.28.0",
         "jiti": ">=1.21.0",
         "less": "^4.0.0",
-        "lightningcss": "^1.21.0",
         "sass": "^1.70.0",
         "sass-embedded": "^1.70.0",
         "stylus": ">=0.54.8",
@@ -3838,13 +3281,16 @@
         "@types/node": {
           "optional": true
         },
-        "jiti": {
+        "@vitejs/devtools": {
           "optional": true
         },
-        "less": {
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
           "optional": true
         },
-        "lightningcss": {
+        "less": {
           "optional": true
         },
         "sass": {
@@ -3870,28 +3316,10 @@
         }
       }
     },
-    "node_modules/vite/node_modules/fdir": {
-      "version": "6.5.0",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
-      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "peerDependencies": {
-        "picomatch": "^3 || ^4"
-      },
-      "peerDependenciesMeta": {
-        "picomatch": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/vite/node_modules/picomatch": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
-      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3902,30 +3330,31 @@
       }
     },
     "node_modules/vitest": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.0.18.tgz",
-      "integrity": "sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ==",
-      "dev": true,
-      "dependencies": {
-        "@vitest/expect": "4.0.18",
-        "@vitest/mocker": "4.0.18",
-        "@vitest/pretty-format": "4.0.18",
-        "@vitest/runner": "4.0.18",
-        "@vitest/snapshot": "4.0.18",
-        "@vitest/spy": "4.0.18",
-        "@vitest/utils": "4.0.18",
-        "es-module-lexer": "^1.7.0",
-        "expect-type": "^1.2.2",
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.4.tgz",
+      "integrity": "sha512-tFuJqTxKb8AvfyqMfnavXdzfy3h3sWZRWwfluGbkeR7n0HUev+FmNgZ8SDrRBTVrVCjgH5cA21qGbCffMNtWvg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.1.4",
+        "@vitest/mocker": "4.1.4",
+        "@vitest/pretty-format": "4.1.4",
+        "@vitest/runner": "4.1.4",
+        "@vitest/snapshot": "4.1.4",
+        "@vitest/spy": "4.1.4",
+        "@vitest/utils": "4.1.4",
+        "es-module-lexer": "^2.0.0",
+        "expect-type": "^1.3.0",
         "magic-string": "^0.30.21",
         "obug": "^2.1.1",
         "pathe": "^2.0.3",
         "picomatch": "^4.0.3",
-        "std-env": "^3.10.0",
+        "std-env": "^4.0.0-rc.1",
         "tinybench": "^2.9.0",
         "tinyexec": "^1.0.2",
         "tinyglobby": "^0.2.15",
-        "tinyrainbow": "^3.0.3",
-        "vite": "^6.0.0 || ^7.0.0",
+        "tinyrainbow": "^3.1.0",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
         "why-is-node-running": "^2.3.0"
       },
       "bin": {
@@ -3941,12 +3370,15 @@
         "@edge-runtime/vm": "*",
         "@opentelemetry/api": "^1.9.0",
         "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
-        "@vitest/browser-playwright": "4.0.18",
-        "@vitest/browser-preview": "4.0.18",
-        "@vitest/browser-webdriverio": "4.0.18",
-        "@vitest/ui": "4.0.18",
+        "@vitest/browser-playwright": "4.1.4",
+        "@vitest/browser-preview": "4.1.4",
+        "@vitest/browser-webdriverio": "4.1.4",
+        "@vitest/coverage-istanbul": "4.1.4",
+        "@vitest/coverage-v8": "4.1.4",
+        "@vitest/ui": "4.1.4",
         "happy-dom": "*",
-        "jsdom": "*"
+        "jsdom": "*",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
       },
       "peerDependenciesMeta": {
         "@edge-runtime/vm": {
@@ -3967,6 +3399,12 @@
         "@vitest/browser-webdriverio": {
           "optional": true
         },
+        "@vitest/coverage-istanbul": {
+          "optional": true
+        },
+        "@vitest/coverage-v8": {
+          "optional": true
+        },
         "@vitest/ui": {
           "optional": true
         },
@@ -3975,14 +3413,18 @@
         },
         "jsdom": {
           "optional": true
+        },
+        "vite": {
+          "optional": false
         }
       }
     },
     "node_modules/vitest/node_modules/picomatch": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
-      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=12"
       },
@@ -4042,6 +3484,7 @@
       "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
       "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "siginfo": "^2.0.0",
         "stackback": "0.0.2"
@@ -4067,13 +3510,6 @@
       "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
       "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
       "dev": true
-    },
-    "node_modules/yallist": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
-      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
-      "dev": true,
-      "license": "ISC"
     }
   }
 }
diff --git a/tauri-app/src-ui/package.json b/tauri-app/src-ui/package.json
index dfc993ce..3288e72e 100644
--- a/tauri-app/src-ui/package.json
+++ b/tauri-app/src-ui/package.json
@@ -15,8 +15,8 @@
   "dependencies": {
     "@tauri-apps/api": "^2.0.0",
     "@tauri-apps/plugin-dialog": "^2.6.0",
-    "@tauri-apps/plugin-updater": "^2.0.0",
     "@tauri-apps/plugin-process": "^2.0.0",
+    "@tauri-apps/plugin-updater": "^2.0.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
@@ -26,15 +26,15 @@
     "@testing-library/user-event": "^14.6.1",
     "@types/react": "^18.2.0",
     "@types/react-dom": "^18.2.0",
-    "@vitejs/plugin-react": "^5.1.4",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@vitejs/plugin-react": "^6.0.1",
+    "@vitest/coverage-v8": "^4.1.4",
     "autoprefixer": "^10.4.16",
     "jsdom": "^29.0.0",
     "postcss": "^8.5.8",
     "tailwindcss": "^3.4.0",
     "typescript": "^5.3.0",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.18"
+    "vite": "^8.0.8",
+    "vitest": "^4.1.4"
   },
   "overrides": {
     "esbuild": ">=0.25.0"
diff --git a/tauri-app/src-ui/src/App.tsx b/tauri-app/src-ui/src/App.tsx
index bd6c9c4b..35770b4c 100644
--- a/tauri-app/src-ui/src/App.tsx
+++ b/tauri-app/src-ui/src/App.tsx
@@ -1,6 +1,6 @@
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { ThemeProvider, useTheme } from "./contexts/ThemeContext";
 import SoulRegistry from "./components/SoulRegistry";
 import BootSequence from "./components/BootSequence";
@@ -114,17 +114,14 @@ function AppInner() {
   const { refreshAgentName, refreshTheme } = useTheme();
   const skillToasts = useSkillEvents();
 
-  const initializeApp = async () => {
+  const initializeAppRef = useRef<() => Promise<void>>();
+  initializeAppRef.current = async () => {
     try {
-      // Always enter Registry selection first for explicit mentor choice.
       const activeAgent = await invoke<string | null>("get_active_agent");
       if (activeAgent) {
         await invoke("suspend_agent");
       }
 
-      // Start managed Ollama (bundled Hive agent LLM).
-      // Await the result BEFORE entering model_loading so AbnormalBrainScreen
-      // mounts with correct initial values for isFirstPull / progress / status.
       let needsPull = false;
       let ollamaFailed = false;
       try {
@@ -135,7 +132,6 @@ function AppInner() {
       }
 
       if (ollamaFailed) {
-        // No Ollama — show instant text + 100% bar, let onReady transition
         setIsFirstPull(false);
         setOllamaProgress(100);
         setOllamaStatus("No local LLM found — continuing with cloud providers");
@@ -144,35 +140,33 @@ function AppInner() {
       }
 
       if (needsPull) {
-        // Model is being downloaded — typewriter + progress bar via events
         setIsFirstPull(true);
         setOllamaProgress(0);
-        setOllamaStatus("Downloading model...");
+        setOllamaStatus("Preparing local model...");
         setAppState("model_loading");
         return;
       }
 
-      // Model exists — show instant text + 100% bar, fire warmup in background
       setIsFirstPull(false);
       setOllamaProgress(100);
       setOllamaStatus("Hive agent ready");
       setAppState("model_loading");
-      // Non-blocking warmup — model will load on first real request if this fails
       invoke("warmup_ollama_model").catch(() => {});
     } catch (e) {
       console.error("[App] initializeApp failed; falling back to management screen:", e);
-      // Fallback to management screen on error
       setAppState("management");
     }
   };
 
-  const handleSplashComplete = () => {
+  const handleSplashComplete = useCallback(() => {
     setAppState("loading");
-    initializeApp();
-  };
+    initializeAppRef.current?.();
+  }, []);
 
-  // Continue to management screen after model loading completes
-  const continueAfterModelReady = async () => {
+  // Continue to management screen after model loading completes.
+  // Wrapped in useCallback so AbnormalBrainScreen's onReady/onSkip
+  // effects don't get invalidated by parent re-renders.
+  const continueAfterModelReady = useCallback(async () => {
     try {
       const identities = await invoke<unknown[]>("get_identities");
       if (identities.length === 0) {
@@ -188,7 +182,7 @@ function AppInner() {
       console.error("[App] continueAfterModelReady failed:", e);
       setAppState("management");
     }
-  };
+  }, []);
 
   // Listen for Ollama lifecycle and model progress events
   useEffect(() => {
@@ -196,16 +190,21 @@ function AppInner() {
 
     listen<Record<string, unknown> | string>("ollama-lifecycle", (event) => {
       const payload = event.payload;
-      if (typeof payload === "object" && payload !== null && "pulling_model" in payload) {
-        // PullingModel { progress_pct } — serde serializes to {"pulling_model": {"progress_pct": N}}
+      if (typeof payload === "object" && payload !== null && "installing_ollama" in payload) {
+        const inner = (payload as { installing_ollama: { progress_pct?: number } }).installing_ollama;
+        const rawPct = inner?.progress_pct ?? 0;
+        setOllamaProgress(rawPct * 0.4);
+        setOllamaStatus("Installing Ollama...");
+      } else if (payload === "starting") {
+        setOllamaStatus("Starting Ollama server...");
+      } else if (typeof payload === "object" && payload !== null && "pulling_model" in payload) {
         const inner = (payload as { pulling_model: { progress_pct?: number } }).pulling_model;
-        setOllamaProgress(inner?.progress_pct ?? 0);
+        const rawPct = inner?.progress_pct ?? 0;
+        setOllamaProgress(40 + rawPct * 0.6);
       } else if (payload === "model_ready") {
         setOllamaProgress(100);
-        // onReady in AbnormalBrainScreen will handle transition after brief pause
       } else if (typeof payload === "object" && payload !== null && "error" in payload) {
         console.warn("[App] Ollama lifecycle error:", payload);
-        // Skip to management on error
         setAppState("management");
       }
     }).then((fn) => unlisteners.push(fn));
@@ -214,9 +213,9 @@ function AppInner() {
       "ollama-model-progress",
       (event) => {
         const { status, completed, total } = event.payload;
-        setOllamaStatus(status || "Downloading...");
+        setOllamaStatus(status || "Downloading model...");
         if (completed != null && total != null && total > 0) {
-          setOllamaProgress((completed / total) * 100);
+          setOllamaProgress(40 + (completed / total) * 60);
         }
       }
     ).then((fn) => unlisteners.push(fn));
@@ -227,9 +226,8 @@ function AppInner() {
   }, []);
 
   useEffect(() => {
-    // If we somehow start in loading (e.g. no splash needed), initialize immediately
     if (appState === "loading") {
-      initializeApp();
+      initializeAppRef.current?.();
     }
   }, []);
 
diff --git a/tauri-app/src-ui/src/browserTauriHarness.ts b/tauri-app/src-ui/src/browserTauriHarness.ts
index e49a592e..cdcdbe4b 100644
--- a/tauri-app/src-ui/src/browserTauriHarness.ts
+++ b/tauri-app/src-ui/src/browserTauriHarness.ts
@@ -548,25 +548,6 @@ async function handleInvoke(cmd: string, args: Record<string, unknown> = {}): Pr
       return null;
     }
 
-    // Orchestration backend
-    case "get_orchestration_backend_status":
-      return {
-        healthy: true,
-        jobs_loaded: 0,
-        runtime_loaded_runs: state.agenticRuns.length,
-        runtime_active_runs: state.agenticRuns.filter((run) => !["completed", "failed", "cancelled"].includes(run.status)).length,
-      };
-    case "list_orchestration_jobs":
-      return [];
-    case "set_orchestration_job_enabled":
-      return null;
-    case "delete_orchestration_job":
-      return null;
-    case "run_orchestration_job_now":
-      return { run_id: `orch-${Date.now()}`, mode: "id_check", result_summary: "Harness orchestration run complete." };
-    case "list_orchestration_job_logs":
-      return [];
-
     // Chat screen status
     case "get_router_status": {
       const hasLocalHttp = typeof state.localLlmUrl === "string" && state.localLlmUrl.trim().length > 0;
diff --git a/tauri-app/src-ui/src/components/AbnormalBrainScreen.tsx b/tauri-app/src-ui/src/components/AbnormalBrainScreen.tsx
index 5e163b5b..6ce303a8 100644
--- a/tauri-app/src-ui/src/components/AbnormalBrainScreen.tsx
+++ b/tauri-app/src-ui/src/components/AbnormalBrainScreen.tsx
@@ -45,15 +45,19 @@ export default function AbnormalBrainScreen({
   const [flickerChar, setFlickerChar] = useState<string | null>(null);
   const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
+  // Keep a stable ref so the effect doesn't depend on callback identity.
+  const onReadyRef = useRef(onReady);
+  onReadyRef.current = onReady;
+
   // When progress hits 100, notify parent after a brief pause
   const readyFired = useRef(false);
   useEffect(() => {
     if (progress >= 100 && !readyFired.current) {
       readyFired.current = true;
-      const t = setTimeout(onReady, 600);
+      const t = setTimeout(() => onReadyRef.current(), 600);
       return () => clearTimeout(t);
     }
-  }, [progress, onReady]);
+  }, [progress]);
 
   // Sync typewriterDone when isFirstPull changes to false after mount
   useEffect(() => {
diff --git a/tauri-app/src-ui/src/components/SanctumDrawer.tsx b/tauri-app/src-ui/src/components/SanctumDrawer.tsx
index 00b653a4..a8295d6f 100644
--- a/tauri-app/src-ui/src/components/SanctumDrawer.tsx
+++ b/tauri-app/src-ui/src/components/SanctumDrawer.tsx
@@ -116,7 +116,7 @@ export default function SanctumDrawer({ open, onClose, onDisconnect }: SanctumDr
     let mounted = true;
     const checkBackendReadiness = async () => {
       try {
-        const status = await invoke<{ healthy: boolean }>("get_orchestration_backend_status");
+        const status = await invoke<{ healthy: boolean }>("get_agentic_runtime_status");
         if (mounted) {
           setBackendReady(Boolean(status?.healthy));
         }
diff --git a/tauri-app/src-ui/src/components/UpdateNotification.tsx b/tauri-app/src-ui/src/components/UpdateNotification.tsx
index eb6f2440..ff72a5e1 100644
--- a/tauri-app/src-ui/src/components/UpdateNotification.tsx
+++ b/tauri-app/src-ui/src/components/UpdateNotification.tsx
@@ -3,11 +3,15 @@ import { check, Update } from "@tauri-apps/plugin-updater";
 import { relaunch } from "@tauri-apps/plugin-process";
 
 export default function UpdateNotification() {
+  const updaterEnabled = import.meta.env.VITE_ABIGAIL_ENABLE_UPDATER === "true";
   const [update, setUpdate] = useState<Update | null>(null);
   const [installing, setInstalling] = useState(false);
   const [dismissed, setDismissed] = useState(false);
 
   useEffect(() => {
+    if (!updaterEnabled) {
+      return;
+    }
     let cancelled = false;
     check()
       .then((u) => {
@@ -21,7 +25,9 @@ export default function UpdateNotification() {
     return () => {
       cancelled = true;
     };
-  }, []);
+  }, [updaterEnabled]);
+
+  if (!updaterEnabled) return null;
 
   if (!update || dismissed) return null;
 
diff --git a/tauri-app/src-ui/src/components/__tests__/SanctumDrawer.test.tsx b/tauri-app/src-ui/src/components/__tests__/SanctumDrawer.test.tsx
index eabe504a..095da44f 100644
--- a/tauri-app/src-ui/src/components/__tests__/SanctumDrawer.test.tsx
+++ b/tauri-app/src-ui/src/components/__tests__/SanctumDrawer.test.tsx
@@ -28,7 +28,7 @@ describe("SanctumDrawer", () => {
 
     let backendHealthy = true;
     mockInvoke.mockImplementation((cmd: string) => {
-      if (cmd === "get_orchestration_backend_status") {
+      if (cmd === "get_agentic_runtime_status") {
         return Promise.resolve({ healthy: backendHealthy });
       }
       return Promise.resolve(null);
@@ -61,7 +61,7 @@ describe("SanctumDrawer", () => {
   it("shows browser sessions and clear controls in the Browser Session tab", async () => {
     const user = userEvent.setup();
     mockInvoke.mockImplementation((cmd: string) => {
-      if (cmd === "get_orchestration_backend_status") {
+      if (cmd === "get_agentic_runtime_status") {
         return Promise.resolve({ healthy: false });
       }
       if (cmd === "list_browser_sessions") {
diff --git a/tauri-app/src/chat_coordinator.rs b/tauri-app/src/chat_coordinator.rs
index 016d1add..444d208e 100644
--- a/tauri-app/src/chat_coordinator.rs
+++ b/tauri-app/src/chat_coordinator.rs
@@ -179,6 +179,12 @@ impl<'a> ChatCoordinator<'a> {
             }
         });
 
+        // Chat turns are depth 0; jobs submitted from this turn nest below it
+        // and inherit the turn's correlation id for trace continuity.
+        let job_ctx = entity_chat::JobContext {
+            depth: 0,
+            correlation_id: Some(prepared.correlation_id.clone()),
+        };
         let pipeline_fut = entity_chat::stream_chat_pipeline(
             &prepared.router,
             &self.state.executor,
@@ -186,6 +192,7 @@ impl<'a> ChatCoordinator<'a> {
             prepared.tools,
             tx,
             prepared.model_override,
+            Some(&job_ctx),
         );
         tokio::pin!(pipeline_fut);
 
diff --git a/tauri-app/src/commands/chat.rs b/tauri-app/src/commands/chat.rs
index 9b16518b..1cb6d027 100644
--- a/tauri-app/src/commands/chat.rs
+++ b/tauri-app/src/commands/chat.rs
@@ -164,11 +164,11 @@ pub fn get_assembled_prompt(state: State<AppState>) -> Result<String, String> {
 pub fn get_topic_stats(_state: State<AppState>) -> Result<serde_json::Value, String> {
     Ok(serde_json::json!({
         "topics": [
-            { "stream": "abigail", "topic": "conversation-turns", "description": "Chat turn persistence" },
-            { "stream": "abigail", "topic": "job-events", "description": "Job lifecycle events" },
-            { "stream": "abigail", "topic": "skill-events", "description": "Skill hot-reload events" },
-            { "stream": "entity", "topic": "conscience-check", "description": "Ethical check requests" },
-            { "stream": "entity", "topic": "ethical-signals", "description": "Ethical evaluation results" },
+            { "stream": "entity", "topic": "memory.archive", "description": "Chat turn persistence" },
+            { "stream": "entity", "topic": "job.events", "description": "Job lifecycle events" },
+            { "stream": "entity", "topic": "skill.executed", "description": "Skill execution events" },
+            { "stream": "entity", "topic": "conscience.check", "description": "Ethical check requests" },
+            { "stream": "entity", "topic": "superego.evaluation", "description": "Ethical evaluation results" },
         ]
     }))
 }
diff --git a/tauri-app/src/commands/jobs.rs b/tauri-app/src/commands/jobs.rs
index b9324cdb..8c1a8702 100644
--- a/tauri-app/src/commands/jobs.rs
+++ b/tauri-app/src/commands/jobs.rs
@@ -115,6 +115,9 @@ pub async fn submit_job(
         ttl_seconds: args.ttl_seconds.unwrap_or(3600),
         input_data: args.input_data,
         parent_job_id: args.parent_job_id,
+        parent_correlation_id: None,
+        depth: 0,
+        provider_profile: None,
         cron_expression: args.cron_expression,
         is_recurring: args.is_recurring.unwrap_or(false),
         significance_keywords: vec![],
diff --git a/tauri-app/src/commands/mod.rs b/tauri-app/src/commands/mod.rs
index 45f80b29..22cd441e 100644
--- a/tauri-app/src/commands/mod.rs
+++ b/tauri-app/src/commands/mod.rs
@@ -10,6 +10,5 @@ pub mod jobs;
 pub mod logging;
 pub mod memory;
 pub mod ollama;
-pub mod orchestration;
 pub mod sensory;
 pub mod skills;
diff --git a/tauri-app/src/commands/ollama.rs b/tauri-app/src/commands/ollama.rs
index 02afe61f..16548615 100644
--- a/tauri-app/src/commands/ollama.rs
+++ b/tauri-app/src/commands/ollama.rs
@@ -160,9 +160,14 @@ pub async fn set_local_llm_during_birth(
 }
 
 /// Start the managed Ollama instance, pull model if needed, and configure the
-/// local LLM URL for the router.  Returns `true` if the model needed to be
-/// pulled (so the frontend can show the loading screen), `false` if it was
-/// already present or Ollama management is disabled.
+/// local LLM URL for the router.  Returns `true` if background work (install
+/// and/or model pull) is happening, `false` if everything was already ready or
+/// Ollama management is disabled.
+///
+/// When Ollama is not installed, this command **auto-installs** it before
+/// starting the server and pulling the model.  All heavy work runs in a
+/// background tokio task; the command returns immediately so the frontend can
+/// show the loading screen.
 ///
 /// Emits `ollama-lifecycle` events so the frontend can track progress.
 #[tauri::command]
@@ -209,125 +214,108 @@ pub async fn start_managed_ollama(
         config.data_dir.clone()
     };
 
-    // 5. Start Ollama (bundled or system)
-    let mgr = OllamaManager::discover_and_start_bundled(&data_dir, bundled_path).await?;
-    let base_url = mgr.base_url();
-
-    // 6. Store manager in state
-    {
-        let mut guard = state.ollama.lock().await;
-        *guard = Some(mgr);
-    }
+    // 5. Try to start Ollama (bundled or system).  If not found, auto-install.
+    let start_result = OllamaManager::discover_and_start_bundled(&data_dir, bundled_path).await;
 
-    let _ = app.emit("ollama-lifecycle", OllamaLifecycleState::Running);
+    let needs_install = start_result.is_err();
 
-    // 7. Check if model already exists
-    let model_exists = {
-        let guard = state.ollama.lock().await;
-        if let Some(ref mgr) = *guard {
-            // Quick check via the existing ensure_model pattern — look at /api/tags
-            let client = reqwest::Client::new();
-            let tags_url = format!("{}/api/tags", mgr.base_url());
-            match client.get(&tags_url).send().await {
-                Ok(resp) => {
-                    if let Ok(body) = resp.json::<serde_json::Value>().await {
-                        body.get("models")
-                            .and_then(|m| m.as_array())
-                            .map(|models| {
-                                models.iter().any(|m| {
-                                    m.get("name").and_then(|n| n.as_str()).is_some_and(|name| {
-                                        name == model_name
-                                            || name == format!("{}:latest", model_name)
-                                            || name.starts_with(&format!("{}:", model_name))
-                                    })
-                                })
-                            })
-                            .unwrap_or(false)
-                    } else {
-                        false
-                    }
-                }
-                Err(_) => false,
-            }
-        } else {
-            false
-        }
-    };
-
-    let needs_pull = !model_exists;
-
-    if needs_pull {
-        // 8. Return immediately so the frontend can show the loading screen,
-        //    then pull the model in a background task that emits progress events.
+    if needs_install {
+        // Ollama binary not found — run install + start + model-pull in background.
+        tracing::info!("Ollama not found; launching background auto-install");
         let app_bg = app.clone();
+        let data_dir_bg = data_dir.clone();
+
         tokio::spawn(async move {
             let state_ref = app_bg.state::<AppState>();
 
-            // Pull model with streaming progress
-            let pull_result =
-                OllamaManager::pull_model_streaming(&base_url, &model_name, |progress| {
-                    let pct = match (progress.completed, progress.total) {
-                        (Some(c), Some(t)) if t > 0 => (c as f32 / t as f32) * 100.0,
+            // ── Phase 1: Install Ollama ──────────────────────────────
+            let _ = app_bg.emit(
+                "ollama-lifecycle",
+                OllamaLifecycleState::InstallingOllama { progress_pct: 0.0 },
+            );
+
+            let app_install = app_bg.clone();
+            let install_result =
+                OllamaManager::download_and_install(move |progress: OllamaInstallProgress| {
+                    let pct = match (progress.written, progress.total) {
+                        (Some(w), Some(t)) if t > 0 => (w as f32 / t as f32) * 100.0,
                         _ => 0.0,
                     };
-                    let _ = app_bg.emit(
+                    let _ = app_install.emit(
                         "ollama-lifecycle",
-                        OllamaLifecycleState::PullingModel { progress_pct: pct },
-                    );
-                    let _ = app_bg.emit(
-                        "ollama-model-progress",
-                        OllamaModelProgress {
-                            model: model_name.clone(),
-                            completed: progress.completed,
-                            total: progress.total,
-                            status: progress.status.clone(),
-                        },
+                        OllamaLifecycleState::InstallingOllama { progress_pct: pct },
                     );
                 })
                 .await;
 
-            if let Err(e) = pull_result {
-                tracing::error!("Background model pull failed: {}", e);
+            if let Err(e) = install_result {
+                tracing::error!("Auto-install of Ollama failed: {}", e);
                 let _ = app_bg.emit(
                     "ollama-lifecycle",
-                    OllamaLifecycleState::Error(e.to_string()),
+                    OllamaLifecycleState::Error(format!("Ollama install failed: {e}")),
                 );
                 return;
             }
 
-            // Mark model ready
+            tracing::info!("Ollama auto-install complete, starting server");
+
+            // ── Phase 2: Start the freshly installed Ollama ──────────
+            let _ = app_bg.emit("ollama-lifecycle", OllamaLifecycleState::Starting);
+
+            let mgr = match OllamaManager::discover_and_start(&data_dir_bg).await {
+                Ok(m) => m,
+                Err(e) => {
+                    tracing::error!("Failed to start Ollama after install: {}", e);
+                    let _ = app_bg.emit(
+                        "ollama-lifecycle",
+                        OllamaLifecycleState::Error(format!(
+                            "Ollama installed but failed to start: {e}"
+                        )),
+                    );
+                    return;
+                }
+            };
+
+            let base_url = mgr.base_url();
             {
                 let mut guard = state_ref.ollama.lock().await;
-                if let Some(ref mut mgr) = *guard {
-                    mgr.mark_model_ready();
-                }
+                *guard = Some(mgr);
             }
+            let _ = app_bg.emit("ollama-lifecycle", OllamaLifecycleState::Running);
 
-            // Auto-configure local_llm_base_url
-            if let Ok(mut config) = state_ref.config.write() {
-                let should_set = config.local_llm_base_url.is_none()
-                    || config
-                        .local_llm_base_url
-                        .as_deref()
-                        .is_none_or(|u| u.is_empty());
-                if should_set {
-                    config.local_llm_base_url = Some(base_url.clone());
-                }
-                if !first_pull_done {
-                    config.first_model_pull_complete = true;
-                }
-                let _ = config.save(&config.config_path());
-            }
+            // ── Phase 3: Pull model ──────────────────────────────────
+            pull_model_and_finalize(&app_bg, &state_ref, &base_url, &model_name, first_pull_done)
+                .await;
+        });
 
-            // Rebuild router
-            if let Err(e) = crate::rebuild_router_from_handle(&app_bg).await {
-                tracing::warn!("Failed to rebuild router after Ollama start: {}", e);
-            }
+        return Ok(true);
+    }
+
+    // Ollama was already installed — normal synchronous start succeeded.
+    let mgr = start_result.unwrap();
+    let base_url = mgr.base_url();
+
+    // 6. Store manager in state
+    {
+        let mut guard = state.ollama.lock().await;
+        *guard = Some(mgr);
+    }
+
+    let _ = app.emit("ollama-lifecycle", OllamaLifecycleState::Running);
+
+    // 7. Check if model already exists
+    let model_exists = check_model_exists_on_server(&base_url, &model_name).await;
+
+    let needs_pull = !model_exists;
 
-            let _ = app_bg.emit("ollama-lifecycle", OllamaLifecycleState::ModelReady);
+    if needs_pull {
+        let app_bg = app.clone();
+        tokio::spawn(async move {
+            let state_ref = app_bg.state::<AppState>();
+            pull_model_and_finalize(&app_bg, &state_ref, &base_url, &model_name, first_pull_done)
+                .await;
         });
 
-        // Return immediately — frontend shows loading screen
         return Ok(true);
     }
 
@@ -368,6 +356,106 @@ pub async fn start_managed_ollama(
     Ok(false)
 }
 
+/// Check whether a model is already available on a running Ollama server.
+async fn check_model_exists_on_server(base_url: &str, model_name: &str) -> bool {
+    let client = reqwest::Client::new();
+    let tags_url = format!("{}/api/tags", base_url);
+    match client.get(&tags_url).send().await {
+        Ok(resp) => {
+            if let Ok(body) = resp.json::<serde_json::Value>().await {
+                body.get("models")
+                    .and_then(|m| m.as_array())
+                    .map(|models| {
+                        models.iter().any(|m| {
+                            m.get("name").and_then(|n| n.as_str()).is_some_and(|name| {
+                                name == model_name
+                                    || name == format!("{}:latest", model_name)
+                                    || name.starts_with(&format!("{}:", model_name))
+                            })
+                        })
+                    })
+                    .unwrap_or(false)
+            } else {
+                false
+            }
+        }
+        Err(_) => false,
+    }
+}
+
+/// Background helper: pull a model, configure `local_llm_base_url`, rebuild
+/// the router, and emit `ModelReady`.  Used by both the fresh-install path and
+/// the normal "Ollama exists but model is missing" path.
+async fn pull_model_and_finalize(
+    app: &tauri::AppHandle,
+    state: &AppState,
+    base_url: &str,
+    model_name: &str,
+    first_pull_done: bool,
+) {
+    let base_url = base_url.to_string();
+    let model_name = model_name.to_string();
+    let app_bg = app.clone();
+
+    let pull_result = OllamaManager::pull_model_streaming(&base_url, &model_name, |progress| {
+        let pct = match (progress.completed, progress.total) {
+            (Some(c), Some(t)) if t > 0 => (c as f32 / t as f32) * 100.0,
+            _ => 0.0,
+        };
+        let _ = app_bg.emit(
+            "ollama-lifecycle",
+            OllamaLifecycleState::PullingModel { progress_pct: pct },
+        );
+        let _ = app_bg.emit(
+            "ollama-model-progress",
+            OllamaModelProgress {
+                model: model_name.clone(),
+                completed: progress.completed,
+                total: progress.total,
+                status: progress.status.clone(),
+            },
+        );
+    })
+    .await;
+
+    if let Err(e) = pull_result {
+        tracing::error!("Background model pull failed: {}", e);
+        let _ = app.emit(
+            "ollama-lifecycle",
+            OllamaLifecycleState::Error(e.to_string()),
+        );
+        return;
+    }
+
+    {
+        let mut guard = state.ollama.lock().await;
+        if let Some(ref mut mgr) = *guard {
+            mgr.mark_model_ready();
+        }
+    }
+
+    if let Ok(mut config) = state.config.write() {
+        let should_set = config.local_llm_base_url.is_none()
+            || config
+                .local_llm_base_url
+                .as_deref()
+                .is_none_or(|u| u.is_empty());
+        if should_set {
+            config.local_llm_base_url = Some(base_url.clone());
+        }
+        if !first_pull_done {
+            config.first_model_pull_complete = true;
+        }
+        let _ = config.save(&config.config_path());
+    }
+
+    if let Err(e) = crate::rebuild_router_from_handle(app).await {
+        tracing::warn!("Failed to rebuild router after Ollama start: {}", e);
+    }
+
+    let _ = app.emit("ollama-lifecycle", OllamaLifecycleState::ModelReady);
+}
+
 /// Send a lightweight generate request to Ollama so the model loads into memory.
 /// This avoids a cold-start delay on the first real chat request.
 #[tauri::command]
diff --git a/tauri-app/src/commands/orchestration.rs b/tauri-app/src/commands/orchestration.rs
deleted file mode 100644
index 7001c55f..00000000
--- a/tauri-app/src/commands/orchestration.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-#![allow(deprecated)] // OrchestrationScheduler is deprecated; Tauri still uses it until migration.
-
-use crate::agentic_runtime::RunAttribution;
-use crate::state::AppState;
-use abigail_capabilities::cognitive::provider::Message;
-use abigail_router::{JobMode, OrchestrationJobLog};
-use serde::Serialize;
-use tauri::State;
-
-#[derive(Debug, Serialize)]
-pub struct OrchestrationBackendStatus {
-    pub healthy: bool,
-    pub jobs_loaded: usize,
-    pub runtime_loaded_runs: usize,
-    pub runtime_active_runs: usize,
-}
-
-#[tauri::command]
-pub async fn get_orchestration_backend_status(
-    state: State<'_, AppState>,
-) -> Result<OrchestrationBackendStatus, String> {
-    let jobs_loaded = state.orchestration_scheduler.list_jobs().await.len();
-    let runtime = state.agentic_runtime.status().await;
-
-    Ok(OrchestrationBackendStatus {
-        healthy: runtime.healthy,
-        jobs_loaded,
-        runtime_loaded_runs: runtime.loaded_runs,
-        runtime_active_runs: runtime.active_runs,
-    })
-}
-
-#[tauri::command]
-pub async fn list_orchestration_jobs(
-    state: State<'_, AppState>,
-) -> Result<Vec<abigail_router::OrchestrationJob>, String> {
-    Ok(state.orchestration_scheduler.list_jobs().await)
-}
-
-#[tauri::command]
-pub async fn set_orchestration_job_enabled(
-    state: State<'_, AppState>,
-    job_id: String,
-    enabled: bool,
-) -> Result<(), String> {
-    state
-        .orchestration_scheduler
-        .set_enabled(&job_id, enabled)
-        .await
-        .map_err(|e| e.to_string())
-}
-
-#[tauri::command]
-pub async fn delete_orchestration_job(
-    state: State<'_, AppState>,
-    job_id: String,
-) -> Result<(), String> {
-    state
-        .orchestration_scheduler
-        .delete_job(&job_id)
-        .await
-        .map_err(|e| e.to_string())
-}
-
-#[tauri::command]
-pub async fn list_orchestration_job_logs(
-    state: State<'_, AppState>,
-    job_id: Option<String>,
-) -> Result<Vec<OrchestrationJobLog>, String> {
-    Ok(state
-        .orchestration_scheduler
-        .get_logs(job_id.as_deref())
-        .await)
-}
-
-#[derive(Debug, Serialize)]
-pub struct RunNowResult {
-    pub run_id: String,
-    pub mode: String,
-    pub result_summary: String,
-}
-
-#[tauri::command]
-pub async fn run_orchestration_job_now(
-    app: tauri::AppHandle,
-    state: State<'_, AppState>,
-    job_id: String,
-) -> Result<RunNowResult, String> {
-    let jobs = state.orchestration_scheduler.list_jobs().await;
-    let job = jobs
-        .into_iter()
-        .find(|j| j.job_id == job_id)
-        .ok_or_else(|| format!("Job not found: {}", job_id))?;
-
-    let started = std::time::Instant::now();
-    let (result_summary, run_id) = match job.mode {
-        JobMode::AgenticRun => {
-            let provider = {
-                let router = state.router.read().map_err(|e| e.to_string())?.clone();
-                router.best_available_provider().ok_or_else(|| {
-                    "No available provider for orchestration agentic run".to_string()
-                })?
-            };
-
-            let task_id = state
-                .agentic_runtime
-                .start_run(
-                    provider,
-                    entity_chat::build_tool_definitions(&state.registry),
-                    state.executor.clone(),
-                    abigail_router::RunConfig {
-                        goal: job.goal_template.clone().unwrap_or_else(|| {
-                            format!("Execute orchestration job '{}'.", job.name)
-                        }),
-                        max_turns: 8,
-                        require_confirmation: false,
-                        system_context: Some(format!(
-                            "Orchestration job {} ({}) initiated this run.",
-                            job.name, job.job_id
-                        )),
-                    },
-                    RunAttribution::entity(
-                        Some("orchestration".to_string()),
-                        Some(job.job_id.clone()),
-                        None,
-                    ),
-                    Some(app),
-                )
-                .await
-                .map_err(|e| e.to_string())?;
-
-            (
-                format!(
-                    "Spawned agentic run {} from orchestration job {}",
-                    task_id, job.job_id
-                ),
-                task_id,
-            )
-        }
-        JobMode::IdCheck => {
-            let router = state.router.read().map_err(|e| e.to_string())?.clone();
-            let prompt = job.goal_template.clone().unwrap_or_else(|| {
-                format!(
-                    "Run the scheduled Id health check for job '{}' and summarize findings.",
-                    job.name
-                )
-            });
-            let response = {
-                let mut req =
-                    abigail_router::RoutingRequest::simple(vec![Message::new("user", &prompt)]);
-                req.force_id_only = true;
-                router
-                    .route_unified(req)
-                    .await
-                    .map(|r| r.completion)
-                    .map_err(|e| e.to_string())?
-            };
-            let run_id = uuid::Uuid::new_v4().to_string();
-            (response.content, run_id)
-        }
-    };
-
-    let (_, decision) = abigail_router::OrchestrationScheduler::score_significance(
-        &result_summary,
-        &job.significance_policy,
-    );
-
-    state
-        .orchestration_scheduler
-        .record_log(OrchestrationJobLog {
-            job_id: job.job_id.clone(),
-            run_id: run_id.clone(),
-            ran_at: chrono::Utc::now().to_rfc3339(),
-            result: result_summary.clone(),
-            decision,
-            duration_ms: started.elapsed().as_millis() as u64,
-        })
-        .await
-        .map_err(|e| e.to_string())?;
-
-    Ok(RunNowResult {
-        run_id,
-        mode: match job.mode {
-            JobMode::AgenticRun => "agentic_run".to_string(),
-            JobMode::IdCheck => "id_check".to_string(),
-        },
-        result_summary,
-    })
-}
diff --git a/tauri-app/src/lib.rs b/tauri-app/src/lib.rs
index 1aa648d8..891c8b3c 100644
--- a/tauri-app/src/lib.rs
+++ b/tauri-app/src/lib.rs
@@ -29,7 +29,6 @@ use crate::commands::jobs::*;
 use crate::commands::logging::*;
 use crate::commands::memory::*;
 use crate::commands::ollama::*;
-use crate::commands::orchestration::*;
 use crate::commands::sensory::*;
 use crate::commands::skills::*;
 use crate::state::AppState;
@@ -39,10 +38,7 @@ use abigail_core::{validate_local_llm_url, AppConfig, GlobalConfig, SecretsVault
 use abigail_hive::{Hive, ModelRegistry};
 use abigail_memory::MemoryStore;
 use abigail_persistence::{EntityScope, PersistenceHandle};
-#[allow(deprecated)]
-use abigail_router::{
-    IdEgoRouter, OrchestrationScheduler, SubagentDefinition, SubagentManager, SubagentProvider,
-};
+use abigail_router::{IdEgoRouter, SubagentDefinition, SubagentManager, SubagentProvider};
 use abigail_runtime::{
     create_browser_skill, register_dynamic_api_skills, register_hive_management_skill,
     register_preloaded_skills, register_skill_factory, register_supported_native_skills,
@@ -792,8 +788,6 @@ fn try_run() -> Result<(), String> {
     ));
     startup.stage("memory store opened");
     let agentic_runtime = Arc::new(agentic_runtime::AgenticRuntime::new(&data_dir));
-    #[allow(deprecated)]
-    let orchestration_scheduler = Arc::new(OrchestrationScheduler::new(data_dir.clone()));
 
     // Open job queue database for async task management.
     let job_queue = {
@@ -836,7 +830,6 @@ fn try_run() -> Result<(), String> {
         active_agent_id: RwLock::new(active_agent_id),
         subagent_manager,
         agentic_runtime,
-        orchestration_scheduler,
         browser,
         http_client,
         ollama: Arc::new(tokio::sync::Mutex::new(None)),
@@ -867,11 +860,25 @@ fn try_run() -> Result<(), String> {
     };
     startup.stage("app state assembled");
 
-    let app = tauri::Builder::default()
+    let updater_enabled = std::env::var("ABIGAIL_ENABLE_UPDATER")
+        .map(|value| {
+            matches!(
+                value.trim().to_ascii_lowercase().as_str(),
+                "1" | "true" | "yes"
+            )
+        })
+        .unwrap_or(false);
+
+    let mut builder = tauri::Builder::default()
         .plugin(tauri_plugin_dialog::init())
-        .plugin(tauri_plugin_updater::Builder::new().build())
-        .plugin(tauri_plugin_process::init())
-        .setup(|app| {
+        .plugin(tauri_plugin_process::init());
+    if updater_enabled {
+        builder = builder.plugin(tauri_plugin_updater::Builder::new().build());
+    } else {
+        tracing::info!("Updater plugin disabled for stabilization build");
+    }
+
+    let app = builder.setup(|app| {
             let handle = app.handle();
             let state = handle.state::<AppState>();
             tracing::info!("Startup setup: entering Tauri setup hook");
@@ -1324,12 +1331,6 @@ fn try_run() -> Result<(), String> {
             cancel_agentic_run,
             list_agentic_runs,
             get_agentic_runtime_status,
-            get_orchestration_backend_status,
-            list_orchestration_jobs,
-            set_orchestration_job_enabled,
-            delete_orchestration_job,
-            run_orchestration_job_now,
-            list_orchestration_job_logs,
             list_subagents,
             delegate_to_subagent,
             get_governor_status,
diff --git a/tauri-app/src/ollama_manager.rs b/tauri-app/src/ollama_manager.rs
index 8d1d2056..066ee66e 100644
--- a/tauri-app/src/ollama_manager.rs
+++ b/tauri-app/src/ollama_manager.rs
@@ -79,6 +79,11 @@ pub enum OllamaLifecycleState {
     NotStarted,
     /// Ollama binary discovered, process starting.
     Starting,
+    /// Ollama is being downloaded and installed automatically.
+    InstallingOllama {
+        /// Install progress as a percentage (0.0–100.0).
+        progress_pct: f32,
+    },
     /// Ollama server is responding to health checks.
     Running,
     /// Model download in progress.
@@ -334,6 +339,7 @@ impl OllamaManager {
             file.flush()
                 .await
                 .map_err(|e| format!("Failed to flush installer file: {}", e))?;
+            drop(file);
 
             on_progress(OllamaInstallProgress {
                 step: "installing".to_string(),
diff --git a/tauri-app/src/state.rs b/tauri-app/src/state.rs
index ed0d5aa5..6a9f01c1 100644
--- a/tauri-app/src/state.rs
+++ b/tauri-app/src/state.rs
@@ -11,7 +11,7 @@ use abigail_hive::{Hive, ModelRegistry};
 use abigail_memory::MemoryStore;
 use abigail_queue::JobQueue;
 #[allow(deprecated)]
-use abigail_router::{ConstraintStore, IdEgoRouter, OrchestrationScheduler, SubagentManager};
+use abigail_router::{ConstraintStore, IdEgoRouter, SubagentManager};
 use abigail_skills::{InstructionRegistry, SkillExecutor, SkillRegistry};
 use abigail_streaming::StreamBroker;
 use std::sync::{Arc, Mutex, RwLock};
@@ -70,10 +70,6 @@ pub struct AppState {
     pub subagent_manager: RwLock<SubagentManager>,
     /// Agentic runtime service handling run lifecycle, persistence, and event bridging.
     pub agentic_runtime: Arc<AgenticRuntime>,
-    /// Orchestration scheduler for persisted jobs and run logs.
-    /// Deprecated: being replaced by JobQueue recurring jobs.
-    #[allow(deprecated)]
-    pub orchestration_scheduler: Arc<OrchestrationScheduler>,
     /// Browser automation capability (lazy-init, async-safe)
     pub browser:
         Arc<tokio::sync::RwLock<abigail_capabilities::sensory::browser::BrowserCapability>>,
diff --git a/tauri-app/tauri.conf.json b/tauri-app/tauri.conf.json
index eff655e5..93195502 100644
--- a/tauri-app/tauri.conf.json
+++ b/tauri-app/tauri.conf.json
@@ -61,16 +61,5 @@
     "externalBin": [],
     "copyright": "Copyright (c) 2025-2026 Jim Cupps",
     "category": "Developer"
-  },
-  "plugins": {
-    "updater": {
-      "pubkey": "",
-      "endpoints": [
-        "https://github.com/jbcupps/abigail/releases/latest/download/latest.json"
-      ],
-      "windows": {
-        "installMode": "passive"
-      }
-    }
   }
 }