refactor(ci): PR-based Claude review instead of batch extraction [skip-regression-check]

Restructure staging-ci to create the promotion PR first, then let
claude-review.yml trigger on the PR via pull_request event. Claude
posts findings as native PR review comments (no JSON extraction).

- claude-review.yml: trigger on pull_request with staging-promotion
  label, uses claude-code-action in native PR review mode, Sonnet
  tags comments with [SEVERITY:CONFIDENCE] for downstream parsing
- staging-ci.yml: new create-promotion-pr job runs in parallel with
  tests/e2e, gate waits for Claude review check on PR, parses
  review comments to create issues and evaluate blocking findings
- create-labels.sh: add staging-promotion label

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

.env.example

@@ -108,12 +108,20 @@ HEARTBEAT_NOTIFY_USER=default
 # Memory hygiene settings (automatic cleanup of stale workspace documents)
 # Runs on each heartbeat tick; identity files (IDENTITY.md, SOUL.md) are never deleted
 # MEMORY_HYGIENE_ENABLED=true
-# MEMORY_HYGIENE_RETENTION_DAYS=30     # delete daily/ docs older than this many days
-# MEMORY_HYGIENE_CADENCE_HOURS=12      # minimum hours between cleanup passes
+# MEMORY_HYGIENE_DAILY_RETENTION_DAYS=30         # delete daily/ docs older than this many days
+# MEMORY_HYGIENE_CONVERSATION_RETENTION_DAYS=7   # delete conversations/ docs older than this many days
+# MEMORY_HYGIENE_CADENCE_HOURS=12                # minimum hours between cleanup passes
 
 # Safety settings
 SAFETY_MAX_OUTPUT_LENGTH=100000
 SAFETY_INJECTION_CHECK_ENABLED=true
 
+# Restart Feature (Docker containers only)
+# Set IRONCLAW_IN_DOCKER=true in the container entrypoint to enable the restart feature.
+# Without this, the restart tool and /restart command will be disabled.
+# IRONCLAW_IN_DOCKER=false
+# IRONCLAW_RESTART_DELAY=5          # default wait before exit (seconds, range: 1-30)
+# IRONCLAW_MAX_FAILURES=10          # max consecutive failures before container exits
+
 # Logging
 RUST_LOG=ironclaw=debug,tower_http=debug

.github/scripts/create-labels.sh

@@ -64,6 +64,10 @@ create "scope: dependencies"  "90A4AE" "Dependency updates"
 
 echo "==> Creating workflow labels..."
 create "skip-regression-check" "9E9E9E" "Acknowledged: fix without regression test"
+create "staging-ci-review"     "D93F0B" "Auto-created by staging CI Claude Code review"
+create "skip-claude-gate"      "FBCA04" "Override: bypass Claude CRITICAL gate on staging CI"
+create "low-confidence"        "C5DEF5" "Claude review finding with <50 confidence"
+create "staging-promotion"     "0E8A16" "Auto-created staging→main promotion PR"
 
 echo "==> Creating contributor labels..."
 create "contributor: new"         "FFF9C4" "First-time contributor"

.github/workflows/claude-review.yml

@@ -0,0 +1,49 @@
+name: Claude Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+  id-token: write
+
+jobs:
+  review:
+    name: Claude Code Review
+    if: contains(github.event.pull_request.labels.*.name, 'staging-promotion')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Run Claude Code review
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          prompt: |
+            Review this PR for security vulnerabilities, bugs, and code quality issues.
+
+            Prefix EVERY review comment with a severity and confidence tag:
+            [SEVERITY:CONFIDENCE] where SEVERITY is CRITICAL/HIGH/MEDIUM/LOW
+            and CONFIDENCE is 0-100.
+
+            Example: [CRITICAL:92] This .unwrap() can panic in production when the config file is missing.
+
+            Severity guide:
+            - CRITICAL: security vulns, panics in prod (.unwrap/.expect), data exfiltration, race conditions
+            - HIGH: logic bugs, missing error handling, breaking API/schema changes
+            - MEDIUM: missing tests, unnecessary complexity, performance issues
+            - LOW: documentation gaps, naming suggestions
+
+            Confidence guide:
+            - 90-100: certain this is a real issue
+            - 70-89: very likely but needs human verification
+            - 50-69: possible issue, not fully sure of context
+            - 0-49: speculative, might be false positive
+
+            Only report real issues you're confident about. Be concise. No nitpicks.
+          claude_args: "--max-turns 5"

.github/workflows/code_style.yml

@@ -44,15 +44,32 @@ jobs:
     - name: Check lints
       run: cargo clippy --all --benches --tests --examples ${{ matrix.flags }} -- -D warnings
 
+  version-check:
+    name: Version Bump Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - name: Check version bumps for changed extensions
+        env:
+          PR_LABELS: ${{ join(github.event.pull_request.labels.*.name, ',') }}
+        run: ./scripts/check-version-bumps.sh
+
   # Roll-up job for branch protection
   code-style:
     name: Code Style (fmt + clippy)
     runs-on: ubuntu-latest
     if: always()
-    needs: [format, clippy]
+    needs: [format, clippy, version-check]
     steps:
       - run: |
           if [[ "${{ needs.format.result }}" != "success" || "${{ needs.clippy.result }}" != "success" ]]; then
             echo "One or more jobs failed"
             exit 1
           fi
+          if [[ "${{ needs.version-check.result }}" != "success" ]]; then
+            echo "Version bump check did not succeed (status: ${{ needs.version-check.result }})"
+            exit 1
+          fi

.github/workflows/coverage.yml

@@ -1,7 +1,9 @@
 name: Code Coverage
 on:
   push:
-    branches: [main]
+    branches: [main]               # Runs when staging merges to main
+  workflow_call:                    # Optional: staging-ci can invoke
+  workflow_dispatch:                # Manual trigger
 
 permissions:
   id-token: write
@@ -44,6 +46,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: llvm-tools-preview
+          targets: wasm32-wasip2
 
       - uses: Swatinem/rust-cache@v2
         with:
@@ -52,11 +55,21 @@ jobs:
       - name: Install cargo-llvm-cov
         uses: taiki-e/install-action@cargo-llvm-cov
 
+      - name: Install cargo-component
+        run: |
+          if ! command -v cargo-component >/dev/null 2>&1; then
+            cargo install cargo-component --locked
+          fi
+
+      - name: Build WASM channels (for integration tests)
+        run: ./scripts/build-wasm-extensions.sh --channels
+
       - name: Run database migrations
         if: matrix.has_postgres
         run: |
           set -euo pipefail
-          for f in migrations/V*.sql; do
+          readarray -t migration_files < <(printf '%s\n' migrations/V*.sql | sort -V)
+          for f in "${migration_files[@]}"; do
             echo "Applying $f..."
             psql -v ON_ERROR_STOP=1 -f "$f"
           done
@@ -92,6 +105,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: llvm-tools-preview
+          targets: wasm32-wasip2
 
       - uses: Swatinem/rust-cache@v2
         with:
@@ -100,16 +114,24 @@ jobs:
       - name: Install cargo-llvm-cov
         uses: taiki-e/install-action@cargo-llvm-cov
 
+      - name: Install cargo-component
+        run: |
+          if ! command -v cargo-component >/dev/null 2>&1; then
+            cargo install cargo-component --locked
+          fi
+
+      - name: Build WASM channels
+        run: ./scripts/build-wasm-extensions.sh --channels
+
       - name: Set up coverage instrumentation
         run: |
-          source <(cargo llvm-cov show-env --export-prefix)
-          # Persist env vars for subsequent steps
-          echo "RUSTFLAGS=${RUSTFLAGS}" >> "$GITHUB_ENV"
-          echo "LLVM_PROFILE_FILE=${LLVM_PROFILE_FILE}" >> "$GITHUB_ENV"
-          echo "CARGO_LLVM_COV=1" >> "$GITHUB_ENV"
-          echo "CARGO_LLVM_COV_SHOW_ENV=1" >> "$GITHUB_ENV"
-          echo "CARGO_LLVM_COV_TARGET_DIR=${CARGO_LLVM_COV_TARGET_DIR}" >> "$GITHUB_ENV"
-          cargo llvm-cov clean --workspace
+          # show-env outputs shell-quoted values (KEY='value') but GITHUB_ENV
+          # expects unquoted KEY=value. Strip only the wrapping single quotes
+          # from KEY='value' lines without altering any internal characters.
+          cargo llvm-cov show-env | sed -E "s/^([A-Za-z_][A-Za-z0-9_]*)='(.*)'$/\1=\2/" >> "$GITHUB_ENV"
+
+      - name: Clean coverage workspace
+        run: cargo llvm-cov clean --workspace
 
       - name: Build instrumented binary
         run: cargo build --no-default-features --features libsql

.github/workflows/e2e.yml

@@ -2,15 +2,13 @@ name: E2E Tests
 on:
   schedule:
     - cron: "0 6 * * 1"  # Weekly Monday 6 AM UTC
+  workflow_call:                    # Called by staging-ci.yml
   workflow_dispatch:
-  pull_request:
-    paths:
-      - "src/channels/web/**"
-      - "tests/e2e/**"
 
 jobs:
-  e2e:
-    name: Browser E2E
+  # ── Step 1: compile once ──────────────────────────────────────────────────
+  build:
+    name: Build ironclaw (libsql)
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
@@ -25,9 +23,44 @@ jobs:
             ~/.cargo/registry
           key: e2e-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}
 
-      - name: Build ironclaw (libsql)
+      - name: Build
         run: cargo build --no-default-features --features libsql
 
+      - name: Upload binary
+        uses: actions/upload-artifact@v4
+        with:
+          name: ironclaw-e2e-binary
+          path: target/debug/ironclaw
+          retention-days: 1
+
+  # ── Step 2: run test slices in parallel ───────────────────────────────────
+  test:
+    name: E2E (${{ matrix.group }})
+    needs: build
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - group: core
+            files: "tests/e2e/scenarios/test_connection.py tests/e2e/scenarios/test_chat.py tests/e2e/scenarios/test_sse_reconnect.py tests/e2e/scenarios/test_html_injection.py"
+          - group: features
+            files: "tests/e2e/scenarios/test_skills.py tests/e2e/scenarios/test_tool_approval.py"
+          - group: extensions
+            files: "tests/e2e/scenarios/test_extensions.py"
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Download binary
+        uses: actions/download-artifact@v4
+        with:
+          name: ironclaw-e2e-binary
+          path: target/debug/
+
+      - name: Make binary executable
+        run: chmod +x target/debug/ironclaw
+
       - uses: actions/setup-python@v5
         with:
           python-version: "3.12"
@@ -38,13 +71,26 @@ jobs:
           pip install -e .
           playwright install --with-deps chromium
 
-      - name: Run E2E tests
-        run: pytest tests/e2e/ -v -x --timeout=120
+      - name: Run E2E tests (${{ matrix.group }})
+        run: pytest ${{ matrix.files }} -v --timeout=120
 
       - name: Upload screenshots on failure
         if: failure()
         uses: actions/upload-artifact@v4
         with:
-          name: e2e-screenshots
+          name: e2e-screenshots-${{ matrix.group }}
           path: tests/e2e/screenshots/
           if-no-files-found: ignore
+
+  # ── Roll-up for branch protection ────────────────────────────────────────
+  e2e:
+    name: E2E Tests
+    runs-on: ubuntu-latest
+    if: always()
+    needs: [test]
+    steps:
+      - run: |
+          if [[ "${{ needs.test.result }}" != "success" ]]; then
+            echo "One or more E2E jobs failed"
+            exit 1
+          fi

.github/workflows/staging-ci.yml

@@ -0,0 +1,414 @@
+name: Staging CI (Batched)
+
+on:
+  schedule:
+    - cron: "*/30 * * * *"         # Every 30 minutes
+  workflow_dispatch:
+    inputs:
+      force:
+        description: "Force run even if no new commits"
+        type: boolean
+        default: false
+      skip_claude_gate:
+        description: "Skip Claude review gate (bypass blocking findings)"
+        type: boolean
+        default: false
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: staging-ci
+  cancel-in-progress: false        # Let running suites finish
+
+jobs:
+  # ── Check for new commits ──────────────────────────────────────
+  check-changes:
+    name: Check for new commits
+    runs-on: ubuntu-latest
+    outputs:
+      has_changes: ${{ steps.check.outputs.has_changes }}
+      current_head: ${{ steps.check.outputs.current_head }}
+      diff_range: ${{ steps.check.outputs.diff_range }}
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: staging
+          fetch-depth: 0
+
+      - name: Check for changes since last tested
+        id: check
+        run: |
+          CURRENT_HEAD=$(git rev-parse HEAD)
+          echo "current_head=${CURRENT_HEAD}" >> "$GITHUB_OUTPUT"
+
+          if git rev-parse staging-tested >/dev/null 2>&1; then
+            LAST_TESTED=$(git rev-parse staging-tested)
+          else
+            LAST_TESTED=""
+          fi
+
+          DIFF_RANGE=""
+          if [ -n "$LAST_TESTED" ] && [ "$LAST_TESTED" = "$CURRENT_HEAD" ]; then
+            echo "No new commits since last tested (${CURRENT_HEAD})"
+            HAS_CHANGES=false
+          else
+            HAS_CHANGES=true
+            if [ -n "$LAST_TESTED" ]; then
+              COMMIT_COUNT=$(git rev-list --count "${LAST_TESTED}..HEAD")
+              echo "Found ${COMMIT_COUNT} new commit(s) since last tested"
+              DIFF_RANGE="${LAST_TESTED}..${CURRENT_HEAD}"
+            else
+              git fetch origin main
+              MERGE_BASE=$(git merge-base origin/main HEAD)
+              echo "First run -- reviewing from merge-base ${MERGE_BASE}"
+              DIFF_RANGE="${MERGE_BASE}..${CURRENT_HEAD}"
+            fi
+          fi
+
+          # Force override from workflow_dispatch
+          if [ "${{ inputs.force }}" = "true" ]; then
+            echo "Force run requested"
+            HAS_CHANGES=true
+            if [ -z "$DIFF_RANGE" ]; then
+              DIFF_RANGE="${CURRENT_HEAD}..${CURRENT_HEAD}"
+            fi
+          fi
+
+          echo "has_changes=${HAS_CHANGES}" >> "$GITHUB_OUTPUT"
+          echo "diff_range=${DIFF_RANGE}" >> "$GITHUB_OUTPUT"
+
+  # ── Run full test suite ──────────────────────────────────────────
+  tests:
+    name: Test Suite
+    needs: check-changes
+    if: needs.check-changes.outputs.has_changes == 'true'
+    uses: ./.github/workflows/test.yml
+
+  # ── Run E2E browser tests ────────────────────────────────────────
+  e2e:
+    name: E2E Browser Tests
+    needs: check-changes
+    if: needs.check-changes.outputs.has_changes == 'true'
+    uses: ./.github/workflows/e2e.yml
+
+  # ── Create promotion PR (triggers claude-review.yml on the PR) ──
+  create-promotion-pr:
+    name: Create Promotion PR
+    needs: check-changes
+    if: needs.check-changes.outputs.has_changes == 'true'
+    runs-on: ubuntu-latest
+    outputs:
+      pr_number: ${{ steps.create-pr.outputs.pr_number }}
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: staging
+          fetch-depth: 0
+
+      - name: Generate GitHub App token
+        id: app-token
+        uses: actions/create-github-app-token@v2
+        with:
+          app-id: ${{ secrets.GH_RELEASES_MANAGER_APP_ID }}
+          private-key: ${{ secrets.GH_RELEASES_MANAGER_APP_PRIVATE_KEY }}
+
+      - name: Check if staging is ahead of main
+        id: ahead-check
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+        run: |
+          git fetch origin main
+          AHEAD=$(git rev-list --count origin/main..origin/staging)
+          echo "commits_ahead=${AHEAD}" >> "$GITHUB_OUTPUT"
+          if [ "$AHEAD" -eq 0 ]; then
+            echo "Staging is not ahead of main. Nothing to promote."
+          else
+            echo "Staging is ${AHEAD} commits ahead of main."
+          fi
+
+      - name: Close stale promotion PRs
+        if: steps.ahead-check.outputs.commits_ahead != '0'
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+        run: |
+          # Close any existing staging->main PRs to avoid duplicates
+          EXISTING=$(gh pr list --base main --head staging --state open --json number -q '.[].number')
+          for PR in $EXISTING; do
+            echo "Closing stale promotion PR #${PR}"
+            gh pr close "$PR" --comment "Superseded by new staging-ci batch run"
+          done
+
+      - name: Create promotion PR
+        id: create-pr
+        if: steps.ahead-check.outputs.commits_ahead != '0'
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+        run: |
+          RANGE="${{ needs.check-changes.outputs.diff_range }}"
+          TIMESTAMP=$(date -u +"%Y-%m-%d %H:%M UTC")
+
+          PR_URL=$(gh pr create \
+            --base main \
+            --head staging \
+            --title "chore: promote staging to main (${TIMESTAMP})" \
+            --body "## Auto-promotion from staging CI
+
+          **Batch range:** \`${RANGE}\`
+          **Triggered by:** Staging CI batch at ${TIMESTAMP}
+
+          Waiting for gates:
+          - Tests: pending
+          - E2E: pending
+          - Claude Code review: pending (will post comments on this PR)
+
+          ---
+          *Auto-created by staging-ci workflow*" \
+            --label "staging-promotion")
+
+          PR_NUM=$(echo "$PR_URL" | grep -oE '[0-9]+$')
+          echo "pr_number=${PR_NUM}" >> "$GITHUB_OUTPUT"
+          echo "Created promotion PR #${PR_NUM}"
+
+  # ── Gate: wait for all checks, process findings, merge or block ──
+  gate:
+    name: Staging Gate
+    needs: [check-changes, tests, e2e, create-promotion-pr]
+    if: >
+      always() &&
+      needs.check-changes.outputs.has_changes == 'true' &&
+      needs.tests.result == 'success' &&
+      needs.e2e.result == 'success' &&
+      needs.create-promotion-pr.result == 'success'
+    runs-on: ubuntu-latest
+    outputs:
+      gate_passed: ${{ steps.evaluate.outputs.passed }}
+    steps:
+      - name: Generate GitHub App token
+        id: app-token
+        uses: actions/create-github-app-token@v2
+        with:
+          app-id: ${{ secrets.GH_RELEASES_MANAGER_APP_ID }}
+          private-key: ${{ secrets.GH_RELEASES_MANAGER_APP_PRIVATE_KEY }}
+
+      - name: Wait for Claude review on PR
+        id: wait-review
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+          PR_NUMBER: ${{ needs.create-promotion-pr.outputs.pr_number }}
+        run: |
+          if [ -z "$PR_NUMBER" ]; then
+            echo "No PR number — skipping Claude review wait"
+            echo "review_done=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          echo "Waiting for Claude Code Review check on PR #${PR_NUMBER}..."
+          TIMEOUT=600  # 10 minutes
+          ELAPSED=0
+          INTERVAL=15
+
+          while [ "$ELAPSED" -lt "$TIMEOUT" ]; do
+            # Check if the claude-review check has completed
+            STATUS=$(gh pr checks "$PR_NUMBER" --json name,state \
+              --jq '.[] | select(.name == "Claude Code Review") | .state' 2>/dev/null || echo "PENDING")
+
+            if [ "$STATUS" = "SUCCESS" ] || [ "$STATUS" = "FAILURE" ]; then
+              echo "Claude review completed with status: ${STATUS}"
+              echo "review_status=${STATUS}" >> "$GITHUB_OUTPUT"
+              echo "review_done=true" >> "$GITHUB_OUTPUT"
+              break
+            fi
+
+            echo "Claude review status: ${STATUS} (${ELAPSED}s elapsed)"
+            sleep "$INTERVAL"
+            ELAPSED=$((ELAPSED + INTERVAL))
+          done
+
+          if [ "$ELAPSED" -ge "$TIMEOUT" ]; then
+            echo "::warning::Claude review timed out after ${TIMEOUT}s"
+            echo "review_status=TIMEOUT" >> "$GITHUB_OUTPUT"
+            echo "review_done=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Process Claude review comments and create issues
+        id: process-findings
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+          PR_NUMBER: ${{ needs.create-promotion-pr.outputs.pr_number }}
+          REPO: ${{ github.repository }}
+        run: |
+          HAS_BLOCKING=false
+          ISSUES_CREATED=0
+
+          if [ -z "$PR_NUMBER" ]; then
+            echo "No PR — skipping finding processing"
+            echo "has_blocking=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          # Get all review comments from Claude on this PR
+          COMMENTS=$(gh api "repos/${REPO}/pulls/${PR_NUMBER}/comments" \
+            --jq '[.[] | select(.user.login == "claude[bot]" or .user.type == "Bot") | {body: .body, path: .path, line: .line, url: .html_url}]' 2>/dev/null || echo "[]")
+
+          COMMENT_COUNT=$(echo "$COMMENTS" | jq 'length')
+          echo "Found ${COMMENT_COUNT} Claude review comment(s)"
+
+          # Also check PR review body comments
+          REVIEW_COMMENTS=$(gh api "repos/${REPO}/pulls/${PR_NUMBER}/reviews" \
+            --jq '[.[] | select(.user.login == "claude[bot]" or .user.type == "Bot") | {body: .body, url: .html_url}]' 2>/dev/null || echo "[]")
+
+          # Combine all comments
+          ALL_COMMENTS=$(echo "$COMMENTS $REVIEW_COMMENTS" | jq -s 'add // []')
+
+          # Parse [SEVERITY:CONFIDENCE] tags from each comment
+          echo "$ALL_COMMENTS" | jq -c '.[]' | while read -r comment; do
+            BODY=$(echo "$comment" | jq -r '.body // ""')
+            URL=$(echo "$comment" | jq -r '.url // ""')
+            FILE=$(echo "$comment" | jq -r '.path // "unknown"')
+            LINE=$(echo "$comment" | jq -r '.line // 0')
+
+            # Extract [SEVERITY:CONFIDENCE] tag
+            TAG=$(echo "$BODY" | grep -oE '\[(CRITICAL|HIGH|MEDIUM|LOW):[0-9]+\]' | head -1 || true)
+            if [ -z "$TAG" ]; then
+              continue
+            fi
+
+            SEVERITY=$(echo "$TAG" | sed 's/\[\(.*\):\(.*\)\]/\1/')
+            CONFIDENCE=$(echo "$TAG" | sed 's/\[\(.*\):\(.*\)\]/\2/')
+            # Strip tag from body for issue description
+            DESC=$(echo "$BODY" | sed "s/\[${SEVERITY}:${CONFIDENCE}\] *//" | head -5)
+
+            echo "Found: [${SEVERITY}:${CONFIDENCE}] in ${FILE}:${LINE}"
+
+            # Determine if this should create an issue (confidence matrix)
+            CREATE_ISSUE=false
+            case "$SEVERITY" in
+              CRITICAL) CREATE_ISSUE=true ;;  # Always
+              HIGH)     [ "$CONFIDENCE" -ge 50 ] && CREATE_ISSUE=true ;;
+              MEDIUM)   [ "$CONFIDENCE" -ge 80 ] && CREATE_ISSUE=true ;;
+              LOW)      [ "$CONFIDENCE" -ge 80 ] && CREATE_ISSUE=true ;;
+            esac
+
+            # Check if blocking (CRITICAL ≥80)
+            if [ "$SEVERITY" = "CRITICAL" ] && [ "$CONFIDENCE" -ge 80 ]; then
+              HAS_BLOCKING=true
+            fi
+
+            if [ "$CREATE_ISSUE" = "true" ]; then
+              # Determine labels
+              case "$SEVERITY" in
+                CRITICAL) LABELS="bug,risk: high,staging-ci-review" ;;
+                HIGH)     LABELS="bug,risk: medium,staging-ci-review" ;;
+                MEDIUM)   LABELS="risk: medium,staging-ci-review" ;;
+                LOW)      LABELS="risk: low,staging-ci-review" ;;
+              esac
+              if [ "$SEVERITY" = "CRITICAL" ] && [ "$CONFIDENCE" -lt 50 ]; then
+                LABELS="${LABELS},low-confidence"
+              fi
+
+              TITLE=$(echo "$DESC" | head -1 | cut -c1-80)
+              {
+                echo "## ${SEVERITY} Issue Found by Staging CI Review"
+                echo ""
+                echo "**Severity:** ${SEVERITY}"
+                echo "**Confidence:** ${CONFIDENCE}/100"
+                echo "**File:** \`${FILE}:${LINE}\`"
+                echo "**PR comment:** ${URL}"
+                echo ""
+                echo "### Description"
+                echo "$DESC"
+                echo ""
+                echo "---"
+                echo "*Auto-created by staging-ci Claude Code review*"
+              } > /tmp/issue-body.md
+
+              gh issue create \
+                --title "[${SEVERITY}] ${TITLE}" \
+                --body-file /tmp/issue-body.md \
+                --label "${LABELS}" || echo "::warning::Failed to create issue for ${SEVERITY} finding"
+              ISSUES_CREATED=$((ISSUES_CREATED + 1))
+            fi
+          done
+
+          echo "Created ${ISSUES_CREATED} issues"
+          echo "has_blocking=${HAS_BLOCKING}" >> "$GITHUB_OUTPUT"
+
+      - name: Evaluate gate
+        id: evaluate
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+          PR_NUMBER: ${{ needs.create-promotion-pr.outputs.pr_number }}
+        run: |
+          HAS_BLOCKING="${{ steps.process-findings.outputs.has_blocking }}"
+          SKIP_INPUT="${{ inputs.skip_claude_gate }}"
+
+          if [ "$HAS_BLOCKING" = "true" ]; then
+            echo "::warning::Claude review found blocking issues (CRITICAL ≥80 confidence)"
+            if [ "$SKIP_INPUT" = "true" ]; then
+              echo "::warning::Gate overridden by skip_claude_gate workflow input"
+              echo "passed=true" >> "$GITHUB_OUTPUT"
+            else
+              echo "::error::Blocking promotion due to CRITICAL findings (≥80 confidence)"
+              echo "::error::PR #${PR_NUMBER} left open with review comments"
+              echo "passed=false" >> "$GITHUB_OUTPUT"
+              exit 1
+            fi
+          else
+            echo "No blocking findings. Gate passed."
+            echo "passed=true" >> "$GITHUB_OUTPUT"
+          fi
+
+          # Merge the promotion PR
+          if [ -n "$PR_NUMBER" ]; then
+            echo "Merging promotion PR #${PR_NUMBER}"
+            gh pr merge "$PR_NUMBER" --merge --auto || echo "::warning::Auto-merge failed for PR #${PR_NUMBER}"
+          fi
+
+  # ── Update tested tag on success ─────────────────────────────────
+  update-tag:
+    name: Update staging-tested tag
+    needs: [check-changes, gate]
+    if: >
+      always() &&
+      needs.check-changes.outputs.has_changes == 'true' &&
+      needs.gate.result == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          ref: staging
+          fetch-depth: 1
+
+      - name: Update staging-tested tag
+        run: |
+          git tag -f staging-tested "${{ needs.check-changes.outputs.current_head }}"
+          git push origin staging-tested --force
+          echo "Updated staging-tested tag to ${{ needs.check-changes.outputs.current_head }}"
+
+  # ── Report ───────────────────────────────────────────────────────
+  report:
+    name: Staging CI Summary
+    needs: [check-changes, tests, e2e, create-promotion-pr, gate, update-tag]
+    if: always() && needs.check-changes.outputs.has_changes == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Summary
+        run: |
+          echo "## Staging CI Batch Results" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Check | Result |" >> "$GITHUB_STEP_SUMMARY"
+          echo "|-------|--------|" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Tests | ${{ needs.tests.result }} |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| E2E | ${{ needs.e2e.result }} |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Promotion PR | ${{ needs.create-promotion-pr.result }} |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Gate | ${{ needs.gate.result }} |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Tag Updated | ${{ needs.update-tag.result }} |" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "Range: ${{ needs.check-changes.outputs.diff_range }}" >> "$GITHUB_STEP_SUMMARY"
+          PR_NUM="${{ needs.create-promotion-pr.outputs.pr_number }}"
+          if [ -n "$PR_NUM" ]; then
+            echo "Promotion PR: #${PR_NUM}" >> "$GITHUB_STEP_SUMMARY"
+          fi

.github/workflows/test.yml

@@ -1,9 +1,7 @@
 name: Run Tests
 on:
-  pull_request:
-  push:
-    branches:
-      - main
+  workflow_call:                    # Called by staging-ci.yml
+  workflow_dispatch:                # Manual escape hatch
 
 jobs:
   tests:
@@ -26,9 +24,14 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         with:
           profile: minimal
+          targets: wasm32-wasip2
       - uses: Swatinem/rust-cache@v2
         with:
           key: ${{ matrix.name }}
+      - name: Install cargo-component
+        run: cargo install cargo-component --locked || true
+      - name: Build WASM channels (for integration tests)
+        run: ./scripts/build-wasm-extensions.sh --channels
       - name: Run Tests
         run: cargo test ${{ matrix.flags }} -- --nocapture
 
@@ -46,6 +49,27 @@ jobs:
       - name: Run Telegram Channel Tests
         run: cargo test --manifest-path channels-src/telegram/Cargo.toml -- --nocapture
 
+  wasm-wit-compat:
+    name: WASM WIT Compatibility
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          profile: minimal
+          targets: wasm32-wasip2
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: wasm-extensions
+      - name: Install cargo-component
+        run: cargo install cargo-component --locked || true
+      - name: Build all WASM extensions against current WIT
+        run: ./scripts/build-wasm-extensions.sh
+      - name: Instantiation test (host linker compatibility)
+        run: cargo test --all-features wit_compat -- --nocapture
+
   docker-build:
     name: Docker Build
     runs-on: ubuntu-latest
@@ -60,10 +84,10 @@ jobs:
     name: Run Tests
     runs-on: ubuntu-latest
     if: always()
-    needs: [tests, telegram-tests, docker-build]
+    needs: [tests, telegram-tests, wasm-wit-compat, docker-build]
     steps:
       - run: |
-          if [[ "${{ needs.tests.result }}" != "success" || "${{ needs.telegram-tests.result }}" != "success" || "${{ needs.docker-build.result }}" != "success" ]]; then
+          if [[ "${{ needs.tests.result }}" != "success" || "${{ needs.telegram-tests.result }}" != "success" || "${{ needs.wasm-wit-compat.result }}" != "success" || "${{ needs.docker-build.result }}" != "success" ]]; then
             echo "One or more jobs failed"
             exit 1
           fi

.gitignore

@@ -16,6 +16,9 @@ target/
 # Benchmark results (local runs, not committed)
 bench-results/
 
+# Coverage reports (local runs, not committed)
+/coverage/
+
 # WASM build artifacts (loaded from disk, not bundled)
 *.wasm
 

CHANGELOG.md

@@ -7,6 +7,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.16.1](https://github.com/nearai/ironclaw/compare/v0.16.0...v0.16.1) - 2026-03-06
+
+### Fixed
+
+- revert WASM artifact SHA256 checksums to null ([#627](https://github.com/nearai/ironclaw/pull/627))
+
+## [0.16.0](https://github.com/nearai/ironclaw/compare/v0.15.0...v0.16.0) - 2026-03-06
+
+### Added
+
+- *(e2e)* extensions tab tests, CI parallelization, and 3 production bug fixes ([#584](https://github.com/nearai/ironclaw/pull/584))
+- WASM extension versioning with WIT compat checks ([#592](https://github.com/nearai/ironclaw/pull/592))
+- Add HMAC-SHA256 webhook signature validation for Slack ([#588](https://github.com/nearai/ironclaw/pull/588))
+- restart ([#531](https://github.com/nearai/ironclaw/pull/531))
+- merge http/web_fetch tools, add tool output stash for large responses ([#578](https://github.com/nearai/ironclaw/pull/578))
+- integrate 13-dimension complexity scorer into smart routing ([#529](https://github.com/nearai/ironclaw/pull/529))
+
+### Fixed
+
+- *(llm)* fix reasoning model response parsing bugs ([#564](https://github.com/nearai/ironclaw/pull/564)) ([#580](https://github.com/nearai/ironclaw/pull/580))
+- *(ci)* fix three coverage workflow failures ([#597](https://github.com/nearai/ironclaw/pull/597))
+- Telegram channel accepts group messages from all users if owner_… ([#590](https://github.com/nearai/ironclaw/pull/590))
+- *(ci)* anchor coverage/ gitignore rule to repo root ([#591](https://github.com/nearai/ironclaw/pull/591))
+- *(security)* use OsRng for all security-critical key and token generation ([#519](https://github.com/nearai/ironclaw/pull/519))
+- prevent concurrent memory hygiene passes and Windows file lock errors ([#535](https://github.com/nearai/ironclaw/pull/535))
+- sort tool_definitions() for deterministic LLM tool ordering ([#582](https://github.com/nearai/ironclaw/pull/582))
+- *(ci)* persist all cargo-llvm-cov env vars for E2E coverage ([#559](https://github.com/nearai/ironclaw/pull/559))
+
+### Other
+
+- *(llm)* complete response cache — set_model invalidation, stats logging, sync mutex ([#290](https://github.com/nearai/ironclaw/pull/290))
+- add 29 E2E trace tests for issues #571-575 ([#593](https://github.com/nearai/ironclaw/pull/593))
+- add 26 tests for multi-thread safety, db CRUD, concurrency, errors ([#442](https://github.com/nearai/ironclaw/pull/442))
+- update WASM artifact SHA256 checksums [skip ci] ([#560](https://github.com/nearai/ironclaw/pull/560))
+- add WIT compatibility tests for WASM extensions ([#586](https://github.com/nearai/ironclaw/pull/586))
+- Trajectory benchmarks and e2e trace test rig ([#553](https://github.com/nearai/ironclaw/pull/553))
+
 ## [0.15.0](https://github.com/nearai/ironclaw/compare/v0.14.0...v0.15.0) - 2026-03-04
 
 ### Added

Cargo.lock

@@ -2828,7 +2828,7 @@ dependencies = [
 
 [[package]]
 name = "ironclaw"
-version = "0.15.0"
+version = "0.16.1"
 dependencies = [
  "aes-gcm",
  "aho-corasick",
@@ -2853,6 +2853,7 @@ dependencies = [
  "futures",
  "hex",
  "hkdf",
+ "hmac",
  "html-to-markdown-rs",
  "http-body-util",
  "hyper 1.8.1",
@@ -2879,6 +2880,7 @@ dependencies = [
  "secrecy",
  "secret-service",
  "security-framework",
+ "semver",
  "serde",
  "serde_json",
  "serde_yml",
@@ -2900,6 +2902,7 @@ dependencies = [
  "tower-http 0.6.8",
  "tracing",
  "tracing-subscriber",
+ "tracing-test",
  "url",
  "urlencoding",
  "uuid",
@@ -6227,6 +6230,27 @@ dependencies = [
  "tracing-serde",
 ]
 
+[[package]]
+name = "tracing-test"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19a4c448db514d4f24c5ddb9f73f2ee71bfb24c526cf0c570ba142d1119e0051"
+dependencies = [
+ "tracing-core",
+ "tracing-subscriber",
+ "tracing-test-macro",
+]
+
+[[package]]
+name = "tracing-test-macro"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad06847b7afb65c7866a36664b75c40b895e318cea4f71299f013fb22965329d"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"

Cargo.toml

@@ -18,7 +18,7 @@ exclude = [
 
 [package]
 name = "ironclaw"
-version = "0.15.0"
+version = "0.16.1"
 edition = "2024"
 rust-version = "1.92"
 description = "Secure personal AI assistant that protects your data and expands its capabilities on the fly"
@@ -106,6 +106,9 @@ serde_yml = "0.0.12"
 dirs = "6"
 fs4 = "0.6"
 
+# Semantic versioning
+semver = "1"
+
 # Secrecy for sensitive values
 secrecy = { version = "0.10", features = ["serde"] }
 
@@ -128,6 +131,7 @@ wasmparser = "0.220"  # WASM binary parsing for validation
 # Cryptography for secrets management
 aes-gcm = "0.10"
 hkdf = "0.12"
+hmac = "0.12"
 sha2 = "0.10"
 blake3 = "1"
 rand = "0.8"
@@ -170,6 +174,7 @@ zbus = "4"
 
 [dev-dependencies]
 tokio-test = "0.4"
+tracing-test = "0.2"
 tokio-tungstenite = "0.26"
 testcontainers-modules = { version = "0.11", features = ["postgres"] }
 pretty_assertions = "1"

channels-src/discord/discord.capabilities.json

@@ -1,4 +1,6 @@
 {
+  "version": "0.1.0",
+  "wit_version": "0.2.0",
   "type": "channel",
   "name": "discord",
   "description": "Discord Gateway/Webhook channel for handling slash commands, buttons, and messages",

channels-src/slack/slack.capabilities.json

@@ -1,4 +1,6 @@
 {
+  "version": "0.1.0",
+  "wit_version": "0.2.0",
   "type": "channel",
   "name": "slack",
   "description": "Slack Events API channel for receiving and responding to Slack messages",
@@ -44,6 +46,9 @@
       "emit_rate_limit": {
         "messages_per_minute": 100,
         "messages_per_hour": 5000
+      },
+      "webhook": {
+        "hmac_secret_name": "slack_signing_secret"
       }
     }
   },

channels-src/telegram/src/lib.rs

@@ -1032,11 +1032,14 @@ fn handle_message(message: TelegramMessage) {
                 return;
             }
         }
-    } else if is_private {
-        // No owner_id: apply dm_policy for private chats
+    } else {
+        // No owner_id: apply authorization based on dm_policy and allow_from
+        // This applies to both private and group chats when owner_id is null
         let dm_policy =
             channel_host::workspace_read(DM_POLICY_PATH).unwrap_or_else(|| "pairing".to_string());
 
+        // For private chats with non-open policy, check allowlist
+        // For group chats with non-open policy, also check allowlist
         if dm_policy != "open" {
             // Build effective allow list: config allow_from + pairing store
             let mut allowed: Vec<String> = channel_host::workspace_read(ALLOW_FROM_PATH)
@@ -1054,8 +1057,8 @@ fn handle_message(message: TelegramMessage) {
                 || username_opt.map_or(false, |u| allowed.contains(&u.to_string()));
 
             if !is_allowed {
-                if dm_policy == "pairing" {
-                    // Upsert pairing request and send reply
+                if is_private && dm_policy == "pairing" {
+                    // Upsert pairing request and send reply (only for private chats)
                     let meta = serde_json::json!({
                         "chat_id": message.chat.id,
                         "user_id": from.id,
@@ -1083,6 +1086,15 @@ fn handle_message(message: TelegramMessage) {
                             );
                         }
                     }
+                } else if !is_private {
+                    // For group chats with non-open dm_policy, just log and drop
+                    channel_host::log(
+                        channel_host::LogLevel::Debug,
+                        &format!(
+                            "Dropping message from unauthorized user {} in group chat",
+                            from.id
+                        ),
+                    );
                 }
                 return;
             }

channels-src/telegram/telegram.capabilities.json

@@ -1,4 +1,6 @@
 {
+  "version": "0.1.0",
+  "wit_version": "0.2.0",
   "type": "channel",
   "name": "telegram",
   "description": "Telegram Bot API channel for receiving and responding to Telegram messages",

channels-src/whatsapp/whatsapp.capabilities.json

@@ -1,4 +1,6 @@
 {
+  "version": "0.1.0",
+  "wit_version": "0.2.0",
   "type": "channel",
   "name": "whatsapp",
   "description": "WhatsApp Cloud API channel for receiving and responding to WhatsApp messages",

deploy/env.example

@@ -24,6 +24,15 @@ GATEWAY_HOST=0.0.0.0
 GATEWAY_PORT=3000
 GATEWAY_AUTH_TOKEN=CHANGE_ME
 
+# Restart Feature (Docker containers only)
+# IMPORTANT: Set this in the container entrypoint or docker-compose to enable restart.
+# The Docker entrypoint loop monitors exit codes:
+#   - Exit code 0 = clean restart: reset failure counter, wait IRONCLAW_RESTART_DELAY, restart
+#   - Exit code ≠ 0 = failure: increment counter, exit after IRONCLAW_MAX_FAILURES
+IRONCLAW_IN_DOCKER=false
+IRONCLAW_RESTART_DELAY=5          # seconds to wait before restarting (range: 1-30)
+IRONCLAW_MAX_FAILURES=10          # max consecutive failures before container exits
+
 # Disabled for initial deploy
 SANDBOX_ENABLED=false
 HEARTBEAT_ENABLED=false

docs/smart-routing-spec.md

@@ -0,0 +1,195 @@
+# Smart Model Routing for IronClaw
+
+**Status:** Implemented
+**Author:** Microwave
+**Date:** 2026-02-19
+
+## What
+
+Automatic model selection based on request complexity. The router analyzes each user message and selects an appropriate model tier (flash/standard/pro/frontier), then maps that tier to a configured model.
+
+## Why
+
+1. **Cost optimization** — Simple requests ("hi", "what time is it") don't need expensive models
+2. **User experience** — Simple requests return faster with lightweight models
+3. **NEAR AI native** — Default backend uses NEAR AI inference where costs vary by model
+4. **Zero-config value** — Users benefit immediately without configuration
+5. **Not just power users** — Everyone gets smart defaults, power users can override
+
+## How
+
+### Architecture
+
+```
+User Message
+     │
+     ▼
+┌──────────────────┐
+│ Pattern Overrides │  ← Fast-path for obvious cases (greetings, security audits)
+└────────┬─────────┘
+         │ no match
+         ▼
+┌──────────────────┐
+│ Complexity Scorer │  ← 13-dimension analysis
+└────────┬─────────┘
+         │ score 0-100
+         ▼
+┌──────────────────┐
+│   Tier Mapping   │  ← 0-15: flash, 16-40: standard, 41-65: pro, 66+: frontier
+└────────┬─────────┘
+         │ tier
+         ▼
+┌──────────────────┐
+│  Model Selection │  ← Currently: cheap provider (Flash/Standard/Pro) vs primary (Frontier)
+└────────┬─────────┘    Target: per-tier model mapping via config
+         │
+         ▼
+    LLM Provider
+```
+
+### Complexity Scorer (13 Dimensions)
+
+Each dimension produces a 0-100 score. Weighted sum determines total.
+
+| Dimension | Weight | Signals |
+|-----------|--------|---------|
+| Reasoning Words | 14% | "why", "explain", "compare", "trade-offs" |
+| Token Estimate | 12% | Prompt length |
+| Code Indicators | 10% | Backticks, syntax, "implement", "PR" |
+| Multi-Step | 10% | "first", "then", "after", "steps" |
+| Domain Specific | 10% | Technical terms (configurable) |
+| Creativity | 7% | "write", "summarize", "tweet", "blog" |
+| Question Complexity | 7% | Multiple questions, open-ended starters |
+| Precision | 6% | Numbers, "exactly", "calculate" |
+| Ambiguity | 5% | Vague references |
+| Context Dependency | 5% | "previous", "you said" |
+| Sentence Complexity | 5% | Commas, conjunctions, clause depth |
+| Tool Likelihood | 5% | "read", "deploy", "install" |
+| Safety Sensitivity | 4% | "password", "auth", "vulnerability" |
+
+**Multi-dimensional boost:** +30% when 3+ dimensions score above threshold.
+
+### Tier Boundaries
+
+| Score | Tier | Typical Use Case |
+|-------|------|------------------|
+| 0-15 | flash | Greetings, acknowledgments, quick lookups |
+| 16-40 | standard | Writing, comparisons, defined tasks |
+| 41-65 | pro | Multi-step analysis, code review |
+| 66+ | frontier | Critical decisions, security audits |
+
+### Pattern Overrides
+
+Fast-path rules that bypass scoring for obvious cases:
+
+```yaml
+# Force flash tier
+- "^(hi|hello|hey|thanks|ok|sure|yes|no)$"
+- "^what.*(time|date|day)"
+
+# Force frontier tier
+- "security.*(audit|review|scan)"
+- "vulnerabilit(y|ies).*(review|scan|check|audit)"
+
+# Force pro tier
+- "deploy.*(mainnet|production)"
+```
+
+### Configuration
+
+> **Note:** The current implementation supports smart routing via
+> `NEARAI_CHEAP_MODEL` and `SMART_ROUTING_CASCADE` env vars, plus
+> `domain_keywords` on `SmartRoutingConfig`. The full `llm.routing` YAML
+> schema below is the target design — not all knobs are wired yet.
+
+**Default (zero-config):**
+```yaml
+llm:
+  routing:
+    enabled: true  # default
+```
+
+**Power user overrides (target schema):**
+```yaml
+llm:
+  routing:
+    enabled: true
+    tiers:
+      flash: "claude-3-5-haiku-latest"
+      standard: "claude-sonnet-4-5-latest"
+      pro: "claude-sonnet-4-5-latest"
+      frontier: "claude-opus-4-5-latest"
+    thinking:
+      pro: "low"
+      frontier: "medium"
+    overrides:
+      - pattern: "my-custom-pattern"
+        tier: "pro"
+    domain_keywords:  # Custom keywords for your domain
+      - "mycompany"
+      - "myproduct"
+      - "internal-tool"
+```
+
+If `domain_keywords` is not set, uses `DEFAULT_DOMAIN_KEYWORDS` which covers common web3/infra terms.
+
+**Disable routing (pin model):**
+```yaml
+llm:
+  routing:
+    enabled: false
+  model: "claude-opus-4-5"
+```
+
+**Bring your own keys:**
+```yaml
+llm:
+  backend: anthropic
+  api_key: "sk-..."
+  routing:
+    enabled: true  # still works with external providers
+```
+
+### Integration Points
+
+1. **RoutingProvider** — New wrapper implementing `LlmProvider` trait (like `FailoverProvider`)
+2. **Scorer** — Pure function, no I/O, fast (~1ms)
+3. **Config schema** — Extend `LlmConfig` with `routing` section
+4. **Telemetry** — Log routing decisions for observability
+
+### Model Agnosticism
+
+**Critical:** No hardcoded model names in the router logic itself.
+
+- Tier→model mappings come from config
+- Default mappings use `-latest` patterns where supported
+- NEAR AI backend handles actual model resolution
+- Router only knows about tiers
+
+### Layers of Control
+
+| Layer | User Type | Config |
+|-------|-----------|--------|
+| 1. Zero-config | Everyone | `routing.enabled: true` (default) |
+| 2. Tier tuning | Power users | Custom `routing.tiers` mapping |
+| 3. Pattern overrides | Power users | Custom `routing.overrides` |
+| 4. Model pinning | Power users | `routing.enabled: false` + `model: X` |
+| 5. Own API keys | Power users | `backend: anthropic` + `api_key` |
+
+## Implementation Plan
+
+1. [x] Port scorer to Rust (`src/llm/smart_routing.rs`)
+2. [x] Implement router wrapper (`src/llm/smart_routing.rs`)
+3. [x] Extend config schema (`src/config.rs`)
+4. [x] Wire into provider creation (`src/llm/mod.rs`)
+5. [x] Add telemetry/logging
+6. [x] Tests with real conversation samples
+7. [x] Codex + Gemini security review
+8. [x] Documentation updated (this spec)
+
+## Expected Outcomes
+
+- **50-70% cost reduction** for typical usage patterns
+- **Faster responses** for simple requests
+- **Zero config required** for default benefits
+- **Full control** for power users who want it

migrations/V10__wasm_versioning.sql

@@ -0,0 +1,19 @@
+-- Add wit_version column to wasm_tools for WIT interface version tracking
+ALTER TABLE wasm_tools ADD COLUMN IF NOT EXISTS wit_version TEXT NOT NULL DEFAULT '0.1.0';
+
+-- Create wasm_channels table for DB-stored channel extensions
+CREATE TABLE IF NOT EXISTS wasm_channels (
+    id UUID PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    version TEXT NOT NULL DEFAULT '0.1.0',
+    wit_version TEXT NOT NULL DEFAULT '0.1.0',
+    description TEXT NOT NULL DEFAULT '',
+    wasm_binary BYTEA NOT NULL,
+    binary_hash BYTEA NOT NULL,
+    capabilities_json TEXT NOT NULL DEFAULT '{}',
+    status TEXT NOT NULL DEFAULT 'active',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT unique_wasm_channel UNIQUE (user_id, name)
+);

registry/channels/discord.json

@@ -3,29 +3,35 @@
   "display_name": "Discord Channel",
   "kind": "channel",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Talk to your agent in Discord",
-  "keywords": ["messaging", "chat", "discord", "bot"],
-
+  "keywords": [
+    "messaging",
+    "chat",
+    "discord",
+    "bot"
+  ],
   "source": {
     "dir": "channels-src/discord",
     "capabilities": "discord.capabilities.json",
     "crate_name": "discord-channel"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/discord-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "manual",
     "provider": "Discord",
-    "secrets": ["discord_bot_token"],
+    "secrets": [
+      "discord_bot_token"
+    ],
     "shared_auth": null,
     "setup_url": "https://discord.com/developers/applications"
   },
-
-  "tags": ["messaging"]
+  "tags": [
+    "messaging"
+  ]
 }

registry/channels/slack.json

@@ -3,29 +3,37 @@
   "display_name": "Slack Channel",
   "kind": "channel",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Talk to your agent in Slack",
-  "keywords": ["messaging", "chat", "workspace", "slack"],
-
+  "keywords": [
+    "messaging",
+    "chat",
+    "workspace",
+    "slack"
+  ],
   "source": {
     "dir": "channels-src/slack",
     "capabilities": "slack.capabilities.json",
     "crate_name": "slack-channel"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/slack-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "manual",
     "provider": "Slack",
-    "secrets": ["slack_bot_token", "slack_signing_secret"],
+    "secrets": [
+      "slack_bot_token",
+      "slack_signing_secret"
+    ],
     "shared_auth": null,
     "setup_url": "https://api.slack.com/apps"
   },
-
-  "tags": ["default", "messaging"]
+  "tags": [
+    "default",
+    "messaging"
+  ]
 }

registry/channels/telegram.json

@@ -3,29 +3,36 @@
   "display_name": "Telegram Channel",
   "kind": "channel",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Talk to your agent through a Telegram bot",
-  "keywords": ["messaging", "bot", "chat", "telegram"],
-
+  "keywords": [
+    "messaging",
+    "bot",
+    "chat",
+    "telegram"
+  ],
   "source": {
     "dir": "channels-src/telegram",
     "capabilities": "telegram.capabilities.json",
     "crate_name": "telegram-channel"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/telegram-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "manual",
     "provider": "Telegram",
-    "secrets": ["telegram_bot_token"],
+    "secrets": [
+      "telegram_bot_token"
+    ],
     "shared_auth": null,
     "setup_url": "https://t.me/BotFather"
   },
-
-  "tags": ["default", "messaging"]
+  "tags": [
+    "default",
+    "messaging"
+  ]
 }

registry/channels/whatsapp.json

@@ -3,29 +3,36 @@
   "display_name": "WhatsApp Channel",
   "kind": "channel",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Talk to your agent through WhatsApp",
-  "keywords": ["messaging", "chat", "whatsapp", "meta"],
-
+  "keywords": [
+    "messaging",
+    "chat",
+    "whatsapp",
+    "meta"
+  ],
   "source": {
     "dir": "channels-src/whatsapp",
     "capabilities": "whatsapp.capabilities.json",
     "crate_name": "whatsapp-channel"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/whatsapp-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "manual",
     "provider": "Meta",
-    "secrets": ["whatsapp_access_token", "whatsapp_verify_token"],
+    "secrets": [
+      "whatsapp_access_token",
+      "whatsapp_verify_token"
+    ],
     "shared_auth": null,
     "setup_url": "https://developers.facebook.com/apps/"
   },
-
-  "tags": ["messaging"]
+  "tags": [
+    "messaging"
+  ]
 }

registry/tools/github.json

@@ -3,29 +3,37 @@
   "display_name": "GitHub",
   "kind": "tool",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "GitHub integration for issues, PRs, repos, and code search",
-  "keywords": ["git", "code", "issues", "pull-requests", "repositories"],
-
+  "keywords": [
+    "git",
+    "code",
+    "issues",
+    "pull-requests",
+    "repositories"
+  ],
   "source": {
     "dir": "tools-src/github",
     "capabilities": "github-tool.capabilities.json",
     "crate_name": "github-tool"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/github-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "manual",
     "provider": "GitHub",
-    "secrets": ["github_token"],
+    "secrets": [
+      "github_token"
+    ],
     "shared_auth": null,
     "setup_url": "https://github.com/settings/tokens"
   },
-
-  "tags": ["default", "development"]
+  "tags": [
+    "default",
+    "development"
+  ]
 }

registry/tools/gmail.json

@@ -3,29 +3,37 @@
   "display_name": "Gmail",
   "kind": "tool",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Read, send, and manage Gmail messages and threads",
-  "keywords": ["email", "google", "mail", "messaging"],
-
+  "keywords": [
+    "email",
+    "google",
+    "mail",
+    "messaging"
+  ],
   "source": {
     "dir": "tools-src/gmail",
     "capabilities": "gmail-tool.capabilities.json",
     "crate_name": "gmail-tool"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/gmail-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "oauth",
     "provider": "Google",
-    "secrets": ["google_oauth_token"],
+    "secrets": [
+      "google_oauth_token"
+    ],
     "shared_auth": "google_oauth_token",
     "setup_url": "https://console.cloud.google.com/apis/credentials"
   },
-
-  "tags": ["default", "google", "messaging"]
+  "tags": [
+    "default",
+    "google",
+    "messaging"
+  ]
 }

registry/tools/google-calendar.json

@@ -3,29 +3,37 @@
   "display_name": "Google Calendar",
   "kind": "tool",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Create, read, update, and delete Google Calendar events",
-  "keywords": ["calendar", "google", "scheduling", "events"],
-
+  "keywords": [
+    "calendar",
+    "google",
+    "scheduling",
+    "events"
+  ],
   "source": {
     "dir": "tools-src/google-calendar",
     "capabilities": "google-calendar-tool.capabilities.json",
     "crate_name": "google-calendar-tool"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/google-calendar-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "oauth",
     "provider": "Google",
-    "secrets": ["google_oauth_token"],
+    "secrets": [
+      "google_oauth_token"
+    ],
     "shared_auth": "google_oauth_token",
     "setup_url": "https://console.cloud.google.com/apis/credentials"
   },
-
-  "tags": ["default", "google", "productivity"]
+  "tags": [
+    "default",
+    "google",
+    "productivity"
+  ]
 }

registry/tools/google-docs.json

@@ -3,29 +3,36 @@
   "display_name": "Google Docs",
   "kind": "tool",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Create and edit Google Docs documents",
-  "keywords": ["documents", "google", "writing", "docs"],
-
+  "keywords": [
+    "documents",
+    "google",
+    "writing",
+    "docs"
+  ],
   "source": {
     "dir": "tools-src/google-docs",
     "capabilities": "google-docs-tool.capabilities.json",
     "crate_name": "google-docs-tool"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/google-docs-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "oauth",
     "provider": "Google",
-    "secrets": ["google_oauth_token"],
+    "secrets": [
+      "google_oauth_token"
+    ],
     "shared_auth": "google_oauth_token",
     "setup_url": "https://console.cloud.google.com/apis/credentials"
   },
-
-  "tags": ["google", "productivity"]
+  "tags": [
+    "google",
+    "productivity"
+  ]
 }

registry/tools/google-drive.json

@@ -3,29 +3,37 @@
   "display_name": "Google Drive",
   "kind": "tool",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Upload, download, search, and manage Google Drive files and folders",
-  "keywords": ["storage", "google", "files", "drive"],
-
+  "keywords": [
+    "storage",
+    "google",
+    "files",
+    "drive"
+  ],
   "source": {
     "dir": "tools-src/google-drive",
     "capabilities": "google-drive-tool.capabilities.json",
     "crate_name": "google-drive-tool"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/google-drive-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "oauth",
     "provider": "Google",
-    "secrets": ["google_oauth_token"],
+    "secrets": [
+      "google_oauth_token"
+    ],
     "shared_auth": "google_oauth_token",
     "setup_url": "https://console.cloud.google.com/apis/credentials"
   },
-
-  "tags": ["default", "google", "storage"]
+  "tags": [
+    "default",
+    "google",
+    "storage"
+  ]
 }

registry/tools/google-sheets.json

@@ -3,29 +3,36 @@
   "display_name": "Google Sheets",
   "kind": "tool",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Read and write Google Sheets spreadsheet data",
-  "keywords": ["spreadsheets", "google", "data", "sheets"],
-
+  "keywords": [
+    "spreadsheets",
+    "google",
+    "data",
+    "sheets"
+  ],
   "source": {
     "dir": "tools-src/google-sheets",
     "capabilities": "google-sheets-tool.capabilities.json",
     "crate_name": "google-sheets-tool"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/google-sheets-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "oauth",
     "provider": "Google",
-    "secrets": ["google_oauth_token"],
+    "secrets": [
+      "google_oauth_token"
+    ],
     "shared_auth": "google_oauth_token",
     "setup_url": "https://console.cloud.google.com/apis/credentials"
   },
-
-  "tags": ["google", "productivity"]
+  "tags": [
+    "google",
+    "productivity"
+  ]
 }

registry/tools/google-slides.json

@@ -3,29 +3,35 @@
   "display_name": "Google Slides",
   "kind": "tool",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Create and edit Google Slides presentations",
-  "keywords": ["presentations", "google", "slides"],
-
+  "keywords": [
+    "presentations",
+    "google",
+    "slides"
+  ],
   "source": {
     "dir": "tools-src/google-slides",
     "capabilities": "google-slides-tool.capabilities.json",
     "crate_name": "google-slides-tool"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/google-slides-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "oauth",
     "provider": "Google",
-    "secrets": ["google_oauth_token"],
+    "secrets": [
+      "google_oauth_token"
+    ],
     "shared_auth": "google_oauth_token",
     "setup_url": "https://console.cloud.google.com/apis/credentials"
   },
-
-  "tags": ["google", "productivity"]
+  "tags": [
+    "google",
+    "productivity"
+  ]
 }

registry/tools/slack.json

@@ -3,29 +3,35 @@
   "display_name": "Slack Tool",
   "kind": "tool",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Your agent uses Slack to post and read messages in your workspace",
-  "keywords": ["messaging", "chat", "workspace"],
-
+  "keywords": [
+    "messaging",
+    "chat",
+    "workspace"
+  ],
   "source": {
     "dir": "tools-src/slack",
     "capabilities": "slack-tool.capabilities.json",
     "crate_name": "slack-tool"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/slack-tool-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "oauth",
     "provider": "Slack",
-    "secrets": ["slack_bot_token"],
+    "secrets": [
+      "slack_bot_token"
+    ],
     "shared_auth": null,
     "setup_url": "https://api.slack.com/apps"
   },
-
-  "tags": ["default", "messaging"]
+  "tags": [
+    "default",
+    "messaging"
+  ]
 }

registry/tools/telegram.json

@@ -3,29 +3,36 @@
   "display_name": "Telegram Tool",
   "kind": "tool",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Your agent uses your Telegram account to read and send messages",
-  "keywords": ["messaging", "chat", "telegram", "mtproto"],
-
+  "keywords": [
+    "messaging",
+    "chat",
+    "telegram",
+    "mtproto"
+  ],
   "source": {
     "dir": "tools-src/telegram",
     "capabilities": "telegram-tool.capabilities.json",
     "crate_name": "telegram-tool"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/telegram-mtproto-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "manual",
     "provider": "Telegram",
-    "secrets": ["telegram_api_id", "telegram_api_hash"],
+    "secrets": [
+      "telegram_api_id",
+      "telegram_api_hash"
+    ],
     "shared_auth": null,
     "setup_url": "https://my.telegram.org/apps"
   },
-
-  "tags": ["messaging"]
+  "tags": [
+    "messaging"
+  ]
 }

registry/tools/web-search.json

@@ -3,29 +3,36 @@
   "display_name": "Web Search",
   "kind": "tool",
   "version": "0.1.0",
+  "wit_version": "0.2.0",
   "description": "Search the web using Brave Search API",
-  "keywords": ["search", "web", "brave", "internet"],
-
+  "keywords": [
+    "search",
+    "web",
+    "brave",
+    "internet"
+  ],
   "source": {
     "dir": "tools-src/web-search",
     "capabilities": "web-search-tool.capabilities.json",
     "crate_name": "web-search-tool"
   },
-
   "artifacts": {
     "wasm32-wasip2": {
       "url": "https://github.com/nearai/ironclaw/releases/latest/download/web-search-wasm32-wasip2.tar.gz",
       "sha256": null
     }
   },
-
   "auth_summary": {
     "method": "manual",
     "provider": "Brave",
-    "secrets": ["brave_api_key"],
+    "secrets": [
+      "brave_api_key"
+    ],
     "shared_auth": null,
     "setup_url": "https://brave.com/search/api/"
   },
-
-  "tags": ["default", "search"]
+  "tags": [
+    "default",
+    "search"
+  ]
 }

scripts/build-wasm-extensions.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+# Build all WASM tools and channels from source.
+#
+# Verifies that every tool/channel in the registry compiles against the
+# current WIT definitions. Used by CI and can be run locally.
+#
+# Prerequisites:
+#   rustup target add wasm32-wasip2
+#   cargo install cargo-component --locked
+#
+# Usage:
+#   ./scripts/build-wasm-extensions.sh           # build all
+#   ./scripts/build-wasm-extensions.sh --tools    # tools only
+#   ./scripts/build-wasm-extensions.sh --channels # channels only
+
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+BUILD_TOOLS=true
+BUILD_CHANNELS=true
+FAILED=()
+
+if [[ "${1:-}" == "--tools" ]]; then
+    BUILD_CHANNELS=false
+elif [[ "${1:-}" == "--channels" ]]; then
+    BUILD_TOOLS=false
+fi
+
+build_extension() {
+    local manifest_path="$1"
+    local source_dir
+    local crate_name
+
+    source_dir=$(jq -r '.source.dir' "$manifest_path")
+    crate_name=$(jq -r '.source.crate_name' "$manifest_path")
+    local name
+    name=$(basename "$manifest_path" .json)
+
+    if [ ! -d "$source_dir" ]; then
+        echo "  SKIP $name (source dir $source_dir not found)"
+        return 0
+    fi
+
+    echo "  BUILD $name ($crate_name) from $source_dir"
+    if ! cargo component build --release --manifest-path "$source_dir/Cargo.toml" 2>&1; then
+        echo "  FAIL $name"
+        FAILED+=("$name")
+        return 1
+    fi
+    echo "  OK   $name"
+}
+
+if $BUILD_TOOLS; then
+    echo "Building WASM tools..."
+    for manifest in registry/tools/*.json; do
+        build_extension "$manifest" || true
+    done
+fi
+
+if $BUILD_CHANNELS; then
+    echo "Building WASM channels..."
+    for manifest in registry/channels/*.json; do
+        build_extension "$manifest" || true
+    done
+fi
+
+echo ""
+if [ ${#FAILED[@]} -gt 0 ]; then
+    echo "FAILED: ${FAILED[*]}"
+    exit 1
+else
+    echo "All WASM extensions built successfully."
+fi

scripts/check-version-bumps.sh

@@ -0,0 +1,251 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# CI script: check that version bumps accompany WIT or extension source changes.
+# Exit 0 if all checks pass, exit 1 if any version wasn't bumped.
+
+ERRORS=0
+
+# --- Skip mechanism -----------------------------------------------------------
+
+if [[ "${PR_LABELS:-}" == *"skip-version-check"* ]]; then
+    echo "skip-version-check label detected — skipping all version checks."
+    exit 0
+fi
+
+# Check commit messages for [skip-version-check]
+if git log "origin/${GITHUB_BASE_REF:-main}...HEAD" --pretty=format:"%s %b" 2>/dev/null \
+    | grep -qF '[skip-version-check]'; then
+    echo "[skip-version-check] found in commit message — skipping all version checks."
+    exit 0
+fi
+
+# --- Determine base branch and changed files ----------------------------------
+
+BASE_BRANCH="${GITHUB_BASE_REF:-main}"
+echo "Base branch: $BASE_BRANCH"
+
+# Ensure the base branch ref is available
+if ! git rev-parse "origin/${BASE_BRANCH}" >/dev/null 2>&1; then
+    echo "Fetching origin/${BASE_BRANCH}..."
+    git fetch origin "$BASE_BRANCH" --depth=1
+fi
+
+CHANGED_FILES=$(git diff --name-only "origin/${BASE_BRANCH}...HEAD")
+
+if [[ -z "$CHANGED_FILES" ]]; then
+    echo "No changed files detected. Nothing to check."
+    exit 0
+fi
+
+# --- Helper functions ---------------------------------------------------------
+
+# Extract the version from a WIT package line like: package near:[email protected];
+extract_wit_version() {
+    local file="$1"
+    if [[ ! -f "$file" ]]; then
+        echo ""
+        return
+    fi
+    sed -n 's/^[[:space:]]*package[[:space:]]\+[^@]*@\([0-9][0-9.]*[0-9]\)[[:space:]]*;.*/\1/p' "$file" \
+        | head -n1
+}
+
+# Extract version from the base branch copy of a file
+extract_wit_version_base() {
+    local file="$1"
+    git show "origin/${BASE_BRANCH}:${file}" 2>/dev/null \
+        | sed -n 's/^[[:space:]]*package[[:space:]]\+[^@]*@\([0-9][0-9.]*[0-9]\)[[:space:]]*;.*/\1/p' \
+        | head -n1 || true
+}
+
+# Extract a Rust string constant value: pub const NAME: &str = "value";
+extract_rust_const() {
+    local file="$1"
+    local const_name="$2"
+    if [[ ! -f "$file" ]]; then
+        echo ""
+        return
+    fi
+    sed -n "s/^.*${const_name}[[:space:]]*:[[:space:]]*&str[[:space:]]*=[[:space:]]*\"\([^\"]*\)\".*/\1/p" "$file" \
+        | head -n1
+}
+
+# Extract JSON "version" field using jq
+extract_json_version() {
+    local file="$1"
+    if [[ ! -f "$file" ]]; then
+        echo ""
+        return
+    fi
+    jq -r '.version // empty' "$file" 2>/dev/null || true
+}
+
+# Extract JSON "version" from the base branch copy of a file
+extract_json_version_base() {
+    local file="$1"
+    git show "origin/${BASE_BRANCH}:${file}" 2>/dev/null | jq -r '.version // empty' 2>/dev/null || true
+}
+
+# Return 0 if $1 (new) is strictly greater than $2 (old) via sort -V, or old is empty.
+version_was_bumped() {
+    local new="$1"
+    local old="$2"
+    if [[ -z "$old" ]]; then
+        # No prior version — treat as new, no bump required
+        return 0
+    fi
+    if [[ -z "$new" ]]; then
+        # Version was removed — that's a problem
+        return 1
+    fi
+    if [[ "$new" == "$old" ]]; then
+        return 1
+    fi
+    # Check new > old via sort -V
+    local highest
+    highest=$(printf '%s\n%s\n' "$new" "$old" | sort -V | tail -n1)
+    [[ "$highest" == "$new" ]]
+}
+
+# --- 1. WIT changes ----------------------------------------------------------
+
+WIT_TOOL_CHANGED=false
+WIT_CHANNEL_CHANGED=false
+
+if echo "$CHANGED_FILES" | grep -qx 'wit/tool\.wit'; then
+    WIT_TOOL_CHANGED=true
+fi
+if echo "$CHANGED_FILES" | grep -qx 'wit/channel\.wit'; then
+    WIT_CHANNEL_CHANGED=true
+fi
+
+if $WIT_TOOL_CHANGED; then
+    echo ""
+    echo "=== wit/tool.wit changed ==="
+
+    NEW_VER=$(extract_wit_version "wit/tool.wit")
+    OLD_VER=$(extract_wit_version_base "wit/tool.wit")
+    echo "  WIT package version: ${OLD_VER:-<none>} -> ${NEW_VER:-<missing>}"
+
+    if ! version_was_bumped "${NEW_VER}" "${OLD_VER}"; then
+        echo "  ERROR: wit/tool.wit package version was not bumped (${OLD_VER} -> ${NEW_VER:-<missing>})."
+        ERRORS=$((ERRORS + 1))
+    else
+        echo "  OK: WIT package version bumped."
+    fi
+
+    # Check WIT_TOOL_VERSION constant matches
+    CONST_VER=$(extract_rust_const "src/tools/wasm/mod.rs" "WIT_TOOL_VERSION")
+    if [[ -n "$NEW_VER" && "$CONST_VER" != "$NEW_VER" ]]; then
+        echo "  ERROR: WIT_TOOL_VERSION in src/tools/wasm/mod.rs is '${CONST_VER}' but wit/tool.wit has '${NEW_VER}'. They must match."
+        ERRORS=$((ERRORS + 1))
+    elif [[ -n "$NEW_VER" ]]; then
+        echo "  OK: WIT_TOOL_VERSION matches wit/tool.wit."
+    fi
+fi
+
+if $WIT_CHANNEL_CHANGED; then
+    echo ""
+    echo "=== wit/channel.wit changed ==="
+
+    NEW_VER=$(extract_wit_version "wit/channel.wit")
+    OLD_VER=$(extract_wit_version_base "wit/channel.wit")
+    echo "  WIT package version: ${OLD_VER:-<none>} -> ${NEW_VER:-<missing>}"
+
+    if ! version_was_bumped "${NEW_VER}" "${OLD_VER}"; then
+        echo "  ERROR: wit/channel.wit package version was not bumped (${OLD_VER} -> ${NEW_VER:-<missing>})."
+        ERRORS=$((ERRORS + 1))
+    else
+        echo "  OK: WIT package version bumped."
+    fi
+
+    # Check WIT_CHANNEL_VERSION constant matches
+    CONST_VER=$(extract_rust_const "src/tools/wasm/mod.rs" "WIT_CHANNEL_VERSION")
+    if [[ -n "$NEW_VER" && "$CONST_VER" != "$NEW_VER" ]]; then
+        echo "  ERROR: WIT_CHANNEL_VERSION in src/tools/wasm/mod.rs is '${CONST_VER}' but wit/channel.wit has '${NEW_VER}'. They must match."
+        ERRORS=$((ERRORS + 1))
+    elif [[ -n "$NEW_VER" ]]; then
+        echo "  OK: WIT_CHANNEL_VERSION matches wit/channel.wit."
+    fi
+fi
+
+if $WIT_TOOL_CHANGED || $WIT_CHANNEL_CHANGED; then
+    echo ""
+    echo "  WARNING: WIT interface changed. All published registry extensions should bump their versions for compatibility."
+fi
+
+# --- 2. Tool source changes ---------------------------------------------------
+
+TOOL_NAMES=$(echo "$CHANGED_FILES" | sed -n 's|^tools-src/\([^/]*\)/.*|\1|p' | sort -u)
+
+if [[ -n "$TOOL_NAMES" ]]; then
+    echo ""
+    echo "=== Tool source changes ==="
+fi
+
+for tool in $TOOL_NAMES; do
+    REGISTRY_FILE="registry/tools/${tool}.json"
+    echo ""
+    echo "  --- tools-src/${tool}/ changed ---"
+
+    if [[ ! -f "$REGISTRY_FILE" ]]; then
+        echo "  SKIP: ${REGISTRY_FILE} does not exist yet (new extension?)."
+        continue
+    fi
+
+    NEW_VER=$(extract_json_version "$REGISTRY_FILE")
+    OLD_VER=$(extract_json_version_base "$REGISTRY_FILE")
+
+    echo "  Registry version: ${OLD_VER:-<none>} -> ${NEW_VER:-<missing>}"
+
+    if ! version_was_bumped "${NEW_VER}" "${OLD_VER}"; then
+        echo "  ERROR: ${REGISTRY_FILE} version was not bumped (${OLD_VER} -> ${NEW_VER:-<missing>}). Bump the version when changing tools-src/${tool}/."
+        ERRORS=$((ERRORS + 1))
+    else
+        echo "  OK: version bumped."
+    fi
+done
+
+# --- 3. Channel source changes ------------------------------------------------
+
+CHANNEL_NAMES=$(echo "$CHANGED_FILES" | sed -n 's|^channels-src/\([^/]*\)/.*|\1|p' | sort -u)
+
+if [[ -n "$CHANNEL_NAMES" ]]; then
+    echo ""
+    echo "=== Channel source changes ==="
+fi
+
+for channel in $CHANNEL_NAMES; do
+    REGISTRY_FILE="registry/channels/${channel}.json"
+    echo ""
+    echo "  --- channels-src/${channel}/ changed ---"
+
+    if [[ ! -f "$REGISTRY_FILE" ]]; then
+        echo "  SKIP: ${REGISTRY_FILE} does not exist yet (new extension?)."
+        continue
+    fi
+
+    NEW_VER=$(extract_json_version "$REGISTRY_FILE")
+    OLD_VER=$(extract_json_version_base "$REGISTRY_FILE")
+
+    echo "  Registry version: ${OLD_VER:-<none>} -> ${NEW_VER:-<missing>}"
+
+    if ! version_was_bumped "${NEW_VER}" "${OLD_VER}"; then
+        echo "  ERROR: ${REGISTRY_FILE} version was not bumped (${OLD_VER} -> ${NEW_VER:-<missing>}). Bump the version when changing channels-src/${channel}/."
+        ERRORS=$((ERRORS + 1))
+    else
+        echo "  OK: version bumped."
+    fi
+done
+
+# --- Summary ------------------------------------------------------------------
+
+echo ""
+if [[ $ERRORS -gt 0 ]]; then
+    echo "FAILED: ${ERRORS} version check(s) did not pass. See errors above."
+    exit 1
+else
+    echo "All version checks passed."
+    exit 0
+fi

scripts/coverage.sh

@@ -0,0 +1,101 @@
+#!/usr/bin/env bash
+# Generate an HTML coverage report for a given set of tests.
+#
+# Usage:
+#   ./scripts/coverage.sh                          # all tests (lib only)
+#   ./scripts/coverage.sh safety                   # tests matching "safety"
+#   ./scripts/coverage.sh safety::sanitizer        # specific module tests
+#   ./scripts/coverage.sh test_a test_b test_c     # multiple test filters
+#
+# Options (env vars):
+#   COV_OPEN=1          Auto-open the report in a browser (default: 1)
+#   COV_FORMAT=html     Output format: html, text, json, lcov (default: html)
+#   COV_OUT=coverage    Output directory (default: coverage/)
+#   COV_FEATURES=""     Extra --features to pass (default: none)
+#   COV_ALL_TARGETS=0   Set to 1 to include integration tests (default: lib only)
+#
+# Requires: cargo-llvm-cov (install: cargo install cargo-llvm-cov)
+
+set -euo pipefail
+
+COV_OPEN="${COV_OPEN:-1}"
+COV_FORMAT="${COV_FORMAT:-html}"
+COV_OUT="${COV_OUT:-coverage}"
+COV_FEATURES="${COV_FEATURES:-}"
+COV_ALL_TARGETS="${COV_ALL_TARGETS:-0}"
+
+cd "$(git rev-parse --show-toplevel)"
+
+if ! command -v cargo-llvm-cov &>/dev/null; then
+    echo "ERROR: cargo-llvm-cov not found. Install with: cargo install cargo-llvm-cov"
+    exit 1
+fi
+
+# Clean stale profiling data to avoid "mismatched data" warnings.
+cargo llvm-cov clean --workspace 2>/dev/null || true
+
+# Build the cargo llvm-cov command
+cmd=(cargo llvm-cov)
+
+# Features
+if [[ -n "$COV_FEATURES" ]]; then
+    cmd+=(--features "$COV_FEATURES")
+else
+    cmd+=(--all-features)
+fi
+
+# By default, only run the lib unit tests (fast, no integration test compilation).
+# Set COV_ALL_TARGETS=1 to include integration tests.
+if [[ "$COV_ALL_TARGETS" != "1" ]]; then
+    cmd+=(--lib)
+fi
+
+# Output format
+case "$COV_FORMAT" in
+    html)
+        cmd+=(--html --output-dir "$COV_OUT")
+        ;;
+    text)
+        cmd+=(--text)
+        ;;
+    json)
+        cmd+=(--json --output-path "$COV_OUT/coverage.json")
+        ;;
+    lcov)
+        cmd+=(--lcov --output-path "$COV_OUT/lcov.info")
+        ;;
+    *)
+        echo "ERROR: Unknown format '$COV_FORMAT'. Use: html, text, json, lcov"
+        exit 1
+        ;;
+esac
+
+# Test name filters (passed after -- to cargo test)
+if [[ $# -gt 0 ]]; then
+    if [[ $# -eq 1 ]]; then
+        cmd+=(-- "$1")
+    else
+        # Join filters with | for regex matching
+        filter=$(IFS='|'; echo "$*")
+        cmd+=(-- "$filter")
+    fi
+fi
+
+echo "Running: ${cmd[*]}"
+echo ""
+
+"${cmd[@]}"
+
+# Open report
+if [[ "$COV_FORMAT" == "html" && "$COV_OPEN" == "1" ]]; then
+    index="$COV_OUT/html/index.html"
+    if [[ -f "$index" ]]; then
+        echo ""
+        echo "Report: $index"
+        if command -v open &>/dev/null; then
+            open "$index"
+        elif command -v xdg-open &>/dev/null; then
+            xdg-open "$index"
+        fi
+    fi
+fi

src/agent/agent_loop.rs

@@ -75,6 +75,8 @@ pub struct AgentDeps {
     pub cost_guard: Arc<crate::agent::cost_guard::CostGuard>,
     /// SSE broadcast sender for live job event streaming to the web gateway.
     pub sse_tx: Option<tokio::sync::broadcast::Sender<crate::channels::web::types::SseEvent>>,
+    /// HTTP interceptor for trace recording/replay.
+    pub http_interceptor: Option<Arc<dyn crate::llm::recording::HttpInterceptor>>,
 }
 
 /// The main agent that coordinates all components.
@@ -633,6 +635,10 @@ impl Agent {
 
         // Parse submission type first
         let mut submission = SubmissionParser::parse(&message.content);
+        tracing::debug!(
+            "[agent_loop] Parsed submission: {:?}",
+            std::any::type_name_of_val(&submission)
+        );
 
         // Hook: BeforeInbound — allow hooks to modify or reject user input
         if let Submission::UserInput { ref content } = submission {
@@ -717,7 +723,14 @@ impl Agent {
                     .await
             }
             Submission::SystemCommand { command, args } => {
-                self.handle_system_command(&command, &args).await
+                tracing::debug!(
+                    "[agent_loop] SystemCommand: command={}, channel={}",
+                    command,
+                    message.channel
+                );
+                // Authorization checks (including restart channel check) are enforced in handle_system_command
+                self.handle_system_command(&command, &args, &message.channel)
+                    .await
             }
             Submission::Undo => self.process_undo(session, thread_id).await,
             Submission::Redo => self.process_redo(session, thread_id).await,

src/agent/commands.rs

@@ -68,7 +68,10 @@ impl Agent {
                 self.handle_help_job(&message.user_id, &job_id).await?
             }
             MessageIntent::Command { command, args } => {
-                match self.handle_command(&command, &args).await? {
+                match self
+                    .handle_command(&command, &args, &message.channel)
+                    .await?
+                {
                     Some(s) => s,
                     None => return Ok(SubmissionResult::Ok { message: None }), // Shutdown signal
                 }
@@ -466,6 +469,7 @@ impl Agent {
         &self,
         command: &str,
         args: &[String],
+        channel: &str,
     ) -> Result<SubmissionResult, Error> {
         match command {
             "help" => Ok(SubmissionResult::response(concat!(
@@ -501,12 +505,75 @@ impl Agent {
                 "  /heartbeat        Run heartbeat check\n",
                 "  /summarize        Summarize current thread\n",
                 "  /suggest          Suggest next steps\n",
+                "  /restart          Gracefully restart the process\n",
                 "\n",
                 "  /quit             Exit",
             ))),
 
             "ping" => Ok(SubmissionResult::response("pong!")),
 
+            "restart" => {
+                tracing::info!("[commands::restart] Restart command received");
+                // Channel authorization check: restart is only available via web interface
+                if channel != "gateway" {
+                    tracing::warn!(
+                        "[commands::restart] Restart rejected: not from gateway channel (from: {})",
+                        channel
+                    );
+                    return Ok(SubmissionResult::error(
+                        "Restart is only available through the web interface with explicit user confirmation. \
+                         Use the Restart button in the UI."
+                            .to_string(),
+                    ));
+                }
+                // Environment check: restart is only available in Docker containers
+                let in_docker = std::env::var("IRONCLAW_IN_DOCKER")
+                    .map(|v| v.to_lowercase() == "true")
+                    .unwrap_or(false);
+
+                tracing::debug!("[commands::restart] IRONCLAW_IN_DOCKER={}", in_docker);
+
+                if !in_docker {
+                    tracing::warn!(
+                        "[commands::restart] Restart rejected: not in Docker environment"
+                    );
+                    return Ok(SubmissionResult::error(
+                        "Restart is not available in this environment. \
+                         The IRONCLAW_IN_DOCKER environment variable must be set to 'true' for Docker deployments."
+                            .to_string(),
+                    ));
+                }
+
+                // Execute restart tool directly (don't dispatch as a job for LLM planning)
+                // This ensures the tool runs immediately without LLM involvement
+                use crate::tools::Tool;
+                let tool = crate::tools::builtin::RestartTool;
+                let params = serde_json::json!({});
+
+                // Create a minimal JobContext for the tool
+                let dummy_ctx =
+                    crate::context::JobContext::with_user("system", "Restart", "Graceful restart");
+
+                match tool.execute(params, &dummy_ctx).await {
+                    Ok(output) => {
+                        tracing::info!("[commands::restart] RestartTool executed successfully");
+                        // Extract text from the ToolOutput result
+                        let response = match output.result {
+                            serde_json::Value::String(s) => s,
+                            _ => output.result.to_string(),
+                        };
+                        Ok(SubmissionResult::response(response))
+                    }
+                    Err(e) => {
+                        tracing::error!(
+                            "[commands::restart] RestartTool execution failed: {:?}",
+                            e
+                        );
+                        Ok(SubmissionResult::error(format!("Restart failed: {}", e)))
+                    }
+                }
+            }
+
             "version" => Ok(SubmissionResult::response(format!(
                 "{} v{}",
                 env!("CARGO_PKG_NAME"),
@@ -744,10 +811,11 @@ impl Agent {
         &self,
         command: &str,
         args: &[String],
+        channel: &str,
     ) -> Result<Option<String>, Error> {
         // System commands are now handled directly via Submission::SystemCommand,
         // but the router may still send us unknown /commands.
-        match self.handle_system_command(command, args).await? {
+        match self.handle_system_command(command, args, channel).await? {
             SubmissionResult::Response { content } => Ok(Some(content)),
             SubmissionResult::Ok { message } => Ok(message),
             SubmissionResult::Error { message } => Ok(Some(format!("Error: {}", message))),

src/agent/dispatcher.rs

@@ -127,7 +127,9 @@ impl Agent {
         let mut context_messages = initial_messages;
 
         // Create a JobContext for tool execution (chat doesn't have a real job)
-        let job_ctx = JobContext::with_user(&message.user_id, "chat", "Interactive chat session");
+        let mut job_ctx =
+            JobContext::with_user(&message.user_id, "chat", "Interactive chat session");
+        job_ctx.http_interceptor = self.deps.http_interceptor.clone();
 
         let max_tool_iterations = self.config.max_tool_iterations;
         // Force a text-only response on the last iteration to guarantee termination
@@ -686,6 +688,15 @@ impl Agent {
                                     deferred_auth = Some(instructions);
                                 }
 
+                                // Stash full output so subsequent tools can reference it
+                                if let Ok(ref output) = tool_result {
+                                    job_ctx
+                                        .tool_output_stash
+                                        .write()
+                                        .await
+                                        .insert(tc.id.clone(), output.clone());
+                                }
+
                                 // Sanitize and add tool result to context
                                 let result_content = match tool_result {
                                     Ok(output) => {
@@ -1066,6 +1077,7 @@ mod tests {
             hooks: Arc::new(HookRegistry::new()),
             cost_guard: Arc::new(CostGuard::new(CostGuardConfig::default())),
             sse_tx: None,
+            http_interceptor: None,
         };
 
         Agent::new(
@@ -1805,6 +1817,7 @@ mod tests {
             hooks: Arc::new(HookRegistry::new()),
             cost_guard: Arc::new(CostGuard::new(CostGuardConfig::default())),
             sse_tx: None,
+            http_interceptor: None,
         };
 
         Agent::new(
@@ -1917,6 +1930,7 @@ mod tests {
                 hooks: Arc::new(HookRegistry::new()),
                 cost_guard: Arc::new(CostGuard::new(CostGuardConfig::default())),
                 sse_tx: None,
+                http_interceptor: None,
             };
 
             Agent::new(

src/agent/heartbeat.rs

@@ -164,6 +164,7 @@ impl HeartbeatRunner {
                 if report.had_work() {
                     tracing::info!(
                         daily_logs_deleted = report.daily_logs_deleted,
+                        conversation_docs_deleted = report.conversation_docs_deleted,
                         "heartbeat: memory hygiene deleted stale documents"
                     );
                 }

src/agent/submission.rs

@@ -14,6 +14,7 @@ impl SubmissionParser {
     pub fn parse(content: &str) -> Submission {
         let trimmed = content.trim();
         let lower = trimmed.to_lowercase();
+        tracing::debug!("[SubmissionParser::parse] Parsing input: {:?}", trimmed);
 
         // Control commands (exact match or prefix)
         if lower == "/undo" {
@@ -91,6 +92,13 @@ impl SubmissionParser {
                 args: vec![],
             };
         }
+        if lower == "/restart" {
+            tracing::debug!("[SubmissionParser::parse] Recognized /restart command");
+            return Submission::SystemCommand {
+                command: "restart".to_string(),
+                args: vec![],
+            };
+        }
         if lower.starts_with("/model") {
             let args: Vec<String> = trimmed
                 .split_whitespace()

src/agent/thread_ops.rs

@@ -734,8 +734,9 @@ impl Agent {
             }
 
             // Execute the approved tool and continue the loop
-            let job_ctx =
+            let mut job_ctx =
                 JobContext::with_user(&message.user_id, "chat", "Interactive chat session");
+            job_ctx.http_interceptor = self.deps.http_interceptor.clone();
 
             let _ = self
                 .channels

src/app.rs

@@ -15,7 +15,7 @@ use crate::context::ContextManager;
 use crate::db::Database;
 use crate::extensions::ExtensionManager;
 use crate::hooks::HookRegistry;
-use crate::llm::{LlmProvider, SessionManager};
+use crate::llm::{LlmProvider, RecordingLlm, SessionManager};
 use crate::safety::SafetyLayer;
 use crate::secrets::SecretsStore;
 use crate::skills::SkillRegistry;
@@ -48,6 +48,7 @@ pub struct AppComponents {
     pub skill_registry: Option<Arc<std::sync::RwLock<SkillRegistry>>>,
     pub skill_catalog: Option<Arc<SkillCatalog>>,
     pub cost_guard: Arc<crate::agent::cost_guard::CostGuard>,
+    pub recording_handle: Option<Arc<RecordingLlm>>,
     pub session: Arc<SessionManager>,
     pub catalog_entries: Vec<crate::extensions::RegistryEntry>,
     pub dev_loaded_tool_names: Vec<String>,
@@ -71,6 +72,9 @@ pub struct AppBuilder {
     db: Option<Arc<dyn Database>>,
     secrets_store: Option<Arc<dyn SecretsStore + Send + Sync>>,
 
+    // Test overrides
+    llm_override: Option<Arc<dyn LlmProvider>>,
+
     // Backend-specific handles needed by secrets store
     #[cfg(feature = "postgres")]
     pg_pool: Option<deadpool_postgres::Pool>,
@@ -99,6 +103,7 @@ impl AppBuilder {
             log_broadcaster,
             db: None,
             secrets_store: None,
+            llm_override: None,
             #[cfg(feature = "postgres")]
             pg_pool: None,
             #[cfg(feature = "libsql")]
@@ -106,11 +111,26 @@ impl AppBuilder {
         }
     }
 
+    /// Inject a pre-created database, skipping `init_database()`.
+    pub fn with_database(&mut self, db: Arc<dyn Database>) {
+        self.db = Some(db);
+    }
+
+    /// Inject a pre-created LLM provider, skipping `init_llm()`.
+    pub fn with_llm(&mut self, llm: Arc<dyn LlmProvider>) {
+        self.llm_override = Some(llm);
+    }
+
     /// Phase 1: Initialize database backend.
     ///
     /// Creates the database connection, runs migrations, reloads config
     /// from DB, attaches DB to session manager, and cleans up stale jobs.
     pub async fn init_database(&mut self) -> Result<(), anyhow::Error> {
+        if self.db.is_some() {
+            tracing::debug!("Database already provided, skipping init_database()");
+            return Ok(());
+        }
+
         if self.flags.no_db {
             tracing::warn!("Running without database connection");
             return Ok(());
@@ -297,10 +317,17 @@ impl AppBuilder {
     #[allow(clippy::type_complexity)]
     pub fn init_llm(
         &self,
-    ) -> Result<(Arc<dyn LlmProvider>, Option<Arc<dyn LlmProvider>>), anyhow::Error> {
-        let (llm, cheap_llm) =
+    ) -> Result<
+        (
+            Arc<dyn LlmProvider>,
+            Option<Arc<dyn LlmProvider>>,
+            Option<Arc<RecordingLlm>>,
+        ),
+        anyhow::Error,
+    > {
+        let (llm, cheap_llm, recording_handle) =
             crate::llm::build_provider_chain(&self.config.llm, self.session.clone())?;
-        Ok((llm, cheap_llm))
+        Ok((llm, cheap_llm, recording_handle))
     }
 
     /// Phase 4: Initialize safety, tools, embeddings, and workspace.
@@ -653,7 +680,11 @@ impl AppBuilder {
         self.init_database().await?;
         self.init_secrets().await?;
 
-        let (llm, cheap_llm) = self.init_llm()?;
+        let (llm, cheap_llm, recording_handle) = if let Some(llm) = self.llm_override.take() {
+            (llm, None, None)
+        } else {
+            self.init_llm()?
+        };
         let (safety, tools, embeddings, workspace) = self.init_tools(&llm).await?;
 
         // Create hook registry early so runtime extension activation can register hooks.
@@ -765,6 +796,7 @@ impl AppBuilder {
             skill_registry,
             skill_catalog,
             cost_guard,
+            recording_handle,
             session: self.session,
             catalog_entries,
             dev_loaded_tool_names,

src/channels/wasm/error.rs

@@ -80,6 +80,9 @@ pub enum WasmChannelError {
 
     #[error("HTTP request error: {0}")]
     HttpRequest(String),
+
+    #[error("WIT version mismatch: {0}")]
+    IncompatibleWitVersion(String),
 }
 
 impl From<crate::tools::wasm::WasmError> for WasmChannelError {

src/channels/wasm/loader.rs

@@ -90,6 +90,14 @@ impl WasmChannelLoader {
                         "Parsed capabilities file"
                     );
 
+                    // Check WIT version compatibility
+                    crate::tools::wasm::loader::check_wit_version_compat(
+                        name,
+                        cap_file.wit_version.as_deref(),
+                        crate::tools::wasm::WIT_CHANNEL_VERSION,
+                    )
+                    .map_err(|e| WasmChannelError::IncompatibleWitVersion(e.to_string()))?;
+
                     let caps = cap_file.to_capabilities();
 
                     // Debug: log resulting capabilities
@@ -277,6 +285,13 @@ impl LoadedChannel {
             .and_then(|f| f.signature_key_secret_name().map(|s| s.to_string()))
     }
 
+    /// Get the HMAC-SHA256 signing secret name from capabilities.
+    pub fn hmac_secret_name(&self) -> Option<String> {
+        self.capabilities_file
+            .as_ref()
+            .and_then(|f| f.hmac_secret_name().map(|s| s.to_string()))
+    }
+
     /// Get the webhook secret name from capabilities.
     pub fn webhook_secret_name(&self) -> String {
         self.capabilities_file

src/channels/wasm/mod.rs

@@ -87,6 +87,8 @@ mod router;
 mod runtime;
 mod schema;
 pub(crate) mod signature;
+#[allow(dead_code)]
+pub(crate) mod storage;
 mod wrapper;
 
 // Core types

src/channels/wasm/router.rs

@@ -44,6 +44,8 @@ pub struct WasmChannelRouter {
     secret_headers: RwLock<HashMap<String, String>>,
     /// Ed25519 public keys for signature verification by channel name (hex-encoded).
     signature_keys: RwLock<HashMap<String, String>>,
+    /// HMAC-SHA256 signing secrets for signature verification by channel name (Slack-style).
+    hmac_secrets: RwLock<HashMap<String, String>>,
 }
 
 impl WasmChannelRouter {
@@ -55,6 +57,7 @@ impl WasmChannelRouter {
             secrets: RwLock::new(HashMap::new()),
             secret_headers: RwLock::new(HashMap::new()),
             signature_keys: RwLock::new(HashMap::new()),
+            hmac_secrets: RwLock::new(HashMap::new()),
         }
     }
 
@@ -134,6 +137,7 @@ impl WasmChannelRouter {
         self.secrets.write().await.remove(channel_name);
         self.secret_headers.write().await.remove(channel_name);
         self.signature_keys.write().await.remove(channel_name);
+        self.hmac_secrets.write().await.remove(channel_name);
 
         // Remove all paths for this channel
         self.path_to_channel
@@ -208,6 +212,24 @@ impl WasmChannelRouter {
     pub async fn get_signature_key(&self, channel_name: &str) -> Option<String> {
         self.signature_keys.read().await.get(channel_name).cloned()
     }
+
+    /// Register an HMAC-SHA256 signing secret for signature verification.
+    ///
+    /// Channels with a registered secret will have Slack-style HMAC-SHA256
+    /// signature validation performed before forwarding to WASM.
+    pub async fn register_hmac_secret(&self, channel_name: &str, secret: &str) {
+        self.hmac_secrets
+            .write()
+            .await
+            .insert(channel_name.to_string(), secret.to_string());
+    }
+
+    /// Get the HMAC signing secret for a channel.
+    ///
+    /// Returns `None` if no secret is registered (no HMAC check needed).
+    pub async fn get_hmac_secret(&self, channel_name: &str) -> Option<String> {
+        self.hmac_secrets.read().await.get(channel_name).cloned()
+    }
 }
 
 impl Default for WasmChannelRouter {
@@ -427,6 +449,57 @@ async fn webhook_handler(
         }
     }
 
+    // HMAC-SHA256 signature verification (Slack-style)
+    if let Some(hmac_secret) = state.router.get_hmac_secret(channel_name).await {
+        let timestamp = headers
+            .get("x-slack-request-timestamp")
+            .and_then(|v| v.to_str().ok());
+        let sig_header = headers
+            .get("x-slack-signature")
+            .and_then(|v| v.to_str().ok());
+
+        match (timestamp, sig_header) {
+            (Some(ts), Some(sig)) => {
+                let now_secs = std::time::SystemTime::now()
+                    .duration_since(std::time::UNIX_EPOCH)
+                    .unwrap_or_default()
+                    .as_secs() as i64;
+
+                if !crate::channels::wasm::signature::verify_slack_signature(
+                    &hmac_secret,
+                    ts,
+                    &body,
+                    sig,
+                    now_secs,
+                ) {
+                    tracing::warn!(
+                        channel = %channel_name,
+                        "HMAC-SHA256 signature verification failed"
+                    );
+                    return (
+                        StatusCode::UNAUTHORIZED,
+                        Json(serde_json::json!({
+                            "error": "Invalid Slack signature"
+                        })),
+                    );
+                }
+                tracing::debug!(channel = %channel_name, "HMAC-SHA256 signature verified");
+            }
+            _ => {
+                tracing::warn!(
+                    channel = %channel_name,
+                    "Slack signature headers missing but secret is registered"
+                );
+                return (
+                    StatusCode::UNAUTHORIZED,
+                    Json(serde_json::json!({
+                        "error": "Missing Slack signature headers"
+                    })),
+                );
+            }
+        }
+    }
+
     // Convert headers to HashMap
     let headers_map: HashMap<String, String> = headers
         .iter()
@@ -731,7 +804,59 @@ mod tests {
         assert_eq!(router.get_secret_header("slack").await, "X-Webhook-Secret");
     }
 
-    // ── Category 3: Router Signature Key Management ─────────────────────
+    // ── Category 3: Router HMAC Secret Management ───────────────────────
+
+    #[tokio::test]
+    async fn test_register_and_get_hmac_secret() {
+        let router = WasmChannelRouter::new();
+        let channel = create_test_channel("slack");
+
+        router.register(channel, vec![], None, None).await;
+
+        let hmac_secret = "my-slack-signing-secret";
+        router.register_hmac_secret("slack", hmac_secret).await;
+
+        let retrieved = router.get_hmac_secret("slack").await;
+        assert_eq!(retrieved, Some(hmac_secret.to_string()));
+    }
+
+    #[tokio::test]
+    async fn test_no_hmac_secret_returns_none() {
+        let router = WasmChannelRouter::new();
+        let channel = create_test_channel("slack");
+        router.register(channel, vec![], None, None).await;
+
+        // Slack has no HMAC secret registered
+        let secret = router.get_hmac_secret("slack").await;
+        assert!(secret.is_none());
+    }
+
+    #[tokio::test]
+    async fn test_unregister_removes_hmac_secret() {
+        let router = WasmChannelRouter::new();
+        let channel = create_test_channel("slack");
+
+        let endpoints = vec![RegisteredEndpoint {
+            channel_name: "slack".to_string(),
+            path: "/webhook/slack".to_string(),
+            methods: vec!["POST".to_string()],
+            require_secret: false,
+        }];
+
+        router.register(channel, endpoints, None, None).await;
+        router.register_hmac_secret("slack", "signing-secret").await;
+
+        // Secret should exist
+        assert!(router.get_hmac_secret("slack").await.is_some());
+
+        // Unregister
+        router.unregister("slack").await;
+
+        // Secret should be gone
+        assert!(router.get_hmac_secret("slack").await.is_none());
+    }
+
+    // ── Category 4: Router Signature Key Management ─────────────────────
 
     #[tokio::test]
     async fn test_register_and_get_signature_key() {
@@ -1163,4 +1288,215 @@ mod tests {
             "Valid secret + valid signature should not return 401"
         );
     }
+
+    // ── HMAC-SHA256 Webhook Signature Tests ────────────────────────────
+
+    /// Helper to create a router with a registered channel at /webhook/slack.
+    async fn setup_slack_router() -> (Arc<WasmChannelRouter>, AxumRouter) {
+        let wasm_router = Arc::new(WasmChannelRouter::new());
+        let channel = create_test_channel("slack");
+
+        let endpoints = vec![RegisteredEndpoint {
+            channel_name: "slack".to_string(),
+            path: "/webhook/slack".to_string(),
+            methods: vec!["POST".to_string()],
+            require_secret: false,
+        }];
+
+        wasm_router.register(channel, endpoints, None, None).await;
+
+        let app = create_wasm_channel_router(wasm_router.clone(), None);
+        (wasm_router, app)
+    }
+
+    /// Helper: compute expected Slack signature for testing.
+    fn slack_signature(signing_secret: &str, timestamp: &str, body: &[u8]) -> String {
+        use hmac::{Hmac, Mac};
+        use sha2::Sha256;
+
+        let mut basestring = Vec::new();
+        basestring.extend_from_slice(b"v0:");
+        basestring.extend_from_slice(timestamp.as_bytes());
+        basestring.push(b':');
+        basestring.extend_from_slice(body);
+
+        let mut mac = Hmac::<Sha256>::new_from_slice(signing_secret.as_bytes()).unwrap();
+        mac.update(&basestring);
+        let computed = mac.finalize().into_bytes();
+        format!("v0={}", hex::encode(computed))
+    }
+
+    #[tokio::test]
+    async fn test_webhook_hmac_rejects_missing_sig_headers() {
+        let (wasm_router, app) = setup_slack_router().await;
+
+        wasm_router
+            .register_hmac_secret("slack", "my-signing-secret")
+            .await;
+
+        // Send request without HMAC signature headers
+        let req = Request::builder()
+            .method("POST")
+            .uri("/webhook/slack")
+            .header("content-type", "application/json")
+            .body(Body::from("token=xyzz0WbapA4vBCDEFasx0q6G"))
+            .unwrap();
+
+        let resp = app.oneshot(req).await.unwrap();
+        assert_eq!(
+            resp.status(),
+            StatusCode::UNAUTHORIZED,
+            "Missing HMAC signature headers should return 401"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_webhook_hmac_rejects_invalid_signature() {
+        let (wasm_router, app) = setup_slack_router().await;
+
+        wasm_router
+            .register_hmac_secret("slack", "my-signing-secret")
+            .await;
+
+        let req = Request::builder()
+            .method("POST")
+            .uri("/webhook/slack")
+            .header("content-type", "application/json")
+            .header("x-slack-request-timestamp", "1234567890")
+            .header("x-slack-signature", "v0=deadbeefdeadbeef")
+            .body(Body::from("token=xyzz0WbapA4vBCDEFasx0q6G"))
+            .unwrap();
+
+        let resp = app.oneshot(req).await.unwrap();
+        assert_eq!(
+            resp.status(),
+            StatusCode::UNAUTHORIZED,
+            "Invalid HMAC signature should return 401"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_webhook_hmac_accepts_valid_signature() {
+        let (wasm_router, app) = setup_slack_router().await;
+
+        let signing_secret = "my-signing-secret";
+        wasm_router
+            .register_hmac_secret("slack", signing_secret)
+            .await;
+
+        let now_secs = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+        let timestamp = now_secs.to_string();
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        let signature = slack_signature(signing_secret, &timestamp, body);
+
+        let req = Request::builder()
+            .method("POST")
+            .uri("/webhook/slack")
+            .header("content-type", "application/json")
+            .header("x-slack-request-timestamp", &timestamp)
+            .header("x-slack-signature", &signature)
+            .body(Body::from(&body[..]))
+            .unwrap();
+
+        let resp = app.oneshot(req).await.unwrap();
+        // Should NOT be 401 — signature is valid (may be 500 since no WASM module)
+        assert_ne!(
+            resp.status(),
+            StatusCode::UNAUTHORIZED,
+            "Valid HMAC signature should not return 401"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_webhook_hmac_skips_check_for_no_secret() {
+        let (_wasm_router, app) = setup_slack_router().await;
+
+        // No HMAC secret registered — should not require signature
+        let req = Request::builder()
+            .method("POST")
+            .uri("/webhook/slack")
+            .header("content-type", "application/json")
+            .body(Body::from("token=xyzz0WbapA4vBCDEFasx0q6G"))
+            .unwrap();
+
+        let resp = app.oneshot(req).await.unwrap();
+        // Should NOT be 401 (may be 500 since no WASM module, but not auth failure)
+        assert_ne!(
+            resp.status(),
+            StatusCode::UNAUTHORIZED,
+            "No HMAC secret registered — should skip check"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_webhook_hmac_uses_correct_body() {
+        let (wasm_router, app) = setup_slack_router().await;
+
+        let signing_secret = "my-signing-secret";
+        wasm_router
+            .register_hmac_secret("slack", signing_secret)
+            .await;
+
+        let timestamp = "1234567890";
+        let body_a = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+        let body_b = b"token=MODIFIED";
+
+        // Sign body A
+        let signature = slack_signature(signing_secret, timestamp, body_a);
+
+        // But send body B
+        let req = Request::builder()
+            .method("POST")
+            .uri("/webhook/slack")
+            .header("content-type", "application/json")
+            .header("x-slack-request-timestamp", timestamp)
+            .header("x-slack-signature", &signature)
+            .body(Body::from(&body_b[..]))
+            .unwrap();
+
+        let resp = app.oneshot(req).await.unwrap();
+        assert_eq!(
+            resp.status(),
+            StatusCode::UNAUTHORIZED,
+            "Signature for different body should return 401"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_webhook_hmac_uses_correct_timestamp() {
+        let (wasm_router, app) = setup_slack_router().await;
+
+        let signing_secret = "my-signing-secret";
+        wasm_router
+            .register_hmac_secret("slack", signing_secret)
+            .await;
+
+        let timestamp_a = "1234567890";
+        let timestamp_b = "9999999999";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        // Sign with timestamp A
+        let signature = slack_signature(signing_secret, timestamp_a, body);
+
+        // But send timestamp B in the header
+        let req = Request::builder()
+            .method("POST")
+            .uri("/webhook/slack")
+            .header("content-type", "application/json")
+            .header("x-slack-request-timestamp", timestamp_b)
+            .header("x-slack-signature", &signature)
+            .body(Body::from(&body[..]))
+            .unwrap();
+
+        let resp = app.oneshot(req).await.unwrap();
+        assert_eq!(
+            resp.status(),
+            StatusCode::UNAUTHORIZED,
+            "Signature with mismatched timestamp should return 401"
+        );
+    }
 }

src/channels/wasm/schema.rs

@@ -51,6 +51,14 @@ use crate::tools::wasm::{CapabilitiesFile as ToolCapabilitiesFile, RateLimitSche
 /// Root schema for a channel capabilities JSON file.
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct ChannelCapabilitiesFile {
+    /// Extension version (semver).
+    #[serde(default)]
+    pub version: Option<String>,
+
+    /// WIT interface version this channel was compiled against (semver).
+    #[serde(default)]
+    pub wit_version: Option<String>,
+
     /// File type, must be "channel".
     #[serde(default = "default_type")]
     pub r#type: String,
@@ -154,6 +162,18 @@ impl ChannelCapabilitiesFile {
             .and_then(|w| w.signature_key_secret_name.as_deref())
     }
 
+    /// Get the HMAC-SHA256 signing secret name for this channel.
+    ///
+    /// Returns the secret name declared in `webhook.hmac_secret_name`,
+    /// used to look up the HMAC signing secret in the secrets store (Slack-style).
+    pub fn hmac_secret_name(&self) -> Option<&str> {
+        self.capabilities
+            .channel
+            .as_ref()
+            .and_then(|c| c.webhook.as_ref())
+            .and_then(|w| w.hmac_secret_name.as_deref())
+    }
+
     /// Get the webhook secret name for this channel.
     ///
     /// Returns the configured secret name or defaults to "{channel_name}_webhook_secret".
@@ -278,6 +298,10 @@ pub struct WebhookSchema {
     /// for signature verification (e.g., Discord interaction verification).
     #[serde(default)]
     pub signature_key_secret_name: Option<String>,
+
+    /// Secret name in secrets store for HMAC-SHA256 signing (Slack-style).
+    #[serde(default)]
+    pub hmac_secret_name: Option<String>,
 }
 
 /// Setup configuration schema.

src/channels/wasm/signature.rs

@@ -1,9 +1,11 @@
-//! Discord Ed25519 signature verification.
+//! Webhook signature verification (Discord Ed25519 and Slack HMAC-SHA256).
 //!
-//! Validates `X-Signature-Ed25519` and `X-Signature-Timestamp` headers
-//! on incoming Discord interaction webhooks, per Discord's security requirements.
+//! Validates request signatures for incoming webhooks:
+//! - Discord: `X-Signature-Ed25519` and `X-Signature-Timestamp` headers
+//! - Slack: `X-Slack-Signature` and `X-Slack-Request-Timestamp` headers
 //!
 //! See: <https://discord.com/developers/docs/interactions/overview#validating-security-request-headers>
+//! See: <https://api.slack.com/authentication/verifying-requests-from-slack>
 
 /// Verify a Discord interaction signature.
 ///
@@ -50,6 +52,60 @@ pub fn verify_discord_signature(
     verifying_key.verify_strict(&message, &signature).is_ok()
 }
 
+/// Verify a Slack webhook signature using HMAC-SHA256.
+///
+/// Slack signs each webhook request with HMAC-SHA256 using:
+/// - basestring = `"v0:" + timestamp + ":" + body`
+/// - signature = hex-encoded HMAC-SHA256(signing_secret, basestring)
+/// - header = `"v0=" + signature` (in `X-Slack-Signature` header)
+///
+/// Includes staleness check: rejects requests with timestamps older than 5 minutes.
+/// Returns `true` if the signature is valid, `false` on any error
+/// (bad timing, mismatched signature, invalid format, etc.).
+pub fn verify_slack_signature(
+    signing_secret: &str,
+    timestamp: &str,
+    body: &[u8],
+    signature_header: &str,
+    now_secs: i64,
+) -> bool {
+    use hmac::{Hmac, Mac};
+    use sha2::Sha256;
+
+    // 1. Parse and check staleness (5-minute window)
+    let ts: i64 = match timestamp.parse() {
+        Ok(v) => v,
+        Err(_) => return false,
+    };
+    if (now_secs - ts).abs() > 300 {
+        return false;
+    }
+
+    // 2. Build the basestring: "v0:{timestamp}:{body}"
+    let mut basestring = Vec::with_capacity(3 + timestamp.len() + 1 + body.len());
+    basestring.extend_from_slice(b"v0:");
+    basestring.extend_from_slice(timestamp.as_bytes());
+    basestring.push(b':');
+    basestring.extend_from_slice(body);
+
+    // 3. Compute HMAC-SHA256
+    let mut mac = match Hmac::<Sha256>::new_from_slice(signing_secret.as_bytes()) {
+        Ok(m) => m,
+        Err(_) => return false,
+    };
+    mac.update(&basestring);
+    let computed = mac.finalize().into_bytes();
+    let computed_hex = hex::encode(computed);
+    let expected = format!("v0={}", computed_hex);
+
+    // 4. Constant-time compare (avoids timing side-channels)
+    use subtle::ConstantTimeEq;
+    expected
+        .as_bytes()
+        .ct_eq(signature_header.as_bytes())
+        .into()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -338,4 +394,264 @@ mod tests {
             "Negative timestamp should be rejected"
         );
     }
+
+    // ── Category: HMAC-SHA256 Signature Verification (Slack) ────────────
+
+    /// Helper: compute expected Slack signature for a given secret, timestamp, and body.
+    fn sign_slack_message(signing_secret: &str, timestamp: &str, body: &[u8]) -> String {
+        use hmac::{Hmac, Mac};
+        use sha2::Sha256;
+
+        let mut basestring = Vec::new();
+        basestring.extend_from_slice(b"v0:");
+        basestring.extend_from_slice(timestamp.as_bytes());
+        basestring.push(b':');
+        basestring.extend_from_slice(body);
+
+        let mut mac = Hmac::<Sha256>::new_from_slice(signing_secret.as_bytes()).unwrap();
+        mac.update(&basestring);
+        let computed = mac.finalize().into_bytes();
+        format!("v0={}", hex::encode(computed))
+    }
+
+    const SLACK_TEST_TS: i64 = 1234567890;
+
+    #[test]
+    fn test_slack_valid_signature_succeeds() {
+        let signing_secret = "my-signing-secret";
+        let timestamp = "1234567890";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G&team_id=T1DC2JH3J";
+
+        let signature = sign_slack_message(signing_secret, timestamp, body);
+        assert!(verify_slack_signature(
+            signing_secret,
+            timestamp,
+            body,
+            &signature,
+            SLACK_TEST_TS
+        ));
+    }
+
+    #[test]
+    fn test_slack_tampered_body_fails() {
+        let signing_secret = "my-signing-secret";
+        let timestamp = "1234567890";
+        let original_body = b"token=xyzz0WbapA4vBCDEFasx0q6G&team_id=T1DC2JH3J";
+        let tampered_body = b"token=MODIFIED&team_id=T1DC2JH3J";
+
+        let signature = sign_slack_message(signing_secret, timestamp, original_body);
+        assert!(
+            !verify_slack_signature(
+                signing_secret,
+                timestamp,
+                tampered_body,
+                &signature,
+                SLACK_TEST_TS
+            ),
+            "Signature for different body should fail"
+        );
+    }
+
+    #[test]
+    fn test_slack_tampered_timestamp_fails() {
+        let signing_secret = "my-signing-secret";
+        let timestamp = "1234567890";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G&team_id=T1DC2JH3J";
+
+        let signature = sign_slack_message(signing_secret, timestamp, body);
+        assert!(
+            !verify_slack_signature(
+                signing_secret,
+                "9999999999", // Different timestamp in signature
+                body,
+                &signature,
+                SLACK_TEST_TS
+            ),
+            "Signature with wrong timestamp should fail"
+        );
+    }
+
+    #[test]
+    fn test_slack_tampered_signature_fails() {
+        let signing_secret = "my-signing-secret";
+        let timestamp = "1234567890";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G&team_id=T1DC2JH3J";
+
+        let signature = sign_slack_message(signing_secret, timestamp, body);
+        // Flip a byte in the signature hex (change first char after "v0=")
+        let chars: Vec<char> = signature.chars().collect();
+        let mut new_chars = chars.clone();
+        if chars.len() > 3 {
+            new_chars[3] = if chars[3] == 'a' { 'b' } else { 'a' };
+        }
+        let modified_sig: String = new_chars.iter().collect();
+
+        assert!(
+            !verify_slack_signature(
+                signing_secret,
+                timestamp,
+                body,
+                &modified_sig,
+                SLACK_TEST_TS
+            ),
+            "Tampered signature should fail"
+        );
+    }
+
+    #[test]
+    fn test_slack_stale_timestamp_rejected() {
+        let signing_secret = "my-signing-secret";
+        let timestamp = "1234567890";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        let signature = sign_slack_message(signing_secret, timestamp, body);
+        // now_secs is 400 seconds after timestamp — too stale
+        assert!(
+            !verify_slack_signature(
+                signing_secret,
+                timestamp,
+                body,
+                &signature,
+                SLACK_TEST_TS + 400
+            ),
+            "Stale timestamp (400s old) should be rejected"
+        );
+    }
+
+    #[test]
+    fn test_slack_future_timestamp_rejected() {
+        let signing_secret = "my-signing-secret";
+        let timestamp = "1234567890";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        let signature = sign_slack_message(signing_secret, timestamp, body);
+        // now_secs is 400 seconds before timestamp — future
+        assert!(
+            !verify_slack_signature(
+                signing_secret,
+                timestamp,
+                body,
+                &signature,
+                SLACK_TEST_TS - 400
+            ),
+            "Future timestamp (400s ahead) should be rejected"
+        );
+    }
+
+    #[test]
+    fn test_slack_boundary_300s_accepted() {
+        let signing_secret = "my-signing-secret";
+        let timestamp = "1234567890";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        let signature = sign_slack_message(signing_secret, timestamp, body);
+        // Exactly 300 seconds difference — should be accepted
+        assert!(
+            verify_slack_signature(
+                signing_secret,
+                timestamp,
+                body,
+                &signature,
+                SLACK_TEST_TS + 300
+            ),
+            "Timestamp exactly 300s old should be accepted"
+        );
+    }
+
+    #[test]
+    fn test_slack_boundary_301s_rejected() {
+        let signing_secret = "my-signing-secret";
+        let timestamp = "1234567890";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        let signature = sign_slack_message(signing_secret, timestamp, body);
+        // 301 seconds difference — should be rejected
+        assert!(
+            !verify_slack_signature(
+                signing_secret,
+                timestamp,
+                body,
+                &signature,
+                SLACK_TEST_TS + 301
+            ),
+            "Timestamp 301s old should be rejected"
+        );
+    }
+
+    #[test]
+    fn test_slack_non_numeric_timestamp_rejected() {
+        let signing_secret = "my-signing-secret";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        assert!(
+            !verify_slack_signature(signing_secret, "not-a-number", body, "v0=abc123", 0),
+            "Non-numeric timestamp should be rejected"
+        );
+    }
+
+    #[test]
+    fn test_slack_missing_v0_prefix_fails() {
+        let signing_secret = "my-signing-secret";
+        let timestamp = "1234567890";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        let signature = sign_slack_message(signing_secret, timestamp, body);
+        // Remove the "v0=" prefix
+        let bad_sig = signature.strip_prefix("v0=").unwrap_or(&signature);
+
+        assert!(
+            !verify_slack_signature(signing_secret, timestamp, body, bad_sig, SLACK_TEST_TS),
+            "Missing v0= prefix should fail"
+        );
+    }
+
+    #[test]
+    fn test_slack_wrong_signing_secret_fails() {
+        let secret_a = "secret-a";
+        let secret_b = "secret-b";
+        let timestamp = "1234567890";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        let signature = sign_slack_message(secret_a, timestamp, body);
+        // Try to verify with a different secret
+        assert!(
+            !verify_slack_signature(secret_b, timestamp, body, &signature, SLACK_TEST_TS),
+            "Signature from different secret should fail"
+        );
+    }
+
+    #[test]
+    fn test_slack_empty_body_valid() {
+        let signing_secret = "my-signing-secret";
+        let timestamp = "1234567890";
+        let body = b"";
+
+        let signature = sign_slack_message(signing_secret, timestamp, body);
+        assert!(
+            verify_slack_signature(signing_secret, timestamp, body, &signature, SLACK_TEST_TS),
+            "Empty body with valid signature should succeed"
+        );
+    }
+
+    #[test]
+    fn test_slack_negative_timestamp_rejected() {
+        let signing_secret = "my-signing-secret";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        assert!(
+            !verify_slack_signature(signing_secret, "-1", body, "v0=abc123", 0),
+            "Negative timestamp should be rejected"
+        );
+    }
+
+    #[test]
+    fn test_slack_empty_timestamp_rejected() {
+        let signing_secret = "my-signing-secret";
+        let body = b"token=xyzz0WbapA4vBCDEFasx0q6G";
+
+        assert!(
+            !verify_slack_signature(signing_secret, "", body, "v0=abc123", 0),
+            "Empty timestamp should be rejected"
+        );
+    }
 }

src/channels/wasm/storage.rs

@@ -0,0 +1,690 @@
+//! WASM channel binary storage with integrity verification.
+//!
+//! Stores compiled WASM channels in the database with BLAKE3 hash verification.
+//! Mirrors the pattern in `crate::tools::wasm::storage` but without capabilities table.
+//!
+//! # Storage Flow
+//!
+//! ```text
+//! WASM bytes ──► BLAKE3 hash ──► Store in database
+//!                    │               (binary + hash)
+//!                    │
+//!                    └──► Later: Load ──► Verify hash ──► Return bytes
+//! ```
+
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+#[cfg(feature = "postgres")]
+use deadpool_postgres::Pool;
+use uuid::Uuid;
+
+use crate::tools::wasm::storage::{compute_binary_hash, verify_binary_integrity};
+
+/// A stored WASM channel (metadata only, no binary).
+#[derive(Debug, Clone)]
+pub struct StoredWasmChannel {
+    pub id: Uuid,
+    pub user_id: String,
+    pub name: String,
+    pub version: String,
+    pub wit_version: String,
+    pub description: String,
+    pub capabilities_json: String,
+    pub status: String,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
+
+/// Full channel data including binary.
+#[derive(Debug)]
+pub struct StoredWasmChannelWithBinary {
+    pub channel: StoredWasmChannel,
+    pub wasm_binary: Vec<u8>,
+    pub binary_hash: Vec<u8>,
+}
+
+/// Parameters for storing a new WASM channel.
+pub struct StoreChannelParams {
+    pub user_id: String,
+    pub name: String,
+    pub version: String,
+    pub wit_version: String,
+    pub description: String,
+    pub wasm_binary: Vec<u8>,
+    pub capabilities_json: String,
+}
+
+/// Error from WASM channel storage operations.
+#[derive(Debug, Clone, thiserror::Error)]
+pub enum WasmChannelStoreError {
+    #[error("Channel not found: {0}")]
+    NotFound(String),
+
+    #[error("Binary integrity check failed: hash mismatch")]
+    IntegrityCheckFailed,
+
+    #[error("Database error: {0}")]
+    Database(String),
+
+    #[error("Invalid data: {0}")]
+    InvalidData(String),
+}
+
+/// Trait for WASM channel storage.
+#[async_trait]
+pub trait WasmChannelStore: Send + Sync {
+    /// Store a new WASM channel.
+    async fn store(
+        &self,
+        params: StoreChannelParams,
+    ) -> Result<StoredWasmChannel, WasmChannelStoreError>;
+
+    /// Get channel metadata (without binary).
+    async fn get(
+        &self,
+        user_id: &str,
+        name: &str,
+    ) -> Result<StoredWasmChannel, WasmChannelStoreError>;
+
+    /// Get channel with binary (verifies integrity).
+    async fn get_with_binary(
+        &self,
+        user_id: &str,
+        name: &str,
+    ) -> Result<StoredWasmChannelWithBinary, WasmChannelStoreError>;
+
+    /// List all channels for a user.
+    async fn list(&self, user_id: &str) -> Result<Vec<StoredWasmChannel>, WasmChannelStoreError>;
+
+    /// Delete a channel.
+    async fn delete(&self, user_id: &str, name: &str) -> Result<bool, WasmChannelStoreError>;
+}
+
+// ==================== PostgreSQL implementation ====================
+
+/// PostgreSQL implementation of WasmChannelStore.
+#[cfg(feature = "postgres")]
+pub struct PostgresWasmChannelStore {
+    pool: Pool,
+}
+
+#[cfg(feature = "postgres")]
+impl PostgresWasmChannelStore {
+    pub fn new(pool: Pool) -> Self {
+        Self { pool }
+    }
+}
+
+#[cfg(feature = "postgres")]
+#[async_trait]
+impl WasmChannelStore for PostgresWasmChannelStore {
+    async fn store(
+        &self,
+        params: StoreChannelParams,
+    ) -> Result<StoredWasmChannel, WasmChannelStoreError> {
+        let mut client = self
+            .pool
+            .get()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        let binary_hash = compute_binary_hash(&params.wasm_binary);
+        let id = Uuid::new_v4();
+        let now = Utc::now();
+
+        // Wrap delete + insert in a transaction for atomicity
+        let tx = client
+            .transaction()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        // Delete any existing version for this (user_id, name) — upgrade-in-place
+        tx.execute(
+            "DELETE FROM wasm_channels WHERE user_id = $1 AND name = $2",
+            &[&params.user_id, &params.name],
+        )
+        .await
+        .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        let row = tx
+            .query_one(
+                r#"
+                INSERT INTO wasm_channels (
+                    id, user_id, name, version, wit_version, description, wasm_binary, binary_hash,
+                    capabilities_json, status, created_at, updated_at
+                )
+                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, 'active', $10, $10)
+                RETURNING id, user_id, name, version, wit_version, description,
+                          capabilities_json, status, created_at, updated_at
+                "#,
+                &[
+                    &id,
+                    &params.user_id,
+                    &params.name,
+                    &params.version,
+                    &params.wit_version,
+                    &params.description,
+                    &params.wasm_binary,
+                    &binary_hash,
+                    &params.capabilities_json,
+                    &now,
+                ],
+            )
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        let channel = pg_row_to_channel(&row)?;
+
+        tx.commit()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        Ok(channel)
+    }
+
+    async fn get(
+        &self,
+        user_id: &str,
+        name: &str,
+    ) -> Result<StoredWasmChannel, WasmChannelStoreError> {
+        let client = self
+            .pool
+            .get()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        let row = client
+            .query_opt(
+                r#"
+                SELECT id, user_id, name, version, wit_version, description,
+                       capabilities_json, status, created_at, updated_at
+                FROM wasm_channels
+                WHERE user_id = $1 AND name = $2
+                "#,
+                &[&user_id, &name],
+            )
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        match row {
+            Some(r) => pg_row_to_channel(&r),
+            None => Err(WasmChannelStoreError::NotFound(name.to_string())),
+        }
+    }
+
+    async fn get_with_binary(
+        &self,
+        user_id: &str,
+        name: &str,
+    ) -> Result<StoredWasmChannelWithBinary, WasmChannelStoreError> {
+        let client = self
+            .pool
+            .get()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        let row = client
+            .query_opt(
+                r#"
+                SELECT id, user_id, name, version, wit_version, description,
+                       wasm_binary, binary_hash,
+                       capabilities_json, status, created_at, updated_at
+                FROM wasm_channels
+                WHERE user_id = $1 AND name = $2
+                "#,
+                &[&user_id, &name],
+            )
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        match row {
+            Some(r) => {
+                let wasm_binary: Vec<u8> = r.get("wasm_binary");
+                let binary_hash: Vec<u8> = r.get("binary_hash");
+
+                if !verify_binary_integrity(&wasm_binary, &binary_hash) {
+                    tracing::error!(
+                        user_id = user_id,
+                        name = name,
+                        "WASM channel binary integrity check failed"
+                    );
+                    return Err(WasmChannelStoreError::IntegrityCheckFailed);
+                }
+
+                let channel = StoredWasmChannel {
+                    id: r.get("id"),
+                    user_id: r.get("user_id"),
+                    name: r.get("name"),
+                    version: r.get("version"),
+                    wit_version: r.get("wit_version"),
+                    description: r.get("description"),
+                    capabilities_json: r.get("capabilities_json"),
+                    status: r.get("status"),
+                    created_at: r.get("created_at"),
+                    updated_at: r.get("updated_at"),
+                };
+
+                Ok(StoredWasmChannelWithBinary {
+                    channel,
+                    wasm_binary,
+                    binary_hash,
+                })
+            }
+            None => Err(WasmChannelStoreError::NotFound(name.to_string())),
+        }
+    }
+
+    async fn list(&self, user_id: &str) -> Result<Vec<StoredWasmChannel>, WasmChannelStoreError> {
+        let client = self
+            .pool
+            .get()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        let rows = client
+            .query(
+                r#"
+                SELECT id, user_id, name, version, wit_version, description,
+                       capabilities_json, status, created_at, updated_at
+                FROM wasm_channels
+                WHERE user_id = $1
+                ORDER BY name
+                "#,
+                &[&user_id],
+            )
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        rows.into_iter().map(|r| pg_row_to_channel(&r)).collect()
+    }
+
+    async fn delete(&self, user_id: &str, name: &str) -> Result<bool, WasmChannelStoreError> {
+        let client = self
+            .pool
+            .get()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        let result = client
+            .execute(
+                "DELETE FROM wasm_channels WHERE user_id = $1 AND name = $2",
+                &[&user_id, &name],
+            )
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        Ok(result > 0)
+    }
+}
+
+#[cfg(feature = "postgres")]
+fn pg_row_to_channel(
+    row: &tokio_postgres::Row,
+) -> Result<StoredWasmChannel, WasmChannelStoreError> {
+    Ok(StoredWasmChannel {
+        id: row.get("id"),
+        user_id: row.get("user_id"),
+        name: row.get("name"),
+        version: row.get("version"),
+        wit_version: row.get("wit_version"),
+        description: row.get("description"),
+        capabilities_json: row.get("capabilities_json"),
+        status: row.get("status"),
+        created_at: row.get("created_at"),
+        updated_at: row.get("updated_at"),
+    })
+}
+
+// ==================== libSQL implementation ====================
+
+/// libSQL/Turso implementation of WasmChannelStore.
+///
+/// Holds an `Arc<Database>` handle and creates a fresh connection per operation,
+/// matching the connection-per-request pattern used by the main `LibSqlBackend`.
+#[cfg(feature = "libsql")]
+pub struct LibSqlWasmChannelStore {
+    db: std::sync::Arc<libsql::Database>,
+}
+
+#[cfg(feature = "libsql")]
+impl LibSqlWasmChannelStore {
+    pub fn new(db: std::sync::Arc<libsql::Database>) -> Self {
+        Self { db }
+    }
+
+    async fn connect(&self) -> Result<libsql::Connection, WasmChannelStoreError> {
+        let conn = self
+            .db
+            .connect()
+            .map_err(|e| WasmChannelStoreError::Database(format!("Connection failed: {}", e)))?;
+        conn.query("PRAGMA busy_timeout = 5000", ())
+            .await
+            .map_err(|e| {
+                WasmChannelStoreError::Database(format!("Failed to set busy_timeout: {}", e))
+            })?;
+        Ok(conn)
+    }
+}
+
+#[cfg(feature = "libsql")]
+#[async_trait]
+impl WasmChannelStore for LibSqlWasmChannelStore {
+    async fn store(
+        &self,
+        params: StoreChannelParams,
+    ) -> Result<StoredWasmChannel, WasmChannelStoreError> {
+        let binary_hash = compute_binary_hash(&params.wasm_binary);
+        let id = Uuid::new_v4();
+        let now = Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true);
+
+        let conn = self.connect().await?;
+        let tx = conn
+            .transaction()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        // Delete any existing version for this (user_id, name) — upgrade-in-place
+        tx.execute(
+            "DELETE FROM wasm_channels WHERE user_id = ?1 AND name = ?2",
+            libsql::params![params.user_id.as_str(), params.name.as_str()],
+        )
+        .await
+        .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        tx.execute(
+            r#"
+                INSERT INTO wasm_channels (
+                    id, user_id, name, version, wit_version, description, wasm_binary, binary_hash,
+                    capabilities_json, status, created_at, updated_at
+                )
+                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, 'active', ?10, ?10)
+                "#,
+            libsql::params![
+                id.to_string(),
+                params.user_id.as_str(),
+                params.name.as_str(),
+                params.version.as_str(),
+                params.wit_version.as_str(),
+                params.description.as_str(),
+                libsql::Value::Blob(params.wasm_binary),
+                libsql::Value::Blob(binary_hash),
+                params.capabilities_json.as_str(),
+                now.as_str(),
+            ],
+        )
+        .await
+        .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        // Read back the row within the same transaction
+        let mut rows = tx
+            .query(
+                r#"
+                SELECT id, user_id, name, version, wit_version, description,
+                       capabilities_json, status, created_at, updated_at
+                FROM wasm_channels
+                WHERE user_id = ?1 AND name = ?2
+                "#,
+                libsql::params![params.user_id.as_str(), params.name.as_str()],
+            )
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        let row = rows
+            .next()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?
+            .ok_or_else(|| {
+                WasmChannelStoreError::Database("Insert succeeded but row not found".into())
+            })?;
+
+        let channel = libsql_row_to_channel(&row)?;
+
+        tx.commit()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        Ok(channel)
+    }
+
+    async fn get(
+        &self,
+        user_id: &str,
+        name: &str,
+    ) -> Result<StoredWasmChannel, WasmChannelStoreError> {
+        let conn = self.connect().await?;
+        let mut rows = conn
+            .query(
+                r#"
+                SELECT id, user_id, name, version, wit_version, description,
+                       capabilities_json, status, created_at, updated_at
+                FROM wasm_channels
+                WHERE user_id = ?1 AND name = ?2
+                "#,
+                libsql::params![user_id, name],
+            )
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        match rows
+            .next()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?
+        {
+            Some(row) => libsql_row_to_channel(&row),
+            None => Err(WasmChannelStoreError::NotFound(name.to_string())),
+        }
+    }
+
+    async fn get_with_binary(
+        &self,
+        user_id: &str,
+        name: &str,
+    ) -> Result<StoredWasmChannelWithBinary, WasmChannelStoreError> {
+        let conn = self.connect().await?;
+        let mut rows = conn
+            .query(
+                r#"
+                SELECT id, user_id, name, version, wit_version, description,
+                       wasm_binary, binary_hash,
+                       capabilities_json, status, created_at, updated_at
+                FROM wasm_channels
+                WHERE user_id = ?1 AND name = ?2
+                "#,
+                libsql::params![user_id, name],
+            )
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        match rows
+            .next()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?
+        {
+            Some(row) => {
+                let wasm_binary: Vec<u8> = row
+                    .get(6)
+                    .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+                let binary_hash: Vec<u8> = row
+                    .get(7)
+                    .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+                if !verify_binary_integrity(&wasm_binary, &binary_hash) {
+                    tracing::error!(
+                        user_id = user_id,
+                        name = name,
+                        "WASM channel binary integrity check failed"
+                    );
+                    return Err(WasmChannelStoreError::IntegrityCheckFailed);
+                }
+
+                let channel = libsql_row_to_channel_with_offset(&row)?;
+
+                Ok(StoredWasmChannelWithBinary {
+                    channel,
+                    wasm_binary,
+                    binary_hash,
+                })
+            }
+            None => Err(WasmChannelStoreError::NotFound(name.to_string())),
+        }
+    }
+
+    async fn list(&self, user_id: &str) -> Result<Vec<StoredWasmChannel>, WasmChannelStoreError> {
+        let conn = self.connect().await?;
+        let mut rows = conn
+            .query(
+                r#"
+                SELECT id, user_id, name, version, wit_version, description,
+                       capabilities_json, status, created_at, updated_at
+                FROM wasm_channels
+                WHERE user_id = ?1
+                ORDER BY name
+                "#,
+                libsql::params![user_id],
+            )
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        let mut channels = Vec::new();
+        while let Some(row) = rows
+            .next()
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?
+        {
+            channels.push(libsql_row_to_channel(&row)?);
+        }
+        Ok(channels)
+    }
+
+    async fn delete(&self, user_id: &str, name: &str) -> Result<bool, WasmChannelStoreError> {
+        let conn = self.connect().await?;
+        let result = conn
+            .execute(
+                "DELETE FROM wasm_channels WHERE user_id = ?1 AND name = ?2",
+                libsql::params![user_id, name],
+            )
+            .await
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+        Ok(result > 0)
+    }
+}
+
+#[cfg(feature = "libsql")]
+#[allow(dead_code)]
+fn libsql_channel_opt_text(s: Option<&str>) -> libsql::Value {
+    match s {
+        Some(s) => libsql::Value::Text(s.to_string()),
+        None => libsql::Value::Null,
+    }
+}
+
+#[cfg(feature = "libsql")]
+fn libsql_channel_parse_ts(s: &str) -> Result<DateTime<Utc>, WasmChannelStoreError> {
+    if let Ok(dt) = chrono::DateTime::parse_from_rfc3339(s) {
+        return Ok(dt.with_timezone(&Utc));
+    }
+    if let Ok(ndt) = chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S%.f") {
+        return Ok(ndt.and_utc());
+    }
+    if let Ok(ndt) = chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S") {
+        return Ok(ndt.and_utc());
+    }
+    Err(WasmChannelStoreError::InvalidData(format!(
+        "unparseable timestamp: {:?}",
+        s
+    )))
+}
+
+/// Parse a channel row with standard column order (no binary columns).
+/// Columns: id(0), user_id(1), name(2), version(3), wit_version(4), description(5),
+///          capabilities_json(6), status(7), created_at(8), updated_at(9)
+#[cfg(feature = "libsql")]
+fn libsql_row_to_channel(row: &libsql::Row) -> Result<StoredWasmChannel, WasmChannelStoreError> {
+    let id_str: String = row
+        .get(0)
+        .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+    let created_at_str: String = row
+        .get(8)
+        .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+    let updated_at_str: String = row
+        .get(9)
+        .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+    Ok(StoredWasmChannel {
+        id: id_str
+            .parse()
+            .map_err(|e: uuid::Error| WasmChannelStoreError::InvalidData(e.to_string()))?,
+        user_id: row
+            .get(1)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        name: row
+            .get(2)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        version: row
+            .get(3)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        wit_version: row
+            .get(4)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        description: row
+            .get(5)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        capabilities_json: row
+            .get(6)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        status: row
+            .get(7)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        created_at: libsql_channel_parse_ts(&created_at_str)?,
+        updated_at: libsql_channel_parse_ts(&updated_at_str)?,
+    })
+}
+
+/// Parse a channel row when binary columns are present (get_with_binary query).
+/// Columns: id(0), user_id(1), name(2), version(3), wit_version(4), description(5),
+///          wasm_binary(6), binary_hash(7),
+///          capabilities_json(8), status(9), created_at(10), updated_at(11)
+#[cfg(feature = "libsql")]
+fn libsql_row_to_channel_with_offset(
+    row: &libsql::Row,
+) -> Result<StoredWasmChannel, WasmChannelStoreError> {
+    let id_str: String = row
+        .get(0)
+        .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+    let created_at_str: String = row
+        .get(10)
+        .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+    let updated_at_str: String = row
+        .get(11)
+        .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?;
+
+    Ok(StoredWasmChannel {
+        id: id_str
+            .parse()
+            .map_err(|e: uuid::Error| WasmChannelStoreError::InvalidData(e.to_string()))?,
+        user_id: row
+            .get(1)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        name: row
+            .get(2)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        version: row
+            .get(3)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        wit_version: row
+            .get(4)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        description: row
+            .get(5)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        capabilities_json: row
+            .get(8)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        status: row
+            .get(9)
+            .map_err(|e| WasmChannelStoreError::Database(e.to_string()))?,
+        created_at: libsql_channel_parse_ts(&created_at_str)?,
+        updated_at: libsql_channel_parse_ts(&updated_at_str)?,
+    })
+}

src/channels/wasm/wrapper.rs

@@ -933,8 +933,19 @@ impl WasmChannel {
         Self::add_host_functions(&mut linker)?;
 
         // Instantiate using the generated bindings
-        let instance = SandboxedChannel::instantiate(store, &component, &linker)
-            .map_err(|e| WasmChannelError::Instantiation(e.to_string()))?;
+        let instance = SandboxedChannel::instantiate(store, &component, &linker).map_err(|e| {
+            let msg = e.to_string();
+            if msg.contains("near:agent") || msg.contains("import") {
+                WasmChannelError::Instantiation(format!(
+                    "{msg}. This may indicate a WIT version mismatch — \
+                         the channel was compiled against a different WIT than the host supports \
+                         (host WIT: {}). Rebuild the channel against the current WIT.",
+                    crate::tools::wasm::WIT_CHANNEL_VERSION
+                ))
+            } else {
+                WasmChannelError::Instantiation(msg)
+            }
+        })?;
 
         Ok(instance)
     }

src/channels/web/mod.rs

@@ -63,13 +63,11 @@ impl GatewayChannel {
     /// If no auth token is configured, generates a random one and prints it.
     pub fn new(config: GatewayConfig) -> Self {
         let auth_token = config.auth_token.clone().unwrap_or_else(|| {
-            use rand::Rng;
-            let token: String = rand::thread_rng()
-                .sample_iter(&rand::distributions::Alphanumeric)
-                .take(32)
-                .map(char::from)
-                .collect();
-            token
+            use rand::RngCore;
+            use rand::rngs::OsRng;
+            let mut bytes = [0u8; 32];
+            OsRng.fill_bytes(&mut bytes);
+            bytes.iter().map(|b| format!("{b:02x}")).collect()
         });
 
         let state = Arc::new(GatewayState {

src/channels/web/server.rs

@@ -606,6 +606,12 @@ async fn chat_send_handler(
     State(state): State<Arc<GatewayState>>,
     Json(req): Json<SendMessageRequest>,
 ) -> Result<(StatusCode, Json<SendMessageResponse>), (StatusCode, String)> {
+    tracing::debug!(
+        "[chat_send_handler] Received message: content={:?}, thread_id={:?}",
+        req.content,
+        req.thread_id
+    );
+
     if !state.chat_rate_limiter.check() {
         return Err((
             StatusCode::TOO_MANY_REQUESTS,
@@ -621,6 +627,11 @@ async fn chat_send_handler(
     }
 
     let msg_id = msg.id;
+    tracing::debug!(
+        "[chat_send_handler] Created message id={}, content={:?}",
+        msg_id,
+        req.content
+    );
 
     let tx_guard = state.msg_tx.read().await;
     let tx = tx_guard.as_ref().ok_or((
@@ -628,6 +639,7 @@ async fn chat_send_handler(
         "Channel not started".to_string(),
     ))?;
 
+    tracing::debug!("[chat_send_handler] Sending message through channel");
     tx.send(msg).await.map_err(|_| {
         (
             StatusCode::INTERNAL_SERVER_ERROR,
@@ -635,6 +647,8 @@ async fn chat_send_handler(
         )
     })?;
 
+    tracing::debug!("[chat_send_handler] Message sent successfully, returning 202 ACCEPTED");
+
     Ok((
         StatusCode::ACCEPTED,
         Json(SendMessageResponse {
@@ -2300,11 +2314,17 @@ async fn gateway_status_handler(
         (None, None, None)
     };
 
+    let restart_enabled = std::env::var("IRONCLAW_IN_DOCKER")
+        .map(|v| v.to_lowercase() == "true")
+        .unwrap_or(false);
+
     Json(GatewayStatusResponse {
+        version: env!("CARGO_PKG_VERSION").to_string(),
         sse_connections,
         ws_connections,
         total_connections: sse_connections + ws_connections,
         uptime_secs,
+        restart_enabled,
         daily_cost,
         actions_this_hour,
         model_usage,
@@ -2321,10 +2341,12 @@ struct ModelUsageEntry {
 
 #[derive(serde::Serialize)]
 struct GatewayStatusResponse {
+    version: String,
     sse_connections: u64,
     ws_connections: u64,
     total_connections: u64,
     uptime_secs: u64,
+    restart_enabled: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
     daily_cost: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]

src/channels/web/static/app.js

@@ -133,6 +133,110 @@ function apiFetch(path, options) {
   });
 }
 
+// --- Restart Feature ---
+
+let isRestarting = false; // Track if we're currently restarting
+let restartEnabled = false; // Track if restart is available in this deployment
+
+function triggerRestart() {
+  if (!currentThreadId) {
+    alert('Please start a conversation first');
+    return;
+  }
+
+  // Show the confirmation modal
+  const confirmModal = document.getElementById('restart-confirm-modal');
+  confirmModal.style.display = 'flex';
+}
+
+function confirmRestart() {
+  if (!currentThreadId) {
+    alert('Please start a conversation first');
+    return;
+  }
+
+  // Hide confirmation modal
+  const confirmModal = document.getElementById('restart-confirm-modal');
+  confirmModal.style.display = 'none';
+
+  const restartBtn = document.getElementById('restart-btn');
+  const restartIcon = document.getElementById('restart-icon');
+
+  // Mark as restarting
+  isRestarting = true;
+  restartBtn.disabled = true;
+  if (restartIcon) restartIcon.classList.add('spinning');
+
+  // Show progress modal
+  const loaderEl = document.getElementById('restart-loader');
+  loaderEl.style.display = 'flex';
+
+  // Send restart command via chat
+  console.log('[confirmRestart] Sending /restart command to server');
+  apiFetch('/api/chat/send', {
+    method: 'POST',
+    body: {
+      content: '/restart',
+      thread_id: currentThreadId,
+    },
+  })
+    .then((response) => {
+      console.log('[confirmRestart] API call succeeded, response:', response);
+    })
+    .catch((err) => {
+      console.error('[confirmRestart] Restart request failed:', err);
+      addMessage('system', 'Restart failed: ' + err.message);
+      isRestarting = false;
+      restartBtn.disabled = false;
+      if (restartIcon) restartIcon.classList.remove('spinning');
+      loaderEl.style.display = 'none';
+    });
+}
+
+function cancelRestart() {
+  const confirmModal = document.getElementById('restart-confirm-modal');
+  confirmModal.style.display = 'none';
+}
+
+function tryShowRestartModal() {
+  // Defensive callback for when restart is detected in messages.
+  if (!isRestarting) {
+    isRestarting = true;
+    const restartBtn = document.getElementById('restart-btn');
+    const restartIcon = document.getElementById('restart-icon');
+    restartBtn.disabled = true;
+    if (restartIcon) restartIcon.classList.add('spinning');
+
+    // Show progress modal
+    const loaderEl = document.getElementById('restart-loader');
+    loaderEl.style.display = 'flex';
+  }
+}
+
+function updateRestartButtonVisibility() {
+  const restartBtn = document.getElementById('restart-btn');
+  if (restartBtn) {
+    restartBtn.style.display = restartEnabled ? 'block' : 'none';
+  }
+}
+
+function startGatewayStatusPolling() {
+  fetchGatewayStatus();
+  // Poll every 5 seconds
+  setInterval(fetchGatewayStatus, 5000);
+}
+
+function fetchGatewayStatus() {
+  apiFetch('/api/gateway/status')
+    .then((data) => {
+      restartEnabled = data.restart_enabled || false;
+      updateRestartButtonVisibility();
+    })
+    .catch((err) => {
+      console.warn('[gateway status] Failed to fetch:', err);
+    });
+}
+
 // --- SSE ---
 
 function connectSSE() {
@@ -143,6 +247,18 @@ function connectSSE() {
   eventSource.onopen = () => {
     document.getElementById('sse-dot').classList.remove('disconnected');
     document.getElementById('sse-status').textContent = 'Connected';
+
+    // If we were restarting, close the modal and reset button now that server is back
+    if (isRestarting) {
+      const loaderEl = document.getElementById('restart-loader');
+      if (loaderEl) loaderEl.style.display = 'none';
+      const restartBtn = document.getElementById('restart-btn');
+      const restartIcon = document.getElementById('restart-icon');
+      if (restartBtn) restartBtn.disabled = false;
+      if (restartIcon) restartIcon.classList.remove('spinning');
+      isRestarting = false;
+    }
+
     if (sseHasConnectedBefore && currentThreadId) {
       finalizeActivityGroup();
       loadHistory();
@@ -163,6 +279,11 @@ function connectSSE() {
     enableChatInput();
     // Refresh thread list so new titles appear after first message
     loadThreads();
+
+    // Show restart modal if the response indicates restart was initiated
+    if (data.content && data.content.toLowerCase().includes('restart initiated')) {
+      setTimeout(() => tryShowRestartModal(), 500);
+    }
   });
 
   eventSource.addEventListener('thinking', (e) => {
@@ -181,6 +302,11 @@ function connectSSE() {
     const data = JSON.parse(e.data);
     if (!isCurrentThread(data.thread_id)) return;
     completeToolCard(data.name, data.success, data.error, data.parameters);
+
+    // Show restart modal only when the restart tool succeeds
+    if (data.name.toLowerCase() === 'restart' && data.success) {
+      setTimeout(() => tryShowRestartModal(), 500);
+    }
   });
 
   eventSource.addEventListener('tool_result', (e) => {
@@ -877,7 +1003,7 @@ function showAuthCard(data) {
     oauthBtn.className = 'auth-oauth';
     oauthBtn.textContent = 'Authenticate with ' + data.extension_name;
     oauthBtn.addEventListener('click', () => {
-      window.open(data.auth_url, '_blank', 'width=600,height=700');
+      openOAuthUrl(data.auth_url);
     });
     links.appendChild(oauthBtn);
   }
@@ -1795,7 +1921,7 @@ function renderAvailableExtensionCard(entry) {
         // OAuth popup if auth started during install (builtin creds)
         if (res.auth_url) {
           showToast('Opening authentication for ' + entry.display_name, 'info');
-          window.open(res.auth_url, '_blank', 'width=600,height=700');
+          openOAuthUrl(res.auth_url);
         }
         loadExtensions();
         // Auto-open configure for WASM channels
@@ -1953,7 +2079,7 @@ function renderExtensionCard(ext) {
     card.appendChild(url);
   }
 
-  if (ext.tools.length > 0) {
+  if (ext.tools && ext.tools.length > 0) {
     const tools = document.createElement('div');
     tools.className = 'ext-tools';
     tools.textContent = 'Tools: ' + ext.tools.join(', ');
@@ -2053,7 +2179,7 @@ function activateExtension(name) {
         // Even on success, the tool may need OAuth (e.g., WASM loaded but no token yet)
         if (res.auth_url) {
           showToast('Opening authentication for ' + name, 'info');
-          window.open(res.auth_url, '_blank', 'width=600,height=700');
+          openOAuthUrl(res.auth_url);
         }
         loadExtensions();
         return;
@@ -2061,7 +2187,7 @@ function activateExtension(name) {
 
       if (res.auth_url) {
         showToast('Opening authentication for ' + name, 'info');
-        window.open(res.auth_url, '_blank');
+        openOAuthUrl(res.auth_url);
       } else if (res.awaiting_token) {
         showConfigureModal(name);
       } else {
@@ -2203,20 +2329,21 @@ function submitConfigureModal(name, fields) {
     body: { secrets },
   })
     .then((res) => {
-      closeConfigureModal();
       if (res.success) {
+        closeConfigureModal();
         if (res.auth_url) {
           // OAuth flow started — open consent popup. The auth_completed SSE will
           // not arrive immediately (it fires after OAuth callback), so show a toast now.
           showToast('Opening OAuth authorization for ' + name, 'info');
-          window.open(res.auth_url, '_blank', 'width=600,height=700');
+          openOAuthUrl(res.auth_url);
           loadExtensions();
         }
         // For non-OAuth success: the server always broadcasts auth_completed SSE,
         // which will show the toast and refresh extensions — no need to do it here too.
       } else {
+        // Keep modal open so the user can correct their input and retry.
+        btns.forEach(function(b) { b.disabled = false; });
         showToast(res.message || 'Configuration failed', 'error');
-        loadExtensions();
       }
     })
     .catch((err) => {
@@ -2230,6 +2357,25 @@ function closeConfigureModal() {
   if (existing) existing.remove();
 }
 
+// Validate that a server-supplied OAuth URL is HTTPS before opening a popup.
+// Rejects javascript:, data:, and other non-HTTPS schemes to prevent URL-injection.
+// Uses the URL constructor to safely parse and validate the scheme, which also
+// handles non-string values (objects, null, etc.) that would throw on .startsWith().
+function openOAuthUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+    if (parsed.protocol !== 'https:') {
+      throw new Error('non-HTTPS protocol: ' + parsed.protocol);
+    }
+  } catch (e) {
+    console.warn('Blocked invalid/non-HTTPS OAuth URL:', url, e.message);
+    showToast('Invalid OAuth URL returned by server', 'error');
+    return;
+  }
+  window.open(parsed.href, '_blank', 'width=600,height=700');
+}
+
 // --- Pairing ---
 
 function loadPairingRequests(channel, container) {
@@ -3148,6 +3294,12 @@ function fetchGatewayStatus() {
     var popover = document.getElementById('gateway-popover');
     var html = '';
 
+    // Version
+    if (data.version) {
+      html += '<div class="gw-section-label">IronClaw v' + escapeHtml(data.version) + '</div>';
+      html += '<div class="gw-divider"></div>';
+    }
+
     // Connection info
     html += '<div class="gw-section-label">Connections</div>';
     html += '<div class="gw-stat"><span>SSE</span><span>' + (data.sse_connections || 0) + '</span></div>';

src/channels/web/static/index.html

@@ -33,6 +33,48 @@
     </div>
   </div>
 
+  <!-- Restart Confirmation Modal -->
+  <div id="restart-confirm-modal" class="restart-modal" style="display: none;">
+    <div class="restart-modal-overlay" onclick="cancelRestart()"></div>
+    <div class="restart-modal-content">
+      <div class="restart-modal-header">
+        <h2>Restart IronClaw Instance</h2>
+        <button class="restart-modal-close" onclick="cancelRestart()" title="Close">×</button>
+      </div>
+      <div class="restart-modal-body">
+        <p class="restart-modal-description">
+          Are you sure you want to restart the IronClaw instance? This will gracefully restart the process.
+        </p>
+        <div class="restart-modal-warning">
+          <span class="restart-modal-warning-icon">⚠️</span>
+          <p>Any in-progress jobs may be interrupted. The restart will complete within a few seconds.</p>
+        </div>
+      </div>
+      <div class="restart-modal-footer">
+        <button class="restart-modal-btn cancel" onclick="cancelRestart()">Cancel</button>
+        <button class="restart-modal-btn confirm" onclick="confirmRestart()">Confirm Restart</button>
+      </div>
+    </div>
+  </div>
+
+  <!-- Restart Progress Modal -->
+  <div id="restart-loader" class="restart-loader" style="display: none;">
+    <div class="restart-loader-overlay"></div>
+    <div class="restart-loader-content">
+      <div class="restart-spinner"></div>
+      <div class="restart-loader-text">
+        <p class="restart-title">Restarting IronClaw</p>
+        <p class="restart-subtitle">Please wait while the process restarts...</p>
+      </div>
+      <div class="restart-progress-bar">
+        <div class="restart-progress-fill"></div>
+      </div>
+      <p class="restart-modal-info">
+        Check the Logs tab for details after the restart completes.
+      </p>
+    </div>
+  </div>
+
   <!-- Main App (hidden until authenticated) -->
   <div id="app">
     <!-- Tab Bar -->
@@ -57,6 +99,14 @@
         <span id="sse-status">Connected</span>
         <div class="gateway-popover" id="gateway-popover"></div>
       </div>
+      <button class="restart-btn" id="restart-btn" onclick="triggerRestart()" title="Gracefully restart the process">
+        <svg id="restart-icon" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <path d="M23 4v6h-6"></path>
+          <path d="M1 20v-6h6"></path>
+          <path d="M3.51 9a9 9 0 0114.85-3.36M20.49 15a9 9 0 01-14.85 3.36"></path>
+        </svg>
+        <span>Restart</span>
+      </button>
     </div>
 
     <!-- Chat Tab -->

src/channels/web/static/style.css

@@ -259,6 +259,284 @@ body {
   white-space: nowrap;
 }
 
+/* Restart Button */
+.restart-btn {
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+  padding: 0.25rem 0.75rem;
+  border-radius: 0.5rem;
+  font-size: 0.8rem;
+  border: 1px solid;
+  border-color: #00d894;
+  color: #00d894;
+  background-color: transparent;
+  cursor: pointer;
+  transition: color 150ms, background-color 150ms, border-color 150ms;
+}
+
+.restart-btn:hover:not(:disabled) {
+  background-color: rgba(0, 216, 148, 0.1);
+}
+
+.restart-btn:disabled {
+  border-color: #333;
+  color: #666;
+  cursor: not-allowed;
+}
+
+.restart-btn:disabled:hover {
+  background-color: transparent;
+}
+
+.restart-btn svg {
+  flex-shrink: 0;
+  width: 13px;
+  height: 13px;
+}
+
+.restart-btn svg.spinning {
+  animation: spin-icon 1s linear infinite;
+}
+
+@keyframes spin-icon {
+  from { transform: rotate(0deg); }
+  to { transform: rotate(360deg); }
+}
+
+/* Restart Loader Overlay */
+.restart-loader {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 9999;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.restart-loader-overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  backdrop-filter: blur(4px);
+  z-index: -1;
+}
+
+.restart-loader-content {
+  position: relative;
+  z-index: 10000;
+  background-color: #1a1a1a;
+  border: 1px solid #333;
+  border-radius: 0.75rem;
+  box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+  width: 100%;
+  max-width: 28rem;
+  margin: 0 1rem;
+  overflow: hidden;
+  padding: 1.25rem;
+}
+
+.restart-spinner {
+  display: none;
+}
+
+.restart-loader-text {
+  padding: 0;
+}
+
+.restart-title {
+  color: #e0e0e0;
+  font-size: 0.85rem;
+  margin-bottom: 1rem;
+  margin-top: 0;
+}
+
+.restart-subtitle {
+  display: none;
+}
+
+/* Restart Modal (Confirmation) */
+.restart-modal {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 9999;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.restart-modal-overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  backdrop-filter: blur(4px);
+}
+
+.restart-modal-content {
+  position: relative;
+  z-index: 10000;
+  background-color: #1a1a1a;
+  border: 1px solid #333;
+  border-radius: 0.75rem;
+  box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+  width: 100%;
+  max-width: 28rem;
+  margin: 0 1rem;
+  overflow: hidden;
+}
+
+.restart-modal-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 1rem 1.25rem;
+  border-bottom: 1px solid #2a2a2a;
+}
+
+.restart-modal-header h2 {
+  color: #e0e0e0;
+  font-size: 0.95rem;
+  margin: 0;
+}
+
+.restart-modal-close {
+  color: #888;
+  padding: 0.25rem;
+  border-radius: 0.25rem;
+  background-color: transparent;
+  border: none;
+  cursor: pointer;
+  transition: color 150ms, background-color 150ms;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.restart-modal-close:hover {
+  color: #ccc;
+  background-color: #2a2a2a;
+}
+
+.restart-modal-body {
+  padding: 1.25rem;
+}
+
+.restart-modal-description {
+  color: #aaa;
+  font-size: 0.85rem;
+  margin: 0;
+}
+
+.restart-modal-warning {
+  margin-top: 1rem;
+  background-color: #1e1400;
+  border: 1px solid #3a2a00;
+  border-radius: 0.5rem;
+  padding: 0.75rem 1rem;
+}
+
+.restart-modal-warning p {
+  color: #facc15;
+  font-size: 0.8rem;
+  margin: 0;
+}
+
+.restart-modal-footer {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 0.75rem;
+  padding: 1rem 1.25rem;
+  border-top: 1px solid #2a2a2a;
+}
+
+.restart-modal-btn {
+  padding: 0.5rem 1rem;
+  border-radius: 0.5rem;
+  font-size: 0.85rem;
+  border: none;
+  cursor: pointer;
+  transition: background-color 150ms;
+}
+
+.restart-modal-btn.cancel {
+  color: #ccc;
+  background-color: transparent;
+}
+
+.restart-modal-btn.cancel:hover {
+  background-color: #2a2a2a;
+}
+
+.restart-modal-btn.confirm {
+  background-color: #00D894;
+  color: #111;
+}
+
+.restart-modal-btn.confirm:hover {
+  background-color: #00be82;
+}
+
+/* Progress Bar for Restart */
+.restart-progress-bar {
+  width: 100%;
+  height: 0.375rem;
+  background-color: #2a2a2a;
+  border-radius: 9999px;
+  overflow: hidden;
+}
+
+.restart-progress-fill {
+  height: 100%;
+  border-radius: 9999px;
+  background-color: #00D894;
+  width: 40%;
+  animation: indeterminate 1.5s ease-in-out infinite;
+}
+
+@keyframes indeterminate {
+  0% {
+    margin-left: 0;
+    width: 40%;
+  }
+  50% {
+    margin-left: 60%;
+    width: 40%;
+  }
+  100% {
+    margin-left: 0;
+    width: 40%;
+  }
+}
+
+.restart-modal-info {
+  color: #666;
+  font-size: 0.8rem;
+  margin-top: 1.25rem;
+  margin-bottom: 0;
+}
+
+.restart-modal-info a {
+  color: #00D894;
+  text-decoration: none;
+}
+
+.restart-modal-info a:hover {
+  text-decoration: underline;
+}
+
 .tee-popover {
   display: none;
   position: absolute;

src/cli/oauth_defaults.rs

@@ -353,7 +353,7 @@ pub fn build_oauth_url(
     // Generate PKCE verifier and challenge
     let (code_verifier, code_challenge) = if use_pkce {
         let mut verifier_bytes = [0u8; 32];
-        rand::thread_rng().fill_bytes(&mut verifier_bytes);
+        rand::rngs::OsRng.fill_bytes(&mut verifier_bytes);
         let verifier = URL_SAFE_NO_PAD.encode(verifier_bytes);
 
         let mut hasher = Sha256::new();
@@ -367,7 +367,7 @@ pub fn build_oauth_url(
 
     // Generate random state for CSRF protection
     let mut state_bytes = [0u8; 32];
-    rand::thread_rng().fill_bytes(&mut state_bytes);
+    rand::rngs::OsRng.fill_bytes(&mut state_bytes);
     let state = URL_SAFE_NO_PAD.encode(state_bytes);
 
     // Build authorization URL

src/config/agent.rs

@@ -30,6 +30,26 @@ pub struct AgentConfig {
 }
 
 impl AgentConfig {
+    /// Create a test-friendly config without reading env vars.
+    #[cfg(feature = "libsql")]
+    pub fn for_testing() -> Self {
+        Self {
+            name: "test-rig".to_string(),
+            max_parallel_jobs: 1,
+            job_timeout: Duration::from_secs(30),
+            stuck_threshold: Duration::from_secs(300),
+            repair_check_interval: Duration::from_secs(3600),
+            max_repair_attempts: 0,
+            use_planning: false,
+            session_idle_timeout: Duration::from_secs(3600),
+            allow_local_tools: true,
+            max_cost_per_day_cents: None,
+            max_actions_per_hour: None,
+            max_tool_iterations: 10,
+            auto_approve_tools: true,
+        }
+    }
+
     pub(crate) fn resolve(settings: &Settings) -> Result<Self, ConfigError> {
         Ok(Self {
             name: parse_optional_env("AGENT_NAME", settings.agent.name.clone())?,

src/config/hygiene.rs

@@ -10,8 +10,10 @@ use crate::error::ConfigError;
 pub struct HygieneConfig {
     /// Whether hygiene is enabled. Env: `MEMORY_HYGIENE_ENABLED` (default: true).
     pub enabled: bool,
-    /// Days before `daily/` documents are deleted. Env: `MEMORY_HYGIENE_RETENTION_DAYS` (default: 30).
-    pub retention_days: u32,
+    /// Days before `daily/` documents are deleted. Env: `MEMORY_HYGIENE_DAILY_RETENTION_DAYS` (default: 30).
+    pub daily_retention_days: u32,
+    /// Days before `conversations/` documents are deleted. Env: `MEMORY_HYGIENE_CONVERSATION_RETENTION_DAYS` (default: 7).
+    pub conversation_retention_days: u32,
     /// Minimum hours between hygiene passes. Env: `MEMORY_HYGIENE_CADENCE_HOURS` (default: 12).
     pub cadence_hours: u32,
 }
@@ -20,7 +22,8 @@ impl Default for HygieneConfig {
     fn default() -> Self {
         Self {
             enabled: true,
-            retention_days: 30,
+            daily_retention_days: 30,
+            conversation_retention_days: 7,
             cadence_hours: 12,
         }
     }
@@ -30,7 +33,11 @@ impl HygieneConfig {
     pub(crate) fn resolve() -> Result<Self, ConfigError> {
         Ok(Self {
             enabled: parse_bool_env("MEMORY_HYGIENE_ENABLED", true)?,
-            retention_days: parse_optional_env("MEMORY_HYGIENE_RETENTION_DAYS", 30)?,
+            daily_retention_days: parse_optional_env("MEMORY_HYGIENE_DAILY_RETENTION_DAYS", 30)?,
+            conversation_retention_days: parse_optional_env(
+                "MEMORY_HYGIENE_CONVERSATION_RETENTION_DAYS",
+                7,
+            )?,
             cadence_hours: parse_optional_env("MEMORY_HYGIENE_CADENCE_HOURS", 12)?,
         })
     }
@@ -40,7 +47,8 @@ impl HygieneConfig {
     pub fn to_workspace_config(&self) -> crate::workspace::hygiene::HygieneConfig {
         crate::workspace::hygiene::HygieneConfig {
             enabled: self.enabled,
-            retention_days: self.retention_days,
+            daily_retention_days: self.daily_retention_days,
+            conversation_retention_days: self.conversation_retention_days,
             cadence_hours: self.cadence_hours,
             state_dir: ironclaw_base_dir(),
         }

src/config/llm.rs

@@ -195,6 +195,40 @@ pub struct NearAiConfig {
 }
 
 impl LlmConfig {
+    /// Create a test-friendly config without reading env vars.
+    ///
+    /// Uses NearAi backend with dummy values. The LLM provider is replaced
+    /// by `TraceLlm` via `AppBuilder::with_llm()`, so these values are unused.
+    #[cfg(feature = "libsql")]
+    pub fn for_testing() -> Self {
+        Self {
+            backend: LlmBackend::NearAi,
+            nearai: NearAiConfig {
+                model: "test-model".to_string(),
+                cheap_model: None,
+                base_url: "http://localhost:0".to_string(),
+                auth_base_url: "http://localhost:0".to_string(),
+                session_path: PathBuf::from("/tmp/ironclaw-test-session.json"),
+                api_key: None,
+                fallback_model: None,
+                max_retries: 0,
+                circuit_breaker_threshold: None,
+                circuit_breaker_recovery_secs: 30,
+                response_cache_enabled: false,
+                response_cache_ttl_secs: 3600,
+                response_cache_max_entries: 100,
+                failover_cooldown_secs: 300,
+                failover_cooldown_threshold: 3,
+                smart_routing_cascade: false,
+            },
+            openai: None,
+            anthropic: None,
+            ollama: None,
+            openai_compatible: None,
+            tinfoil: None,
+        }
+    }
+
     /// Resolve a model name from env var → settings.selected_model → hardcoded default.
     fn resolve_model(
         env_var: &str,

src/config/mod.rs

@@ -78,6 +78,77 @@ pub struct Config {
 }
 
 impl Config {
+    /// Create a full Config for integration tests without reading env vars.
+    ///
+    /// Requires the `libsql` feature. Sets up:
+    /// - libSQL database at the given path
+    /// - WASM and embeddings disabled
+    /// - Skills enabled with the given directories
+    /// - Heartbeat, routines, sandbox, builder all disabled
+    /// - Safety with injection check off, 100k output limit
+    #[cfg(feature = "libsql")]
+    pub fn for_testing(
+        libsql_path: std::path::PathBuf,
+        skills_dir: std::path::PathBuf,
+        installed_skills_dir: std::path::PathBuf,
+    ) -> Self {
+        Self {
+            database: DatabaseConfig {
+                backend: DatabaseBackend::LibSql,
+                url: secrecy::SecretString::from("unused://test".to_string()),
+                pool_size: 1,
+                ssl_mode: SslMode::Disable,
+                libsql_path: Some(libsql_path),
+                libsql_url: None,
+                libsql_auth_token: None,
+            },
+            llm: LlmConfig::for_testing(),
+            embeddings: EmbeddingsConfig::default(),
+            tunnel: TunnelConfig::default(),
+            channels: ChannelsConfig {
+                cli: CliConfig { enabled: false },
+                http: None,
+                gateway: None,
+                signal: None,
+                wasm_channels_dir: std::path::PathBuf::from("/tmp/ironclaw-test-channels"),
+                wasm_channels_enabled: false,
+                wasm_channel_owner_ids: HashMap::new(),
+            },
+            agent: AgentConfig::for_testing(),
+            safety: SafetyConfig {
+                max_output_length: 100_000,
+                injection_check_enabled: false,
+            },
+            wasm: WasmConfig {
+                enabled: false,
+                ..WasmConfig::default()
+            },
+            secrets: SecretsConfig::default(),
+            builder: BuilderModeConfig {
+                enabled: false,
+                ..BuilderModeConfig::default()
+            },
+            heartbeat: HeartbeatConfig::default(),
+            hygiene: HygieneConfig::default(),
+            routines: RoutineConfig {
+                enabled: false,
+                ..RoutineConfig::default()
+            },
+            sandbox: SandboxModeConfig {
+                enabled: false,
+                ..SandboxModeConfig::default()
+            },
+            claude_code: ClaudeCodeConfig::default(),
+            skills: SkillsConfig {
+                enabled: true,
+                local_dir: skills_dir,
+                installed_dir: installed_skills_dir,
+                ..SkillsConfig::default()
+            },
+            observability: crate::observability::ObservabilityConfig::default(),
+        }
+    }
+
     /// Load configuration from environment variables and the database.
     ///
     /// Priority: env var > TOML config file > DB settings > default.

src/context/state.rs

@@ -9,6 +9,8 @@ use rust_decimal::Decimal;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
+use crate::llm::recording::HttpInterceptor;
+
 /// State of a job.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -146,6 +148,22 @@ pub struct JobContext {
     /// Wrapped in `Arc` for cheap cloning on every tool invocation.
     #[serde(skip)]
     pub extra_env: Arc<HashMap<String, String>>,
+    /// Optional HTTP interceptor for trace recording/replay.
+    ///
+    /// When set, tools that make outgoing HTTP requests should check this
+    /// interceptor before sending real requests. During recording, the
+    /// interceptor captures request/response pairs. During replay, it
+    /// returns pre-recorded responses.
+    #[serde(skip)]
+    pub http_interceptor: Option<Arc<dyn HttpInterceptor>>,
+    /// Stash of full tool outputs keyed by tool_call_id.
+    ///
+    /// Tool outputs may be truncated before reaching the LLM context window,
+    /// but subsequent tools (e.g., `json`) may need the full output. This
+    /// stash stores the complete, unsanitized output so tools can reference
+    /// previous results by ID via `$tool_call_id` parameter syntax.
+    #[serde(skip)]
+    pub tool_output_stash: Arc<tokio::sync::RwLock<HashMap<String, String>>>,
 }
 
 impl JobContext {
@@ -182,7 +200,9 @@ impl JobContext {
             repair_attempts: 0,
             transitions: Vec::new(),
             extra_env: Arc::new(HashMap::new()),
+            http_interceptor: None,
             metadata: serde_json::Value::Null,
+            tool_output_stash: Arc::new(tokio::sync::RwLock::new(HashMap::new())),
         }
     }
 

src/db/libsql/jobs.rs

@@ -117,6 +117,10 @@ impl JobStore for LibSqlBackend {
                     transitions: Vec::new(),
                     metadata: serde_json::Value::Null,
                     extra_env: std::sync::Arc::new(std::collections::HashMap::new()),
+                    http_interceptor: None,
+                    tool_output_stash: std::sync::Arc::new(tokio::sync::RwLock::new(
+                        std::collections::HashMap::new(),
+                    )),
                 }))
             }
             None => Ok(None),

src/db/libsql_migrations.rs

@@ -298,6 +298,7 @@ CREATE TABLE IF NOT EXISTS wasm_tools (
     user_id TEXT NOT NULL,
     name TEXT NOT NULL,
     version TEXT NOT NULL DEFAULT '1.0.0',
+    wit_version TEXT NOT NULL DEFAULT '0.1.0',
     description TEXT NOT NULL,
     wasm_binary BLOB NOT NULL,
     binary_hash BLOB NOT NULL,
@@ -314,6 +315,24 @@ CREATE INDEX IF NOT EXISTS idx_wasm_tools_user ON wasm_tools(user_id);
 CREATE INDEX IF NOT EXISTS idx_wasm_tools_name ON wasm_tools(user_id, name);
 CREATE INDEX IF NOT EXISTS idx_wasm_tools_status ON wasm_tools(status);
 
+-- ==================== WASM Channel Extensions ====================
+
+CREATE TABLE IF NOT EXISTS wasm_channels (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    version TEXT NOT NULL DEFAULT '0.1.0',
+    wit_version TEXT NOT NULL DEFAULT '0.1.0',
+    description TEXT NOT NULL DEFAULT '',
+    wasm_binary BLOB NOT NULL,
+    binary_hash BLOB NOT NULL,
+    capabilities_json TEXT NOT NULL DEFAULT '{}',
+    status TEXT NOT NULL DEFAULT 'active',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE (user_id, name)
+);
+
 -- ==================== Tool Capabilities ====================
 
 CREATE TABLE IF NOT EXISTS tool_capabilities (

src/error.rs

@@ -422,3 +422,147 @@ pub enum RoutineError {
 
 /// Result type alias for the agent.
 pub type Result<T> = std::result::Result<T, Error>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn config_error_display() {
+        let err = ConfigError::MissingEnvVar("DATABASE_URL".to_string());
+        let msg = err.to_string();
+        assert!(
+            msg.contains("DATABASE_URL"),
+            "Should mention the variable name: {msg}"
+        );
+
+        let err = ConfigError::MissingRequired {
+            key: "llm.model".to_string(),
+            hint: "Set LLM_MODEL env var".to_string(),
+        };
+        let msg = err.to_string();
+        assert!(msg.contains("llm.model"), "Should mention the key: {msg}");
+        assert!(
+            msg.contains("Set LLM_MODEL"),
+            "Should include the hint: {msg}"
+        );
+
+        let err = ConfigError::InvalidValue {
+            key: "port".to_string(),
+            message: "must be a number".to_string(),
+        };
+        let msg = err.to_string();
+        assert!(msg.contains("port"), "Should mention the key: {msg}");
+    }
+
+    #[test]
+    fn database_error_display() {
+        let err = DatabaseError::NotFound {
+            entity: "conversation".to_string(),
+            id: "abc-123".to_string(),
+        };
+        let msg = err.to_string();
+        assert!(msg.contains("conversation"), "Should mention entity: {msg}");
+        assert!(msg.contains("abc-123"), "Should mention id: {msg}");
+
+        let err = DatabaseError::Query("syntax error near SELECT".to_string());
+        assert!(err.to_string().contains("syntax error"));
+    }
+
+    #[test]
+    fn channel_error_display() {
+        let err = ChannelError::StartupFailed {
+            name: "telegram".to_string(),
+            reason: "invalid token".to_string(),
+        };
+        let msg = err.to_string();
+        assert!(msg.contains("telegram"), "Should mention channel: {msg}");
+        assert!(
+            msg.contains("invalid token"),
+            "Should mention reason: {msg}"
+        );
+    }
+
+    #[test]
+    fn llm_error_display() {
+        let err = LlmError::ContextLengthExceeded {
+            used: 100_000,
+            limit: 50_000,
+        };
+        let msg = err.to_string();
+        assert!(msg.contains("100000"), "Should mention used tokens: {msg}");
+        assert!(msg.contains("50000"), "Should mention limit: {msg}");
+
+        let err = LlmError::RateLimited {
+            provider: "openai".to_string(),
+            retry_after: Some(Duration::from_secs(30)),
+        };
+        let msg = err.to_string();
+        assert!(msg.contains("openai"), "Should mention provider: {msg}");
+    }
+
+    #[test]
+    fn job_error_display() {
+        let err = JobError::MaxJobsExceeded { max: 5 };
+        let msg = err.to_string();
+        assert!(msg.contains("5"), "Should mention max: {msg}");
+
+        let id = Uuid::new_v4();
+        let err = JobError::NotFound { id };
+        let msg = err.to_string();
+        assert!(
+            msg.contains(&id.to_string()),
+            "Should mention job id: {msg}"
+        );
+    }
+
+    #[test]
+    fn safety_error_display() {
+        let err = SafetyError::InjectionDetected {
+            pattern: "SYSTEM:".to_string(),
+        };
+        let msg = err.to_string();
+        assert!(msg.contains("SYSTEM:"), "Should mention pattern: {msg}");
+    }
+
+    #[test]
+    fn workspace_error_display() {
+        let err = WorkspaceError::DocumentNotFound {
+            doc_type: "notes".to_string(),
+            user_id: "user1".to_string(),
+        };
+        let msg = err.to_string();
+        assert!(msg.contains("notes"), "Should mention doc_type: {msg}");
+        assert!(msg.contains("user1"), "Should mention user_id: {msg}");
+    }
+
+    #[test]
+    fn routine_error_display() {
+        let err = RoutineError::InvalidCron {
+            reason: "bad format".to_string(),
+        };
+        let msg = err.to_string();
+        assert!(msg.contains("bad format"), "Should mention reason: {msg}");
+    }
+
+    #[test]
+    fn top_level_error_from_conversions() {
+        let config_err = ConfigError::MissingEnvVar("TEST".to_string());
+        let err: Error = config_err.into();
+        assert!(matches!(err, Error::Config(_)));
+
+        let db_err = DatabaseError::Query("test".to_string());
+        let err: Error = db_err.into();
+        assert!(matches!(err, Error::Database(_)));
+
+        let job_err = JobError::MaxJobsExceeded { max: 1 };
+        let err: Error = job_err.into();
+        assert!(matches!(err, Error::Job(_)));
+
+        let safety_err = SafetyError::ValidationFailed {
+            reason: "test".to_string(),
+        };
+        let err: Error = safety_err.into();
+        assert!(matches!(err, Error::Safety(_)));
+    }
+}

src/extensions/manager.rs

@@ -637,6 +637,78 @@ impl ExtensionManager {
         }
     }
 
+    /// Get detailed info about an installed extension (version, wit_version, host compatibility).
+    pub async fn extension_info(&self, name: &str) -> Result<serde_json::Value, ExtensionError> {
+        Self::validate_extension_name(name)?;
+        let kind = self.determine_installed_kind(name).await?;
+
+        match kind {
+            ExtensionKind::WasmTool => {
+                let cap_path = self
+                    .wasm_tools_dir
+                    .join(format!("{}.capabilities.json", name));
+                let wasm_path = self.wasm_tools_dir.join(format!("{}.wasm", name));
+
+                let mut info = serde_json::json!({
+                    "name": name,
+                    "kind": "wasm_tool",
+                    "installed": wasm_path.exists(),
+                });
+
+                if cap_path.exists()
+                    && let Ok(bytes) = tokio::fs::read(&cap_path).await
+                    && let Ok(cap) = crate::tools::wasm::CapabilitiesFile::from_bytes(&bytes)
+                {
+                    info["version"] =
+                        serde_json::json!(cap.version.unwrap_or_else(|| "unknown".into()));
+                    info["wit_version"] =
+                        serde_json::json!(cap.wit_version.unwrap_or_else(|| "unknown".into()));
+                }
+
+                info["host_wit_version"] = serde_json::json!(crate::tools::wasm::WIT_TOOL_VERSION);
+
+                Ok(info)
+            }
+            ExtensionKind::WasmChannel => {
+                let cap_path = self
+                    .wasm_channels_dir
+                    .join(format!("{}.capabilities.json", name));
+                let wasm_path = self.wasm_channels_dir.join(format!("{}.wasm", name));
+
+                let mut info = serde_json::json!({
+                    "name": name,
+                    "kind": "wasm_channel",
+                    "installed": wasm_path.exists(),
+                    "active": self.active_channel_names.read().await.contains(name),
+                });
+
+                if cap_path.exists()
+                    && let Ok(bytes) = tokio::fs::read(&cap_path).await
+                    && let Ok(cap) =
+                        crate::channels::wasm::ChannelCapabilitiesFile::from_bytes(&bytes)
+                {
+                    info["version"] =
+                        serde_json::json!(cap.version.unwrap_or_else(|| "unknown".into()));
+                    info["wit_version"] =
+                        serde_json::json!(cap.wit_version.unwrap_or_else(|| "unknown".into()));
+                }
+
+                info["host_wit_version"] =
+                    serde_json::json!(crate::tools::wasm::WIT_CHANNEL_VERSION);
+
+                Ok(info)
+            }
+            ExtensionKind::McpServer => {
+                let info = serde_json::json!({
+                    "name": name,
+                    "kind": "mcp_server",
+                    "connected": self.mcp_clients.read().await.contains_key(name),
+                });
+                Ok(info)
+            }
+        }
+    }
+
     // ── MCP config helpers (DB with disk fallback) ─────────────────────
 
     async fn load_mcp_servers(
@@ -2397,6 +2469,7 @@ impl ExtensionManager {
         let webhook_secret_name = loaded.webhook_secret_name();
         let secret_header = loaded.webhook_secret_header().map(|s| s.to_string());
         let sig_key_secret_name = loaded.signature_key_secret_name();
+        let hmac_secret_name = loaded.hmac_secret_name();
 
         // Get webhook secret from secrets store
         let webhook_secret = self
@@ -2480,6 +2553,21 @@ impl ExtensionManager {
                     }
                 }
             }
+
+            // Register HMAC signing secret if declared in capabilities
+            if let Some(hmac_name) = &hmac_secret_name {
+                match self.secrets.get_decrypted(&self.user_id, hmac_name).await {
+                    Ok(secret) => {
+                        wasm_channel_router
+                            .register_hmac_secret(&channel_name, secret.expose())
+                            .await;
+                        tracing::info!(channel = %channel_name, "Registered HMAC signing secret for hot-activated channel");
+                    }
+                    Err(e) => {
+                        tracing::warn!(channel = %channel_name, error = %e, "HMAC secret not found");
+                    }
+                }
+            }
         }
 
         // Inject credentials
@@ -2587,19 +2675,30 @@ impl ExtensionManager {
             }
         };
 
-        // Also refresh the webhook secret in the router
-        // Load capabilities file to get the correct secret name (may be overridden)
-        let webhook_secret_name = {
-            let cap_path = self
-                .wasm_channels_dir
-                .join(format!("{}.capabilities.json", name));
-            match tokio::fs::read(&cap_path).await {
-                Ok(bytes) => crate::channels::wasm::ChannelCapabilitiesFile::from_bytes(&bytes)
-                    .map(|f| f.webhook_secret_name())
-                    .unwrap_or_else(|_| format!("{}_webhook_secret", name)),
-                Err(_) => format!("{}_webhook_secret", name),
-            }
+        // Load capabilities file once to extract all secret names
+        let cap_path = self
+            .wasm_channels_dir
+            .join(format!("{}.capabilities.json", name));
+        let capabilities_file = match tokio::fs::read(&cap_path).await {
+            Ok(bytes) => crate::channels::wasm::ChannelCapabilitiesFile::from_bytes(&bytes).ok(),
+            Err(_) => None,
         };
+
+        // Extract all secret names from the capabilities file
+        let webhook_secret_name = capabilities_file
+            .as_ref()
+            .map(|f| f.webhook_secret_name())
+            .unwrap_or_else(|| format!("{}_webhook_secret", name));
+
+        let sig_key_secret_name = capabilities_file
+            .as_ref()
+            .and_then(|f| f.signature_key_secret_name().map(|s| s.to_string()));
+
+        let hmac_secret_name = capabilities_file
+            .as_ref()
+            .and_then(|f| f.hmac_secret_name().map(|s| s.to_string()));
+
+        // Refresh webhook secret
         if let Ok(secret) = self
             .secrets
             .get_decrypted(&self.user_id, &webhook_secret_name)
@@ -2618,18 +2717,7 @@ impl ExtensionManager {
             existing_channel.update_config(config_updates).await;
         }
 
-        // Also refresh signature key in the router
-        let sig_key_secret_name = {
-            let cap_path = self
-                .wasm_channels_dir
-                .join(format!("{}.capabilities.json", name));
-            match tokio::fs::read(&cap_path).await {
-                Ok(bytes) => crate::channels::wasm::ChannelCapabilitiesFile::from_bytes(&bytes)
-                    .ok()
-                    .and_then(|f| f.signature_key_secret_name().map(|s| s.to_string())),
-                Err(_) => None,
-            }
-        };
+        // Refresh signature key
         if let Some(ref sig_key_name) = sig_key_secret_name
             && let Ok(key_secret) = self
                 .secrets
@@ -2649,6 +2737,23 @@ impl ExtensionManager {
             }
         }
 
+        // Refresh HMAC signing secret
+        if let Some(ref hmac_secret_name_ref) = hmac_secret_name {
+            match self
+                .secrets
+                .get_decrypted(&self.user_id, hmac_secret_name_ref)
+                .await
+            {
+                Ok(secret) => {
+                    router.register_hmac_secret(name, secret.expose()).await;
+                    tracing::info!(channel = %name, "Refreshed HMAC signing secret");
+                }
+                Err(e) => {
+                    tracing::warn!(channel = %name, error = %e, "HMAC secret not found");
+                }
+            }
+        }
+
         // Refresh tunnel_url in case it wasn't set at startup
         if let Some(ref tunnel_url) = self.tunnel_url {
             let mut config_updates = std::collections::HashMap::new();
@@ -2943,8 +3048,9 @@ impl ExtensionManager {
                             .unwrap_or(false);
                         if !already_provided && !already_stored {
                             use rand::RngCore;
+                            use rand::rngs::OsRng;
                             let mut bytes = vec![0u8; auto_gen.length];
-                            rand::thread_rng().fill_bytes(&mut bytes);
+                            OsRng.fill_bytes(&mut bytes);
                             let hex_value: String =
                                 bytes.iter().map(|b| format!("{b:02x}")).collect();
                             let params = CreateSecretParams::new(&secret_def.name, &hex_value)

src/history/store.rs

@@ -237,6 +237,10 @@ impl Store {
                     total_tokens_used: 0,
                     max_tokens: 0,
                     extra_env: std::sync::Arc::new(std::collections::HashMap::new()),
+                    http_interceptor: None,
+                    tool_output_stash: std::sync::Arc::new(tokio::sync::RwLock::new(
+                        std::collections::HashMap::new(),
+                    )),
                 }))
             }
             None => Ok(None),

src/llm/mod.rs

@@ -13,6 +13,7 @@ pub mod failover;
 mod nearai_chat;
 mod provider;
 mod reasoning;
+pub mod recording;
 pub mod response_cache;
 pub mod retry;
 mod rig_adapter;
@@ -30,6 +31,7 @@ pub use reasoning::{
     ActionPlan, Reasoning, ReasoningContext, RespondOutput, RespondResult, SILENT_REPLY_TOKEN,
     TokenUsage, ToolSelection, is_silent_reply,
 };
+pub use recording::RecordingLlm;
 pub use response_cache::{CachedProvider, ResponseCacheConfig};
 pub use retry::{RetryConfig, RetryProvider};
 pub use rig_adapter::RigAdapter;
@@ -314,7 +316,14 @@ pub fn create_cheap_llm_provider(
 pub fn build_provider_chain(
     config: &LlmConfig,
     session: Arc<SessionManager>,
-) -> Result<(Arc<dyn LlmProvider>, Option<Arc<dyn LlmProvider>>), LlmError> {
+) -> Result<
+    (
+        Arc<dyn LlmProvider>,
+        Option<Arc<dyn LlmProvider>>,
+        Option<Arc<RecordingLlm>>,
+    ),
+    LlmError,
+> {
     let llm = create_llm_provider(config, session.clone())?;
     tracing::info!("LLM provider initialized: {}", llm.model_name());
 
@@ -427,13 +436,21 @@ pub fn build_provider_chain(
         llm
     };
 
+    // 6. Recording (trace capture for replay testing)
+    let recording_handle = RecordingLlm::from_env(llm.clone());
+    let llm: Arc<dyn LlmProvider> = if let Some(ref recorder) = recording_handle {
+        Arc::clone(recorder) as Arc<dyn LlmProvider>
+    } else {
+        llm
+    };
+
     // Standalone cheap LLM for heartbeat/evaluation (not part of the chain)
     let cheap_llm = create_cheap_llm_provider(config, session)?;
     if let Some(ref cheap) = cheap_llm {
         tracing::info!("Cheap LLM provider initialized: {}", cheap.model_name());
     }
 
-    Ok((llm, cheap_llm))
+    Ok((llm, cheap_llm, recording_handle))
 }
 
 #[cfg(test)]

src/llm/nearai_chat.rs

@@ -522,9 +522,6 @@ impl LlmProvider for NearAiChatProvider {
                     reason: "No choices in response".to_string(),
                 })?;
 
-        // Fall back to reasoning_content when content is null (e.g. GLM-5
-        // returns its answer in reasoning_content instead of content).
-        let content = choice.message.content.or(choice.message.reasoning_content);
         let tool_calls: Vec<ToolCall> = choice
             .message
             .tool_calls
@@ -541,6 +538,18 @@ impl LlmProvider for NearAiChatProvider {
             })
             .collect();
 
+        // Fall back to reasoning_content when content is null (e.g. GLM-5
+        // returns its answer in reasoning_content instead of content), but
+        // only for final text responses. Tool-call responses often have
+        // content: null + reasoning_content filled with chain-of-thought;
+        // leaking that into conversation history inflates context and
+        // confuses the model.
+        let content = if tool_calls.is_empty() {
+            choice.message.content.or(choice.message.reasoning_content)
+        } else {
+            choice.message.content
+        };
+
         let finish_reason = match choice.finish_reason.as_deref() {
             Some("stop") => FinishReason::Stop,
             Some("length") => FinishReason::Length,
@@ -1285,4 +1294,109 @@ mod tests {
         assert_eq!(input, default_in);
         assert_eq!(output, default_out);
     }
+
+    /// Regression: reasoning_content must NOT leak into tool-call responses.
+    #[test]
+    fn test_reasoning_content_not_leaked_into_tool_call_response() {
+        let response: ChatCompletionResponse = serde_json::from_value(serde_json::json!({
+            "id": "chatcmpl-test",
+            "choices": [{
+                "message": {
+                    "role": "assistant",
+                    "content": null,
+                    "reasoning_content": "Let me think about which tool to call...",
+                    "tool_calls": [{
+                        "id": "call_abc123",
+                        "type": "function",
+                        "function": {
+                            "name": "search",
+                            "arguments": "{\"query\":\"test\"}"
+                        }
+                    }]
+                },
+                "finish_reason": "tool_calls"
+            }],
+            "usage": { "prompt_tokens": 100, "completion_tokens": 50 }
+        }))
+        .unwrap();
+
+        let choice = response.choices.into_iter().next().unwrap();
+        let tool_calls: Vec<ToolCall> = choice
+            .message
+            .tool_calls
+            .unwrap_or_default()
+            .into_iter()
+            .map(|tc| {
+                let arguments = serde_json::from_str(&tc.function.arguments)
+                    .unwrap_or(serde_json::Value::Object(Default::default()));
+                ToolCall {
+                    id: tc.id,
+                    name: tc.function.name,
+                    arguments,
+                }
+            })
+            .collect();
+
+        let content = if tool_calls.is_empty() {
+            choice.message.content.or(choice.message.reasoning_content)
+        } else {
+            choice.message.content
+        };
+
+        assert!(
+            content.is_none(),
+            "reasoning_content should NOT leak into tool-call responses, got: {:?}",
+            content
+        );
+        assert_eq!(tool_calls.len(), 1);
+        assert_eq!(tool_calls[0].name, "search");
+    }
+
+    /// Regression: reasoning_content SHOULD be used as fallback for text responses.
+    #[test]
+    fn test_reasoning_content_used_for_text_response() {
+        let response: ChatCompletionResponse = serde_json::from_value(serde_json::json!({
+            "id": "chatcmpl-test",
+            "choices": [{
+                "message": {
+                    "role": "assistant",
+                    "content": null,
+                    "reasoning_content": "The answer is 42."
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": { "prompt_tokens": 50, "completion_tokens": 20 }
+        }))
+        .unwrap();
+
+        let choice = response.choices.into_iter().next().unwrap();
+        let tool_calls: Vec<ToolCall> = choice
+            .message
+            .tool_calls
+            .unwrap_or_default()
+            .into_iter()
+            .map(|tc| {
+                let arguments = serde_json::from_str(&tc.function.arguments)
+                    .unwrap_or(serde_json::Value::Object(Default::default()));
+                ToolCall {
+                    id: tc.id,
+                    name: tc.function.name,
+                    arguments,
+                }
+            })
+            .collect();
+
+        let content = if tool_calls.is_empty() {
+            choice.message.content.or(choice.message.reasoning_content)
+        } else {
+            choice.message.content
+        };
+
+        assert_eq!(
+            content,
+            Some("The answer is 42.".to_string()),
+            "reasoning_content should be used as fallback for text responses"
+        );
+        assert!(tool_calls.is_empty());
+    }
 }

src/llm/reasoning.rs

@@ -335,8 +335,9 @@ impl Reasoning {
 
         let response = self.llm.complete(request).await?;
 
-        // Parse the plan from the response
-        self.parse_plan(&response.content)
+        // Clean reasoning model artifacts before parsing JSON
+        let cleaned = clean_response(&response.content);
+        self.parse_plan(&cleaned)
     }
 
     /// Select the best tool for the current situation.
@@ -429,7 +430,9 @@ Respond in JSON format:
 
         let response = self.llm.complete(request).await?;
 
-        self.parse_evaluation(&response.content)
+        // Clean reasoning model artifacts before parsing JSON
+        let cleaned = clean_response(&response.content);
+        self.parse_evaluation(&cleaned)
     }
 
     /// Generate a response to a user message.
@@ -689,6 +692,8 @@ Example:
 - If tools return empty or irrelevant results, answer with what you already know rather than retrying
 
 ## Tool Call Style
+- ALWAYS call tools via tool_calls — never just describe what you would do
+- If you say "let me fetch/check/look up X", you MUST include the actual tool call in the same response
 - Do not narrate routine, low-risk tool calls; just call the tool
 - Narrate only when it helps: multi-step work, sensitive actions, or when the user asks
 - For multi-step tasks, call independent tools in parallel when possible
@@ -1131,6 +1136,51 @@ fn recover_tool_calls_from_content(
         }
     }
 
+    // Bracket format from flatten_tool_messages:
+    // [Called tool `name` with arguments: {...}]
+    {
+        let mut remaining = content;
+        while let Some(start) = remaining.find("[Called tool `") {
+            let after_prefix = &remaining[start + "[Called tool `".len()..];
+            let Some(backtick_end) = after_prefix.find('`') else {
+                break;
+            };
+            let name = &after_prefix[..backtick_end];
+            let after_name = &after_prefix[backtick_end + 1..];
+
+            if !tool_names.contains(name) {
+                remaining = after_name;
+                continue;
+            }
+
+            // Look for " with arguments: " followed by JSON until "]"
+            if let Some(args_start) = after_name.strip_prefix(" with arguments: ") {
+                // Find the closing "]" — but the JSON itself may contain "]",
+                // so find the last "]" on this logical line.
+                if let Some(bracket_end) = args_start.rfind(']') {
+                    let args_str = &args_start[..bracket_end];
+                    let arguments = serde_json::from_str::<serde_json::Value>(args_str)
+                        .unwrap_or(serde_json::Value::Object(Default::default()));
+                    calls.push(ToolCall {
+                        id: format!("recovered_{}", calls.len()),
+                        name: name.to_string(),
+                        arguments,
+                    });
+                    remaining = &args_start[bracket_end + 1..];
+                    continue;
+                }
+            }
+
+            // No arguments or malformed — call with empty args
+            calls.push(ToolCall {
+                id: format!("recovered_{}", calls.len()),
+                name: name.to_string(),
+                arguments: serde_json::Value::Object(Default::default()),
+            });
+            remaining = after_name;
+        }
+    }
+
     calls
 }
 
@@ -1174,10 +1224,39 @@ fn clean_response(text: &str) -> String {
         result = strip_pipe_tag(&result, tag);
     }
 
+    // 6b. Strip bracket-format inline tool calls: [Called tool `name` with arguments: {...}]
+    result = strip_bracket_tool_calls(&result);
+
     // 7. Collapse triple+ newlines, trim
     collapse_newlines(&result)
 }
 
+/// Strip bracket-format inline tool calls produced by `flatten_tool_messages`.
+///
+/// Removes patterns like `[Called tool `name` with arguments: {...}]` from text
+/// so the user doesn't see raw tool call syntax when the model echoes it back.
+fn strip_bracket_tool_calls(text: &str) -> String {
+    let mut result = String::with_capacity(text.len());
+    let mut remaining = text;
+    while let Some(start) = remaining.find("[Called tool `") {
+        result.push_str(&remaining[..start]);
+        let after = &remaining[start..];
+        // Find the closing "]" for this bracket expression
+        if let Some(end) = after.find("]\n").map(|i| i + 2).or_else(|| {
+            // If it's at the end of the string, just find "]"
+            after.rfind(']').map(|i| i + 1)
+        }) {
+            remaining = &after[end..];
+        } else {
+            // Malformed — keep the rest
+            result.push_str(after);
+            return result;
+        }
+    }
+    result.push_str(remaining);
+    result
+}
+
 /// Tool-related tags stripped with simple string matching (no code-awareness needed).
 const TOOL_TAGS: &[&str] = &["tool_call", "function_call", "tool_calls"];
 
@@ -1216,8 +1295,15 @@ fn strip_thinking_tags_regex(text: &str, code_regions: &[CodeRegion]) -> String
     }
 
     // Strict mode: if still inside an unclosed thinking tag, discard trailing text
+    // BUT preserve any <final> block embedded in the discarded region
     if !in_thinking {
         result.push_str(&text[last_index..]);
+    } else {
+        let trailing = &text[last_index..];
+        let trailing_regions = find_code_regions(trailing);
+        if let Some(final_content) = extract_final_content(trailing, &trailing_regions) {
+            result.push_str(&final_content);
+        }
     }
 
     result
@@ -1841,4 +1927,85 @@ That's my plan."#;
         assert_eq!(calls.len(), 1);
         assert_eq!(calls[0].name, "tool_list");
     }
+
+    // ---- plan/evaluate bypass clean_response (Bug #564-2) ----
+
+    #[test]
+    fn test_clean_response_strips_think_before_json_plan() {
+        let raw = r#"<think>I need to plan the steps carefully...</think>{"steps": [{"description": "Step 1", "tool": "search", "expected_outcome": "results"}], "reasoning": "Simple plan"}"#;
+        let cleaned = clean_response(raw);
+        // After cleaning, the JSON should be parseable
+        let json_str = extract_json(&cleaned).unwrap();
+        let parsed: serde_json::Value = serde_json::from_str(json_str).unwrap();
+        assert!(parsed.get("steps").is_some());
+    }
+
+    #[test]
+    fn test_clean_response_strips_think_before_json_evaluation() {
+        let raw = r#"<think>Let me evaluate whether this was successful...</think>{"success": true, "confidence": 0.95, "reasoning": "Task completed", "issues": [], "suggestions": []}"#;
+        let cleaned = clean_response(raw);
+        let json_str = extract_json(&cleaned).unwrap();
+        let eval: SuccessEvaluation = serde_json::from_str(json_str).unwrap();
+        assert!(eval.success);
+        assert_eq!(eval.confidence, 0.95);
+    }
+
+    // ---- Unclosed think before final (Bug #564-3) ----
+
+    #[test]
+    fn test_unclosed_think_before_final() {
+        assert_eq!(
+            clean_response("<think>reasoning no close tag <final>actual answer</final>"),
+            "actual answer"
+        );
+    }
+
+    #[test]
+    fn test_unclosed_thinking_before_final() {
+        assert_eq!(
+            clean_response("<thinking>long reasoning... <final>the real answer</final>"),
+            "the real answer"
+        );
+    }
+
+    #[test]
+    fn test_unclosed_think_before_final_with_prefix() {
+        assert_eq!(
+            clean_response("Hello <think>reasoning <final>world</final>"),
+            "Hello world"
+        );
+    }
+
+    #[test]
+    fn test_unclosed_think_no_final_still_discards() {
+        assert_eq!(clean_response("Hello <thinking>this never closes"), "Hello");
+    }
+
+    #[test]
+    fn test_recover_bracket_format_tool_call() {
+        let tools = make_tools(&["http"]);
+        let content = "Let me try that. [Called tool `http` with arguments: {\"method\":\"GET\",\"url\":\"https://example.com\"}]";
+        let calls = recover_tool_calls_from_content(content, &tools);
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].name, "http");
+        assert_eq!(calls[0].arguments["method"], "GET");
+        assert_eq!(calls[0].arguments["url"], "https://example.com");
+    }
+
+    #[test]
+    fn test_recover_bracket_format_unknown_tool_ignored() {
+        let tools = make_tools(&["http"]);
+        let content = "[Called tool `unknown_tool` with arguments: {}]";
+        let calls = recover_tool_calls_from_content(content, &tools);
+        assert!(calls.is_empty());
+    }
+
+    #[test]
+    fn test_clean_response_strips_bracket_tool_calls() {
+        let input = "Let me fetch that.\n[Called tool `http` with arguments: {\"method\":\"GET\",\"url\":\"https://example.com\"}]\nHere are the results.";
+        let cleaned = clean_response(input);
+        assert!(!cleaned.contains("[Called tool"));
+        assert!(cleaned.contains("Let me fetch that."));
+        assert!(cleaned.contains("Here are the results."));
+    }
 }

src/llm/recording.rs

@@ -0,0 +1,917 @@
+//! Live trace recording mode.
+//!
+//! Wraps any [`LlmProvider`] and captures every LLM interaction into
+//! the trace fixture format used by `TraceLlm` for deterministic E2E
+//! testing. Recorded traces can be replayed later via `TraceLlm`.
+//!
+//! The trace includes:
+//! - **Memory snapshot**: workspace documents captured before the first LLM call
+//! - **HTTP exchanges**: all outgoing HTTP request/response pairs from tools
+//! - **Steps**: user inputs, LLM responses (text/tool_calls), and expected tool
+//!   results for verifying tool output during replay
+//!
+//! Enable by setting `IRONCLAW_RECORD_TRACE=1` at runtime.
+
+use std::collections::VecDeque;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use rust_decimal::Decimal;
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+
+use crate::error::LlmError;
+use crate::llm::provider::{
+    ChatMessage, CompletionRequest, CompletionResponse, LlmProvider, ModelMetadata, Role,
+    ToolCompletionRequest, ToolCompletionResponse,
+};
+
+// ── Trace format types ─────────────────────────────────────────────
+
+/// Top-level trace file — extended format with memory snapshot and HTTP exchanges.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TraceFile {
+    pub model_name: String,
+    /// Workspace memory documents captured before the recording session.
+    /// Replay should restore these before running the trace.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub memory_snapshot: Vec<MemorySnapshotEntry>,
+    /// HTTP exchanges recorded during the session, in order.
+    /// Replay should return these instead of making real HTTP requests.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub http_exchanges: Vec<HttpExchange>,
+    pub steps: Vec<TraceStep>,
+}
+
+/// A memory document captured at recording start.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MemorySnapshotEntry {
+    pub path: String,
+    pub content: String,
+}
+
+/// A recorded HTTP request/response pair.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HttpExchange {
+    pub request: HttpExchangeRequest,
+    pub response: HttpExchangeResponse,
+}
+
+/// The request side of an HTTP exchange.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HttpExchangeRequest {
+    pub method: String,
+    pub url: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub headers: Vec<(String, String)>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<String>,
+}
+
+/// The response side of an HTTP exchange.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HttpExchangeResponse {
+    pub status: u16,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub headers: Vec<(String, String)>,
+    pub body: String,
+}
+
+/// A single step in the trace.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TraceStep {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub request_hint: Option<RequestHint>,
+    pub response: TraceResponse,
+    /// Tool results that appeared in the message context since the previous step.
+    /// During replay, the test harness can compare actual tool results against
+    /// these to verify tool output hasn't changed (regression detection).
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub expected_tool_results: Vec<ExpectedToolResult>,
+}
+
+/// Soft validation hints for matching a step to a request.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RequestHint {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub last_user_message_contains: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub min_message_count: Option<usize>,
+}
+
+/// Tagged response enum — text, tool_calls, or user_input.
+///
+/// `user_input` steps are metadata markers — they record what the user said
+/// but do **not** correspond to an LLM call. During replay, `TraceLlm` must
+/// skip `user_input` steps and only consume `text`/`tool_calls` steps.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum TraceResponse {
+    Text {
+        content: String,
+        input_tokens: u32,
+        output_tokens: u32,
+    },
+    ToolCalls {
+        tool_calls: Vec<TraceToolCall>,
+        input_tokens: u32,
+        output_tokens: u32,
+    },
+    /// Marker for a user message that triggered subsequent LLM calls.
+    /// Not an LLM response — replay providers must skip these.
+    UserInput { content: String },
+}
+
+/// A tool call in a trace step.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TraceToolCall {
+    pub id: String,
+    pub name: String,
+    pub arguments: serde_json::Value,
+}
+
+/// Recorded tool result for regression checking during replay.
+///
+/// During replay, after tools execute and before returning the canned LLM
+/// response, the test harness should compare actual `Role::Tool` messages
+/// against these entries. A content mismatch indicates a tool behavior change.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExpectedToolResult {
+    pub tool_call_id: String,
+    pub name: String,
+    /// The full tool result content as it appeared in the message context.
+    pub content: String,
+}
+
+// ── HTTP interceptor ───────────────────────────────────────────────
+
+/// Trait for intercepting HTTP requests from tools.
+///
+/// During recording, the interceptor captures exchanges after the real
+/// request completes. During replay, it short-circuits with a recorded response.
+#[async_trait]
+pub trait HttpInterceptor: Send + Sync + std::fmt::Debug {
+    /// Called before making an HTTP request.
+    ///
+    /// Return `Some(response)` to short-circuit (replay mode).
+    /// Return `None` to let the real request proceed (recording mode).
+    async fn before_request(&self, request: &HttpExchangeRequest) -> Option<HttpExchangeResponse>;
+
+    /// Called after a real HTTP request completes (recording mode only).
+    async fn after_response(&self, request: &HttpExchangeRequest, response: &HttpExchangeResponse);
+}
+
+/// Records HTTP exchanges during a live session.
+#[derive(Debug)]
+pub struct RecordingHttpInterceptor {
+    exchanges: Mutex<Vec<HttpExchange>>,
+}
+
+impl Default for RecordingHttpInterceptor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl RecordingHttpInterceptor {
+    pub fn new() -> Self {
+        Self {
+            exchanges: Mutex::new(Vec::new()),
+        }
+    }
+
+    /// Return all recorded exchanges.
+    pub async fn take_exchanges(&self) -> Vec<HttpExchange> {
+        self.exchanges.lock().await.clone()
+    }
+}
+
+#[async_trait]
+impl HttpInterceptor for RecordingHttpInterceptor {
+    async fn before_request(&self, _request: &HttpExchangeRequest) -> Option<HttpExchangeResponse> {
+        // Recording mode: let the real request proceed
+        None
+    }
+
+    async fn after_response(&self, request: &HttpExchangeRequest, response: &HttpExchangeResponse) {
+        self.exchanges.lock().await.push(HttpExchange {
+            request: request.clone(),
+            response: response.clone(),
+        });
+    }
+}
+
+/// Replays recorded HTTP exchanges during test runs.
+///
+/// Returns responses in order. If more requests arrive than recorded
+/// exchanges, returns a 599 error response.
+#[derive(Debug)]
+pub struct ReplayingHttpInterceptor {
+    exchanges: Mutex<VecDeque<HttpExchange>>,
+}
+
+impl ReplayingHttpInterceptor {
+    pub fn new(exchanges: Vec<HttpExchange>) -> Self {
+        Self {
+            exchanges: Mutex::new(VecDeque::from(exchanges)),
+        }
+    }
+}
+
+#[async_trait]
+impl HttpInterceptor for ReplayingHttpInterceptor {
+    async fn before_request(&self, request: &HttpExchangeRequest) -> Option<HttpExchangeResponse> {
+        let mut queue = self.exchanges.lock().await;
+        if let Some(exchange) = queue.pop_front() {
+            // Soft-check: warn if the request doesn't match
+            if exchange.request.url != request.url || exchange.request.method != request.method {
+                tracing::warn!(
+                    expected_url = %exchange.request.url,
+                    actual_url = %request.url,
+                    expected_method = %exchange.request.method,
+                    actual_method = %request.method,
+                    "HTTP replay: request mismatch (returning recorded response anyway)"
+                );
+            }
+            Some(exchange.response)
+        } else {
+            tracing::error!(
+                url = %request.url,
+                method = %request.method,
+                "HTTP replay: no more recorded exchanges, returning error"
+            );
+            Some(HttpExchangeResponse {
+                status: 599,
+                headers: Vec::new(),
+                body: "trace replay: no more recorded HTTP exchanges".to_string(),
+            })
+        }
+    }
+
+    async fn after_response(
+        &self,
+        _request: &HttpExchangeRequest,
+        _response: &HttpExchangeResponse,
+    ) {
+        // Replay mode: nothing to record
+    }
+}
+
+// ── RecordingLlm ───────────────────────────────────────────────────
+
+/// LLM provider decorator that records interactions into a trace file.
+pub struct RecordingLlm {
+    inner: Arc<dyn LlmProvider>,
+    steps: Mutex<Vec<TraceStep>>,
+    prev_message_count: Mutex<usize>,
+    output_path: PathBuf,
+    model_name: String,
+    memory_snapshot: Mutex<Vec<MemorySnapshotEntry>>,
+    http_interceptor: Arc<RecordingHttpInterceptor>,
+}
+
+impl RecordingLlm {
+    /// Wrap a provider for recording.
+    pub fn new(inner: Arc<dyn LlmProvider>, output_path: PathBuf, model_name: String) -> Self {
+        Self {
+            inner,
+            steps: Mutex::new(Vec::new()),
+            prev_message_count: Mutex::new(0),
+            output_path,
+            model_name,
+            memory_snapshot: Mutex::new(Vec::new()),
+            http_interceptor: Arc::new(RecordingHttpInterceptor::new()),
+        }
+    }
+
+    /// Create from environment variables if recording is enabled.
+    ///
+    /// - `IRONCLAW_RECORD_TRACE` — any non-empty value enables recording
+    /// - `IRONCLAW_TRACE_OUTPUT` — file path (default: `./trace_{timestamp}.json`)
+    /// - `IRONCLAW_TRACE_MODEL_NAME` — model_name field (default: `recorded-{inner.model_name()}`)
+    pub fn from_env(inner: Arc<dyn LlmProvider>) -> Option<Arc<Self>> {
+        let enabled = std::env::var("IRONCLAW_RECORD_TRACE")
+            .ok()
+            .filter(|v| !v.is_empty());
+        enabled?;
+
+        let output_path = std::env::var("IRONCLAW_TRACE_OUTPUT")
+            .ok()
+            .filter(|v| !v.is_empty())
+            .map(PathBuf::from)
+            .unwrap_or_else(|| {
+                let ts = chrono::Local::now().format("%Y%m%dT%H%M%S");
+                PathBuf::from(format!("trace_{ts}.json"))
+            });
+
+        let model_name = std::env::var("IRONCLAW_TRACE_MODEL_NAME")
+            .ok()
+            .filter(|v| !v.is_empty())
+            .unwrap_or_else(|| format!("recorded-{}", inner.model_name()));
+
+        tracing::info!(
+            output = %output_path.display(),
+            model = %model_name,
+            "LLM trace recording enabled"
+        );
+
+        Some(Arc::new(Self::new(inner, output_path, model_name)))
+    }
+
+    /// Get the HTTP interceptor for wiring into tools.
+    ///
+    /// Pass this to `JobContext` or `HttpTool` so outgoing HTTP requests
+    /// are recorded into the trace.
+    pub fn http_interceptor(&self) -> Arc<dyn HttpInterceptor> {
+        Arc::clone(&self.http_interceptor) as Arc<dyn HttpInterceptor>
+    }
+
+    /// Snapshot all memory documents from a workspace.
+    ///
+    /// Call this once after creation, before the agent starts processing.
+    pub async fn snapshot_memory(&self, workspace: &crate::workspace::Workspace) {
+        match workspace.list_all().await {
+            Ok(paths) => {
+                let mut snapshot = self.memory_snapshot.lock().await;
+                for path in paths {
+                    match workspace.read(&path).await {
+                        Ok(doc) => {
+                            snapshot.push(MemorySnapshotEntry {
+                                path: doc.path,
+                                content: doc.content,
+                            });
+                        }
+                        Err(e) => {
+                            tracing::debug!(path = %path, error = %e, "Skipped memory doc in snapshot");
+                        }
+                    }
+                }
+                tracing::info!(
+                    documents = snapshot.len(),
+                    "Captured memory snapshot for trace recording"
+                );
+            }
+            Err(e) => {
+                tracing::warn!("Failed to snapshot memory for trace recording: {}", e);
+            }
+        }
+    }
+
+    /// Flush accumulated steps, memory snapshot, and HTTP exchanges to the output file.
+    pub async fn flush(&self) -> Result<(), std::io::Error> {
+        let steps = self.steps.lock().await;
+        let memory_snapshot = self.memory_snapshot.lock().await;
+        let http_exchanges = self.http_interceptor.take_exchanges().await;
+
+        let trace = TraceFile {
+            model_name: self.model_name.clone(),
+            memory_snapshot: memory_snapshot.clone(),
+            http_exchanges,
+            steps: steps.clone(),
+        };
+        let json = serde_json::to_string_pretty(&trace).map_err(std::io::Error::other)?;
+        tokio::fs::write(&self.output_path, json).await?;
+        tracing::info!(
+            steps = steps.len(),
+            memory_docs = memory_snapshot.len(),
+            path = %self.output_path.display(),
+            "Flushed LLM trace recording"
+        );
+        Ok(())
+    }
+
+    /// Extract new user messages, tool results, and build request hint.
+    ///
+    /// Returns `(hint, tool_results)` where tool_results are new `Role::Tool`
+    /// messages since the last call — these become `expected_tool_results` on
+    /// the next step for replay verification.
+    async fn capture_new_messages(
+        &self,
+        messages: &[ChatMessage],
+    ) -> (Option<RequestHint>, Vec<ExpectedToolResult>) {
+        let mut prev_count = self.prev_message_count.lock().await;
+        let current_count = messages.len();
+        // After context compaction, the message list may shrink below
+        // prev_count.  Clamp to avoid an out-of-bounds slice.
+        let start = (*prev_count).min(current_count);
+
+        let new_messages = &messages[start..];
+
+        // Emit UserInput steps for new user messages
+        let new_user_messages: Vec<&ChatMessage> = new_messages
+            .iter()
+            .filter(|m| m.role == Role::User)
+            .collect();
+
+        if !new_user_messages.is_empty() {
+            let mut steps = self.steps.lock().await;
+            for msg in &new_user_messages {
+                steps.push(TraceStep {
+                    request_hint: None,
+                    response: TraceResponse::UserInput {
+                        content: msg.content.clone(),
+                    },
+                    expected_tool_results: Vec::new(),
+                });
+            }
+        }
+
+        // Capture new tool result messages for expected_tool_results
+        let tool_results: Vec<ExpectedToolResult> = new_messages
+            .iter()
+            .filter(|m| m.role == Role::Tool)
+            .map(|m| ExpectedToolResult {
+                tool_call_id: m.tool_call_id.clone().unwrap_or_default(),
+                name: m.name.clone().unwrap_or_default(),
+                content: m.content.clone(),
+            })
+            .collect();
+
+        *prev_count = current_count;
+
+        // Build request hint from last user message
+        let hint = messages
+            .iter()
+            .rev()
+            .find(|m| m.role == Role::User)
+            .map(|msg| {
+                let hint_text = if msg.content.len() > 80 {
+                    msg.content[..80].to_string()
+                } else {
+                    msg.content.clone()
+                };
+                RequestHint {
+                    last_user_message_contains: Some(hint_text),
+                    min_message_count: Some(current_count),
+                }
+            });
+
+        (hint, tool_results)
+    }
+}
+
+#[async_trait]
+impl LlmProvider for RecordingLlm {
+    fn model_name(&self) -> &str {
+        self.inner.model_name()
+    }
+
+    fn cost_per_token(&self) -> (Decimal, Decimal) {
+        self.inner.cost_per_token()
+    }
+
+    async fn complete(&self, request: CompletionRequest) -> Result<CompletionResponse, LlmError> {
+        let (hint, tool_results) = self.capture_new_messages(&request.messages).await;
+        let response = self.inner.complete(request).await?;
+
+        self.steps.lock().await.push(TraceStep {
+            request_hint: hint,
+            response: TraceResponse::Text {
+                content: response.content.clone(),
+                input_tokens: response.input_tokens,
+                output_tokens: response.output_tokens,
+            },
+            expected_tool_results: tool_results,
+        });
+
+        Ok(response)
+    }
+
+    async fn complete_with_tools(
+        &self,
+        request: ToolCompletionRequest,
+    ) -> Result<ToolCompletionResponse, LlmError> {
+        let (hint, tool_results) = self.capture_new_messages(&request.messages).await;
+        let response = self.inner.complete_with_tools(request).await?;
+
+        let step = if response.tool_calls.is_empty() {
+            TraceStep {
+                request_hint: hint,
+                response: TraceResponse::Text {
+                    content: response.content.clone().unwrap_or_default(),
+                    input_tokens: response.input_tokens,
+                    output_tokens: response.output_tokens,
+                },
+                expected_tool_results: tool_results,
+            }
+        } else {
+            TraceStep {
+                request_hint: hint,
+                response: TraceResponse::ToolCalls {
+                    tool_calls: response
+                        .tool_calls
+                        .iter()
+                        .map(|tc| TraceToolCall {
+                            id: tc.id.clone(),
+                            name: tc.name.clone(),
+                            arguments: tc.arguments.clone(),
+                        })
+                        .collect(),
+                    input_tokens: response.input_tokens,
+                    output_tokens: response.output_tokens,
+                },
+                expected_tool_results: tool_results,
+            }
+        };
+
+        self.steps.lock().await.push(step);
+        Ok(response)
+    }
+
+    async fn list_models(&self) -> Result<Vec<String>, LlmError> {
+        self.inner.list_models().await
+    }
+
+    async fn model_metadata(&self) -> Result<ModelMetadata, LlmError> {
+        self.inner.model_metadata().await
+    }
+
+    fn effective_model_name(&self, requested_model: Option<&str>) -> String {
+        self.inner.effective_model_name(requested_model)
+    }
+
+    fn active_model_name(&self) -> String {
+        self.inner.active_model_name()
+    }
+
+    fn set_model(&self, model: &str) -> Result<(), LlmError> {
+        self.inner.set_model(model)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testing::StubLlm;
+
+    fn make_recorder(stub: Arc<StubLlm>) -> RecordingLlm {
+        RecordingLlm::new(
+            stub,
+            PathBuf::from("/tmp/test_recording.json"),
+            "test-recording".to_string(),
+        )
+    }
+
+    #[tokio::test]
+    async fn captures_user_input_before_first_response() {
+        let stub = Arc::new(StubLlm::new("hello back"));
+        let recorder = make_recorder(stub);
+
+        let request = CompletionRequest::new(vec![
+            ChatMessage::system("You are helpful."),
+            ChatMessage::user("Hello!"),
+        ]);
+        recorder.complete(request).await.unwrap();
+
+        let steps = recorder.steps.lock().await;
+        assert_eq!(steps.len(), 2);
+
+        // First step: user_input
+        assert!(
+            matches!(&steps[0].response, TraceResponse::UserInput { content } if content == "Hello!")
+        );
+
+        // Second step: text response
+        assert!(
+            matches!(&steps[1].response, TraceResponse::Text { content, .. } if content == "hello back")
+        );
+    }
+
+    #[tokio::test]
+    async fn captures_text_response_correctly() {
+        let stub = Arc::new(StubLlm::new("test response"));
+        let recorder = make_recorder(stub);
+
+        let request = CompletionRequest::new(vec![ChatMessage::user("question")]);
+        recorder.complete(request).await.unwrap();
+
+        let steps = recorder.steps.lock().await;
+        // user_input + text
+        assert_eq!(steps.len(), 2);
+        match &steps[1].response {
+            TraceResponse::Text {
+                content,
+                input_tokens,
+                output_tokens,
+            } => {
+                assert_eq!(content, "test response");
+                // StubLlm returns 0s for tokens, which is fine
+                let _ = (*input_tokens, *output_tokens);
+            }
+            _ => panic!("Expected Text response"),
+        }
+    }
+
+    #[tokio::test]
+    async fn captures_tool_calls_response() {
+        let stub = Arc::new(StubLlm::new("tool result"));
+        let recorder = make_recorder(stub);
+
+        // complete_with_tools on StubLlm returns text, not tool_calls.
+        // But we can still verify the recording captures it as text.
+        let request = ToolCompletionRequest::new(vec![ChatMessage::user("use a tool")], vec![]);
+        recorder.complete_with_tools(request).await.unwrap();
+
+        let steps = recorder.steps.lock().await;
+        assert_eq!(steps.len(), 2); // user_input + text (StubLlm doesn't return tool_calls)
+    }
+
+    #[tokio::test]
+    async fn no_spurious_user_input_for_tool_iterations() {
+        let stub = Arc::new(StubLlm::new("response"));
+        let recorder = make_recorder(stub);
+
+        // First call with user message
+        let request = CompletionRequest::new(vec![
+            ChatMessage::system("sys"),
+            ChatMessage::user("Do something"),
+        ]);
+        recorder.complete(request).await.unwrap();
+
+        // Second call: same messages plus tool result (no new user message)
+        let request = CompletionRequest::new(vec![
+            ChatMessage::system("sys"),
+            ChatMessage::user("Do something"),
+            ChatMessage::assistant("I'll use a tool"),
+            ChatMessage::tool_result("call_1", "echo", "result"),
+        ]);
+        recorder.complete(request).await.unwrap();
+
+        let steps = recorder.steps.lock().await;
+        // Step 0: user_input "Do something"
+        // Step 1: text response
+        // Step 2: text response (no new user_input since no new user messages)
+        assert_eq!(steps.len(), 3);
+        assert!(matches!(
+            &steps[0].response,
+            TraceResponse::UserInput { .. }
+        ));
+        assert!(matches!(&steps[1].response, TraceResponse::Text { .. }));
+        assert!(matches!(&steps[2].response, TraceResponse::Text { .. }));
+    }
+
+    #[tokio::test]
+    async fn captures_tool_results_for_verification() {
+        let stub = Arc::new(StubLlm::new("response"));
+        let recorder = make_recorder(stub);
+
+        // First call: user asks something
+        let request = CompletionRequest::new(vec![
+            ChatMessage::system("sys"),
+            ChatMessage::user("Do something"),
+        ]);
+        recorder.complete(request).await.unwrap();
+
+        // Second call: includes tool results from previous tool_calls
+        let request = CompletionRequest::new(vec![
+            ChatMessage::system("sys"),
+            ChatMessage::user("Do something"),
+            ChatMessage::assistant("I'll use a tool"),
+            ChatMessage::tool_result("call_1", "echo", "echoed: hello"),
+            ChatMessage::tool_result("call_2", "time", "2026-03-04T14:00:00Z"),
+        ]);
+        recorder.complete(request).await.unwrap();
+
+        let steps = recorder.steps.lock().await;
+        // Step 2 (the second LLM response) should have expected_tool_results
+        let step = &steps[2];
+        assert_eq!(step.expected_tool_results.len(), 2);
+        assert_eq!(step.expected_tool_results[0].name, "echo");
+        assert_eq!(step.expected_tool_results[0].content, "echoed: hello");
+        assert_eq!(step.expected_tool_results[1].name, "time");
+    }
+
+    #[tokio::test]
+    async fn request_hint_extraction() {
+        let stub = Arc::new(StubLlm::new("response"));
+        let recorder = make_recorder(stub);
+
+        let request = CompletionRequest::new(vec![
+            ChatMessage::system("sys"),
+            ChatMessage::user("What time is it?"),
+        ]);
+        recorder.complete(request).await.unwrap();
+
+        let steps = recorder.steps.lock().await;
+        let text_step = &steps[1];
+        let hint = text_step.request_hint.as_ref().unwrap();
+        assert_eq!(
+            hint.last_user_message_contains.as_deref(),
+            Some("What time is it?")
+        );
+        assert_eq!(hint.min_message_count, Some(2));
+    }
+
+    #[tokio::test]
+    async fn flush_writes_valid_json_with_all_fields() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("trace.json");
+
+        let stub = Arc::new(StubLlm::new("response"));
+        let recorder = RecordingLlm::new(stub, path.clone(), "flush-test".to_string());
+
+        // Simulate a memory snapshot
+        recorder
+            .memory_snapshot
+            .lock()
+            .await
+            .push(MemorySnapshotEntry {
+                path: "context/test.md".to_string(),
+                content: "test content".to_string(),
+            });
+
+        // Simulate an HTTP exchange
+        recorder
+            .http_interceptor
+            .after_response(
+                &HttpExchangeRequest {
+                    method: "GET".to_string(),
+                    url: "https://api.example.com/data".to_string(),
+                    headers: Vec::new(),
+                    body: None,
+                },
+                &HttpExchangeResponse {
+                    status: 200,
+                    headers: Vec::new(),
+                    body: r#"{"ok": true}"#.to_string(),
+                },
+            )
+            .await;
+
+        let request = CompletionRequest::new(vec![ChatMessage::user("hello")]);
+        recorder.complete(request).await.unwrap();
+        recorder.flush().await.unwrap();
+
+        let content = tokio::fs::read_to_string(&path).await.unwrap();
+        let trace: TraceFile = serde_json::from_str(&content).unwrap();
+        assert_eq!(trace.model_name, "flush-test");
+        assert_eq!(trace.memory_snapshot.len(), 1);
+        assert_eq!(trace.memory_snapshot[0].path, "context/test.md");
+        assert_eq!(trace.http_exchanges.len(), 1);
+        assert_eq!(trace.http_exchanges[0].response.status, 200);
+        assert_eq!(trace.steps.len(), 2);
+    }
+
+    #[test]
+    fn from_env_returns_none_when_unset() {
+        // SAFETY: This test is single-threaded and no other thread reads this var.
+        unsafe { std::env::remove_var("IRONCLAW_RECORD_TRACE") };
+        let stub = Arc::new(StubLlm::new("response"));
+        let result = RecordingLlm::from_env(stub);
+        assert!(result.is_none());
+    }
+
+    #[tokio::test]
+    async fn recording_http_interceptor_passes_through_and_records() {
+        let interceptor = RecordingHttpInterceptor::new();
+
+        let req = HttpExchangeRequest {
+            method: "GET".to_string(),
+            url: "https://example.com".to_string(),
+            headers: Vec::new(),
+            body: None,
+        };
+
+        // before_request should return None (pass through)
+        assert!(interceptor.before_request(&req).await.is_none());
+
+        // after_response records the exchange
+        let resp = HttpExchangeResponse {
+            status: 200,
+            headers: Vec::new(),
+            body: "ok".to_string(),
+        };
+        interceptor.after_response(&req, &resp).await;
+
+        let exchanges = interceptor.take_exchanges().await;
+        assert_eq!(exchanges.len(), 1);
+        assert_eq!(exchanges[0].request.url, "https://example.com");
+    }
+
+    #[tokio::test]
+    async fn replaying_http_interceptor_returns_recorded_responses() {
+        let exchanges = vec![HttpExchange {
+            request: HttpExchangeRequest {
+                method: "GET".to_string(),
+                url: "https://api.example.com/data".to_string(),
+                headers: Vec::new(),
+                body: None,
+            },
+            response: HttpExchangeResponse {
+                status: 200,
+                headers: Vec::new(),
+                body: r#"{"items": []}"#.to_string(),
+            },
+        }];
+        let interceptor = ReplayingHttpInterceptor::new(exchanges);
+
+        // First request: returns recorded response
+        let req = HttpExchangeRequest {
+            method: "GET".to_string(),
+            url: "https://api.example.com/data".to_string(),
+            headers: Vec::new(),
+            body: None,
+        };
+        let resp = interceptor.before_request(&req).await.unwrap();
+        assert_eq!(resp.status, 200);
+        assert_eq!(resp.body, r#"{"items": []}"#);
+
+        // Second request: no more exchanges → 599
+        let resp = interceptor.before_request(&req).await.unwrap();
+        assert_eq!(resp.status, 599);
+    }
+
+    #[test]
+    fn serde_roundtrip_extended_format() {
+        let trace = TraceFile {
+            model_name: "test".to_string(),
+            memory_snapshot: vec![MemorySnapshotEntry {
+                path: "context/vision.md".to_string(),
+                content: "Be helpful.".to_string(),
+            }],
+            http_exchanges: vec![HttpExchange {
+                request: HttpExchangeRequest {
+                    method: "GET".to_string(),
+                    url: "https://api.example.com".to_string(),
+                    headers: vec![("Accept".to_string(), "application/json".to_string())],
+                    body: None,
+                },
+                response: HttpExchangeResponse {
+                    status: 200,
+                    headers: Vec::new(),
+                    body: "{}".to_string(),
+                },
+            }],
+            steps: vec![
+                TraceStep {
+                    request_hint: None,
+                    response: TraceResponse::UserInput {
+                        content: "hello".to_string(),
+                    },
+                    expected_tool_results: Vec::new(),
+                },
+                TraceStep {
+                    request_hint: Some(RequestHint {
+                        last_user_message_contains: Some("hello".to_string()),
+                        min_message_count: Some(2),
+                    }),
+                    response: TraceResponse::ToolCalls {
+                        tool_calls: vec![TraceToolCall {
+                            id: "call_1".to_string(),
+                            name: "echo".to_string(),
+                            arguments: serde_json::json!({"message": "hi"}),
+                        }],
+                        input_tokens: 50,
+                        output_tokens: 20,
+                    },
+                    expected_tool_results: Vec::new(),
+                },
+                TraceStep {
+                    request_hint: None,
+                    response: TraceResponse::Text {
+                        content: "done".to_string(),
+                        input_tokens: 80,
+                        output_tokens: 10,
+                    },
+                    expected_tool_results: vec![ExpectedToolResult {
+                        tool_call_id: "call_1".to_string(),
+                        name: "echo".to_string(),
+                        content: "hi".to_string(),
+                    }],
+                },
+            ],
+        };
+
+        let json = serde_json::to_string_pretty(&trace).unwrap();
+        let parsed: TraceFile = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed.model_name, "test");
+        assert_eq!(parsed.memory_snapshot.len(), 1);
+        assert_eq!(parsed.http_exchanges.len(), 1);
+        assert_eq!(parsed.steps.len(), 3);
+        assert_eq!(parsed.steps[2].expected_tool_results.len(), 1);
+    }
+
+    #[test]
+    fn backward_compatible_with_old_format() {
+        // Old format without memory_snapshot, http_exchanges, expected_tool_results
+        let json = r#"{
+            "model_name": "old-trace",
+            "steps": [
+                {
+                    "response": {
+                        "type": "text",
+                        "content": "hello",
+                        "input_tokens": 10,
+                        "output_tokens": 5
+                    }
+                }
+            ]
+        }"#;
+        let trace: TraceFile = serde_json::from_str(json).unwrap();
+        assert_eq!(trace.model_name, "old-trace");
+        assert!(trace.memory_snapshot.is_empty());
+        assert!(trace.http_exchanges.is_empty());
+        assert!(trace.steps[0].expected_tool_results.is_empty());
+    }
+}

src/llm/response_cache.rs

@@ -16,13 +16,14 @@
 //! ```
 
 use std::collections::HashMap;
-use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
+
 use std::time::{Duration, Instant};
 
 use async_trait::async_trait;
 use rust_decimal::Decimal;
 use sha2::{Digest, Sha256};
-use tokio::sync::Mutex;
 
 use crate::error::LlmError;
 use crate::llm::provider::{
@@ -30,6 +31,9 @@ use crate::llm::provider::{
     ToolCompletionResponse,
 };
 
+/// How often (in requests) to emit a cache statistics log line.
+const STATS_LOG_EVERY_N: u64 = 100;
+
 /// Configuration for the response cache.
 #[derive(Debug, Clone)]
 pub struct ResponseCacheConfig {
@@ -61,8 +65,16 @@ struct CacheEntry {
 /// tool calls can have side effects that should not be replayed.
 pub struct CachedProvider {
     inner: Arc<dyn LlmProvider>,
+    /// `std::sync::Mutex` (not tokio) — never held across an `.await` point,
+    /// so blocking acquisition is safe and keeps `set_model()` synchronous.
     cache: Mutex<HashMap<String, CacheEntry>>,
     config: ResponseCacheConfig,
+    /// Total `complete()` calls (hits + misses) for periodic stats logging.
+    request_count: AtomicU64,
+    /// Running total of cache hits, independent of entry lifecycle.
+    /// Never decremented on eviction, so `hit_rate_pct` in stats doesn't
+    /// drift down as entries expire or are LRU-evicted.
+    total_hit_count: AtomicU64,
 }
 
 impl CachedProvider {
@@ -72,27 +84,53 @@ impl CachedProvider {
             inner,
             cache: Mutex::new(HashMap::new()),
             config,
+            request_count: AtomicU64::new(0),
+            total_hit_count: AtomicU64::new(0),
         }
     }
 
     /// Number of entries currently in the cache.
-    pub async fn len(&self) -> usize {
-        self.cache.lock().await.len()
+    pub fn len(&self) -> usize {
+        self.cache.lock().unwrap_or_else(|e| e.into_inner()).len()
     }
 
     /// Whether the cache is empty.
-    pub async fn is_empty(&self) -> bool {
-        self.cache.lock().await.is_empty()
+    pub fn is_empty(&self) -> bool {
+        self.cache
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .is_empty()
     }
 
-    /// Total cache hits across all entries.
-    pub async fn total_hits(&self) -> u64 {
-        self.cache.lock().await.values().map(|e| e.hit_count).sum()
+    /// Total cache hits since this provider was created.
+    ///
+    /// Backed by an atomic counter that is never decremented on eviction,
+    /// so the value is accurate even under high eviction pressure.
+    pub fn total_hits(&self) -> u64 {
+        self.total_hit_count.load(Ordering::Relaxed)
     }
 
     /// Clear all cached entries.
-    pub async fn clear(&self) {
-        self.cache.lock().await.clear();
+    pub fn clear(&self) {
+        self.cache.lock().unwrap_or_else(|e| e.into_inner()).clear();
+    }
+
+    /// Emit a cache statistics log line if `req_no` is a multiple of
+    /// [`STATS_LOG_EVERY_N`]. `total_hits` must come from the `total_hit_count`
+    /// atomic so it accurately reflects hits that occurred on since-evicted
+    /// entries. Must be called while holding the cache lock so that
+    /// `entry_count` is consistent with the snapshot.
+    fn maybe_log_stats(guard: &HashMap<String, CacheEntry>, req_no: u64, total_hits: u64) {
+        if req_no.is_multiple_of(STATS_LOG_EVERY_N) {
+            let hit_rate = total_hits as f64 / req_no as f64 * 100.0;
+            tracing::info!(
+                total_requests = req_no,
+                total_hits,
+                hit_rate_pct = format!("{hit_rate:.1}"),
+                entry_count = guard.len(),
+                "LLM response cache statistics"
+            );
+        }
     }
 }
 
@@ -147,28 +185,47 @@ impl LlmProvider for CachedProvider {
         let effective_model = self.inner.effective_model_name(request.model.as_deref());
         let key = cache_key(&effective_model, &request);
         let now = Instant::now();
+        let req_no = self.request_count.fetch_add(1, Ordering::Relaxed) + 1;
 
-        // Check cache
+        // Check cache — lock not held across the .await below.
         {
-            let mut guard = self.cache.lock().await;
+            let mut guard = self.cache.lock().unwrap_or_else(|e| e.into_inner());
             if let Some(entry) = guard.get_mut(&key) {
                 if now.duration_since(entry.created_at) < self.config.ttl {
                     entry.last_accessed = now;
                     entry.hit_count += 1;
-                    tracing::debug!(hits = entry.hit_count, "response cache hit");
-                    return Ok(entry.response.clone());
+                    let hit_count = entry.hit_count;
+                    // Clone now so we can release the mutable borrow before stats.
+                    let cached_response = entry.response.clone();
+                    tracing::debug!(hits = hit_count, "response cache hit");
+                    // Drop the mutable borrow of `entry` before reading `guard` immutably.
+                    let _ = entry;
+                    let total_hits = self.total_hit_count.fetch_add(1, Ordering::Relaxed) + 1;
+                    Self::maybe_log_stats(&guard, req_no, total_hits);
+                    return Ok(cached_response);
                 }
                 // Expired, remove it
                 guard.remove(&key);
             }
         }
 
-        // Cache miss, call the real provider
-        let response = self.inner.complete(request).await?;
+        // Cache miss — call the real provider.
+        let result = self.inner.complete(request).await;
 
-        // Store in cache
+        // Store result and maybe log stats, all within one lock acquisition.
+        // Stats are logged even on provider error so milestone intervals are
+        // not silently skipped.
         {
-            let mut guard = self.cache.lock().await;
+            let mut guard = self.cache.lock().unwrap_or_else(|e| e.into_inner());
+            let total_hits = self.total_hit_count.load(Ordering::Relaxed);
+
+            let response = match result {
+                Err(e) => {
+                    Self::maybe_log_stats(&guard, req_no, total_hits);
+                    return Err(e);
+                }
+                Ok(r) => r,
+            };
 
             // Evict expired entries
             guard.retain(|_, entry| now.duration_since(entry.created_at) < self.config.ttl);
@@ -196,9 +253,10 @@ impl LlmProvider for CachedProvider {
                     hit_count: 0,
                 },
             );
-        }
 
-        Ok(response)
+            Self::maybe_log_stats(&guard, req_no, total_hits);
+            Ok(response)
+        }
     }
 
     async fn complete_with_tools(
@@ -226,16 +284,91 @@ impl LlmProvider for CachedProvider {
     }
 
     fn set_model(&self, model: &str) -> Result<(), LlmError> {
+        // Cache keys embed the active model name via `effective_model_name()`, so
+        // requests to the new model automatically land in a separate cache slot.
+        // Entries for the old model remain valid: if we switch back, they will be
+        // hit again rather than wasted. Natural TTL / LRU eviction cleans them up.
         self.inner.set_model(model)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::llm::provider::ChatMessage;
+    use std::sync::atomic::{AtomicU32, Ordering};
+
+    use rust_decimal::Decimal;
+    use tracing_test::traced_test;
+
+    use crate::error::LlmError;
+    use crate::llm::provider::{
+        ChatMessage, CompletionResponse, FinishReason, ToolCompletionRequest,
+        ToolCompletionResponse,
+    };
     use crate::llm::response_cache::*;
     use crate::testing::StubLlm;
 
+    /// Minimal provider stub that supports `set_model()` — used to test
+    /// per-model cache key isolation.
+    struct SwitchableStub {
+        call_count: AtomicU32,
+        active_model: std::sync::RwLock<String>,
+    }
+
+    impl SwitchableStub {
+        fn new() -> Self {
+            Self {
+                call_count: AtomicU32::new(0),
+                active_model: std::sync::RwLock::new("stub-model".to_string()),
+            }
+        }
+    }
+
+    #[async_trait]
+    impl LlmProvider for SwitchableStub {
+        fn model_name(&self) -> &str {
+            "stub-model"
+        }
+
+        fn active_model_name(&self) -> String {
+            self.active_model.read().unwrap().clone()
+        }
+
+        fn cost_per_token(&self) -> (Decimal, Decimal) {
+            (Decimal::ZERO, Decimal::ZERO)
+        }
+
+        fn set_model(&self, model: &str) -> Result<(), LlmError> {
+            *self.active_model.write().unwrap() = model.to_string();
+            Ok(())
+        }
+
+        async fn complete(
+            &self,
+            _request: CompletionRequest,
+        ) -> Result<CompletionResponse, LlmError> {
+            self.call_count.fetch_add(1, Ordering::Relaxed);
+            Ok(CompletionResponse {
+                content: "ok".into(),
+                input_tokens: 1,
+                output_tokens: 1,
+                finish_reason: FinishReason::Stop,
+            })
+        }
+
+        async fn complete_with_tools(
+            &self,
+            _request: ToolCompletionRequest,
+        ) -> Result<ToolCompletionResponse, LlmError> {
+            Ok(ToolCompletionResponse {
+                content: Some("ok".into()),
+                tool_calls: vec![],
+                input_tokens: 1,
+                output_tokens: 1,
+                finish_reason: FinishReason::Stop,
+            })
+        }
+    }
+
     fn simple_request() -> CompletionRequest {
         CompletionRequest {
             messages: vec![ChatMessage::user("hello")],
@@ -321,7 +454,7 @@ mod tests {
         assert_eq!(stub.calls(), 1); // still 1
         assert_eq!(r2.content, "cached response");
 
-        assert_eq!(cached.total_hits().await, 1);
+        assert_eq!(cached.total_hits(), 1);
     }
 
     #[tokio::test]
@@ -333,7 +466,7 @@ mod tests {
         cached.complete(different_request()).await.unwrap();
 
         assert_eq!(stub.calls(), 2);
-        assert_eq!(cached.len().await, 2);
+        assert_eq!(cached.len(), 2);
     }
 
     #[tokio::test]
@@ -372,7 +505,7 @@ mod tests {
         // Fill cache with 2 entries
         cached.complete(simple_request()).await.unwrap();
         cached.complete(different_request()).await.unwrap();
-        assert_eq!(cached.len().await, 2);
+        assert_eq!(cached.len(), 2);
 
         // Add a third: should evict the oldest
         let third = CompletionRequest {
@@ -384,7 +517,7 @@ mod tests {
             metadata: Default::default(),
         };
         cached.complete(third).await.unwrap();
-        assert_eq!(cached.len().await, 2);
+        assert_eq!(cached.len(), 2);
         assert_eq!(stub.calls(), 3);
     }
 
@@ -408,7 +541,7 @@ mod tests {
 
         // Both should have called through
         assert_eq!(stub.calls(), 2);
-        assert!(cached.is_empty().await);
+        assert!(cached.is_empty());
     }
 
     #[tokio::test]
@@ -425,12 +558,12 @@ mod tests {
         stub.set_failing(true);
         let result = cached.complete(simple_request()).await;
         assert!(result.is_err());
-        assert!(cached.is_empty().await);
+        assert!(cached.is_empty());
 
         // After fixing the provider, should succeed and cache
         stub.set_failing(false);
         cached.complete(simple_request()).await.unwrap();
-        assert_eq!(cached.len().await, 1);
+        assert_eq!(cached.len(), 1);
     }
 
     #[tokio::test]
@@ -439,10 +572,10 @@ mod tests {
         let cached = CachedProvider::new(stub.clone(), ResponseCacheConfig::default());
 
         cached.complete(simple_request()).await.unwrap();
-        assert_eq!(cached.len().await, 1);
+        assert_eq!(cached.len(), 1);
 
-        cached.clear().await;
-        assert!(cached.is_empty().await);
+        cached.clear();
+        assert!(cached.is_empty());
     }
 
     #[tokio::test]
@@ -459,7 +592,7 @@ mod tests {
         cached.complete(req_b).await.unwrap();
 
         assert_eq!(stub.calls(), 2);
-        assert_eq!(cached.len().await, 2);
+        assert_eq!(cached.len(), 2);
     }
 
     #[test]
@@ -475,4 +608,171 @@ mod tests {
         let cached = CachedProvider::new(stub.clone(), ResponseCacheConfig::default());
         assert_eq!(cached.model_name(), "stub-model");
     }
+
+    /// Switching models preserves existing cached entries and routes subsequent
+    /// requests to a separate cache slot. Switching back replays the old slot.
+    #[tokio::test]
+    async fn set_model_isolates_per_model_via_key() {
+        let stub = Arc::new(SwitchableStub::new());
+        let cached = CachedProvider::new(stub.clone(), ResponseCacheConfig::default());
+
+        // Populate cache under the initial model ("stub-model").
+        cached.complete(simple_request()).await.unwrap();
+        assert_eq!(stub.call_count.load(Ordering::Relaxed), 1);
+        assert_eq!(cached.len(), 1, "one entry cached for stub-model");
+
+        // Switch to a different model — old entries must survive.
+        cached.set_model("model-b").unwrap();
+        assert_eq!(cached.len(), 1, "old entries preserved after model switch");
+
+        // Same request under model-b is a cache miss (different key).
+        cached.complete(simple_request()).await.unwrap();
+        assert_eq!(
+            stub.call_count.load(Ordering::Relaxed),
+            2,
+            "cache miss for model-b"
+        );
+        assert_eq!(cached.len(), 2, "separate slots for stub-model and model-b");
+
+        // Switch back — original slot is still valid (cache hit, no extra call).
+        cached.set_model("stub-model").unwrap();
+        cached.complete(simple_request()).await.unwrap();
+        assert_eq!(
+            stub.call_count.load(Ordering::Relaxed),
+            2,
+            "cache hit when switching back to stub-model"
+        );
+    }
+
+    /// When `set_model()` fails the error is propagated and the cache is unaffected.
+    #[tokio::test]
+    async fn set_model_error_leaves_cache_intact() {
+        // StubLlm does not override set_model() — returns an error by default.
+        let stub = Arc::new(StubLlm::default());
+        let cached = CachedProvider::new(stub, ResponseCacheConfig::default());
+
+        cached.complete(simple_request()).await.unwrap();
+        assert_eq!(cached.len(), 1);
+
+        let result = cached.set_model("new-model");
+        assert!(result.is_err());
+        assert_eq!(cached.len(), 1, "cache unaffected by failed set_model");
+    }
+
+    /// `hit_rate_pct` stays accurate even after entries are evicted.
+    /// The `total_hit_count` atomic is never decremented on eviction.
+    #[tokio::test]
+    async fn total_hits_survives_eviction() {
+        let stub = Arc::new(StubLlm::new("response"));
+        // max_entries = 1 so the first entry is LRU-evicted when a second arrives.
+        let cached = CachedProvider::new(
+            stub.clone(),
+            ResponseCacheConfig {
+                ttl: Duration::from_secs(60),
+                max_entries: 1,
+            },
+        );
+
+        // Populate the cache and score a hit.
+        cached.complete(simple_request()).await.unwrap();
+        cached.complete(simple_request()).await.unwrap();
+        assert_eq!(cached.total_hits(), 1);
+
+        // Add a different request — LRU evicts the first entry.
+        cached.complete(different_request()).await.unwrap();
+        assert_eq!(cached.len(), 1, "first entry was evicted");
+
+        // The hit from the evicted entry must still be counted.
+        assert_eq!(cached.total_hits(), 1, "hit count survives eviction");
+    }
+
+    /// A stats line is emitted exactly at the 100th request.
+    #[tokio::test]
+    #[traced_test]
+    async fn stats_logged_at_request_100() {
+        let stub = Arc::new(StubLlm::new("response"));
+        let cached = CachedProvider::new(
+            stub.clone(),
+            ResponseCacheConfig {
+                ttl: Duration::from_secs(60),
+                max_entries: 2000,
+            },
+        );
+
+        // 99 distinct requests — no stats line yet.
+        for i in 0..99u32 {
+            let req = CompletionRequest {
+                messages: vec![ChatMessage::user(format!("request {i}"))],
+                model: None,
+                max_tokens: None,
+                temperature: None,
+                stop_sequences: None,
+                metadata: Default::default(),
+            };
+            cached.complete(req).await.unwrap();
+        }
+        assert!(
+            !logs_contain("LLM response cache statistics"),
+            "no stats before request 100"
+        );
+
+        // 100th request triggers the first stats line.
+        let req = CompletionRequest {
+            messages: vec![ChatMessage::user("request 99")],
+            model: None,
+            max_tokens: None,
+            temperature: None,
+            stop_sequences: None,
+            metadata: Default::default(),
+        };
+        cached.complete(req).await.unwrap();
+        assert!(
+            logs_contain("LLM response cache statistics"),
+            "stats emitted at request 100"
+        );
+    }
+
+    /// Stats are emitted even when the inner provider returns an error.
+    #[tokio::test]
+    #[traced_test]
+    async fn stats_logged_on_provider_error_at_interval() {
+        let stub = Arc::new(StubLlm::new("response"));
+        let cached = CachedProvider::new(
+            stub.clone(),
+            ResponseCacheConfig {
+                ttl: Duration::from_secs(60),
+                max_entries: 2000,
+            },
+        );
+
+        // 99 successful requests.
+        for i in 0..99u32 {
+            let req = CompletionRequest {
+                messages: vec![ChatMessage::user(format!("req {i}"))],
+                model: None,
+                max_tokens: None,
+                temperature: None,
+                stop_sequences: None,
+                metadata: Default::default(),
+            };
+            cached.complete(req).await.unwrap();
+        }
+
+        // 100th request fails — stats must still be logged.
+        stub.set_failing(true);
+        let req = CompletionRequest {
+            messages: vec![ChatMessage::user("req 99")],
+            model: None,
+            max_tokens: None,
+            temperature: None,
+            stop_sequences: None,
+            metadata: Default::default(),
+        };
+        let result = cached.complete(req).await;
+        assert!(result.is_err());
+        assert!(
+            logs_contain("LLM response cache statistics"),
+            "stats emitted even when provider errors on request 100"
+        );
+    }
 }

src/main.rs

@@ -652,6 +652,17 @@ async fn async_main() -> anyhow::Result<()> {
         ext_mgr.set_sse_sender(sender.clone()).await;
     }
 
+    // Snapshot memory for trace recording before the agent starts
+    if let Some(ref recorder) = components.recording_handle
+        && let Some(ref ws) = components.workspace
+    {
+        recorder.snapshot_memory(ws).await;
+    }
+
+    let http_interceptor = components
+        .recording_handle
+        .as_ref()
+        .map(|r| r.http_interceptor());
     let deps = AgentDeps {
         store: components.db,
         llm: components.llm,
@@ -666,6 +677,7 @@ async fn async_main() -> anyhow::Result<()> {
         hooks: components.hooks,
         cost_guard: components.cost_guard,
         sse_tx: sse_sender,
+        http_interceptor,
     };
 
     let agent = Agent::new(
@@ -686,6 +698,13 @@ async fn async_main() -> anyhow::Result<()> {
 
     // ── Shutdown ────────────────────────────────────────────────────────
 
+    // Flush LLM trace recording if enabled
+    if let Some(ref recorder) = components.recording_handle
+        && let Err(e) = recorder.flush().await
+    {
+        tracing::warn!("Failed to write LLM trace: {}", e);
+    }
+
     if let Some(ref mut server) = webhook_server {
         server.shutdown().await;
     }
@@ -931,6 +950,7 @@ async fn setup_wasm_channels(
 
         let secret_name = loaded.webhook_secret_name();
         let sig_key_secret_name = loaded.signature_key_secret_name();
+        let hmac_secret_name = loaded.hmac_secret_name();
 
         let webhook_secret = if let Some(secrets) = secrets_store {
             secrets
@@ -1025,6 +1045,17 @@ async fn setup_wasm_channels(
             }
         }
 
+        // Register HMAC signing secret if declared in capabilities
+        if let Some(ref hmac_secret_name) = hmac_secret_name
+            && let Some(secrets) = secrets_store
+            && let Ok(secret) = secrets.get_decrypted("default", hmac_secret_name).await
+        {
+            wasm_router
+                .register_hmac_secret(&channel_name, secret.expose())
+                .await;
+            tracing::info!(channel = %channel_name, "Registered HMAC signing secret");
+        }
+
         if let Some(secrets) = secrets_store {
             match inject_channel_credentials(&channel_arc, secrets.as_ref(), &channel_name).await {
                 Ok(count) => {

src/orchestrator/auth.rs

@@ -14,7 +14,6 @@ use axum::extract::{Request, State};
 use axum::http::StatusCode;
 use axum::middleware::Next;
 use axum::response::Response;
-use rand::Rng;
 use serde::{Deserialize, Serialize};
 use subtle::ConstantTimeEq;
 use tokio::sync::RwLock;
@@ -98,8 +97,10 @@ impl Default for TokenStore {
 
 /// Generate a cryptographically random token (32 bytes, hex-encoded = 64 chars).
 fn generate_token() -> String {
+    use rand::RngCore;
+    use rand::rngs::OsRng;
     let mut bytes = [0u8; 32];
-    rand::thread_rng().fill(&mut bytes);
+    OsRng.fill_bytes(&mut bytes);
     // Hex-encode without pulling in a crate: fixed-size array, no allocation concern.
     bytes.iter().fold(String::with_capacity(64), |mut s, b| {
         use std::fmt::Write;

src/pairing/store.rs

@@ -10,6 +10,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use fs4::FileExt;
 use rand::Rng;
+use rand::rngs::OsRng;
 use serde::{Deserialize, Serialize};
 
 use crate::bootstrap::ironclaw_base_dir;
@@ -147,7 +148,7 @@ fn is_expired(req: &PairingRequest, now_secs: u64) -> bool {
 }
 
 fn random_code() -> String {
-    let mut rng = rand::thread_rng();
+    let mut rng = OsRng;
     (0..PAIRING_CODE_LENGTH)
         .map(|_| {
             let idx = rng.gen_range(0..PAIRING_ALPHABET.len());
@@ -157,7 +158,7 @@ fn random_code() -> String {
 }
 
 fn generate_unique_code(existing: &HashSet<String>) -> String {
-    let mut rng = rand::thread_rng();
+    let mut rng = OsRng;
     for _ in 0..500 {
         let code = random_code();
         if !existing.contains(&code) {

src/safety/mod.rs

@@ -47,14 +47,22 @@ impl SafetyLayer {
 
     /// Sanitize tool output before it reaches the LLM.
     pub fn sanitize_tool_output(&self, tool_name: &str, output: &str) -> SanitizedOutput {
-        // Check length limits first
+        // Check length limits — keep the beginning so the LLM has partial data
         if output.len() > self.config.max_output_length {
+            // Find a safe truncation point on a char boundary
+            let mut cut = self.config.max_output_length;
+            while cut > 0 && !output.is_char_boundary(cut) {
+                cut -= 1;
+            }
+            let truncated = &output[..cut];
+            let notice = format!(
+                "\n\n[... truncated: showing {}/{} bytes. Use the json tool with \
+                 source_tool_call_id to query the full output.]",
+                cut,
+                output.len()
+            );
             return SanitizedOutput {
-                content: format!(
-                    "[Output truncated: {} bytes exceeded maximum of {} bytes]",
-                    output.len(),
-                    self.config.max_output_length
-                ),
+                content: format!("{}{}", truncated, notice),
                 warnings: vec![InjectionWarning {
                     pattern: "output_too_large".to_string(),
                     severity: Severity::Low,

src/secrets/crypto.rs

@@ -59,7 +59,7 @@ impl SecretsCrypto {
     /// Generate a random salt for a new secret.
     pub fn generate_salt() -> Vec<u8> {
         let mut salt = vec![0u8; SALT_SIZE];
-        rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut salt);
+        rand::RngCore::fill_bytes(&mut OsRng, &mut salt);
         salt
     }
 
@@ -247,4 +247,23 @@ mod tests {
         let decrypted = crypto.decrypt(&encrypted, &salt).unwrap();
         assert_eq!(decrypted.expose().as_bytes(), plaintext.as_slice());
     }
+
+    #[test]
+    fn test_generate_salt_correct_length() {
+        let salt = SecretsCrypto::generate_salt();
+        assert_eq!(salt.len(), super::SALT_SIZE);
+    }
+
+    #[test]
+    fn test_generate_salt_nonzero() {
+        let salt = SecretsCrypto::generate_salt();
+        assert!(salt.iter().any(|&b| b != 0), "salt should not be all zeros");
+    }
+
+    #[test]
+    fn test_generate_salt_unique() {
+        let s1 = SecretsCrypto::generate_salt();
+        let s2 = SecretsCrypto::generate_salt();
+        assert_ne!(s1, s2, "two generated salts should not be identical");
+    }
 }

src/secrets/keychain.rs

@@ -28,8 +28,9 @@ const MASTER_KEY_ACCOUNT: &str = "master_key";
 /// Generate a random 32-byte master key.
 pub fn generate_master_key() -> Vec<u8> {
     use rand::RngCore;
+    use rand::rngs::OsRng;
     let mut key = vec![0u8; 32];
-    rand::thread_rng().fill_bytes(&mut key);
+    OsRng.fill_bytes(&mut key);
     key
 }
 

src/setup/channels.rs

@@ -901,9 +901,9 @@ fn validate_cloudflare_token_format(token: &str) -> bool {
 /// Generate a random secret of specified length (in bytes).
 fn generate_secret_with_length(length: usize) -> String {
     use rand::RngCore;
-    let mut rng = rand::thread_rng();
+    use rand::rngs::OsRng;
     let mut bytes = vec![0u8; length];
-    rng.fill_bytes(&mut bytes);
+    OsRng.fill_bytes(&mut bytes);
     bytes.iter().map(|b| format!("{:02x}", b)).collect()
 }
 

src/skills/registry.rs

@@ -288,6 +288,18 @@ impl SkillRegistry {
         self.skills.len()
     }
 
+    /// Retain only skills whose names are in the given allowlist.
+    ///
+    /// If `names` is empty, this is a no-op (all skills are kept).
+    pub fn retain_only(&mut self, names: &[&str]) {
+        if names.is_empty() {
+            return;
+        }
+        let names_set: HashSet<&str> = names.iter().copied().collect();
+        self.skills
+            .retain(|s| names_set.contains(s.manifest.name.as_str()));
+    }
+
     /// Check if a skill with the given name is loaded.
     pub fn has(&self, name: &str) -> bool {
         self.skills.iter().any(|s| s.manifest.name == name)
@@ -982,6 +994,27 @@ mod tests {
         assert_eq!(skill.lowercased_tags, vec!["email", "prose"]);
     }
 
+    #[tokio::test]
+    async fn test_retain_only_empty_is_noop() {
+        let dir = tempfile::tempdir().unwrap();
+        fs::write(
+            dir.path().join("SKILL.md"),
+            "---\nname: keep-me\ndescription: test\nactivation:\n  keywords: [\"test\"]\n---\n\nKeep this skill.\n",
+        )
+        .unwrap();
+
+        let mut registry = SkillRegistry::new(dir.path().to_path_buf());
+        registry.discover_all().await;
+        assert_eq!(registry.count(), 1);
+
+        registry.retain_only(&[]);
+        assert_eq!(
+            registry.count(),
+            1,
+            "empty retain_only should keep all skills"
+        );
+    }
+
     #[test]
     fn test_compute_hash_deterministic() {
         let h1 = compute_hash("hello world");

src/testing.rs

@@ -294,6 +294,7 @@ impl TestHarnessBuilder {
             hooks,
             cost_guard,
             sse_tx: None,
+            http_interceptor: None,
         };
 
         TestHarness {
@@ -651,4 +652,583 @@ mod tests {
         assert_eq!(response.content, "hello world");
         assert_eq!(response.finish_reason, FinishReason::Stop);
     }
+
+    // === Database CRUD coverage for untested trait methods ===
+
+    #[cfg(feature = "libsql")]
+    #[tokio::test]
+    async fn test_settings_crud() {
+        let harness = TestHarnessBuilder::new().build().await;
+        let db = &harness.db;
+
+        // Initially no setting
+        let val = db.get_setting("user1", "theme").await.expect("get");
+        assert!(val.is_none());
+
+        // Set a value
+        db.set_setting("user1", "theme", &serde_json::json!("dark"))
+            .await
+            .expect("set");
+
+        // Read it back
+        let val = db
+            .get_setting("user1", "theme")
+            .await
+            .expect("get")
+            .expect("should exist");
+        assert_eq!(val, serde_json::json!("dark"));
+
+        // Update it
+        db.set_setting("user1", "theme", &serde_json::json!("light"))
+            .await
+            .expect("set update");
+        let val = db
+            .get_setting("user1", "theme")
+            .await
+            .expect("get")
+            .expect("should exist");
+        assert_eq!(val, serde_json::json!("light"));
+
+        // List settings
+        let all = db.list_settings("user1").await.expect("list");
+        assert_eq!(all.len(), 1);
+
+        // Delete
+        let deleted = db.delete_setting("user1", "theme").await.expect("delete");
+        assert!(deleted);
+
+        let val = db.get_setting("user1", "theme").await.expect("get");
+        assert!(val.is_none());
+
+        // Delete non-existent
+        let deleted = db.delete_setting("user1", "theme").await.expect("delete");
+        assert!(!deleted);
+    }
+
+    #[cfg(feature = "libsql")]
+    #[tokio::test]
+    async fn test_settings_bulk_operations() {
+        let harness = TestHarnessBuilder::new().build().await;
+        let db = &harness.db;
+
+        // Initially no settings
+        let has = db.has_settings("bulk_user").await.expect("has_settings");
+        assert!(!has);
+
+        // Set all settings at once
+        let mut settings = std::collections::HashMap::new();
+        settings.insert("key1".to_string(), serde_json::json!("value1"));
+        settings.insert("key2".to_string(), serde_json::json!(42));
+        db.set_all_settings("bulk_user", &settings)
+            .await
+            .expect("set_all");
+
+        // Has settings should now be true
+        let has = db.has_settings("bulk_user").await.expect("has_settings");
+        assert!(has);
+
+        // Get all settings
+        let all = db.get_all_settings("bulk_user").await.expect("get_all");
+        assert_eq!(all.len(), 2);
+        assert_eq!(all["key1"], serde_json::json!("value1"));
+        assert_eq!(all["key2"], serde_json::json!(42));
+
+        // Get full setting row
+        let full = db
+            .get_setting_full("bulk_user", "key1")
+            .await
+            .expect("get_full")
+            .expect("should exist");
+        assert_eq!(full.key, "key1");
+    }
+
+    #[cfg(feature = "libsql")]
+    #[tokio::test]
+    async fn test_tool_failure_tracking() {
+        let harness = TestHarnessBuilder::new().build().await;
+        let db = &harness.db;
+
+        // Record some failures
+        db.record_tool_failure("bad_tool", "connection refused")
+            .await
+            .expect("record 1");
+        db.record_tool_failure("bad_tool", "timeout")
+            .await
+            .expect("record 2");
+        db.record_tool_failure("bad_tool", "parse error")
+            .await
+            .expect("record 3");
+
+        // Get broken tools (threshold = 2, should include bad_tool with 3 failures)
+        let broken = db.get_broken_tools(2).await.expect("get broken");
+        assert!(!broken.is_empty());
+        let found = broken.iter().find(|b| b.name == "bad_tool");
+        assert!(found.is_some(), "bad_tool should be in broken tools list");
+
+        // Mark as repaired
+        db.mark_tool_repaired("bad_tool")
+            .await
+            .expect("mark repaired");
+    }
+
+    #[cfg(feature = "libsql")]
+    #[tokio::test]
+    async fn test_routine_crud() {
+        use crate::agent::routine::{
+            NotifyConfig, Routine, RoutineAction, RoutineGuardrails, RoutineRun, RunStatus, Trigger,
+        };
+
+        let harness = TestHarnessBuilder::new().build().await;
+        let db = &harness.db;
+
+        let routine_id = uuid::Uuid::new_v4();
+        let routine = Routine {
+            id: routine_id,
+            name: "test-routine".to_string(),
+            description: "A test routine".to_string(),
+            user_id: "user1".to_string(),
+            enabled: true,
+            trigger: Trigger::Cron {
+                schedule: "0 * * * *".to_string(),
+            },
+            action: RoutineAction::Lightweight {
+                prompt: "Check status".to_string(),
+                context_paths: vec![],
+                max_tokens: 500,
+            },
+            guardrails: RoutineGuardrails {
+                cooldown: std::time::Duration::from_secs(60),
+                max_concurrent: 1,
+                dedup_window: None,
+            },
+            notify: NotifyConfig {
+                channel: None,
+                user: "user1".to_string(),
+                on_attention: true,
+                on_failure: true,
+                on_success: false,
+            },
+            last_run_at: None,
+            next_fire_at: None,
+            run_count: 0,
+            consecutive_failures: 0,
+            state: serde_json::json!({}),
+            created_at: chrono::Utc::now(),
+            updated_at: chrono::Utc::now(),
+        };
+
+        // Create
+        db.create_routine(&routine).await.expect("create routine");
+
+        // Get by ID
+        let fetched = db
+            .get_routine(routine_id)
+            .await
+            .expect("get routine")
+            .expect("should exist");
+        assert_eq!(fetched.name, "test-routine");
+        assert!(fetched.enabled);
+
+        // Get by name
+        let by_name = db
+            .get_routine_by_name("user1", "test-routine")
+            .await
+            .expect("get by name")
+            .expect("should exist");
+        assert_eq!(by_name.id, routine_id);
+
+        // List routines for user
+        let list = db.list_routines("user1").await.expect("list routines");
+        assert_eq!(list.len(), 1);
+
+        // List all routines
+        let all = db.list_all_routines().await.expect("list all");
+        assert!(!all.is_empty());
+
+        // Update routine (disable + change description)
+        let mut updated = fetched;
+        updated.enabled = false;
+        updated.description = "Updated description".to_string();
+        db.update_routine(&updated).await.expect("update routine");
+
+        let re_fetched = db
+            .get_routine(routine_id)
+            .await
+            .expect("get")
+            .expect("exists");
+        assert!(!re_fetched.enabled);
+        assert_eq!(re_fetched.description, "Updated description");
+
+        // Create a routine run
+        let run_id = uuid::Uuid::new_v4();
+        let run = RoutineRun {
+            id: run_id,
+            routine_id,
+            trigger_type: "cron".to_string(),
+            trigger_detail: Some("0 * * * *".to_string()),
+            started_at: chrono::Utc::now(),
+            completed_at: None,
+            status: RunStatus::Running,
+            result_summary: None,
+            tokens_used: None,
+            job_id: None,
+            created_at: chrono::Utc::now(),
+        };
+        db.create_routine_run(&run).await.expect("create run");
+
+        // List runs
+        let runs = db
+            .list_routine_runs(routine_id, 10)
+            .await
+            .expect("list runs");
+        assert_eq!(runs.len(), 1);
+        assert!(matches!(runs[0].status, RunStatus::Running));
+
+        // Complete the run
+        db.complete_routine_run(run_id, RunStatus::Ok, Some("All good"), Some(150))
+            .await
+            .expect("complete run");
+
+        let runs = db
+            .list_routine_runs(routine_id, 10)
+            .await
+            .expect("list runs after complete");
+        assert!(matches!(runs[0].status, RunStatus::Ok));
+
+        // Delete
+        let deleted = db.delete_routine(routine_id).await.expect("delete");
+        assert!(deleted);
+
+        // Delete non-existent
+        let deleted = db.delete_routine(routine_id).await.expect("delete again");
+        assert!(!deleted);
+    }
+
+    #[cfg(feature = "libsql")]
+    #[tokio::test]
+    async fn test_routine_runtime_update() {
+        use crate::agent::routine::{
+            NotifyConfig, Routine, RoutineAction, RoutineGuardrails, Trigger,
+        };
+
+        let harness = TestHarnessBuilder::new().build().await;
+        let db = &harness.db;
+
+        let routine_id = uuid::Uuid::new_v4();
+        let routine = Routine {
+            id: routine_id,
+            name: "runtime-test".to_string(),
+            description: "Test runtime update".to_string(),
+            user_id: "user1".to_string(),
+            enabled: true,
+            trigger: Trigger::Manual,
+            action: RoutineAction::Lightweight {
+                prompt: "test".to_string(),
+                context_paths: vec![],
+                max_tokens: 100,
+            },
+            guardrails: RoutineGuardrails {
+                cooldown: std::time::Duration::from_secs(0),
+                max_concurrent: 1,
+                dedup_window: None,
+            },
+            notify: NotifyConfig {
+                channel: None,
+                user: "user1".to_string(),
+                on_attention: false,
+                on_failure: false,
+                on_success: false,
+            },
+            last_run_at: None,
+            next_fire_at: None,
+            run_count: 0,
+            consecutive_failures: 0,
+            state: serde_json::json!({}),
+            created_at: chrono::Utc::now(),
+            updated_at: chrono::Utc::now(),
+        };
+        db.create_routine(&routine).await.expect("create");
+
+        let now = chrono::Utc::now();
+        db.update_routine_runtime(
+            routine_id,
+            now,
+            Some(now + chrono::TimeDelta::seconds(3600)),
+            5,
+            2,
+            &serde_json::json!({"last_result": "ok"}),
+        )
+        .await
+        .expect("update runtime");
+
+        let fetched = db
+            .get_routine(routine_id)
+            .await
+            .expect("get")
+            .expect("exists");
+        assert_eq!(fetched.run_count, 5);
+        assert_eq!(fetched.consecutive_failures, 2);
+        assert!(fetched.last_run_at.is_some());
+        assert!(fetched.next_fire_at.is_some());
+
+        // Cleanup
+        db.delete_routine(routine_id).await.expect("delete");
+    }
+
+    #[cfg(feature = "libsql")]
+    #[tokio::test]
+    async fn test_llm_call_recording() {
+        use crate::history::LlmCallRecord;
+
+        let harness = TestHarnessBuilder::new().build().await;
+        let db = &harness.db;
+
+        let record = LlmCallRecord {
+            job_id: None,
+            conversation_id: None,
+            provider: "openai",
+            model: "gpt-4",
+            input_tokens: 100,
+            output_tokens: 50,
+            cost: Decimal::new(5, 3), // 0.005
+            purpose: Some("test"),
+        };
+
+        let call_id = db.record_llm_call(&record).await.expect("record llm call");
+        assert!(!call_id.is_nil());
+    }
+
+    #[cfg(feature = "libsql")]
+    #[tokio::test]
+    async fn test_sandbox_job_lifecycle() {
+        use crate::history::SandboxJobRecord;
+
+        let harness = TestHarnessBuilder::new().build().await;
+        let db = &harness.db;
+
+        let job_id = uuid::Uuid::new_v4();
+        let job = SandboxJobRecord {
+            id: job_id,
+            task: "Build a test tool".to_string(),
+            status: "creating".to_string(),
+            user_id: "user1".to_string(),
+            project_dir: "/workspace/test".to_string(),
+            success: None,
+            failure_reason: None,
+            created_at: chrono::Utc::now(),
+            started_at: None,
+            completed_at: None,
+            credential_grants_json: "[]".to_string(),
+        };
+
+        // Create
+        db.save_sandbox_job(&job).await.expect("save sandbox job");
+
+        // Get
+        let fetched = db
+            .get_sandbox_job(job_id)
+            .await
+            .expect("get")
+            .expect("should exist");
+        assert_eq!(fetched.task, "Build a test tool");
+        assert_eq!(fetched.status, "creating");
+
+        // Update status to running
+        db.update_sandbox_job_status(
+            job_id,
+            "running",
+            None,
+            None,
+            Some(chrono::Utc::now()),
+            None,
+        )
+        .await
+        .expect("update to running");
+
+        // Update to completed
+        db.update_sandbox_job_status(
+            job_id,
+            "completed",
+            Some(true),
+            Some("Done"),
+            None,
+            Some(chrono::Utc::now()),
+        )
+        .await
+        .expect("update to completed");
+
+        let fetched = db
+            .get_sandbox_job(job_id)
+            .await
+            .expect("get")
+            .expect("should exist");
+        assert_eq!(fetched.status, "completed");
+        assert_eq!(fetched.success, Some(true));
+
+        // List
+        let all = db.list_sandbox_jobs().await.expect("list");
+        assert!(!all.is_empty());
+
+        // Summary
+        let summary = db.sandbox_job_summary().await.expect("summary");
+        assert!(summary.total >= 1);
+
+        // Per-user list
+        let user_jobs = db
+            .list_sandbox_jobs_for_user("user1")
+            .await
+            .expect("user list");
+        assert!(!user_jobs.is_empty());
+
+        // Ownership check
+        let belongs = db
+            .sandbox_job_belongs_to_user(job_id, "user1")
+            .await
+            .expect("belongs check");
+        assert!(belongs);
+        let not_belongs = db
+            .sandbox_job_belongs_to_user(job_id, "other_user")
+            .await
+            .expect("belongs check");
+        assert!(!not_belongs);
+    }
+
+    #[cfg(feature = "libsql")]
+    #[tokio::test]
+    async fn test_sandbox_job_mode() {
+        use crate::history::SandboxJobRecord;
+
+        let harness = TestHarnessBuilder::new().build().await;
+        let db = &harness.db;
+
+        let job_id = uuid::Uuid::new_v4();
+        let job = SandboxJobRecord {
+            id: job_id,
+            task: "Mode test".to_string(),
+            status: "creating".to_string(),
+            user_id: "user1".to_string(),
+            project_dir: "/workspace".to_string(),
+            success: None,
+            failure_reason: None,
+            created_at: chrono::Utc::now(),
+            started_at: None,
+            completed_at: None,
+            credential_grants_json: "[]".to_string(),
+        };
+        db.save_sandbox_job(&job).await.expect("save");
+
+        // Default mode
+        let mode = db.get_sandbox_job_mode(job_id).await.expect("get mode");
+        // Default is "worker" per schema or NULL
+        assert!(mode.is_none() || mode.as_deref() == Some("worker"));
+
+        // Update mode
+        db.update_sandbox_job_mode(job_id, "claude_code")
+            .await
+            .expect("update mode");
+        let mode = db
+            .get_sandbox_job_mode(job_id)
+            .await
+            .expect("get mode")
+            .expect("should have mode");
+        assert_eq!(mode, "claude_code");
+    }
+
+    #[cfg(feature = "libsql")]
+    #[tokio::test]
+    async fn test_job_events() {
+        use crate::history::SandboxJobRecord;
+
+        let harness = TestHarnessBuilder::new().build().await;
+        let db = &harness.db;
+
+        // Create a sandbox job first (foreign key)
+        let job_id = uuid::Uuid::new_v4();
+        let job = SandboxJobRecord {
+            id: job_id,
+            task: "Event test".to_string(),
+            status: "running".to_string(),
+            user_id: "user1".to_string(),
+            project_dir: "/workspace".to_string(),
+            success: None,
+            failure_reason: None,
+            created_at: chrono::Utc::now(),
+            started_at: Some(chrono::Utc::now()),
+            completed_at: None,
+            credential_grants_json: "[]".to_string(),
+        };
+        db.save_sandbox_job(&job).await.expect("save job");
+
+        // Save events
+        db.save_job_event(
+            job_id,
+            "tool_call",
+            &serde_json::json!({"tool": "shell", "args": {"command": "ls"}}),
+        )
+        .await
+        .expect("save event 1");
+
+        db.save_job_event(
+            job_id,
+            "tool_result",
+            &serde_json::json!({"output": "file1.txt\nfile2.txt"}),
+        )
+        .await
+        .expect("save event 2");
+
+        db.save_job_event(
+            job_id,
+            "llm_response",
+            &serde_json::json!({"content": "Found 2 files"}),
+        )
+        .await
+        .expect("save event 3");
+
+        // List all events
+        let events = db.list_job_events(job_id, None).await.expect("list events");
+        assert_eq!(events.len(), 3);
+
+        // List with limit
+        let events = db
+            .list_job_events(job_id, Some(2))
+            .await
+            .expect("list events limited");
+        assert_eq!(events.len(), 2);
+    }
+
+    #[cfg(feature = "libsql")]
+    #[tokio::test]
+    async fn test_estimation_snapshot_round_trip() {
+        let harness = TestHarnessBuilder::new().build().await;
+        let db = &harness.db;
+
+        // Create a job first
+        let job_ctx = crate::context::JobContext::with_user("user1", "Estimate test", "testing");
+        let job_id = job_ctx.job_id;
+        db.save_job(&job_ctx).await.expect("save job");
+
+        // Save estimation snapshot
+        let snap_id = db
+            .save_estimation_snapshot(
+                job_id,
+                "code_generation",
+                &["shell".to_string(), "write_file".to_string()],
+                Decimal::new(50, 2), // 0.50
+                120,
+                Decimal::new(500, 2), // 5.00
+            )
+            .await
+            .expect("save snapshot");
+        assert!(!snap_id.is_nil());
+
+        // Update with actuals
+        db.update_estimation_actuals(
+            snap_id,
+            Decimal::new(45, 2), // 0.45
+            110,
+            Some(Decimal::new(600, 2)), // 6.00
+        )
+        .await
+        .expect("update actuals");
+    }
 }

src/tools/builtin/extension_tools.rs

@@ -496,6 +496,61 @@ impl Tool for ToolRemoveTool {
     }
 }
 
+// ── extension_info ────────────────────────────────────────────────────
+
+pub struct ExtensionInfoTool {
+    manager: Arc<ExtensionManager>,
+}
+
+impl ExtensionInfoTool {
+    pub fn new(manager: Arc<ExtensionManager>) -> Self {
+        Self { manager }
+    }
+}
+
+#[async_trait]
+impl Tool for ExtensionInfoTool {
+    fn name(&self) -> &str {
+        "extension_info"
+    }
+
+    fn description(&self) -> &str {
+        "Show detailed information about an installed extension, including version \
+         and WIT version compatibility."
+    }
+
+    fn parameters_schema(&self) -> serde_json::Value {
+        serde_json::json!({
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Extension name to get info about"
+                }
+            },
+            "required": ["name"]
+        })
+    }
+
+    async fn execute(
+        &self,
+        params: serde_json::Value,
+        _ctx: &JobContext,
+    ) -> Result<ToolOutput, ToolError> {
+        let start = std::time::Instant::now();
+
+        let name = require_str(&params, "name")?;
+
+        let info = self
+            .manager
+            .extension_info(name)
+            .await
+            .map_err(|e| ToolError::ExecutionFailed(e.to_string()))?;
+
+        Ok(ToolOutput::success(info, start.elapsed()))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -588,6 +643,18 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_extension_info_schema() {
+        let tool = ExtensionInfoTool {
+            manager: test_manager_stub(),
+        };
+        assert_eq!(tool.name(), "extension_info");
+        let schema = tool.parameters_schema();
+        assert!(schema["properties"].get("name").is_some());
+        let required = schema["required"].as_array().unwrap();
+        assert!(required.iter().any(|v| v.as_str() == Some("name")));
+    }
+
     /// Create a stub manager for schema tests (these don't call execute).
     fn test_manager_stub() -> Arc<ExtensionManager> {
         use crate::secrets::{InMemorySecretsStore, SecretsCrypto};

src/tools/builtin/http.rs

@@ -1,4 +1,12 @@
 //! HTTP request tool.
+//!
+//! Unified HTTP tool that handles both simple page/API fetches (GET, no auth)
+//! and full API calls (any method, custom headers, credential injection).
+//!
+//! - Plain GET without auth headers/body → no approval needed, follows redirects
+//! - Everything else → requires approval
+//!
+//! Replaces the former `web_fetch` tool which was a separate GET-only tool.
 
 use std::collections::HashMap;
 use std::net::{IpAddr, ToSocketAddrs};
@@ -25,6 +33,16 @@ use crate::tools::builtin::convert_html_to_markdown;
 /// HTTP wrapper uses the same limit for consistency.
 const MAX_RESPONSE_SIZE: usize = 5 * 1024 * 1024;
 
+/// Maximum number of redirects to follow for simple GET requests.
+const MAX_REDIRECTS: usize = 3;
+
+/// Descriptive User-Agent so public APIs don't reject bare requests.
+const USER_AGENT: &str = concat!(
+    "IronClaw-Agent/",
+    env!("CARGO_PKG_VERSION"),
+    " (https://github.com/nearai/ironclaw)"
+);
+
 /// Tool for making HTTP requests.
 pub struct HttpTool {
     client: Client,
@@ -38,6 +56,7 @@ impl HttpTool {
         let client = Client::builder()
             .timeout(Duration::from_secs(30))
             .redirect(reqwest::redirect::Policy::none())
+            .user_agent(USER_AGENT)
             .build()
             .expect("Failed to create HTTP client");
 
@@ -201,7 +220,10 @@ impl Tool for HttpTool {
     }
 
     fn description(&self) -> &str {
-        "Make HTTP requests to external APIs. Supports GET, POST, PUT, DELETE methods."
+        "Make HTTP requests. Simple GET requests (no auth, no custom headers) run without \
+         approval and follow redirects — use for fetching weather, public JSON APIs, web pages, \
+         and documentation. Requests with authentication, custom headers, or non-GET methods \
+         (POST, PUT, DELETE, PATCH) require user approval."
     }
 
     fn parameters_schema(&self) -> serde_json::Value {
@@ -245,7 +267,7 @@ impl Tool for HttpTool {
     async fn execute(
         &self,
         params: serde_json::Value,
-        _ctx: &JobContext,
+        ctx: &JobContext,
     ) -> Result<ToolOutput, ToolError> {
         let start = std::time::Instant::now();
 
@@ -311,7 +333,7 @@ impl Tool for HttpTool {
             let matched: Vec<crate::secrets::CredentialMapping> = registry.find_for_host(host);
             for mapping in &matched {
                 match store
-                    .get_decrypted(&_ctx.user_id, &mapping.secret_name)
+                    .get_decrypted(&ctx.user_id, &mapping.secret_name)
                     .await
                 {
                     Ok(secret) => {
@@ -343,25 +365,133 @@ impl Tool for HttpTool {
             .scan_http_request(parsed_url.as_str(), &headers_vec, body_bytes.as_deref())
             .map_err(|e| ToolError::NotAuthorized(format!("{}", e)))?;
 
-        // Execute request
-        let response = request.send().await.map_err(|e| {
-            if e.is_timeout() {
-                ToolError::Timeout(Duration::from_secs(30))
-            } else {
-                ToolError::ExternalService(e.to_string())
+        // Build the interceptor request descriptor for recording/replay
+        let intercept_req = crate::llm::recording::HttpExchangeRequest {
+            method: method.to_uppercase(),
+            url: parsed_url.to_string(),
+            headers: headers_vec.clone(),
+            body: body_bytes
+                .as_ref()
+                .map(|b| String::from_utf8_lossy(b).into_owned()),
+        };
+
+        // Check HTTP interceptor (replay mode returns pre-recorded response)
+        if let Some(ref interceptor) = ctx.http_interceptor
+            && let Some(recorded) = interceptor.before_request(&intercept_req).await
+        {
+            let headers: HashMap<String, String> = recorded.headers.iter().cloned().collect();
+            let body: serde_json::Value = serde_json::from_str(&recorded.body)
+                .unwrap_or_else(|_| serde_json::Value::String(recorded.body.clone()));
+            let result = serde_json::json!({
+                "status": recorded.status,
+                "headers": headers,
+                "body": body
+            });
+            return Ok(ToolOutput::success(result, start.elapsed()).with_raw(recorded.body));
+        }
+
+        // Determine if this is a simple GET (eligible for redirect following).
+        let is_simple_get =
+            method.eq_ignore_ascii_case("GET") && headers_vec.is_empty() && body_bytes.is_none();
+
+        // Execute request, optionally following redirects for simple GETs.
+        let response = if is_simple_get {
+            let mut redirects_remaining = MAX_REDIRECTS;
+            loop {
+                let resp = self
+                    .client
+                    .get(parsed_url.clone())
+                    .header(
+                        reqwest::header::ACCEPT,
+                        "text/markdown, text/html;q=0.9, application/json;q=0.9, */*;q=0.8",
+                    )
+                    .send()
+                    .await
+                    .map_err(|e| {
+                        if e.is_timeout() {
+                            ToolError::Timeout(Duration::from_secs(30))
+                        } else {
+                            ToolError::ExternalService(e.to_string())
+                        }
+                    })?;
+
+                let status = resp.status().as_u16();
+                if (300..400).contains(&status) {
+                    if redirects_remaining == 0 {
+                        return Err(ToolError::ExecutionFailed(format!(
+                            "too many redirects (max {})",
+                            MAX_REDIRECTS
+                        )));
+                    }
+
+                    let location = resp
+                        .headers()
+                        .get(reqwest::header::LOCATION)
+                        .and_then(|v| v.to_str().ok())
+                        .ok_or_else(|| {
+                            ToolError::ExecutionFailed(format!(
+                                "redirect (HTTP {}) has no Location header",
+                                status
+                            ))
+                        })?;
+
+                    let next_url_str =
+                        if location.starts_with("http://") || location.starts_with("https://") {
+                            location.to_string()
+                        } else {
+                            parsed_url
+                                .join(location)
+                                .map(|u| u.to_string())
+                                .map_err(|e| {
+                                    ToolError::ExecutionFailed(format!(
+                                        "could not resolve relative redirect '{}': {}",
+                                        location, e
+                                    ))
+                                })?
+                        };
+
+                    // SSRF re-validation on every hop.
+                    parsed_url = validate_url(&next_url_str)?;
+                    let detector = LeakDetector::new();
+                    detector
+                        .scan_http_request(parsed_url.as_str(), &[], None)
+                        .map_err(|e| ToolError::NotAuthorized(e.to_string()))?;
+
+                    redirects_remaining -= 1;
+                    tracing::debug!(
+                        to = %parsed_url,
+                        hops_left = redirects_remaining,
+                        "http tool following redirect"
+                    );
+                    continue;
+                }
+
+                break resp;
             }
-        })?;
+        } else {
+            let resp = request.send().await.map_err(|e| {
+                if e.is_timeout() {
+                    ToolError::Timeout(Duration::from_secs(30))
+                } else {
+                    ToolError::ExternalService(e.to_string())
+                }
+            })?;
+
+            let status = resp.status().as_u16();
+
+            // Block redirects for non-simple requests (potential SSRF)
+            if (300..400).contains(&status) {
+                return Err(ToolError::NotAuthorized(format!(
+                    "request returned redirect (HTTP {}), which is blocked to prevent SSRF",
+                    status
+                )));
+            }
+
+            resp
+        };
 
         let status = response.status().as_u16();
 
-        // Block redirects: the server tried to send us elsewhere (potential SSRF)
-        if (300..400).contains(&status) {
-            return Err(ToolError::NotAuthorized(format!(
-                "request returned redirect (HTTP {}), which is blocked to prevent SSRF",
-                status
-            )));
-        }
-
         let headers: HashMap<String, String> = response
             .headers()
             .iter()
@@ -407,6 +537,24 @@ impl Tool for HttpTool {
 
         let body_text = String::from_utf8_lossy(&body_bytes).into_owned();
 
+        // Record the HTTP exchange if interceptor is present (recording mode)
+        if let Some(ref interceptor) = ctx.http_interceptor {
+            let resp_headers: Vec<(String, String)> = headers
+                .iter()
+                .map(|(k, v)| (k.clone(), v.clone()))
+                .collect();
+            interceptor
+                .after_response(
+                    &intercept_req,
+                    &crate::llm::recording::HttpExchangeResponse {
+                        status,
+                        headers: resp_headers,
+                        body: body_text.clone(),
+                    },
+                )
+                .await;
+        }
+
         #[cfg(feature = "html-to-markdown")]
         let body_text = if is_html_response(&headers) {
             match convert_html_to_markdown(&body_text, parsed_url.as_str()) {
@@ -453,6 +601,25 @@ impl Tool for HttpTool {
         {
             return ApprovalRequirement::Always;
         }
+        // 3. Plain GET without headers or body → no approval needed
+        let method = params
+            .get("method")
+            .and_then(|v| v.as_str())
+            .unwrap_or("GET");
+        let has_headers = params
+            .get("headers")
+            .map(|h| match h {
+                serde_json::Value::Array(a) => !a.is_empty(),
+                serde_json::Value::Object(o) => !o.is_empty(),
+                _ => false,
+            })
+            .unwrap_or(false);
+        let has_body = params.get("body").is_some();
+
+        if method.eq_ignore_ascii_case("GET") && !has_headers && !has_body {
+            return ApprovalRequirement::Never;
+        }
+
         // Default: outbound HTTP still needs approval unless auto-approved
         ApprovalRequirement::UnlessAutoApproved
     }
@@ -579,12 +746,37 @@ mod tests {
     // ── Approval requirement tests ──────────────────────────────────────
 
     #[test]
-    fn test_no_auth_headers_returns_unless_auto_approved() {
+    fn test_plain_get_returns_never() {
         let tool = HttpTool::new();
         let params = serde_json::json!({
             "method": "GET",
             "url": "https://api.example.com/data"
         });
+        assert_eq!(tool.requires_approval(&params), ApprovalRequirement::Never);
+    }
+
+    #[test]
+    fn test_post_returns_unless_auto_approved() {
+        let tool = HttpTool::new();
+        let params = serde_json::json!({
+            "method": "POST",
+            "url": "https://api.example.com/data",
+            "body": {"key": "value"}
+        });
+        assert_eq!(
+            tool.requires_approval(&params),
+            ApprovalRequirement::UnlessAutoApproved
+        );
+    }
+
+    #[test]
+    fn test_get_with_headers_returns_unless_auto_approved() {
+        let tool = HttpTool::new();
+        let params = serde_json::json!({
+            "method": "GET",
+            "url": "https://api.example.com/data",
+            "headers": [{"name": "X-Custom", "value": "test"}]
+        });
         assert_eq!(
             tool.requires_approval(&params),
             ApprovalRequirement::UnlessAutoApproved
@@ -682,30 +874,24 @@ mod tests {
     }
 
     #[test]
-    fn test_empty_headers_return_unless_auto_approved() {
+    fn test_empty_headers_get_returns_never() {
         let tool = HttpTool::new();
 
-        // Empty object
+        // Empty object — still a plain GET
         let params = serde_json::json!({
             "method": "GET",
             "url": "https://example.com",
             "headers": {}
         });
-        assert_eq!(
-            tool.requires_approval(&params),
-            ApprovalRequirement::UnlessAutoApproved
-        );
+        assert_eq!(tool.requires_approval(&params), ApprovalRequirement::Never);
 
-        // Empty array
+        // Empty array — still a plain GET
         let params = serde_json::json!({
             "method": "GET",
             "url": "https://example.com",
             "headers": []
         });
-        assert_eq!(
-            tool.requires_approval(&params),
-            ApprovalRequirement::UnlessAutoApproved
-        );
+        assert_eq!(tool.requires_approval(&params), ApprovalRequirement::Never);
     }
 
     // ── Credential registry approval tests ─────────────────────────────
@@ -740,7 +926,7 @@ mod tests {
     }
 
     #[test]
-    fn test_host_without_credential_mapping_returns_unless_auto_approved() {
+    fn test_host_without_credential_mapping_get_returns_never() {
         use crate::tools::wasm::SharedCredentialRegistry;
 
         let registry = Arc::new(SharedCredentialRegistry::new());
@@ -756,10 +942,19 @@ mod tests {
             ))),
         );
 
+        // Plain GET with no credentials → Never
         let params = serde_json::json!({
             "method": "GET",
             "url": "https://api.example.com/data"
         });
+        assert_eq!(tool.requires_approval(&params), ApprovalRequirement::Never);
+
+        // POST with no credentials → UnlessAutoApproved
+        let params = serde_json::json!({
+            "method": "POST",
+            "url": "https://api.example.com/data",
+            "body": {"key": "value"}
+        });
         assert_eq!(
             tool.requires_approval(&params),
             ApprovalRequirement::UnlessAutoApproved
@@ -803,4 +998,44 @@ mod tests {
         let params = serde_json::json!({"method": "GET"});
         assert_eq!(extract_host_from_params(&params), None);
     }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn requires_approval_multi_thread_no_panic() {
+        use crate::secrets::CredentialMapping;
+        use crate::tools::wasm::SharedCredentialRegistry;
+
+        // Test with credential registry (uses std::sync::RwLock - should be safe)
+        let registry = Arc::new(SharedCredentialRegistry::new());
+        registry.add_mappings(vec![CredentialMapping::bearer("test_key", "api.test.com")]);
+
+        let tool = HttpTool::new().with_credentials(
+            registry,
+            Arc::new(crate::secrets::InMemorySecretsStore::new(Arc::new(
+                crate::secrets::SecretsCrypto::new(secrecy::SecretString::from(
+                    "0123456789abcdef0123456789abcdef".to_string(),
+                ))
+                .unwrap(),
+            ))),
+        );
+
+        // These calls should not panic in multi-thread runtime
+        let params_no_auth = serde_json::json!({
+            "method": "GET",
+            "url": "https://api.example.com/data"
+        });
+        let _ = tool.requires_approval(&params_no_auth);
+
+        let params_with_cred = serde_json::json!({
+            "method": "GET",
+            "url": "https://api.test.com/v1/models"
+        });
+        let _ = tool.requires_approval(&params_with_cred);
+
+        let params_with_auth = serde_json::json!({
+            "method": "GET",
+            "url": "https://api.example.com",
+            "headers": {"Authorization": "Bearer token"}
+        });
+        let _ = tool.requires_approval(&params_with_auth);
+    }
 }

src/tools/builtin/json.rs

@@ -15,7 +15,9 @@ impl Tool for JsonTool {
     }
 
     fn description(&self) -> &str {
-        "Parse, query, and transform JSON data. Supports JSONPath-like queries."
+        "Parse, query, and transform JSON data. Supports JSONPath-like queries. \
+         Use `source_tool_call_id` to reference the full output of a previous tool call \
+         (avoids truncation issues with large responses)."
     }
 
     fn parameters_schema(&self) -> serde_json::Value {
@@ -28,27 +30,48 @@ impl Tool for JsonTool {
                     "description": "The JSON operation to perform"
                 },
                 "data": {
-                    "description": "JSON input data. Pass a string for parse, or any JSON value (object, array, string, number, boolean, null) otherwise."
+                    "description": "JSON input data. Pass a string for parse, or any JSON value otherwise. Not required when source_tool_call_id is provided."
+                },
+                "source_tool_call_id": {
+                    "type": "string",
+                    "description": "Reference a previous tool call's full output by its ID (e.g., 'call_abc123'). Use this instead of data when the previous tool output was large and may have been truncated."
                 },
                 "path": {
                     "type": "string",
                     "description": "JSONPath-like path for query operation (e.g., 'foo.bar[0].baz')"
                 }
             },
-            "required": ["operation", "data"]
+            "required": ["operation"]
         })
     }
 
     async fn execute(
         &self,
         params: serde_json::Value,
-        _ctx: &JobContext,
+        ctx: &JobContext,
     ) -> Result<ToolOutput, ToolError> {
         let start = std::time::Instant::now();
 
         let operation = require_str(&params, "operation")?;
 
-        let data = require_param(&params, "data")?;
+        // Resolve data: from stash (via source_tool_call_id) or from params
+        let data_value =
+            if let Some(ref_id) = params.get("source_tool_call_id").and_then(|v| v.as_str()) {
+                let stash = ctx.tool_output_stash.read().await;
+                let full_output = stash.get(ref_id).ok_or_else(|| {
+                    ToolError::InvalidParameters(format!(
+                        "no tool output found for call ID '{}'. Available IDs: {:?}",
+                        ref_id,
+                        stash.keys().collect::<Vec<_>>()
+                    ))
+                })?;
+                // Parse the stashed output as JSON, or wrap as string
+                serde_json::from_str::<serde_json::Value>(full_output)
+                    .unwrap_or_else(|_| serde_json::Value::String(full_output.clone()))
+            } else {
+                require_param(&params, "data")?.clone()
+            };
+        let data = &data_value;
 
         let result = match operation {
             "parse" => {
@@ -64,7 +87,11 @@ impl Tool for JsonTool {
                 parsed
             }
             "stringify" => {
-                let value = parse_json_input(data)?;
+                let value = if data.is_string() {
+                    parse_json_input(data)?
+                } else {
+                    data.clone()
+                };
                 let json_str = serde_json::to_string_pretty(&value).map_err(|e| {
                     ToolError::ExecutionFailed(format!("failed to stringify: {}", e))
                 })?;
@@ -76,7 +103,11 @@ impl Tool for JsonTool {
                     ToolError::InvalidParameters("missing 'path' parameter for query".to_string())
                 })?;
 
-                let value = parse_json_input(data)?;
+                let value = if data.is_string() {
+                    parse_json_input(data)?
+                } else {
+                    data.clone()
+                };
                 query_json(&value, path)?
             }
             "validate" => {
@@ -190,6 +221,54 @@ mod tests {
         assert!(err.to_string().contains("invalid JSON input"));
     }
 
+    #[tokio::test]
+    async fn test_query_with_object_data_from_stash() {
+        use crate::context::JobContext;
+
+        let ctx = JobContext::with_user("test", "chat", "test-session");
+
+        // Simulate stashed output: the http tool stores serialized JSON
+        // containing {"status": 200, "body": {"leagues": [{"name": "MLB"}]}}
+        let stashed = r#"{"status": 200, "body": {"leagues": [{"name": "MLB"}]}}"#;
+        ctx.tool_output_stash
+            .write()
+            .await
+            .insert("call_http_01".to_string(), stashed.to_string());
+
+        let tool = JsonTool;
+        let params = serde_json::json!({
+            "operation": "query",
+            "source_tool_call_id": "call_http_01",
+            "path": "body.leagues[0].name"
+        });
+
+        let result = tool.execute(params, &ctx).await.unwrap();
+        assert_eq!(result.result, serde_json::json!("MLB"));
+    }
+
+    #[tokio::test]
+    async fn test_stringify_with_object_data_from_stash() {
+        use crate::context::JobContext;
+
+        let ctx = JobContext::with_user("test", "chat", "test-session");
+
+        let stashed = r#"{"key": "value"}"#;
+        ctx.tool_output_stash
+            .write()
+            .await
+            .insert("call_01".to_string(), stashed.to_string());
+
+        let tool = JsonTool;
+        let params = serde_json::json!({
+            "operation": "stringify",
+            "source_tool_call_id": "call_01"
+        });
+
+        let result = tool.execute(params, &ctx).await.unwrap();
+        let stringified = result.result.as_str().unwrap();
+        assert!(stringified.contains("\"key\": \"value\""));
+    }
+
     #[test]
     fn test_json_tool_schema_data_is_freeform() {
         let schema = JsonTool.parameters_schema();

src/tools/builtin/message.rs

@@ -533,41 +533,53 @@ mod tests {
         );
     }
 
-    /// Regression test: requires_approval() is a sync method called from async context.
-    /// With tokio::sync::RwLock, this would panic with:
-    ///   "Cannot block the current thread from within a runtime"
-    /// because blocking_read() cannot be called inside an async runtime.
-    /// With std::sync::RwLock, it works correctly since std locks are safe
-    /// for short-held locks in sync methods called from async contexts.
-    #[tokio::test]
-    async fn requires_approval_works_from_async_context() {
-        let tool = MessageTool::new(Arc::new(ChannelManager::new()));
+    // ── Multi-thread runtime safety tests ─────────────────────────────
 
-        // Set context asynchronously (simulating real usage pattern)
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn requires_approval_no_channel_multi_thread() {
+        let tool = MessageTool::new(Arc::new(ChannelManager::new()));
+        // No channel set, no channel param - should not panic in multi-thread runtime
+        let result = tool.requires_approval(&serde_json::json!({"content": "hello"}));
+        assert_eq!(result, ApprovalRequirement::UnlessAutoApproved);
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn requires_approval_with_context_multi_thread() {
+        let tool = MessageTool::new(Arc::new(ChannelManager::new()));
         tool.set_context(Some("signal".to_string()), Some("+1234567890".to_string()))
             .await;
 
-        // Call requires_approval (sync method) from async context.
-        // This is the critical test: with tokio::sync::RwLock::blocking_read(),
-        // this would panic. With std::sync::RwLock::read(), it works.
-        let approval = tool.requires_approval(&serde_json::json!({
+        // No channel param - uses default, less risky
+        let result = tool.requires_approval(&serde_json::json!({"content": "hello"}));
+        assert_eq!(result, ApprovalRequirement::UnlessAutoApproved);
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn requires_approval_cross_channel_multi_thread() {
+        let tool = MessageTool::new(Arc::new(ChannelManager::new()));
+        tool.set_context(Some("signal".to_string()), Some("+1234567890".to_string()))
+            .await;
+
+        // Different channel than default requires approval
+        let result = tool.requires_approval(&serde_json::json!({
             "content": "hello",
             "channel": "telegram"
         }));
-        // Different channel from default -> Always
-        assert!(matches!(approval, ApprovalRequirement::Always));
+        assert_eq!(result, ApprovalRequirement::Always);
+    }
 
-        // No channel specified (uses default) -> UnlessAutoApproved
-        let approval = tool.requires_approval(&serde_json::json!({
-            "content": "hello"
-        }));
-        assert!(matches!(approval, ApprovalRequirement::UnlessAutoApproved));
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn requires_approval_same_channel_explicit_multi_thread() {
+        let tool = MessageTool::new(Arc::new(ChannelManager::new()));
+        tool.set_context(Some("signal".to_string()), Some("+1234567890".to_string()))
+            .await;
 
-        // Explicit channel (even if same as default) -> Always
-        let approval = tool.requires_approval(&serde_json::json!({
+        // Explicit channel that matches default still returns Always
+        // (existing behavior: any explicit channel param triggers Always)
+        let result = tool.requires_approval(&serde_json::json!({
             "content": "hello",
             "channel": "signal"
         }));
-        assert!(matches!(approval, ApprovalRequirement::Always));
+        assert_eq!(result, ApprovalRequirement::Always);
     }
 }

src/tools/builtin/mod.rs

@@ -9,16 +9,17 @@ mod json;
 mod memory;
 mod message;
 pub mod path_utils;
+mod restart;
 pub mod routine;
 pub mod secrets_tools;
 pub(crate) mod shell;
 pub mod skill_tools;
 mod time;
-mod web_fetch;
 
 pub use echo::EchoTool;
 pub use extension_tools::{
-    ToolActivateTool, ToolAuthTool, ToolInstallTool, ToolListTool, ToolRemoveTool, ToolSearchTool,
+    ExtensionInfoTool, ToolActivateTool, ToolAuthTool, ToolInstallTool, ToolListTool,
+    ToolRemoveTool, ToolSearchTool,
 };
 pub use file::{ApplyPatchTool, ListDirTool, ReadFileTool, WriteFileTool};
 pub use http::HttpTool;
@@ -29,6 +30,7 @@ pub use job::{
 pub use json::JsonTool;
 pub use memory::{MemoryReadTool, MemorySearchTool, MemoryTreeTool, MemoryWriteTool};
 pub use message::MessageTool;
+pub use restart::RestartTool;
 pub use routine::{
     RoutineCreateTool, RoutineDeleteTool, RoutineHistoryTool, RoutineListTool, RoutineUpdateTool,
 };
@@ -36,8 +38,6 @@ pub use secrets_tools::{SecretDeleteTool, SecretListTool};
 pub use shell::ShellTool;
 pub use skill_tools::{SkillInstallTool, SkillListTool, SkillRemoveTool, SkillSearchTool};
 pub use time::TimeTool;
-pub use web_fetch::WebFetchTool;
-
 mod html_converter;
 
 pub use html_converter::convert_html_to_markdown;

src/tools/builtin/restart.rs

@@ -0,0 +1,483 @@
+//! Restart tool for graceful process restart.
+//!
+//! ## Architecture
+//!
+//! IronClaw runs inside a Docker container with an entrypoint loop that monitors exit codes:
+//! - **Exit code 0** (clean): Reset failure counter, wait `IRONCLAW_RESTART_DELAY` (default 5s), restart
+//! - **Exit code ≠ 0** (failure): Increment failure counter, exit after `IRONCLAW_MAX_FAILURES` (default 10)
+//!
+//! This tool triggers a restart by calling `std::process::exit(0)` after a brief delay, allowing
+//! the HTTP response to be flushed before the process terminates. The entrypoint loop then
+//! detects the clean exit and automatically restarts the process.
+//!
+//! ## Security
+//!
+//! - **Approval Model:** User approval happens at the command level via web modal confirmation,
+//!   not at tool execution level. This allows approved commands to execute in autonomous jobs.
+//! - **Web-Only Access:** The `/restart` command only works via the web gateway (enforced in commands.rs)
+//! - **Parameter Validation:** Delay clamped to 1-30 seconds
+//!
+//! ## Known Limitations
+//!
+//! - Hard exit without graceful shutdown (no destructor cleanup, no RwLock drains)
+//! - In-flight jobs are paused during restart and resumed by the entrypoint
+//! - Future: Implement graceful shutdown with CancellationToken for proper resource cleanup
+
+use async_trait::async_trait;
+use std::time::Duration;
+
+use crate::context::JobContext;
+#[allow(unused_imports)]
+use crate::tools::tool::{ApprovalRequirement, Tool, ToolError, ToolOutput};
+
+/// Tool for triggering a graceful process restart via exit code 0.
+///
+/// This tool signals the Docker entrypoint loop to restart the process by exiting cleanly
+/// (exit code 0). User approval happens at the command level (via the web modal confirmation),
+/// not at tool execution level. The `/restart` command is only callable via the web gateway
+/// interface to prevent unauthorized restarts.
+pub struct RestartTool;
+
+#[async_trait]
+impl Tool for RestartTool {
+    fn name(&self) -> &str {
+        "restart"
+    }
+
+    fn description(&self) -> &str {
+        "Restart the IronClaw agent process. The process exits cleanly (code 0) and the \
+         container entrypoint loop restarts it automatically within a few seconds."
+    }
+
+    fn parameters_schema(&self) -> serde_json::Value {
+        serde_json::json!({
+            "type": "object",
+            "properties": {
+                "delay_secs": {
+                    "type": "integer",
+                    "description": "Seconds to wait before exiting (default: 2, min: 1, max: 30)",
+                    "minimum": 1,
+                    "maximum": 30
+                }
+            }
+        })
+    }
+
+    async fn execute(
+        &self,
+        params: serde_json::Value,
+        _ctx: &JobContext,
+    ) -> Result<ToolOutput, ToolError> {
+        tracing::info!("[RestartTool::execute] Restart tool invoked");
+        let start = std::time::Instant::now();
+
+        // Check if running inside a Docker container via IRONCLAW_IN_DOCKER env var.
+        // The Docker entrypoint sets this to "true". For local development, it's unset or "false".
+        // The entrypoint restart loop only works inside a Docker container (ironclaw-worker).
+        let in_docker = std::env::var("IRONCLAW_IN_DOCKER")
+            .map(|v| v.to_lowercase() == "true")
+            .unwrap_or(false);
+
+        tracing::debug!("[RestartTool::execute] IRONCLAW_IN_DOCKER={}", in_docker);
+
+        if !in_docker {
+            tracing::error!("[RestartTool::execute] Not in Docker, rejecting restart");
+            return Err(ToolError::ExecutionFailed(
+                "Restart is only available when running inside the Docker container. \
+                 For local development, please restart IronClaw manually."
+                    .to_string(),
+            ));
+        }
+
+        // Extract delay_secs parameter, defaulting to 2 seconds
+        let delay = params
+            .get("delay_secs")
+            .and_then(|v| v.as_u64())
+            .unwrap_or(2)
+            // Validate delay against schema bounds (1-30 seconds)
+            .clamp(1, 30);
+        tracing::info!("[RestartTool::execute] Delay set to {} seconds", delay);
+
+        // Spawn a background task so the response is flushed before exit.
+        // We use std::process::exit(0) to trigger a Docker container restart:
+        //
+        // - The ironclaw-worker Docker container runs an entrypoint loop that monitors
+        //   the exit code of the `ironclaw run` process:
+        //   * Exit code 0 = clean restart: reset failure counter, wait IRONCLAW_RESTART_DELAY
+        //     (default 5s), then restart the process
+        //   * Exit code ≠ 0 = failure: increment counter, exit after IRONCLAW_MAX_FAILURES
+        //     (default 10 failures)
+        //
+        // - std::process::exit(0) is a hard exit (no destructors, no graceful shutdown).
+        //   This is intentional because:
+        //   1. The HTTP response must be sent before exit (hence tokio::spawn + delay)
+        //   2. In-flight jobs are paused/resumed by the entrypoint loop
+        //   3. Database connections are pooled and reopened on restart
+        //   4. The brief delay allows the response to flush before termination
+        //
+        // - Future improvement: implement graceful shutdown with CancellationToken
+        //   to properly drain Axum, close DB connections, and checkpoint jobs.
+        // Check if restart is disabled (e.g., in tests). This allows tests to verify
+        // parameter parsing and output without actually terminating the process.
+        let restart_disabled = std::env::var("IRONCLAW_DISABLE_RESTART")
+            .map(|v| {
+                let v = v.to_lowercase();
+                v == "1" || v == "true"
+            })
+            .unwrap_or(false);
+
+        tracing::info!(
+            "[RestartTool::execute] Spawning background task to exit in {} seconds (disabled={})",
+            delay,
+            restart_disabled
+        );
+        tokio::spawn(async move {
+            tracing::info!("[RestartTool] Sleeping for {} seconds before exit", delay);
+            tokio::time::sleep(Duration::from_secs(delay)).await;
+            if !restart_disabled {
+                tracing::warn!("[RestartTool] Calling std::process::exit(0) NOW");
+                std::process::exit(0);
+            } else {
+                tracing::info!(
+                    "[RestartTool] Exit disabled (IRONCLAW_DISABLE_RESTART set), skipping std::process::exit(0)"
+                );
+            }
+        });
+
+        let msg = format!(
+            "Restarting in {delay} second(s). The process will exit cleanly and the \
+             entrypoint restart loop will bring IronClaw back online."
+        );
+        tracing::info!("[RestartTool::execute] Returning success response: {}", msg);
+        Ok(ToolOutput::text(msg, start.elapsed()))
+    }
+
+    fn requires_sanitization(&self) -> bool {
+        false
+    }
+
+    // NOTE: Approval is handled at the command level (/restart via web modal confirmation),
+    // not at the tool execution level. By the time the tool executes, the user has already
+    // confirmed via the web interface. So we don't require approval here.
+    // This allows the tool to execute in autonomous jobs created from approved commands.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Helper to simulate Docker environment for testing
+    fn enable_docker_env() {
+        unsafe {
+            std::env::set_var("IRONCLAW_IN_DOCKER", "true");
+        }
+    }
+
+    #[test]
+    fn test_restart_tool_approval_handled_at_command_level() {
+        // Approval is handled at the /restart command level (web modal confirmation),
+        // not at tool execution. Tool execution approval is for user-interactive approvals
+        // that happen during job execution. The restart confirmation modal provides that gate.
+        let tool = RestartTool;
+        let approval = tool.requires_approval(&serde_json::json!({}));
+        // Default (Never) allows tool to execute in autonomous jobs created from approved commands
+        assert!(matches!(approval, ApprovalRequirement::Never));
+    }
+
+    #[test]
+    fn test_restart_tool_name() {
+        let tool = RestartTool;
+        assert_eq!(tool.name(), "restart");
+    }
+
+    #[test]
+    fn test_restart_tool_parameters_schema() {
+        let tool = RestartTool;
+        let schema = tool.parameters_schema();
+
+        // Verify schema has delay_secs property with bounds
+        let props = schema.get("properties").unwrap();
+        assert!(props.get("delay_secs").is_some());
+
+        let delay_schema = props.get("delay_secs").unwrap();
+        assert_eq!(delay_schema.get("minimum").unwrap().as_u64().unwrap(), 1);
+        assert_eq!(delay_schema.get("maximum").unwrap().as_u64().unwrap(), 30);
+    }
+
+    #[test]
+    fn test_restart_tool_requires_sanitization() {
+        let tool = RestartTool;
+        assert!(!tool.requires_sanitization());
+    }
+
+    #[tokio::test]
+    async fn test_restart_tool_delay_parameter_validation() {
+        enable_docker_env();
+        let tool = RestartTool;
+        let ctx = crate::context::JobContext::new("test", "test restart");
+
+        // Test with valid delay
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": 5}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().expect("result should be a string");
+        assert!(text.contains("Restarting in 5 second(s)"));
+
+        // Test with no delay parameter (should use default 2)
+        let result = tool.execute(serde_json::json!({}), &ctx).await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().expect("result should be a string");
+        assert!(text.contains("Restarting in 2 second(s)"));
+    }
+
+    #[tokio::test]
+    async fn test_restart_tool_delay_clamping() {
+        enable_docker_env();
+        let tool = RestartTool;
+        let ctx = crate::context::JobContext::new("test", "test restart");
+
+        // Test with too small delay (should clamp to 1)
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": 0}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().expect("result should be a string");
+        assert!(text.contains("Restarting in 1 second(s)"));
+
+        // Test with too large delay (should clamp to 30)
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": 100}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().expect("result should be a string");
+        assert!(text.contains("Restarting in 30 second(s)"));
+    }
+
+    #[test]
+    fn test_restart_tool_description() {
+        let tool = RestartTool;
+        let desc = tool.description();
+        assert!(desc.contains("Restart"));
+        assert!(desc.contains("IronClaw"));
+        assert!(desc.contains("exits cleanly"));
+        assert!(desc.contains("code 0"));
+    }
+
+    #[test]
+    fn test_restart_tool_schema_completeness() {
+        let tool = RestartTool;
+        let schema = tool.parameters_schema();
+
+        // Verify schema structure
+        assert_eq!(schema.get("type").unwrap().as_str().unwrap(), "object");
+
+        let props = schema.get("properties").unwrap();
+        assert!(props.is_object());
+
+        let delay_schema = props.get("delay_secs").unwrap();
+        assert_eq!(
+            delay_schema.get("type").unwrap().as_str().unwrap(),
+            "integer"
+        );
+        assert!(delay_schema.get("description").is_some());
+    }
+
+    #[tokio::test]
+    async fn test_restart_tool_boundary_values() {
+        enable_docker_env();
+        let tool = RestartTool;
+        let ctx = crate::context::JobContext::new("test", "test restart");
+
+        // Test minimum boundary (exactly 1)
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": 1}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().unwrap();
+        assert!(text.contains("Restarting in 1 second(s)"));
+
+        // Test maximum boundary (exactly 30)
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": 30}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().unwrap();
+        assert!(text.contains("Restarting in 30 second(s)"));
+
+        // Test middle value
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": 15}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().unwrap();
+        assert!(text.contains("Restarting in 15 second(s)"));
+    }
+
+    #[tokio::test]
+    async fn test_restart_tool_invalid_parameter_types() {
+        enable_docker_env();
+        let tool = RestartTool;
+        let ctx = crate::context::JobContext::new("test", "test restart");
+
+        // String instead of integer - should use default
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": "5"}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().unwrap();
+        assert!(text.contains("Restarting in 2 second(s)")); // Falls back to default
+
+        // Null value - should use default
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": null}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().unwrap();
+        assert!(text.contains("Restarting in 2 second(s)"));
+
+        // Float value - should use default (as_u64 fails on floats)
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": 5.5}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().unwrap();
+        assert!(text.contains("Restarting in 2 second(s)"));
+    }
+
+    #[tokio::test]
+    async fn test_restart_tool_output_structure() {
+        enable_docker_env();
+        let tool = RestartTool;
+        let ctx = crate::context::JobContext::new("test", "test restart");
+
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": 5}), &ctx)
+            .await;
+
+        assert!(result.is_ok());
+        let output = result.unwrap();
+
+        // Verify ToolOutput structure
+        assert!(output.result.is_string());
+        assert!(output.duration.as_secs() == 0); // Should be nearly instant
+        assert!(output.cost.is_none()); // No cost tracking for restart
+        assert!(output.raw.is_none()); // No raw output stored
+    }
+
+    #[tokio::test]
+    async fn test_restart_tool_extra_parameters_ignored() {
+        enable_docker_env();
+        let tool = RestartTool;
+        let ctx = crate::context::JobContext::new("test", "test restart");
+
+        // Extra parameters should be ignored
+        let result = tool
+            .execute(
+                serde_json::json!({
+                    "delay_secs": 5,
+                    "extra_field": "should be ignored",
+                    "another": 123
+                }),
+                &ctx,
+            )
+            .await;
+
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().unwrap();
+        assert!(text.contains("Restarting in 5 second(s)"));
+    }
+
+    #[tokio::test]
+    async fn test_restart_tool_negative_numbers() {
+        enable_docker_env();
+        let tool = RestartTool;
+        let ctx = crate::context::JobContext::new("test", "test restart");
+
+        // Negative number should clamp to 1
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": -5}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().unwrap();
+        // as_u64() on negative number returns None, so falls to default 2
+        assert!(text.contains("Restarting in 2 second(s)"));
+    }
+
+    #[tokio::test]
+    async fn test_restart_tool_very_large_numbers() {
+        enable_docker_env();
+        let tool = RestartTool;
+        let ctx = crate::context::JobContext::new("test", "test restart");
+
+        // Very large number should clamp to 30
+        let result = tool
+            .execute(serde_json::json!({"delay_secs": u64::MAX}), &ctx)
+            .await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().unwrap();
+        assert!(text.contains("Restarting in 30 second(s)"));
+    }
+
+    #[tokio::test]
+    async fn test_restart_tool_empty_object() {
+        enable_docker_env();
+        let tool = RestartTool;
+        let ctx = crate::context::JobContext::new("test", "test restart");
+
+        // Empty object params should use all defaults
+        let result = tool.execute(serde_json::json!({}), &ctx).await;
+        assert!(result.is_ok());
+        let output = result.unwrap();
+        let text = output.result.as_str().unwrap();
+        assert!(text.contains("Restarting in 2 second(s)"));
+        assert!(text.contains("exit cleanly"));
+        assert!(text.contains("entrypoint restart loop"));
+    }
+
+    #[test]
+    fn test_restart_tool_approval_consistent_regardless_of_params() {
+        let tool = RestartTool;
+
+        // Approval requirement should be the same regardless of params
+        let approval1 = tool.requires_approval(&serde_json::json!({"delay_secs": 5}));
+        let approval2 = tool.requires_approval(&serde_json::json!({"delay_secs": 100}));
+        let approval3 = tool.requires_approval(&serde_json::json!({}));
+
+        // All should return the default (Never) since approval happens at command level
+        assert!(matches!(approval1, ApprovalRequirement::Never));
+        assert!(matches!(approval2, ApprovalRequirement::Never));
+        assert!(matches!(approval3, ApprovalRequirement::Never));
+    }
+
+    #[test]
+    fn test_restart_tool_requires_docker_environment() {
+        // Test that restart is rejected when not in Docker (IRONCLAW_IN_DOCKER not set or false)
+        // Uses sync test to avoid async/env var ordering issues with test parallelization.
+        let in_docker = std::env::var("IRONCLAW_IN_DOCKER")
+            .map(|v| v.to_lowercase() == "true")
+            .unwrap_or(false);
+
+        // Verify logic: when not in Docker, env var should be false/unset
+        if !in_docker {
+            // Simulating what the tool would do when IRONCLAW_IN_DOCKER is not set
+            assert!(
+                !in_docker,
+                "Test environment should have IRONCLAW_IN_DOCKER unset or false"
+            );
+        }
+    }
+}

src/tools/builtin/web_fetch.rs

@@ -1,378 +0,0 @@
-//! Web fetch tool — GET a URL and return its content as clean Markdown.
-//!
-//! Distinct from the generic `http` tool (which handles API calls with full
-//! method/header/body control). `web_fetch` is purpose-built for reading web
-//! pages, articles, and documentation:
-//!
-//! - GET-only, no custom headers or body
-//! - Always attempts HTML → Markdown conversion via Readability
-//! - Returns structured output: `{url, final_url, status, title, content, word_count}`
-//! - Auto-approved (no confirmation prompt)
-//! - Follows up to 3 redirects, SSRF-validating each hop
-//!
-//! All the same security infrastructure as `http`:
-//! HTTPS-only, SSRF protection, DNS rebinding defence, outbound/inbound leak
-//! scanning, 5 MB response cap.
-
-use std::time::{Duration, Instant};
-
-use async_trait::async_trait;
-use futures::StreamExt;
-use reqwest::Client;
-
-use crate::context::JobContext;
-use crate::safety::LeakDetector;
-use crate::tools::builtin::http::validate_url;
-use crate::tools::tool::{ApprovalRequirement, Tool, ToolError, ToolOutput, ToolRateLimitConfig};
-
-#[cfg(feature = "html-to-markdown")]
-use crate::tools::builtin::convert_html_to_markdown;
-
-/// Maximum response body size — matches the `http` tool limit.
-const MAX_RESPONSE_SIZE: usize = 5 * 1024 * 1024;
-
-/// Maximum number of redirects to follow before giving up.
-const MAX_REDIRECTS: usize = 3;
-
-/// Chrome-like User-Agent — many sites block default `reqwest` strings.
-const USER_AGENT: &str = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) \
-    AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
-
-/// Extract the `<title>` text from raw HTML without a full DOM parser.
-///
-/// Uses `to_ascii_lowercase()` (not `to_lowercase()`) so that byte offsets
-/// remain valid across both strings.  HTML tag names are ASCII-only, so
-/// ASCII-only case folding is sufficient.  Unicode `to_lowercase()` can
-/// change byte lengths (e.g. `İ` → `i\u{307}`), making offsets derived
-/// from the lowercased string invalid when used to index into the original.
-fn extract_title(html: &str) -> Option<String> {
-    let lower = html.to_ascii_lowercase();
-    let tag_start = lower.find("<title")?;
-    let tag_end = html[tag_start..].find('>')? + tag_start + 1;
-    let close = lower[tag_end..].find("</title>")? + tag_end;
-    let title = html[tag_end..close].trim().to_string();
-    if title.is_empty() { None } else { Some(title) }
-}
-
-/// Web fetch tool — retrieve a URL and return clean Markdown content.
-pub struct WebFetchTool {
-    client: Client,
-    leak_detector: LeakDetector,
-}
-
-impl WebFetchTool {
-    /// Create a new `WebFetchTool` with a Chrome-like UA and no auto-redirects.
-    ///
-    /// Redirects are followed manually (up to [`MAX_REDIRECTS`] hops) so that
-    /// each `Location` URL is SSRF-validated before the next request is sent.
-    pub fn new() -> Self {
-        let client = Client::builder()
-            .timeout(Duration::from_secs(30))
-            .redirect(reqwest::redirect::Policy::none())
-            .user_agent(USER_AGENT)
-            .build()
-            .expect("Failed to create HTTP client for web_fetch");
-
-        Self {
-            client,
-            leak_detector: LeakDetector::new(),
-        }
-    }
-}
-
-impl Default for WebFetchTool {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[async_trait]
-impl Tool for WebFetchTool {
-    fn name(&self) -> &str {
-        "web_fetch"
-    }
-
-    fn description(&self) -> &str {
-        "Fetch a URL and extract its content as clean Markdown. \
-         Use for reading articles, documentation, and web pages. \
-         For API calls (POST, custom headers, authentication), use the `http` tool instead."
-    }
-
-    fn parameters_schema(&self) -> serde_json::Value {
-        serde_json::json!({
-            "type": "object",
-            "properties": {
-                "url": {
-                    "type": "string",
-                    "description": "HTTPS URL to fetch. Must be a public URL (no localhost or private IPs)."
-                }
-            },
-            "required": ["url"],
-            "additionalProperties": false
-        })
-    }
-
-    async fn execute(
-        &self,
-        params: serde_json::Value,
-        _ctx: &JobContext,
-    ) -> Result<ToolOutput, ToolError> {
-        let start = Instant::now();
-
-        let url_str = params
-            .get("url")
-            .and_then(|v| v.as_str())
-            .ok_or_else(|| ToolError::InvalidParameters("'url' is required".to_string()))?;
-
-        // SSRF defence: HTTPS-only, no localhost, no private IPs, DNS rebinding check.
-        let mut current_url = validate_url(url_str)?;
-
-        // Outbound leak scan — reject if URL contains secrets.
-        self.leak_detector
-            .scan_http_request(current_url.as_str(), &[], None)
-            .map_err(|e| ToolError::NotAuthorized(e.to_string()))?;
-
-        // Follow redirects manually so every hop is SSRF-validated.
-        let response = {
-            let mut redirects_remaining = MAX_REDIRECTS;
-            loop {
-                let resp = self
-                    .client
-                    .get(current_url.clone())
-                    .header(
-                        reqwest::header::ACCEPT,
-                        "text/markdown, text/html;q=0.9, */*;q=0.8",
-                    )
-                    .send()
-                    .await
-                    .map_err(|e| {
-                        if e.is_timeout() {
-                            ToolError::Timeout(Duration::from_secs(30))
-                        } else {
-                            ToolError::ExternalService(e.to_string())
-                        }
-                    })?;
-
-                let status = resp.status().as_u16();
-
-                if (300..400).contains(&status) {
-                    if redirects_remaining == 0 {
-                        return Err(ToolError::ExecutionFailed(format!(
-                            "too many redirects (max {})",
-                            MAX_REDIRECTS
-                        )));
-                    }
-
-                    let location = resp
-                        .headers()
-                        .get(reqwest::header::LOCATION)
-                        .and_then(|v| v.to_str().ok())
-                        .ok_or_else(|| {
-                            ToolError::ExecutionFailed(format!(
-                                "redirect (HTTP {}) has no Location header",
-                                status
-                            ))
-                        })?;
-
-                    // Resolve relative redirects against the current URL.
-                    let next_url_str =
-                        if location.starts_with("http://") || location.starts_with("https://") {
-                            location.to_string()
-                        } else {
-                            // Relative redirect — join with current URL.
-                            current_url
-                                .join(location)
-                                .map(|u| u.to_string())
-                                .map_err(|e| {
-                                    ToolError::ExecutionFailed(format!(
-                                        "could not resolve relative redirect '{}': {}",
-                                        location, e
-                                    ))
-                                })?
-                        };
-
-                    // SSRF re-validation on every hop.
-                    current_url = validate_url(&next_url_str)?;
-                    self.leak_detector
-                        .scan_http_request(current_url.as_str(), &[], None)
-                        .map_err(|e| ToolError::NotAuthorized(e.to_string()))?;
-
-                    redirects_remaining -= 1;
-                    tracing::debug!(
-                        to = %current_url,
-                        hops_left = redirects_remaining,
-                        "web_fetch following redirect"
-                    );
-                    continue;
-                }
-
-                break resp;
-            }
-        };
-
-        let status = response.status().as_u16();
-
-        // Detect content type before consuming the response.
-        let content_type = response
-            .headers()
-            .get(reqwest::header::CONTENT_TYPE)
-            .and_then(|v| v.to_str().ok())
-            .unwrap_or("")
-            .to_lowercase();
-
-        // Pre-check Content-Length to reject obviously oversized responses.
-        if let Some(content_length) = response.headers().get(reqwest::header::CONTENT_LENGTH)
-            && let Ok(s) = content_length.to_str()
-            && let Ok(len) = s.parse::<usize>()
-            && len > MAX_RESPONSE_SIZE
-        {
-            return Err(ToolError::ExecutionFailed(format!(
-                "Response Content-Length ({} bytes) exceeds maximum allowed size ({} bytes)",
-                len, MAX_RESPONSE_SIZE
-            )));
-        }
-
-        // Stream body with a hard 5 MB cap.
-        let mut body: Vec<u8> = Vec::new();
-        let mut stream = response.bytes_stream();
-        while let Some(chunk) = StreamExt::next(&mut stream).await {
-            let chunk = chunk.map_err(|e| {
-                ToolError::ExternalService(format!("failed to read response body: {}", e))
-            })?;
-            if body.len() + chunk.len() > MAX_RESPONSE_SIZE {
-                return Err(ToolError::ExecutionFailed(format!(
-                    "Response body exceeds maximum allowed size ({} bytes)",
-                    MAX_RESPONSE_SIZE
-                )));
-            }
-            body.extend_from_slice(&chunk);
-        }
-
-        let raw_text = String::from_utf8_lossy(&body).into_owned();
-
-        // HTML → Markdown conversion (always attempted for HTML responses).
-        let is_html = content_type.contains("text/html");
-
-        let (content, title) = if is_html {
-            let title = extract_title(&raw_text);
-
-            #[cfg(feature = "html-to-markdown")]
-            let content = match convert_html_to_markdown(&raw_text, current_url.as_str()) {
-                Ok(md) => md,
-                Err(e) => {
-                    tracing::warn!(
-                        url = %current_url,
-                        error = %e,
-                        "HTML-to-markdown conversion failed, returning raw text"
-                    );
-                    raw_text.clone()
-                }
-            };
-
-            #[cfg(not(feature = "html-to-markdown"))]
-            let content = raw_text.clone();
-
-            (content, title)
-        } else {
-            (raw_text.clone(), None)
-        };
-
-        let word_count = content.split_whitespace().count();
-
-        let result = serde_json::json!({
-            "url": url_str,
-            "final_url": current_url.as_str(),
-            "status": status,
-            "title": title,
-            "content": content,
-            "word_count": word_count,
-        });
-
-        Ok(ToolOutput::success(result, start.elapsed()).with_raw(raw_text))
-    }
-
-    fn estimated_duration(&self, _params: &serde_json::Value) -> Option<Duration> {
-        Some(Duration::from_secs(5))
-    }
-
-    fn requires_sanitization(&self) -> bool {
-        true // External data always needs sanitization
-    }
-
-    fn requires_approval(&self, _params: &serde_json::Value) -> ApprovalRequirement {
-        // Web fetch is always auto-approved — the SSRF/leak protections are
-        // unconditional, and reading public web pages doesn't require confirmation.
-        ApprovalRequirement::Never
-    }
-
-    fn rate_limit_config(&self) -> Option<ToolRateLimitConfig> {
-        Some(ToolRateLimitConfig::new(30, 500)) // same as http tool
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn extract_title_finds_basic_title() {
-        let html = "<html><head><title>Hello World</title></head><body></body></html>";
-        assert_eq!(extract_title(html), Some("Hello World".to_string()));
-    }
-
-    #[test]
-    fn extract_title_trims_whitespace() {
-        let html = "<html><head><title>  Spaced Title  </title></head></html>";
-        assert_eq!(extract_title(html), Some("Spaced Title".to_string()));
-    }
-
-    #[test]
-    fn extract_title_returns_none_when_absent() {
-        let html = "<html><head></head><body>No title</body></html>";
-        assert_eq!(extract_title(html), None);
-    }
-
-    #[test]
-    fn extract_title_handles_case_insensitive_tag() {
-        let html = "<html><head><TITLE>Case Test</TITLE></head></html>";
-        assert_eq!(extract_title(html), Some("Case Test".to_string()));
-    }
-
-    #[test]
-    fn extract_title_with_non_ascii_before_tag() {
-        // Turkish dotless-ı (U+0131) is 2 bytes in UTF-8 and lowercases to
-        // ASCII 'i' (1 byte).  Using to_lowercase() would shift the byte offset
-        // of '<title>' so that html[tag_start..] panics at a non-char boundary.
-        // to_ascii_lowercase() preserves byte lengths and must not panic.
-        let html = "<html><head><meta charset=\"utf-8\"/><title>ıTitle</title></head></html>";
-        let result = extract_title(html);
-        assert!(
-            result.is_some(),
-            "should extract title with non-ASCII content"
-        );
-        assert!(result.unwrap().contains("Title"));
-    }
-
-    #[test]
-    fn extract_title_with_tag_attributes() {
-        // <title lang="en"> has attributes — ensure the '>' scan still lands correctly.
-        let html = "<html><head><title lang=\"en\">Attributed</title></head></html>";
-        assert_eq!(extract_title(html), Some("Attributed".to_string()));
-    }
-
-    #[test]
-    fn web_fetch_tool_name_and_schema() {
-        let tool = WebFetchTool::new();
-        assert_eq!(tool.name(), "web_fetch");
-        let schema = tool.parameters_schema();
-        assert_eq!(schema["required"][0], "url");
-        assert_eq!(schema["properties"]["url"]["type"], "string");
-    }
-
-    #[test]
-    fn web_fetch_never_requires_approval() {
-        let tool = WebFetchTool::new();
-        let params = serde_json::json!({"url": "https://example.com"});
-        assert_eq!(tool.requires_approval(&params), ApprovalRequirement::Never);
-    }
-}

src/tools/mcp/auth.rs

@@ -185,7 +185,7 @@ impl PkceChallenge {
     /// Generate a new PKCE challenge pair.
     pub fn generate() -> Self {
         let mut verifier_bytes = [0u8; 32];
-        rand::thread_rng().fill_bytes(&mut verifier_bytes);
+        rand::rngs::OsRng.fill_bytes(&mut verifier_bytes);
         let verifier = URL_SAFE_NO_PAD.encode(verifier_bytes);
 
         let mut hasher = Sha256::new();

src/tools/registry.rs

@@ -16,11 +16,12 @@ use crate::skills::catalog::SkillCatalog;
 use crate::skills::registry::SkillRegistry;
 use crate::tools::builder::{BuildSoftwareTool, BuilderConfig, LlmSoftwareBuilder};
 use crate::tools::builtin::{
-    ApplyPatchTool, CancelJobTool, CreateJobTool, EchoTool, HttpTool, JobEventsTool, JobPromptTool,
-    JobStatusTool, JsonTool, ListDirTool, ListJobsTool, MemoryReadTool, MemorySearchTool,
-    MemoryTreeTool, MemoryWriteTool, PromptQueue, ReadFileTool, ShellTool, SkillInstallTool,
-    SkillListTool, SkillRemoveTool, SkillSearchTool, TimeTool, ToolActivateTool, ToolAuthTool,
-    ToolInstallTool, ToolListTool, ToolRemoveTool, ToolSearchTool, WebFetchTool, WriteFileTool,
+    ApplyPatchTool, CancelJobTool, CreateJobTool, EchoTool, ExtensionInfoTool, HttpTool,
+    JobEventsTool, JobPromptTool, JobStatusTool, JsonTool, ListDirTool, ListJobsTool,
+    MemoryReadTool, MemorySearchTool, MemoryTreeTool, MemoryWriteTool, PromptQueue, ReadFileTool,
+    ShellTool, SkillInstallTool, SkillListTool, SkillRemoveTool, SkillSearchTool, TimeTool,
+    ToolActivateTool, ToolAuthTool, ToolInstallTool, ToolListTool, ToolRemoveTool, ToolSearchTool,
+    WriteFileTool,
 };
 use crate::tools::rate_limiter::RateLimiter;
 use crate::tools::tool::{Tool, ToolDomain};
@@ -69,6 +70,7 @@ const PROTECTED_TOOL_NAMES: &[&str] = &[
     "skill_remove",
     "message",
     "web_fetch",
+    "restart",
 ];
 
 /// Registry of available tools.
@@ -156,7 +158,8 @@ impl ToolRegistry {
 
     /// Get a tool by name.
     pub async fn get(&self, name: &str) -> Option<Arc<dyn Tool>> {
-        self.tools.read().await.get(name).cloned()
+        let tools = self.tools.read().await;
+        tools.get(name).map(Arc::clone)
     }
 
     /// Check if a tool exists.
@@ -169,6 +172,18 @@ impl ToolRegistry {
         self.tools.read().await.keys().cloned().collect()
     }
 
+    /// Retain only tools whose names are in the given allowlist.
+    ///
+    /// If `names` is empty, this is a no-op (all tools are kept).
+    pub async fn retain_only(&self, names: &[&str]) {
+        if names.is_empty() {
+            return;
+        }
+        let names_set: std::collections::HashSet<&str> = names.iter().copied().collect();
+        let mut tools = self.tools.write().await;
+        tools.retain(|k, _| names_set.contains(k.as_str()));
+    }
+
     /// Get the number of registered tools.
     pub fn count(&self) -> usize {
         self.tools.try_read().map(|t| t.len()).unwrap_or(0)
@@ -181,7 +196,8 @@ impl ToolRegistry {
 
     /// Get tool definitions for LLM function calling.
     pub async fn tool_definitions(&self) -> Vec<ToolDefinition> {
-        self.tools
+        let mut defs: Vec<ToolDefinition> = self
+            .tools
             .read()
             .await
             .values()
@@ -190,7 +206,9 @@ impl ToolRegistry {
                 description: tool.description().to_string(),
                 parameters: tool.parameters_schema(),
             })
-            .collect()
+            .collect();
+        defs.sort_unstable_by(|a, b| a.name.cmp(&b.name));
+        defs
     }
 
     /// Get tool definitions for specific tools.
@@ -198,11 +216,12 @@ impl ToolRegistry {
         let tools = self.tools.read().await;
         names
             .iter()
-            .filter_map(|name| tools.get(*name))
-            .map(|tool| ToolDefinition {
-                name: tool.name().to_string(),
-                description: tool.description().to_string(),
-                parameters: tool.parameters_schema(),
+            .filter_map(|name| {
+                tools.get(*name).map(|tool| ToolDefinition {
+                    name: tool.name().to_string(),
+                    description: tool.description().to_string(),
+                    parameters: tool.parameters_schema(),
+                })
             })
             .collect()
     }
@@ -218,7 +237,6 @@ impl ToolRegistry {
             http = http.with_credentials(Arc::clone(cr), Arc::clone(ss));
         }
         self.register_sync(Arc::new(http));
-        self.register_sync(Arc::new(WebFetchTool::new()));
 
         tracing::info!("Registered {} built-in tools", self.count());
     }
@@ -369,8 +387,9 @@ impl ToolRegistry {
         self.register_sync(Arc::new(ToolAuthTool::new(Arc::clone(&manager))));
         self.register_sync(Arc::new(ToolActivateTool::new(Arc::clone(&manager))));
         self.register_sync(Arc::new(ToolListTool::new(Arc::clone(&manager))));
-        self.register_sync(Arc::new(ToolRemoveTool::new(manager)));
-        tracing::info!("Registered 6 extension management tools");
+        self.register_sync(Arc::new(ToolRemoveTool::new(Arc::clone(&manager))));
+        self.register_sync(Arc::new(ExtensionInfoTool::new(manager)));
+        tracing::info!("Registered 7 extension management tools");
     }
 
     /// Register skill management tools (list, search, install, remove).
@@ -745,4 +764,111 @@ mod tests {
         assert_eq!(desc, original_desc);
         assert_ne!(desc, "EVIL SHADOW");
     }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+    async fn concurrent_register_and_read_no_panic() {
+        use std::sync::Arc as StdArc;
+
+        let registry = StdArc::new(ToolRegistry::new());
+        registry.register_builtin_tools();
+
+        // Spawn concurrent readers and check they don't panic
+        let mut handles = Vec::new();
+
+        // Readers
+        for _ in 0..10 {
+            let reg = StdArc::clone(&registry);
+            handles.push(tokio::spawn(async move {
+                let tools = reg.all().await;
+                assert!(!tools.is_empty());
+                let names = reg.list().await;
+                assert!(!names.is_empty());
+                let _ = reg.get("echo").await;
+                let _ = reg.has("echo").await;
+                let _ = reg.tool_definitions().await;
+            }));
+        }
+
+        // Concurrent register attempts (will be rejected as shadowing)
+        for _ in 0..5 {
+            let reg = StdArc::clone(&registry);
+            handles.push(tokio::spawn(async move {
+                // This will be rejected (echo is protected) but should not panic
+                reg.register(Arc::new(EchoTool)).await;
+            }));
+        }
+
+        for handle in handles {
+            handle.await.expect("task should not panic");
+        }
+    }
+
+    #[tokio::test]
+    async fn test_tool_definitions_sorted_alphabetically() {
+        // Create tools with names that would NOT be alphabetical if inserted in this order.
+        struct ToolZ;
+        struct ToolA;
+        struct ToolM;
+
+        macro_rules! impl_tool {
+            ($ty:ident, $name:expr) => {
+                #[async_trait::async_trait]
+                impl Tool for $ty {
+                    fn name(&self) -> &str {
+                        $name
+                    }
+                    fn description(&self) -> &str {
+                        $name
+                    }
+                    fn parameters_schema(&self) -> serde_json::Value {
+                        serde_json::json!({})
+                    }
+                    async fn execute(
+                        &self,
+                        _: serde_json::Value,
+                        _: &crate::context::JobContext,
+                    ) -> Result<crate::tools::tool::ToolOutput, crate::tools::tool::ToolError> {
+                        unreachable!()
+                    }
+                }
+            };
+        }
+
+        impl_tool!(ToolZ, "zebra");
+        impl_tool!(ToolA, "alpha");
+        impl_tool!(ToolM, "middle");
+
+        let registry = ToolRegistry::new();
+        // Register in non-alphabetical order
+        registry.register(Arc::new(ToolZ)).await;
+        registry.register(Arc::new(ToolA)).await;
+        registry.register(Arc::new(ToolM)).await;
+
+        let defs = registry.tool_definitions().await;
+        let names: Vec<&str> = defs.iter().map(|d| d.name.as_str()).collect();
+        assert_eq!(names, vec!["alpha", "middle", "zebra"]);
+    }
+
+    #[tokio::test]
+    async fn test_retain_only_filters_tools() {
+        let registry = ToolRegistry::new();
+        registry.register_builtin_tools();
+        let all = registry.list().await;
+        assert!(all.len() > 2, "expected multiple built-in tools");
+        registry.retain_only(&["echo", "time"]).await;
+        let remaining = registry.list().await;
+        assert_eq!(remaining.len(), 2);
+        assert!(remaining.contains(&"echo".to_string()));
+        assert!(remaining.contains(&"time".to_string()));
+    }
+
+    #[tokio::test]
+    async fn test_retain_only_empty_is_noop() {
+        let registry = ToolRegistry::new();
+        registry.register_builtin_tools();
+        let before = registry.list().await.len();
+        registry.retain_only(&[]).await;
+        let after = registry.list().await.len();
+        assert_eq!(before, after);
+    }
 }

src/tools/wasm/capabilities_schema.rs

@@ -41,6 +41,14 @@ use crate::tools::wasm::{
 /// Root schema for a capabilities JSON file.
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct CapabilitiesFile {
+    /// Extension version (semver).
+    #[serde(default)]
+    pub version: Option<String>,
+
+    /// WIT interface version this extension was compiled against (semver).
+    #[serde(default)]
+    pub wit_version: Option<String>,
+
     /// HTTP request capability.
     #[serde(default)]
     pub http: Option<HttpCapabilitySchema>,

src/tools/wasm/loader.rs

@@ -72,6 +72,9 @@ pub enum WasmLoadError {
 
     #[error("Invalid tool name: {0}")]
     InvalidName(String),
+
+    #[error("WIT version mismatch: {0}")]
+    WitVersionMismatch(String),
 }
 
 /// Loads WASM tools from files or storage into the registry.
@@ -127,6 +130,14 @@ impl WasmToolLoader {
                 let cap_file = CapabilitiesFile::from_bytes(&cap_bytes)
                     .map_err(|e| WasmLoadError::InvalidCapabilities(e.to_string()))?;
                 cap_file.validate(name);
+
+                // Check WIT version compatibility
+                check_wit_version_compat(
+                    name,
+                    cap_file.wit_version.as_deref(),
+                    crate::tools::wasm::WIT_TOOL_VERSION,
+                )?;
+
                 let caps = cap_file.to_capabilities();
                 let oauth = resolve_oauth_refresh_config(&cap_file);
                 (caps, oauth)
@@ -310,6 +321,61 @@ impl WasmToolLoader {
     }
 }
 
+/// Check that a declared WIT version is compatible with the host WIT version.
+///
+/// Compatibility rules (semver):
+/// - Same major version required (0.x is special: same minor required)
+/// - Extension WIT version must not be greater than host version
+///
+/// If `declared` is `None`, the check is skipped (pre-versioning extension).
+pub(crate) fn check_wit_version_compat(
+    name: &str,
+    declared: Option<&str>,
+    host_version: &str,
+) -> Result<(), WasmLoadError> {
+    let Some(declared_str) = declared else {
+        return Ok(());
+    };
+
+    let declared = semver::Version::parse(declared_str).map_err(|e| {
+        WasmLoadError::WitVersionMismatch(format!(
+            "Extension '{name}' has invalid wit_version '{declared_str}': {e}"
+        ))
+    })?;
+
+    let host = semver::Version::parse(host_version).map_err(|e| {
+        WasmLoadError::WitVersionMismatch(format!(
+            "Host WIT version '{host_version}' is invalid: {e}"
+        ))
+    })?;
+
+    // Major version must match
+    if declared.major != host.major {
+        return Err(WasmLoadError::WitVersionMismatch(format!(
+            "Extension '{name}' compiled against WIT {declared}, but host supports WIT {host}. \
+             Major version mismatch — rebuild the extension."
+        )));
+    }
+
+    // For 0.x versions, minor must also match (semver: 0.x.y has no compatibility guarantees)
+    if declared.major == 0 && declared.minor != host.minor {
+        return Err(WasmLoadError::WitVersionMismatch(format!(
+            "Extension '{name}' compiled against WIT {declared}, but host supports WIT {host}. \
+             Rebuild the extension against the current WIT."
+        )));
+    }
+
+    // Extension cannot be newer than host
+    if declared > host {
+        return Err(WasmLoadError::WitVersionMismatch(format!(
+            "Extension '{name}' compiled against WIT {declared}, but host only supports WIT {host}. \
+             Update the host or rebuild with an older WIT."
+        )));
+    }
+
+    Ok(())
+}
+
 /// Extract OAuth refresh configuration from a parsed capabilities file.
 ///
 /// Returns `None` if there's no `auth.oauth` section or if the client_id
@@ -615,7 +681,46 @@ mod tests {
 
     use tempfile::TempDir;
 
-    use crate::tools::wasm::loader::{WasmLoadError, discover_tools};
+    use crate::tools::wasm::loader::{WasmLoadError, check_wit_version_compat, discover_tools};
+
+    #[test]
+    fn wit_version_compat_none_is_ok() {
+        // Pre-versioning extensions (no wit_version declared) should always pass
+        assert!(check_wit_version_compat("test", None, "0.2.0").is_ok());
+    }
+
+    #[test]
+    fn wit_version_compat_exact_match() {
+        assert!(check_wit_version_compat("test", Some("0.2.0"), "0.2.0").is_ok());
+    }
+
+    #[test]
+    fn wit_version_compat_patch_older_ok() {
+        // Extension on older patch of same minor is compatible
+        assert!(check_wit_version_compat("test", Some("0.2.0"), "0.2.1").is_ok());
+    }
+
+    #[test]
+    fn wit_version_compat_minor_mismatch_0x() {
+        // For 0.x, different minor is breaking
+        assert!(check_wit_version_compat("test", Some("0.1.0"), "0.2.0").is_err());
+        assert!(check_wit_version_compat("test", Some("0.3.0"), "0.2.0").is_err());
+    }
+
+    #[test]
+    fn wit_version_compat_major_mismatch() {
+        assert!(check_wit_version_compat("test", Some("1.0.0"), "2.0.0").is_err());
+    }
+
+    #[test]
+    fn wit_version_compat_extension_newer_than_host() {
+        assert!(check_wit_version_compat("test", Some("0.2.1"), "0.2.0").is_err());
+    }
+
+    #[test]
+    fn wit_version_compat_invalid_version() {
+        assert!(check_wit_version_compat("test", Some("not-a-version"), "0.2.0").is_err());
+    }
 
     #[tokio::test]
     async fn test_discover_tools_empty_dir() {

src/tools/wasm/mod.rs

@@ -73,6 +73,15 @@
 //! let output = tool.execute(serde_json::json!({"input": "test"}), &ctx).await?;
 //! ```
 
+/// Host WIT version for tool extensions.
+///
+/// Extensions declaring a `wit_version` in their capabilities file are checked
+/// against this at load time: same major, not greater than host.
+pub const WIT_TOOL_VERSION: &str = "0.2.0";
+
+/// Host WIT version for channel extensions.
+pub const WIT_CHANNEL_VERSION: &str = "0.2.0";
+
 mod allowlist;
 mod capabilities;
 mod capabilities_schema;
@@ -80,10 +89,10 @@ pub(crate) mod credential_injector;
 mod error;
 mod host;
 mod limits;
-mod loader;
+pub(crate) mod loader;
 mod rate_limiter;
 mod runtime;
-mod storage;
+pub(crate) mod storage;
 mod wrapper;
 
 // Core types

src/tools/wasm/storage.rs

@@ -100,6 +100,7 @@ pub struct StoredWasmTool {
     pub user_id: String,
     pub name: String,
     pub version: String,
+    pub wit_version: String,
     pub description: String,
     pub parameters_schema: serde_json::Value,
     pub source_url: Option<String>,
@@ -244,6 +245,7 @@ pub struct StoreToolParams {
     pub user_id: String,
     pub name: String,
     pub version: String,
+    pub wit_version: String,
     pub description: String,
     pub wasm_binary: Vec<u8>,
     pub parameters_schema: serde_json::Value,
@@ -280,7 +282,7 @@ impl PostgresWasmToolStore {
 #[async_trait]
 impl WasmToolStore for PostgresWasmToolStore {
     async fn store(&self, params: StoreToolParams) -> Result<StoredWasmTool, WasmStorageError> {
-        let client = self
+        let mut client = self
             .pool
             .get()
             .await
@@ -290,22 +292,29 @@ impl WasmToolStore for PostgresWasmToolStore {
         let id = Uuid::new_v4();
         let now = Utc::now();
 
-        let row = client
+        // Wrap delete + insert in a transaction for atomicity
+        let tx = client
+            .transaction()
+            .await
+            .map_err(|e| WasmStorageError::Database(e.to_string()))?;
+
+        // Delete any existing version for this (user_id, name) — upgrade-in-place
+        tx.execute(
+            "DELETE FROM wasm_tools WHERE user_id = $1 AND name = $2",
+            &[&params.user_id, &params.name],
+        )
+        .await
+        .map_err(|e| WasmStorageError::Database(e.to_string()))?;
+
+        let row = tx
             .query_one(
                 r#"
                 INSERT INTO wasm_tools (
-                    id, user_id, name, version, description, wasm_binary, binary_hash,
+                    id, user_id, name, version, wit_version, description, wasm_binary, binary_hash,
                     parameters_schema, source_url, trust_level, status, created_at, updated_at
                 )
-                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, 'active', $11, $11)
-                ON CONFLICT (user_id, name, version) DO UPDATE SET
-                    description = EXCLUDED.description,
-                    wasm_binary = EXCLUDED.wasm_binary,
-                    binary_hash = EXCLUDED.binary_hash,
-                    parameters_schema = EXCLUDED.parameters_schema,
-                    source_url = EXCLUDED.source_url,
-                    updated_at = NOW()
-                RETURNING id, user_id, name, version, description, parameters_schema,
+                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, 'active', $12, $12)
+                RETURNING id, user_id, name, version, wit_version, description, parameters_schema,
                           source_url, trust_level, status, created_at, updated_at
                 "#,
                 &[
@@ -313,6 +322,7 @@ impl WasmToolStore for PostgresWasmToolStore {
                     &params.user_id,
                     &params.name,
                     &params.version,
+                    &params.wit_version,
                     &params.description,
                     &params.wasm_binary,
                     &binary_hash,
@@ -325,7 +335,13 @@ impl WasmToolStore for PostgresWasmToolStore {
             .await
             .map_err(|e| WasmStorageError::Database(e.to_string()))?;
 
-        row_to_tool(&row)
+        let tool = row_to_tool(&row)?;
+
+        tx.commit()
+            .await
+            .map_err(|e| WasmStorageError::Database(e.to_string()))?;
+
+        Ok(tool)
     }
 
     async fn get(&self, user_id: &str, name: &str) -> Result<StoredWasmTool, WasmStorageError> {
@@ -338,12 +354,10 @@ impl WasmToolStore for PostgresWasmToolStore {
         let row = client
             .query_opt(
                 r#"
-                SELECT id, user_id, name, version, description, parameters_schema,
+                SELECT id, user_id, name, version, wit_version, description, parameters_schema,
                        source_url, trust_level, status, created_at, updated_at
                 FROM wasm_tools
                 WHERE user_id = $1 AND name = $2 AND status = 'active'
-                ORDER BY version DESC
-                LIMIT 1
                 "#,
                 &[&user_id, &name],
             )
@@ -377,12 +391,10 @@ impl WasmToolStore for PostgresWasmToolStore {
         let row = client
             .query_opt(
                 r#"
-                SELECT id, user_id, name, version, description, wasm_binary, binary_hash,
+                SELECT id, user_id, name, version, wit_version, description, wasm_binary, binary_hash,
                        parameters_schema, source_url, trust_level, status, created_at, updated_at
                 FROM wasm_tools
                 WHERE user_id = $1 AND name = $2 AND status = 'active'
-                ORDER BY version DESC
-                LIMIT 1
                 "#,
                 &[&user_id, &name],
             )
@@ -482,11 +494,11 @@ impl WasmToolStore for PostgresWasmToolStore {
         let rows = client
             .query(
                 r#"
-                SELECT DISTINCT ON (name) id, user_id, name, version, description,
+                SELECT id, user_id, name, version, wit_version, description,
                        parameters_schema, source_url, trust_level, status, created_at, updated_at
                 FROM wasm_tools
                 WHERE user_id = $1
-                ORDER BY name, version DESC
+                ORDER BY name
                 "#,
                 &[&user_id],
             )
@@ -552,6 +564,7 @@ fn row_to_tool(row: &tokio_postgres::Row) -> Result<StoredWasmTool, WasmStorageE
         user_id: row.get("user_id"),
         name: row.get("name"),
         version: row.get("version"),
+        wit_version: row.get("wit_version"),
         description: row.get("description"),
         parameters_schema: row.get("parameters_schema"),
         source_url: row.get("source_url"),
@@ -605,33 +618,35 @@ impl WasmToolStore for LibSqlWasmToolStore {
         let schema_str = serde_json::to_string(&params.parameters_schema)
             .map_err(|e| WasmStorageError::InvalidData(e.to_string()))?;
 
-        // Wrap INSERT + read-back in a transaction to prevent TOCTOU races
+        // Wrap delete + INSERT + read-back in a transaction
         let conn = self.connect().await?;
         let tx = conn
             .transaction()
             .await
             .map_err(|e| WasmStorageError::Database(e.to_string()))?;
 
+        // Delete any existing version for this (user_id, name) — upgrade-in-place
+        tx.execute(
+            "DELETE FROM wasm_tools WHERE user_id = ?1 AND name = ?2",
+            libsql::params![params.user_id.as_str(), params.name.as_str()],
+        )
+        .await
+        .map_err(|e| WasmStorageError::Database(e.to_string()))?;
+
         tx.execute(
             r#"
                 INSERT INTO wasm_tools (
-                    id, user_id, name, version, description, wasm_binary, binary_hash,
+                    id, user_id, name, version, wit_version, description, wasm_binary, binary_hash,
                     parameters_schema, source_url, trust_level, status, created_at, updated_at
                 )
-                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, 'active', ?11, ?11)
-                ON CONFLICT (user_id, name, version) DO UPDATE SET
-                    description = excluded.description,
-                    wasm_binary = excluded.wasm_binary,
-                    binary_hash = excluded.binary_hash,
-                    parameters_schema = excluded.parameters_schema,
-                    source_url = excluded.source_url,
-                    updated_at = ?11
+                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, 'active', ?12, ?12)
                 "#,
             libsql::params![
                 id.to_string(),
                 params.user_id.as_str(),
                 params.name.as_str(),
                 params.version.as_str(),
+                params.wit_version.as_str(),
                 params.description.as_str(),
                 libsql::Value::Blob(params.wasm_binary),
                 libsql::Value::Blob(binary_hash),
@@ -648,12 +663,10 @@ impl WasmToolStore for LibSqlWasmToolStore {
         let mut rows = tx
             .query(
                 r#"
-                SELECT id, user_id, name, version, description, parameters_schema,
+                SELECT id, user_id, name, version, wit_version, description, parameters_schema,
                        source_url, trust_level, status, created_at, updated_at
                 FROM wasm_tools
                 WHERE user_id = ?1 AND name = ?2
-                ORDER BY version DESC
-                LIMIT 1
                 "#,
                 libsql::params![params.user_id.as_str(), params.name.as_str()],
             )
@@ -682,12 +695,10 @@ impl WasmToolStore for LibSqlWasmToolStore {
         let mut rows = conn
             .query(
                 r#"
-                SELECT id, user_id, name, version, description, parameters_schema,
+                SELECT id, user_id, name, version, wit_version, description, parameters_schema,
                        source_url, trust_level, status, created_at, updated_at
                 FROM wasm_tools
                 WHERE user_id = ?1 AND name = ?2 AND status = 'active'
-                ORDER BY version DESC
-                LIMIT 1
                 "#,
                 libsql::params![user_id, name],
             )
@@ -720,12 +731,10 @@ impl WasmToolStore for LibSqlWasmToolStore {
         let mut rows = conn
             .query(
                 r#"
-                SELECT id, user_id, name, version, description, wasm_binary, binary_hash,
+                SELECT id, user_id, name, version, wit_version, description, wasm_binary, binary_hash,
                        parameters_schema, source_url, trust_level, status, created_at, updated_at
                 FROM wasm_tools
                 WHERE user_id = ?1 AND name = ?2 AND status = 'active'
-                ORDER BY version DESC
-                LIMIT 1
                 "#,
                 libsql::params![user_id, name],
             )
@@ -739,10 +748,10 @@ impl WasmToolStore for LibSqlWasmToolStore {
         {
             Some(row) => {
                 let wasm_binary: Vec<u8> = row
-                    .get(5)
+                    .get(6)
                     .map_err(|e| WasmStorageError::Database(e.to_string()))?;
                 let binary_hash: Vec<u8> = row
-                    .get(6)
+                    .get(7)
                     .map_err(|e| WasmStorageError::Database(e.to_string()))?;
 
                 if !verify_binary_integrity(&wasm_binary, &binary_hash) {
@@ -844,21 +853,14 @@ impl WasmToolStore for LibSqlWasmToolStore {
     }
 
     async fn list(&self, user_id: &str) -> Result<Vec<StoredWasmTool>, WasmStorageError> {
-        // SQLite doesn't have DISTINCT ON, so we use a subquery to get latest version per name
         let conn = self.connect().await?;
         let mut rows = conn
             .query(
                 r#"
-                SELECT id, user_id, name, version, description, parameters_schema,
+                SELECT id, user_id, name, version, wit_version, description, parameters_schema,
                        source_url, trust_level, status, created_at, updated_at
                 FROM wasm_tools
                 WHERE user_id = ?1
-                  AND rowid IN (
-                      SELECT MAX(rowid)
-                      FROM wasm_tools
-                      WHERE user_id = ?1
-                      GROUP BY name
-                  )
                 ORDER BY name
                 "#,
                 libsql::params![user_id],
@@ -941,22 +943,22 @@ fn libsql_wasm_parse_ts(s: &str) -> Result<DateTime<Utc>, WasmStorageError> {
 }
 
 /// Parse a tool row with standard column order (no binary columns).
-/// Columns: id(0), user_id(1), name(2), version(3), description(4),
-///          parameters_schema(5), source_url(6), trust_level(7), status(8),
-///          created_at(9), updated_at(10)
+/// Columns: id(0), user_id(1), name(2), version(3), wit_version(4), description(5),
+///          parameters_schema(6), source_url(7), trust_level(8), status(9),
+///          created_at(10), updated_at(11)
 #[cfg(feature = "libsql")]
 fn libsql_row_to_tool(row: &libsql::Row) -> Result<StoredWasmTool, WasmStorageError> {
-    libsql_row_to_tool_at(row, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+    libsql_row_to_tool_at(row, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
 }
 
 /// Parse a tool row when binary columns are present (get_with_binary query).
-/// Columns: id(0), user_id(1), name(2), version(3), description(4),
-///          wasm_binary(5), binary_hash(6),
-///          parameters_schema(7), source_url(8), trust_level(9), status(10),
-///          created_at(11), updated_at(12)
+/// Columns: id(0), user_id(1), name(2), version(3), wit_version(4), description(5),
+///          wasm_binary(6), binary_hash(7),
+///          parameters_schema(8), source_url(9), trust_level(10), status(11),
+///          created_at(12), updated_at(13)
 #[cfg(feature = "libsql")]
 fn libsql_row_to_tool_with_offset(row: &libsql::Row) -> Result<StoredWasmTool, WasmStorageError> {
-    libsql_row_to_tool_at(row, 0, 1, 2, 3, 4, 7, 8, 9, 10, 11, 12)
+    libsql_row_to_tool_at(row, 0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13)
 }
 
 #[cfg(feature = "libsql")]
@@ -967,6 +969,7 @@ fn libsql_row_to_tool_at(
     user_id_idx: i32,
     name_idx: i32,
     version_idx: i32,
+    wit_version_idx: i32,
     description_idx: i32,
     schema_idx: i32,
     source_url_idx: i32,
@@ -1007,6 +1010,9 @@ fn libsql_row_to_tool_at(
         version: row
             .get(version_idx)
             .map_err(|e| WasmStorageError::Database(e.to_string()))?,
+        wit_version: row
+            .get(wit_version_idx)
+            .map_err(|e| WasmStorageError::Database(e.to_string()))?,
         description: row
             .get(description_idx)
             .map_err(|e| WasmStorageError::Database(e.to_string()))?,

src/tools/wasm/wrapper.rs

@@ -589,8 +589,20 @@ impl WasmToolWrapper {
         Self::add_host_functions(&mut linker)?;
 
         // Instantiate using the generated bindings
-        let instance = SandboxedTool::instantiate(&mut store, &component, &linker)
-            .map_err(|e| WasmError::InstantiationFailed(e.to_string()))?;
+        let instance =
+            SandboxedTool::instantiate(&mut store, &component, &linker).map_err(|e| {
+                let msg = e.to_string();
+                if msg.contains("near:agent") || msg.contains("import") {
+                    WasmError::InstantiationFailed(format!(
+                        "{msg}. This usually means the extension was compiled against \
+                         a different WIT version than the host supports. \
+                         Rebuild the extension against the current WIT (host: {}).",
+                        crate::tools::wasm::WIT_TOOL_VERSION
+                    ))
+                } else {
+                    WasmError::InstantiationFailed(msg)
+                }
+            })?;
 
         // Coerce string-encoded values to their schema-declared types.
         // LLMs frequently pass numeric values as strings (e.g. "5" instead of 5).

src/workspace/hygiene.rs

@@ -1,21 +1,31 @@
 //! Memory hygiene: automatic cleanup of stale workspace documents.
 //!
-//! Runs on a configurable cadence and deletes daily log entries older
-//! than the retention period. Identity files (`IDENTITY.md`, `SOUL.md`,
-//! etc.) are never touched.
+//! Runs on a configurable cadence and deletes daily log entries and conversation
+//! documents older than their respective retention periods. Identity files
+//! (`IDENTITY.md`, `SOUL.md`, etc.) are never touched.
+//!
+//! A global [`AtomicBool`] guard prevents concurrent hygiene passes, which
+//! avoids TOCTOU races on the state file and Windows file-locking errors
+//! (OS error 1224) when multiple heartbeat ticks fire before the first
+//! pass completes.
 //!
 //! ```text
 //! ┌─────────────────────────────────────────────┐
 //! │               Hygiene Pass                   │
 //! │                                              │
+//! │  0. Acquire RUNNING guard (skip if held)     │
 //! │  1. Check cadence (skip if ran recently)     │
-//! │  2. List daily/ documents                    │
-//! │  3. Delete those older than retention_days   │
-//! │  4. Log summary                              │
+//! │  2. Save state (claim the cadence window)    │
+//! │  3. List daily/ documents                    │
+//! │  4. Delete those older than daily_retention  │
+//! │  5. List conversations/ documents            │
+//! │  6. Delete those older than conversation_ret │
+//! │  7. Log summary                              │
 //! └─────────────────────────────────────────────┘
 //! ```
 
 use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
@@ -23,13 +33,44 @@ use serde::{Deserialize, Serialize};
 use crate::bootstrap::ironclaw_base_dir;
 use crate::workspace::Workspace;
 
+/// Global guard preventing concurrent hygiene passes.
+static RUNNING: AtomicBool = AtomicBool::new(false);
+
+/// Paths that must never be deleted by hygiene, regardless of age.
+const IDENTITY_PATHS: &[&str] = &[
+    crate::workspace::document::paths::MEMORY,
+    crate::workspace::document::paths::IDENTITY,
+    crate::workspace::document::paths::SOUL,
+    crate::workspace::document::paths::AGENTS,
+    crate::workspace::document::paths::USER,
+    crate::workspace::document::paths::HEARTBEAT,
+    crate::workspace::document::paths::README,
+    crate::workspace::document::paths::TOOLS,
+    crate::workspace::document::paths::BOOTSTRAP,
+];
+
+/// Check if a document path is an identity document that must never be deleted.
+///
+/// Performs case-insensitive comparison to handle case-insensitive filesystems
+/// (Windows, macOS) and prevent accidental deletion of identity docs with
+/// different casing (e.g., memory.md, MEMORY.MD, Memory.md).
+fn is_identity_path(path: &str) -> bool {
+    let file_name = path.rsplit('/').next().unwrap_or(path);
+    let file_name_lower = file_name.to_lowercase();
+    IDENTITY_PATHS
+        .iter()
+        .any(|&p| p.to_lowercase() == file_name_lower)
+}
+
 /// Configuration for workspace hygiene.
 #[derive(Debug, Clone)]
 pub struct HygieneConfig {
     /// Whether hygiene is enabled at all.
     pub enabled: bool,
     /// Documents in `daily/` older than this many days are deleted.
-    pub retention_days: u32,
+    pub daily_retention_days: u32,
+    /// Documents in `conversations/` older than this many days are deleted.
+    pub conversation_retention_days: u32,
     /// Minimum hours between hygiene passes.
     pub cadence_hours: u32,
     /// Directory to store state file (default: `~/.ironclaw`).
@@ -40,7 +81,8 @@ impl Default for HygieneConfig {
     fn default() -> Self {
         Self {
             enabled: true,
-            retention_days: 30,
+            daily_retention_days: 30,
+            conversation_retention_days: 7,
             cadence_hours: 12,
             state_dir: ironclaw_base_dir(),
         }
@@ -58,6 +100,8 @@ struct HygieneState {
 pub struct HygieneReport {
     /// Number of daily log documents deleted.
     pub daily_logs_deleted: u32,
+    /// Number of conversation documents deleted.
+    pub conversation_docs_deleted: u32,
     /// Whether the run was skipped (cadence not yet elapsed).
     pub skipped: bool,
 }
@@ -65,7 +109,7 @@ pub struct HygieneReport {
 impl HygieneReport {
     /// True if any cleanup work was done.
     pub fn had_work(&self) -> bool {
-        self.daily_logs_deleted > 0
+        self.daily_logs_deleted > 0 || self.conversation_docs_deleted > 0
     }
 }
 
@@ -73,6 +117,10 @@ impl HygieneReport {
 ///
 /// This is best-effort: failures are logged but never propagate. The
 /// agent should not crash because cleanup failed.
+///
+/// An [`AtomicBool`] guard ensures only one pass runs at a time, and the
+/// state file is written *before* cleanup so that concurrent callers that
+/// slip past the guard still see an up-to-date cadence timestamp.
 pub async fn run_if_due(workspace: &Workspace, config: &HygieneConfig) -> HygieneReport {
     if !config.enabled {
         return HygieneReport {
@@ -81,6 +129,22 @@ pub async fn run_if_due(workspace: &Workspace, config: &HygieneConfig) -> Hygien
         };
     }
 
+    // Prevent concurrent passes. If another task is already running,
+    // skip immediately.
+    if RUNNING
+        .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+        .is_err()
+    {
+        tracing::debug!("memory hygiene: skipping (another pass is running)");
+        return HygieneReport {
+            skipped: true,
+            ..Default::default()
+        };
+    }
+
+    // Ensure the guard is released when we return.
+    let _guard = RunningGuard;
+
     let state_file = config.state_dir.join("memory_hygiene_state.json");
 
     // Check cadence
@@ -100,34 +164,52 @@ pub async fn run_if_due(workspace: &Workspace, config: &HygieneConfig) -> Hygien
         }
     }
 
+    // Save state *before* cleanup to claim the cadence window and prevent
+    // TOCTOU races where another task reads stale state.
+    save_state(&state_file);
+
     tracing::info!(
-        retention_days = config.retention_days,
+        daily_retention_days = config.daily_retention_days,
+        conversation_retention_days = config.conversation_retention_days,
         "memory hygiene: starting cleanup pass"
     );
 
     let mut report = HygieneReport::default();
 
     // Delete old daily logs
-    match cleanup_daily_logs(workspace, config.retention_days).await {
+    match cleanup_daily_logs(workspace, config.daily_retention_days).await {
         Ok(count) => report.daily_logs_deleted = count,
         Err(e) => tracing::warn!("memory hygiene: failed to clean daily logs: {e}"),
     }
 
+    // Delete old conversation documents
+    match cleanup_conversation_docs(workspace, config.conversation_retention_days).await {
+        Ok(count) => report.conversation_docs_deleted = count,
+        Err(e) => tracing::warn!("memory hygiene: failed to clean conversation docs: {e}"),
+    }
+
     if report.had_work() {
         tracing::info!(
             daily_logs_deleted = report.daily_logs_deleted,
+            conversation_docs_deleted = report.conversation_docs_deleted,
             "memory hygiene: cleanup complete"
         );
     } else {
         tracing::debug!("memory hygiene: nothing to clean");
     }
 
-    // Save state (best-effort)
-    save_state(&state_file);
-
     report
 }
 
+/// RAII guard that clears the [`RUNNING`] flag on drop.
+struct RunningGuard;
+
+impl Drop for RunningGuard {
+    fn drop(&mut self) {
+        RUNNING.store(false, Ordering::SeqCst);
+    }
+}
+
 /// Delete daily log documents older than `retention_days`.
 async fn cleanup_daily_logs(
     workspace: &Workspace,
@@ -142,6 +224,11 @@ async fn cleanup_daily_logs(
             continue;
         }
 
+        // Never delete identity documents
+        if is_identity_path(&entry.path) {
+            continue;
+        }
+
         // Check if the document is old enough to delete
         if let Some(updated_at) = entry.updated_at
             && updated_at < cutoff
@@ -164,6 +251,50 @@ async fn cleanup_daily_logs(
     Ok(deleted)
 }
 
+/// Delete conversation documents older than `retention_days`.
+async fn cleanup_conversation_docs(
+    workspace: &Workspace,
+    retention_days: u32,
+) -> Result<u32, anyhow::Error> {
+    let cutoff = Utc::now() - chrono::Duration::days(i64::from(retention_days));
+    let entries = workspace.list("conversations/").await?;
+
+    let mut deleted = 0u32;
+    for entry in entries {
+        if entry.is_directory {
+            continue;
+        }
+
+        // Never delete identity documents
+        if is_identity_path(&entry.path) {
+            continue;
+        }
+
+        // Check if the document is old enough to delete
+        if let Some(updated_at) = entry.updated_at
+            && updated_at < cutoff
+        {
+            let path = if entry.path.starts_with("conversations/") {
+                entry.path.clone()
+            } else {
+                format!("conversations/{}", entry.path)
+            };
+
+            if let Err(e) = workspace.delete(&path).await {
+                tracing::warn!(
+                    path,
+                    "memory hygiene: failed to delete conversation doc: {e}"
+                );
+            } else {
+                tracing::debug!(path, "memory hygiene: deleted old conversation doc");
+                deleted += 1;
+            }
+        }
+    }
+
+    Ok(deleted)
+}
+
 fn state_path_dir(state_file: &std::path::Path) -> Option<&std::path::Path> {
     state_file.parent()
 }
@@ -173,29 +304,53 @@ fn load_state(path: &std::path::Path) -> Option<HygieneState> {
     serde_json::from_str(&data).ok()
 }
 
+/// Save state using atomic write (write to temp file, then rename).
+///
+/// This avoids partial writes and Windows file-locking errors (OS error
+/// 1224) when multiple processes try to write the same file.
 fn save_state(path: &std::path::Path) {
     let state = HygieneState {
         last_run: Utc::now(),
     };
-    if let Some(dir) = state_path_dir(path) {
-        std::fs::create_dir_all(dir).ok();
-    }
-    if let Ok(json) = serde_json::to_string_pretty(&state)
-        && let Err(e) = std::fs::write(path, json)
+    if let Some(dir) = state_path_dir(path)
+        && let Err(e) = std::fs::create_dir_all(dir)
     {
-        tracing::warn!("memory hygiene: failed to save state: {e}");
+        tracing::warn!("memory hygiene: failed to create state dir: {e}");
+        return;
+    }
+    let Ok(json) = serde_json::to_string_pretty(&state) else {
+        return;
+    };
+
+    // Write to a temp file in the same directory, then atomically rename.
+    let tmp_path = path.with_extension("json.tmp");
+    if let Err(e) = std::fs::write(&tmp_path, &json) {
+        tracing::warn!("memory hygiene: failed to write temp state: {e}");
+        return;
+    }
+    if let Err(e) = std::fs::rename(&tmp_path, path) {
+        tracing::warn!("memory hygiene: failed to rename state file: {e}");
+        // Clean up temp file on rename failure
+        let _ = std::fs::remove_file(&tmp_path);
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::sync::Mutex;
+
     use crate::workspace::hygiene::*;
 
+    /// Serialize tests that touch the global `RUNNING` AtomicBool so they
+    /// don't interfere with each other when `cargo test` runs in parallel.
+    static RUNNING_TESTS: Mutex<()> = Mutex::new(());
+
     #[test]
     fn default_config_is_reasonable() {
         let cfg = HygieneConfig::default();
         assert!(cfg.enabled);
-        assert_eq!(cfg.retention_days, 30);
+        assert_eq!(cfg.daily_retention_days, 30);
+        assert_eq!(cfg.conversation_retention_days, 7);
         assert_eq!(cfg.cadence_hours, 12);
     }
 
@@ -210,11 +365,83 @@ mod tests {
     fn report_had_work_when_deleted() {
         let report = HygieneReport {
             daily_logs_deleted: 3,
+            conversation_docs_deleted: 0,
             skipped: false,
         };
         assert!(report.had_work());
     }
 
+    #[test]
+    fn report_had_work_when_conversation_deleted() {
+        let report = HygieneReport {
+            daily_logs_deleted: 0,
+            conversation_docs_deleted: 2,
+            skipped: false,
+        };
+        assert!(report.had_work());
+    }
+
+    #[test]
+    fn is_identity_path_excludes_sacred_docs() {
+        for name in [
+            "MEMORY.md",
+            "IDENTITY.md",
+            "SOUL.md",
+            "AGENTS.md",
+            "USER.md",
+            "HEARTBEAT.md",
+            "README.md",
+            "TOOLS.md",
+            "BOOTSTRAP.md",
+        ] {
+            assert!(is_identity_path(name), "{name} should be excluded");
+            assert!(
+                is_identity_path(&format!("conversations/{name}")),
+                "conversations/{name} should be excluded via path"
+            );
+        }
+    }
+
+    #[test]
+    fn is_identity_path_case_insensitive() {
+        // Verify case-insensitive matching for case-insensitive filesystems
+        assert!(
+            is_identity_path("memory.md"),
+            "lowercase memory.md should be excluded"
+        );
+        assert!(
+            is_identity_path("Memory.md"),
+            "mixed case Memory.md should be excluded"
+        );
+        assert!(
+            is_identity_path("MEMORY.MD"),
+            "uppercase MEMORY.MD should be excluded"
+        );
+        assert!(
+            is_identity_path("identity.md"),
+            "lowercase identity.md should be excluded"
+        );
+        assert!(
+            is_identity_path("conversations/soul.md"),
+            "conversations/soul.md should be excluded"
+        );
+        assert!(
+            is_identity_path("conversations/SOUL.MD"),
+            "conversations/SOUL.MD should be excluded"
+        );
+    }
+
+    #[test]
+    fn is_identity_path_allows_normal_docs() {
+        for path in [
+            "daily/2024-01-01.md",
+            "conversations/chat-abc.md",
+            "notes.md",
+        ] {
+            assert!(!is_identity_path(path), "{path} should not be excluded");
+        }
+    }
+
     #[test]
     fn load_state_returns_none_for_missing_file() {
         assert!(load_state(std::path::Path::new("/tmp/nonexistent_hygiene.json")).is_none());
@@ -241,4 +468,222 @@ mod tests {
         save_state(&path);
         assert!(path.exists());
     }
+
+    #[test]
+    fn save_state_is_atomic_no_tmp_left_behind() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("state.json");
+        let tmp = dir.path().join("state.json.tmp");
+
+        save_state(&path);
+        assert!(path.exists(), "state file should exist");
+        assert!(!tmp.exists(), "temp file should be cleaned up after rename");
+
+        // Verify the content is valid JSON
+        let state = load_state(&path).expect("saved state should be loadable");
+        let elapsed = Utc::now().signed_duration_since(state.last_run);
+        assert!(elapsed.num_seconds() < 2);
+    }
+
+    /// Regression test for issue #495: concurrent hygiene passes should be
+    /// serialized by the AtomicBool guard.
+    #[test]
+    fn running_guard_prevents_reentry() {
+        let _lock = RUNNING_TESTS.lock().unwrap();
+
+        // Reset the global flag to ensure a clean state
+        RUNNING.store(false, Ordering::SeqCst);
+
+        // Simulate acquiring the guard
+        assert!(
+            RUNNING
+                .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+                .is_ok(),
+            "first acquisition should succeed"
+        );
+
+        // Second acquisition should fail
+        assert!(
+            RUNNING
+                .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+                .is_err(),
+            "second acquisition should fail while first is held"
+        );
+
+        // Release
+        RUNNING.store(false, Ordering::SeqCst);
+
+        // Now it should succeed again
+        assert!(
+            RUNNING
+                .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+                .is_ok(),
+            "acquisition should succeed after release"
+        );
+        RUNNING.store(false, Ordering::SeqCst);
+    }
+
+    // ================================================================
+    // Async integration tests (require libsql backend)
+    // ================================================================
+
+    #[cfg(feature = "libsql")]
+    mod async_tests {
+        use super::*;
+        use crate::db::Database;
+        use std::sync::Arc;
+
+        /// Helper to create a test database with migrations.
+        async fn create_test_db() -> (Arc<dyn crate::db::Database>, tempfile::TempDir) {
+            use crate::db::libsql::LibSqlBackend;
+
+            let temp_dir = tempfile::tempdir().expect("tempdir");
+            let db_path = temp_dir.path().join("test_hygiene.db");
+            let backend = LibSqlBackend::new_local(&db_path)
+                .await
+                .expect("LibSqlBackend::new_local");
+            backend.run_migrations().await.expect("run_migrations");
+            let db: Arc<dyn Database> = Arc::new(backend);
+            (db, temp_dir)
+        }
+
+        /// Helper to create a workspace from a test database.
+        fn create_workspace(db: &Arc<dyn Database>) -> Arc<Workspace> {
+            Arc::new(Workspace::new_with_db("default", db.clone()))
+        }
+
+        #[tokio::test]
+        async fn cleanup_daily_logs_preserves_identity_documents() {
+            let (db, _tmp) = create_test_db().await;
+            let ws = create_workspace(&db);
+
+            // Write several regular documents (non-identity)
+            ws.write("daily/2024-01-15.md", "Old log")
+                .await
+                .expect("write log 1");
+            ws.write("daily/2024-01-20.md", "Another log")
+                .await
+                .expect("write log 2");
+
+            // Write an identity document
+            ws.write("MEMORY.md", "Long-term curated memory")
+                .await
+                .expect("write identity");
+
+            // List before cleanup
+            let before = ws.list("daily/").await.expect("list before");
+            let daily_count_before = before.iter().filter(|e| !e.is_directory).count();
+            assert!(daily_count_before >= 2, "should have at least 2 daily logs");
+
+            // Run cleanup with 0-day retention (deletes everything old)
+            // This tests that even with aggressive cleanup, identity docs survive
+            let deleted = cleanup_daily_logs(&ws, 0)
+                .await
+                .expect("cleanup_daily_logs");
+
+            // Should have deleted some documents (the daily logs)
+            assert!(deleted > 0, "should have deleted old daily documents");
+
+            // Verify identity doc still exists
+            let identity = db
+                .get_document_by_path("default", None, "MEMORY.md")
+                .await
+                .expect("get identity doc");
+            assert_eq!(identity.path, "MEMORY.md");
+            assert_eq!(identity.content, "Long-term curated memory");
+        }
+
+        #[tokio::test]
+        async fn cleanup_conversation_docs_handles_empty_directory() {
+            let (db, _tmp) = create_test_db().await;
+            let ws = create_workspace(&db);
+
+            // Run cleanup on an empty directory (conversations/ doesn't exist)
+            let deleted = cleanup_conversation_docs(&ws, 7)
+                .await
+                .expect("cleanup_conversation_docs");
+
+            // Should delete 0 (nothing to delete)
+            assert_eq!(deleted, 0, "should delete 0 from empty directory");
+        }
+
+        #[tokio::test]
+        async fn cleanup_respects_cadence_prevents_concurrent_runs() {
+            let (db, _tmp) = create_test_db().await;
+            let ws = create_workspace(&db);
+
+            let config = HygieneConfig {
+                enabled: true,
+                daily_retention_days: 30,
+                conversation_retention_days: 7,
+                cadence_hours: 12,
+                state_dir: _tmp.path().to_path_buf(),
+            };
+
+            // First run should succeed
+            let report1 = run_if_due(&ws, &config).await;
+            assert!(!report1.skipped, "first run should not be skipped");
+
+            // Second run immediately should be skipped (cadence not elapsed)
+            let report2 = run_if_due(&ws, &config).await;
+            assert!(report2.skipped, "second run should be skipped by cadence");
+
+            // Report structure should be correct
+            assert_eq!(
+                report1.daily_logs_deleted + report1.conversation_docs_deleted,
+                0,
+                "first run should have clean counts"
+            );
+        }
+
+        #[tokio::test]
+        async fn cleanup_reports_deletion_counts_correctly() {
+            let (db, _tmp) = create_test_db().await;
+            let ws = create_workspace(&db);
+
+            // Write some documents
+            ws.write("daily/log1.md", "content 1")
+                .await
+                .expect("write doc 1");
+            ws.write("daily/log2.md", "content 2")
+                .await
+                .expect("write doc 2");
+            ws.write("conversations/chat1.md", "content 3")
+                .await
+                .expect("write doc 3");
+
+            // Run with 0-day retention to delete everything non-identity
+            let deleted_daily = cleanup_daily_logs(&ws, 0).await.expect("cleanup daily");
+            let deleted_conv = cleanup_conversation_docs(&ws, 0)
+                .await
+                .expect("cleanup conversations");
+
+            // Both should report deletions
+            assert!(deleted_daily > 0, "should report deleted daily logs");
+            assert_eq!(deleted_conv, 1, "should report 1 deleted conversation doc");
+
+            // Create a HygieneReport and verify aggregation works
+            let report = HygieneReport {
+                daily_logs_deleted: deleted_daily,
+                conversation_docs_deleted: deleted_conv,
+                skipped: false,
+            };
+
+            // Verify HygieneReport structure
+            assert!(!report.skipped, "should not be skipped");
+            assert!(report.had_work(), "report should indicate work was done");
+            assert!(
+                report.daily_logs_deleted > 0 || report.conversation_docs_deleted > 0,
+                "report should have at least one deletion count > 0"
+            );
+
+            // Verify had_work() correctly combines both counts
+            let no_work = HygieneReport {
+                daily_logs_deleted: 0,
+                conversation_docs_deleted: 0,
+                skipped: false,
+            };
+            assert!(!no_work.had_work(), "empty report should indicate no work");
+        }
+    }
 }

tests/e2e/README.md

@@ -52,6 +52,10 @@ Then Playwright drives a headless Chromium browser against the gateway, making D
 | `test_connection.py` | Auth, tab navigation, connection status |
 | `test_chat.py` | Send message, SSE streaming, response rendering |
 | `test_skills.py` | ClawHub search, skill install/remove |
+| `test_tool_approval.py` | Tool approval overlay (approve, deny, always, params toggle) |
+| `test_sse_reconnect.py` | SSE reconnection handling |
+| `test_html_injection.py` | HTML injection security |
+| `test_extensions.py` | Extensions tab: install, remove, configure, OAuth, auth card, activate |
 
 ## Adding new scenarios
 
@@ -59,3 +63,106 @@ Then Playwright drives a headless Chromium browser against the gateway, making D
 2. Use the `page` fixture for a fresh browser page
 3. Use selectors from `helpers.py` (update `SEL` dict if new elements are needed)
 4. Keep tests deterministic -- use the mock LLM, not real providers
+
+## Mocking API responses with `page.route()`
+
+For tabs that depend on external data (extensions, jobs, memory, routines), use
+Playwright's `page.route()` to intercept the browser's HTTP requests to the
+ironclaw gateway and return deterministic fixture JSON. This avoids needing
+real installed binaries, live external services, or complex database setup.
+
+### Basic pattern
+
+```python
+import json
+
+async def test_something(page):
+    # 1. Set up route intercepts BEFORE navigation triggers the fetch
+    # Always use async def handlers — route.fulfill() is a coroutine and must be awaited.
+    async def handle_tools(route):
+        await route.fulfill(
+            status=200,
+            content_type="application/json",
+            body=json.dumps({"tools": [{"name": "echo", "description": "Echo"}]}),
+        )
+
+    await page.route("**/api/extensions/tools", handle_tools)
+
+    # 2. Navigate / interact to trigger the fetch
+    await page.locator('.tab-bar button[data-tab="extensions"]').click()
+
+    # 3. Assert on the rendered DOM
+    rows = page.locator("#tools-tbody tr")
+    assert await rows.count() == 1
+```
+
+### Matching only the exact path
+
+`**/api/extensions` matches `http://host/api/extensions` but NOT sub-paths
+like `http://host/api/extensions/install`. For the bare list endpoint, add
+a check inside the handler:
+
+```python
+async def handle_ext_list(route):
+    path = route.request.url.split("?")[0]
+    if path.endswith("/api/extensions"):
+        await route.fulfill(json={"extensions": []})
+    else:
+        await route.continue_()   # Let sub-paths through to the real server
+
+await page.route("**/api/extensions*", handle_ext_list)
+```
+
+### Mocking method-specific behaviour (GET vs POST)
+
+```python
+async def handle_setup(route):
+    if route.request.method == "GET":
+        await route.fulfill(json={"secrets": [...]})
+    else:  # POST
+        await route.fulfill(json={"success": True})
+
+await page.route("**/api/extensions/my-ext/setup", handle_setup)
+```
+
+### Counting calls (for reload tests)
+
+```python
+calls = []
+
+async def counting_handler(route):
+    calls.append(1)
+    await route.fulfill(json={"extensions": []})
+
+await page.route("**/api/extensions", counting_handler)
+# ... interact ...
+assert len(calls) == 2   # called twice (initial + after some action)
+```
+
+### Applying the pattern to other tabs
+
+| Tab | Key API endpoints to mock |
+|-----|--------------------------|
+| **Jobs** | `/api/jobs`, `/api/jobs/{id}`, `/api/jobs/{id}/events` |
+| **Memory** | `/api/memory/search`, `/api/memory/tree`, `/api/memory/read` |
+| **Routines** | `/api/routines`, `/api/routines/{id}/runs` |
+
+### Injecting state directly via `page.evaluate()`
+
+For purely client-side UI (components rendered entirely in JS without API calls),
+call the JavaScript function directly to skip the network layer entirely:
+
+```python
+# Show an approval card without needing a real tool execution
+await page.evaluate("""
+    showApproval({
+        request_id: 'test-001',
+        thread_id: currentThreadId,
+        tool_name: 'shell',
+        description: 'Run something',
+    })
+""")
+```
+
+This is the pattern used in `test_tool_approval.py` and parts of
+`test_extensions.py` (auth card, configure modal).

tests/e2e/conftest.py

@@ -99,11 +99,12 @@ async def ironclaw_server(ironclaw_binary, mock_llm_server):
         "ONBOARD_COMPLETED": "true",
     }
     # Forward LLVM coverage instrumentation env vars when present
-    # (allows cargo-llvm-cov to collect profraw data from E2E runs)
-    for key in ("LLVM_PROFILE_FILE", "CARGO_LLVM_COV", "CARGO_LLVM_COV_SHOW_ENV",
-                "CARGO_LLVM_COV_TARGET_DIR"):
-        val = os.environ.get(key)
-        if val is not None:
+    # (allows cargo-llvm-cov to collect profraw data from E2E runs).
+    # Use prefix matching to stay resilient to cargo-llvm-cov changes.
+    COV_ENV_PREFIXES = ("CARGO_LLVM_COV", "LLVM_")
+    COV_ENV_EXTRAS = ("CARGO_ENCODED_RUSTFLAGS", "CARGO_INCREMENTAL")
+    for key, val in os.environ.items():
+        if key.startswith(COV_ENV_PREFIXES) or key in COV_ENV_EXTRAS:
             env[key] = val
     proc = await asyncio.create_subprocess_exec(
         ironclaw_binary, "--no-onboard",